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);
}
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;
}
bool script_add_global_object(script_type *script,char *err_str)
{
// must remove other globals to stop parenting problems
JS_SetGlobalObject(js.cx,NULL);
// create global for this script
script->global=JS_NewObject(js.cx,&global_class,NULL,NULL);
if (script->global==NULL) {
strcpy(err_str,"Not enough memory to create global object");
return(FALSE);
}
// set sub objects
script_set_property_lock(TRUE);
script_add_global_map_object(script->global);
script_add_global_multiplayer_object(script->global);
script_add_global_camera_object(script->global);
script_add_global_interface_object(script->global);
script_add_global_data_object(script->global);
script_add_global_sound_object(script->global);
script_add_global_spawn_object(script->global);
script_add_global_utility_object(script->global);
script_set_property_lock(FALSE);
// set global
JS_SetGlobalObject(js.cx,script->global);
// initialize standard classes
if (!JS_InitStandardClasses(js.cx,script->global)) {
strcpy(err_str,"Could not initialize standard classes");
return(FALSE);
}
return(TRUE);
}
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;
}
/*
* call-seq:
* native_initialize(options={})
*
* Initializes the native spidermonkey values.
*/
static VALUE
initialize_native(VALUE self, VALUE rb_runtime, VALUE UNUSED(options))
{
JohnsonContext* context;
JohnsonRuntime* runtime;
Data_Get_Struct(self, JohnsonContext, context);
Data_Get_Struct(rb_runtime, JohnsonRuntime, runtime);
if ((context->js = JS_NewContext(runtime->js, 8192L)))
{
// See if the runtime already has a shared global object.
JSObject* global = runtime->global;
// If it does, use it. If not,
if (!global)
// create one of our global objects.
global = johnson_create_global_object(context->js);
// Manually set the context's global object.
JS_SetGlobalObject(context->js, global);
JS_SetErrorReporter(context->js, report_js_error);
JS_SetBranchCallback(context->js, branch_callback);
JS_SetContextPrivate(context->js, (void *)self);
JS_SetOptions(context->js, JS_GetOptions(context->js)
| JSOPTION_DONT_REPORT_UNCAUGHT
#ifdef JSOPTION_VAROBJFIX
| JSOPTION_VAROBJFIX
#endif
// #ifdef JSOPTION_XML
// | JSOPTION_XML
// #endif
);
// Success.
return init_spidermonkey_extensions(context, self);
}
if (context->js) JS_DestroyContext(context->js);
rb_raise(rb_eRuntimeError, "Failed to initialize SpiderMonkey context");
}
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 3;
/* 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 4;
/* Your application code here. This may include JSAPI calls to create your own custom JS objects and run scripts. */
js::RootedValue rval(cx);
int rc = JS_EvaluateScript(cx, global, runCommand, strlen(runCommand),
"TestCommand", 0, rval.address());
if (!rc)
return 5;
if (!JSVAL_IS_STRING(rval))
return 0;
/* Result of the command is a string, print it out. */
js::RootedString str(cx, JSVAL_TO_STRING(rval));
size_t encodedLength = JS_GetStringEncodingLength(cx, str);
rc = 0;
char *buffer = (char *)malloc(encodedLength + 1);
buffer[encodedLength] = '\0';
size_t result = JS_EncodeStringToBuffer(cx, str, buffer, encodedLength);
if (result == (size_t) - 1)
rc = 6;
else
puts(buffer);
free(buffer);
return rc;
}
bool ScriptEngine_StartUp()
{
SetScriptFolder();
bool bOk = true;
bOk =
NULL != (g_JsRt = JS_NewRuntime(1L * 1024L * 1024L, JS_USE_HELPER_THREADS))
&& NULL != (g_JsCx = JS_NewContext(g_JsRt, 8192))
&& (
JS_SetOptions(g_JsCx, JSOPTION_VAROBJFIX),
JS_SetErrorReporter(g_JsCx, reportError),
true
)
// . (global):
&& NULL != (g_JsGlobal = NewGlobalObject(g_JsCx))
;
if(bOk)
{
JSAutoCompartment ac(g_JsCx, g_JsGlobal);
JS_SetGlobalObject(g_JsCx, g_JsGlobal);
//char * loadInitScript = "load(scriptFolder+'AfxGoldSrcInit.js');";
//jsval rval;
//bOk = bOk && JS_EvaluateScript(g_JsCx, JS_GetGlobalForScopeChain(g_JsCx), loadInitScript, strlen(loadInitScript), NULL, 0, &rval);
}
if(!bOk)
{
MessageBox(0, "Failed to init scripting engine.", "Error", MB_OK|MB_ICONERROR);
ScriptEngine_ShutDown();
}
g_JsRunning = bOk;
return bOk;
}
bool Context::initialize()
{
JS_SetErrorReporter(_jsctx, reportError);
/* Enter a request before running anything in the context */
JSAutoRequest ar(_jsctx);
/* Create the global object in a new compartment. */
_global = JS_NewGlobalObject(_jsctx, &global_class, nullptr);
if (_global)
return false;
/* Set the context's global */
JSAutoCompartment ac(_jsctx, _global);
JS_SetGlobalObject(_jsctx, _global);
/* Populate the global object with the standard globals, like Object and Array. */
if (!JS_InitStandardClasses(_jsctx, _global)) {
return false;
}
return true;
}
/*---------------------------------------------------------------------------*/
void WebcJSBrowserContext::FreeContext (JSContext* cx)
{
if (mNumFreeContexts < WEBC_CFG_JS_CX_POOL_SIZE)
{
mContextPool[mNumFreeContexts++] = cx;
#ifdef WEBC_JS_GARBAGE_COLLECT_INTERVAL
if (!mGCCounter)
{
JS_GC(cx);
mGCCounter = WEBC_JS_GARBAGE_COLLECT_INTERVAL;
}
else
{
mGCCounter--;
}
#endif // WEBC_JS_GARBAGE_COLLECT_INTERVAL
JS_SetGlobalObject(cx, WEBC_NULL);
}
else
{
JS_DestroyContext(cx);
}
}
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;
}
int
main(int argc, char **argv)
{
int stackDummy;
SG_error err;
SG_context * pCtx = NULL;
JSRuntime *rt;
JSContext *cx;
SG_log_console__data cLogStdData;
SG_log_text__data cLogFileData;
SG_log_text__writer__daily_path__data cLogFileWriterData;
JSObject *glob;
int result;
SG_bool skipModules = SG_FALSE;
SG_zero(cLogStdData);
SG_zero(cLogFileData);
SG_zero(cLogFileWriterData);
CheckHelpMessages();
setlocale(LC_ALL, "");
gStackBase = (jsuword)&stackDummy;
#ifdef XP_OS2
/* these streams are normally line buffered on OS/2 and need a \n, *
* so we need to unbuffer then to get a reasonable prompt */
setbuf(stdout,0);
setbuf(stderr,0);
#endif
gErrFile = stderr;
gOutFile = stdout;
argc--;
argv++;
err = SG_context__alloc(&pCtx);
if (SG_IS_ERROR(err))
return 1;
SG_lib__global_initialize(pCtx);
if (SG_context__has_err(pCtx))
{
_vscript_context_teardown(&pCtx);
return 1;
}
_checkSkipModules(pCtx, &argc, argv, &skipModules);
if (SG_context__has_err(pCtx))
{
_vscript_context_teardown(&pCtx);
return 1;
}
SG_jscore__new_runtime(pCtx, ContextCallback, shell_functions, skipModules, &rt);
if (SG_context__has_err(pCtx))
{
_vscript_context_teardown(&pCtx);
return 1;
}
SG_jscore__new_context(pCtx, &cx, &glob, NULL);
if (SG_context__has_err(pCtx))
{
_vscript_context_teardown(&pCtx);
return 1;
}
JS_SetGlobalObject(cx, glob);
//////////////////////////////////////////////////////////////////
// Allocate and initialize the SG_context.
_set_up_logging(pCtx, &cLogStdData, &cLogFileData, &cLogFileWriterData);
result = ProcessArgs(cx, glob, argv, argc);
_clean_up_logging(pCtx, &cLogStdData, &cLogFileData, &cLogFileWriterData);
// TODO 2011/09/30 The following call removes "pCtx" from
// TODO the private data in the "cx". This was
// TODO done for neatness before we destroy it.
// TODO And this has worked fine for years.
// TODO
// TODO I have commented this out as an experiment
// TODO so that the "pCtx" is still available for
// TODO use in any GC/Finalize callbacks.
// TODO
// TODO SG_jsglue__set_sg_context(NULL, cx);
JS_EndRequest(cx);
JS_DestroyContext(cx);
// End of SG_context post-processing.
//////////////////////////////////////////////////////////////////
result = result + _vscript_context_teardown(&pCtx);
return result;
}
/* attribute JSContext safeJSContext; */
NS_IMETHODIMP
XPCJSContextStack::GetSafeJSContext(JSContext * *aSafeJSContext)
{
if(!mSafeJSContext)
{
#ifndef XPCONNECT_STANDALONE
// Start by getting the principal holder and principal for this
// context. If we can't manage that, don't bother with the rest.
nsRefPtr<nsNullPrincipal> principal = new nsNullPrincipal();
nsCOMPtr<nsIScriptObjectPrincipal> sop;
if(principal)
{
nsresult rv = principal->Init();
if(NS_SUCCEEDED(rv))
sop = new PrincipalHolder(principal);
}
if(!sop)
{
*aSafeJSContext = nsnull;
return NS_ERROR_FAILURE;
}
#endif /* !XPCONNECT_STANDALONE */
JSRuntime *rt;
XPCJSRuntime* xpcrt;
nsXPConnect* xpc = nsXPConnect::GetXPConnect();
nsCOMPtr<nsIXPConnect> xpcholder(static_cast<nsIXPConnect*>(xpc));
if(xpc && (xpcrt = xpc->GetRuntime()) && (rt = xpcrt->GetJSRuntime()))
{
JSObject *glob;
mSafeJSContext = JS_NewContext(rt, 8192);
if(mSafeJSContext)
{
nsCString origin;
principal->GetOrigin(getter_Copies(origin));
// scoped JS Request
JSAutoRequest req(mSafeJSContext);
JSCompartment *compartment;
nsresult rv = xpc_CreateGlobalObject(mSafeJSContext, &global_class,
origin, principal, &glob,
&compartment);
if(NS_FAILED(rv))
glob = nsnull;
#ifndef XPCONNECT_STANDALONE
if(glob)
{
// Make sure the context is associated with a proper compartment
// and not the default compartment.
JS_SetGlobalObject(mSafeJSContext, glob);
// Note: make sure to set the private before calling
// InitClasses
nsIScriptObjectPrincipal* priv = nsnull;
sop.swap(priv);
if(!JS_SetPrivate(mSafeJSContext, glob, priv))
{
// Drop the whole thing
NS_RELEASE(priv);
glob = nsnull;
}
}
// After this point either glob is null and the
// nsIScriptObjectPrincipal ownership is either handled by the
// nsCOMPtr or dealt with, or we'll release in the finalize
// hook.
#endif
if(glob && NS_FAILED(xpc->InitClasses(mSafeJSContext, glob)))
{
glob = nsnull;
}
}
if(mSafeJSContext && !glob)
{
// Destroy the context outside the scope of JSAutoRequest that
// uses the context in its destructor.
JS_DestroyContext(mSafeJSContext);
mSafeJSContext = nsnull;
}
// Save it off so we can destroy it later, even if
// mSafeJSContext has been set to another context
// via SetSafeJSContext. If we don't get here,
// then mSafeJSContext must have been set via
// SetSafeJSContext, and we're not responsible for
// destroying the passed-in context.
mOwnSafeJSContext = mSafeJSContext;
}
}
*aSafeJSContext = mSafeJSContext;
return mSafeJSContext ? NS_OK : NS_ERROR_UNEXPECTED;
}
int
main(int argc, const char* argv[])
{
JSRuntime* rt = NULL;
JSContext* cx = NULL;
JSObject* global = NULL;
JSObject* klass = NULL;
JSScript* script;
JSString* scriptsrc;
jschar* schars;
size_t slen;
jsval sroot;
jsval result;
couch_args* args = couch_parse_args(argc, argv);
rt = JS_NewRuntime(64L * 1024L * 1024L);
if(rt == NULL)
return 1;
cx = JS_NewContext(rt, args->stack_size);
if(cx == NULL)
return 1;
JS_SetErrorReporter(cx, couch_error);
JS_ToggleOptions(cx, JSOPTION_XML);
SETUP_REQUEST(cx);
global = JS_NewObject(cx, &global_class, NULL, NULL);
if(global == NULL)
return 1;
JS_SetGlobalObject(cx, global);
if(!JS_InitStandardClasses(cx, global))
return 1;
if(couch_load_funcs(cx, global, global_functions) != JS_TRUE)
return 1;
if(args->use_http) {
http_check_enabled();
klass = JS_InitClass(
cx, global,
NULL,
&CouchHTTPClass, req_ctor,
0,
CouchHTTPProperties, CouchHTTPFunctions,
NULL, NULL
);
if(!klass)
{
fprintf(stderr, "Failed to initialize CouchHTTP class.\n");
exit(2);
}
}
// Convert script source to jschars.
scriptsrc = dec_string(cx, args->script, strlen(args->script));
if(!scriptsrc)
return 1;
schars = JS_GetStringChars(scriptsrc);
slen = JS_GetStringLength(scriptsrc);
// Root it so GC doesn't collect it.
sroot = STRING_TO_JSVAL(scriptsrc);
if(JS_AddRoot(cx, &sroot) != JS_TRUE) {
fprintf(stderr, "Internal root error.\n");
return 1;
}
// Compile and run
script = JS_CompileUCScript(cx, global, schars, slen, args->script_name, 1);
if(!script) {
fprintf(stderr, "Failed to compile script.\n");
return 1;
}
JS_ExecuteScript(cx, global, script, &result);
// Warning message if we don't remove it.
JS_RemoveRoot(cx, &sroot);
FINISH_REQUEST(cx);
JS_DestroyContext(cx);
JS_DestroyRuntime(rt);
JS_ShutDown();
return 0;
}
JSObject *
GlobalObject::initFunctionAndObjectClasses(JSContext *cx)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
JS_ASSERT(isNative());
/*
* Calling a function from a cleared global triggers this (yeah, I know).
* Uncomment this once bug 470510 is fixed (if that bug doesn't remove
* isCleared entirely).
*/
// JS_ASSERT(!isCleared());
/* If cx has no global object, make this the global object. */
if (!cx->globalObject)
JS_SetGlobalObject(cx, this);
/*
* Create |Object.prototype| first, mirroring CreateBlankProto but for the
* prototype of the created object.
*/
JSObject *objectProto = NewObjectWithGivenProto(cx, &ObjectClass, NULL, this);
if (!objectProto || !objectProto->setSingletonType(cx))
return NULL;
/*
* The default 'new' type of Object.prototype is required by type inference
* to have unknown properties, to simplify handling of e.g. heterogenous
* objects in JSON and script literals.
*/
if (!objectProto->setNewTypeUnknown(cx))
return NULL;
/* Create |Function.prototype| next so we can create other functions. */
JSFunction *functionProto;
{
JSObject *proto = NewObjectWithGivenProto(cx, &FunctionClass, objectProto, this);
if (!proto)
return NULL;
/*
* Bizarrely, |Function.prototype| must be an interpreted function, so
* give it the guts to be one.
*/
functionProto = js_NewFunction(cx, proto, NULL, 0, JSFUN_INTERPRETED, this, NULL);
if (!functionProto)
return NULL;
JS_ASSERT(proto == functionProto);
functionProto->flags |= JSFUN_PROTOTYPE;
JSScript *script =
JSScript::NewScript(cx, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, JSVERSION_DEFAULT);
if (!script)
return NULL;
script->noScriptRval = true;
script->code[0] = JSOP_STOP;
script->code[1] = SRC_NULL;
functionProto->initScript(script);
functionProto->getType(cx)->interpretedFunction = functionProto;
script->setFunction(functionProto);
if (!proto->setSingletonType(cx))
return NULL;
/*
* The default 'new' type of Function.prototype is required by type
* inference to have unknown properties, to simplify handling of e.g.
* CloneFunctionObject.
*/
if (!proto->setNewTypeUnknown(cx))
return NULL;
}
/* Create the Object function now that we have a [[Prototype]] for it. */
jsid objectId = ATOM_TO_JSID(CLASS_ATOM(cx, Object));
JSFunction *objectCtor;
{
JSObject *ctor = NewObjectWithGivenProto(cx, &FunctionClass, functionProto, this);
if (!ctor)
return NULL;
objectCtor = js_NewFunction(cx, ctor, js_Object, 1, JSFUN_CONSTRUCTOR, this,
JSID_TO_ATOM(objectId));
if (!objectCtor)
return NULL;
JS_ASSERT(ctor == objectCtor);
objectCtor->setConstructorClass(&ObjectClass);
}
/*
* Install |Object| and |Object.prototype| for the benefit of subsequent
* code that looks for them.
*/
setObjectClassDetails(objectCtor, objectProto);
/* Create |Function| so it and |Function.prototype| can be installed. */
jsid functionId = ATOM_TO_JSID(CLASS_ATOM(cx, Function));
JSFunction *functionCtor;
{
JSObject *ctor =
NewObjectWithGivenProto(cx, &FunctionClass, functionProto, this);
if (!ctor)
return NULL;
functionCtor = js_NewFunction(cx, ctor, Function, 1, JSFUN_CONSTRUCTOR, this,
JSID_TO_ATOM(functionId));
if (!functionCtor)
return NULL;
JS_ASSERT(ctor == functionCtor);
functionCtor->setConstructorClass(&FunctionClass);
}
/*
* Install |Function| and |Function.prototype| so that we can freely create
* functions and objects without special effort.
*/
setFunctionClassDetails(functionCtor, functionProto);
/*
* The hard part's done: now go back and add all the properties these
* primordial values have.
*/
if (!LinkConstructorAndPrototype(cx, objectCtor, objectProto) ||
!DefinePropertiesAndBrand(cx, objectProto, object_props, object_methods) ||
!DefinePropertiesAndBrand(cx, objectCtor, NULL, object_static_methods) ||
!LinkConstructorAndPrototype(cx, functionCtor, functionProto) ||
!DefinePropertiesAndBrand(cx, functionProto, NULL, function_methods) ||
!DefinePropertiesAndBrand(cx, functionCtor, NULL, NULL))
{
return NULL;
}
/* Add the global Function and Object properties now. */
if (!addDataProperty(cx, objectId, JSProto_Object + JSProto_LIMIT * 2, 0))
return NULL;
if (!addDataProperty(cx, functionId, JSProto_Function + JSProto_LIMIT * 2, 0))
return NULL;
/* Heavy lifting done, but lingering tasks remain. */
/* ES5 15.1.2.1. */
jsid id = ATOM_TO_JSID(cx->runtime->atomState.evalAtom);
JSObject *evalobj = js_DefineFunction(cx, this, id, eval, 1, JSFUN_STUB_GSOPS);
if (!evalobj)
return NULL;
setOriginalEval(evalobj);
/* ES5 13.2.3: Construct the unique [[ThrowTypeError]] function object. */
JSFunction *throwTypeError = js_NewFunction(cx, NULL, ThrowTypeError, 0, 0, this, NULL);
if (!throwTypeError)
return NULL;
AutoIdVector ids(cx);
if (!throwTypeError->preventExtensions(cx, &ids))
return NULL;
setThrowTypeError(throwTypeError);
/*
* The global object should have |Object.prototype| as its [[Prototype]].
* Eventually we'd like to have standard classes be there from the start,
* and thus we would know we were always setting what had previously been a
* null [[Prototype]], but right now some code assumes it can set the
* [[Prototype]] before standard classes have been initialized. For now,
* only set the [[Prototype]] if it hasn't already been set.
*/
if (shouldSplicePrototype(cx) && !splicePrototype(cx, objectProto))
return NULL;
/*
* Notify any debuggers about the creation of the script for
* |Function.prototype| -- after all initialization, for simplicity.
*/
js_CallNewScriptHook(cx, functionProto->script(), functionProto);
return functionProto;
}
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;
}
PRBool CreateFakeBrowserWindow(JSContext* cx, JSObject* parent, nsIPrincipal* systemPrincipal) {
nsresult rv;
jsval value;
nsCOMPtr<nsIXPConnect> xpc = do_GetService(nsIXPConnect::GetCID());
if (xpc == nsnull) {
JS_ReportError(cx, "Adblock Plus: Coult not retrieve nsIXPConnect - wrong Gecko version?");
return PR_FALSE;
}
rv = xpc->FlagSystemFilenamePrefix("adblockplus.dll/");
if (NS_FAILED(rv)) {
JS_ReportError(cx, "Adblock Plus: Failed to enable protection for inline JavaScript");
return PR_FALSE;
}
JSObject* obj = JS_NewObject(cx, nsnull, nsnull, parent);
if (obj == nsnull) {
JS_ReportError(cx, "Adblock Plus: Failed to create fake browser window object - out of memory?");
return PR_FALSE;
}
JS_SetGlobalObject(cx, obj);
// Have to loop through the methods manually because JS_DefineFunctions won't do anything for some reason
for (JSFunctionSpec *fs = window_methods; fs->name; fs++) {
JSFunction *fun = JS_DefineFunction(cx, obj, fs->name, fs->call, fs->nargs, fs->flags);
if (!fun) {
JS_ReportError(cx, "Adblock Plus: Failed to attach native methods to fake browser window");
return PR_FALSE;
}
}
if (!JS_DefineProperties(cx, obj, window_properties)) {
JS_ReportError(cx, "Adblock Plus: Failed to attach native properties to fake browser window");
return PR_FALSE;
}
JSPrincipals* principals;
rv = systemPrincipal->GetJSPrincipals(cx, &principals);
if (NS_FAILED(rv)) {
JS_ReportError(cx, "Adblock Plus: Could not convert system principal into JavaScript principals");
return PR_FALSE;
}
for (int i = 0; includes[i]; i += 2) {
JSScript* inlineScript = JS_CompileScriptForPrincipals(cx, obj, principals, includes[i+1], strlen(includes[i+1]), includes[i], 1);
if (inlineScript == nsnull) {
JS_ReportError(cx, "Adblock Plus: Failed to compile %s", includes[i]);
return PR_FALSE;
}
if (!JS_ExecuteScript(cx, obj, inlineScript, &value)) {
JS_ReportError(cx, "Adblock Plus: Failed to execute %s", includes[i]);
return PR_FALSE;
}
JS_DestroyScript(cx, inlineScript);
}
JSPRINCIPALS_DROP(cx, principals);
nsCOMPtr<nsISupports> wrapped;
rv = xpc->WrapJS(cx, obj, NS_GET_IID(nsISupports), getter_AddRefs(wrapped));
if (NS_FAILED(rv)) {
JS_ReportError(cx, "Adblock Plus: Failed to create XPConnect wrapper for fake browser window");
return PR_FALSE;
}
fakeBrowserWindow = do_QueryInterface(wrapped);
if (fakeBrowserWindow == nsnull) {
JS_ReportError(cx, "Adblock Plus: Failed to QI fake browser window");
return PR_FALSE;
}
jsval readerVal;
JS_GetProperty(cx, obj, "_dtdReader", &readerVal);
if (readerVal == JSVAL_VOID) {
JS_ReportError(cx, "Adblock Plus: Failed to retrieve DTD reader object");
return PR_FALSE;
}
JSObject* reader = JSVAL_TO_OBJECT(readerVal);
for (int i = 0; i < NUM_LABELS; i++) {
JSString* str = JS_NewStringCopyZ(cx, context_labels[i]);
if (str == nsnull) {
JS_ReportError(cx, "Adblock Plus: Could not create JavaScript string for '%s' - out of memory?", context_labels[i]);
return PR_FALSE;
}
jsval args[] = {STRING_TO_JSVAL(str)};
jsval retval;
if (!JS_CallFunctionName(cx, reader, "getEntity", 1, args, &retval)) {
JS_ReportError(cx, "Adblock Plus: Failed to retrieve entity '%s' from overlay.dtd", context_labels[i]);
return PR_FALSE;
}
str = JS_ValueToString(cx, retval);
if (str == nsnull) {
JS_ReportError(cx, "Adblock Plus: Could not convert return value of _dtdReader.getEntity() to string");
return PR_FALSE;
}
strcpy_s(labelValues[i], sizeof(labelValues[i]), JS_GetStringBytes(str));
}
return PR_TRUE;
}
JSObject *
GlobalObject::initFunctionAndObjectClasses(JSContext *cx)
{
Rooted<GlobalObject*> self(cx, this);
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
JS_ASSERT(isNative());
/*
* Calling a function from a cleared global triggers this (yeah, I know).
* Uncomment this once bug 470510 is fixed (if that bug doesn't remove
* isCleared entirely).
*/
// JS_ASSERT(!isCleared());
/* If cx has no global object, make this the global object. */
if (!cx->globalObject)
JS_SetGlobalObject(cx, self);
RootedObject objectProto(cx);
/*
* Create |Object.prototype| first, mirroring CreateBlankProto but for the
* prototype of the created object.
*/
objectProto = NewObjectWithGivenProto(cx, &ObjectClass, NULL, self);
if (!objectProto || !objectProto->setSingletonType(cx))
return NULL;
/*
* The default 'new' type of Object.prototype is required by type inference
* to have unknown properties, to simplify handling of e.g. heterogenous
* objects in JSON and script literals.
*/
if (!objectProto->setNewTypeUnknown(cx))
return NULL;
/* Create |Function.prototype| next so we can create other functions. */
RootedFunction functionProto(cx);
{
JSObject *functionProto_ = NewObjectWithGivenProto(cx, &FunctionClass, objectProto, self);
if (!functionProto_)
return NULL;
functionProto = functionProto_->toFunction();
/*
* Bizarrely, |Function.prototype| must be an interpreted function, so
* give it the guts to be one.
*/
JSObject *proto = js_NewFunction(cx, functionProto,
NULL, 0, JSFUN_INTERPRETED, self, NULL);
if (!proto)
return NULL;
JS_ASSERT(proto == functionProto);
functionProto->flags |= JSFUN_PROTOTYPE;
const char *rawSource = "() {\n}";
size_t sourceLen = strlen(rawSource);
jschar *source = InflateString(cx, rawSource, &sourceLen);
if (!source)
return NULL;
ScriptSource *ss = cx->new_<ScriptSource>();
if (!ss) {
cx->free_(source);
return NULL;
}
ScriptSourceHolder ssh(cx->runtime, ss);
ss->setSource(source, sourceLen);
CompileOptions options(cx);
options.setNoScriptRval(true)
.setVersion(JSVERSION_DEFAULT);
Rooted<JSScript*> script(cx, JSScript::Create(cx,
/* enclosingScope = */ NullPtr(),
/* savedCallerFun = */ false,
options,
/* staticLevel = */ 0,
ss,
0,
ss->length()));
if (!script || !JSScript::fullyInitTrivial(cx, script))
return NULL;
functionProto->initScript(script);
functionProto->getType(cx)->interpretedFunction = functionProto;
script->setFunction(functionProto);
if (!functionProto->setSingletonType(cx))
return NULL;
/*
* The default 'new' type of Function.prototype is required by type
* inference to have unknown properties, to simplify handling of e.g.
* CloneFunctionObject.
*/
if (!functionProto->setNewTypeUnknown(cx))
return NULL;
}
/* Create the Object function now that we have a [[Prototype]] for it. */
RootedFunction objectCtor(cx);
{
JSObject *ctor = NewObjectWithGivenProto(cx, &FunctionClass, functionProto, self);
if (!ctor)
return NULL;
objectCtor = js_NewFunction(cx, ctor, js_Object, 1, JSFUN_CONSTRUCTOR, self,
CLASS_NAME(cx, Object));
if (!objectCtor)
return NULL;
}
/*
* Install |Object| and |Object.prototype| for the benefit of subsequent
* code that looks for them.
*/
self->setObjectClassDetails(objectCtor, objectProto);
/* Create |Function| so it and |Function.prototype| can be installed. */
RootedFunction functionCtor(cx);
{
// Note that ctor is rooted purely for the JS_ASSERT at the end
RootedObject ctor(cx, NewObjectWithGivenProto(cx, &FunctionClass, functionProto, self));
if (!ctor)
return NULL;
functionCtor = js_NewFunction(cx, ctor, Function, 1, JSFUN_CONSTRUCTOR, self,
CLASS_NAME(cx, Function));
if (!functionCtor)
return NULL;
JS_ASSERT(ctor == functionCtor);
}
/*
* Install |Function| and |Function.prototype| so that we can freely create
* functions and objects without special effort.
*/
self->setFunctionClassDetails(functionCtor, functionProto);
/*
* The hard part's done: now go back and add all the properties these
* primordial values have.
*/
if (!LinkConstructorAndPrototype(cx, objectCtor, objectProto) ||
!DefinePropertiesAndBrand(cx, objectProto, NULL, object_methods))
{
return NULL;
}
/*
* Add an Object.prototype.__proto__ accessor property to implement that
* extension (if it's actually enabled). Cache the getter for this
* function so that cross-compartment [[Prototype]]-getting is implemented
* in one place.
*/
Rooted<JSFunction*> getter(cx, js_NewFunction(cx, NULL, ProtoGetter, 0, 0, self, NULL));
if (!getter)
return NULL;
#if JS_HAS_OBJ_PROTO_PROP
Rooted<JSFunction*> setter(cx, js_NewFunction(cx, NULL, ProtoSetter, 0, 0, self, NULL));
if (!setter)
return NULL;
RootedValue undefinedValue(cx, UndefinedValue());
if (!objectProto->defineProperty(cx, cx->runtime->atomState.protoAtom, undefinedValue,
JS_DATA_TO_FUNC_PTR(PropertyOp, getter.get()),
JS_DATA_TO_FUNC_PTR(StrictPropertyOp, setter.get()),
JSPROP_GETTER | JSPROP_SETTER | JSPROP_SHARED))
{
return NULL;
}
#endif /* JS_HAS_OBJ_PROTO_PROP */
self->setProtoGetter(getter);
if (!DefinePropertiesAndBrand(cx, objectCtor, NULL, object_static_methods) ||
!LinkConstructorAndPrototype(cx, functionCtor, functionProto) ||
!DefinePropertiesAndBrand(cx, functionProto, NULL, function_methods) ||
!DefinePropertiesAndBrand(cx, functionCtor, NULL, NULL))
{
return NULL;
}
/* Add the global Function and Object properties now. */
jsid objectId = NameToId(CLASS_NAME(cx, Object));
if (!self->addDataProperty(cx, objectId, JSProto_Object + JSProto_LIMIT * 2, 0))
return NULL;
jsid functionId = NameToId(CLASS_NAME(cx, Function));
if (!self->addDataProperty(cx, functionId, JSProto_Function + JSProto_LIMIT * 2, 0))
return NULL;
/* Heavy lifting done, but lingering tasks remain. */
/* ES5 15.1.2.1. */
RootedId id(cx, NameToId(cx->runtime->atomState.evalAtom));
JSObject *evalobj = js_DefineFunction(cx, self, id, IndirectEval, 1, JSFUN_STUB_GSOPS);
if (!evalobj)
return NULL;
self->setOriginalEval(evalobj);
/* ES5 13.2.3: Construct the unique [[ThrowTypeError]] function object. */
RootedFunction throwTypeError(cx, js_NewFunction(cx, NULL, ThrowTypeError, 0, 0, self, NULL));
if (!throwTypeError)
return NULL;
if (!throwTypeError->preventExtensions(cx))
return NULL;
self->setThrowTypeError(throwTypeError);
RootedObject intrinsicsHolder(cx, JS_NewObject(cx, NULL, NULL, self));
if (!intrinsicsHolder)
return NULL;
self->setIntrinsicsHolder(intrinsicsHolder);
if (!JS_DefineFunctions(cx, intrinsicsHolder, intrinsic_functions))
return NULL;
/*
* The global object should have |Object.prototype| as its [[Prototype]].
* Eventually we'd like to have standard classes be there from the start,
* and thus we would know we were always setting what had previously been a
* null [[Prototype]], but right now some code assumes it can set the
* [[Prototype]] before standard classes have been initialized. For now,
* only set the [[Prototype]] if it hasn't already been set.
*/
if (self->shouldSplicePrototype(cx) && !self->splicePrototype(cx, objectProto))
return NULL;
/*
* Notify any debuggers about the creation of the script for
* |Function.prototype| -- after all initialization, for simplicity.
*/
js_CallNewScriptHook(cx, functionProto->script(), functionProto);
return functionProto;
}
int main() {
std::string a = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbccccccccccccaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
std::string output;
ZopfliOptions options;
ZopfliInitOptions(&options);
snappy::Compress(a.data(), a.size(), &output);
if(!checkhash((unsigned char *)output.data(), output.size(), (char *)"0x5a8f06cf6817a74bc75c3c8290196928acb04c189ecdd192a93eb3c3")) {
std::cout<<"Something wrong\n";
}
unsigned char b[] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbccccccccccccaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
unsigned char *out = NULL;
size_t outsize = 0;
ZopfliCompress(&options, ZOPFLI_FORMAT_GZIP, b, a.size(), &out, &outsize);
if(!checkhash(out, outsize, (char *)"0x0f66ce213d2d27067ff9ffa8bbde2dd06d7f3e687549fad846169e16")) {
std::cout<<"Something wrong\n";
}
HangulInputContext* ic;
const char* p = "dekde";
const ucschar* commit;
ic = hangul_ic_new("2y");
while (*p != '\0') {
hangul_ic_process(ic, *p);
p++;
}
commit = hangul_ic_get_commit_string(ic);
int len = wcslen((const wchar_t*)commit);
if(!checkhash((unsigned char*)commit, len * sizeof(const wchar_t), (char *)"0xc9bf9374fbc9f4989afd0af7ac9824a4dcc768b33bfa3bb38e42617b")) {
std::cout<<"Something wrong\n";
}
hangul_ic_delete(ic);
static JSClass global_class = { "global",
JSCLASS_NEW_RESOLVE | JSCLASS_GLOBAL_FLAGS,
JS_PropertyStub, JS_PropertyStub, JS_PropertyStub,
JS_StrictPropertyStub,
JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub,
NULL, JSCLASS_NO_OPTIONAL_MEMBERS
};
JSRuntime *rt = JS_NewRuntime(8 * 1024 * 1024);
JSContext *cx = JS_NewContext(rt, 8192);
JS_SetOptions(cx, JSOPTION_VAROBJFIX);
JS_SetErrorReporter(cx, reportError);
JSObject *global = JS_NewCompartmentAndGlobalObject(cx, &global_class, NULL);
JS_SetGlobalObject(cx, global);
if (!JS_InitStandardClasses(cx, global)) {
return 1;
}
char source[] = "Math.random()";
jsval rval;
cx->rngSeed = 31337;
JS_EvaluateScript(cx, global, source, strlen(source),
"none", 10, &rval);
double nums[2];
nums[0] = JSVAL_TO_DOUBLE(rval);
JS_EvaluateScript(cx, global, source, strlen(source),
"none", 10, &rval);
nums[1] = JSVAL_TO_DOUBLE(rval);
if(!checkhash((unsigned char*)nums, 2 * sizeof(double), (char *)"0x61b35e8d466f24ee1ea502350ec6f5d1134fe6ec543c17845fa62f8a")) {
std::cout<<"Something wrong\n";
}
JS_DestroyContext(cx);
JS_DestroyRuntime(rt);
JS_ShutDown();
mtprngParam mt;
byte bay[] = "qqqqqqqqqqqqqqqq";
byte result[100];
for(int i=0; i< 100; i++) {
result[i] = 0;
}
mtprngSetup(&mt);
mtprngSeed(&mt, bay, 16);
mtprngNext(&mt, result, 100);
if(!checkhash((unsigned char*)&result, 100, (char *)"0x7754dfd27fe6fa00551861ff41e4f48315bd89bef6da652f182ce2d6")) {
std::cout<<"Something wrong\n";
}
ranlib::ChiSquare<double> gen(4);
gen.seed(31337);
double f[16];
for(int i = 0; i<16; i++) {
f[i] = gen.random();
}
if(!checkhash((unsigned char*)&f, 16 * sizeof(double), (char *)"0xd19d0c167fe93b11004c0167c226d2e92c17dfa36ffb243f39824098")) {
std::cout<<"Something wrong\n";
}
Botan::byte pass[] = "aaaabbbb";
Botan::PBKDF* pbkdf = Botan::get_pbkdf("PBKDF2(SHA-256)");
Botan::OctetString aes_key = pbkdf->derive_key(32, "pass1337", pass, 8, 31337);
std::string aa = aes_key.as_string();
if(!checkhash((unsigned char*)aa.c_str(), aa.size(), (char *)"0x0c33d122ed50848a676539ae48eb84db0dcbf69e9ee857094755f2d7")) {
std::cout<<"Something wrong\n";
}
std::cout<<"Answer is RUCTF_";
checkhash((unsigned char*)together, pos, (char *)"");
return 0;
}
nsresult
mozJSComponentLoader::GlobalForLocation(nsILocalFile *aComponent,
JSObject **aGlobal,
char **aLocation)
{
nsresult rv;
JSPrincipals* jsPrincipals = nsnull;
JSCLContextHelper cx(mContext);
#ifndef XPCONNECT_STANDALONE
rv = mSystemPrincipal->GetJSPrincipals(cx, &jsPrincipals);
NS_ENSURE_SUCCESS(rv, rv);
JSPrincipalsHolder princHolder(mContext, jsPrincipals);
#endif
nsCOMPtr<nsIXPCScriptable> backstagePass;
rv = mRuntimeService->GetBackstagePass(getter_AddRefs(backstagePass));
NS_ENSURE_SUCCESS(rv, rv);
JSCLAutoErrorReporterSetter aers(cx, mozJSLoaderErrorReporter);
nsCOMPtr<nsIXPConnect> xpc =
do_GetService(kXPConnectServiceContractID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
// Make sure InitClassesWithNewWrappedGlobal() installs the
// backstage pass as the global in our compilation context.
JS_SetGlobalObject(cx, nsnull);
nsCOMPtr<nsIXPConnectJSObjectHolder> holder;
rv = xpc->InitClassesWithNewWrappedGlobal(cx, backstagePass,
NS_GET_IID(nsISupports),
nsIXPConnect::
FLAG_SYSTEM_GLOBAL_OBJECT,
getter_AddRefs(holder));
NS_ENSURE_SUCCESS(rv, rv);
JSObject *global;
rv = holder->GetJSObject(&global);
NS_ENSURE_SUCCESS(rv, rv);
if (!JS_DefineFunctions(cx, global, gGlobalFun)) {
return NS_ERROR_FAILURE;
}
nsCOMPtr<nsIXPConnectJSObjectHolder> locationHolder;
rv = xpc->WrapNative(cx, global, aComponent,
NS_GET_IID(nsILocalFile),
getter_AddRefs(locationHolder));
NS_ENSURE_SUCCESS(rv, rv);
JSObject *locationObj;
rv = locationHolder->GetJSObject(&locationObj);
NS_ENSURE_SUCCESS(rv, rv);
if (!JS_DefineProperty(cx, global, "__LOCATION__",
OBJECT_TO_JSVAL(locationObj), nsnull, nsnull, 0)) {
return NS_ERROR_FAILURE;
}
nsCAutoString nativePath;
// Quick hack to unbust XPCONNECT_STANDALONE.
// This leaves the jsdebugger with a non-URL pathname in the
// XPCONNECT_STANDALONE case - but at least it builds and runs otherwise.
// See: http://bugzilla.mozilla.org/show_bug.cgi?id=121438
#ifdef XPCONNECT_STANDALONE
localFile->GetNativePath(nativePath);
#else
NS_GetURLSpecFromFile(aComponent, nativePath);
#endif
// Before compiling the script, first check to see if we have it in
// the fastload file. Note: as a rule, fastload errors are not fatal
// to loading the script, since we can always slow-load.
nsCOMPtr<nsIFastLoadService> flSvc = do_GetFastLoadService(&rv);
// Save the old state and restore it upon return
FastLoadStateHolder flState(flSvc);
PRBool fastLoading = PR_FALSE;
if (NS_SUCCEEDED(rv)) {
rv = StartFastLoad(flSvc);
if (NS_SUCCEEDED(rv)) {
fastLoading = PR_TRUE;
}
}
nsCOMPtr<nsIURI> uri;
rv = NS_NewURI(getter_AddRefs(uri), nativePath);
NS_ENSURE_SUCCESS(rv, rv);
JSScript *script = nsnull;
if (fastLoading) {
rv = ReadScript(flSvc, nativePath.get(), uri, cx, &script);
if (NS_SUCCEEDED(rv)) {
LOG(("Successfully loaded %s from fastload\n", nativePath.get()));
fastLoading = PR_FALSE; // no need to write out the script
} else if (rv == NS_ERROR_NOT_AVAILABLE) {
// This is ok, it just means the script is not yet in the
// fastload file.
rv = NS_OK;
} else {
LOG(("Failed to deserialize %s\n", nativePath.get()));
// Remove the fastload file, it may be corrupted.
LOG(("Invalid fastload file detected, removing it\n"));
nsCOMPtr<nsIObjectOutputStream> objectOutput;
flSvc->GetOutputStream(getter_AddRefs(objectOutput));
if (objectOutput) {
flSvc->SetOutputStream(nsnull);
objectOutput->Close();
}
nsCOMPtr<nsIObjectInputStream> objectInput;
flSvc->GetInputStream(getter_AddRefs(objectInput));
if (objectInput) {
flSvc->SetInputStream(nsnull);
objectInput->Close();
}
if (mFastLoadFile) {
mFastLoadFile->Remove(PR_FALSE);
}
fastLoading = PR_FALSE;
}
}
if (!script || NS_FAILED(rv)) {
// The script wasn't in the fastload cache, so compile it now.
LOG(("Slow loading %s\n", nativePath.get()));
#ifdef HAVE_PR_MEMMAP
PRInt64 fileSize;
rv = aComponent->GetFileSize(&fileSize);
if (NS_FAILED(rv))
return rv;
PRInt64 maxSize;
LL_UI2L(maxSize, PR_UINT32_MAX);
if (LL_CMP(fileSize, >, maxSize)) {
NS_ERROR("file too large");
return NS_ERROR_FAILURE;
}
PRFileDesc *fileHandle;
rv = aComponent->OpenNSPRFileDesc(PR_RDONLY, 0, &fileHandle);
NS_ENSURE_SUCCESS(rv, rv);
// Make sure the file is closed, no matter how we return.
FileAutoCloser fileCloser(fileHandle);
PRFileMap *map = PR_CreateFileMap(fileHandle, fileSize,
PR_PROT_READONLY);
if (!map) {
NS_ERROR("Failed to create file map");
return NS_ERROR_FAILURE;
}
// Make sure the file map is closed, no matter how we return.
FileMapAutoCloser mapCloser(map);
PRUint32 fileSize32;
LL_L2UI(fileSize32, fileSize);
char *buf = static_cast<char*>(PR_MemMap(map, 0, fileSize32));
if (!buf) {
NS_WARNING("Failed to map file");
return NS_ERROR_FAILURE;
}
script = JS_CompileScriptForPrincipals(cx, global,
jsPrincipals,
buf, fileSize32,
nativePath.get(), 1);
PR_MemUnmap(buf, fileSize32);
#else /* HAVE_PR_MEMMAP */
/**
* No memmap implementation, so fall back to using
* JS_CompileFileHandleForPrincipals().
*/
FILE *fileHandle;
rv = aComponent->OpenANSIFileDesc("r", &fileHandle);
NS_ENSURE_SUCCESS(rv, rv);
script = JS_CompileFileHandleForPrincipals(cx, global,
nativePath.get(),
fileHandle, jsPrincipals);
/* JS will close the filehandle after compilation is complete. */
#endif /* HAVE_PR_MEMMAP */
}
void
gjstest_test_func_gjs_jsapi_util_error_throw(void)
{
JSRuntime *runtime;
JSContext *context;
JSObject *global;
jsval exc, value, previous;
const char *s;
/* create a runtime just to avoid tangling this test with all the
* code surrounding how we create one normally in context.c
*/
runtime = JS_NewRuntime(1024*1024 /* max bytes */);
context = JS_NewContext(runtime, 8192);
JS_BeginRequest(context);
global = JS_NewObject(context, NULL, NULL, NULL);
JS_SetGlobalObject(context, global);
JS_InitStandardClasses(context, global);
JS_SetErrorReporter(context, test_error_reporter);
/* Test that we can throw */
gjs_throw(context, "This is an exception %d", 42);
g_assert(JS_IsExceptionPending(context));
exc = JSVAL_VOID;
JS_GetPendingException(context, &exc);
g_assert(exc != JSVAL_VOID);
value = JSVAL_VOID;
JS_GetProperty(context, JSVAL_TO_OBJECT(exc), "message",
&value);
g_assert(JSVAL_IS_STRING(value));
/* JS_GetStringBytes() is broken for non-ASCII but that's OK here */
s = JS_GetStringBytes(JSVAL_TO_STRING(value));
g_assert(s != NULL);
if (strcmp(s, "This is an exception 42") != 0) {
g_error("Exception has wrong message '%s'",
s);
}
/* keep this around before we clear it */
previous = exc;
JS_AddRoot(context, &previous);
JS_ClearPendingException(context);
g_assert(!JS_IsExceptionPending(context));
/* Check that we don't overwrite a pending exception */
JS_SetPendingException(context, previous);
g_assert(JS_IsExceptionPending(context));
gjs_throw(context, "Second different exception %s", "foo");
g_assert(JS_IsExceptionPending(context));
exc = JSVAL_VOID;
JS_GetPendingException(context, &exc);
g_assert(exc != JSVAL_VOID);
g_assert(exc == previous);
JS_RemoveRoot(context, &previous);
JS_EndRequest(context);
JS_DestroyContext(context);
JS_DestroyRuntime(runtime);
JS_ShutDown();
}
