/*
* The *resolved out parameter, on success, should be false to indicate that id
* was not resolved; and true if id was resolved.
*/
static bool
param_resolve(JSContext *context,
JS::HandleObject obj,
JS::HandleId id,
bool *resolved)
{
GIObjectInfo *info = NULL;
GIFunctionInfo *method_info;
Param *priv;
bool ret = false;
priv = priv_from_js(context, obj);
if (priv != NULL) {
/* instance, not prototype */
*resolved = false;
return true;
}
GjsAutoJSChar name;
if (!gjs_get_string_id(context, id, &name)) {
*resolved = false;
return true; /* not resolved, but no error */
}
info = (GIObjectInfo*)g_irepository_find_by_gtype(g_irepository_get_default(), G_TYPE_PARAM);
method_info = g_object_info_find_method(info, name);
if (method_info == NULL) {
*resolved = false;
ret = true;
goto out;
}
#if GJS_VERBOSE_ENABLE_GI_USAGE
_gjs_log_info_usage((GIBaseInfo*) method_info);
#endif
if (g_function_info_get_flags (method_info) & GI_FUNCTION_IS_METHOD) {
gjs_debug(GJS_DEBUG_GOBJECT,
"Defining method %s in prototype for GObject.ParamSpec",
g_base_info_get_name( (GIBaseInfo*) method_info));
if (gjs_define_function(context, obj, G_TYPE_PARAM, method_info) == NULL) {
g_base_info_unref( (GIBaseInfo*) method_info);
goto out;
}
*resolved = true; /* we defined the prop in obj */
}
g_base_info_unref( (GIBaseInfo*) method_info);
ret = true;
out:
if (info != NULL)
g_base_info_unref( (GIBaseInfo*)info);
return ret;
}
void
gjs_log_object_props(JSContext *context,
JSObject *obj,
GjsDebugTopic topic,
const char *prefix)
{
JSObject *props_iter;
jsid prop_id;
JS_BeginRequest(context);
/* We potentially create new strings, plus the property iterator,
* that could get collected as we go through this process. So
* create a local root scope.
*/
JS_EnterLocalRootScope(context);
props_iter = JS_NewPropertyIterator(context, obj);
if (props_iter == NULL) {
gjs_debug(GJS_DEBUG_ERROR,
"Failed to create property iterator for object props");
goto done;
}
prop_id = JSVAL_VOID;
if (!JS_NextProperty(context, props_iter, &prop_id))
goto done;
while (prop_id != JSVAL_VOID) {
jsval nameval;
const char *name;
jsval propval;
if (!JS_IdToValue(context, prop_id, &nameval))
goto next;
if (!gjs_get_string_id(nameval, &name))
goto next;
if (!gjs_object_get_property(context, obj, name, &propval))
goto next;
gjs_debug(topic,
"%s%s = '%s'",
prefix, name,
gjs_value_debug_string(context, propval));
next:
prop_id = JSVAL_VOID;
if (!JS_NextProperty(context, props_iter, &prop_id))
break;
}
done:
JS_LeaveLocalRootScope(context);
JS_EndRequest(context);
}
static bool
interface_new_resolve(JSContext *context,
JS::HandleObject obj,
JS::HandleId id,
JS::MutableHandleObject objp)
{
Interface *priv;
char *name;
bool ret = false;
GIFunctionInfo *method_info;
if (!gjs_get_string_id(context, id, &name))
return true;
priv = priv_from_js(context, obj);
if (priv == NULL)
goto out;
/* If we have no GIRepository information then this interface was defined
* from within GJS. In that case, it has no properties that need to be
* resolved from within C code, as interfaces cannot inherit. */
if (priv->info == NULL) {
ret = true;
goto out;
}
method_info = g_interface_info_find_method((GIInterfaceInfo*) priv->info, name);
if (method_info != NULL) {
if (g_function_info_get_flags (method_info) & GI_FUNCTION_IS_METHOD) {
if (gjs_define_function(context, obj,
priv->gtype,
(GICallableInfo*)method_info) == NULL) {
g_base_info_unref((GIBaseInfo*)method_info);
goto out;
}
objp.set(obj);
}
g_base_info_unref((GIBaseInfo*)method_info);
}
ret = true;
out:
g_free (name);
return ret;
}
/*
* Like JSResolveOp, but flags provide contextual information as follows:
*
* JSRESOLVE_QUALIFIED a qualified property id: obj.id or obj[id], not id
* JSRESOLVE_ASSIGNING obj[id] is on the left-hand side of an assignment
* JSRESOLVE_DETECTING 'if (o.p)...' or similar detection opcode sequence
* JSRESOLVE_DECLARING var, const, or function prolog declaration opcode
* JSRESOLVE_CLASSNAME class name used when constructing
*
* The *objp out parameter, on success, should be null to indicate that id
* was not resolved; and non-null, referring to obj or one of its prototypes,
* if id was resolved.
*/
static JSBool
importer_new_resolve(JSContext *context,
JSObject **obj,
jsid *id,
unsigned flags,
JSObject **objp)
{
Importer *priv;
char *name;
JSBool ret = JS_TRUE;
jsid module_init_name;
*objp = NULL;
module_init_name = gjs_context_get_const_string(context, GJS_STRING_MODULE_INIT);
if (*id == module_init_name)
return JS_TRUE;
if (!gjs_get_string_id(context, *id, &name))
return JS_FALSE;
/* let Object.prototype resolve these */
if (strcmp(name, "valueOf") == 0 ||
strcmp(name, "toString") == 0 ||
strcmp(name, "__iterator__") == 0)
goto out;
priv = priv_from_js(context, *obj);
gjs_debug_jsprop(GJS_DEBUG_IMPORTER,
"Resolve prop '%s' hook obj %p priv %p",
name, (void *)obj, priv);
if (priv == NULL) /* we are the prototype, or have the wrong class */
goto out;
JS_BeginRequest(context);
if (do_import(context, *obj, priv, name)) {
*objp = *obj;
} else {
ret = JS_FALSE;
}
JS_EndRequest(context);
out:
g_free(name);
return ret;
}
static JSBool
interface_new_resolve(JSContext *context,
JSObject *obj,
jsid id,
unsigned flags,
JSObject **objp)
{
Interface *priv;
char *name;
JSBool ret = JS_FALSE;
GIFunctionInfo *method_info;
*objp = NULL;
if (!gjs_get_string_id(context, id, &name))
return JS_TRUE;
priv = priv_from_js(context, obj);
if (priv == NULL)
goto out;
method_info = g_interface_info_find_method((GIInterfaceInfo*) priv->info, name);
if (method_info != NULL) {
if (gjs_define_function(context, obj,
priv->gtype,
(GICallableInfo*)method_info) == NULL) {
g_base_info_unref((GIBaseInfo*)method_info);
goto out;
}
*objp = obj;
g_base_info_unref((GIBaseInfo*)method_info);
}
ret = JS_TRUE;
out:
g_free (name);
return ret;
}
/*
* Like JSResolveOp, but flags provide contextual information as follows:
*
* JSRESOLVE_QUALIFIED a qualified property id: obj.id or obj[id], not id
* JSRESOLVE_ASSIGNING obj[id] is on the left-hand side of an assignment
* JSRESOLVE_DETECTING 'if (o.p)...' or similar detection opcode sequence
* JSRESOLVE_DECLARING var, const, or function prolog declaration opcode
* JSRESOLVE_CLASSNAME class name used when constructing
*
* The *objp out parameter, on success, should be null to indicate that id
* was not resolved; and non-null, referring to obj or one of its prototypes,
* if id was resolved.
*/
static JSBool
importer_new_resolve(JSContext *context,
JS::HandleObject obj,
JS::HandleId id,
unsigned flags,
JS::MutableHandleObject objp)
{
Importer *priv;
std::string name;
JSBool ret = JS_TRUE;
jsid module_init_name;
module_init_name = gjs_context_get_const_string(context, GJS_STRING_MODULE_INIT);
if (id == module_init_name)
return JS_TRUE;
if (!gjs_get_string_id(context, id, name))
return JS_FALSE;
/* let Object.prototype resolve these */
if (name == "valueOf" ||
name == "toString" ||
name == "__iterator__")
goto out;
priv = priv_from_js(context, obj);
// std::cout << "Resolve prop '" << name << "' hook obj " << (uint32_t)*obj << " priv " << (uint32_t)priv << "\n";
if (priv == NULL) /* we are the prototype, or have the wrong class */
goto out;
JS_BeginRequest(context);
if (do_import(context, obj, priv, name)) {
objp.set(obj);
} else {
ret = JS_FALSE;
}
JS_EndRequest(context);
out:
return ret;
}
/*
* Like JSResolveOp, but flags provide contextual information as follows:
*
* JSRESOLVE_QUALIFIED a qualified property id: obj.id or obj[id], not id
* JSRESOLVE_ASSIGNING obj[id] is on the left-hand side of an assignment
* JSRESOLVE_DETECTING 'if (o.p)...' or similar detection opcode sequence
* JSRESOLVE_DECLARING var, const, or function prolog declaration opcode
* JSRESOLVE_CLASSNAME class name used when constructing
*
* The *objp out parameter, on success, should be null to indicate that id
* was not resolved; and non-null, referring to obj or one of its prototypes,
* if id was resolved.
*/
static JSBool
importer_new_resolve(JSContext *context,
JSObject *obj,
jsid id,
uintN flags,
JSObject **objp)
{
Importer *priv;
char *name;
JSBool ret = JS_TRUE;
*objp = NULL;
if (!gjs_get_string_id(context, id, &name))
return JS_FALSE;
/* let Object.prototype resolve these */
if (strcmp(name, "valueOf") == 0 ||
strcmp(name, "toString") == 0 ||
strcmp(name, "__iterator__") == 0)
goto out;
priv = priv_from_js(context, obj);
gjs_debug_jsprop(GJS_DEBUG_IMPORTER, "Resolve prop '%s' hook obj %p priv %p", name, obj, priv);
if (priv == NULL) /* we are the prototype, or have the wrong class */
goto out;
JS_BeginRequest(context);
if (do_import(context, obj, priv, name)) {
*objp = obj;
} else {
ret = JS_FALSE;
}
JS_EndRequest(context);
out:
g_free(name);
return ret;
}
static void
load_module_elements(JSContext *context,
JSObject *in_object,
ImporterIterator *iter,
const char *init_path) {
JSObject *module_obj;
JSObject *jsiter;
module_obj = load_module_init(context, in_object, init_path);
if (module_obj != NULL) {
jsid idp;
jsiter = JS_NewPropertyIterator(context, module_obj);
if (jsiter == NULL) {
return;
}
if (!JS_NextProperty(context, jsiter, &idp)) {
return;
}
while (!JSID_IS_VOID(idp)) {
char *name;
if (!gjs_get_string_id(context, idp, &name)) {
continue;
}
/* Pass ownership of name */
g_ptr_array_add(iter->elements, name);
if (!JS_NextProperty(context, jsiter, &idp)) {
break;
}
}
}
}
/*
* Like JSResolveOp, but flags provide contextual information as follows:
*
* JSRESOLVE_QUALIFIED a qualified property id: obj.id or obj[id], not id
* JSRESOLVE_ASSIGNING obj[id] is on the left-hand side of an assignment
* JSRESOLVE_DETECTING 'if (o.p)...' or similar detection opcode sequence
* JSRESOLVE_DECLARING var, const, or fundamental prolog declaration opcode
* JSRESOLVE_CLASSNAME class name used when constructing
*
* The *objp out parameter, on success, should be null to indicate that id
* was not resolved; and non-null, referring to obj or one of its prototypes,
* if id was resolved.
*/
static JSBool
fundamental_instance_new_resolve(JSContext *context,
JS::HandleObject obj,
JS::HandleId id,
unsigned flags,
JS::MutableHandleObject objp)
{
FundamentalInstance *priv;
char *name;
JSBool ret = JS_FALSE;
if (!gjs_get_string_id(context, id, &name))
return JS_TRUE; /* not resolved, but no error */
priv = priv_from_js(context, obj);
gjs_debug_jsprop(GJS_DEBUG_GFUNDAMENTAL, "Resolve prop '%s' hook obj %p priv %p", name, *obj, priv);
if (priv == NULL)
goto out; /* wrong class */
if (priv->prototype == NULL) {
/* We are the prototype, so look for methods and other class properties */
Fundamental *proto_priv = (Fundamental *) priv;
GIFunctionInfo *method_info;
method_info = g_object_info_find_method((GIStructInfo*) proto_priv->info,
name);
if (method_info != NULL) {
const char *method_name;
#if GJS_VERBOSE_ENABLE_GI_USAGE
_gjs_log_info_usage((GIBaseInfo *) method_info);
#endif
if (g_function_info_get_flags (method_info) & GI_FUNCTION_IS_METHOD) {
method_name = g_base_info_get_name((GIBaseInfo *) method_info);
/* we do not define deprecated methods in the prototype */
if (g_base_info_is_deprecated((GIBaseInfo *) method_info)) {
gjs_debug(GJS_DEBUG_GFUNDAMENTAL,
"Ignoring definition of deprecated method %s in prototype %s.%s",
method_name,
g_base_info_get_namespace((GIBaseInfo *) proto_priv->info),
g_base_info_get_name((GIBaseInfo *) proto_priv->info));
g_base_info_unref((GIBaseInfo *) method_info);
ret = JS_TRUE;
goto out;
}
gjs_debug(GJS_DEBUG_GFUNDAMENTAL,
"Defining method %s in prototype for %s.%s",
method_name,
g_base_info_get_namespace((GIBaseInfo *) proto_priv->info),
g_base_info_get_name((GIBaseInfo *) proto_priv->info));
if (gjs_define_function(context, obj, proto_priv->gtype,
method_info) == NULL) {
g_base_info_unref((GIBaseInfo *) method_info);
goto out;
}
objp.set(obj);
}
g_base_info_unref((GIBaseInfo *) method_info);
}
ret = fundamental_instance_new_resolve_interface(context, obj, objp,
proto_priv, name);
} else {
/* We are an instance, not a prototype, so look for
* per-instance props that we want to define on the
* JSObject. Generally we do not want to cache these in JS, we
* want to always pull them from the C object, or JS would not
* see any changes made from C. So we use the get/set prop
* hooks, not this resolve hook.
*/
}
ret = JS_TRUE;
out:
g_free(name);
return ret;
}
/* Initialize a newly created Boxed from an object that is a "hash" of
* properties to set as fieds of the object. We don't require that every field
* of the object be set.
*/
static JSBool
boxed_init_from_props(JSContext *context,
JSObject *obj,
Boxed *priv,
jsval props_value)
{
JSObject *props;
JSObject *iter;
jsid prop_id;
GHashTable *field_map;
gboolean success;
success = FALSE;
if (!JSVAL_IS_OBJECT(props_value)) {
gjs_throw(context, "argument should be a hash with fields to set");
return JS_FALSE;
}
props = JSVAL_TO_OBJECT(props_value);
iter = JS_NewPropertyIterator(context, props);
if (iter == NULL) {
gjs_throw(context, "Failed to create property iterator for fields hash");
return JS_FALSE;
}
field_map = get_field_map(priv->info);
prop_id = JSID_VOID;
if (!JS_NextProperty(context, iter, &prop_id))
goto out;
while (!JSID_IS_VOID(prop_id)) {
GIFieldInfo *field_info;
char *name;
jsval value;
if (!gjs_get_string_id(context, prop_id, &name))
goto out;
field_info = g_hash_table_lookup(field_map, name);
if (field_info == NULL) {
gjs_throw(context, "No field %s on boxed type %s",
name, g_base_info_get_name((GIBaseInfo *)priv->info));
g_free(name);
goto out;
}
if (!gjs_object_require_property(context, props, "property list", name, &value)) {
g_free(name);
goto out;
}
g_free(name);
if (!boxed_set_field_from_value(context, priv, field_info, value))
goto out;
prop_id = JSID_VOID;
if (!JS_NextProperty(context, iter, &prop_id))
goto out;
}
success = TRUE;
out:
g_hash_table_destroy(field_map);
return success;
}
/*
* Like JSResolveOp, but flags provide contextual information as follows:
*
* JSRESOLVE_QUALIFIED a qualified property id: obj.id or obj[id], not id
* JSRESOLVE_ASSIGNING obj[id] is on the left-hand side of an assignment
* JSRESOLVE_DETECTING 'if (o.p)...' or similar detection opcode sequence
* JSRESOLVE_DECLARING var, const, or boxed prolog declaration opcode
* JSRESOLVE_CLASSNAME class name used when constructing
*
* The *objp out parameter, on success, should be null to indicate that id
* was not resolved; and non-null, referring to obj or one of its prototypes,
* if id was resolved.
*/
static JSBool
boxed_new_resolve(JSContext *context,
JSObject *obj,
jsid id,
unsigned flags,
JSObject **objp)
{
Boxed *priv;
char *name;
JSBool ret = JS_FALSE;
*objp = NULL;
if (!gjs_get_string_id(context, id, &name))
return JS_TRUE; /* not resolved, but no error */
priv = priv_from_js(context, obj);
gjs_debug_jsprop(GJS_DEBUG_GBOXED, "Resolve prop '%s' hook obj %p priv %p", name, obj, priv);
if (priv == NULL)
goto out; /* wrong class */
if (priv->gboxed == NULL) {
/* We are the prototype, so look for methods and other class properties */
GIFunctionInfo *method_info;
method_info = g_struct_info_find_method((GIStructInfo*) priv->info,
name);
if (method_info != NULL) {
JSObject *boxed_proto;
const char *method_name;
#if GJS_VERBOSE_ENABLE_GI_USAGE
_gjs_log_info_usage((GIBaseInfo*) method_info);
#endif
method_name = g_base_info_get_name( (GIBaseInfo*) method_info);
gjs_debug(GJS_DEBUG_GBOXED,
"Defining method %s in prototype for %s.%s",
method_name,
g_base_info_get_namespace( (GIBaseInfo*) priv->info),
g_base_info_get_name( (GIBaseInfo*) priv->info));
boxed_proto = obj;
if (gjs_define_function(context, boxed_proto, priv->gtype,
(GICallableInfo *)method_info) == NULL) {
g_base_info_unref( (GIBaseInfo*) method_info);
goto out;
}
*objp = boxed_proto; /* we defined the prop in object_proto */
g_base_info_unref( (GIBaseInfo*) method_info);
}
} else {
/* We are an instance, not a prototype, so look for
* per-instance props that we want to define on the
* JSObject. Generally we do not want to cache these in JS, we
* want to always pull them from the C object, or JS would not
* see any changes made from C. So we use the get/set prop
* hooks, not this resolve hook.
*/
}
ret = JS_TRUE;
out:
g_free(name);
return ret;
}
/* a hook on getting a property; set value_p to override property's value.
* Return value is JS_FALSE on OOM/exception.
*/
static JSBool
param_get_prop(JSContext *context,
JSObject *obj,
jsid id,
jsval *value_p)
{
JSBool success;
Param *priv;
GParamSpec *pspec;
char *name;
GType gtype;
GIObjectInfo *info = NULL, *parent_info = NULL;
GIFieldInfo *field_info = NULL;
GITypeInfo *type_info = NULL;
GIArgument arg;
if (!gjs_get_string_id(context, id, &name))
return JS_TRUE; /* not something we affect, but no error */
priv = priv_from_js(context, obj);
if (priv == NULL) {
g_free(name);
return JS_FALSE; /* wrong class */
}
success = JS_FALSE;
pspec = priv->gparam;
gtype = G_TYPE_FROM_INSTANCE(pspec);
info = (GIObjectInfo*)g_irepository_find_by_gtype(g_irepository_get_default(), gtype);
if (info == NULL) {
/* We may have a non-introspectable GParamSpec subclass here. Just return VOID. */
*value_p = JSVAL_VOID;
success = JS_TRUE;
goto out;
}
parent_info = g_object_info_get_parent(info);
field_info = find_field_info(info, name);
if (field_info == NULL) {
/* Try it on the parent GParamSpec for generic GParamSpec properties. */
field_info = find_field_info(parent_info, name);
}
if (field_info == NULL) {
*value_p = JSVAL_VOID;
success = JS_TRUE;
goto out;
}
type_info = g_field_info_get_type(field_info);
if (!g_field_info_get_field(field_info, priv->gparam, &arg)) {
gjs_throw(context, "Reading field %s.%s is not supported",
g_base_info_get_name(info),
g_base_info_get_name((GIBaseInfo*)field_info));
goto out;
}
if (!gjs_value_from_g_argument(context, value_p, type_info, &arg, TRUE))
goto out;
success = JS_TRUE;
out:
if (field_info != NULL)
g_base_info_unref((GIBaseInfo*)field_info);
if (type_info != NULL)
g_base_info_unref((GIBaseInfo*)type_info);
if (info != NULL)
g_base_info_unref((GIBaseInfo*)info);
if (parent_info != NULL)
g_base_info_unref((GIBaseInfo*)parent_info);
g_free(name);
return success;
}
/*
* Like JSResolveOp, but flags provide contextual information as follows:
*
* JSRESOLVE_QUALIFIED a qualified property id: obj.id or obj[id], not id
* JSRESOLVE_ASSIGNING obj[id] is on the left-hand side of an assignment
* JSRESOLVE_DETECTING 'if (o.p)...' or similar detection opcode sequence
* JSRESOLVE_DECLARING var, const, or boxed prolog declaration opcode
* JSRESOLVE_CLASSNAME class name used when constructing
*
* The *objp out parameter, on success, should be null to indicate that id
* was not resolved; and non-null, referring to obj or one of its prototypes,
* if id was resolved.
*/
static JSBool
union_new_resolve(JSContext *context,
JS::HandleObject obj,
JS::HandleId id,
unsigned flags,
JS::MutableHandleObject objp)
{
Union *priv;
char *name;
JSBool ret = JS_TRUE;
if (!gjs_get_string_id(context, id, &name))
return JS_TRUE; /* not resolved, but no error */
priv = priv_from_js(context, obj);
gjs_debug_jsprop(GJS_DEBUG_GBOXED, "Resolve prop '%s' hook obj %p priv %p", name, *obj, priv);
if (priv == NULL) {
ret = JS_FALSE; /* wrong class */
goto out;
}
if (priv->gboxed == NULL) {
/* We are the prototype, so look for methods and other class properties */
GIFunctionInfo *method_info;
method_info = g_union_info_find_method((GIUnionInfo*) priv->info,
name);
if (method_info != NULL) {
JSObject *union_proto;
const char *method_name;
#if GJS_VERBOSE_ENABLE_GI_USAGE
_gjs_log_info_usage((GIBaseInfo*) method_info);
#endif
if (g_function_info_get_flags (method_info) & GI_FUNCTION_IS_METHOD) {
method_name = g_base_info_get_name( (GIBaseInfo*) method_info);
gjs_debug(GJS_DEBUG_GBOXED,
"Defining method %s in prototype for %s.%s",
method_name,
g_base_info_get_namespace( (GIBaseInfo*) priv->info),
g_base_info_get_name( (GIBaseInfo*) priv->info));
union_proto = obj;
if (gjs_define_function(context, union_proto,
g_registered_type_info_get_g_type(priv->info),
method_info) == NULL) {
g_base_info_unref( (GIBaseInfo*) method_info);
ret = JS_FALSE;
goto out;
}
objp.set(union_proto); /* we defined the prop in object_proto */
}
g_base_info_unref( (GIBaseInfo*) method_info);
}
} else {
/* We are an instance, not a prototype, so look for
* per-instance props that we want to define on the
* JSObject. Generally we do not want to cache these in JS, we
* want to always pull them from the C object, or JS would not
* see any changes made from C. So we use the get/set prop
* hooks, not this resolve hook.
*/
}
out:
g_free(name);
return ret;
}
/*
* Like JSResolveOp, but flags provide contextual information as follows:
*
* JSRESOLVE_QUALIFIED a qualified property id: obj.id or obj[id], not id
* JSRESOLVE_ASSIGNING obj[id] is on the left-hand side of an assignment
* JSRESOLVE_DETECTING 'if (o.p)...' or similar detection opcode sequence
* JSRESOLVE_DECLARING var, const, or function prolog declaration opcode
* JSRESOLVE_CLASSNAME class name used when constructing
*
* The *objp out parameter, on success, should be null to indicate that id
* was not resolved; and non-null, referring to obj or one of its prototypes,
* if id was resolved.
*/
static JSBool
ns_new_resolve(JSContext *context,
JS::HandleObject obj,
JS::HandleId id,
unsigned flags,
JS::MutableHandleObject objp)
{
Ns *priv;
char *name;
GIRepository *repo;
GIBaseInfo *info;
JSBool ret = JS_FALSE;
gboolean defined;
if (!gjs_get_string_id(context, id, &name))
return JS_TRUE; /* not resolved, but no error */
/* let Object.prototype resolve these */
if (strcmp(name, "valueOf") == 0 ||
strcmp(name, "toString") == 0) {
ret = JS_TRUE;
goto out;
}
priv = priv_from_js(context, obj);
gjs_debug_jsprop(GJS_DEBUG_GNAMESPACE, "Resolve prop '%s' hook obj %p priv %p", name, *obj, priv);
if (priv == NULL) {
ret = JS_TRUE; /* we are the prototype, or have the wrong class */
goto out;
}
JS_BeginRequest(context);
repo = g_irepository_get_default();
info = g_irepository_find_by_name(repo, priv->gi_namespace, name);
if (info == NULL) {
/* No property defined, but no error either, so return TRUE */
JS_EndRequest(context);
ret = JS_TRUE;
goto out;
}
gjs_debug(GJS_DEBUG_GNAMESPACE,
"Found info type %s for '%s' in namespace '%s'",
gjs_info_type_name(g_base_info_get_type(info)),
g_base_info_get_name(info),
g_base_info_get_namespace(info));
if (gjs_define_info(context, obj, info, &defined)) {
g_base_info_unref(info);
if (defined)
objp.set(obj); /* we defined the property in this object */
ret = JS_TRUE;
} else {
gjs_debug(GJS_DEBUG_GNAMESPACE,
"Failed to define info '%s'",
g_base_info_get_name(info));
g_base_info_unref(info);
}
JS_EndRequest(context);
out:
g_free(name);
return ret;
}
