void TraceMonkeyEngine::init() { Logging::log(Logging::DEBUG, "TraceMonkeyEngine::init\r\n"); INDENT_LOG(Logging::DEBUG); assert(runtime == NULL); runtime = JS_NewRuntime(8L * 1024L * 1024L); // Force GC after X MB. if (runtime == NULL) { Logging::log(Logging::ERROR, "Cannot create TraceMonkey runtime\r\n"); assert(0); } /* Create a context. */ context = JS_NewContext(runtime, 8192); if (context == NULL) { Logging::log(Logging::ERROR, "Cannot create TraceMonkey runtime\r\n"); assert(0); } JS_SetOptions(context, JSOPTION_VAROBJFIX); JS_SetVersion(context, JSVERSION_ECMA_3); JS_SetErrorReporter(context, reportError); // Create the global object. Store it locally for a while until it is usable by others JSObject* _global = JS_NewObject(context, &global_class, NULL, NULL); if (_global == NULL) { Logging::log(Logging::ERROR, "Cannot create TraceMonkey runtime\r\n"); assert(0); } /* Populate the global object with the standard globals, like Object and Array. */ if (!JS_InitStandardClasses(context, _global)) { Logging::log(Logging::ERROR, "Cannot create TraceMonkey runtime\r\n"); assert(0); } // Create our internal wrappers globalValue = ScriptValuePtr(new TraceMonkeyValue( this, true, OBJECT_TO_JSVAL(_global) )); global = _global; // Now that globalValue is set, it is usable by others, so reveal it // JITting // JS_ToggleOptions(context, JSOPTION_JIT); // Might be buggy, wait for 1.8 to release // JS_MaybeGC - call during idle time in the main loop? Or other method? // Use JS_SetContextPrivate and JS_GetContextPrivate to associate application-specific data with a context. // - Useful for security checks, once we have a context for the system and sandboxed contexts // for user scripts // Debugging features JS_SetGCZeal(context, 2); // XXX This is 'extremely high' - make a parameter, see MDC docs }
bool round_js_sm_engine_init(RoundJavaScriptEngine* engine) { if (!engine) return NULL; JS_SetCStringsAreUTF8(); engine->cx = NULL; engine->rt = NULL; engine->obj = NULL; engine->rt = JS_NewRuntime(8L * 1024L * 1024L); if (!engine->rt) return false; engine->cx = JS_NewContext(engine->rt, 8192); if (!engine->cx) return false; JS_SetErrorReporter(engine->cx, RoundJSReportError); // Obsolete since JSAPI 16 engine->obj = JS_NewCompartmentAndGlobalObject(engine->cx, &RoundJSGlobalClass, NULL); if (!engine->obj) return false; JS_InitStandardClasses(engine->cx, engine->obj); JS_DefineFunctions(engine->cx, engine->obj, JS_SM_FUNCTIONS); return true; }
int run(JSContext *cx) { /* Enter a request before running anything in the context */ JSAutoRequest ar(cx); /* Create the global object in a new compartment. */ JSObject *global = JS_NewGlobalObject(cx, &global_class, nullptr); if (!global) return 1; /* Set the context's global */ JSAutoCompartment ac(cx, global); JS_SetGlobalObject(cx, global); /* Populate the global object with the standard globals, like Object and Array. */ if (!JS_InitStandardClasses(cx, global)) return 1; /* Your application code here. This may include JSAPI calls to create your own custom JS objects and run scripts. */ if(!JS_DefineFunctions(cx,global,global_functions)) return 1; const char* script="var text='Hello People';" "logVersion();" "echo(text)"; JSBool ok; jsval rval; ok=JS_EvaluateScript(cx,global,script,strlen(script),"INLINE",0,&rval); return 0; }
spidermonkey_vm *sm_initialize(long thread_stack, long heap_size) { spidermonkey_vm *vm = ejs_alloc(sizeof(spidermonkey_vm)); spidermonkey_state *state = ejs_alloc(sizeof(spidermonkey_state)); state->branch_count = 0; state->error = NULL; state->terminate = 0; int gc_size = (int) heap_size * 0.25; vm->runtime = JS_NewRuntime(MAX_GC_SIZE); JS_SetGCParameter(vm->runtime, JSGC_MAX_BYTES, heap_size); JS_SetGCParameter(vm->runtime, JSGC_MAX_MALLOC_BYTES, gc_size); vm->context = JS_NewContext(vm->runtime, 8192); JS_SetScriptStackQuota(vm->context, thread_stack); begin_request(vm); JS_SetOptions(vm->context, JSOPTION_VAROBJFIX); JS_SetOptions(vm->context, JSOPTION_STRICT); JS_SetOptions(vm->context, JSOPTION_COMPILE_N_GO); JS_SetOptions(vm->context, JSVERSION_LATEST); vm->global = JS_NewCompartmentAndGlobalObject(vm->context, &global_class, NULL); JS_InitStandardClasses(vm->context, vm->global); JS_SetErrorReporter(vm->context, on_error); JS_SetOperationCallback(vm->context, on_branch); JS_SetContextPrivate(vm->context, state); JSNative funptr = (JSNative) &js_log; JS_DefineFunction(vm->context, JS_GetGlobalObject(vm->context), "ejsLog", funptr, 0, 0); end_request(vm); return vm; }
void JavaScriptEngine::Start() { globalRuntime = JS_NewRuntime(32L * 1024L * 1024L); if (globalRuntime == NULL) { LogInfo(TAG, "(globalRuntime == NULL)"); return; } globalContext = JS_NewContext(globalRuntime, 8192); if (globalContext == NULL) { LogInfo(TAG, "(globalContext == NULL)"); return; } JS_SetOptions(globalContext, JSOPTION_VAROBJFIX); JS_SetVersion(globalContext, JSVERSION_LATEST); JS_SetErrorReporter(globalContext, ReportError); globalObject = JS_NewCompartmentAndGlobalObject(globalContext, &globalClass, NULL); if (globalObject == NULL) { LogInfo(TAG, "(globalObject == NULL)"); return; } if (!JS_InitStandardClasses(globalContext, globalObject)) { LogInfo(TAG, "(!JS_InitStandardClasses(globalContext, global))"); return; } BindingGlobalObject(); BindingObject(); RunScript("index.js"); }
ScriptInterface_impl::ScriptInterface_impl(const char* nativeScopeName, const shared_ptr<ScriptRuntime>& runtime) : m_runtime(runtime), m_glob(runtime->m_rt), m_nativeScope(runtime->m_rt) { bool ok; m_cx = JS_NewContext(m_runtime->m_rt, STACK_CHUNK_SIZE); ENSURE(m_cx); JS_SetParallelIonCompilationEnabled(m_runtime->m_rt, true); // For GC debugging: // JS_SetGCZeal(m_cx, 2); JS_SetContextPrivate(m_cx, NULL); JS_SetErrorReporter(m_cx, ErrorReporter); JS_SetGlobalJitCompilerOption(m_runtime->m_rt, JSJITCOMPILER_ION_ENABLE, 1); JS_SetGlobalJitCompilerOption(m_runtime->m_rt, JSJITCOMPILER_BASELINE_ENABLE, 1); JS::ContextOptionsRef(m_cx).setExtraWarnings(1) .setWerror(0) .setVarObjFix(1) .setStrictMode(1); JS::CompartmentOptions opt; opt.setVersion(JSVERSION_LATEST); JSAutoRequest rq(m_cx); JS::RootedObject globalRootedVal(m_cx, JS_NewGlobalObject(m_cx, &global_class, NULL, JS::OnNewGlobalHookOption::FireOnNewGlobalHook, opt)); m_comp = JS_EnterCompartment(m_cx, globalRootedVal); ok = JS_InitStandardClasses(m_cx, globalRootedVal); ENSURE(ok); m_glob = globalRootedVal.get(); // Use the testing functions to globally enable gcPreserveCode. This brings quite a // big performance improvement. In future SpiderMonkey versions, we should probably // use the functions implemented here: https://bugzilla.mozilla.org/show_bug.cgi?id=1068697 JS::RootedObject testingFunctionsObj(m_cx, js::GetTestingFunctions(m_cx)); ENSURE(testingFunctionsObj); JS::RootedValue ret(m_cx); JS_CallFunctionName(m_cx, testingFunctionsObj, "gcPreserveCode", JS::HandleValueArray::empty(), &ret); JS_DefineProperty(m_cx, m_glob, "global", globalRootedVal, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT); m_nativeScope = JS_DefineObject(m_cx, m_glob, nativeScopeName, NULL, NULL, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT); JS_DefineFunction(m_cx, globalRootedVal, "print", ::print, 0, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT); JS_DefineFunction(m_cx, globalRootedVal, "log", ::logmsg, 1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT); JS_DefineFunction(m_cx, globalRootedVal, "warn", ::warn, 1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT); JS_DefineFunction(m_cx, globalRootedVal, "error", ::error, 1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT); JS_DefineFunction(m_cx, globalRootedVal, "deepcopy", ::deepcopy, 1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT); Register("ProfileStart", ::ProfileStart, 1); Register("ProfileStop", ::ProfileStop, 0); runtime->RegisterContext(m_cx); }
/* Create PJS_Context structure */ PJS_Context * PJS_CreateContext(PJS_Runtime *rt) { PJS_Context *pcx; JSObject *obj; Newz(1, pcx, 1, PJS_Context); if (pcx == NULL) { croak("Failed to allocate memory for PJS_Context"); } /* The 'stack size' param here isn't actually the stack size, it's the "chunk size of the stack pool--an obscure memory management tuning knob" http://groups.google.com/group/mozilla.dev.tech.js-engine/browse_thread/thread/be9f404b623acf39 */ pcx->cx = JS_NewContext(rt->rt, 8192); if(pcx->cx == NULL) { Safefree(pcx); croak("Failed to create JSContext"); } JS_SetOptions(pcx->cx, JSOPTION_DONT_REPORT_UNCAUGHT); obj = JS_NewObject(pcx->cx, &global_class, NULL, NULL); if (JS_InitStandardClasses(pcx->cx, obj) == JS_FALSE) { PJS_DestroyContext(pcx); croak("Standard classes not loaded properly."); } pcx->function_by_name = newHV(); pcx->class_by_name = newHV(); pcx->class_by_package = newHV(); if (PJS_InitPerlArrayClass(pcx, obj) == JS_FALSE) { PJS_DestroyContext(pcx); croak("Perl classes not loaded properly."); } if (PJS_InitPerlHashClass(pcx, obj) == JS_FALSE) { PJS_DestroyContext(pcx); croak("Perl classes not loaded properly."); } if (PJS_InitPerlSubClass(pcx, obj) == JS_FALSE) { PJS_DestroyContext(pcx); croak("Perl class 'PerlSub' not loaded properly."); } pcx->rt = rt; /* Add context to context list */ pcx->next = rt->list; rt->list = pcx; JS_SetContextPrivate(pcx->cx, (void *) pcx); return pcx; }
JSInterpreter::JSInterpreter() { /* Create a JS runtime. You always need at least one runtime per process. */ rt = JS_NewRuntime(8 * 1024 * 1024); if (rt == NULL) throw * new std::runtime_error("Can't create JS runtime."); /* * Create a context. You always need a context per thread. * Note that this program is not multi-threaded. */ cx = JS_NewContext(rt, 8192); if (cx == NULL) throw * new std::runtime_error("Can't create js context."); JS_SetOptions(cx, JSOPTION_VAROBJFIX | JSOPTION_JIT | JSOPTION_METHODJIT); JS_SetVersion(cx, JSVERSION_LATEST); JS_SetErrorReporter(cx, reportError); /* * Create the global object in a new compartment. * You always need a global object per context. */ global = JS_NewCompartmentAndGlobalObject(cx, &global_class, NULL); if (global == NULL) throw * new std::runtime_error("Can't create global object."); /* * Populate the global object with the standard JavaScript * function and object classes, such as Object, Array, Date. */ if (!JS_InitStandardClasses(cx, global)) throw * new std::runtime_error("Can't initialise standard classes."); }
int main (int argc, char *argv[]) { JSRuntime *rt; JSObject *glob; int number_failed; Suite *s; SRunner *sr; g_type_init (); rt = JS_NewRuntime(0x100000); cx = JS_NewContext(rt, 0x1000); /* create the global object here */ glob = JS_NewObject(cx, NULL, NULL, NULL); JS_InitStandardClasses(cx, glob); s = gom_value_suite (); sr = srunner_create (s); srunner_run_all (sr, CK_NORMAL); number_failed = srunner_ntests_failed (sr); srunner_free (sr); return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE; }
void registerDefaultClasses(JSContext* cx, JSObject* global) { if (!JS_InitStandardClasses(cx, global)) { js_log("error initializing the standard classes"); } // // Javascript controller (__jsc__) // JSObject *jsc = JS_NewObject(cx, NULL, NULL, NULL); jsval jscVal = OBJECT_TO_JSVAL(jsc); JS_SetProperty(cx, global, "__jsc__", &jscVal); JS_DefineFunction(cx, jsc, "garbageCollect", ScriptingCore::forceGC, 0, JSPROP_READONLY | JSPROP_PERMANENT | JSPROP_ENUMERATE ); JS_DefineFunction(cx, jsc, "dumpRoot", ScriptingCore::dumpRoot, 0, JSPROP_READONLY | JSPROP_PERMANENT | JSPROP_ENUMERATE ); JS_DefineFunction(cx, jsc, "addGCRootObject", ScriptingCore::addRootJS, 1, JSPROP_READONLY | JSPROP_PERMANENT | JSPROP_ENUMERATE ); JS_DefineFunction(cx, jsc, "removeGCRootObject", ScriptingCore::removeRootJS, 1, JSPROP_READONLY | JSPROP_PERMANENT | JSPROP_ENUMERATE ); // register some global functions JS_DefineFunction(cx, global, "require", ScriptingCore::executeScript, 1, JSPROP_READONLY | JSPROP_PERMANENT); JS_DefineFunction(cx, global, "log", ScriptingCore::log, 0, JSPROP_READONLY | JSPROP_PERMANENT); JS_DefineFunction(cx, global, "forceGC", ScriptingCore::forceGC, 0, JSPROP_READONLY | JSPROP_PERMANENT); // should be used only for debug JS_DefineFunction(cx, global, "newGlobal", jsNewGlobal, 1, JSPROP_READONLY | JSPROP_PERMANENT); // register the server socket JS_DefineFunction(cx, glob, "_socketOpen", jsSocketOpen, 1, JSPROP_READONLY | JSPROP_PERMANENT); JS_DefineFunction(cx, glob, "_socketWrite", jsSocketWrite, 1, JSPROP_READONLY | JSPROP_PERMANENT); JS_DefineFunction(cx, glob, "_socketRead", jsSocketRead, 1, JSPROP_READONLY | JSPROP_PERMANENT); JS_DefineFunction(cx, glob, "_socketClose", jsSocketClose, 1, JSPROP_READONLY | JSPROP_PERMANENT); }
// PD_TRACE_DECLARE_FUNCTION ( SDB_SCOPE_INIT, "Scope::init" ) BOOLEAN Scope::init() { BOOLEAN ret = FALSE ; PD_TRACE_ENTRY ( SDB_SCOPE_INIT ); SDB_ASSERT( globalEngine, "Script engine has not been initialized" ); SDB_ASSERT( ! _context && ! _global, "Can't init a scope twice" ); _context = JS_NewContext( globalEngine->_runtime, 1024 * 1024 ) ; VERIFY( _context ); JS_SetOptions( _context, JSOPTION_VAROBJFIX ); JS_SetVersion( _context, JSVERSION_LATEST ); JS_SetErrorReporter( _context, sdbReportError ); _global = JS_NewCompartmentAndGlobalObject( _context, &global_class, NULL ); VERIFY( _global ); VERIFY( JS_InitStandardClasses( _context, _global ) ); VERIFY( InitDbClasses( _context, _global ) ) ; VERIFY ( SDB_OK == evalInitScripts ( this ) ) ; ret = TRUE ; done : PD_TRACE_EXIT ( SDB_SCOPE_INIT ); return ret ; error : goto done ; }
void SetupScripting() { /* Initialize the JS engine -- new/required as of SpiderMonkey 31. */ JS_Init(120000); /* Create a JS runtime. */ rt = JS_NewRuntime(8L * 1024L * 1024L); /* Create a context. */ cx = JS_NewContext(rt, 8192); JS_SetOptions(cx, JSOPTION_VAROBJFIX); JS_SetErrorReporter(cx, reportError); /* Enter a request before running anything in the context */ JSAutoRequest ar(cx); /* Create the global object in a new compartment. */ global = JS_NewGlobalObject(cx, &global_class, NULL); /* Set the context's global */ JSAutoCompartment ac(cx, global); JS_SetGlobalObject(cx, global); /* Populate the global object with the standard globals, like Object and Array. */ JS_InitStandardClasses(cx, global); }
nsresult CentralizedAdminPrefManagerInit() { nsresult rv; JSRuntime *rt; // If autoconfig_cx already created, no need to create it again if (autoconfig_cx) return NS_OK; // We need the XPCONNECT service nsCOMPtr<nsIXPConnect> xpc = do_GetService(nsIXPConnect::GetCID(), &rv); if (NS_FAILED(rv)) { return rv; } // Get the JS RunTime nsCOMPtr<nsIJSRuntimeService> rtsvc = do_GetService("@mozilla.org/js/xpc/RuntimeService;1", &rv); if (NS_SUCCEEDED(rv)) rv = rtsvc->GetRuntime(&rt); if (NS_FAILED(rv)) { NS_ERROR("Couldn't get JS RunTime"); return rv; } // Create a new JS context for autoconfig JS script autoconfig_cx = JS_NewContext(rt, 1024); if (!autoconfig_cx) return NS_ERROR_OUT_OF_MEMORY; JSAutoRequest ar(autoconfig_cx); JS_SetErrorReporter(autoconfig_cx, autoConfigErrorReporter); // Create a new Security Manger and set it for the new JS context nsCOMPtr<nsIXPCSecurityManager> secman = static_cast<nsIXPCSecurityManager*>(new AutoConfigSecMan()); xpc->SetSecurityManagerForJSContext(autoconfig_cx, secman, 0); autoconfig_glob = JS_NewGlobalObject(autoconfig_cx, &global_class, NULL); if (autoconfig_glob) { JSAutoEnterCompartment ac; if(!ac.enter(autoconfig_cx, autoconfig_glob)) return NS_ERROR_FAILURE; if (JS_InitStandardClasses(autoconfig_cx, autoconfig_glob)) { // XPCONNECT enable this JS context rv = xpc->InitClasses(autoconfig_cx, autoconfig_glob); if (NS_SUCCEEDED(rv)) return NS_OK; } } // failue exit... clean up the JS context JS_DestroyContext(autoconfig_cx); autoconfig_cx = nsnull; return NS_ERROR_FAILURE; }
/* Execute a string in its own context (away from Synchronet objects) */ static JSBool js_eval(JSContext *parent_cx, uintN argc, jsval *arglist) { jsval *argv=JS_ARGV(parent_cx, arglist); char* buf; size_t buflen; JSString* str; JSObject* script; JSContext* cx; JSObject* obj; JSErrorReporter reporter; JS_SET_RVAL(cx, arglist, JSVAL_VOID); if(argc<1) return(JS_TRUE); if((str=JS_ValueToString(parent_cx, argv[0]))==NULL) return(JS_FALSE); JSSTRING_TO_MSTRING(parent_cx, str, buf, &buflen); HANDLE_PENDING(parent_cx); if(buf==NULL) return(JS_TRUE); if((cx=JS_NewContext(JS_GetRuntime(parent_cx),JAVASCRIPT_CONTEXT_STACK))==NULL) { free(buf); return(JS_FALSE); } /* Use the error reporter from the parent context */ reporter=JS_SetErrorReporter(parent_cx,NULL); JS_SetErrorReporter(parent_cx,reporter); JS_SetErrorReporter(cx,reporter); /* Use the operation callback from the parent context */ JS_SetContextPrivate(cx, JS_GetContextPrivate(parent_cx)); JS_SetOperationCallback(cx, JS_GetOperationCallback(parent_cx)); if((obj=JS_NewCompartmentAndGlobalObject(cx, &eval_class, NULL))==NULL || !JS_InitStandardClasses(cx,obj)) { JS_DestroyContext(cx); free(buf); return(JS_FALSE); } if((script=JS_CompileScript(cx, obj, buf, buflen, NULL, 0))!=NULL) { jsval rval; JS_ExecuteScript(cx, obj, script, &rval); JS_SET_RVAL(cx, arglist, rval); } free(buf); JS_DestroyContext(cx); return(JS_TRUE); }
void SG_jscore__new_context(SG_context * pCtx, JSContext ** pp_cx, JSObject ** pp_glob, const SG_vhash * pServerConfig) { JSContext * cx = NULL; JSObject * glob = NULL; SG_ASSERT(pCtx!=NULL); SG_NULLARGCHECK_RETURN(pp_cx); if(gpJSCoreGlobalState==NULL) SG_ERR_THROW2_RETURN(SG_ERR_UNINITIALIZED, (pCtx, "jscore has not been initialized")); if (gpJSCoreGlobalState->cb) JS_SetContextCallback(gpJSCoreGlobalState->rt, gpJSCoreGlobalState->cb); cx = JS_NewContext(gpJSCoreGlobalState->rt, 8192); if(cx==NULL) SG_ERR_THROW2_RETURN(SG_ERR_MALLOCFAILED, (pCtx, "Failed to allocate new JS context")); (void)JS_SetContextThread(cx); JS_BeginRequest(cx); JS_SetOptions(cx, JSOPTION_VAROBJFIX); JS_SetVersion(cx, JSVERSION_LATEST); JS_SetContextPrivate(cx, pCtx); glob = JS_NewCompartmentAndGlobalObject(cx, &global_class, NULL); if(glob==NULL) SG_ERR_THROW2(SG_ERR_JS, (pCtx, "Failed to create JavaScript global object for new JSContext.")); if(!JS_InitStandardClasses(cx, glob)) SG_ERR_THROW2(SG_ERR_JS, (pCtx, "JS_InitStandardClasses() failed.")); if (gpJSCoreGlobalState->shell_functions) if (!JS_DefineFunctions(cx, glob, gpJSCoreGlobalState->shell_functions)) SG_ERR_THROW2(SG_ERR_JS, (pCtx, "Failed to install shell functions")); SG_jsglue__set_sg_context(pCtx, cx); SG_ERR_CHECK( SG_jsglue__install_scripting_api(pCtx, cx, glob) ); SG_ERR_CHECK( SG_zing_jsglue__install_scripting_api(pCtx, cx, glob) ); if (! gpJSCoreGlobalState->bSkipModules) { _sg_jscore__install_modules(pCtx, cx, glob, pServerConfig); SG_ERR_CHECK_CURRENT_DISREGARD(SG_ERR_NOTAFILE); } *pp_cx = cx; *pp_glob = glob; return; fail: if (cx) { JS_EndRequest(cx); JS_DestroyContext(cx); } }
int main(int argc, const char *argv[]) { /* JS variables. */ JSRuntime *rt; JSContext *cx; JSObject *global; /* Create a JS runtime. */ rt = JS_NewRuntime(8L * 1024L * 1024L,JS_NO_HELPER_THREADS); if (rt == NULL) return 1; /* Create a context. */ cx = JS_NewContext(rt, 8192); if (cx == NULL) return 1; JS_SetOptions(cx, JSOPTION_VAROBJFIX | JSOPTION_METHODJIT); JS_SetVersion(cx, JSVERSION_LATEST); JS_SetErrorReporter(cx, reportError); /* Create the global object in a new compartment. */ global = JS_NewGlobalObject(cx, &global_class, NULL); if (global == NULL) return 1; /* Populate the global object with the standard globals, like Object and Array. */ if (!JS_InitStandardClasses(cx, global)) return 1; /* Your application code here. This may include JSAPI calls * to create your own custom JavaScript objects and to run scripts. * * The following example code creates a literal JavaScript script, * evaluates it, and prints the result to stdout. * * Errors are conventionally saved in a JSBool variable named ok. */ JS_DefineFunction(cx,global,"print",&js_print,0,0); // execJsFile(cx,"t.js"); // testObj(cx); beforeTest(cx); execJsFile(cx,"t4.js"); test(cx); /* End of your application code */ /* Clean things up and shut down SpiderMonkey. */ JS_DestroyContext(cx); JS_DestroyRuntime(rt); JS_ShutDown(); return 0; }
/* Execute a string in its own context (away from Synchronet objects) */ static JSBool js_eval(JSContext *parent_cx, JSObject *parent_obj, uintN argc, jsval *argv, jsval *rval) { char* buf; size_t buflen; JSString* str; JSScript* script; JSContext* cx; JSObject* obj; JSErrorReporter reporter; #ifndef EVAL_BRANCH_CALLBACK JSBranchCallback callback; #endif if(argc<1) return(JS_TRUE); if((str=JS_ValueToString(parent_cx, argv[0]))==NULL) return(JS_FALSE); if((buf=JS_GetStringBytes(str))==NULL) return(JS_FALSE); buflen=JS_GetStringLength(str); if((cx=JS_NewContext(JS_GetRuntime(parent_cx),JAVASCRIPT_CONTEXT_STACK))==NULL) return(JS_FALSE); /* Use the error reporter from the parent context */ reporter=JS_SetErrorReporter(parent_cx,NULL); JS_SetErrorReporter(parent_cx,reporter); JS_SetErrorReporter(cx,reporter); #ifdef EVAL_BRANCH_CALLBACK JS_SetContextPrivate(cx, JS_GetPrivate(parent_cx, parent_obj)); JS_SetBranchCallback(cx, js_BranchCallback); #else /* Use the branch callback from the parent context */ JS_SetContextPrivate(cx, JS_GetContextPrivate(parent_cx)); callback=JS_SetBranchCallback(parent_cx,NULL); JS_SetBranchCallback(parent_cx, callback); JS_SetBranchCallback(cx, callback); #endif if((obj=JS_NewObject(cx, NULL, NULL, NULL))==NULL || !JS_InitStandardClasses(cx,obj)) { JS_DestroyContext(cx); return(JS_FALSE); } if((script=JS_CompileScript(cx, obj, buf, buflen, NULL, 0))!=NULL) { JS_ExecuteScript(cx, obj, script, rval); JS_DestroyScript(cx, script); } JS_DestroyContext(cx); return(JS_TRUE); }
qq_js_t* qq_js_init() { qq_js_t* h =(qq_js_t*) s_malloc0(sizeof(*h)); h->runtime = JS_NewRuntime(8L*1024L*1024L); h->context = JS_NewContext(h->runtime, 8*1024); JS_SetOptions(h->context, JSOPTION_VAROBJFIX); JS_SetErrorReporter(h->context, report_error); h->global = JS_NewCompartmentAndGlobalObject(h->context, &global_class, NULL); JS_InitStandardClasses(h->context, h->global); return h; }
static void _egueb_script_js_sm_init_global_object(Egueb_Script_Js_Sm_Scripter *thiz) { /* Create a global object and a set of standard objects */ thiz->global = JS_NewCompartmentAndGlobalObject(thiz->cx, &global_class, NULL); /* TODO add the global dom functions: alert... */ JS_DefineFunctions(thiz->cx, thiz->global, global_functions); /* Populate the global object with the standard globals, * like Object and Array. */ JS_InitStandardClasses(thiz->cx, thiz->global); }
/** * gjs_init_context_standard: * @context: a #JSContext * * This function creates a default global object for @context, * and calls JS_InitStandardClasses using it. * * Returns: %TRUE on success, %FALSE otherwise */ gboolean gjs_init_context_standard (JSContext *context) { JSObject *global; global = JS_NewCompartmentAndGlobalObject(context, &global_class, NULL); if (global == NULL) return FALSE; if (!JS_InitStandardClasses(context, global)) return FALSE; return TRUE; }
ScriptInterface_impl::ScriptInterface_impl(const char* nativeScopeName, const shared_ptr<ScriptRuntime>& runtime) : m_runtime(runtime), m_glob(runtime->m_rt), m_nativeScope(runtime->m_rt) { bool ok; m_cx = JS_NewContext(m_runtime->m_rt, STACK_CHUNK_SIZE); ENSURE(m_cx); JS_SetOffthreadIonCompilationEnabled(m_runtime->m_rt, true); // For GC debugging: // JS_SetGCZeal(m_cx, 2, JS_DEFAULT_ZEAL_FREQ); JS_SetContextPrivate(m_cx, NULL); JS_SetErrorReporter(m_runtime->m_rt, ErrorReporter); JS_SetGlobalJitCompilerOption(m_runtime->m_rt, JSJITCOMPILER_ION_ENABLE, 1); JS_SetGlobalJitCompilerOption(m_runtime->m_rt, JSJITCOMPILER_BASELINE_ENABLE, 1); JS::RuntimeOptionsRef(m_cx).setExtraWarnings(1) .setWerror(0) .setVarObjFix(1) .setStrictMode(1); JS::CompartmentOptions opt; opt.setVersion(JSVERSION_LATEST); // Keep JIT code during non-shrinking GCs. This brings a quite big performance improvement. opt.setPreserveJitCode(true); JSAutoRequest rq(m_cx); JS::RootedObject globalRootedVal(m_cx, JS_NewGlobalObject(m_cx, &global_class, NULL, JS::OnNewGlobalHookOption::FireOnNewGlobalHook, opt)); m_comp = JS_EnterCompartment(m_cx, globalRootedVal); ok = JS_InitStandardClasses(m_cx, globalRootedVal); ENSURE(ok); m_glob = globalRootedVal.get(); JS_DefineProperty(m_cx, m_glob, "global", globalRootedVal, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT); m_nativeScope = JS_DefineObject(m_cx, m_glob, nativeScopeName, nullptr, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT); JS_DefineFunction(m_cx, globalRootedVal, "print", ::print, 0, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT); JS_DefineFunction(m_cx, globalRootedVal, "log", ::logmsg, 1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT); JS_DefineFunction(m_cx, globalRootedVal, "warn", ::warn, 1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT); JS_DefineFunction(m_cx, globalRootedVal, "error", ::error, 1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT); JS_DefineFunction(m_cx, globalRootedVal, "deepcopy", ::deepcopy, 1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT); Register("ProfileStart", ::ProfileStart, 1); Register("ProfileStop", ::ProfileStop, 0); Register("ProfileAttribute", ::ProfileAttribute, 1); runtime->RegisterContext(m_cx); }
static JSBool evalcx(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) { JSString *str; JSObject *sandbox; JSContext *subcx; const jschar *src; size_t srclen; JSBool ret = JS_FALSE; char *name = NULL; sandbox = NULL; if(!JS_ConvertArguments(cx, argc, argv, "S / o", &str, &sandbox)) { return JS_FALSE; } subcx = JS_NewContext(JS_GetRuntime(cx), 8L * 1024L); if(!subcx) { JS_ReportOutOfMemory(cx); return JS_FALSE; } SETUP_REQUEST(subcx); src = JS_GetStringChars(str); srclen = JS_GetStringLength(str); if(!sandbox) { sandbox = JS_NewObject(subcx, NULL, NULL, NULL); if(!sandbox || !JS_InitStandardClasses(subcx, sandbox)) { goto done; } } if(argc > 2) { name = enc_string(cx, argv[2], NULL); } if(srclen == 0) { *rval = OBJECT_TO_JSVAL(sandbox); } else { JS_EvaluateUCScript(subcx, sandbox, src, srclen, name, 1, rval); } ret = JS_TRUE; done: if(name) JS_free(cx, name); FINISH_REQUEST(subcx); JS_DestroyContext(subcx); return ret; }
// Initialize PAC parser. // // - Initializes JavaScript engine, // - Exports dns_functions (defined above) to JavaScript context. // - Sets error reporting function to print_jserror, // - Evaluates JavaScript code in pacUtils variable defined in pac_utils.h. int // 0 (=Failure) or 1 (=Success) pacparser_init() { jsval rval; char *error_prefix = "pacparser.c: pacparser_init:"; // Initialize JS engine if (!(rt = JS_NewRuntime(8L * 1024L * 1024L)) || !(cx = JS_NewContext(rt, 8192)) || !(global = JS_NewObject(cx, &global_class, NULL, NULL)) || !JS_InitStandardClasses(cx, global)) { print_error("%s %s\n", error_prefix, "Could not initialize JavaScript " "runtime."); return 0; } JS_SetErrorReporter(cx, print_jserror); // Export our functions to Javascript engine if (!JS_DefineFunction(cx, global, "dnsResolve", dns_resolve, 1, 0)) { print_error("%s %s\n", error_prefix, "Could not define dnsResolve in JS context."); return 0; } if (!JS_DefineFunction(cx, global, "myIpAddress", my_ip, 0, 0)) { print_error("%s %s\n", error_prefix, "Could not define myIpAddress in JS context."); return 0; } if (!JS_DefineFunction(cx, global, "dnsResolveEx", dns_resolve_ex, 1, 0)) { print_error("%s %s\n", error_prefix, "Could not define dnsResolveEx in JS context."); return 0; } if (!JS_DefineFunction(cx, global, "myIpAddressEx", my_ip_ex, 0, 0)) { print_error("%s %s\n", error_prefix, "Could not define myIpAddressEx in JS context."); return 0; } // Evaluate pacUtils. Utility functions required to parse pac files. if (!JS_EvaluateScript(cx, // JS engine context global, // global object pacUtils, // this is defined in pac_utils.h strlen(pacUtils), NULL, // filename (NULL in this case) 1, // line number, used for reporting. &rval)) { print_error("%s %s\n", error_prefix, "Could not evaluate pacUtils defined in pac_utils.h."); return 0; } if (_debug()) print_error("DEBUG: Pacparser Initalized.\n"); return 1; }
bool CompileFile(const std::string &inputFilePath, const std::string &outputFilePath) { bool result = false; std::string ofp; if (!outputFilePath.empty()) { ofp = outputFilePath; } else { ofp = RemoveFileExt(inputFilePath) + BYTE_CODE_FILE_EXT; } std::cout << "Input file: " << inputFilePath << std::endl; JSRuntime * runtime = JS_NewRuntime(10 * 1024 * 1024, JS_NO_HELPER_THREADS); JSContext *context = JS_NewContext(runtime, 10240); JS_SetOptions(context, JSOPTION_TYPE_INFERENCE); JS_SetVersion(context, JSVERSION_LATEST); JS_SetOptions(context, JS_GetOptions(context) & ~JSOPTION_METHODJIT); JS_SetOptions(context, JS_GetOptions(context) & ~JSOPTION_METHODJIT_ALWAYS); JSObject* global = JS_NewGlobalObject(context, &GlobalClass, NULL); JS_SetErrorReporter(context, &ReportError); if (JS_InitStandardClasses(context, global)) { JS::CompileOptions options(context); options.setUTF8(true); options.setSourcePolicy(JS::CompileOptions::NO_SOURCE); js::RootedObject rootedObject(context, global); std::cout << "Compiling ..." << std::endl; JSScript *script = JS::Compile(context, rootedObject, options, inputFilePath.c_str()); if (script) { void *data = NULL; uint32_t length = 0; std::cout << "Encoding ..." << std::endl; data = JS_EncodeScript(context, script, &length); if (data) { if (WriteFile(ofp, data, length)) { std::cout << "Done! " << "Output file: " << ofp << std::endl; result = true; } } } } if (context) { JS_DestroyContext(context); context = NULL; } if (runtime) { JS_DestroyRuntime(runtime); runtime = NULL; } return result; }
static JSBool evalcx(JSContext *cx, uintN argc, jsval* vp) { jsval* argv = JS_ARGV(cx, vp); JSString *str; JSObject *sandbox; JSContext *subcx; const jschar *src; size_t srclen; jsval rval; JSBool ret = JS_FALSE; sandbox = NULL; if(!JS_ConvertArguments(cx, argc, argv, "S / o", &str, &sandbox)) { return JS_FALSE; } subcx = JS_NewContext(JS_GetRuntime(cx), 8L * 1024L); if(!subcx) { JS_ReportOutOfMemory(cx); return JS_FALSE; } SETUP_REQUEST(subcx); src = JS_GetStringChars(str); srclen = JS_GetStringLength(str); if(!sandbox) { sandbox = JS_NewObject(subcx, NULL, NULL, NULL); if(!sandbox || !JS_InitStandardClasses(subcx, sandbox)) { goto done; } } if(srclen == 0) { JS_SET_RVAL(cx, vp, OBJECT_TO_JSVAL(sandbox)); } else { JS_EvaluateUCScript(subcx, sandbox, src, srclen, NULL, 0, &rval); JS_SET_RVAL(cx, vp, rval); } ret = JS_TRUE; done: FINISH_REQUEST(subcx); JS_DestroyContext(subcx); return ret; }
static JSObject * smjs_get_global_object(void) { JSObject *jsobj; assert(smjs_ctx); jsobj = JS_NewCompartmentAndGlobalObject(smjs_ctx, (JSClass *) &global_class, NULL); if (!jsobj) return NULL; JS_InitStandardClasses(smjs_ctx, jsobj); return jsobj; }
void initialize_js(struct flim *flim) { flim->js_runtime = JS_NewRuntime(8L * 1024L * 1024L); flim->js_context = JS_NewContext(flim->js_runtime, 8192); JS_SetOptions(flim->js_context, JSOPTION_VAROBJFIX | JSOPTION_METHODJIT); JS_SetVersion(flim->js_context, JSVERSION_LATEST); JS_SetErrorReporter(flim->js_context, report_error); flim->global = JS_NewCompartmentAndGlobalObject( flim->js_context, &global_class, NULL); JS_InitStandardClasses(flim->js_context, flim->global); JS_DefineFunctions(flim->js_context, flim->global, js_functions); eval_file("runtime/flim.js"); eval_file("runtime/underscore.js"); }
lwqq_js_t* lwqq_js_init() { lwqq_js_t* h = s_malloc0(sizeof(*h)); h->runtime = JS_NewRuntime(8L*1024L*1024L); h->context = JS_NewContext(h->runtime, 16*1024); JS_SetOptions(h->context, JSOPTION_VAROBJFIX|JSOPTION_COMPILE_N_GO|JSOPTION_NO_SCRIPT_RVAL); JS_SetErrorReporter(h->context, report_error); #ifdef MOZJS_185 h->global = JS_NewCompartmentAndGlobalObject(h->context, &global_class, NULL); #else h->global = JS_NewGlobalObject(h->context,&global_class,NULL); #endif JS_InitStandardClasses(h->context, h->global); return h; }
static ctxStore *ctxs_new(pxPAC *pac) { JSObject *global = NULL; jsval rval; // Create the basic context ctxStore *self = px_malloc0(sizeof(ctxStore)); // Setup Javascript global class self->cls = px_malloc0(sizeof(JSClass)); self->cls->name = "global"; self->cls->flags = 0; self->cls->addProperty = JS_PropertyStub; self->cls->delProperty = JS_PropertyStub; self->cls->getProperty = JS_PropertyStub; self->cls->setProperty = JS_PropertyStub; self->cls->enumerate = JS_EnumerateStub; self->cls->resolve = JS_ResolveStub; self->cls->convert = JS_ConvertStub; self->cls->finalize = JS_FinalizeStub; // Initialize Javascript runtime environment if (!(self->run = JS_NewRuntime(1024 * 1024))) goto error; if (!(self->ctx = JS_NewContext(self->run, 1024 * 1024))) goto error; if (!(global = JS_NewObject(self->ctx, self->cls, NULL, NULL))) goto error; JS_InitStandardClasses(self->ctx, global); // Define Javascript functions JS_DefineFunction(self->ctx, global, "dnsResolve", dnsResolve, 1, 0); JS_DefineFunction(self->ctx, global, "myIpAddress", myIpAddress, 0, 0); JS_EvaluateScript(self->ctx, global, JAVASCRIPT_ROUTINES, strlen(JAVASCRIPT_ROUTINES), "pacutils.js", 0, &rval); // Add PAC to the environment JS_EvaluateScript(self->ctx, global, px_pac_to_string(pac), strlen(px_pac_to_string(pac)), px_url_to_string((pxURL *) px_pac_get_url(pac)), 0, &rval); // Save the pac self->pac = px_strdup(px_pac_to_string(pac)); return self; error: ctxs_free(self); return NULL; }
JSObject * JSAPITest::createGlobal(JSPrincipals *principals) { /* Create the global object. */ global = JS_NewGlobalObject(cx, getGlobalClass(), principals); if (!global) return NULL; JS_AddNamedObjectRoot(cx, &global, "test-global"); JS::HandleObject globalHandle = JS::HandleObject::fromMarkedLocation(&global); JSAutoCompartment ac(cx, globalHandle); /* Populate the global object with the standard globals, like Object and Array. */ if (!JS_InitStandardClasses(cx, globalHandle)) return NULL; return global; }