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;
}
JavaClass_deleteProperty(JSContext *cx, JSObject *obj, jsid id, jsval *vp)
{
JSVersion version = JS_GetVersion(cx);
*vp = JSVAL_FALSE;
if (!JSVERSION_IS_ECMA(version)) {
JS_ReportErrorNumber(cx, jsj_GetErrorMessage, NULL,
JSJMSG_JCLASS_PROP_DELETE);
return JS_FALSE;
} else {
/* Attempts to delete permanent properties are silently ignored
by ECMAScript. */
return JS_TRUE;
}
}
static JSBool
access_java_array_element(JSContext *cx,
JNIEnv *jEnv,
JSObject *obj,
jsid id,
jsval *vp,
JSBool do_assignment)
{
jsval idval;
jarray java_array;
JavaClassDescriptor *class_descriptor;
JavaObjectWrapper *java_wrapper;
jsize array_length, index;
JavaSignature *array_component_signature;
/* printf("In JavaArray_getProperty\n"); */
java_wrapper = JS_GetPrivate(cx, obj);
if (!java_wrapper) {
const char *property_name;
if (JS_IdToValue(cx, id, &idval) && JSVAL_IS_STRING(idval) &&
(property_name = JS_GetStringBytes(JSVAL_TO_STRING(idval))) != NULL) {
if (!strcmp(property_name, "constructor")) {
if (vp)
*vp = JSVAL_VOID;
return JS_TRUE;
}
}
JS_ReportErrorNumber(cx, jsj_GetErrorMessage, NULL,
JSJMSG_BAD_OP_JARRAY);
return JS_FALSE;
}
class_descriptor = java_wrapper->class_descriptor;
java_array = java_wrapper->java_obj;
JS_ASSERT(class_descriptor->type == JAVA_SIGNATURE_ARRAY);
JS_IdToValue(cx, id, &idval);
if (!JSVAL_IS_INT(idval))
idval = try_convert_to_jsint(cx, idval);
if (!JSVAL_IS_INT(idval)) {
/*
* Usually, properties of JavaArray objects are indexed by integers, but
* Java arrays also inherit all the methods of java.lang.Object, so a
* string-valued property is also possible.
*/
if (JSVAL_IS_STRING(idval)) {
const char *member_name;
member_name = JS_GetStringBytes(JSVAL_TO_STRING(idval));
if (do_assignment) {
JSVersion version = JS_GetVersion(cx);
if (!JSVERSION_IS_ECMA(version)) {
JS_ReportErrorNumber(cx, jsj_GetErrorMessage, NULL,
JSJMSG_CANT_WRITE_JARRAY, member_name);
return JS_FALSE;
} else {
if (vp)
*vp = JSVAL_VOID;
return JS_TRUE;
}
} else {
if (!strcmp(member_name, "length")) {
array_length = jsj_GetJavaArrayLength(cx, jEnv, java_array);
if (array_length < 0)
return JS_FALSE;
if (vp)
*vp = INT_TO_JSVAL(array_length);
return JS_TRUE;
}
/* Check to see if we're reflecting a Java array method */
return JavaObject_getPropertyById(cx, obj, id, vp);
}
}
JS_ReportErrorNumber(cx, jsj_GetErrorMessage, NULL,
JSJMSG_BAD_INDEX_EXPR);
return JS_FALSE;
}
index = JSVAL_TO_INT(idval);
#if 0
array_length = jsj_GetJavaArrayLength(cx, jEnv, java_array);
if (array_length < 0)
return JS_FALSE;
/* Just let Java throw an exception instead of checking array bounds here */
if (index < 0 || index >= array_length) {
char numBuf[12];
sprintf(numBuf, "%d", index);
JS_ReportErrorNumber(cx, jsj_GetErrorMessage, NULL,
JSJMSG_BAD_JARRAY_INDEX, numBuf);
return JS_FALSE;
}
#endif
array_component_signature = class_descriptor->array_component_signature;
if (!vp)
return JS_TRUE;
if (do_assignment) {
return jsj_SetJavaArrayElement(cx, jEnv, java_array, index,
array_component_signature, *vp);
} else {
return jsj_GetJavaArrayElement(cx, jEnv, java_array, index,
array_component_signature, vp);
}
}
void GlobalInfo::Functions::version::call(JSContext* cx, JS::CallArgs args) {
ValueReader(cx, args.rval()).fromStringData(JS_VersionToString(JS_GetVersion(cx)));
}
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;
}
~AutoVersionChecker() {
#ifdef DEBUG
JSVersion versionAfter = JS_GetVersion(cx);
NS_ABORT_IF_FALSE(versionAfter == versionBefore, "version must not change");
#endif
}
explicit AutoVersionChecker(JSContext *cx) : cx(cx) {
#ifdef DEBUG
versionBefore = JS_GetVersion(cx);
#endif
}