JSObject*
gjs_param_from_g_param(JSContext *context,
GParamSpec *gparam)
{
JSObject *obj;
Param *priv;
if (gparam == NULL)
return NULL;
gjs_debug(GJS_DEBUG_GPARAM,
"Wrapping %s '%s' on %s with JSObject",
g_type_name(G_TYPE_FROM_INSTANCE((GTypeInstance*) gparam)),
gparam->name,
g_type_name(gparam->owner_type));
JS::RootedObject proto(context, gjs_lookup_param_prototype(context));
obj = JS_NewObjectWithGivenProto(context, JS_GetClass(proto), proto);
GJS_INC_COUNTER(param);
priv = g_slice_new0(Param);
JS_SetPrivate(obj, priv);
priv->gparam = gparam;
g_param_spec_ref (gparam);
gjs_debug(GJS_DEBUG_GPARAM,
"JSObject created with param instance %p type %s",
priv->gparam, g_type_name(G_TYPE_FROM_INSTANCE((GTypeInstance*) priv->gparam)));
return obj;
}
static FundamentalInstance *
init_fundamental_instance(JSContext *context,
JSObject *object)
{
Fundamental *proto_priv;
FundamentalInstance *priv;
JS_BeginRequest(context);
priv = g_slice_new0(FundamentalInstance);
GJS_INC_COUNTER(fundamental);
g_assert(priv_from_js(context, object) == NULL);
JS_SetPrivate(object, priv);
gjs_debug_lifecycle(GJS_DEBUG_GFUNDAMENTAL,
"fundamental instance constructor, obj %p priv %p proto %p ",
object, priv, JS_GetPrototype (object));
proto_priv = proto_priv_from_js(context, object);
g_assert(proto_priv != NULL);
priv->prototype = proto_priv;
JS_EndRequest(context);
return priv;
}
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_NewObject(context, &gjs_importer_class, NULL, global);
if (importer == NULL)
gjs_fatal("No memory to create importer importer");
priv = g_slice_new0(Importer);
GJS_INC_COUNTER(importer);
g_assert(priv_from_js(context, importer) == NULL);
JS_SetPrivate(importer, priv);
gjs_debug_lifecycle(GJS_DEBUG_IMPORTER,
"importer constructor, obj %p priv %p", importer, priv);
return importer;
}
JSObject*
gjs_boxed_from_c_struct(JSContext *context,
GIStructInfo *info,
void *gboxed,
GjsBoxedCreationFlags flags)
{
JSObject *obj;
JSObject *proto;
Boxed *priv;
Boxed *proto_priv;
if (gboxed == NULL)
return NULL;
gjs_debug_marshal(GJS_DEBUG_GBOXED,
"Wrapping struct %s %p with JSObject",
g_base_info_get_name((GIBaseInfo *)info), gboxed);
proto = gjs_lookup_boxed_prototype(context, info);
proto_priv = priv_from_js(context, proto);
obj = JS_NewObjectWithGivenProto(context,
JS_GET_CLASS(context, proto), proto,
gjs_get_import_global (context));
GJS_INC_COUNTER(boxed);
priv = g_slice_new0(Boxed);
*priv = *proto_priv;
g_base_info_ref( (GIBaseInfo*) priv->info);
JS_SetPrivate(context, obj, priv);
if ((flags & GJS_BOXED_CREATION_NO_COPY) != 0) {
/* we need to create a JS Boxed which references the
* original C struct, not a copy of it. Used for
* G_SIGNAL_TYPE_STATIC_SCOPE
*/
priv->gboxed = gboxed;
priv->not_owning_gboxed = TRUE;
} else {
if (priv->gtype != G_TYPE_NONE && g_type_is_a (priv->gtype, G_TYPE_BOXED)) {
priv->gboxed = g_boxed_copy(priv->gtype, gboxed);
} else if (priv->gtype == G_TYPE_VARIANT) {
priv->gboxed = g_variant_ref_sink (gboxed);
} else if (priv->can_allocate_directly) {
boxed_new_direct(priv);
memcpy(priv->gboxed, gboxed, g_struct_info_get_size (priv->info));
} else {
gjs_throw(context,
"Can't create a Javascript object for %s; no way to copy",
g_base_info_get_name( (GIBaseInfo*) priv->info));
}
}
return obj;
}
void
gjs_define_error_class(JSContext *context,
JSObject *in_object,
GIEnumInfo *info)
{
const char *constructor_name;
GIBoxedInfo *glib_error_info;
JSObject *prototype, *parent_proto;
JSObject *constructor;
Error *priv;
/* See the comment in gjs_define_boxed_class() for an
* explanation of how this all works; Error is pretty much the
* same as Boxed (except that we inherit from GLib.Error).
*/
constructor_name = g_base_info_get_name( (GIBaseInfo*) info);
g_irepository_require(NULL, "GLib", "2.0", (GIRepositoryLoadFlags) 0, NULL);
glib_error_info = (GIBoxedInfo*) g_irepository_find_by_name(NULL, "GLib", "Error");
parent_proto = gjs_lookup_generic_prototype(context, glib_error_info);
g_base_info_unref((GIBaseInfo*)glib_error_info);
if (!gjs_init_class_dynamic(context, in_object,
parent_proto,
g_base_info_get_namespace( (GIBaseInfo*) info),
constructor_name,
&gjs_error_class,
gjs_error_constructor, 1,
/* props of prototype */
&gjs_error_proto_props[0],
/* funcs of prototype */
&gjs_error_proto_funcs[0],
/* props of constructor, MyConstructor.myprop */
NULL,
/* funcs of constructor, MyConstructor.myfunc() */
&gjs_error_constructor_funcs[0],
&prototype,
&constructor)) {
gjs_log_exception(context);
g_error("Can't init class %s", constructor_name);
}
GJS_INC_COUNTER(gerror);
priv = g_slice_new0(Error);
priv->info = info;
g_base_info_ref( (GIBaseInfo*) priv->info);
priv->domain = g_quark_from_string (g_enum_info_get_error_domain(priv->info));
JS_SetPrivate(prototype, priv);
gjs_debug(GJS_DEBUG_GBOXED, "Defined class %s prototype is %p class %p in object %p",
constructor_name, prototype, JS_GetClass(prototype), in_object);
gjs_define_enum_values(context, constructor, priv->info);
gjs_define_enum_static_methods(context, constructor, priv->info);
}
static JSBool
get_nested_interface_object (JSContext *context,
JSObject *parent_obj,
Boxed *parent_priv,
GIFieldInfo *field_info,
GITypeInfo *type_info,
GIBaseInfo *interface_info,
jsval *value)
{
JSObject *obj;
JSObject *proto;
int offset;
Boxed *priv;
Boxed *proto_priv;
if (!struct_is_simple ((GIStructInfo *)interface_info)) {
gjs_throw(context, "Reading field %s.%s is not supported",
g_base_info_get_name ((GIBaseInfo *)parent_priv->info),
g_base_info_get_name ((GIBaseInfo *)field_info));
return JS_FALSE;
}
proto = gjs_lookup_boxed_prototype(context, (GIBoxedInfo*) interface_info);
proto_priv = priv_from_js(context, proto);
offset = g_field_info_get_offset (field_info);
obj = JS_NewObjectWithGivenProto(context,
JS_GET_CLASS(context, proto), proto,
gjs_get_import_global (context));
if (obj == NULL)
return JS_FALSE;
GJS_INC_COUNTER(boxed);
priv = g_slice_new0(Boxed);
JS_SetPrivate(context, obj, priv);
priv->info = (GIBoxedInfo*) interface_info;
g_base_info_ref( (GIBaseInfo*) priv->info);
priv->gtype = g_registered_type_info_get_g_type ((GIRegisteredTypeInfo*) interface_info);
priv->can_allocate_directly = proto_priv->can_allocate_directly;
/* A structure nested inside a parent object; doesn't have an independent allocation */
priv->gboxed = ((char *)parent_priv->gboxed) + offset;
priv->not_owning_gboxed = TRUE;
/* We never actually read the reserved slot, but we put the parent object
* into it to hold onto the parent object.
*/
JS_SetReservedSlot(context, obj, 0,
OBJECT_TO_JSVAL (parent_obj));
*value = OBJECT_TO_JSVAL(obj);
return JS_TRUE;
}
JSObject*
gjs_error_from_gerror(JSContext *context,
GError *gerror,
gboolean add_stack)
{
JSObject *obj;
JSObject *proto;
Error *priv;
Error *proto_priv;
GIEnumInfo *info;
if (gerror == NULL)
return NULL;
info = find_error_domain_info(gerror->domain);
if (!info) {
/* We don't have error domain metadata */
/* Marshal the error as a plain GError */
GIBaseInfo *glib_boxed;
JSObject *retval;
glib_boxed = g_irepository_find_by_name(NULL, "GLib", "Error");
retval = gjs_boxed_from_c_struct(context, glib_boxed, gerror, 0);
g_base_info_unref(glib_boxed);
return retval;
}
gjs_debug_marshal(GJS_DEBUG_GBOXED,
"Wrapping struct %s %p with JSObject",
g_base_info_get_name((GIBaseInfo *)info), gboxed);
proto = gjs_lookup_error_prototype(context, info);
proto_priv = priv_from_js(context, proto);
obj = JS_NewObjectWithGivenProto(context,
JS_GET_CLASS(context, proto), proto,
gjs_get_import_global (context));
GJS_INC_COUNTER(gerror);
priv = g_slice_new0(Error);
JS_SetPrivate(context, obj, priv);
priv->info = info;
priv->domain = proto_priv->domain;
g_base_info_ref( (GIBaseInfo*) priv->info);
priv->gerror = g_error_copy(gerror);
if (add_stack)
define_error_properties(context, obj);
return obj;
}
bool
gjs_define_interface_class(JSContext *context,
JS::HandleObject in_object,
GIInterfaceInfo *info,
GType gtype,
JS::MutableHandleObject constructor)
{
Interface *priv;
const char *constructor_name;
const char *ns;
JS::RootedObject prototype(context);
ns = gjs_get_names_from_gtype_and_gi_info(gtype, (GIBaseInfo *) info,
&constructor_name);
if (!gjs_init_class_dynamic(context, in_object,
JS::NullPtr(),
ns,
constructor_name,
&gjs_interface_class,
gjs_interface_constructor, 0,
/* props of prototype */
&gjs_interface_proto_props[0],
/* funcs of prototype */
&gjs_interface_proto_funcs[0],
/* props of constructor, MyConstructor.myprop */
NULL,
/* funcs of constructor, MyConstructor.myfunc() */
NULL,
&prototype,
constructor)) {
g_error("Can't init class %s", constructor_name);
}
GJS_INC_COUNTER(interface);
priv = g_slice_new0(Interface);
priv->info = info == NULL ? NULL : g_base_info_ref((GIBaseInfo *) info);
priv->gtype = gtype;
priv->vtable = (GTypeInterface *) g_type_default_interface_ref(gtype);
JS_SetPrivate(prototype, priv);
/* If we have no GIRepository information, then this interface was defined
* from within GJS and therefore has no C static methods to be defined. */
if (priv->info)
gjs_define_static_methods(context, constructor, priv->gtype, priv->info);
JS::RootedObject gtype_obj(context,
gjs_gtype_create_gtype_wrapper(context, priv->gtype));
JS_DefineProperty(context, constructor, "$gtype", gtype_obj, JSPROP_PERMANENT);
return true;
}
GClosure*
gjs_closure_new(JSContext *context,
JSObject *callable,
const char *description,
gboolean root_function)
{
Closure *c;
c = (Closure*) g_closure_new_simple(sizeof(Closure), NULL);
c->runtime = JS_GetRuntime(context);
/* The saved context is used for lifetime management, so that the closure will
* be torn down with the context that created it. The context could be attached to
* the default context of the runtime using if we wanted the closure to survive
* the context that created it.
*/
c->context = context;
JS_BeginRequest(context);
c->obj = callable;
c->unref_on_global_object_finalized = FALSE;
GJS_INC_COUNTER(closure);
/* the finalize notifier right now is purely to track the counter
* of how many closures are alive.
*/
g_closure_add_finalize_notifier(&c->base, NULL, closure_finalized);
if (root_function) {
/* Fully manage closure lifetime if so asked */
gjs_keep_alive_add_global_child(context,
global_context_finalized,
c->obj,
c);
g_closure_add_invalidate_notifier(&c->base, NULL, closure_invalidated);
} else {
/* Only mark the closure as invalid if memory is managed
outside (i.e. by object.c for signals) */
g_closure_add_invalidate_notifier(&c->base, NULL, closure_set_invalid);
}
gjs_debug_closure("Create closure %p which calls object %p '%s'",
c, c->obj, description);
JS_EndRequest(context);
return &c->base;
}
JSBool
gjs_define_error_class(JSContext *context,
JSObject *in_object,
GIEnumInfo *info,
JSObject **constructor_p,
JSObject **prototype_p)
{
const char *constructor_name;
GIBoxedInfo *glib_error_info;
JSObject *prototype, *parent_proto;
JSObject *constructor;
jsval value;
Error *priv;
/* See the comment in gjs_define_boxed_class() for an
* explanation of how this all works; Error is pretty much the
* same as Boxed (except that we inherit from GLib.Error).
*/
constructor_name = g_base_info_get_name( (GIBaseInfo*) info);
if (gjs_object_get_property(context, in_object, constructor_name, &value)) {
JSObject *constructor;
if (!JSVAL_IS_OBJECT(value)) {
gjs_throw(context, "Existing property '%s' does not look like a constructor",
constructor_name);
return JS_FALSE;
}
constructor = JSVAL_TO_OBJECT(value);
gjs_object_get_property(context, constructor, "prototype", &value);
if (!JSVAL_IS_OBJECT(value)) {
gjs_throw(context, "error %s prototype property does not appear to exist or has wrong type", constructor_name);
return JS_FALSE;
} else {
if (prototype_p)
*prototype_p = JSVAL_TO_OBJECT(value);
if (constructor_p)
*constructor_p = constructor;
return JS_TRUE;
}
}
g_irepository_require(NULL, "GLib", "2.0", 0, NULL);
glib_error_info = (GIBoxedInfo*) g_irepository_find_by_name(NULL, "GLib", "Error");
parent_proto = gjs_lookup_boxed_prototype(context, glib_error_info);
g_base_info_unref((GIBaseInfo*)glib_error_info);
prototype = gjs_init_class_dynamic(context, in_object,
parent_proto,
g_base_info_get_namespace( (GIBaseInfo*) info),
constructor_name,
&gjs_error_class,
gjs_error_constructor,
/* number of constructor args (less can be passed) */
1,
/* props of prototype */
&gjs_error_proto_props[0],
/* funcs of prototype */
&gjs_error_proto_funcs[0],
/* props of constructor, MyConstructor.myprop */
NULL,
/* funcs of constructor, MyConstructor.myfunc() */
&gjs_error_constructor_funcs[0]);
if (prototype == NULL) {
gjs_log_exception(context, NULL);
gjs_fatal("Can't init class %s", constructor_name);
}
g_assert(gjs_object_has_property(context, in_object, constructor_name));
GJS_INC_COUNTER(gerror);
priv = g_slice_new0(Error);
priv->info = info;
g_base_info_ref( (GIBaseInfo*) priv->info);
priv->domain = g_quark_from_string (g_enum_info_get_error_domain(priv->info));
JS_SetPrivate(context, prototype, priv);
gjs_debug(GJS_DEBUG_GBOXED, "Defined class %s prototype is %p class %p in object %p",
constructor_name, prototype, JS_GET_CLASS(context, prototype), in_object);
constructor = NULL;
gjs_object_get_property(context, in_object, constructor_name, &value);
if (!JSVAL_IS_VOID(value)) {
if (!JSVAL_IS_OBJECT(value)) {
gjs_throw(context, "Property '%s' does not look like a constructor",
constructor_name);
return JS_FALSE;
}
}
constructor = JSVAL_TO_OBJECT(value);
gjs_define_enum_values(context, constructor, priv->info);
if (constructor_p)
*constructor_p = constructor;
if (prototype_p)
*prototype_p = prototype;
return JS_TRUE;
}
JSBool
gjs_define_boxed_class(JSContext *context,
JSObject *in_object,
GIBoxedInfo *info,
JSObject **constructor_p,
JSObject **prototype_p)
{
const char *constructor_name;
JSObject *prototype;
JSObject *constructor;
jsval value;
Boxed *priv;
/* See the comment in gjs_define_object_class() for an
* explanation of how this all works; Boxed is pretty much the
* same as Object.
*/
constructor_name = g_base_info_get_name( (GIBaseInfo*) info);
if (gjs_object_get_property(context, in_object, constructor_name, &value)) {
JSObject *constructor;
if (!JSVAL_IS_OBJECT(value)) {
gjs_throw(context, "Existing property '%s' does not look like a constructor",
constructor_name);
return JS_FALSE;
}
constructor = JSVAL_TO_OBJECT(value);
gjs_object_get_property(context, constructor, "prototype", &value);
if (!JSVAL_IS_OBJECT(value)) {
gjs_throw(context, "boxed %s prototype property does not appear to exist or has wrong type", constructor_name);
return JS_FALSE;
} else {
if (prototype_p)
*prototype_p = JSVAL_TO_OBJECT(value);
if (constructor_p)
*constructor_p = constructor;
return JS_TRUE;
}
}
if (!gjs_init_class_dynamic(context, in_object,
NULL, /* parent prototype */
g_base_info_get_namespace( (GIBaseInfo*) info),
constructor_name,
&gjs_boxed_class,
gjs_boxed_constructor, 1,
/* props of prototype */
&gjs_boxed_proto_props[0],
/* funcs of prototype */
&gjs_boxed_proto_funcs[0],
/* props of constructor, MyConstructor.myprop */
NULL,
/* funcs of constructor, MyConstructor.myfunc() */
NULL,
&prototype,
&constructor)) {
gjs_log_exception(context, NULL);
gjs_fatal("Can't init class %s", constructor_name);
}
GJS_INC_COUNTER(boxed);
priv = g_slice_new0(Boxed);
priv->info = info;
boxed_fill_prototype_info(priv);
g_base_info_ref( (GIBaseInfo*) priv->info);
priv->gtype = g_registered_type_info_get_g_type ((GIRegisteredTypeInfo*) priv->info);
JS_SetPrivate(context, prototype, priv);
gjs_debug(GJS_DEBUG_GBOXED, "Defined class %s prototype is %p class %p in object %p",
constructor_name, prototype, JS_GET_CLASS(context, prototype), in_object);
priv->can_allocate_directly = struct_is_simple (priv->info);
define_boxed_class_fields (context, priv, prototype);
gjs_define_static_methods (context, constructor, priv->gtype, priv->info);
value = OBJECT_TO_JSVAL(gjs_gtype_create_gtype_wrapper(context, priv->gtype));
JS_DefineProperty(context, constructor, "$gtype", value,
NULL, NULL, JSPROP_PERMANENT);
if (constructor_p)
*constructor_p = constructor;
if (prototype_p)
*prototype_p = prototype;
return JS_TRUE;
}
JSBool
gjs_define_interface_class(JSContext *context,
JSObject *in_object,
GIInterfaceInfo *info,
JSObject **prototype_p)
{
Interface *priv;
const char *constructor_name;
JSObject *constructor;
JSObject *prototype;
jsval value;
constructor_name = g_base_info_get_name((GIBaseInfo*)info);
gjs_object_get_property(context, in_object, constructor_name, &value);
if (!JSVAL_IS_VOID(value)) {
JSObject *constructor;
if (!JSVAL_IS_OBJECT(value)) {
gjs_throw(context, "Existing property '%s' does not look like a constructor",
constructor_name);
return JS_FALSE;
}
constructor = JSVAL_TO_OBJECT(value);
gjs_object_get_property(context, constructor, "prototype", &value);
if (!JSVAL_IS_OBJECT(value)) {
gjs_throw(context, "prototype property does not appear to exist or has wrong type");
return JS_FALSE;
} else {
if (prototype_p)
*prototype_p = JSVAL_TO_OBJECT(value);
return JS_TRUE;
}
return JS_TRUE;
}
if (!gjs_init_class_dynamic(context, in_object,
NULL,
g_base_info_get_namespace((GIBaseInfo*)info),
constructor_name,
&gjs_interface_class,
gjs_interface_constructor, 0,
/* props of prototype */
&gjs_interface_proto_props[0],
/* funcs of prototype */
&gjs_interface_proto_funcs[0],
/* props of constructor, MyConstructor.myprop */
NULL,
/* funcs of constructor, MyConstructor.myfunc() */
NULL,
&prototype,
&constructor)) {
gjs_fatal("Can't init class %s", constructor_name);
}
GJS_INC_COUNTER(interface);
priv = g_slice_new0(Interface);
priv->info = info;
priv->gtype = g_registered_type_info_get_g_type(priv->info);
g_base_info_ref((GIBaseInfo*)priv->info);
JS_SetPrivate(context, prototype, priv);
gjs_define_static_methods(context, constructor, priv->gtype, priv->info);
value = OBJECT_TO_JSVAL(gjs_gtype_create_gtype_wrapper(context, priv->gtype));
JS_DefineProperty(context, constructor, "$gtype", value,
NULL, NULL, JSPROP_PERMANENT);
if (prototype_p)
*prototype_p = prototype;
return JS_TRUE;
}
static JSObject*
ns_new(JSContext *context,
const char *ns_name)
{
JSObject *ns;
JSObject *global;
Ns *priv;
JSBool found;
/* put constructor in the global namespace */
global = gjs_get_import_global(context);
if (!JS_HasProperty(context, global, gjs_ns_class.name, &found))
return NULL;
if (!found) {
JSObject *prototype;
prototype = JS_InitClass(context, global,
/* parent prototype JSObject* for
* prototype; NULL for
* Object.prototype
*/
NULL,
&gjs_ns_class,
/* constructor for instances (NULL for
* none - just name the prototype like
* Math - rarely correct)
*/
gjs_ns_constructor,
/* number of constructor args */
0,
/* props of prototype */
&gjs_ns_proto_props[0],
/* funcs of prototype */
&gjs_ns_proto_funcs[0],
/* props of constructor, MyConstructor.myprop */
NULL,
/* funcs of constructor, MyConstructor.myfunc() */
NULL);
if (prototype == NULL)
g_error("Can't init class %s", gjs_ns_class.name);
gjs_debug(GJS_DEBUG_GNAMESPACE, "Initialized class %s prototype %p",
gjs_ns_class.name, prototype);
}
ns = JS_NewObject(context, &gjs_ns_class, NULL, global);
if (ns == NULL)
g_error("No memory to create ns object");
priv = g_slice_new0(Ns);
GJS_INC_COUNTER(ns);
g_assert(priv_from_js(context, ns) == NULL);
JS_SetPrivate(ns, priv);
gjs_debug_lifecycle(GJS_DEBUG_GNAMESPACE, "ns constructor, obj %p priv %p", ns, priv);
priv = priv_from_js(context, ns);
priv->gi_namespace = g_strdup(ns_name);
return ns;
}
