Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

Lint node_script.cc

  • Loading branch information...
commit 40f29dd48a52699c82af8b844a2e6f2832f23a6a 1 parent 5b81897
@ry ry authored
Showing with 187 additions and 138 deletions.
  1. +187 −90 src/node_script.cc
  2. +0 −48 src/node_script.h
View
277 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();

contextArg is never used...

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
+ 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.")));
@herby
herby added a note

This refers to Javascript class name, not C++ class name, so probably revert it (or, better, change to 'vm' or something...).

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
+ } 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.")));
}
@herby
herby added a note

Ditto, new Script was meant in Javascript context, so now something like createScript...

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
- 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.")));
}
@herby
herby added a note

Same here.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
- 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);
+
View
48 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);
@herby

This refers to Javascript class name, not C++ class name, so probably revert it (or, better, change to 'vm' or something...).

@herby

Ditto, new Script was meant in Javascript context, so now something like createScript...

@herby

Same here.

@bnoordhuis

contextArg is never used...

Please sign in to comment.
Something went wrong with that request. Please try again.