lukechilds
/
node
mirror of https://github.com/lukechilds/node.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Lint node_script.cc

v0.7.4-release
Ryan Dahl 14 years ago
parent
5b81897cf6
commit
40f29dd48a
2 changed files with 187 additions and 138 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 275
      src/node_script.cc
  2. 48
      src/node_script.h

275
src/node_script.cc
View File

@ -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
View File

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

Write Preview
Loading…
Cancel
Save