Browse Source

Lint node_script.cc

v0.7.4-release
Ryan Dahl 14 years ago
parent
commit
40f29dd48a
  1. 275
      src/node_script.cc
  2. 48
      src/node_script.h

275
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() {
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);

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);

Loading…
Cancel
Save