void
test_Exception()
{
HandleScope handle_scope;
Persistent<Context> context = Context::New();
Handle<Script> script = Script::New(String::New("function foo(x) { throw x; };"));
Context::Scope scope(context);
TryCatch trycatch;
Handle<Value> v = script->Run();
do_check_true(!v.IsEmpty());
do_check_true(!trycatch.HasCaught());
Handle<Function> fn = context->Global()->Get(String::NewSymbol("foo")).As<Function>();
do_check_true(!fn.IsEmpty());
Local<Value> args[1] = { Integer::New(4) };
v = fn->Call(context->Global(), 1, args);
do_check_true(v.IsEmpty());
do_check_true(trycatch.HasCaught());
Handle<Value> exn = trycatch.Exception();
do_check_true(exn->IsInt32());
do_check_eq(exn->Int32Value(), 4);
context.Dispose();
}
void
test_BasicCall()
{
HandleScope handle_scope;
Handle<ObjectTemplate> templ = ObjectTemplate::New();
Handle<FunctionTemplate> fnT = v8::FunctionTemplate::New(AddOne);
templ->Set("AddOne", fnT);
Persistent<Context> context = Context::New(NULL, templ);
Context::Scope context_scope(context);
Local<Value> addone = context->Global()->Get(String::New("AddOne"));
do_check_true(!addone.IsEmpty());
do_check_true(!addone->IsUndefined());
do_check_true(addone->IsObject());
do_check_true(addone->IsFunction());
Local<Function> fn = addone.As<Function>();
do_check_eq(fn, fnT->GetFunction());
Local<Number> n = Number::New(0.5);
Handle<Value> args[] = { n };
Local<Value> v = fn->Call(context->Global(), 1, args);
do_check_true(!v.IsEmpty());
do_check_true(v->IsNumber());
Local<Number> n2 = v->ToNumber();
do_check_eq(n2->Value(), 1.5);
context.Dispose();
}
void cm_script_GetGeometrySize(cm_script* Script, int* x, int* y, int* z)
{
// Thread protection
v8::Locker Locker;
// Create a stack-allocated handle scope.
HandleScope handle_scope;
// Enter the created context for compiling and
// running the hello world script.
Context::Scope context_scope(context);
// Get the latest geometry
v8::Local<v8::Function> FunctionName = v8::Local<v8::Function>::Cast(context->Global()->Get(v8::String::New("cm_GetGeometry")));
v8::Handle<v8::Value> args[] = { };
v8::Local<v8::Value> Result = FunctionName->Call(FunctionName, 0, args);
// If we got back an array
if(Result->IsArray())
{
// Turn into array
v8::Handle<v8::Array> Array0 = v8::Handle<v8::Array>::Cast(Result);
*z = Array0->Length();
v8::Handle<v8::Array> Array1 = v8::Handle<v8::Array>::Cast(Array0->Get(0));
*y = Array1->Length();
v8::Handle<v8::Array> Array2 = v8::Handle<v8::Array>::Cast(Array1->Get(0));
*x = Array2->Length();
}
else
*x = *y = *z = 0;
}
extern "C" Handle<Value> create_function(Persistent<Context> context,
char* source_s,
char* name) {
// Create a stack-allocated handle scope.
HandleScope handle_scope;
Context::Scope context_scope(context);
// Create a string containing the JavaScript source code.
Handle<String> source = String::New(source_s);
// Compile the source code.
Handle<Script> script = Script::Compile(source);
// Run the script to get the result.
Handle<Value> result = script->Run();
// magic
Handle<Object> global = context->Global();
Handle<Value> value = global->Get(String::New(name));
Handle<Function> func = v8::Handle<Function>::Cast(value);
func->SetName(String::New(name));
Persistent<Function> persistent_func = Persistent<Function>::New(func);
return persistent_func;
}
jstring JNICALL Java_me_sarim_myfirstapp_MainActivity_avroparse( JNIEnv* env,jobject thiz,jstring sk1) {
std::string banglatxt;
GetJStringContent(env,sk1,banglatxt);
Context::Scope context_scope(context);
/*
std::string code1 = "OmicronLab.Avro.Phonetic.parse('";
std::string code2 = "');";
std::string finalcode = code1 + banglatxt + code2;
Handle<String> source2 = String::New(finalcode.c_str());
Handle<Script> script2 = Script::Compile(source2);
Handle<Value> result = script2->Run();
*/
Handle<Object> global = context->Global();
Handle<Value> avro_parse = global->Get(String::New("testfunc"));
Handle<Function> avro_parse_func = Handle<Function>::Cast(avro_parse);
Handle<Value> args[1];
Handle<Value> result;
args[0] = v8::String::New(banglatxt.c_str());
result = avro_parse_func->Call(global, 1, args);
// Convert the result to an ASCII string and print it.
String::Utf8Value ascii(result);
//printf("%s\n", *ascii);
//char * bntext = *ascii;
std::string bntext = std::string(*ascii);
return env->NewStringUTF(bntext.c_str());
}
Handle<Value> WrappedScript::CreateContext(const Arguments& args)
{
HandleScope scope;
Persistent<Context> context = Context::New(NULL, WrappedContext::global_template);
WrappedContext *wrappedContext = new WrappedContext(context);
Local<Object> global = context->Global();
// Allow current context access to newly created context's objects.
context->SetSecurityToken(Context::GetCurrent()->GetSecurityToken());
// If a sandbox is provided initial the new context's global with it.
if (args.Length() > 0) {
Local<Object> sandbox = args[0]->ToObject();
Local<Array> keys = sandbox->GetPropertyNames();
for (uint32_t i = 0; i < keys->Length(); i++) {
Handle<String> key = keys->Get(Integer::New(i))->ToString();
Handle<Value> value = sandbox->Get(key);
if (value == sandbox) {
value = global;
}
global->Set(key, value);
}
}
return scope.Close(global);
}
/*
* Class: org_appcelerator_kroll_runtime_v8_V8Runtime
* Method: nativeInit
* Signature: (Lorg/appcelerator/kroll/runtime/v8/V8Runtime;)J
*/
JNIEXPORT void JNICALL Java_org_appcelerator_kroll_runtime_v8_V8Runtime_nativeInit(JNIEnv *env, jobject self, jboolean useGlobalRefs, jint debuggerPort, jboolean DBG)
{
HandleScope scope;
titanium::JNIScope jniScope(env);
// Log all uncaught V8 exceptions.
V8::AddMessageListener(logV8Exception);
V8::SetCaptureStackTraceForUncaughtExceptions(true);
JavaObject::useGlobalRefs = useGlobalRefs;
V8Runtime::debuggerEnabled = debuggerPort >= 0;
V8Runtime::DBG = DBG;
V8Runtime::javaInstance = env->NewGlobalRef(self);
JNIUtil::initCache();
Persistent<Context> context = Persistent<Context>::New(Context::New());
context->Enter();
V8Runtime::globalContext = context;
V8Runtime::bootstrap(context->Global());
if (V8Runtime::debuggerEnabled) {
jclass v8RuntimeClass = env->FindClass("org/appcelerator/kroll/runtime/v8/V8Runtime");
dispatchDebugMessage = env->GetMethodID(v8RuntimeClass, "dispatchDebugMessages", "()V");
Debug::SetDebugMessageDispatchHandler(dispatchHandler);
Debug::EnableAgent("titanium", debuggerPort, true);
}
LOG_HEAP_STATS(TAG);
}
void
test_obj_propexn() {
HandleScope handle_scope;
Persistent<Context> context = Context::New();
Context::Scope context_scope(context);
Handle<Object> obj = Object::New();
obj->SetAccessor(String::New("myprop"), ReadExn, WriteExn);
Local<Object> global = context->Global();
global->Set(String::New("testobj"), obj);
Handle<String> source = String::New("var n = 0;"
"try { testobj.myprop; } catch (e) { n += e; };"
"try { testobj.myprop = (n+9); } catch (e) { n += e; }; n");
// Compile the source code.
Handle<Script> script = Script::Compile(source);
TryCatch trycatch;
// Run the script to get the result.
Handle<Value> result = script->Run();
do_check_false(result.IsEmpty());
do_check_true(result->IsInt32());
do_check_false(trycatch.HasCaught());
JSInt32 i = result->Int32Value();
do_check_eq(13, i);
context.Dispose();
}
void
test_obj_defprop() {
HandleScope handle_scope;
Persistent<Context> context = Context::New();
Context::Scope context_scope(context);
Handle<Object> obj = Object::New();
Handle<Value> data = Integer::New(2);
obj->SetAccessor(String::New("myprop"), ReadTestVal, WriteTestVal, data);
Local<Object> global = context->Global();
global->Set(String::New("testobj"), obj);
Handle<String> source = String::New("var n = testobj.myprop; testobj.myprop = (n+9); testobj.myprop");
// Compile the source code.
Handle<Script> script = Script::Compile(source);
// Run the script to get the result.
Handle<Value> result = script->Run();
do_check_true(!result.IsEmpty());
do_check_true(result->IsInt32());
JSInt32 i = result->Int32Value();
do_check_eq(12, i);
context.Dispose();
}
jstring JNICALL Java_com_omicronlab_avrokeyboard_PhoneticIM_avroparse( JNIEnv* env,jobject thiz,jstring sk1) {
std::string banglatxt;
//convert java String to Cpp String
GetJStringContent(env,sk1,banglatxt);
Context::Scope context_scope(context);
Handle<Object> global = context->Global();
Handle<Value> avro_parse = global->Get(String::New("avroparsefunc"));
Handle<Function> avro_parse_func = Handle<Function>::Cast(avro_parse);
Handle<Value> args[1];
Handle<Value> result;
args[0] = v8::String::New(banglatxt.c_str());
result = avro_parse_func->Call(global, 1, args);
// Convert the result to an ASCII string
String::Utf8Value ascii(result);
std::string bntext = std::string(*ascii);
return env->NewStringUTF(bntext.c_str());
}
bool cm_script_GetGeometry(cm_script* Script, int x, int y, int z, int* Char, int* Color)
{
// Get geometry size and return on error
int Sizex, Sizey, Sizez;
cm_script_GetGeometrySize(Script, &Sizex, &Sizey, &Sizez);
if(x < 0 || x >= Sizex || y < 0 || y >= Sizey)
return false;
// Thread protection
v8::Locker Locker;
// Create a stack-allocated handle scope.
HandleScope handle_scope;
// Enter the created context for compiling and
// running the hello world script.
Context::Scope context_scope(context);
// Get the latest geometry
v8::Local<v8::Function> FunctionName = v8::Local<v8::Function>::Cast(context->Global()->Get(v8::String::New("cm_GetGeometry")));
v8::Handle<v8::Value> args[] = { };
v8::Local<v8::Value> Result = FunctionName->Call(FunctionName, 0, args);
// If we got back an array
if(Result->IsArray())
{
// Turn into array
v8::Handle<v8::Array> Array = v8::Handle<v8::Array>::Cast(Result);
String::AsciiValue Ascii(Array->ToString());
if(Array->IsUndefined())
return false;
v8::Handle<v8::Array> Array0 = v8::Handle<v8::Array>::Cast(Array->Get(z));
String::AsciiValue Ascii0(Array0->ToString());
if(Array0->IsUndefined())
return false;
v8::Handle<v8::Array> Array1 = v8::Handle<v8::Array>::Cast(Array0->Get(y));
String::AsciiValue Ascii1(Array1->ToString());
if(Array1->IsUndefined())
return false;
v8::Handle<v8::Value> Array2 = Array1->Get(x);
String::AsciiValue Ascii2(Array2->ToString());
if(Array2->IsUndefined())
return false;
*Color = CM_BG_RED | CM_FG_WHITE;
*Char = (*Ascii2)[0];
// If empty (space) just return false
if(*Char != ' ')
return true;
}
// Failed
return false;
}
extern "C" void registerValue(Persistent<Context> context, const char* name, Handle<Value> val) {
HandleScope handle_scope;
Context::Scope context_scope(context);
Handle<Object> global = context->Global();
global->Set(String::New(name), val);
}
extern "C" void register_function(Persistent<Context> context, InvocationCallback cb) {
HandleScope handle_scope;
Context::Scope context_scope(context);
Handle<Object> global = context->Global();
global->Set(String::New("apply_fsharp"), FunctionTemplate::New(cb)->GetFunction());
}
// Load up the JS engine
void initJsEngine(){
char path[1024];
uint32_t size = sizeof(path);
if (_NSGetExecutablePath(path, &size) != 0)
printf("buffer too small; need size %u\n", size);
string script_path;
char *pch, *next_pch;
pch = strtok(path, "/");
next_pch = strtok(NULL, "/");
//Rebuild the path, ommitting the last part (the exe name)
while (next_pch != NULL) {
script_path.append( "/" );
script_path.append( pch );
pch = next_pch;
next_pch = strtok(NULL, "/");
}
script_path.append("/script.js");
ifstream infile;
infile.open (script_path.c_str(), ifstream::in);
string file = "";
while (infile.good()){
file += (char) infile.get();
}
//Get rid of the of character
file[file.length() - 1] = ' ';
setJsFile( file.c_str() );
infile.close();
// Lock this v8 instance to this thread?
Locker locker;
HandleScope handle_scope;
Persistent<Context> context = Context::New();
Context::Scope context_scope(context);
context->Global()->Set(String::New("System"), getSystemTemplate()->NewInstance() );
context->Global()->Set(String::New("Player"), getPlayerTemplate()->NewInstance() );
context->Global()->Set(String::New("Games"), getGamesTemplate()->NewInstance() );
Handle<String> source = String::New(js_file);
Handle<Script> script = Script::Compile(source);
Handle<Value> result = script->Run();
context.Dispose();
}
WrappedContext::WrappedContext(Persistent<Context> context)
: context_(context)
{
HandleScope scope;
Local<Object> globalProxy = context->Global();
Local<Object> global = globalProxy->GetPrototype().As<Object>();
Wrap(global);
}
int main(int argc, char** argv) {
signal(SIGSEGV, AnsiSignalHandler);
// printf("SILK V0.1\n");
if (argc < 2) {
printf("usage: %s file.js\n", argv[0]);
exit(1);
}
char *startup = readFile(argv[1]);
if (!startup) {
printf("%s not found\n", argv[1]);
exit(1);
}
if (startup[0] == '#' && startup[1] == '!') {
startup[0] = startup[1] = '/';
}
init_global_object();
{
HandleScope scope;
context = Persistent<Context>::New(Context::New(NULL, globalObject));
Context::Scope context_scope(context);
// Debug::EnableAgent("silkjs", 9222);
// Debug::SetDebugMessageDispatchHandler(debugger, true);
Handle<Script>init = Script::New(String::New("global=this;"), String::New("builtin"));
init->Run();
mainScript = Persistent<Script>::New(Script::Compile(String::New(startup), String::New(argv[1])));
mainScript->Run();
Handle<String> process_name = String::New("main");
Handle<Value> process_val = context->Global()->Get(process_name);
Handle<Function> process_fun = Handle<Function>::Cast(process_val);
mainFunc = Persistent<Function>::New(process_fun);
const int ac = argc-2;
Handle<Value>av[ac];
for (int i=2; i<argc; i++) {
av[i-2] = String::New(argv[i]);
}
// printf("SILKJS running %s\n", argv[1]);
mainFunc->Call(context->Global(), ac, av);
}
}
extern "C" Handle<Value> apply_function(Persistent<Context> context,
Handle<Function> func,
Handle<Value> arg1) {
HandleScope handle_scope;
Context::Scope context_scope(context);
Handle<Value> result = func->Call(context->Global(), 1, &arg1);
Persistent<Value> js_result = Persistent<Value>::New(result);
return js_result;
}
/*
void cm_script_Interact(cm_script* Script)
{
// Thread protection
v8::Locker Locker;
// Create a stack-allocated handle scope.
HandleScope handle_scope;
// Cast as needed
Persistent<Context> context = *((Persistent<Context>*)Script->__PersistentContext);
// Get the latest geometry
v8::Local<v8::Function> FunctionName = v8::Local<v8::Function>::Cast(context->Global()->Get(v8::String::New("cm_Interact")));
v8::Handle<v8::Value> args[] = { };
FunctionName->Call(FunctionName, 0, args);
}
void cm_script_LookAt(cm_script* Script)
{
// Thread protection
v8::Locker Locker;
// Create a stack-allocated handle scope.
HandleScope handle_scope;
// Cast as needed
Persistent<Context> context = *((Persistent<Context>*)Script->__PersistentContext);
// Get the latest geometry
v8::Local<v8::Function> FunctionName = v8::Local<v8::Function>::Cast(context->Global()->Get(v8::String::New("cm_LookAt")));
v8::Handle<v8::Value> args[] = { };
FunctionName->Call(FunctionName, 0, args);
}
*/
void cm_script_Update(cm_script* Script, float dT)
{
// Thread protection
v8::Locker Locker;
// Create a stack-allocated handle scope.
HandleScope handle_scope;
// Enter the created context for compiling and
// running the hello world script.
Context::Scope context_scope(context);
// Get the latest geometry
v8::Local<v8::Function> FunctionName = v8::Local<v8::Function>::Cast(context->Global()->Get(v8::String::New("cm_Update")));
v8::Handle<v8::Value> args[] = { v8::Number::New(dT) };
FunctionName->Call(FunctionName, 1, args);
}
int main (int argc, char const *argv[])
{
HandleScope handle_scope;
Handle<ObjectTemplate> global = ObjectTemplate::New();
global->Set(String::New("load"), FunctionTemplate::New(js_load));
Persistent<Context> context = Context::New(NULL, global);
Context::Scope context_scope(context);
Handle<Object> global_obj(context->Global());
IO::initialize(global_obj);
Process::initialize(global_obj);
Handle<Value> result = LoadScript(argv[1]);
context.Dispose();
return 0;
}
Handle<Value> EditorGetCurrentLineRange(const Arguments& args)
{
CComPtr<VirtualPoint> point;
long charOffset;
long lineLen;
long absCharOffset;
g_pSelection->get_ActivePoint(&point);
point->get_AbsoluteCharOffset(&absCharOffset);
point->get_LineCharOffset(&charOffset);
point->get_LineLength(&lineLen);
long lineOffset = absCharOffset - charOffset;
Local<Function> fCreateRange =
Local<Function>::Cast(g_Context->Global()->Get(String::New("createRange")));
Handle<Value> argv[] = { Int32::New(lineOffset), Int32::New(lineOffset + lineLen) };
return fCreateRange->Call(fCreateRange, 2, argv);
}
// Performs a dust.js render inside of V8
int DustJs::render(const string filename, const map<string, string> &model, onRenderFn callback) {
const string tmpl = filename.substr(0, filename.find_last_of("."));
// Create a new scope
HandleScope handle_scope;
Persistent<Context> context = Context::New(NULL);
Context::Scope context_scope(context);
// Load the dust libraries
// Note: The libraries are generated at build time to bundle dust.js
// rather than load it at runtime from an arbitrary location
const char* lib_dust = reinterpret_cast<const char*>(lib_dust_js);
const char* lib_compiler = reinterpret_cast<const char*>(lib_compiler_js);
const char* lib_parser = reinterpret_cast<const char*>(lib_parser_js);
const char* lib_helpers = reinterpret_cast<const char*>(lib_dust_helpers_js);
eval(lib_dust);
eval(lib_compiler);
eval(lib_parser);
eval(lib_helpers);
// Get dust out of the global scope so we can bind it with C++ methods
Handle<Object> global = context->Global();
Handle<Object> dust = global->Get(String::New("dust"))->ToObject();
dust->Set(String::New("onLoad"), FunctionTemplate::New(onLoad)->GetFunction());
// Call dust.render with our arguments
Handle<Value> cbargs[3];
cbargs[0] = String::New(tmpl.c_str());
cbargs[1] = mapToJson(model);
cbargs[2] = FunctionTemplate::New(callback)->GetFunction();
Handle<Function> render = Handle<Function>::Cast(dust->Get(String::New("render")));
render->Call(dust, 3, cbargs);
// Done!
return 0;
}
Handle<Value> evalInContext(const Arguments& args) {
if (args.Length() < 3) {
return ThrowException(Exception::TypeError(String::New("evalInContext takes 3 arguments.")));
}
if (!args[1]->IsObject()) {
return ThrowException(Exception::TypeError(String::New("evalInContext expects an object as second argument.")));
}
HandleScope scope;
Persistent<Context> context = Context::New();
Context::Scope context_scope(context);
Local<Object> global = context->Global();
Local<Object> jscontext = args[1]->ToObject()->Clone();
Local<Array> names = jscontext->GetOwnPropertyNames();
for (int i = 0; i < names->Length(); i++) {
global->Set(names->Get(i), jscontext->Get(names->Get(i)));
}
TryCatch tc;
Local<Script> compiled = Script::Compile(args[0]->ToString(), args[2]->ToString());
if (compiled.IsEmpty()) {
return tc.ReThrow();
}
Handle<Value> value = compiled->Run();
if (value.IsEmpty()) {
return tc.ReThrow();
}
return scope.Close(value);
}
Persistent<Function> GetFunctionHandle(const char * filename, const char * functionName)
{
HandleScope handle_scope;
Persistent<Function> function;
Handle<ObjectTemplate> objectTemplate = ObjectTemplate::New();
Handle<Script> script = ReadAndCompileScript(filename);
Handle<String> processName = String::New(functionName);
Handle<Value> process_val = g_context->Global()->Get(processName);
// bail if we couldn't find the function
if( !process_val->IsFunction())
return function;
Handle<Function> process_fun = Handle<Function>::Cast(process_val);
function = Persistent<Function>::New(process_fun);
return function;
}
int main(int argc, char* argv[])
{
HandleScope handleScope;
Local<FunctionTemplate> logFunction = FunctionTemplate::New(LogCallback);
Local<ObjectTemplate> globals = ObjectTemplate::New();
globals->Set(String::New("Log"),logFunction);
Handle<Context> context = Context::New(NULL,globals);
g_context = Persistent<Context>::New(context); // make the context global
Context::Scope scope(g_context);
Persistent<Function> updateFunction = GetFunctionHandle("test.js","Update");
printf("\n\n... Running Code ...\n\n");
const int numArgs=0;
Handle<Value> * args = NULL;
Handle<Value> result = updateFunction->Call( g_context->Global(), numArgs, args);
// Convert the result to an ASCII string and print it.
String::AsciiValue ascii(result);
printf("The Result is %s\n", *ascii);
return 0;
}
void
test_obj_tmplexn() {
HandleScope scope;
Persistent<Context> context = Context::New();
Context::Scope context_scope(context);
Handle<ObjectTemplate> tmpl = ObjectTemplate::New();
tmpl->SetNamedPropertyHandler(NamedGetterThrows, NamedSetterThrows, 0, NamedDeleterThrows);
tmpl->SetIndexedPropertyHandler(IndexedGetterThrows, IndexedSetterThrows, 0, IndexedDeleterThrows);
Handle<Object> obj = tmpl->NewInstance();
Local<Object> global = context->Global();
global->Set(String::New("testobj"), obj);
Handle<String> source = String::New("var n = 0;"
"try { testobj.myprop; } catch (e) { n += e; };"
"try { testobj.myprop = (n+9); } catch (e) { n += e; }"
"try { delete testobj.myprop; } catch (e) { n += e; };"
"try { testobj[4]; } catch (e) { n += e; };"
"try { testobj[5] = (n+9); } catch (e) { n += e; }"
"try { delete testobj[6]; } catch (e) { n += e; }; n");
// Compile the source code.
Handle<Script> script = Script::Compile(source);
TryCatch trycatch;
// Run the script to get the result.
Handle<Value> result = script->Run();
do_check_false(result.IsEmpty());
do_check_true(result->IsInt32());
do_check_false(trycatch.HasCaught());
JSInt32 i = result->Int32Value();
do_check_eq(i, 21);
context.Dispose();
}
Handle<Value> WrappedScript::EvalMachine(const Arguments& args)
{
HandleScope scope;
if (input_flag == compileCode && args.Length() < 1) {
return ThrowException(Exception::TypeError(String::New("needs at least 'code' argument.")));
}
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 (input_flag == compileCode) code = args[0]->ToString();
Local<Object> sandbox;
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 filename_index = sandbox_index + (context_flag == newContext ? 1 : 0);
Local<String> filename =
args.Length() > filename_index ? args[filename_index]->ToString() : String::New("evalmachine.<anonymous>");
const int display_error_index = args.Length() - 1;
bool display_error = false;
if (args.Length() > display_error_index && args[display_error_index]->IsBoolean()
&& args[display_error_index]->BooleanValue() == true) {
display_error = true;
}
Persistent<Context> context;
Local<Array> keys;
unsigned int i;
WrappedContext *nContext = NULL;
Local<Object> contextArg;
if (context_flag == newContext) {
// Create the new context
context = Context::New();
} else if (context_flag == userContext) {
// Use the passed in context
contextArg = args[sandbox_index]->ToObject();
nContext = NativeObject::Unwrap<WrappedContext>(contextArg);
context = nContext->GetV8Context();
}
// New and user context share code. DRY it up.
if (context_flag == userContext || context_flag == newContext) {
// Enter the context
context->Enter();
// Call the initCallback, if it exists
if (nContext) {
Persistent<Function> initCallback = nContext->GetInitCallback();
if (!initCallback.IsEmpty()) {
Handle<Value> callbackArgs[] = { contextArg, context->Global() };
initCallback->Call(contextArg, 2, callbackArgs);
}
}
// Copy everything from the passed in sandbox (either the persistent
// context for runInContext(), or the sandbox arg to runInNewContext()).
keys = sandbox->GetPropertyNames();
for (i = 0; i < keys->Length(); i++) {
Handle<String> key = keys->Get(Integer::New(i))->ToString();
Handle<Value> value = sandbox->Get(key);
if (value == sandbox) {
value = context->Global();
}
context->Global()->Set(key, value);
}
}
Handle<Value> result;
Handle<Script> script;
if (input_flag == compileCode) {
// well, here WrappedScript::New would suffice in all cases, but maybe
// Compile has a little better performance where possible
script = output_flag == returnResult ? Script::Compile(code, filename) : Script::New(code, filename);
if (script.IsEmpty()) {
// Hack because I can't get a proper stacktrace on SyntaxError
return Undefined();
}
} else {
WrappedScript *n_script = NativeObject::Unwrap<WrappedScript>(args.Holder());
if (!n_script) {
return ThrowException(Exception::Error(String::New("Must be called as a method of Script.")));
} else if (n_script->script_.IsEmpty()) {
return ThrowException(Exception::Error(String::New("'this' must be a result of previous "
"new Script(code) call.")));
}
script = n_script->script_;
}
if (output_flag == returnResult) {
result = script->Run();
if (result.IsEmpty()) {
if (context_flag == newContext) {
context->DetachGlobal();
context->Exit();
context.Dispose();
}
return Undefined();
}
} else {
WrappedScript *n_script = NativeObject::Unwrap<WrappedScript>(args.Holder());
if (!n_script) {
return ThrowException(Exception::Error(String::New("Must be called as a method of Script.")));
}
n_script->script_ = Persistent<Script>::New(script);
result = args.This();
}
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++) {
Handle<String> key = keys->Get(Integer::New(i))->ToString();
Handle<Value> value = context->Global()->Get(key);
if (value == context->Global()) {
value = sandbox;
}
sandbox->Set(key, value);
}
}
if (context_flag == newContext) {
// Clean up, clean up, everybody everywhere!
context->DetachGlobal();
context->Exit();
context.Dispose();
} else if (context_flag == userContext) {
// Exit the passed in context.
context->Exit();
}
if (result->IsObject()) {
Local<Context> creation = result->ToObject()->CreationContext();
}
return result == args.This() ? result : scope.Close(result);
}
void CanvasContextV8Bindings::loadScript(const std::string& _filename, OgreCanvas::CanvasContext* _canvasContext, OgreCanvas::CanvasLogger* _console)
{
CanvasContextV8Bindings::context2D = _canvasContext;
HandleScope handle_scope;
//Console :
//template
Handle<FunctionTemplate> consoleTemplate = FunctionTemplate::New();
consoleTemplate->SetClassName(v8::String::New("Console"));
CanvasContextV8Bindings::consoleTemplate = Persistent<FunctionTemplate>::New(consoleTemplate);
//prototype
Handle<ObjectTemplate> consolePrototype = consoleTemplate->PrototypeTemplate();
//attaching method
consolePrototype->Set("log", FunctionTemplate::New(log));
//creating instance
Handle<ObjectTemplate> consoleInstance = consoleTemplate->InstanceTemplate();
consoleInstance->SetInternalFieldCount(1);
//Image :
//template
Handle<FunctionTemplate> imageTemplate = FunctionTemplate::New();
imageTemplate->SetClassName(v8::String::New("Image"));
CanvasContextV8Bindings::imageTemplate = Persistent<FunctionTemplate>::New(imageTemplate);
//prototype
Handle<ObjectTemplate> imagePrototype = imageTemplate->PrototypeTemplate();
//creating instance
Handle<ObjectTemplate> imageInstance = imageTemplate->InstanceTemplate();
imageInstance->SetInternalFieldCount(1);
//Canvas gradient :
//template
Handle<FunctionTemplate> canvasGradientTemplate = FunctionTemplate::New();
canvasGradientTemplate->SetClassName(v8::String::New("CanvasGradient"));
CanvasContextV8Bindings::canvasGradientTemplate = Persistent<FunctionTemplate>::New(canvasGradientTemplate);
//prototype
Handle<ObjectTemplate> canvasGradientPrototype = canvasGradientTemplate->PrototypeTemplate();
//creating instance
Handle<ObjectTemplate> canvasGradientInstance = canvasGradientTemplate->InstanceTemplate();
canvasGradientInstance->SetInternalFieldCount(1);
//attaching method
canvasGradientPrototype->Set("addColorStop", FunctionTemplate::New(addColorStop));
//Canvas Pattern :
//template
Handle<FunctionTemplate> canvasPatternTemplate = FunctionTemplate::New();
canvasPatternTemplate->SetClassName(v8::String::New("CanvasPattern"));
CanvasContextV8Bindings::canvasPatternTemplate = Persistent<FunctionTemplate>::New(canvasPatternTemplate);
//prototype
Handle<ObjectTemplate> canvasPatternPrototype = canvasPatternTemplate->PrototypeTemplate();
//creating instance
Handle<ObjectTemplate> canvasPatternInstance = canvasPatternTemplate->InstanceTemplate();
canvasPatternInstance->SetInternalFieldCount(1);
//Canvas context :
//template
Handle<FunctionTemplate> canvasContextTemplate = FunctionTemplate::New();
canvasContextTemplate->SetClassName(v8::String::New("CanvasContext"));
//prototype
Handle<ObjectTemplate> canvasContextPrototype = canvasContextTemplate->PrototypeTemplate();
//attaching method
//2D Context
canvasContextPrototype->Set("save", FunctionTemplate::New(save));
canvasContextPrototype->Set("restore", FunctionTemplate::New(restore));
//Transformation
canvasContextPrototype->Set("scale", FunctionTemplate::New(scale));
canvasContextPrototype->Set("rotate", FunctionTemplate::New(rotate));
canvasContextPrototype->Set("translate", FunctionTemplate::New(translate));
canvasContextPrototype->Set("transform", FunctionTemplate::New(transform));
canvasContextPrototype->Set("setTransform", FunctionTemplate::New(setTransform));
//Image drawing
canvasContextPrototype->Set("drawImage", FunctionTemplate::New(drawImage));
//Colors, styles and shadows
canvasContextPrototype->Set("createLinearGradient", FunctionTemplate::New(createLinearGradient));
canvasContextPrototype->Set("createRadialGradient", FunctionTemplate::New(createRadialGradient));
canvasContextPrototype->Set("createPattern", FunctionTemplate::New(createPattern));
//Paths
canvasContextPrototype->Set("beginPath", FunctionTemplate::New(beginPath));
canvasContextPrototype->Set("closePath", FunctionTemplate::New(closePath));
canvasContextPrototype->Set("fill", FunctionTemplate::New(fill));
canvasContextPrototype->Set("stroke", FunctionTemplate::New(stroke));
canvasContextPrototype->Set("clip", FunctionTemplate::New(clip));
canvasContextPrototype->Set("moveTo", FunctionTemplate::New(moveTo));
canvasContextPrototype->Set("lineTo", FunctionTemplate::New(lineTo));
canvasContextPrototype->Set("quadraticCurveTo", FunctionTemplate::New(quadraticCurveTo));
canvasContextPrototype->Set("bezierCurveTo", FunctionTemplate::New(bezierCurveTo));
canvasContextPrototype->Set("arcTo", FunctionTemplate::New(arcTo));
canvasContextPrototype->Set("arc", FunctionTemplate::New(arc));
canvasContextPrototype->Set("rect", FunctionTemplate::New(rect));
canvasContextPrototype->Set("isPointInPath", FunctionTemplate::New(isPointInPath));
//Text
canvasContextPrototype->Set("fillText", FunctionTemplate::New(fillText));
canvasContextPrototype->Set("strokeText", FunctionTemplate::New(strokeText));
canvasContextPrototype->Set("measureText", FunctionTemplate::New(measureText));
//Rectangles
canvasContextPrototype->Set("clearRect", FunctionTemplate::New(clearRect));
canvasContextPrototype->Set("fillRect", FunctionTemplate::New(fillRect));
canvasContextPrototype->Set("strokeRect", FunctionTemplate::New(strokeRect));
//New
canvasContextPrototype->Set("saveToPNG", FunctionTemplate::New(saveToPNG));
canvasContextPrototype->Set("clear", FunctionTemplate::New(clear));
//creating instance
Handle<ObjectTemplate> canvasContextInstance = canvasContextTemplate->InstanceTemplate();
canvasContextInstance->SetInternalFieldCount(1);
//attaching properties
//Compositing
canvasContextInstance->SetAccessor(v8::String::New("globalAlpha"), getterGlobalAlpha, setterGlobalAlpha);
canvasContextInstance->SetAccessor(v8::String::New("globalCompositeOperation"), getterGlobalCompositeOperation, setterGlobalCompositeOperation);
//Line styles
canvasContextInstance->SetAccessor(v8::String::New("lineWidth"), getterLineWidth, setterLineWidth);
canvasContextInstance->SetAccessor(v8::String::New("lineCap"), getterLineCap, setterLineCap);
canvasContextInstance->SetAccessor(v8::String::New("lineJoin"), getterLineJoin, setterLineJoin);
canvasContextInstance->SetAccessor(v8::String::New("miterLimit"), getterMiterLimit, setterMiterLimit);
canvasContextInstance->SetAccessor(v8::String::New("lineDash"), getterLineDash, setterLineDash);
//Colors, styles and shadows
canvasContextInstance->SetAccessor(v8::String::New("fillStyle"), getterFillStyle, setterFillStyle);
canvasContextInstance->SetAccessor(v8::String::New("strokeStyle"), getterStrokeStyle, setterStrokeStyle);
canvasContextInstance->SetAccessor(v8::String::New("shadowOffsetX"), getterShadowOffsetX, setterShadowOffsetX);
canvasContextInstance->SetAccessor(v8::String::New("shadowOffsetY"), getterShadowOffsetY, setterShadowOffsetY);
canvasContextInstance->SetAccessor(v8::String::New("shadowBlur"), getterShadowBlur, setterShadowBlur);
canvasContextInstance->SetAccessor(v8::String::New("shadowColor"), getterShadowColor, setterShadowColor);
//Text
canvasContextInstance->SetAccessor(v8::String::New("font"), getterFont, setterFont);
canvasContextInstance->SetAccessor(v8::String::New("textAlign"), getterTextAlign, setterTextAlign);
canvasContextInstance->SetAccessor(v8::String::New("textBaseline"), getterTextBaseline, setterTextBaseline);
//New
canvasContextInstance->SetAccessor(v8::String::New("antialiasing"), getterAntiAliasing, setterAntiAliasing);
//Image
Handle<ObjectTemplate> global = ObjectTemplate::New();
global->Set(String::New("loadImage"), FunctionTemplate::New(loadImage));
Persistent<Context> context = Context::New(NULL, global);
CanvasContextV8Bindings::contextV8 = context;
Context::Scope context_scope(context);
//building link between js 'ctx' variable and c++ _canvasContext variable
Handle<Function> canvasContextConstructor = canvasContextTemplate->GetFunction();
Local<Object> obj = canvasContextConstructor->NewInstance();
obj->SetInternalField(0, External::New(_canvasContext));
context->Global()->Set(v8::String::New("ctx"), obj);
//building link between js 'console' variable and c++ _console variable
Handle<Function> consoleConstructor = consoleTemplate->GetFunction();
Local<Object> obj2 = consoleConstructor->NewInstance();
obj2->SetInternalField(0, External::New(_console));
context->Global()->Set(v8::String::New("console"), obj2);
Handle<v8::String> source = v8::String::New(readScript(_filename).c_str());
Handle<Script> script = Script::Compile(source);
Handle<Value> result = script->Run();
/*
CanvasContextV8Bindings::canvasGradientTemplate.Dispose();
CanvasContextV8Bindings::canvasPatternTemplate.Dispose();
CanvasContextV8Bindings::imageTemplate.Dispose();
*/
}
bool v8test_userobjectcompare()
{
BEGINTEST();
HandleScope handle_scope;
Persistent<Context> context = Context::New();
Context::Scope context_scope(context);
V8::SetUserObjectComparisonCallbackFunction(UserObjectComparison);
Local<ObjectTemplate> ot = ObjectTemplate::New();
ot->MarkAsUseUserObjectComparison();
Local<Object> uoc1 = ot->NewInstance();
Local<Object> uoc2 = ot->NewInstance();
context->Global()->Set(String::New("uoc1a"), uoc1);
context->Global()->Set(String::New("uoc1b"), uoc1);
context->Global()->Set(String::New("uoc2"), uoc2);
Local<Object> obj1 = Object::New();
context->Global()->Set(String::New("obj1a"), obj1);
context->Global()->Set(String::New("obj1b"), obj1);
context->Global()->Set(String::New("obj2"), Object::New());
Local<String> string1 = String::New("Hello World");
context->Global()->Set(String::New("string1a"), string1);
context->Global()->Set(String::New("string1b"), string1);
context->Global()->Set(String::New("string2"), v8::String::New("Goodbye World"));
// XXX Opportunity for optimization - don't invoke user callback if objects are
// equal.
#if 0
userObjectComparisonCalled = 0; userObjectComparisonReturn = false;
VERIFY(true == runscript("uoc1a == uoc1b"));
VERIFY(userObjectComparisonCalled == 0);
#endif
// Comparing two uoc objects invokes uoc
userObjectComparisonCalled = 0;
userObjectComparisonReturn = false;
VERIFY(false == runscript("uoc1a == uoc2"));
VERIFY(userObjectComparisonCalled == 1);
VERIFY(false == runscript("uoc2 == uoc1a"));
VERIFY(userObjectComparisonCalled == 2);
userObjectComparisonReturn = true;
VERIFY(true == runscript("uoc1a == uoc2"));
VERIFY(userObjectComparisonCalled == 3);
VERIFY(true == runscript("uoc2 == uoc1a"));
VERIFY(userObjectComparisonCalled == 4);
// != on two uoc object invokes uoc
userObjectComparisonCalled = 0;
userObjectComparisonReturn = false;
VERIFY(true == runscript("uoc1a != uoc2"));
VERIFY(userObjectComparisonCalled == 1);
VERIFY(true == runscript("uoc2 != uoc1a"));
VERIFY(userObjectComparisonCalled == 2);
userObjectComparisonReturn = true;
VERIFY(false == runscript("uoc1a != uoc2"));
VERIFY(userObjectComparisonCalled == 3);
VERIFY(false == runscript("uoc2 != uoc1a"));
VERIFY(userObjectComparisonCalled == 4);
// Comparison against a non-object doesn't invoke uoc
userObjectComparisonCalled = 0;
userObjectComparisonReturn = false;
VERIFY(false == runscript("uoc1a == string1a"));
VERIFY(userObjectComparisonCalled == 0);
VERIFY(false == runscript("string1a == uoc1a"));
VERIFY(userObjectComparisonCalled == 0);
VERIFY(false == runscript("2 == uoc1a"));
VERIFY(userObjectComparisonCalled == 0);
VERIFY(true == runscript("uoc1a != string1a"));
VERIFY(userObjectComparisonCalled == 0);
VERIFY(true == runscript("string1a != uoc1a"));
VERIFY(userObjectComparisonCalled == 0);
VERIFY(true == runscript("2 != uoc1a"));
VERIFY(userObjectComparisonCalled == 0);
// Comparison against a non-uoc-object still invokes uoc
userObjectComparisonCalled = 0;
userObjectComparisonReturn = false;
VERIFY(false == runscript("uoc1a == obj1a"));
VERIFY(userObjectComparisonCalled == 1);
VERIFY(false == runscript("obj1a == uoc1a"));
VERIFY(userObjectComparisonCalled == 2);
userObjectComparisonReturn = true;
VERIFY(true == runscript("uoc1a == obj1a"));
VERIFY(userObjectComparisonCalled == 3);
VERIFY(true == runscript("obj1a == uoc1a"));
VERIFY(userObjectComparisonCalled == 4);
// != comparison against a non-uoc-object still invokes uoc
userObjectComparisonCalled = 0;
userObjectComparisonReturn = false;
VERIFY(true == runscript("uoc1a != obj1a"));
VERIFY(userObjectComparisonCalled == 1);
VERIFY(true == runscript("obj1a != uoc1a"));
VERIFY(userObjectComparisonCalled == 2);
userObjectComparisonReturn = true;
VERIFY(false == runscript("uoc1a != obj1a"));
VERIFY(userObjectComparisonCalled == 3);
VERIFY(false == runscript("obj1a != uoc1a"));
VERIFY(userObjectComparisonCalled == 4);
// Comparing two non-uoc objects does not invoke uoc
userObjectComparisonCalled = 0;
userObjectComparisonReturn = false;
VERIFY(true == runscript("obj1a == obj1a"));
VERIFY(true == runscript("obj1a == obj1b"));
VERIFY(false == runscript("obj1a == obj2"));
VERIFY(false == runscript("obj1a == string1a"));
VERIFY(true == runscript("string1a == string1a"));
VERIFY(true == runscript("string1a == string1b"));
VERIFY(false == runscript("string1a == string2"));
VERIFY(userObjectComparisonCalled == 0);
// Correct lhs and rhs passed to uoc
userObjectComparisonCalled = 0;
userObjectComparisonReturn = false;
SET_EXPECTED(uoc1, uoc2);
VERIFY(false == runscript("uoc1a == uoc2"));
VERIFY(true == expectedObjectsCompared);
SET_EXPECTED(uoc2, uoc1);
VERIFY(false == runscript("uoc2 == uoc1a"));
VERIFY(true == expectedObjectsCompared);
SET_EXPECTED(uoc1, uoc2);
VERIFY(true == runscript("uoc1a != uoc2"));
VERIFY(true == expectedObjectsCompared);
SET_EXPECTED(uoc2, uoc1);
VERIFY(true == runscript("uoc2 != uoc1a"));
VERIFY(true == expectedObjectsCompared);
SET_EXPECTED(uoc1, obj1);
VERIFY(false == runscript("uoc1a == obj1a"));
VERIFY(true == expectedObjectsCompared);
SET_EXPECTED(obj1, uoc1);
VERIFY(false == runscript("obj1a == uoc1a"));
VERIFY(true == expectedObjectsCompared);
cleanup:
V8::SetUserObjectComparisonCallbackFunction(0);
context.Dispose();
ENDTEST();
}
int main(int argc, char* argv[]) {
SDL_Init(SDL_INIT_EVERYTHING);
V8::Initialize();
isolate = Isolate::GetCurrent();
HandleScope handle_scope(isolate);
Persistent<Context> context = Context::New();
Context::Scope context_scope(context);
Local<Object> global = context->Global();
Local<Object> sphere = Object::New();
global->Set(String::New("sphere"), sphere);
API::fs::Init(sphere);
API::engine::Init(sphere);
API::graphics::Init(sphere);
API::events::Init(sphere);
Local<Object> engine = sphere->Get(String::New("engine"))->ToObject();
engine->Set(String::New("argc"), Integer::New(argc));
Local<Array> js_argv = Array::New(argc);
for (int i = 0; i < argc; i++) {
js_argv->Set(Number::New(i), String::New(argv[i]));
}
engine->Set(String::New("argv"), js_argv);
const char* gameScript = Files::readTextFile("system/sphere.js");
if (gameScript == NULL) {
debug("Error loading bootstrap script.\n");
exit(1);
}
TryCatch trycatch;
Local<Script> compiled = Script::Compile(String::New(gameScript), String::New("system/sphere.js"));
if (compiled.IsEmpty()) {
Handle<Value> exception = trycatch.Exception();
String::Utf8Value exception_str(exception);
printf("Exception: %s\n", *exception_str);
exit(1);
}
Handle<Value> value = compiled->Run();
if (value.IsEmpty()) {
Handle<Object> exception = trycatch.Exception()->ToObject();
Handle<String> str;
if (exception->Has(String::New("stack"))) {
str = exception->Get(String::New("stack"))->ToString();
}
else {
str = exception->ToString();
}
String::Utf8Value exception_str(str);
printf("Exception: %s\n", *exception_str);
exit(1);
}
return 0;
}
int main (int argc, char** argv) {
signal(SIGSEGV, AnsiSignalHandler);
// printf("SILK V0.1\n");
char *startup;
const char *progName;
signal(SIGSEGV, AnsiSignalHandler);
signal(SIGINT, AnsiSignalHandler);
if (argc < 2) {
startup = readFile("/usr/local/silkjs/builtin/interpreter.js");
if (!startup) {
startup = readFile("/usr/share/silkjs/builtin/interpreter.js");
}
progName = "interpreter";
}
else {
startup = readFile(argv[1]);
progName = argv[1];
}
if (!startup) {
printf("%s not found\n", argv[1]);
exit(1);
}
if (startup[0] == '#' && startup[1] == '!') {
startup[0] = startup[1] = '/';
}
// v8 command line switches
const char *switches = "--harmony";
V8::SetFlagsFromString(switches, strlen(switches));
{
// Isolate *isolate = Isolate::New();
// isolate->Enter();
// Locker lock(isolate);
Locker locker;
HandleScope scope;
init_global_object();
V8::SetCaptureStackTraceForUncaughtExceptions(true, 50); // , StackTrace::kDetailed);
context = Context::New(NULL, globalObject);
Context::Scope context_scope(context);
{
Locker locker;
// Debug::SetDebugMessageDispatchHandler(debugger, true);
// Debug::EnableAgent("silkjs", 5858);
Handle<Script>init = Script::New(String::New("global=this; module = {}; include('builtin/all.js');"), String::New("builtin"));
init->Run();
V8::SetCaptureStackTraceForUncaughtExceptions(true, 50, StackTrace::kDetailed);
TryCatch tryCatch;
mainScript = Persistent<Script>::New(Script::Compile(String::New(startup), String::New(progName)));
if (mainScript.IsEmpty()) {
ReportException(&tryCatch);
exit(1);
}
Handle<Value>v = mainScript->Run();
if (v.IsEmpty()) {
ReportException(&tryCatch);
exit(1);
}
Handle<String> process_name = String::New("main");
Handle<Value> process_val = context->Global()->Get(process_name);
if (!process_val.IsEmpty() && process_val->IsFunction()) {
Handle<Function> process_fun = Handle<Function>::Cast(process_val);
mainFunc = Persistent<Function>::New(process_fun);
int ac = argc - 2;
if (ac < 0) {
ac = 0;
}
Handle<Value>av[ac];
for (int i = 2; i < argc; i++) {
av[i - 2] = String::New(argv[i]);
}
v = mainFunc->Call(context->Global(), ac, av);
if (v.IsEmpty()) {
ReportException(&tryCatch);
exit(1);
}
}
}
context.Dispose();
}
}