Branch data Line data Source code
1 : : /* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; -*- */
2 : : // SPDX-License-Identifier: MIT OR LGPL-2.0-or-later
3 : : // SPDX-FileCopyrightText: 2008 litl, LLC
4 : :
5 : : #include <config.h>
6 : :
7 : : #include <stddef.h> // for size_t
8 : :
9 : : #include <girepository.h>
10 : : #include <glib.h>
11 : :
12 : : #include <js/CallArgs.h>
13 : : #include <js/Class.h>
14 : : #include <js/ErrorReport.h> // for JSEXN_TYPEERR
15 : : #include <js/Object.h> // for GetClass
16 : : #include <js/PropertyAndElement.h>
17 : : #include <js/PropertyDescriptor.h> // for JSPROP_READONLY
18 : : #include <js/PropertySpec.h> // for JSPropertySpec, JS_PS_END, JS_STR...
19 : : #include <js/RootingAPI.h>
20 : : #include <js/TypeDecls.h>
21 : : #include <js/Utility.h> // for UniqueChars
22 : : #include <js/Value.h>
23 : : #include <jsapi.h> // for JS_NewObjectForConstructor, JS_NewObjectWithG...
24 : :
25 : : #include "gi/cwrapper.h"
26 : : #include "gi/function.h"
27 : : #include "gi/param.h"
28 : : #include "gi/repo.h"
29 : : #include "gi/wrapperutils.h"
30 : : #include "gjs/atoms.h"
31 : : #include "gjs/context-private.h"
32 : : #include "gjs/jsapi-class.h"
33 : : #include "gjs/jsapi-util.h"
34 : : #include "gjs/macros.h"
35 : : #include "gjs/mem-private.h"
36 : : #include "util/log.h"
37 : :
38 : : extern struct JSClass gjs_param_class;
39 : :
40 : : // Reserved slots
41 : : static const size_t POINTER = 0;
42 : :
43 : : struct Param : GjsAutoParam {
44 : 253 : explicit Param(GParamSpec* param)
45 : 253 : : GjsAutoParam(param, GjsAutoTakeOwnership()) {}
46 : : };
47 : :
48 : 1472 : [[nodiscard]] static GParamSpec* param_value(JSContext* cx,
49 : : JS::HandleObject obj) {
50 [ - + ]: 1472 : if (!JS_InstanceOf(cx, obj, &gjs_param_class, nullptr))
51 : 0 : return nullptr;
52 : :
53 : 1472 : auto* priv = JS::GetMaybePtrFromReservedSlot<Param>(obj, POINTER);
54 [ + + ]: 1472 : return priv ? priv->get() : nullptr;
55 : : }
56 : :
57 : : /*
58 : : * The *resolved out parameter, on success, should be false to indicate that id
59 : : * was not resolved; and true if id was resolved.
60 : : */
61 : : GJS_JSAPI_RETURN_CONVENTION
62 : : static bool
63 : 886 : param_resolve(JSContext *context,
64 : : JS::HandleObject obj,
65 : : JS::HandleId id,
66 : : bool *resolved)
67 : : {
68 [ + + ]: 886 : if (!param_value(context, obj)) {
69 : : /* instance, not prototype */
70 : 566 : *resolved = false;
71 : 566 : return true;
72 : : }
73 : :
74 : 320 : JS::UniqueChars name;
75 [ - + ]: 320 : if (!gjs_get_string_id(context, id, &name))
76 : 0 : return false;
77 [ - + ]: 320 : if (!name) {
78 : 0 : *resolved = false;
79 : 0 : return true; /* not resolved, but no error */
80 : : }
81 : :
82 : 320 : GjsAutoObjectInfo info = g_irepository_find_by_gtype(nullptr, G_TYPE_PARAM);
83 : : GjsAutoFunctionInfo method_info =
84 : 320 : g_object_info_find_method(info, name.get());
85 : :
86 [ + + ]: 320 : if (!method_info) {
87 : 229 : *resolved = false;
88 : 229 : return true;
89 : : }
90 : : #if GJS_VERBOSE_ENABLE_GI_USAGE
91 : : _gjs_log_info_usage(method_info);
92 : : #endif
93 : :
94 [ + - ]: 91 : if (g_function_info_get_flags (method_info) & GI_FUNCTION_IS_METHOD) {
95 : 91 : gjs_debug(GJS_DEBUG_GOBJECT,
96 : : "Defining method %s in prototype for GObject.ParamSpec",
97 : : method_info.name());
98 : :
99 [ - + ]: 91 : if (!gjs_define_function(context, obj, G_TYPE_PARAM, method_info))
100 : 0 : return false;
101 : :
102 : 91 : *resolved = true; /* we defined the prop in obj */
103 : : }
104 : :
105 : 91 : return true;
106 : 320 : }
107 : :
108 : : GJS_JSAPI_RETURN_CONVENTION
109 : 0 : static bool gjs_param_constructor(JSContext* cx, unsigned argc, JS::Value* vp) {
110 : 0 : JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
111 : :
112 [ # # ]: 0 : if (!args.isConstructing()) {
113 : 0 : gjs_throw_constructor_error(cx);
114 : 0 : return false;
115 : : }
116 : :
117 : : JS::RootedObject new_object(
118 : 0 : cx, JS_NewObjectForConstructor(cx, &gjs_param_class, args));
119 [ # # ]: 0 : if (!new_object)
120 : 0 : return false;
121 : :
122 : 0 : GJS_INC_COUNTER(param);
123 : :
124 : 0 : args.rval().setObject(*new_object);
125 : 0 : return true;
126 : 0 : }
127 : :
128 : 303 : static void param_finalize(JS::GCContext*, JSObject* obj) {
129 : 303 : Param* priv = JS::GetMaybePtrFromReservedSlot<Param>(obj, POINTER);
130 : : gjs_debug_lifecycle(GJS_DEBUG_GPARAM, "finalize, obj %p priv %p", obj,
131 : : priv);
132 [ + + ]: 303 : if (!priv)
133 : 50 : return; /* wrong class? */
134 : :
135 : 253 : GJS_DEC_COUNTER(param);
136 : 253 : JS::SetReservedSlot(obj, POINTER, JS::UndefinedValue());
137 [ + - ]: 253 : delete priv;
138 : : }
139 : :
140 : : /* The bizarre thing about this vtable is that it applies to both
141 : : * instances of the object, and to the prototype that instances of the
142 : : * class have.
143 : : */
144 : : static const struct JSClassOps gjs_param_class_ops = {
145 : : nullptr, // addProperty
146 : : nullptr, // deleteProperty
147 : : nullptr, // enumerate
148 : : nullptr, // newEnumerate
149 : : param_resolve,
150 : : nullptr, // mayResolve
151 : : param_finalize};
152 : :
153 : : static JSPropertySpec proto_props[] = {
154 : : JS_STRING_SYM_PS(toStringTag, "GObject_ParamSpec", JSPROP_READONLY),
155 : : JS_PS_END};
156 : :
157 : : static constexpr js::ClassSpec class_spec = {
158 : : nullptr, // createConstructor
159 : : nullptr, // createPrototype
160 : : nullptr, // constructorFunctions
161 : : nullptr, // constructorProperties
162 : : nullptr, // prototypeFunctions
163 : : proto_props, // prototypeProperties
164 : : nullptr // finishInit
165 : : };
166 : :
167 : : struct JSClass gjs_param_class = {
168 : : "GObject_ParamSpec",
169 : : JSCLASS_HAS_RESERVED_SLOTS(1) | JSCLASS_BACKGROUND_FINALIZE,
170 : : &gjs_param_class_ops, &class_spec};
171 : :
172 : : GJS_JSAPI_RETURN_CONVENTION
173 : : static JSObject*
174 : 253 : gjs_lookup_param_prototype(JSContext *context)
175 : : {
176 : 253 : const GjsAtoms& atoms = GjsContextPrivate::atoms(context);
177 : : JS::RootedObject in_object(
178 : 253 : context, gjs_lookup_namespace_object_by_name(context, atoms.gobject()));
179 : :
180 [ - + ]: 253 : if (G_UNLIKELY (!in_object))
181 : 0 : return nullptr;
182 : :
183 : 253 : JS::RootedValue value(context);
184 [ + - - + ]: 506 : if (!JS_GetPropertyById(context, in_object, atoms.param_spec(), &value) ||
185 [ - + ]: 253 : G_UNLIKELY(!value.isObject()))
186 : 0 : return nullptr;
187 : :
188 : 253 : JS::RootedObject constructor(context, &value.toObject());
189 : 253 : g_assert(constructor);
190 : :
191 [ + - - + ]: 506 : if (!JS_GetPropertyById(context, constructor, atoms.prototype(), &value) ||
192 [ - + ]: 253 : G_UNLIKELY(!value.isObjectOrNull()))
193 : 0 : return nullptr;
194 : :
195 : 253 : return value.toObjectOrNull();
196 : 253 : }
197 : :
198 : : bool
199 : 51 : gjs_define_param_class(JSContext *context,
200 : : JS::HandleObject in_object)
201 : : {
202 : 51 : JS::RootedObject prototype(context), constructor(context);
203 [ - + ]: 51 : if (!gjs_init_class_dynamic(
204 : : context, in_object, nullptr, "GObject", "ParamSpec",
205 : : &gjs_param_class, gjs_param_constructor, 0,
206 : : proto_props, // props of prototype
207 : : nullptr, // funcs of prototype
208 : : nullptr, // props of constructor, MyConstructor.myprop
209 : : nullptr, // funcs of constructor
210 : : &prototype, &constructor))
211 : 0 : return false;
212 : :
213 [ - + ]: 51 : if (!gjs_wrapper_define_gtype_prop(context, constructor, G_TYPE_PARAM))
214 : 0 : return false;
215 : :
216 : 51 : GjsAutoObjectInfo info = g_irepository_find_by_gtype(nullptr, G_TYPE_PARAM);
217 [ - + ]: 51 : if (!gjs_define_static_methods<InfoType::Object>(context, constructor,
218 : : G_TYPE_PARAM, info))
219 : 0 : return false;
220 : :
221 : 51 : gjs_debug(GJS_DEBUG_GPARAM,
222 : : "Defined class ParamSpec prototype is %p class %p in object %p",
223 : 51 : prototype.get(), &gjs_param_class, in_object.get());
224 : 51 : return true;
225 : 51 : }
226 : :
227 : : JSObject*
228 : 253 : gjs_param_from_g_param(JSContext *context,
229 : : GParamSpec *gparam)
230 : : {
231 : : JSObject *obj;
232 : :
233 [ - + ]: 253 : if (!gparam)
234 : 0 : return nullptr;
235 : :
236 : 506 : gjs_debug(GJS_DEBUG_GPARAM,
237 : : "Wrapping %s '%s' on %s with JSObject",
238 : 253 : g_type_name(G_TYPE_FROM_INSTANCE((GTypeInstance*) gparam)),
239 : : gparam->name,
240 : : g_type_name(gparam->owner_type));
241 : :
242 : 253 : JS::RootedObject proto(context, gjs_lookup_param_prototype(context));
243 : :
244 : 253 : obj = JS_NewObjectWithGivenProto(context, JS::GetClass(proto), proto);
245 : :
246 : 253 : GJS_INC_COUNTER(param);
247 : 253 : auto* priv = new Param(gparam);
248 : 253 : JS::SetReservedSlot(obj, POINTER, JS::PrivateValue(priv));
249 : :
250 : 253 : gjs_debug(GJS_DEBUG_GPARAM,
251 : : "JSObject created with param instance %p type %s", gparam,
252 : 253 : g_type_name(G_TYPE_FROM_INSTANCE(gparam)));
253 : :
254 : 253 : return obj;
255 : 253 : }
256 : :
257 : : GParamSpec*
258 : 293 : gjs_g_param_from_param(JSContext *context,
259 : : JS::HandleObject obj)
260 : : {
261 [ - + ]: 293 : if (!obj)
262 : 0 : return nullptr;
263 : :
264 : 293 : return param_value(context, obj);
265 : : }
266 : :
267 : : bool
268 : 293 : gjs_typecheck_param(JSContext *context,
269 : : JS::HandleObject object,
270 : : GType expected_type,
271 : : bool throw_error)
272 : : {
273 : : bool result;
274 : :
275 [ - + ]: 293 : if (!gjs_typecheck_instance(context, object, &gjs_param_class, throw_error))
276 : 0 : return false;
277 : :
278 : 293 : GParamSpec* param = param_value(context, object);
279 [ - + ]: 293 : if (!param) {
280 [ # # ]: 0 : if (throw_error) {
281 : 0 : gjs_throw_custom(context, JSEXN_TYPEERR, nullptr,
282 : : "Object is GObject.ParamSpec.prototype, not an "
283 : : "object instance - cannot convert to a GObject."
284 : : "ParamSpec instance");
285 : : }
286 : :
287 : 0 : return false;
288 : : }
289 : :
290 [ + + ]: 293 : if (expected_type != G_TYPE_NONE)
291 [ + - + - ]: 226 : result = g_type_is_a(G_TYPE_FROM_INSTANCE(param), expected_type);
292 : : else
293 : 67 : result = true;
294 : :
295 [ - + - - ]: 293 : if (!result && throw_error) {
296 : 0 : gjs_throw_custom(context, JSEXN_TYPEERR, nullptr,
297 : : "Object is of type %s - cannot convert to %s",
298 : 0 : g_type_name(G_TYPE_FROM_INSTANCE(param)),
299 : : g_type_name(expected_type));
300 : : }
301 : :
302 : 293 : return result;
303 : : }
|
