JSObject*
gjs_construct_object_dynamic(JSContext *context,
JSObject *proto,
uintN argc,
jsval *argv)
{
RuntimeData *rd;
JSClass *proto_class;
JSContext *load_context;
JSObject *result;
JS_BeginRequest(context);
/* We replace the passed-in context and global object with our
* runtime-global permanent load context. Otherwise, JS_ConstructObject
* can't find the constructor in whatever random global object is set
* on the passed-in context.
*/
load_context = gjs_runtime_get_load_context(JS_GetRuntime(context));
JS_BeginRequest(load_context);
proto_class = JS_GET_CLASS(load_context, proto);
rd = get_data_from_context(load_context);
/* Check that it's safe to cast to DynamicJSClass */
if (g_hash_table_lookup(rd->dynamic_classes, proto_class) == NULL) {
gjs_throw(load_context, "Prototype is not for a dynamically-registered class");
goto error;
}
gjs_debug_lifecycle(GJS_DEBUG_GREPO,
"Constructing instance of dynamic class %s %p from proto %p",
proto_class->name, proto_class, proto);
if (argc > 0)
result = JS_ConstructObjectWithArguments(load_context, proto_class, proto, NULL, argc, argv);
else
result = JS_ConstructObject(load_context, proto_class, proto, NULL);
if (!result)
goto error;
JS_EndRequest(load_context);
JS_EndRequest(context);
return result;
error:
/* Move the exception to the calling context from load context.
*/
if (!gjs_move_exception(load_context, context)) {
/* set an exception since none was set */
gjs_throw(context, "No exception was set, but object construction failed somehow");
}
JS_EndRequest(load_context);
JS_EndRequest(context);
return NULL;
}
JSObject *
gom_js_mouse_event_init_class (JSContext *cx, JSObject *obj)
{
gom_js_object_register_js_class (cx, GOM_TYPE_MOUSE_EVENT, &GomJSMouseEventClass);
return JS_InitClass (cx, obj,
JS_ConstructObject (cx, &GomJSUIEventClass, NULL, NULL),
&GomJSMouseEventClass, gom_js_mouse_event_construct, 0,
gom_js_mouse_event_props, gom_js_mouse_event_funcs, NULL, NULL);
}
JSObject * ScriptingHost::CreateCustomObject(const std::string & typeName)
{
std::map < std::string, CustomType > ::iterator it = m_CustomObjectTypes.find(typeName);
if (it == m_CustomObjectTypes.end())
throw PSERROR_Scripting_TypeDoesNotExist();
return JS_ConstructObject(m_Context, (*it).second.m_Class, (*it).second.m_Object, NULL);
}
static JSObject*
importer_new(JSContext *context)
{
JSObject *importer;
Importer *priv;
JSObject *global;
(void) priv;
global = gjs_get_import_global(context);
if (!gjs_object_has_property(context, global, gjs_importer_class.name)) {
JSObject *prototype;
prototype = JS_InitClass(context, global,
/* parent prototype JSObject* for
* prototype; NULL for
* Object.prototype
*/
NULL,
&gjs_importer_class,
/* constructor for instances (NULL for
* none - just name the prototype like
* Math - rarely correct)
*/
gjs_importer_constructor,
/* number of constructor args */
0,
/* props of prototype */
&gjs_importer_proto_props[0],
/* funcs of prototype */
&gjs_importer_proto_funcs[0],
/* props of constructor, MyConstructor.myprop */
NULL,
/* funcs of constructor, MyConstructor.myfunc() */
NULL);
if (prototype == NULL)
gjs_fatal("Can't init class %s", gjs_importer_class.name);
g_assert(gjs_object_has_property(context, global, gjs_importer_class.name));
gjs_debug(GJS_DEBUG_IMPORTER, "Initialized class %s prototype %p",
gjs_importer_class.name, prototype);
}
importer = JS_ConstructObject(context, &gjs_importer_class, NULL, global);
if (importer == NULL)
gjs_fatal("No memory to create ns object");
return importer;
}
static JSBool
import_native_file(JSContext *context,
JSObject *obj,
const char *name,
const char *full_path)
{
JSObject *module_obj;
GjsNativeFlags flags;
JSBool retval = JS_FALSE;
gjs_debug(GJS_DEBUG_IMPORTER,
"Importing '%s' from '%s'", name, full_path ? full_path : "<internal>");
module_obj = JS_ConstructObject(context, NULL, NULL, NULL);
if (module_obj == NULL) {
return JS_FALSE;
}
/* We store the module object into the parent module before
* initializing the module. If the module has the
* GJS_NATIVE_SUPPLIES_MODULE_OBJ flag, it will just overwrite
* the reference we stored when it initializes.
*/
if (!define_import(context, obj, module_obj, name))
return JS_FALSE;
if (!define_meta_properties(context, module_obj, name, obj))
goto out;
if (!gjs_import_native_module(context, module_obj, full_path, &flags))
goto out;
if (!finish_import(context, name))
goto out;
if (!seal_import(context, obj, name))
goto out;
retval = JS_TRUE;
out:
if (!retval)
cancel_import(context, obj, name);
return retval;
}
JSObject*
gjs_keep_alive_new(JSContext *context)
{
JSObject *keep_alive;
JSObject *global;
/* This function creates an unattached KeepAlive object; following our
* general strategy, we have a single KeepAlive class with a constructor
* stored on our single "load global" pseudo-global object, and we create
* instances with the load global as parent.
*/
g_assert(context != NULL);
JS_BeginRequest(context);
global = gjs_get_import_global(context);
g_assert(global != NULL);
if (!gjs_object_has_property(context, global, gjs_keep_alive_class.name)) {
JSObject *prototype;
gjs_debug(GJS_DEBUG_KEEP_ALIVE,
"Initializing keep-alive class in context %p global %p",
context, global);
prototype = JS_InitClass(context, global,
/* parent prototype JSObject* for
* prototype; NULL for
* Object.prototype
*/
NULL,
&gjs_keep_alive_class,
/* constructor for instances (NULL for
* none - just name the prototype like
* Math - rarely correct)
*/
gjs_keep_alive_constructor,
/* number of constructor args */
0,
/* props of prototype */
&gjs_keep_alive_proto_props[0],
/* funcs of prototype */
&gjs_keep_alive_proto_funcs[0],
/* props of constructor, MyConstructor.myprop */
NULL,
/* funcs of constructor, MyConstructor.myfunc() */
NULL);
if (prototype == NULL)
gjs_fatal("Can't init class %s", gjs_keep_alive_class.name);
g_assert(gjs_object_has_property(context, global, gjs_keep_alive_class.name));
gjs_debug(GJS_DEBUG_KEEP_ALIVE, "Initialized class %s prototype %p",
gjs_keep_alive_class.name, prototype);
}
gjs_debug(GJS_DEBUG_KEEP_ALIVE,
"Creating new keep-alive object for context %p global %p",
context, global);
keep_alive = JS_ConstructObject(context, &gjs_keep_alive_class, NULL, global);
if (keep_alive == NULL) {
gjs_log_exception(context, NULL);
gjs_fatal("Failed to create keep_alive object");
}
JS_EndRequest(context);
return keep_alive;
}
JSObject*
gjs_keep_alive_new(JSContext *context)
{
JSObject *keep_alive;
JSObject *global;
g_assert(context != NULL);
JS_BeginRequest(context);
/* put constructor in the global namespace */
global = JS_GetGlobalObject(context);
g_assert(global != NULL);
if (!gjs_object_has_property(context, global, gjs_keep_alive_class.name)) {
JSObject *prototype;
gjs_debug(GJS_DEBUG_KEEP_ALIVE,
"Initializing keep-alive class in context %p global %p",
context, global);
prototype = JS_InitClass(context, global,
/* parent prototype JSObject* for
* prototype; NULL for
* Object.prototype
*/
NULL,
&gjs_keep_alive_class,
/* constructor for instances (NULL for
* none - just name the prototype like
* Math - rarely correct)
*/
keep_alive_constructor,
/* number of constructor args */
0,
/* props of prototype */
&gjs_keep_alive_proto_props[0],
/* funcs of prototype */
&gjs_keep_alive_proto_funcs[0],
/* props of constructor, MyConstructor.myprop */
NULL,
/* funcs of constructor, MyConstructor.myfunc() */
NULL);
if (prototype == NULL)
gjs_fatal("Can't init class %s", gjs_keep_alive_class.name);
g_assert(gjs_object_has_property(context, global, gjs_keep_alive_class.name));
gjs_debug(GJS_DEBUG_KEEP_ALIVE, "Initialized class %s prototype %p",
gjs_keep_alive_class.name, prototype);
}
gjs_debug(GJS_DEBUG_KEEP_ALIVE,
"Creating new keep-alive object for context %p global %p",
context, global);
/* Without the "global" parent object, this craters inside of
* xulrunner because in jsobj.c:js_ConstructObject it looks up
* VOID as the constructor. Exploring in gdb, it is walking up
* the scope chain in a way that involves scary xpconnect-looking
* stuff. Having "global" as parent seems to fix it. But, it would
* not hurt to understand this better.
*/
keep_alive = JS_ConstructObject(context, &gjs_keep_alive_class, NULL, global);
if (keep_alive == NULL) {
gjs_log_exception(context, NULL);
gjs_fatal("Failed to create keep_alive object");
}
JS_EndRequest(context);
return keep_alive;
}
static JSBool
import_file(JSContext *context,
JSObject *obj,
const char *name,
const char *full_path)
{
char *script;
gsize script_len;
JSObject *module_obj;
GError *error;
jsval script_retval;
JSBool retval = JS_FALSE;
gjs_debug(GJS_DEBUG_IMPORTER,
"Importing '%s'", full_path);
module_obj = JS_ConstructObject(context, NULL, NULL, NULL);
if (module_obj == NULL) {
return JS_FALSE;
}
if (!define_import(context, obj, module_obj, name))
return JS_FALSE;
if (!define_meta_properties(context, module_obj, name, obj))
goto out;
script = NULL;
script_len = 0;
error = NULL;
if (!g_file_get_contents(full_path, &script, &script_len, &error)) {
gjs_throw(context, "Could not open %s: %s", full_path, error->message);
g_error_free(error);
goto out;
}
g_assert(script != NULL);
if (!JS_EvaluateScript(context,
module_obj,
script,
script_len,
full_path,
1, /* line number */
&script_retval)) {
g_free(script);
/* If JSOPTION_DONT_REPORT_UNCAUGHT is set then the exception
* would be left set after the evaluate and not go to the error
* reporter function.
*/
if (JS_IsExceptionPending(context)) {
gjs_debug(GJS_DEBUG_IMPORTER,
"Module '%s' left an exception set",
name);
gjs_log_and_keep_exception(context, NULL);
} else {
gjs_throw(context,
"JS_EvaluateScript() returned FALSE but did not set exception");
}
goto out;
}
g_free(script);
if (!finish_import(context, name))
goto out;
if (!seal_import(context, obj, name))
goto out;
retval = JS_TRUE;
out:
if (!retval)
cancel_import(context, obj, name);
return retval;
}