/*! @decl void create(void|int version, void|int stacksize)
*!
*! Creates an instance of the Context class.
*!
*! @param version
*! This context will be initially made compatible with the specified
*! JavaScript version. The following constants are accepted as the value
*! of this parameter:
*!
*! @dl
*! @item JSVERSION_1_0
*! JavaScript v1.0
*! @item JSVERSION_1_1
*! JavaScript v1.1
*! @item JSVERSION_1_2
*! JavaScript v1.2
*! @item JSVERSION_1_3
*! JavaScript v1.3 (ECMA)
*! @item JSVERSION_1_4
*! JavaScript v1.4 (ECMA)
*! @item JSVERSION_1_5
*! JavaScript v1.5 (ECMA)
*! @enddl
*!
*! The default value is @b{JSVERSION_1_5@}
*!
*! @param stacksize
*! Sets the size of the private stack for this context. Value given in
*! bytes. Defaults to 8192.
*/
static void ctx_create(INT32 args)
{
INT32 version = JSVERSION_1_5;
INT32 stacksize = 8192;
switch(args) {
case 2:
get_all_args("create", args, "%i%i", &version, &stacksize);
break;
case 1:
get_all_args("create", args, "%i", &version);
break;
}
THIS->ctx = JS_NewContext(smrt, stacksize);
if (!THIS->ctx)
Pike_error("Could not create a new context\n");
if (!init_globals(THIS->ctx))
Pike_error("Could not initialize the new context.\n");
if (!JS_DefineFunctions(THIS->ctx, global, output_functions))
Pike_error("Could not populate the global object with output functions\n");
JS_SetVersion(THIS->ctx, version);
/* create some privacy for us */
if (!JS_SetPrivate(THIS->ctx, global, THIS))
Pike_error("Could not set the private storage for the global object\n");
pop_n_elems(args);
}
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.");
}
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");
}
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
}
// 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 ;
}
ContextCallback(JSContext *cx, uintN contextOp)
{
if (contextOp == JSCONTEXT_NEW) {
JS_SetErrorReporter(cx, my_ErrorReporter);
JS_SetVersion(cx, JSVERSION_LATEST);
}
return JS_TRUE;
}
Version(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
if (argc > 0 && JSVAL_IS_INT(argv[0]))
*rval = INT_TO_JSVAL(JS_SetVersion(cx, JSVersion(JSVAL_TO_INT(argv[0]))));
else
*rval = INT_TO_JSVAL(JS_GetVersion(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;
}
static void ctx_compile(INT32 args)
{
JSScript *compiled;
struct pike_string *script;
jsval rval;
INT32 version = -1, oldversion = -1;
if (!THIS->ctx) {
pop_n_elems(args);
push_int(0);
return;
}
switch(args) {
case 2:
get_all_args("compile", args, "%S%i", &script, &version);
break;
case 1:
get_all_args("compile", args, "%S", &script);
break;
default:
Pike_error("Not enough arguments\n");
}
if (version != -1)
oldversion = JS_SetVersion(THIS->ctx, version);
/* TODO: filename should indicate the actual location of the script */
compiled = JS_CompileScript(THIS->ctx, global,
script->str, script->len,
"Caudium/js", &rval);
if (oldversion != -1)
JS_SetVersion(THIS->ctx, oldversion);
pop_n_elems(args);
if (!compiled) {
push_int(-1);
return;
}
}
nsresult
nsInProcessTabChildGlobal::InitTabChildGlobal()
{
nsCOMPtr<nsIJSRuntimeService> runtimeSvc =
do_GetService("@mozilla.org/js/xpc/RuntimeService;1");
NS_ENSURE_STATE(runtimeSvc);
JSRuntime* rt = nsnull;
runtimeSvc->GetRuntime(&rt);
NS_ENSURE_STATE(rt);
JSContext* cx = JS_NewContext(rt, 8192);
NS_ENSURE_STATE(cx);
mCx = cx;
nsContentUtils::XPConnect()->SetSecurityManagerForJSContext(cx, nsContentUtils::GetSecurityManager(), 0);
nsContentUtils::GetSecurityManager()->GetSystemPrincipal(getter_AddRefs(mPrincipal));
JS_SetNativeStackQuota(cx, 128 * sizeof(size_t) * 1024);
JS_SetOptions(cx, JS_GetOptions(cx) | JSOPTION_JIT | JSOPTION_PRIVATE_IS_NSISUPPORTS);
JS_SetVersion(cx, JSVERSION_LATEST);
JS_SetErrorReporter(cx, ContentScriptErrorReporter);
xpc_LocalizeContext(cx);
JSAutoRequest ar(cx);
nsIXPConnect* xpc = nsContentUtils::XPConnect();
const PRUint32 flags = nsIXPConnect::INIT_JS_STANDARD_CLASSES |
/*nsIXPConnect::OMIT_COMPONENTS_OBJECT ? |*/
nsIXPConnect::FLAG_SYSTEM_GLOBAL_OBJECT;
nsISupports* scopeSupports =
NS_ISUPPORTS_CAST(nsIDOMEventTarget*, this);
JS_SetContextPrivate(cx, scopeSupports);
nsresult rv =
xpc->InitClassesWithNewWrappedGlobal(cx, scopeSupports,
NS_GET_IID(nsISupports),
GetPrincipal(), nsnull,
flags, getter_AddRefs(mGlobal));
NS_ENSURE_SUCCESS(rv, false);
JSObject* global = nsnull;
rv = mGlobal->GetJSObject(&global);
NS_ENSURE_SUCCESS(rv, false);
JS_SetGlobalObject(cx, global);
DidCreateCx();
return NS_OK;
}
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;
}
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");
}
bool
JetpackChild::Init(base::ProcessHandle aParentProcessHandle,
MessageLoop* aIOLoop,
IPC::Channel* aChannel)
{
if (!Open(aChannel, aParentProcessHandle, aIOLoop))
return false;
if (!(mRuntime = JS_NewRuntime(32L * 1024L * 1024L)) ||
!(mCx = JS_NewContext(mRuntime, 8192)))
return false;
JS_SetVersion(mCx, JSVERSION_LATEST);
JS_SetOptions(mCx, JS_GetOptions(mCx) |
JSOPTION_DONT_REPORT_UNCAUGHT |
JSOPTION_ATLINE |
JSOPTION_JIT);
JS_SetErrorReporter(mCx, ReportError);
{
JSAutoRequest request(mCx);
JS_SetContextPrivate(mCx, this);
JSObject* implGlobal =
JS_NewCompartmentAndGlobalObject(mCx, const_cast<JSClass*>(&sGlobalClass), NULL);
if (!implGlobal)
return false;
JSAutoEnterCompartment ac;
if (!ac.enter(mCx, implGlobal))
return false;
jsval ctypes;
if (!JS_InitStandardClasses(mCx, implGlobal) ||
#ifdef BUILD_CTYPES
!JS_InitCTypesClass(mCx, implGlobal) ||
!JS_GetProperty(mCx, implGlobal, "ctypes", &ctypes) ||
!JS_SetCTypesCallbacks(mCx, JSVAL_TO_OBJECT(ctypes), &sCallbacks) ||
#endif
!JS_DefineFunctions(mCx, implGlobal,
const_cast<JSFunctionSpec*>(sImplMethods)))
return false;
}
return true;
}
RuntimeContext::RuntimeContext(SharedPtr<Runtime>& runtime, int size) : _runtime(runtime), _context(NULL)
{
_context = JS_NewContext(*runtime, size);
if ( _context != NULL )
{
JS_SetErrorReporter(_context, &RuntimeContext::errorReporter);
JS_BeginRequest(_context);
JS_SetOptions(_context, JSOPTION_XML /* | JSOPTION_VAROBJFIX */);
JS_SetVersion(_context, JSVERSION_1_8);
//if ( m_configuration->GetBranchLimit() > 0 )
//{
// JS_SetBranchCallback(cx, Engine::BranchCallback);
// JS_ToggleOptions(cx, JSOPTION_NATIVE_BRANCH_CALLBACK);
//}
JS_EndRequest(_context);
}
}
JSContext * InitializeSpiderMonkey() {
runtime = JS_NewRuntime(jsRuntimeSize);
JSContext * context = JS_NewContext(runtime, jsStackSize);
JS_SetOptions(context,
JSOPTION_VAROBJFIX |
JSOPTION_JIT |
JSOPTION_METHODJIT |
JSOPTION_COMPILE_N_GO
);
JS_SetVersion(context, JSVERSION_LATEST);
JS_SetErrorReporter(context, reportError);
return context;
}
ScriptingCore::ScriptingCore() {
/* Create the JSRuntime. */
this->mJSRuntime = JS_NewRuntime(8L * 1024L * 1024L);
if (this->mJSRuntime == NULL) {
LOG_D("Could not create JSRuntime!");
}
/* Create the JSContext. */
this->mJSContext = JS_NewContext(this->mJSRuntime, 8192);
if (this->mJSContext == NULL) {
LOG_D("Could not create JSContext!");
}
/* Set flags. */
JS_SetOptions(this->mJSContext, JSOPTION_VAROBJFIX);
JS_SetVersion(this->mJSContext, JSVERSION_LATEST);
JS_SetErrorReporter(this->mJSContext, reportError);
/* Create the global object in a new compartment. */
this->mGlobal = JS_NewCompartmentAndGlobalObject(this->mJSContext, &global_class, NULL);
if (this->mGlobal == NULL) {
LOG_D("Could not create global!");
}
if (!JS_InitStandardClasses(this->mJSContext, this->mGlobal)) {
LOG_D("Could not initialize standard classes!");
}
/* Create the AndEngine namespace. */
JSObject* andengineNamespace = JS_NewObject(this->mJSContext, NULL, NULL, NULL);
jsval andengineNamespaceVal = OBJECT_TO_JSVAL(andengineNamespace);
JS_SetProperty(this->mJSContext, this->mGlobal, "andengine", &andengineNamespaceVal);
/* Register AndEngine classes. */
S_Entity::jsCreateClass(this->mJSContext, andengineNamespace, "Entity");
// S_CCSize::jsCreateClass(this->mJSContext, andengineNamespace, "Size");
// S_CCRect::jsCreateClass(this->mJSContext, andengineNamespace, "Rect");
/* Register some global functions. */
// JS_DefineFunction(this->mJSContext, andengineNamespace, "log", ScriptingCore::log, 0, JSPROP_READONLY | JSPROP_PERMANENT);
// JS_DefineFunction(this->mJSContext, andengineNamespace, "forceGC", ScriptingCore::forceGC, 0, JSPROP_READONLY | JSPROP_PERMANENT);
}
JSObject*
Core_initialize (JSContext *cx, const char* path)
{
JS_BeginRequest(cx);
JS_SetOptions(cx, JSOPTION_VAROBJFIX|JSOPTION_JIT|JSOPTION_XML);
JS_SetVersion(cx, JS_StringToVersion("1.8"));
JSObject* object = JS_NewObject(cx, &Core_class, NULL, NULL);
if (object && JS_InitStandardClasses(cx, object)) {
JS_DefineFunctions(cx, object, Core_methods);
JS_EnterLocalRootScope(cx);
// Properties
jsval property;
std::string rootPath = __Core_getRootPath(cx, path);
jsval paths[] = {
STRING_TO_JSVAL(JS_NewString(cx, JS_strdup(cx, rootPath.c_str()), rootPath.length())),
STRING_TO_JSVAL(JS_NewString(cx, JS_strdup(cx, __LJS_LIBRARY_PATH__), strlen(__LJS_LIBRARY_PATH__)))
};
property = OBJECT_TO_JSVAL(JS_NewArrayObject(cx, 2, paths));
JS_SetProperty(cx, object, "__PATH__", &property);
property = STRING_TO_JSVAL(JS_NewString(cx, JS_strdup(cx, __LJS_VERSION__), strlen(__LJS_VERSION__)));
JS_SetProperty(cx, object, "__VERSION__", &property);
property = OBJECT_TO_JSVAL(object);
JS_SetProperty(cx, object, "Program", &property);
JS_LeaveLocalRootScope(cx);
JS_EndRequest(cx);
if (__Core_include(cx, __LJS_LIBRARY_PATH__ "/Core")) {
return object;
}
}
return NULL;
}
nsresult Init()
{
mRuntime = JS_NewRuntime(sRuntimeHeapSize, JS_NO_HELPER_THREADS);
NS_ENSURE_TRUE(mRuntime, NS_ERROR_OUT_OF_MEMORY);
mContext = JS_NewContext(mRuntime, 0);
NS_ENSURE_TRUE(mContext, NS_ERROR_OUT_OF_MEMORY);
JSAutoRequest ar(mContext);
mGlobal = JS_NewGlobalObject(mContext, &sGlobalClass, nullptr);
NS_ENSURE_TRUE(mGlobal, NS_ERROR_OUT_OF_MEMORY);
JS_SetGlobalObject(mContext, mGlobal);
JS_InitStandardClasses(mContext, mGlobal);
JS_SetVersion(mContext, JSVERSION_LATEST);
JS_SetErrorReporter(mContext, PACErrorReporter);
if (!JS_DefineFunctions(mContext, mGlobal, PACGlobalFunctions))
return NS_ERROR_FAILURE;
return NS_OK;
}
ScriptInterface_impl::ScriptInterface_impl(const char* nativeScopeName, const shared_ptr<ScriptRuntime>& runtime) :
m_runtime(runtime)
{
JSBool ok;
m_cx = JS_NewContext(m_runtime->m_rt, STACK_CHUNK_SIZE);
ENSURE(m_cx);
// For GC debugging:
// JS_SetGCZeal(m_cx, 2);
JS_SetContextPrivate(m_cx, NULL);
JS_SetErrorReporter(m_cx, ErrorReporter);
uint32 options = 0;
options |= JSOPTION_STRICT; // "warn on dubious practice"
options |= JSOPTION_XML; // "ECMAScript for XML support: parse <!-- --> as a token"
options |= JSOPTION_VAROBJFIX; // "recommended" (fixes variable scoping)
// Enable method JIT, unless script profiling/debugging is enabled (since profiling/debugging
// hooks are incompatible with the JIT)
// TODO: Verify what exactly is incompatible
if (!g_ScriptProfilingEnabled && !g_JSDebuggerEnabled)
{
options |= JSOPTION_METHODJIT;
// Some other JIT flags to experiment with:
options |= JSOPTION_JIT;
options |= JSOPTION_PROFILING;
}
JS_SetOptions(m_cx, options);
JS_SetVersion(m_cx, JSVERSION_LATEST);
// Threadsafe SpiderMonkey requires that we have a request before doing anything much
JS_BeginRequest(m_cx);
// We only want a single compartment per runtime
if (m_runtime->m_compartmentGlobal)
{
m_call = JS_EnterCrossCompartmentCall(m_cx, m_runtime->m_compartmentGlobal);
m_glob = JS_NewGlobalObject(m_cx, &global_class);
}
else
{
m_call = NULL;
m_glob = JS_NewCompartmentAndGlobalObject(m_cx, &global_class, NULL);
m_runtime->m_compartmentGlobal = m_glob;
}
ok = JS_InitStandardClasses(m_cx, m_glob);
ENSURE(ok);
JS_DefineProperty(m_cx, m_glob, "global", OBJECT_TO_JSVAL(m_glob), NULL, NULL, 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, m_glob, "print", ::print, 0, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
JS_DefineFunction(m_cx, m_glob, "log", ::logmsg, 1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
JS_DefineFunction(m_cx, m_glob, "warn", ::warn, 1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
JS_DefineFunction(m_cx, m_glob, "error", ::error, 1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
JS_DefineFunction(m_cx, m_glob, "deepcopy", ::deepcopy, 1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
Register("ProfileStart", ::ProfileStart, 1);
Register("ProfileStop", ::ProfileStop, 0);
}
/*
* Purpose: Carry out rule running in this spun off thread
*
* Entry:
* 1st - Queue entry
*
* Exit:
* SUCCESS = ERR_NONE
* FAILURE = ERR_* (type of error)
*/
ERRTYPE spawnRuleRunner(Queue_Entry *qentry) {
JSObject *script = NULL;
JSRuntime *rt = NULL;
JSContext *cx = NULL;
JSBool ret;
JSObject *global;
jsval rval;
Logic_Entry *lentry;
if((lentry = getLogicEntryForVoid(qentry->voidId)) == NULL) {
printf("logic 2\r\n");
return ERR_NONE;
}
rt = JS_NewRuntime(SPIDERMONKEY_ALLOC_RAM);
if(rt == NULL) {
return ERR_UNKNOWN;
}
/*
* 8192 = size of each stack chunk (not stack size)
*
* Apparently this is an internal variable in spidermonkey
* that shouldn't be tweaked without knowing a lot about
* spidermonkey's garbage collection.
*/
cx = JS_NewContext(rt, 8192);
if(cx == NULL) {
JS_DestroyRuntime(rt);
return ERR_UNKNOWN;
}
JS_SetOptions(cx, JSOPTION_VAROBJFIX | JSOPTION_JIT | JSOPTION_COMPILE_N_GO); // JSOPTION_METHODJIT
JS_SetVersion(cx, JSVERSION_LATEST);
JS_SetErrorReporter(cx, jsErrorHandler);
// Create the global object in a new compartment. See http://developer.mozilla.org/En/SpiderMonkey/JSAPI_User_Guide#Native_functions
global = JS_NewCompartmentAndGlobalObject(cx, &js_global_object_class, NULL);
if (global == NULL) {
JS_DestroyContext(cx);
JS_DestroyRuntime(rt);
return ERR_UNKNOWN;
}
if(JS_InitStandardClasses(cx, global) == false) {
JS_DestroyContext(cx);
JS_DestroyRuntime(rt);
return ERR_UNKNOWN;
}
createJSObjectThwonk(cx, global, qentry);
script = JS_CompileScript(cx, global, lentry->logic, strlen(lentry->logic), "<inline>", 0);
if(script == NULL) {
// TODO: Log error to database for script writer to see
printf("Couldn't compiled the script\n");
JS_DestroyContext(cx);
JS_DestroyRuntime(rt);
return ERR_UNKNOWN;
}
ret = JS_ExecuteScript(cx, global, script, &rval);
if(ret == JS_FALSE) {
// TODO: Log error to database for script writer to see
printf("Failed to run compiled script.\n");
JS_DestroyContext(cx);
JS_DestroyRuntime(rt);
return ERR_UNKNOWN;
}
// str = JS_ValueToString(cx, rval);
// printf("script result: %s\n", JS_GetStringBytes(str));
JS_DestroyContext(cx);
JS_DestroyRuntime(rt);
JS_ShutDown(); // Is this needed since thread is ending on return from this function?
return ERR_NONE;
}
static int
ProcessArgs(JSContext *cx, JSObject *obj, char **argv, int argc)
{
const char rcfilename[] = "xpcshell.js";
FILE *rcfile;
int i, j, length;
JSObject *argsObj;
char *filename = NULL;
JSBool isInteractive = JS_TRUE;
JSBool forceTTY = JS_FALSE;
rcfile = fopen(rcfilename, "r");
if (rcfile) {
printf("[loading '%s'...]\n", rcfilename);
ProcessFile(cx, obj, rcfilename, rcfile, JS_FALSE);
}
/*
* Scan past all optional arguments so we can create the arguments object
* before processing any -f options, which must interleave properly with
* -v and -w options. This requires two passes, and without getopt, we'll
* have to keep the option logic here and in the second for loop in sync.
*/
for (i = 0; i < argc; i++) {
if (argv[i][0] != '-' || argv[i][1] == '\0') {
++i;
break;
}
switch (argv[i][1]) {
case 'v':
case 'f':
case 'e':
++i;
break;
default:;
}
}
/*
* Create arguments early and define it to root it, so it's safe from any
* GC calls nested below, and so it is available to -f <file> arguments.
*/
argsObj = JS_NewArrayObject(cx, 0, NULL);
if (!argsObj)
return 1;
if (!JS_DefineProperty(cx, obj, "arguments", OBJECT_TO_JSVAL(argsObj),
NULL, NULL, 0)) {
return 1;
}
length = argc - i;
for (j = 0; j < length; j++) {
JSString *str = JS_NewStringCopyZ(cx, argv[i++]);
if (!str)
return 1;
if (!JS_DefineElement(cx, argsObj, j, STRING_TO_JSVAL(str),
NULL, NULL, JSPROP_ENUMERATE)) {
return 1;
}
}
for (i = 0; i < argc; i++) {
if (argv[i][0] != '-' || argv[i][1] == '\0') {
filename = argv[i++];
isInteractive = JS_FALSE;
break;
}
switch (argv[i][1]) {
case 'v':
if (++i == argc) {
return usage();
}
JS_SetVersion(cx, JSVersion(atoi(argv[i])));
break;
case 'W':
reportWarnings = JS_FALSE;
break;
case 'w':
reportWarnings = JS_TRUE;
break;
case 's':
JS_ToggleOptions(cx, JSOPTION_STRICT);
break;
case 'x':
JS_ToggleOptions(cx, JSOPTION_XML);
break;
case 'P':
if (JS_GET_CLASS(cx, JS_GetPrototype(cx, obj)) != &global_class) {
JSObject *gobj;
if (!JS_SealObject(cx, obj, JS_TRUE))
return JS_FALSE;
gobj = JS_NewObject(cx, &global_class, NULL, NULL);
if (!gobj)
return JS_FALSE;
if (!JS_SetPrototype(cx, gobj, obj))
return JS_FALSE;
JS_SetParent(cx, gobj, NULL);
JS_SetGlobalObject(cx, gobj);
obj = gobj;
}
break;
case 'f':
if (++i == argc) {
return usage();
}
Process(cx, obj, argv[i], JS_FALSE);
/*
* XXX: js -f foo.js should interpret foo.js and then
* drop into interactive mode, but that breaks test
* harness. Just execute foo.js for now.
*/
isInteractive = JS_FALSE;
break;
case 'i':
isInteractive = forceTTY = JS_TRUE;
break;
case 'e':
{
jsval rval;
if (++i == argc) {
return usage();
}
JS_EvaluateScript(cx, obj, argv[i], strlen(argv[i]),
"-e", 1, &rval);
isInteractive = JS_FALSE;
break;
}
case 'C':
compileOnly = JS_TRUE;
isInteractive = JS_FALSE;
break;
#ifdef MOZ_SHARK
case 'k':
JS_ConnectShark();
break;
#endif
default:
return usage();
}
}
if (filename || isInteractive)
Process(cx, obj, filename, forceTTY);
return gExitCode;
}
static PyObject *spindly_js(PyObject *self, PyObject *args) {
JSRuntime *runtime;
JSContext *context;
JSObject *global;
char *script;
Py_ssize_t script_length;
PyObject *params = NULL;
int timeout = 10;
jsval rvalue;
int error = 0;
struct watchdog *wd = NULL;
if (!PyArg_ParseTuple(args, "s#|Oi:js", &script, &script_length, ¶ms, &timeout)) {
return NULL;
}
if (params != NULL && !PyDict_Check(params)) {
return PyErr_Format(PyExc_TypeError, "params must be a dict");
}
runtime = JS_NewRuntime(1024L * 1024L);
if (!runtime) {
return PyErr_Format(PyExc_SystemError, "unable to initialize JS runtime\n");
}
context = JS_NewContext(runtime, 8192);
if (!context) {
JS_DestroyRuntime(runtime);
return PyErr_Format(PyExc_SystemError, "unable to initialize JS context\n");
}
JS_SetContextPrivate(context, &error);
JS_SetOptions(context, JSOPTION_VAROBJFIX);
JS_SetVersion(context, JSVERSION_LATEST);
JS_SetErrorReporter(context, raise_python_exception);
JS_SetOperationCallback(context, js_destroy);
global = JS_NewCompartmentAndGlobalObject(context, &global_class, NULL);
JS_InitStandardClasses(context, global);
if (params != NULL) {
populate_javascript_object(context, global, params);
}
if (timeout > 0) {
wd = run_watchdog(context, timeout);
if (wd == NULL) {
shutdown(runtime, context);
return PyErr_Format(PyExc_SystemError, "unable to initialize JS watchdog\n");
}
}
JSBool retval = JS_EvaluateScript(context, global, script, script_length, "spindly", 1, &rvalue);
if (wd) {
shutdown_watchdog(wd);
}
if (retval == JS_FALSE || error == 1) {
shutdown(runtime, context);
return NULL;
}
PyObject *obj = to_python_object(context, rvalue);
shutdown(runtime, context);
return obj;
}
int main(int argc, const char *argv[])
{
int index;
/* JS variables. */
JSRuntime* rt;
JSContext* cx;
JSObject* global;
JSObject* alpha;
JSObject* bindings;
jsval global_val;
JSObject* args;
jsval args_val;
/* Create a JS runtime. */
rt = JS_NewRuntime(8L * 1024L * 1024L);
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_NewCompartmentAndGlobalObject(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;
alpha = JS_DefineObject(cx, global, "alpha", NULL, NULL, 0);
/* Attach the global functions */
if (!JS_DefineFunctions(cx, alpha, global_functions)) return 1;
/* expose the binding functions for require to use */
bindings = JS_DefineObject(cx, alpha, "bindings", NULL, NULL, 0);
if (!JS_DefineFunctions(cx, bindings, binding_functions)) return 1;
/* Set global on alpha */
global_val = OBJECT_TO_JSVAL(global);
if (!JS_SetProperty(cx, alpha, "global", &global_val)) return 1;
/* Set args on alpha */
args = JS_NewArrayObject(cx, 0, NULL);
args_val = OBJECT_TO_JSVAL(args);
if (!JS_SetProperty(cx, alpha, "args", &args_val)) return 1;
for (index = 0; index < argc; index++) {
jsval arg = STRING_TO_JSVAL(JS_NewStringCopyZ(cx, argv[index]));
if (!JS_SetElement(cx, args, index, &arg)) return 1;
}
/* Bootstrap using the code in main.js */
JS_EvaluateScript(cx, global, embedded_src_main_js, strlen(embedded_src_main_js), "main.js", 1, NULL);
/* Cleanup. */
JS_DestroyContext(cx);
JS_DestroyRuntime(rt);
JS_ShutDown();
return 0;
}
/**
* Load a JavaScript file then run the function corresponding to the service by
* passing the conf, inputs and outputs parameters by value as JavaScript
* Objects.
*
* @param main_conf the conf maps containing the main.cfg settings
* @param request the map containing the HTTP request
* @param s the service structure
* @param inputs the maps containing the inputs
* @param outputs the maps containing the outputs
* @return SERVICE_SUCCEEDED or SERVICE_FAILED if the service run, -1
* if the service failed to load or throw error at runtime.
*/
int zoo_js_support(maps** main_conf,map* request,service* s,maps **inputs,maps **outputs)
{
/*maps* main=*main_conf;
maps* _inputs=*inputs;
maps* _outputs=*outputs;*/
/* The class of the global object. */
JSClass global_class= {
"global", JSCLASS_GLOBAL_FLAGS,
JS_PropertyStub, JS_PropertyStub, JS_PropertyStub, JS_StrictPropertyStub,
JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, JS_FinalizeStub,
JSCLASS_NO_OPTIONAL_MEMBERS
};
/* JS variables. */
JSRuntime *rt;
JSContext *cx;
JSObject *global;
/* Create a JS runtime. */
rt = JS_NewRuntime(8L * 1024L * 1024L);
if (rt == NULL)
return 1;
/* Create a context. */
cx = JS_NewContext(rt,8192);
if (cx == NULL){
return 1;
}
JS_SetOptions(cx, JSOPTION_VAROBJFIX | JSOPTION_JIT | JSOPTION_METHODJIT);
JS_SetVersion(cx, JSVERSION_LATEST);
JS_SetErrorReporter(cx, reportError);
/* Create the global object. */
global = JS_NewCompartmentAndGlobalObject(cx, &global_class, NULL);
/* Populate the global object with the standard globals,
like Object and Array. */
if (!JS_InitStandardClasses(cx, global)){
return 1;
}
/* Define specific function and global variable to share with JS runtime
*/
jsval tmp=INT_TO_JSVAL(3);
if (!JS_SetProperty(cx, global, "SERVICE_SUCCEEDED", &tmp))
return 1;
tmp=INT_TO_JSVAL(4);
if (!JS_SetProperty(cx, global, "SERVICE_FAILED", &tmp))
return 1;
if (!JS_DefineFunction(cx, global, "ZOORequest", JSRequest, 4, 0))
return 1;
if (!JS_DefineFunction(cx, global, "ZOOTranslate", JSTranslate, 4, 0))
return 1;
if (!JS_DefineFunction(cx, global, "ZOOUpdateStatus", JSUpdateStatus, 2, 0))
return 1;
if (!JS_DefineFunction(cx, global, "alert", JSAlert, 2, 0))
return 1;
if (!JS_DefineFunction(cx, global, "importScripts", JSLoadScripts, 1, 0))
return 1;
/**
* Add private context object
*/
void* cxPrivate = request;
JS_SetContextPrivate(cx,cxPrivate);
map* tmpm1=getMap(request,"metapath");
char ntmp[1024];
map* cwdMap=getMapFromMaps(*main_conf,"main","servicePath");
if(cwdMap!=NULL)
sprintf(ntmp,"%s",cwdMap->value);
else
getcwd(ntmp,1024);
/**
* Load the first part of the ZOO-API
*/
char *api0=(char*)malloc((strlen(ntmp)+17)*sizeof(char));
sprintf(api0,"%s/ZOO-proj4js.js",ntmp);
#ifdef JS_DEBUG
fprintf(stderr,"Trying to load %s\n",api0);
#endif
JSObject *api_script1=loadZooApiFile(cx,global,api0);
free(api0);
fflush(stderr);
char *api1=(char*)malloc((strlen(ntmp)+13)*sizeof(char));
sprintf(api1,"%s/ZOO-api.js",ntmp);
#ifdef JS_DEBUG
fprintf(stderr,"Trying to load %s\n",api1);
#endif
JSObject *api_script2=loadZooApiFile(cx,global,api1);
free(api1);
fflush(stderr);
/* Your application code here. This may include JSAPI calls
to create your own custom JS objects and run scripts. */
//maps* out=*outputs;
int res=SERVICE_FAILED;
//maps* mc=*main_conf;
map* tmpm2=getMap(s->content,"serviceProvider");
char *filename=(char*)malloc(strlen(tmpm1->value)+strlen(tmpm2->value)+strlen(ntmp)+3);
sprintf(filename,"%s/%s/%s",ntmp,tmpm1->value,tmpm2->value);
filename[strlen(tmpm1->value)+strlen(tmpm2->value)+strlen(ntmp)+2]=0;
#ifdef JS_DEBUG
fprintf(stderr,"FILENAME %s\n",filename);
#endif
struct stat file_status;
stat(filename, &file_status);
//char *source=(char*)malloc(file_status.st_size);
//uint16 lineno;
jsval rval;
JSBool ok ;
JSObject *script = JS_CompileFile(cx, global, filename);
if(script!=NULL){
(void)JS_ExecuteScript(cx, global, script, &rval);
}
else{
char tmp1[1024];
sprintf(tmp1,"Unable to load JavaScript file %s",filename);
free(filename);
errorException(*main_conf,tmp1,"NoApplicableCode",NULL);
JS_MaybeGC(cx);
JS_DestroyContext(cx);
JS_DestroyRuntime(rt);
JS_ShutDown();
return -1;
}
/* Call a function in obj's scope. */
jsval argv[3];
JSObject *jsargv1=JSObject_FromMaps(cx,*main_conf);
argv[0] = OBJECT_TO_JSVAL(jsargv1);
JSObject *jsargv2=JSObject_FromMaps(cx,*inputs);
argv[1] = OBJECT_TO_JSVAL(jsargv2);
JSObject *jsargv3=JSObject_FromMaps(cx,*outputs);
argv[2] = OBJECT_TO_JSVAL(jsargv3);
jsval rval1=JSVAL_NULL;
#ifdef JS_DEBUG
fprintf(stderr, "object %p\n", (void *) argv[2]);
#endif
ok = JS_CallFunctionName(cx, global, s->name, 3, argv, &rval1);
#ifdef JS_DEBUG
fprintf(stderr, "object %p\n", (void *) argv[2]);
#endif
JSObject *d;
if (ok==JS_TRUE && JSVAL_IS_OBJECT(rval1)==JS_TRUE) {
#ifdef JS_DEBUG
fprintf(stderr,"Function run sucessfully !\n");
#endif
/* Should get a number back from the service function call. */
ok = JS_ValueToObject(cx, rval1, &d);
}else{
/* Unable to run JS function */
char tmp1[1024];
if(strlen(dbg)==0)
sprintf(dbg,"No result was found after the function call");
sprintf(tmp1,"Unable to run %s from the JavaScript file %s : \n %s",s->name,filename,dbg);
#ifdef JS_DEBUG
fprintf(stderr,"%s",tmp1);
#endif
errorException(*main_conf,tmp1,"NoApplicableCode",NULL);
free(filename);
JS_MaybeGC(cx);
JS_DestroyContext(cx);
JS_DestroyRuntime(rt);
JS_ShutDown();
// Should return -1 here but the unallocation won't work from zoo_service_loader.c line 1847
return -1;
}
//jsval t=OBJECT_TO_JSVAL(d);
if(JS_IsArrayObject(cx,d)){
#ifdef JS_DEBUG
fprintf(stderr,"An array was returned !\n");
#endif
jsuint len;
if((JS_GetArrayLength(cx, d, &len)==JS_FALSE)){
#ifdef JS_DEBUG
fprintf(stderr,"outputs array is empty\n");
#endif
}
jsval tmp1;
JSBool hasResult=JS_GetElement(cx,d,0,&tmp1);
res=JSVAL_TO_INT(tmp1);
#ifdef JS_DEBUG
fprintf(stderr," * %d * \n",res);
#endif
if(res==SERVICE_SUCCEEDED){
jsval tmp2;
JSBool hasElement=JS_GetElement(cx,d,1,&tmp2);
if(hasElement==JS_TRUE){
freeMaps(outputs);
free(*outputs);
*outputs=mapsFromJSObject(cx,tmp2);
}
}else{
jsval tmp3;
JSBool hasConf=JS_GetElement(cx,d,1,&tmp3);
if(hasConf==JS_TRUE){
freeMaps(main_conf);
free(*main_conf);
*main_conf=mapsFromJSObject(cx,tmp3);
}
}
}
else{
#ifdef JS_DEBUG
fprintf(stderr,"The service didn't return an array !\n");
#endif
/**
* Extract result
*/
jsval tmp1;
JSBool hasResult=JS_GetProperty(cx,d,"result",&tmp1);
res=JSVAL_TO_INT(tmp1);
#ifdef JS_DEBUG
fprintf(stderr," * %d * \n",res);
#endif
/**
* Extract outputs when available.
*/
jsval tmp2;
JSBool hasElement=JS_GetProperty(cx,d,"outputs",&tmp2);
if(!JSVAL_IS_VOID(tmp2) && hasElement==JS_TRUE){
freeMaps(outputs);
free(*outputs);
*outputs=mapsFromJSObject(cx,tmp2);
}
JS_MaybeGC(cx);
#ifdef JS_DEBUG
if(JSVAL_IS_VOID(tmp2))
fprintf(stderr,"No outputs property returned\n");
else{
if(JS_IsArrayObject(cx,JSVAL_TO_OBJECT(tmp2)))
fprintf(stderr,"outputs is an array as expected\n");
else
fprintf(stderr,"outputs is not an array as expected\n");
}
JS_MaybeGC(cx);
#endif
/**
* Extract conf when available.
*/
jsval tmp3;
JSBool hasConf=JS_GetProperty(cx,d,"conf",&tmp3);
if(!JSVAL_IS_VOID(tmp3) && hasConf==JS_TRUE){
freeMaps(main_conf);
free(*main_conf);
*main_conf=mapsFromJSObject(cx,tmp3);
}
JS_MaybeGC(cx);
#ifdef JS_DEBUG
dumpMaps(*outputs);
#endif
}
/* Cleanup. */
JS_MaybeGC(cx);
JS_DestroyContext(cx);
JS_DestroyRuntime(rt);
JS_ShutDown();
free(filename);
#ifdef JS_DEBUG
fprintf(stderr,"Returned value %d\n",res);
#endif
return res;
}
NS_IMETHODIMP nsJSSh::Init()
{
nsCOMPtr<nsIScriptSecurityManager> ssm = do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID);
if (!ssm) {
NS_ERROR("failed to get script security manager");
return NS_ERROR_FAILURE;
}
ssm->GetSystemPrincipal(getter_AddRefs(mPrincipal));
if (!mPrincipal) {
NS_ERROR("failed to get system principal");
return NS_ERROR_FAILURE;
}
nsCOMPtr<nsIXPConnect> xpc = do_GetService(nsIXPConnect::GetCID());
if (!xpc) {
NS_ERROR("failed to get xpconnect service");
return NS_ERROR_FAILURE;
}
nsCOMPtr<nsIJSRuntimeService> rtsvc = do_GetService("@mozilla.org/js/xpc/RuntimeService;1");
// get the JSRuntime from the runtime svc
if (!rtsvc) {
NS_ERROR("failed to get nsJSRuntimeService");
return NS_ERROR_FAILURE;
}
JSRuntime *rt = nsnull;
if (NS_FAILED(rtsvc->GetRuntime(&rt)) || !rt) {
NS_ERROR("failed to get JSRuntime from nsJSRuntimeService");
return NS_ERROR_FAILURE;
}
mJSContext = JS_NewContext(rt, 8192);
if (!mJSContext) {
NS_ERROR("JS_NewContext failed");
return NS_ERROR_FAILURE;
}
JSAutoRequest ar(mJSContext);
// Enable e4x:
JS_SetOptions(mJSContext, JS_GetOptions(mJSContext) | JSOPTION_XML);
// Always use the latest js version
JS_SetVersion(mJSContext, JSVERSION_LATEST);
mContextStack = do_GetService("@mozilla.org/js/xpc/ContextStack;1");
if (!mContextStack) {
NS_ERROR("failed to get the nsThreadJSContextStack service");
return NS_ERROR_FAILURE;
}
JS_SetErrorReporter(mJSContext, my_ErrorReporter);
nsCOMPtr<nsIXPConnectJSObjectHolder> holder;
xpc->InitClassesWithNewWrappedGlobal(mJSContext, (nsIJSSh*)this,
NS_GET_IID(nsISupports),
PR_TRUE,
getter_AddRefs(holder));
if (!holder) {
NS_ERROR("global initialization failed");
return NS_ERROR_FAILURE;
}
holder->GetJSObject(&mGlobal);
if (!mGlobal) {
NS_ERROR("bad global object");
return NS_ERROR_FAILURE;
}
mContextObj = mGlobal;
if (!JS_DefineFunctions(mJSContext, mGlobal, global_functions)) {
NS_ERROR("failed to initialise global functions");
return NS_ERROR_FAILURE;
}
if (!mStartupURI.IsEmpty())
LoadURL(mStartupURI.get());
return NS_OK;
}
static GObject*
gjs_context_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_params)
{
GObject *object;
GjsContext *js_context;
guint32 options_flags;
JSVersion js_version;
object = (* G_OBJECT_CLASS (gjs_context_parent_class)->constructor) (type,
n_construct_properties,
construct_params);
js_context = GJS_CONTEXT(object);
if (js_context->runtime == NULL) {
js_context->runtime = JS_NewRuntime(32*1024*1024 /* max bytes */);
if (js_context->runtime == NULL)
gjs_fatal("Failed to create javascript runtime");
JS_SetGCParameter(js_context->runtime, JSGC_MAX_BYTES, 0xffffffff);
js_context->we_own_runtime = TRUE;
gjs_runtime_init(js_context->runtime);
}
js_context->context = JS_NewContext(js_context->runtime, 8192 /* stack chunk size */);
if (js_context->context == NULL)
gjs_fatal("Failed to create javascript context");
JS_BeginRequest(js_context->context);
/* same as firefox, see discussion at
* https://bugzilla.mozilla.org/show_bug.cgi?id=420869 */
JS_SetScriptStackQuota(js_context->context, 100*1024*1024);
/* JSOPTION_DONT_REPORT_UNCAUGHT: Don't send exceptions to our
* error report handler; instead leave them set. This allows us
* to get at the exception object.
*
* JSOPTION_STRICT: Report warnings to error reporter function.
*/
options_flags = JSOPTION_DONT_REPORT_UNCAUGHT | JSOPTION_STRICT;
if (!g_getenv("GJS_DISABLE_JIT")) {
gjs_debug(GJS_DEBUG_CONTEXT, "Enabling JIT");
options_flags |= JSOPTION_METHODJIT;
}
JS_SetOptions(js_context->context,
JS_GetOptions(js_context->context) | options_flags);
JS_SetLocaleCallbacks(js_context->context, &gjs_locale_callbacks);
JS_SetErrorReporter(js_context->context, gjs_error_reporter);
/* set ourselves as the private data */
JS_SetContextPrivate(js_context->context, js_context);
js_version = JS_StringToVersion(js_context->jsversion_string);
/* It doesn't make sense to throw here; just use the default if we
* don't know.
*/
if (js_version == JSVERSION_UNKNOWN)
js_version = JSVERSION_DEFAULT;
/* Set the version if we need to. */
if (js_version != JSVERSION_DEFAULT && JS_GetVersion(js_context->context) != js_version) {
gjs_debug(GJS_DEBUG_CONTEXT,
"Changing JavaScript version to %s from %s",
JS_VersionToString(js_version),
JS_VersionToString(JS_GetVersion(js_context->context)));
JS_SetVersion(js_context->context, js_version);
}
if (!gjs_init_context_standard(js_context->context))
gjs_fatal("Failed to initialize context");
js_context->global = JS_GetGlobalObject(js_context->context);
if (!JS_DefineProperty(js_context->context, js_context->global,
"window", OBJECT_TO_JSVAL(js_context->global),
NULL, NULL,
JSPROP_READONLY | JSPROP_PERMANENT))
gjs_fatal("No memory to export global object as 'window'");
/* Define a global function called log() */
if (!JS_DefineFunction(js_context->context, js_context->global,
"log",
(JSNative)gjs_log,
1, GJS_MODULE_PROP_FLAGS))
gjs_fatal("Failed to define log function");
if (!JS_DefineFunction(js_context->context, js_context->global,
"logError",
(JSNative)gjs_log_error,
2, GJS_MODULE_PROP_FLAGS))
gjs_fatal("Failed to define logError function");
/* Define global functions called print() and printerr() */
if (!JS_DefineFunction(js_context->context, js_context->global,
"print",
(JSNative)gjs_print,
3, GJS_MODULE_PROP_FLAGS))
gjs_fatal("Failed to define print function");
if (!JS_DefineFunction(js_context->context, js_context->global,
"printerr",
(JSNative)gjs_printerr,
4, GJS_MODULE_PROP_FLAGS))
gjs_fatal("Failed to define printerr function");
/* We need to know what the default context is, since it's the context whose
* global object is used to load imported JS modules. We currently say that
* it's the context of the runtime's owner, but if we needed to support
* externally created runtimes, we could define it in some other fashion.
*/
if (js_context->we_own_runtime) {
gjs_runtime_set_default_context(js_context->runtime, js_context->context);
} else {
if (gjs_runtime_get_default_context(js_context->runtime) == NULL)
gjs_fatal("GjsContext created for a runtime not owned by GJS");
}
/* We create the global-to-runtime root importer with the
* passed-in search path. If someone else already created
* the root importer, this is a no-op.
*/
if (!gjs_create_root_importer(js_context->context,
js_context->search_path ?
(const char**) js_context->search_path :
NULL,
TRUE))
gjs_fatal("Failed to create root importer");
/* Now copy the global root importer (which we just created,
* if it didn't exist) to our global object
*/
if (!gjs_define_root_importer(js_context->context,
js_context->global,
"imports"))
gjs_fatal("Failed to point 'imports' property at root importer");
if (js_context->we_own_runtime) {
js_context->profiler = gjs_profiler_new(js_context->runtime);
}
if (!gjs_is_registered_native_module(js_context->context, NULL, "gi"))
gjs_register_native_module("gi", gjs_define_gi_stuff, GJS_NATIVE_SUPPLIES_MODULE_OBJ);
/* For GjsDBus */
{
char *priv_typelib_dir = g_build_filename (PKGLIBDIR, "girepository-1.0", NULL);
g_irepository_prepend_search_path(priv_typelib_dir);
g_free (priv_typelib_dir);
}
if (js_context->gc_notifications_enabled)
JS_SetGCCallback(js_context->context, gjs_on_context_gc);
JS_EndRequest(js_context->context);
g_static_mutex_lock (&contexts_lock);
all_contexts = g_list_prepend(all_contexts, object);
g_static_mutex_unlock (&contexts_lock);
return object;
}
int SDL_main(int argc, char **argv) {
bool referenceMode = false;
bool javaScriptMode = false;
char* scripts [32];
int scriptCount = 0;
char* args;
int o = 0;
while ((o = getopt (argc, argv, "rjs:a:")) != -1) {
switch (o) {
case 'r':
referenceMode = true;
break;
case 'j':
javaScriptMode = true;
break;
case 's':
scripts[scriptCount++] = optarg;
break;
case 'a':
args = optarg;
break;
case '?':
printf("[-r] [-s FILE] [-a ARGUMENTS]\n");
break;
}
}
if (referenceMode) {
Avc avc(args);
avc.Play();
} else if (javaScriptMode) {
/* JS variables. */
JSRuntime *rt;
JSContext *cx;
JSObject *global;
/* Create a JS runtime. */
rt = JS_NewRuntime(8L * 1024L * 1024L);
if (rt == NULL)
return 1;
/* Create a context. */
cx = JS_NewContext(rt, 8192);
if (cx == NULL)
return 1;
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. */
global = JS_NewCompartmentAndGlobalObject(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;
if (!JS_DefineFunctions(cx, global, globalFunctions))
return JS_FALSE;
for (int i = 0; i < scriptCount; i++) {
JSScript *script = JS_CompileFile(cx, global, scripts[i]);
if (script == NULL)
return 1;
jsval rval;
JSBool result = JS_ExecuteScript(cx, global, script, &rval);
if (!result) {
printf("Cannot execute script %s", scripts[i]);
}
}
/* Cleanup. */
JS_DestroyContext(cx);
JS_DestroyRuntime(rt);
JS_ShutDown();
}
return 0;
}
int runJS(char* script) {
LOGD("runJS");
// LOGD("script :\n%s", script);
/* Create a JS runtime. */
JSRuntime *rt = JS_NewRuntime(8L * 1024L * 1024L);
if (rt == NULL) {
LOGD("(rt == NULL)");
return 1;
}
/* Create a context. */
JSContext *cx = JS_NewContext(rt, 8192);
if (cx == NULL) {
LOGD("(cx == NULL)");
return 1;
}
JS_SetOptions(cx, JSOPTION_VAROBJFIX);
JS_SetVersion(cx, JSVERSION_LATEST);
JS_SetErrorReporter(cx, jsbindings::reportError);
/* Create the global object in a new compartment. */
JSObject *global =
JS_NewCompartmentAndGlobalObject(cx, &global_class, NULL);
if (global == NULL) {
LOGD("(global == NULL)");
return 1;
}
// Populate the global object with the standard globals,
// like Object and Array.
if (!JS_InitStandardClasses(cx, global)) {
LOGD("(!JS_InitStandardClasses(cx, global))");
return 1;
}
const char *filename = NULL;
int lineno = 0;
jsval rval;
JSBool evaluatedOK = JS_EvaluateScript(cx, global,
script, strlen(script),
filename, lineno, &rval);
if (JS_FALSE == evaluatedOK) {
LOGD("evaluatedOK == JS_FALSE)");
// return 1;
} else {
if (JSVAL_IS_NULL(rval)) {
LOGD("rval : (JSVAL_IS_NULL(rval)");
// return 1;
} else if ((JSVAL_IS_BOOLEAN(rval)) &&
(JS_FALSE == (JSVAL_TO_BOOLEAN(rval)))) {
LOGD("rval : (return value is JS_FALSE");
// return 1;
} else if (JSVAL_IS_STRING(rval)) {
JSString *str = JS_ValueToString(cx, rval);
if (NULL == str) {
LOGD("rval : return string is NULL");
} else {
LOGD("rval : return string =\n%s\n", JS_EncodeString(cx, str));
}
} else if (JSVAL_IS_NUMBER(rval)) {
double number;
if (JS_FALSE == JS_ValueToNumber(cx, rval, &number)) {
LOGD("rval : return number could not be converted");
} else {
LOGD("rval : return number =\n%f", number);
}
}
}
// Cleanup
JS_DestroyContext(cx);
JS_DestroyRuntime(rt);
JS_ShutDown();
LOGD("runJS done.");
return 0;
}
static int
ProcessArgs(JSContext *cx, JSObject *obj, char **argv, int argc)
{
int i, j, length;
JSObject *argsObj;
char *filename = NULL;
JSBool isInteractive = JS_TRUE;
JSBool forceTTY = JS_FALSE;
/*
* Scan past all optional arguments so we can create the arguments object
* before processing any -f options, which must interleave properly with
* -v and -w options. This requires two passes, and without getopt, we'll
* have to keep the option logic here and in the second for loop in sync.
*/
for (i = 0; i < argc; i++) {
if (argv[i][0] != '-' || argv[i][1] == '\0') {
++i;
break;
}
switch (argv[i][1]) {
case 'b':
case 'c':
case 'f':
case 'e':
case 'v':
case 'S':
++i;
break;
default:;
}
}
/*
* Create arguments early and define it to root it, so it's safe from any
* GC calls nested below, and so it is available to -f <file> arguments.
*/
argsObj = JS_NewArrayObject(cx, 0, NULL);
if (!argsObj)
return 1;
if (!JS_DefineProperty(cx, obj, "arguments", OBJECT_TO_JSVAL(argsObj),
NULL, NULL, 0)) {
return 1;
}
length = argc - i;
for (j = 0; j < length; j++) {
JSString *str = JS_NewStringCopyZ(cx, argv[i++]);
if (!str)
return 1;
if (!JS_DefineElement(cx, argsObj, j, STRING_TO_JSVAL(str),
NULL, NULL, JSPROP_ENUMERATE)) {
return 1;
}
}
for (i = 0; i < argc; i++) {
if (argv[i][0] != '-' || argv[i][1] == '\0') {
filename = argv[i++];
isInteractive = JS_FALSE;
break;
}
switch (argv[i][1]) {
case 'v':
if (++i == argc)
return usage();
JS_SetVersion(cx, (JSVersion) atoi(argv[i]));
break;
case 'w':
reportWarnings = JS_TRUE;
break;
case 'W':
reportWarnings = JS_FALSE;
break;
case 's':
JS_ToggleOptions(cx, JSOPTION_STRICT);
break;
case 'E':
JS_ToggleOptions(cx, JSOPTION_RELIMIT);
break;
case 'x':
JS_ToggleOptions(cx, JSOPTION_XML);
break;
case 'o':
if (++i == argc)
return usage();
for (j = 0; js_options[j].name; ++j) {
if (strcmp(js_options[j].name, argv[i]) == 0) {
JS_ToggleOptions(cx, js_options[j].flag);
break;
}
}
break;
case 'c':
/* set stack chunk size */
gStackChunkSize = atoi(argv[++i]);
break;
case 'f':
if (++i == argc)
return usage();
Process(cx, obj, argv[i], JS_FALSE);
/*
* XXX: js -f foo.js should interpret foo.js and then
* drop into interactive mode, but that breaks the test
* harness. Just execute foo.js for now.
*/
isInteractive = JS_FALSE;
break;
case 'e':
{
jsval rval;
if (++i == argc)
return usage();
/* Pass a filename of -e to imitate PERL */
JS_EvaluateScript(cx, obj, argv[i], SG_STRLEN(argv[i]),
"-e", 1, &rval);
isInteractive = JS_FALSE;
break;
}
case 'C':
compileOnly = JS_TRUE;
isInteractive = JS_FALSE;
break;
case 'i':
isInteractive = forceTTY = JS_TRUE;
break;
case 'S':
if (++i == argc)
return usage();
/* Set maximum stack size. */
gMaxStackSize = atoi(argv[i]);
break;
#ifdef MOZ_SHARK
case 'k':
JS_ConnectShark();
break;
#endif
default:
return usage();
}
}
if (filename || isInteractive)
Process(cx, obj, filename, forceTTY);
return gExitCode;
}