void sm_stop(spidermonkey_vm *vm) { begin_request(vm); spidermonkey_state *state = (spidermonkey_state *) JS_GetContextPrivate(vm->context); state->terminate = 1; JS_SetContextPrivate(vm->context, state); //Wait for any executing function to stop //before beginning to free up any memory. while (JS_IsRunning(vm->context)) { sleep(1); } end_request(vm); //Now we should be free to proceed with //freeing up memory without worrying about //crashing the VM. if (state != NULL) { if (state->error != NULL) { free_error(state); } driver_free(state); } JS_SetContextPrivate(vm->context, NULL); JS_DestroyContext(vm->context); JS_DestroyRuntime(vm->runtime); driver_free(vm); }
JsParser::~JsParser() { /** The world is over */ // JS_DestroyContext(js_context); JS_DestroyRuntime(js_runtime); JS_ShutDown(); func("JsParser::close()"); }
void lwqq_js_close(lwqq_js_t* js) { JS_DestroyContext(js->context); JS_DestroyRuntime(js->runtime); JS_ShutDown(); s_free(js); }
/** * gjs_runtime_destroy: * @runtime: a #JSRuntime * * Calls JS_DestroyRuntime() on runtime and frees data allocated by * gjs_runtime_init(); these are unified into a single call because we * need to order things so that the allocated data is cleaned up * after JS_DestroyRuntime(). We might have finalizers run by * JS_DestroyRuntime() that rely on the information stored in the data, * such as the dynamic class structs. * * This should only be called by GJS, not by applications. */ void gjs_runtime_destroy(JSRuntime *runtime) { RuntimeData *rd; void *key; void *value; rd = JS_GetRuntimePrivate(runtime); if (rd->context_stack != NULL || rd->current_frame.depth != 0) gjs_fatal("gjs_runtime_destroy() called during gjs_push_context()"); gjs_debug(GJS_DEBUG_CONTEXT, "Destroying JS runtime"); JS_DestroyRuntime(runtime); gjs_debug(GJS_DEBUG_CONTEXT, "Destroying any remaining dataset items on runtime"); while (gjs_g_hash_table_remove_one(rd->dynamic_classes, &key, &value)) { JSClass *clasp = value; gjs_debug(GJS_DEBUG_GREPO, "Finalizing dynamic class '%s'", clasp->name); g_free( (char*) clasp->name); /* we know we malloc'd the char* even though it's const */ g_slice_free(DynamicJSClass, (DynamicJSClass*) clasp); } g_hash_table_destroy(rd->dynamic_classes); g_slice_free(RuntimeData, rd); }
int main(int argc, const char *argv[]) { /* Initialize the JS engine -- new/required as of SpiderMonkey 31. */ /*if (!JS_Init()) return 1;*/ /* Create a JS runtime. */ JSRuntime *rt = JS_NewRuntime(8L * 1024L * 1024L, JS_NO_HELPER_THREADS); if (!rt) return 1; /* Create a context. */ JSContext *cx = JS_NewContext(rt, 8192); if (!cx) return 1; JS_SetOptions(cx, JSOPTION_VAROBJFIX); JS_SetErrorReporter(cx, reportError); int status = run(cx); JS_DestroyContext(cx); JS_DestroyRuntime(rt); /* Shut down the JS engine. */ JS_ShutDown(); return status; }
static void _egueb_script_js_sm_scripter_free(void *prv) { Egueb_Script_Js_Sm_Scripter *thiz = prv; JS_DestroyContext(thiz->cx); JS_DestroyRuntime(thiz->rt); free(thiz); }
void TearDownScripting(){ JS_DestroyContext(cx); JS_DestroyRuntime(rt); /* Shut down the JS engine. */ JS_ShutDown(); }
void JetpackChild::CleanUp() { ClearReceivers(); JS_DestroyContext(mCx); JS_DestroyRuntime(mRuntime); JS_ShutDown(); }
void qq_js_close(qq_js_t* js) { JS_DestroyContext(js->context); JS_DestroyRuntime(js->runtime); JS_ShutDown(); /*something wrong here*/ //s_free(js); }
void Runtime_dealloc(Runtime* self) { if(self->rt != NULL) { JS_DestroyRuntime(self->rt); } }
void cleanup_smjs(struct module *module) { if (!smjs_ctx) return; JS_DestroyContext(smjs_ctx); JS_DestroyRuntime(smjs_rt); }
void SpidermonkeyDestroy() {// begin SpidermonkeyDestroy #ifdef ADM_JS_THREADSAFE JS_SetContextThread(g_pCx); #endif JS_DestroyContext(g_pCx); JS_DestroyRuntime(g_pRt); }// end SpidermonkeyDestroy
void TerminateSpiderMonkey(JSContext * context) { if (terminated) return; JS_DestroyContext(context); JS_DestroyRuntime(runtime); JS_ShutDown(); terminated = true; }
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; }
static void ctxs_free(ctxStore *self) { if (!self) return; if (self->ctx) JS_DestroyContext(self->ctx); if (self->run) JS_DestroyRuntime(self->run); if (self->cls) px_free(self->cls); px_free(self->pac); px_free(self); }
short exitProgram(JSContext *cx){ //To be called at the very end - Shutdown the whole application if(cx) JS_DestroyContext(cx); JS_DestroyRuntime(runtime); TTF_Quit(); SDL_DestroyRenderer(renderer); SDL_Quit(); JS_ShutDown(); return 0; }
MozJSImplScope::MozRuntime::~MozRuntime() { JS_DestroyContext(_context); JS_DestroyRuntime(_runtime); if (_thread) { invariant(PR_GetCurrentThread() == _thread); PR_DestroyFakeThread(_thread); PR_BindThread(nullptr); } }
void DLLCALL jsrt_Release(JSRuntime *rt) { list_node_t *node; pthread_mutex_lock(&jsrt_mutex); node = listFindNode(&rt_list, rt, 0); if(node) listRemoveNode(&rt_list, node, FALSE); JS_DestroyRuntime(rt); pthread_mutex_unlock(&jsrt_mutex); }
MonkeyEngine::~MonkeyEngine() { if (cx != NULL) { JS_DestroyContext(cx); } if (rt != NULL) { JS_DestroyRuntime(rt); } }
JsExecutionContext::~JsExecutionContext() { JS_SetContextThread(cx); JS_GC(cx); JS_BeginRequest(cx); JS_ClearScope(cx, obj); JS_EndRequest(cx); JS_ClearContextThread(cx); JS_DestroyContext(cx); JS_DestroyRuntime(rt); }
~JSRuntimeWrapper() { MOZ_COUNT_DTOR(JSRuntimeWrapper); if (mContext) { JS_DestroyContext(mContext); } if (mRuntime) { JS_DestroyRuntime(mRuntime); } }
static void deallocate(JohnsonRuntime* runtime) { JS_RemoveRoot(johnson_get_current_context(runtime), &(runtime->global)); JSContext *context; JSContext *iterator = NULL; while ((context = JS_ContextIterator(runtime->js, &iterator)) != NULL) JS_DestroyContext(context); JS_DestroyRuntime(runtime->js); free(runtime); }
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; }
/* XXX FIXME: Iargv/Ienviron are now associated with running. */ rpmjs rpmjsNew(char ** av, uint32_t flags) { rpmjs js = #ifdef NOTYET (flags & 0x80000000) ? rpmjsI() : #endif rpmjsGetPool(_rpmjsPool); JSI_t I = NULL; #if defined(WITH_GPSEE) #if defined(XXX_GPSEE_DEBUGGER) /* XXX js->jsdc? */ JSDContext *jsdc; #endif if (flags == 0) flags = _rpmjs_options; if (F_ISSET(flags, NOUTF8) || getenv("GPSEE_NO_UTF8_C_STRINGS")) { JS_DestroyRuntime(JS_NewRuntime(1024)); putenv((char *) "GPSEE_NO_UTF8_C_STRINGS=1"); } /* XXX FIXME: js->Iargv/js->Ienviron for use by rpmjsRunFile() */ I = gpsee_createInterpreter(); #if defined(XXX_GPSEE_DEBUGGER) js->jsdc = gpsee_initDebugger(I->cx, I->realm, DEBUGGER_JS); #endif #ifdef NOTYET /* FIXME: dig out where NOCACHE has moved. */ if (F_ISSET(flags, NOCACHE)) I->useCompilerCache = 0; #endif if (F_ISSET(flags, NOWARN)) { gpsee_runtime_t * grt = JS_GetRuntimePrivate(JS_GetRuntime(I->cx)); grt->errorReport |= er_noWarnings; } JS_SetOptions(I->cx, (flags & 0xffff)); #if defined(JS_GC_ZEAL) JS_SetGCZeal(I->cx, _rpmjs_zeal); #endif #endif /* WITH_GPSEE */ js->flags = flags; js->I = I; return rpmjsLink(js); }
void SG_jscore__shutdown(SG_context * pCtx) { if(gpJSCoreGlobalState!=NULL) { if (gpJSCoreGlobalState->rt) JS_DestroyRuntime(gpJSCoreGlobalState->rt); JS_ShutDown(); SG_PATHNAME_NULLFREE(pCtx, gpJSCoreGlobalState->pPathToDispatchDotJS); SG_PATHNAME_NULLFREE(pCtx, gpJSCoreGlobalState->pPathToCore); SG_PATHNAME_NULLFREE(pCtx, gpJSCoreGlobalState->pPathToModules); SG_RBTREE_NULLFREE_WITH_ASSOC(pCtx, gpJSCoreGlobalState->prbJSMutexes, _free_js_mutex_cb); SG_NULLFREE(pCtx, gpJSCoreGlobalState); } }
static void JsCleanup(void *arg) { jsEnv *jsEnvPtr = arg; if (jsEnvPtr != NULL) { JS_DestroyContext(jsEnvPtr->context); JS_DestroyRuntime(jsEnvPtr->runtime); JS_ShutDown(); Ns_Log(Debug, "JsCleanup: %p", jsEnvPtr); ns_free(jsEnvPtr); } }
// Destroys JavaSctipt Engine. void pacparser_cleanup() { // Reinitliaze config variables. myip = NULL; if (cx) { JS_DestroyContext(cx); cx = NULL; } if (rt) { JS_DestroyRuntime(rt); rt = NULL; } if (!cx && !rt) JS_ShutDown(); global = NULL; if (_debug()) print_error("DEBUG: Pacparser destroyed.\n"); }
void TraceMonkeyEngine::quit() { Logging::log(Logging::DEBUG, "TraceMonkeyEngine::quit\r\n"); // Clean up our internal wrappers globalValue.reset(); /* Cleanup. */ JS_DestroyContext(context); context = NULL; JS_DestroyRuntime(runtime); runtime = NULL; // JS_ShutDown(); XXX Should be done only when NO runtimes remain, for final cleanup, as we are quitting probably }
bool round_js_sm_engine_destroy(RoundJavaScriptEngine* engine) { if (!engine) return false; if (engine->cx) { JS_DestroyContext(engine->cx); } if (engine->rt) { JS_DestroyRuntime(engine->rt); } JS_ShutDown(); return true; }
void Engine::cleanup() { while ( !m_contexts.empty() ) { JSContext *cx = m_contexts.top(); m_contexts.pop(); JS_ClearContextThread(cx); JS_DestroyContext(cx); } if ( m_runtime!=NULL ) { JS_DestroyRuntime(m_runtime); m_runtime = NULL; } JS_ShutDown(); }