diff options
author | Ryan Dahl <ry@tinyclouds.org> | 2011-01-02 00:17:42 +0300 |
---|---|---|
committer | Ryan Dahl <ry@tinyclouds.org> | 2011-01-02 00:41:04 +0300 |
commit | 40f29dd48a52699c82af8b844a2e6f2832f23a6a (patch) | |
tree | 489a1c7a74a04ccd2afb562f3ff57fcc048923e0 /src | |
parent | 5b81897cf6afe371f540c8a5348d54b87e05d39e (diff) |
Lint node_script.cc
Diffstat (limited to 'src')
-rw-r--r-- | src/node_script.cc | 277 | ||||
-rw-r--r-- | src/node_script.h | 48 |
2 files changed, 187 insertions, 138 deletions
diff --git a/src/node_script.cc b/src/node_script.cc index 5c4223d10e4..81d10958184 100644 --- a/src/node_script.cc +++ b/src/node_script.cc @@ -2,109 +2,198 @@ #include <node_script.h> #include <assert.h> +namespace node { +using v8::Context; +using v8::Script; +using v8::Value; +using v8::Handle; +using v8::HandleScope; +using v8::Object; +using v8::Arguments; +using v8::ThrowException; +using v8::TryCatch; +using v8::String; +using v8::Exception; +using v8::Local; +using v8::Array; +using v8::Persistent; +using v8::Integer; +using v8::FunctionTemplate; -using namespace v8; -using namespace node; +class WrappedContext : ObjectWrap { + public: + static void Initialize(Handle<Object> target); + static Handle<Value> New(const Arguments& args); -Persistent<FunctionTemplate> node::Context::constructor_template; + Persistent<Context> GetV8Context(); + static Local<Object> NewInstance(); + protected: -void node::Context::Initialize (Handle<Object> target) { + static Persistent<FunctionTemplate> constructor_template; + + WrappedContext(); + ~WrappedContext(); + + Persistent<Context> context_; +}; + + +Persistent<FunctionTemplate> WrappedContext::constructor_template; + + +class WrappedScript : ObjectWrap { + public: + static void Initialize(Handle<Object> target); + + enum EvalInputFlags { compileCode, unwrapExternal }; + enum EvalContextFlags { thisContext, newContext, userContext }; + enum EvalOutputFlags { returnResult, wrapExternal }; + + template <EvalInputFlags input_flag, + EvalContextFlags context_flag, + EvalOutputFlags output_flag> + static Handle<Value> EvalMachine(const Arguments& args); + + protected: + static Persistent<FunctionTemplate> constructor_template; + + WrappedScript() : ObjectWrap() {} + ~WrappedScript(); + + static Handle<Value> New(const Arguments& args); + static Handle<Value> CreateContext(const Arguments& arg); + static Handle<Value> RunInContext(const Arguments& args); + static Handle<Value> RunInThisContext(const Arguments& args); + static Handle<Value> RunInNewContext(const Arguments& args); + static Handle<Value> CompileRunInContext(const Arguments& args); + static Handle<Value> CompileRunInThisContext(const Arguments& args); + static Handle<Value> CompileRunInNewContext(const Arguments& args); + + Persistent<Script> script_; +}; + + +void WrappedContext::Initialize(Handle<Object> target) { HandleScope scope; - Local<FunctionTemplate> t = FunctionTemplate::New(node::Context::New); + Local<FunctionTemplate> t = FunctionTemplate::New(WrappedContext::New); constructor_template = Persistent<FunctionTemplate>::New(t); constructor_template->InstanceTemplate()->SetInternalFieldCount(1); constructor_template->SetClassName(String::NewSymbol("Context")); - target->Set(String::NewSymbol("Context"), constructor_template->GetFunction()); + target->Set(String::NewSymbol("Context"), + constructor_template->GetFunction()); } -Handle<Value> node::Context::New (const Arguments& args) { +Handle<Value> WrappedContext::New(const Arguments& args) { HandleScope scope; - node::Context *t = new node::Context(); + WrappedContext *t = new WrappedContext(); t->Wrap(args.This()); return args.This(); } -node::Context::Context() : ObjectWrap() { - context_ = v8::Context::New(); +WrappedContext::WrappedContext() : ObjectWrap() { + context_ = Context::New(); } -node::Context::~Context() { +WrappedContext::~WrappedContext() { context_.Dispose(); } -Local<Object> node::Context::NewInstance() { +Local<Object> WrappedContext::NewInstance() { Local<Object> context = constructor_template->GetFunction()->NewInstance(); return context; } -v8::Persistent<v8::Context> node::Context::GetV8Context() { - return context_; +Persistent<Context> WrappedContext::GetV8Context() { + return context_; } -Persistent<FunctionTemplate> node::Script::constructor_template; +Persistent<FunctionTemplate> WrappedScript::constructor_template; -void node::Script::Initialize (Handle<Object> target) { +void WrappedScript::Initialize(Handle<Object> target) { HandleScope scope; - Local<FunctionTemplate> t = FunctionTemplate::New(node::Script::New); + Local<FunctionTemplate> t = FunctionTemplate::New(WrappedScript::New); constructor_template = Persistent<FunctionTemplate>::New(t); constructor_template->InstanceTemplate()->SetInternalFieldCount(1); constructor_template->SetClassName(String::NewSymbol("Script")); - NODE_SET_PROTOTYPE_METHOD(constructor_template, "createContext", node::Script::CreateContext); - NODE_SET_PROTOTYPE_METHOD(constructor_template, "runInContext", node::Script::RunInContext); - NODE_SET_PROTOTYPE_METHOD(constructor_template, "runInThisContext", node::Script::RunInThisContext); - NODE_SET_PROTOTYPE_METHOD(constructor_template, "runInNewContext", node::Script::RunInNewContext); - NODE_SET_METHOD(constructor_template, "createContext", node::Script::CreateContext); - NODE_SET_METHOD(constructor_template, "runInContext", node::Script::CompileRunInContext); - NODE_SET_METHOD(constructor_template, "runInThisContext", node::Script::CompileRunInThisContext); - NODE_SET_METHOD(constructor_template, "runInNewContext", node::Script::CompileRunInNewContext); + NODE_SET_PROTOTYPE_METHOD(constructor_template, + "createContext", + WrappedScript::CreateContext); - target->Set(String::NewSymbol("Script"), constructor_template->GetFunction()); + NODE_SET_PROTOTYPE_METHOD(constructor_template, + "runInContext", + WrappedScript::RunInContext); + + NODE_SET_PROTOTYPE_METHOD(constructor_template, + "runInThisContext", + WrappedScript::RunInThisContext); + + NODE_SET_PROTOTYPE_METHOD(constructor_template, + "runInNewContext", + WrappedScript::RunInNewContext); + + NODE_SET_METHOD(constructor_template, + "createContext", + WrappedScript::CreateContext); + + NODE_SET_METHOD(constructor_template, + "runInContext", + WrappedScript::CompileRunInContext); + + NODE_SET_METHOD(constructor_template, + "runInThisContext", + WrappedScript::CompileRunInThisContext); + + NODE_SET_METHOD(constructor_template, + "runInNewContext", + WrappedScript::CompileRunInNewContext); + + target->Set(String::NewSymbol("Script"), + constructor_template->GetFunction()); } -Handle<Value> node::Script::New (const Arguments& args) { +Handle<Value> WrappedScript::New(const Arguments& args) { if (!args.IsConstructCall()) { return FromConstructorTemplate(constructor_template, args); } HandleScope scope; - node::Script *t = new node::Script(); + WrappedScript *t = new WrappedScript(); t->Wrap(args.Holder()); return - node::Script::EvalMachine<compileCode, thisContext, wrapExternal>(args); + WrappedScript::EvalMachine<compileCode, thisContext, wrapExternal>(args); } -node::Script::~Script() { +WrappedScript::~WrappedScript() { script_.Dispose(); } -Handle<Value> node::Script::CreateContext (const Arguments& args) { +Handle<Value> WrappedScript::CreateContext(const Arguments& args) { HandleScope scope; - Local<v8::Object> context = node::Context::NewInstance(); + Local<Object> context = WrappedContext::NewInstance(); if (args.Length() > 0) { - Local<Object> sandbox = args[0]->ToObject(); Local<Array> keys = sandbox->GetPropertyNames(); @@ -120,93 +209,94 @@ Handle<Value> node::Script::CreateContext (const Arguments& args) { } -Handle<Value> node::Script::RunInContext (const Arguments& args) { +Handle<Value> WrappedScript::RunInContext(const Arguments& args) { return - node::Script::EvalMachine<unwrapExternal, userContext, returnResult>(args); + WrappedScript::EvalMachine<unwrapExternal, userContext, returnResult>(args); } -Handle<Value> node::Script::RunInThisContext (const Arguments& args) { +Handle<Value> WrappedScript::RunInThisContext(const Arguments& args) { return - node::Script::EvalMachine<unwrapExternal, thisContext, returnResult>(args); + WrappedScript::EvalMachine<unwrapExternal, thisContext, returnResult>(args); } -Handle<Value> node::Script::RunInNewContext(const Arguments& args) { +Handle<Value> WrappedScript::RunInNewContext(const Arguments& args) { return - node::Script::EvalMachine<unwrapExternal, newContext, returnResult>(args); + WrappedScript::EvalMachine<unwrapExternal, newContext, returnResult>(args); } -Handle<Value> node::Script::CompileRunInContext (const Arguments& args) { +Handle<Value> WrappedScript::CompileRunInContext(const Arguments& args) { return - node::Script::EvalMachine<compileCode, userContext, returnResult>(args); + WrappedScript::EvalMachine<compileCode, userContext, returnResult>(args); } -Handle<Value> node::Script::CompileRunInThisContext (const Arguments& args) { +Handle<Value> WrappedScript::CompileRunInThisContext(const Arguments& args) { return - node::Script::EvalMachine<compileCode, thisContext, returnResult>(args); + WrappedScript::EvalMachine<compileCode, thisContext, returnResult>(args); } -Handle<Value> node::Script::CompileRunInNewContext(const Arguments& args) { +Handle<Value> WrappedScript::CompileRunInNewContext(const Arguments& args) { return - node::Script::EvalMachine<compileCode, newContext, returnResult>(args); + WrappedScript::EvalMachine<compileCode, newContext, returnResult>(args); } -template <node::Script::EvalInputFlags iFlag, - node::Script::EvalContextFlags cFlag, - node::Script::EvalOutputFlags oFlag> - Handle<Value> node::Script::EvalMachine(const Arguments& args) { - +template <WrappedScript::EvalInputFlags input_flag, + WrappedScript::EvalContextFlags context_flag, + WrappedScript::EvalOutputFlags output_flag> +Handle<Value> WrappedScript::EvalMachine(const Arguments& args) { HandleScope scope; - if (iFlag == compileCode && args.Length() < 1) { + if (input_flag == compileCode && args.Length() < 1) { return ThrowException(Exception::TypeError( String::New("needs at least 'code' argument."))); } - const int sbIndex = iFlag == compileCode ? 1 : 0; - if (cFlag == userContext && args.Length() < (sbIndex + 1)) { + const int sandbox_index = input_flag == compileCode ? 1 : 0; + if (context_flag == userContext && args.Length() < (sandbox_index + 1)) { return ThrowException(Exception::TypeError( String::New("needs a 'context' argument."))); } Local<String> code; - if (iFlag == compileCode) code = args[0]->ToString(); + if (input_flag == compileCode) code = args[0]->ToString(); Local<Object> sandbox; - if (cFlag == newContext) { - sandbox = args[sbIndex]->IsObject() ? args[sbIndex]->ToObject() : Object::New(); - } else if (cFlag == userContext) { - sandbox = args[sbIndex]->ToObject(); + if (context_flag == newContext) { + sandbox = args[sandbox_index]->IsObject() ? args[sandbox_index]->ToObject() + : Object::New(); + } else if (context_flag == userContext) { + sandbox = args[sandbox_index]->ToObject(); } - const int fnIndex = sbIndex + (cFlag == newContext ? 1 : 0); - Local<String> filename = args.Length() > fnIndex - ? args[fnIndex]->ToString() + const int filename_index = sandbox_index + + (context_flag == newContext ? 1 : 0); + Local<String> filename = args.Length() > filename_index + ? args[filename_index]->ToString() : String::New("evalmachine.<anonymous>"); - Persistent<v8::Context> context; + Persistent<Context> context; Local<Array> keys; unsigned int i; - if (cFlag == newContext) { + if (context_flag == newContext) { // Create the new context - context = v8::Context::New(); + context = Context::New(); - } else if (cFlag == userContext) { + } else if (context_flag == userContext) { // Use the passed in context - Local<Object> contextArg = args[sbIndex]->ToObject(); - node::Context *nContext = ObjectWrap::Unwrap<node::Context>(sandbox); + Local<Object> contextArg = args[sandbox_index]->ToObject(); + WrappedContext *nContext = ObjectWrap::Unwrap<WrappedContext>(sandbox); context = nContext->GetV8Context(); } // New and user context share code. DRY it up. - if (cFlag == userContext || cFlag == newContext) { + if (context_flag == userContext || context_flag == newContext) { // Enter the context context->Enter(); @@ -226,13 +316,13 @@ template <node::Script::EvalInputFlags iFlag, TryCatch try_catch; Handle<Value> result; - Handle<v8::Script> script; + Handle<Script> script; - if (iFlag == compileCode) { - // well, here node::Script::New would suffice in all cases, but maybe + if (input_flag == compileCode) { + // well, here WrappedScript::New would suffice in all cases, but maybe // Compile has a little better performance where possible - script = oFlag == returnResult ? v8::Script::Compile(code, filename) - : v8::Script::New(code, filename); + script = output_flag == returnResult ? Script::Compile(code, filename) + : Script::New(code, filename); if (script.IsEmpty()) { // FIXME UGLY HACK TO DISPLAY SYNTAX ERRORS. DisplayExceptionLine(try_catch); @@ -241,33 +331,34 @@ template <node::Script::EvalInputFlags iFlag, return try_catch.ReThrow(); } } else { - node::Script *nScript = ObjectWrap::Unwrap<node::Script>(args.Holder()); - if (!nScript) { + WrappedScript *n_script = ObjectWrap::Unwrap<WrappedScript>(args.Holder()); + if (!n_script) { return ThrowException(Exception::Error( - String::New("Must be called as a method of Script."))); - } else if (nScript->script_.IsEmpty()) { + String::New("Must be called as a method of WrappedScript."))); + } else if (n_script->script_.IsEmpty()) { return ThrowException(Exception::Error( - String::New("'this' must be a result of previous new Script(code) call."))); + String::New("'this' must be a result of previous " + "new WrappedScript(code) call."))); } - script = nScript->script_; + script = n_script->script_; } - if (oFlag == returnResult) { + if (output_flag == returnResult) { result = script->Run(); if (result.IsEmpty()) return try_catch.ReThrow(); } else { - node::Script *nScript = ObjectWrap::Unwrap<node::Script>(args.Holder()); - if (!nScript) { + WrappedScript *n_script = ObjectWrap::Unwrap<WrappedScript>(args.Holder()); + if (!n_script) { return ThrowException(Exception::Error( - String::New("Must be called as a method of Script."))); + String::New("Must be called as a method of WrappedScript."))); } - nScript->script_ = Persistent<v8::Script>::New(script); + n_script->script_ = Persistent<Script>::New(script); result = args.This(); } - if (cFlag == userContext || cFlag == newContext) { + if (context_flag == userContext || context_flag == newContext) { // success! copy changes back onto the sandbox object. keys = context->Global()->GetPropertyNames(); for (i = 0; i < keys->Length(); i++) { @@ -278,12 +369,12 @@ template <node::Script::EvalInputFlags iFlag, } } - if (cFlag == newContext) { + if (context_flag == newContext) { // Clean up, clean up, everybody everywhere! context->DetachGlobal(); context->Exit(); context.Dispose(); - } else if (cFlag == userContext) { + } else if (context_flag == userContext) { // Exit the passed in context. context->Exit(); } @@ -291,11 +382,17 @@ template <node::Script::EvalInputFlags iFlag, return result == args.This() ? result : scope.Close(result); } -void node::InitEvals(Handle<Object> target) { + +void InitEvals(Handle<Object> target) { HandleScope scope; - node::Context::Initialize(target); - node::Script::Initialize(target); + WrappedContext::Initialize(target); + WrappedScript::Initialize(target); } + +} // namespace node + + NODE_MODULE(node_evals, node::InitEvals); + diff --git a/src/node_script.h b/src/node_script.h index bd300459f51..364bd18ca8a 100644 --- a/src/node_script.h +++ b/src/node_script.h @@ -8,54 +8,6 @@ namespace node { -class Context : ObjectWrap { - public: - static void Initialize (v8::Handle<v8::Object> target); - static v8::Handle<v8::Value> New (const v8::Arguments& args); - - v8::Persistent<v8::Context> GetV8Context(); - static v8::Local<v8::Object> NewInstance(); - - protected: - - static v8::Persistent<v8::FunctionTemplate> constructor_template; - - Context (); - ~Context(); - - v8::Persistent<v8::Context> context_; -}; - - -class Script : ObjectWrap { - public: - static void Initialize (v8::Handle<v8::Object> target); - - enum EvalInputFlags { compileCode, unwrapExternal }; - enum EvalContextFlags { thisContext, newContext, userContext }; - enum EvalOutputFlags { returnResult, wrapExternal }; - - template <EvalInputFlags iFlag, EvalContextFlags cFlag, EvalOutputFlags oFlag> - static v8::Handle<v8::Value> EvalMachine(const v8::Arguments& args); - - protected: - static v8::Persistent<v8::FunctionTemplate> constructor_template; - - Script () : ObjectWrap () {} - ~Script(); - - static v8::Handle<v8::Value> New (const v8::Arguments& args); - static v8::Handle<v8::Value> CreateContext (const v8::Arguments& arg); - static v8::Handle<v8::Value> RunInContext (const v8::Arguments& args); - static v8::Handle<v8::Value> RunInThisContext (const v8::Arguments& args); - static v8::Handle<v8::Value> RunInNewContext (const v8::Arguments& args); - static v8::Handle<v8::Value> CompileRunInContext (const v8::Arguments& args); - static v8::Handle<v8::Value> CompileRunInThisContext (const v8::Arguments& args); - static v8::Handle<v8::Value> CompileRunInNewContext (const v8::Arguments& args); - - v8::Persistent<v8::Script> script_; -}; - void InitEvals(v8::Handle<v8::Object> target); |