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 : : // SPDX-FileCopyrightText: 2020 Canonical, Ltd.
5 : :
6 : : #include <config.h>
7 : :
8 : : #include <stdint.h>
9 : : #include <string.h> // for strcmp, strlen, memcpy
10 : :
11 : : #include <string>
12 : : #include <type_traits>
13 : :
14 : : #include <girepository.h>
15 : : #include <glib-object.h>
16 : : #include <glib.h>
17 : :
18 : : #include <js/Array.h>
19 : : #include <js/CharacterEncoding.h>
20 : : #include <js/Conversions.h>
21 : : #include <js/ErrorReport.h> // for JS_ReportOutOfMemory
22 : : #include <js/Exception.h>
23 : : #include <js/GCVector.h> // for RootedVector, MutableWrappedPtrOp...
24 : : #include <js/Id.h>
25 : : #include <js/PropertyAndElement.h> // for JS_GetElement, JS_HasPropertyById
26 : : #include <js/PropertyDescriptor.h> // for JSPROP_ENUMERATE
27 : : #include <js/RootingAPI.h>
28 : : #include <js/String.h>
29 : : #include <js/TypeDecls.h>
30 : : #include <js/Utility.h> // for UniqueChars
31 : : #include <js/Value.h>
32 : : #include <js/ValueArray.h>
33 : : #include <js/experimental/TypedData.h>
34 : : #include <jsapi.h> // for InformalValueTypeName, IdVector
35 : :
36 : : #include "gi/arg-inl.h"
37 : : #include "gi/arg-types-inl.h"
38 : : #include "gi/arg.h"
39 : : #include "gi/boxed.h"
40 : : #include "gi/closure.h"
41 : : #include "gi/foreign.h"
42 : : #include "gi/fundamental.h"
43 : : #include "gi/gerror.h"
44 : : #include "gi/gtype.h"
45 : : #include "gi/interface.h"
46 : : #include "gi/js-value-inl.h"
47 : : #include "gi/object.h"
48 : : #include "gi/param.h"
49 : : #include "gi/union.h"
50 : : #include "gi/value.h"
51 : : #include "gi/wrapperutils.h"
52 : : #include "gjs/atoms.h"
53 : : #include "gjs/byteArray.h"
54 : : #include "gjs/context-private.h"
55 : : #include "gjs/enum-utils.h"
56 : : #include "gjs/macros.h"
57 : : #include "gjs/jsapi-util.h"
58 : : #include "util/log.h"
59 : : #include "util/misc.h"
60 : :
61 : : GJS_JSAPI_RETURN_CONVENTION static bool gjs_g_arg_release_internal(
62 : : JSContext*, GITransfer, GITypeInfo*, GITypeTag, GjsArgumentType,
63 : : GjsArgumentFlags, GIArgument*);
64 : : static void throw_invalid_argument(JSContext* cx, JS::HandleValue value,
65 : : GITypeInfo* arginfo, const char* arg_name,
66 : : GjsArgumentType arg_type);
67 : :
68 : 17 : bool _gjs_flags_value_is_valid(JSContext* context, GType gtype, int64_t value) {
69 : : /* Do proper value check for flags with GType's */
70 [ + + ]: 17 : if (gtype != G_TYPE_NONE) {
71 : 16 : GjsAutoTypeClass<GFlagsClass> gflags_class(gtype);
72 : 16 : uint32_t tmpval = static_cast<uint32_t>(value);
73 : :
74 : : /* check all bits are valid bits for the flag and is a 32 bit flag*/
75 [ - + ]: 16 : if ((tmpval &= gflags_class->mask) != value) { /* Not a guint32 with invalid mask values*/
76 : 0 : gjs_throw(context,
77 : : "0x%" G_GINT64_MODIFIER "x is not a valid value for flags %s",
78 : : value, g_type_name(gtype));
79 : 0 : return false;
80 : : }
81 [ + - ]: 16 : }
82 : :
83 : 17 : return true;
84 : : }
85 : :
86 : : GJS_JSAPI_RETURN_CONVENTION
87 : 2100 : static bool _gjs_enum_value_is_valid(JSContext* context, GIEnumInfo* enum_info,
88 : : int64_t value) {
89 : : bool found;
90 : : int n_values;
91 : : int i;
92 : :
93 : 2100 : n_values = g_enum_info_get_n_values(enum_info);
94 : 2100 : found = false;
95 : :
96 [ + - ]: 28885 : for (i = 0; i < n_values; ++i) {
97 : 28885 : GjsAutoValueInfo value_info = g_enum_info_get_value(enum_info, i);
98 : 28885 : int64_t enum_value = g_value_info_get_value(value_info);
99 : :
100 [ + + ]: 28885 : if (enum_value == value) {
101 : 2100 : found = true;
102 : 2100 : break;
103 : : }
104 [ + + ]: 28885 : }
105 : :
106 [ - + ]: 2100 : if (!found) {
107 : 0 : gjs_throw(context,
108 : : "%" G_GINT64_MODIFIER "d is not a valid value for enumeration %s",
109 : : value, g_base_info_get_name((GIBaseInfo *)enum_info));
110 : : }
111 : :
112 : 2100 : return found;
113 : : }
114 : :
115 : 2306 : [[nodiscard]] static bool _gjs_enum_uses_signed_type(GIEnumInfo* enum_info) {
116 [ + + ]: 2306 : switch (g_enum_info_get_storage_type(enum_info)) {
117 : 82 : case GI_TYPE_TAG_INT8:
118 : : case GI_TYPE_TAG_INT16:
119 : : case GI_TYPE_TAG_INT32:
120 : : case GI_TYPE_TAG_INT64:
121 : 82 : return true;
122 : 2224 : default:
123 : 2224 : return false;
124 : : }
125 : : }
126 : :
127 : : // This is hacky - g_function_info_invoke() and g_field_info_get/set_field()
128 : : // expect the enum value in gjs_arg_member<int>(arg) and depend on all flags and
129 : : // enumerations being passed on the stack in a 32-bit field. See FIXME comment
130 : : // in g_field_info_get_field(). The same assumption of enums cast to 32-bit
131 : : // signed integers is found in g_value_set_enum()/g_value_set_flags().
132 : 2306 : [[nodiscard]] int64_t _gjs_enum_from_int(GIEnumInfo* enum_info, int int_value) {
133 [ + + ]: 2306 : if (_gjs_enum_uses_signed_type (enum_info))
134 : 82 : return int64_t(int_value);
135 : : else
136 : 2224 : return int64_t(uint32_t(int_value));
137 : : }
138 : :
139 : : /* Here for symmetry, but result is the same for the two cases */
140 : 102 : [[nodiscard]] static int _gjs_enum_to_int(int64_t value) {
141 : 102 : return static_cast<int>(value);
142 : : }
143 : :
144 : : /* Check if an argument of the given needs to be released if we created it
145 : : * from a JS value to pass it into a function and aren't transferring ownership.
146 : : */
147 : 368 : [[nodiscard]] static bool type_needs_release(GITypeInfo* type_info,
148 : : GITypeTag type_tag) {
149 [ + + + ]: 368 : switch (type_tag) {
150 : 64 : case GI_TYPE_TAG_ARRAY:
151 : : case GI_TYPE_TAG_ERROR:
152 : : case GI_TYPE_TAG_FILENAME:
153 : : case GI_TYPE_TAG_GHASH:
154 : : case GI_TYPE_TAG_GLIST:
155 : : case GI_TYPE_TAG_GSLIST:
156 : : case GI_TYPE_TAG_UTF8:
157 : 64 : return true;
158 : :
159 : 203 : case GI_TYPE_TAG_INTERFACE: {
160 : : GType gtype;
161 : :
162 : : GjsAutoBaseInfo interface_info =
163 : 203 : g_type_info_get_interface(type_info);
164 : 203 : g_assert(interface_info != nullptr);
165 : :
166 [ + - - ]: 203 : switch (g_base_info_get_type(interface_info)) {
167 : 203 : case GI_INFO_TYPE_STRUCT:
168 : : case GI_INFO_TYPE_ENUM:
169 : : case GI_INFO_TYPE_FLAGS:
170 : : case GI_INFO_TYPE_OBJECT:
171 : : case GI_INFO_TYPE_INTERFACE:
172 : : case GI_INFO_TYPE_UNION:
173 : : case GI_INFO_TYPE_BOXED:
174 : : // These are subtypes of GIRegisteredTypeInfo for which the
175 : : // cast is safe
176 : 203 : gtype = g_registered_type_info_get_g_type(interface_info);
177 : 203 : break;
178 : 0 : case GI_INFO_TYPE_VALUE:
179 : : // Special case for GValues
180 : 0 : return true;
181 : 0 : default:
182 : 0 : gtype = G_TYPE_NONE;
183 : : }
184 : :
185 [ + - - + : 203 : if (g_type_is_a(gtype, G_TYPE_CLOSURE))
- + ]
186 : 0 : return true;
187 [ + + - + : 203 : else if (g_type_is_a(gtype, G_TYPE_VALUE))
+ + ]
188 : 3 : return true;
189 : : else
190 : 200 : return false;
191 : 203 : }
192 : :
193 : 101 : default:
194 : 101 : return false;
195 : : }
196 : : }
197 : :
198 : 11 : [[nodiscard]] static inline bool is_string_type(GITypeTag tag) {
199 [ + - + + ]: 11 : return tag == GI_TYPE_TAG_FILENAME || tag == GI_TYPE_TAG_UTF8;
200 : : }
201 : :
202 : : /* Check if an argument of the given needs to be released if we obtained it
203 : : * from out argument (or the return value), and we're transferring ownership
204 : : */
205 : 16 : [[nodiscard]] static bool type_needs_out_release(GITypeInfo* type_info,
206 : : GITypeTag type_tag) {
207 [ + + + ]: 16 : switch (type_tag) {
208 : 6 : case GI_TYPE_TAG_ARRAY:
209 : : case GI_TYPE_TAG_ERROR:
210 : : case GI_TYPE_TAG_FILENAME:
211 : : case GI_TYPE_TAG_GHASH:
212 : : case GI_TYPE_TAG_GLIST:
213 : : case GI_TYPE_TAG_GSLIST:
214 : : case GI_TYPE_TAG_UTF8:
215 : 6 : return true;
216 : :
217 : 4 : case GI_TYPE_TAG_INTERFACE: {
218 : : GjsAutoBaseInfo interface_info =
219 : 4 : g_type_info_get_interface(type_info);
220 : :
221 [ - + + - ]: 4 : switch (g_base_info_get_type(interface_info)) {
222 : 0 : case GI_INFO_TYPE_ENUM:
223 : : case GI_INFO_TYPE_FLAGS:
224 : 0 : return false;
225 : :
226 : 3 : case GI_INFO_TYPE_STRUCT:
227 : : case GI_INFO_TYPE_UNION:
228 : 3 : return g_type_info_is_pointer(type_info);
229 : :
230 : 1 : case GI_INFO_TYPE_OBJECT:
231 : 1 : return true;
232 : :
233 : 0 : default:
234 : 0 : return false;
235 : : }
236 : 4 : }
237 : :
238 : 6 : default:
239 : 6 : return false;
240 : : }
241 : : }
242 : :
243 : : template <typename T>
244 : 14 : GJS_JSAPI_RETURN_CONVENTION static bool gjs_array_to_g_list(
245 : : JSContext* cx, const JS::HandleValue& value, GITypeInfo* type_info,
246 : : GITransfer transfer, const char* arg_name, GjsArgumentType arg_type,
247 : : T** list_p) {
248 : : static_assert(std::is_same_v<T, GList> || std::is_same_v<T, GSList>);
249 : :
250 : : // While a list can be NULL in C, that means empty array in JavaScript, it
251 : : // doesn't mean null in JavaScript.
252 : : bool is_array;
253 [ - + ]: 14 : if (!JS::IsArrayObject(cx, value, &is_array))
254 : 0 : return false;
255 [ - + ]: 14 : if (!is_array) {
256 : 0 : throw_invalid_argument(cx, value, type_info, arg_name, arg_type);
257 : 0 : return false;
258 : : }
259 : :
260 : 14 : JS::RootedObject array_obj(cx, &value.toObject());
261 : :
262 : : uint32_t length;
263 [ - + ]: 14 : if (!JS::GetArrayLength(cx, array_obj, &length)) {
264 : 0 : throw_invalid_argument(cx, value, type_info, arg_name, arg_type);
265 : 0 : return false;
266 : : }
267 : :
268 : 14 : GjsAutoTypeInfo param_info = g_type_info_get_param_type(type_info, 0);
269 : 14 : g_assert(param_info);
270 : :
271 [ + + ]: 14 : if (transfer == GI_TRANSFER_CONTAINER) {
272 [ - + ]: 1 : if (type_needs_release (param_info, g_type_info_get_tag(param_info))) {
273 : : /* FIXME: to make this work, we'd have to keep a list of temporary
274 : : * GArguments for the function call so we could free them after
275 : : * the surrounding container had been freed by the callee.
276 : : */
277 : 0 : gjs_throw(cx, "Container transfer for in parameters not supported");
278 : 0 : return false;
279 : : }
280 : :
281 : 1 : transfer = GI_TRANSFER_NOTHING;
282 : : }
283 : :
284 : 14 : JS::RootedObject array(cx, value.toObjectOrNull());
285 : 14 : JS::RootedValue elem(cx);
286 : 14 : T* list = nullptr;
287 : :
288 [ + + ]: 50 : for (size_t i = 0; i < length; ++i) {
289 : 36 : GArgument elem_arg = { 0 };
290 : :
291 : 36 : elem = JS::UndefinedValue();
292 [ - + ]: 36 : if (!JS_GetElement(cx, array, i, &elem)) {
293 : 0 : gjs_throw(cx, "Missing array element %zu", i);
294 : 0 : return false;
295 : : }
296 : :
297 : : /* FIXME we don't know if the list elements can be NULL.
298 : : * gobject-introspection needs to tell us this.
299 : : * Always say they can't for now.
300 : : */
301 [ - + ]: 36 : if (!gjs_value_to_g_argument(cx, elem, param_info,
302 : : GJS_ARGUMENT_LIST_ELEMENT, transfer,
303 : : &elem_arg)) {
304 : 0 : return false;
305 : : }
306 : :
307 : : void* hash_pointer =
308 : 36 : g_type_info_hash_pointer_from_argument(param_info, &elem_arg);
309 : :
310 : : if constexpr (std::is_same_v<T, GList>)
311 : 20 : list = g_list_prepend(list, hash_pointer);
312 : : else if constexpr (std::is_same_v<T, GSList>)
313 : 16 : list = g_slist_prepend(list, hash_pointer);
314 : : }
315 : :
316 : : if constexpr (std::is_same_v<T, GList>)
317 : 7 : list = g_list_reverse(list);
318 : : else if constexpr (std::is_same_v<T, GSList>)
319 : 7 : list = g_slist_reverse(list);
320 : :
321 : 14 : *list_p = list;
322 : :
323 : 14 : return true;
324 : 14 : }
325 : :
326 : 11 : [[nodiscard]] static GHashTable* create_hash_table_for_key_type(
327 : : GITypeTag key_type) {
328 : : /* Don't use key/value destructor functions here, because we can't
329 : : * construct correct ones in general if the value type is complex.
330 : : * Rely on the type-aware g_argument_release functions. */
331 [ + + ]: 11 : if (is_string_type(key_type))
332 : 9 : return g_hash_table_new(g_str_hash, g_str_equal);
333 : 2 : return g_hash_table_new(NULL, NULL);
334 : : }
335 : :
336 : : template <typename IntType>
337 : 8 : GJS_JSAPI_RETURN_CONVENTION static bool hashtable_int_key(
338 : : JSContext* cx, const JS::HandleValue& value, void** pointer_out) {
339 : : static_assert(std::is_integral_v<IntType>, "Need an integer");
340 : 8 : bool out_of_range = false;
341 : :
342 : : Gjs::JsValueHolder::Strict<IntType> i;
343 [ - + ]: 8 : if (!Gjs::js_value_to_c_checked<IntType>(cx, value, &i, &out_of_range))
344 : 0 : return false;
345 : :
346 [ - + ]: 8 : if (out_of_range) {
347 : 0 : gjs_throw(cx, "value is out of range for hash table key of type %s",
348 : : Gjs::static_type_name<IntType>());
349 : : }
350 : :
351 : 8 : *pointer_out = gjs_int_to_pointer<IntType>(i);
352 : :
353 : 8 : return true;
354 : : }
355 : :
356 : : /* Converts a JS::Value to a GHashTable key, stuffing it into @pointer_out if
357 : : * possible, otherwise giving the location of an allocated key in @pointer_out.
358 : : */
359 : : GJS_JSAPI_RETURN_CONVENTION
360 : 41 : static bool value_to_ghashtable_key(JSContext* cx, JS::HandleValue value,
361 : : GITypeTag type_tag, void** pointer_out) {
362 : 41 : bool unsupported = false;
363 : :
364 : 41 : g_assert((value.isString() || value.isInt32()) &&
365 : : "keys from JS_Enumerate must be non-symbol property keys");
366 : :
367 : : gjs_debug_marshal(GJS_DEBUG_GFUNCTION,
368 : : "Converting JS::Value to GHashTable key %s",
369 : : g_type_tag_to_string(type_tag));
370 : :
371 [ - - - - : 41 : switch (type_tag) {
+ - - - -
+ - - ]
372 : 0 : case GI_TYPE_TAG_BOOLEAN:
373 : : /* This doesn't seem particularly useful, but it's easy */
374 : 0 : *pointer_out = gjs_int_to_pointer(JS::ToBoolean(value));
375 : 0 : break;
376 : :
377 : 0 : case GI_TYPE_TAG_UNICHAR:
378 [ # # ]: 0 : if (value.isInt32()) {
379 : 0 : *pointer_out = gjs_int_to_pointer(value.toInt32());
380 : : } else {
381 : : uint32_t ch;
382 [ # # ]: 0 : if (!gjs_unichar_from_string(cx, value, &ch))
383 : 0 : return false;
384 : 0 : *pointer_out = gjs_int_to_pointer(ch);
385 : : }
386 : 0 : break;
387 : :
388 : 0 : case GI_TYPE_TAG_INT8:
389 [ # # ]: 0 : if (!hashtable_int_key<int8_t>(cx, value, pointer_out))
390 : 0 : return false;
391 : 0 : break;
392 : :
393 : 0 : case GI_TYPE_TAG_INT16:
394 [ # # ]: 0 : if (!hashtable_int_key<int16_t>(cx, value, pointer_out))
395 : 0 : return false;
396 : 0 : break;
397 : :
398 : 8 : case GI_TYPE_TAG_INT32:
399 [ - + ]: 8 : if (!hashtable_int_key<int32_t>(cx, value, pointer_out))
400 : 0 : return false;
401 : 8 : break;
402 : :
403 : 0 : case GI_TYPE_TAG_UINT8:
404 [ # # ]: 0 : if (!hashtable_int_key<uint8_t>(cx, value, pointer_out))
405 : 0 : return false;
406 : 0 : break;
407 : :
408 : 0 : case GI_TYPE_TAG_UINT16:
409 [ # # ]: 0 : if (!hashtable_int_key<uint16_t>(cx, value, pointer_out))
410 : 0 : return false;
411 : 0 : break;
412 : :
413 : 0 : case GI_TYPE_TAG_UINT32:
414 [ # # ]: 0 : if (!hashtable_int_key<uint32_t>(cx, value, pointer_out))
415 : 0 : return false;
416 : 0 : break;
417 : :
418 : 0 : case GI_TYPE_TAG_FILENAME: {
419 : 0 : GjsAutoChar cstr;
420 : 0 : JS::RootedValue str_val(cx, value);
421 [ # # ]: 0 : if (!str_val.isString()) {
422 : 0 : JS::RootedString str(cx, JS::ToString(cx, str_val));
423 : 0 : str_val.setString(str);
424 : 0 : }
425 [ # # ]: 0 : if (!gjs_string_to_filename(cx, str_val, &cstr))
426 : 0 : return false;
427 : 0 : *pointer_out = cstr.release();
428 : 0 : break;
429 [ # # # # ]: 0 : }
430 : :
431 : 33 : case GI_TYPE_TAG_UTF8: {
432 : 33 : JS::RootedString str(cx);
433 [ + + ]: 33 : if (!value.isString())
434 : 18 : str = JS::ToString(cx, value);
435 : : else
436 : 15 : str = value.toString();
437 : :
438 : 33 : JS::UniqueChars cstr(JS_EncodeStringToUTF8(cx, str));
439 [ - + ]: 33 : if (!cstr)
440 : 0 : return false;
441 : 33 : *pointer_out = g_strdup(cstr.get());
442 : 33 : break;
443 [ - + - + ]: 66 : }
444 : :
445 : 0 : case GI_TYPE_TAG_FLOAT:
446 : : case GI_TYPE_TAG_DOUBLE:
447 : : case GI_TYPE_TAG_INT64:
448 : : case GI_TYPE_TAG_UINT64:
449 : : /* FIXME: The above four could be supported, but are currently not. The ones
450 : : * below cannot be key types in a regular JS object; we would need to allow
451 : : * marshalling Map objects into GHashTables to support those. */
452 : : case GI_TYPE_TAG_VOID:
453 : : case GI_TYPE_TAG_GTYPE:
454 : : case GI_TYPE_TAG_ERROR:
455 : : case GI_TYPE_TAG_INTERFACE:
456 : : case GI_TYPE_TAG_GLIST:
457 : : case GI_TYPE_TAG_GSLIST:
458 : : case GI_TYPE_TAG_GHASH:
459 : : case GI_TYPE_TAG_ARRAY:
460 : 0 : unsupported = true;
461 : 0 : break;
462 : :
463 : 0 : default:
464 : 0 : g_warning("Unhandled type %s for GHashTable key conversion",
465 : : g_type_tag_to_string(type_tag));
466 : 0 : unsupported = true;
467 : 0 : break;
468 : : }
469 : :
470 [ - + ]: 41 : if (G_UNLIKELY(unsupported)) {
471 : 0 : gjs_throw(cx, "Type %s not supported for hash table keys",
472 : : g_type_tag_to_string(type_tag));
473 : 0 : return false;
474 : : }
475 : :
476 : 41 : return true;
477 : : }
478 : :
479 : : template <typename T>
480 : 16 : [[nodiscard]] static T* heap_value_new_from_arg(GIArgument* val_arg) {
481 : 16 : T* heap_val = g_new(T, 1);
482 : 16 : *heap_val = gjs_arg_get<T>(val_arg);
483 : :
484 : 16 : return heap_val;
485 : : }
486 : :
487 : : GJS_JSAPI_RETURN_CONVENTION
488 : 11 : static bool gjs_object_to_g_hash(JSContext* context, JS::HandleObject props,
489 : : GITypeInfo* type_info, GITransfer transfer,
490 : : GHashTable** hash_p) {
491 : : size_t id_ix, id_len;
492 : :
493 : 11 : g_assert(props && "Property bag cannot be null");
494 : :
495 : 11 : GjsAutoBaseInfo key_param_info = g_type_info_get_param_type(type_info, 0);
496 : 11 : GjsAutoBaseInfo val_param_info = g_type_info_get_param_type(type_info, 1);
497 : :
498 [ - + ]: 11 : if (transfer == GI_TRANSFER_CONTAINER) {
499 [ # # # # : 0 : if (type_needs_release (key_param_info, g_type_info_get_tag(key_param_info)) ||
# # ]
500 : 0 : type_needs_release (val_param_info, g_type_info_get_tag(val_param_info))) {
501 : : /* FIXME: to make this work, we'd have to keep a list of temporary
502 : : * GArguments for the function call so we could free them after
503 : : * the surrounding container had been freed by the callee.
504 : : */
505 : 0 : gjs_throw(context,
506 : : "Container transfer for in parameters not supported");
507 : 0 : return false;
508 : : }
509 : :
510 : 0 : transfer = GI_TRANSFER_NOTHING;
511 : : }
512 : :
513 : 11 : JS::Rooted<JS::IdVector> ids(context, context);
514 [ - + ]: 11 : if (!JS_Enumerate(context, props, &ids))
515 : 0 : return false;
516 : :
517 : 11 : GITypeTag key_tag = g_type_info_get_tag(key_param_info);
518 : : GjsAutoPointer<GHashTable, GHashTable, g_hash_table_destroy> result =
519 : 11 : create_hash_table_for_key_type(key_tag);
520 : :
521 : 11 : JS::RootedValue key_js(context), val_js(context);
522 : 11 : JS::RootedId cur_id(context);
523 [ + + ]: 52 : for (id_ix = 0, id_len = ids.length(); id_ix < id_len; ++id_ix) {
524 : 41 : cur_id = ids[id_ix];
525 : : gpointer key_ptr, val_ptr;
526 : 41 : GIArgument val_arg = { 0 };
527 : :
528 : 41 : if (!JS_IdToValue(context, cur_id, &key_js) ||
529 : : // Type check key type.
530 [ + - ]: 41 : !value_to_ghashtable_key(context, key_js, key_tag, &key_ptr) ||
531 [ + - + - ]: 123 : !JS_GetPropertyById(context, props, cur_id, &val_js) ||
532 : : // Type check and convert value to a C type
533 [ - + - + ]: 82 : !gjs_value_to_g_argument(context, val_js, val_param_info, nullptr,
534 : : GJS_ARGUMENT_HASH_ELEMENT, transfer,
535 : : GjsArgumentFlags::MAY_BE_NULL, &val_arg))
536 : 0 : return false;
537 : :
538 : 41 : GITypeTag val_type = g_type_info_get_tag(val_param_info);
539 : : /* Use heap-allocated values for types that don't fit in a pointer */
540 [ + + ]: 41 : if (val_type == GI_TYPE_TAG_INT64) {
541 : 4 : val_ptr = heap_value_new_from_arg<int64_t>(&val_arg);
542 [ + + ]: 37 : } else if (val_type == GI_TYPE_TAG_UINT64) {
543 : 4 : val_ptr = heap_value_new_from_arg<uint64_t>(&val_arg);
544 [ + + ]: 33 : } else if (val_type == GI_TYPE_TAG_FLOAT) {
545 : 4 : val_ptr = heap_value_new_from_arg<float>(&val_arg);
546 [ + + ]: 29 : } else if (val_type == GI_TYPE_TAG_DOUBLE) {
547 : 4 : val_ptr = heap_value_new_from_arg<double>(&val_arg);
548 : : } else {
549 : : // Other types are simply stuffed inside the pointer
550 : 25 : val_ptr = g_type_info_hash_pointer_from_argument(val_param_info,
551 : : &val_arg);
552 : : }
553 : :
554 : : #if __GNUC__ >= 8 // clang-format off
555 : : _Pragma("GCC diagnostic push")
556 : : _Pragma("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
557 : : #endif
558 : : // The compiler isn't smart enough to figure out that key_ptr will
559 : : // always be initialized if value_to_ghashtable_key() returns true.
560 : 41 : g_hash_table_insert(result, key_ptr, val_ptr);
561 : : #if __GNUC__ >= 8
562 : : _Pragma("GCC diagnostic pop")
563 : : #endif // clang-format on
564 : : }
565 : :
566 : 11 : *hash_p = result.release();
567 : 11 : return true;
568 : 11 : }
569 : :
570 : : template <typename T>
571 : 325 : [[nodiscard]] constexpr T* array_allocate(size_t length) {
572 : : if constexpr (std::is_same_v<T, char*>)
573 : 39 : return g_new0(char*, length);
574 : :
575 : 286 : T* array = g_new(T, length);
576 : 286 : array[length - 1] = {0};
577 : 286 : return array;
578 : : }
579 : :
580 : : template <GITypeTag TAG, typename T>
581 : 347 : GJS_JSAPI_RETURN_CONVENTION static bool js_value_to_c_strict(
582 : : JSContext* cx, const JS::HandleValue& value, T* out) {
583 : : using ValueHolderT = Gjs::JsValueHolder::Strict<T, TAG>;
584 : : if constexpr (Gjs::type_has_js_getter<T, ValueHolderT>())
585 : 311 : return Gjs::js_value_to_c<TAG>(cx, value, out);
586 : :
587 : : ValueHolderT v;
588 : 36 : bool ret = Gjs::js_value_to_c<TAG>(cx, value, &v);
589 : 36 : *out = v;
590 : :
591 : 36 : return ret;
592 : : }
593 : :
594 : : template <typename T, GITypeTag TAG = GI_TYPE_TAG_VOID>
595 : 101 : GJS_JSAPI_RETURN_CONVENTION static bool gjs_array_to_auto_array(
596 : : JSContext* cx, JS::Value array_value, size_t length, void** arr_p) {
597 : 101 : JS::RootedObject array(cx, array_value.toObjectOrNull());
598 : 101 : JS::RootedValue elem(cx);
599 : :
600 : : // Add one so we're always zero terminated
601 : 101 : GjsSmartPointer<T> result = array_allocate<T>(length + 1);
602 : :
603 [ + + ]: 444 : for (size_t i = 0; i < length; ++i) {
604 : 347 : elem = JS::UndefinedValue();
605 : :
606 [ - + ]: 347 : if (!JS_GetElement(cx, array, i, &elem)) {
607 : 0 : gjs_throw(cx, "Missing array element %" G_GSIZE_FORMAT, i);
608 : 0 : return false;
609 : : }
610 : :
611 [ + + ]: 347 : if (!js_value_to_c_strict<TAG>(cx, elem, &result[i])) {
612 : 4 : gjs_throw(cx, "Invalid element in %s array",
613 : : Gjs::static_type_name<T, TAG>());
614 : 4 : return false;
615 : : }
616 : : }
617 : :
618 : 97 : *arr_p = result.release();
619 : :
620 : 97 : return true;
621 : 101 : }
622 : :
623 : : bool
624 : 14 : gjs_array_from_strv(JSContext *context,
625 : : JS::MutableHandleValue value_p,
626 : : const char **strv)
627 : : {
628 : : guint i;
629 : 14 : JS::RootedValueVector elems(context);
630 : :
631 : : /* We treat a NULL strv as an empty array, since this function should always
632 : : * set an array value when returning true.
633 : : * Another alternative would be to set value_p to JS::NullValue, but clients
634 : : * would need to always check for both an empty array and null if that was
635 : : * the case.
636 : : */
637 [ + + + + ]: 38 : for (i = 0; strv != NULL && strv[i] != NULL; i++) {
638 [ - + ]: 24 : if (!elems.growBy(1)) {
639 : 0 : JS_ReportOutOfMemory(context);
640 : 0 : return false;
641 : : }
642 : :
643 [ - + ]: 24 : if (!gjs_string_from_utf8(context, strv[i], elems[i]))
644 : 0 : return false;
645 : : }
646 : :
647 : 14 : JS::RootedObject obj(context, JS::NewArrayObject(context, elems));
648 [ - + ]: 14 : if (!obj)
649 : 0 : return false;
650 : :
651 : 14 : value_p.setObject(*obj);
652 : :
653 : 14 : return true;
654 : 14 : }
655 : :
656 : : bool
657 : 39 : gjs_array_to_strv(JSContext *context,
658 : : JS::Value array_value,
659 : : unsigned int length,
660 : : void **arr_p)
661 : : {
662 : 39 : return gjs_array_to_auto_array<char*>(context, array_value, length, arr_p);
663 : : }
664 : :
665 : : GJS_JSAPI_RETURN_CONVENTION
666 : 14 : static bool gjs_string_to_intarray(JSContext* context, JS::HandleString str,
667 : : GITypeTag element_type, void** arr_p,
668 : : size_t* length) {
669 : : char16_t *result16;
670 : :
671 [ + + + + ]: 14 : switch (element_type) {
672 : 9 : case GI_TYPE_TAG_INT8:
673 : : case GI_TYPE_TAG_UINT8: {
674 : 9 : JS::UniqueChars result;
675 [ - + ]: 9 : if (!gjs_string_to_utf8_n(context, str, &result, length))
676 : 0 : return false;
677 : :
678 : 9 : *arr_p = _gjs_memdup2(result.get(), *length);
679 : 9 : return true;
680 : 9 : }
681 : :
682 : 2 : case GI_TYPE_TAG_INT16:
683 : : case GI_TYPE_TAG_UINT16: {
684 [ - + ]: 2 : if (!gjs_string_get_char16_data(context, str, &result16, length))
685 : 0 : return false;
686 : 2 : *arr_p = result16;
687 : 2 : return true;
688 : : }
689 : :
690 : 2 : case GI_TYPE_TAG_UNICHAR: {
691 : : gunichar* result_ucs4;
692 [ - + ]: 2 : if (!gjs_string_to_ucs4(context, str, &result_ucs4, length))
693 : 0 : return false;
694 : 2 : *arr_p = result_ucs4;
695 : 2 : return true;
696 : : }
697 : :
698 : 1 : default:
699 : : /* can't convert a string to this type */
700 : 1 : gjs_throw(context, "Cannot convert string to array of '%s'",
701 : : g_type_tag_to_string(element_type));
702 : 1 : return false;
703 : : }
704 : : }
705 : :
706 : : GJS_JSAPI_RETURN_CONVENTION
707 : : static bool
708 : 224 : gjs_array_to_ptrarray(JSContext *context,
709 : : JS::Value array_value,
710 : : unsigned int length,
711 : : GITransfer transfer,
712 : : GITypeInfo *param_info,
713 : : void **arr_p)
714 : : {
715 : : unsigned int i;
716 : 224 : JS::RootedObject array_obj(context, array_value.toObjectOrNull());
717 : 224 : JS::RootedValue elem(context);
718 : :
719 : : /* Always one extra element, to cater for null terminated arrays */
720 : 224 : GjsAutoPointer<void*> array = array_allocate<void*>(length + 1);
721 : :
722 [ + + ]: 577 : for (i = 0; i < length; i++) {
723 : : GIArgument arg;
724 : 353 : gjs_arg_unset<void*>(&arg);
725 : :
726 : 353 : elem = JS::UndefinedValue();
727 [ - + ]: 353 : if (!JS_GetElement(context, array_obj, i, &elem)) {
728 : 0 : gjs_throw(context,
729 : : "Missing array element %u",
730 : : i);
731 : 0 : return false;
732 : : }
733 : :
734 [ - + ]: 353 : if (!gjs_value_to_g_argument(
735 : : context, elem, param_info,
736 : : GJS_ARGUMENT_ARRAY_ELEMENT, transfer,
737 : : &arg)) {
738 : 0 : gjs_throw(context,
739 : : "Invalid element in array");
740 : 0 : return false;
741 : : }
742 : :
743 : 353 : array[i] = gjs_arg_get<void*>(&arg);
744 : : }
745 : :
746 : 224 : *arr_p = array.release();
747 : 224 : return true;
748 : 224 : }
749 : :
750 : : GJS_JSAPI_RETURN_CONVENTION
751 : 4 : static bool gjs_array_to_flat_array(JSContext* cx, JS::HandleValue array_value,
752 : : unsigned length, GITypeInfo* param_info,
753 : : size_t param_size, void** arr_p) {
754 : 4 : g_assert((param_size > 0) &&
755 : : "Only flat arrays of elements of known size are supported");
756 : :
757 : 4 : GjsAutoPointer<uint8_t> flat_array = g_new0(uint8_t, param_size * length);
758 : :
759 : 4 : JS::RootedObject array(cx, &array_value.toObject());
760 : 4 : JS::RootedValue elem(cx);
761 [ + + ]: 9 : for (unsigned i = 0; i < length; i++) {
762 : 5 : elem = JS::UndefinedValue();
763 : :
764 [ - + ]: 5 : if (!JS_GetElement(cx, array, i, &elem)) {
765 : 0 : gjs_throw(cx, "Missing array element %u", i);
766 : 0 : return false;
767 : : }
768 : :
769 : : GIArgument arg;
770 [ - + ]: 5 : if (!gjs_value_to_g_argument(cx, elem, param_info,
771 : : GJS_ARGUMENT_ARRAY_ELEMENT,
772 : : GI_TRANSFER_NOTHING, &arg))
773 : 0 : return false;
774 : :
775 : 5 : memcpy(&flat_array[param_size * i], gjs_arg_get<void*>(&arg),
776 : : param_size);
777 : : }
778 : :
779 : 4 : *arr_p = flat_array.release();
780 : 4 : return true;
781 : 4 : }
782 : :
783 : 8 : [[nodiscard]] static bool is_gvalue(GIBaseInfo* info, GIInfoType info_type) {
784 [ - + - ]: 8 : switch (info_type) {
785 : 0 : case GI_INFO_TYPE_VALUE:
786 : 0 : return true;
787 : :
788 : 8 : case GI_INFO_TYPE_STRUCT:
789 : : case GI_INFO_TYPE_OBJECT:
790 : : case GI_INFO_TYPE_INTERFACE:
791 : : case GI_INFO_TYPE_BOXED: {
792 : 8 : GType gtype = g_registered_type_info_get_g_type(info);
793 [ + + - + ]: 8 : return g_type_is_a(gtype, G_TYPE_VALUE);
794 : : }
795 : :
796 : 0 : default:
797 : 0 : return false;
798 : : }
799 : : }
800 : :
801 : : GJS_JSAPI_RETURN_CONVENTION
802 : 321 : static bool gjs_array_to_array(JSContext* context, JS::HandleValue array_value,
803 : : size_t length, GITransfer transfer,
804 : : GITypeInfo* param_info, void** arr_p) {
805 : 321 : GITypeTag element_type = g_type_info_get_storage_type(param_info);
806 : :
807 [ + + + + : 321 : switch (element_type) {
+ - + + +
+ + + - +
+ - - ]
808 : 31 : case GI_TYPE_TAG_UTF8:
809 : 31 : return gjs_array_to_strv (context, array_value, length, arr_p);
810 : 3 : case GI_TYPE_TAG_BOOLEAN:
811 : 3 : return gjs_array_to_auto_array<gboolean, GI_TYPE_TAG_BOOLEAN>(
812 : 3 : context, array_value, length, arr_p);
813 : 2 : case GI_TYPE_TAG_UNICHAR:
814 : 2 : return gjs_array_to_auto_array<char32_t>(context, array_value, length,
815 : 2 : arr_p);
816 : 6 : case GI_TYPE_TAG_UINT8:
817 : 6 : return gjs_array_to_auto_array<uint8_t>(context, array_value, length,
818 : 6 : arr_p);
819 : 1 : case GI_TYPE_TAG_INT8:
820 : 1 : return gjs_array_to_auto_array<int8_t>(context, array_value, length,
821 : 1 : arr_p);
822 : 0 : case GI_TYPE_TAG_UINT16:
823 : 0 : return gjs_array_to_auto_array<uint16_t>(context, array_value, length,
824 : 0 : arr_p);
825 : 2 : case GI_TYPE_TAG_INT16:
826 : 2 : return gjs_array_to_auto_array<int16_t>(context, array_value, length,
827 : 2 : arr_p);
828 : 3 : case GI_TYPE_TAG_UINT32:
829 : 3 : return gjs_array_to_auto_array<uint32_t>(context, array_value, length,
830 : 3 : arr_p);
831 : 34 : case GI_TYPE_TAG_INT32:
832 : 34 : return gjs_array_to_auto_array<int32_t>(context, array_value, length,
833 : 34 : arr_p);
834 : 2 : case GI_TYPE_TAG_INT64:
835 : 2 : return gjs_array_to_auto_array<int64_t>(context, array_value, length,
836 : 2 : arr_p);
837 : 1 : case GI_TYPE_TAG_UINT64:
838 : 1 : return gjs_array_to_auto_array<uint64_t>(context, array_value, length,
839 : 1 : arr_p);
840 : 1 : case GI_TYPE_TAG_FLOAT:
841 : 1 : return gjs_array_to_auto_array<float>(context, array_value, length,
842 : 1 : arr_p);
843 : 0 : case GI_TYPE_TAG_DOUBLE:
844 : 0 : return gjs_array_to_auto_array<double>(context, array_value, length,
845 : 0 : arr_p);
846 : 3 : case GI_TYPE_TAG_GTYPE:
847 : 3 : return gjs_array_to_auto_array<GType, GI_TYPE_TAG_GTYPE>(
848 : 3 : context, array_value, length, arr_p);
849 : :
850 : : /* Everything else is a pointer type */
851 : 232 : case GI_TYPE_TAG_INTERFACE:
852 [ + + ]: 232 : if (!g_type_info_is_pointer(param_info)) {
853 : : GjsAutoBaseInfo interface_info =
854 : 8 : g_type_info_get_interface(param_info);
855 : 8 : GIInfoType info_type = g_base_info_get_type(interface_info);
856 : :
857 [ + + ]: 8 : if (is_gvalue(interface_info, info_type)) {
858 : : // Special case for GValue "flat arrays", this could also
859 : : // using the generic case, but if we do so we're leaking atm.
860 : 4 : return gjs_array_to_auto_array<GValue>(context, array_value,
861 : 4 : length, arr_p);
862 : : }
863 : :
864 : 4 : size_t element_size = gjs_type_get_element_size(
865 : : g_type_info_get_tag(param_info), param_info);
866 : :
867 [ + - ]: 4 : if (element_size) {
868 : 4 : return gjs_array_to_flat_array(context, array_value, length,
869 : 4 : param_info, element_size, arr_p);
870 : : }
871 [ - + ]: 8 : }
872 : : [[fallthrough]];
873 : : case GI_TYPE_TAG_ARRAY:
874 : : case GI_TYPE_TAG_GLIST:
875 : : case GI_TYPE_TAG_GSLIST:
876 : : case GI_TYPE_TAG_GHASH:
877 : : case GI_TYPE_TAG_ERROR:
878 : : case GI_TYPE_TAG_FILENAME:
879 [ + + ]: 224 : return gjs_array_to_ptrarray(context,
880 : : array_value,
881 : : length,
882 : : transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer,
883 : : param_info,
884 : 224 : arr_p);
885 : 0 : case GI_TYPE_TAG_VOID:
886 : : default:
887 : 0 : gjs_throw(context,
888 : : "Unhandled array element type %d", element_type);
889 : 0 : return false;
890 : : }
891 : : }
892 : :
893 : 53 : size_t gjs_type_get_element_size(GITypeTag element_type,
894 : : GITypeInfo* type_info) {
895 [ + + + - : 53 : if (g_type_info_is_pointer(type_info) &&
+ + ]
896 : : element_type != GI_TYPE_TAG_ARRAY)
897 : 30 : return sizeof(void*);
898 : :
899 [ + - - - : 23 : switch (element_type) {
- + - - -
- - - + -
- - - + -
- - - ]
900 : 1 : case GI_TYPE_TAG_BOOLEAN:
901 : 1 : return sizeof(gboolean);
902 : 0 : case GI_TYPE_TAG_INT8:
903 : 0 : return sizeof(int8_t);
904 : 0 : case GI_TYPE_TAG_UINT8:
905 : 0 : return sizeof(uint8_t);
906 : 0 : case GI_TYPE_TAG_INT16:
907 : 0 : return sizeof(int16_t);
908 : 0 : case GI_TYPE_TAG_UINT16:
909 : 0 : return sizeof(uint16_t);
910 : 2 : case GI_TYPE_TAG_INT32:
911 : 2 : return sizeof(int32_t);
912 : 0 : case GI_TYPE_TAG_UINT32:
913 : 0 : return sizeof(uint32_t);
914 : 0 : case GI_TYPE_TAG_INT64:
915 : 0 : return sizeof(int64_t);
916 : 0 : case GI_TYPE_TAG_UINT64:
917 : 0 : return sizeof(uint64_t);
918 : 0 : case GI_TYPE_TAG_FLOAT:
919 : 0 : return sizeof(float);
920 : 0 : case GI_TYPE_TAG_DOUBLE:
921 : 0 : return sizeof(double);
922 : 0 : case GI_TYPE_TAG_GTYPE:
923 : 0 : return sizeof(GType);
924 : 2 : case GI_TYPE_TAG_UNICHAR:
925 : 2 : return sizeof(char32_t);
926 : 0 : case GI_TYPE_TAG_GLIST:
927 : 0 : return sizeof(GSList);
928 : 0 : case GI_TYPE_TAG_GSLIST:
929 : 0 : return sizeof(GList);
930 : 0 : case GI_TYPE_TAG_ERROR:
931 : 0 : return sizeof(GError);
932 : 0 : case GI_TYPE_TAG_UTF8:
933 : : case GI_TYPE_TAG_FILENAME:
934 : 0 : return sizeof(char*);
935 : 18 : case GI_TYPE_TAG_INTERFACE: {
936 : 18 : GjsAutoBaseInfo interface_info = g_type_info_get_interface(type_info);
937 : :
938 [ - + - - : 18 : switch (g_base_info_get_type(interface_info)) {
- ]
939 : 0 : case GI_INFO_TYPE_ENUM:
940 : : case GI_INFO_TYPE_FLAGS:
941 : 0 : return sizeof(unsigned int);
942 : :
943 : 18 : case GI_INFO_TYPE_STRUCT:
944 : 18 : return g_struct_info_get_size(interface_info);
945 : 0 : case GI_INFO_TYPE_UNION:
946 : 0 : return g_union_info_get_size(interface_info);
947 : 0 : case GI_INFO_TYPE_VALUE:
948 : 0 : return sizeof(GValue);
949 : 0 : default:
950 : 0 : return 0;
951 : : }
952 : 18 : }
953 : :
954 : 0 : case GI_TYPE_TAG_GHASH:
955 : 0 : return sizeof(void*);
956 : :
957 : 0 : case GI_TYPE_TAG_ARRAY:
958 [ # # ]: 0 : if (g_type_info_get_array_type(type_info) == GI_ARRAY_TYPE_C) {
959 : 0 : int length = g_type_info_get_array_length(type_info);
960 [ # # ]: 0 : if (length < 0)
961 : 0 : return sizeof(void*);
962 : :
963 : : GjsAutoBaseInfo param_info =
964 : 0 : g_type_info_get_param_type(type_info, 0);
965 : 0 : GITypeTag param_tag = g_type_info_get_tag(param_info);
966 : : size_t param_size =
967 : 0 : gjs_type_get_element_size(param_tag, param_info);
968 : :
969 [ # # ]: 0 : if (param_size)
970 : 0 : return param_size * length;
971 [ # # ]: 0 : }
972 : :
973 : 0 : return sizeof(void*);
974 : :
975 : 0 : case GI_TYPE_TAG_VOID:
976 : 0 : break;
977 : : }
978 : :
979 : : g_return_val_if_reached(0);
980 : : }
981 : :
982 : : enum class ArrayReleaseType {
983 : : EXPLICIT_LENGTH,
984 : : ZERO_TERMINATED,
985 : : };
986 : :
987 : : template <ArrayReleaseType release_type = ArrayReleaseType::EXPLICIT_LENGTH>
988 : 356 : static inline bool gjs_g_argument_release_array_internal(
989 : : JSContext* cx, GITransfer element_transfer, GjsArgumentFlags flags,
990 : : GITypeInfo* param_type, unsigned length, GIArgument* arg) {
991 : 356 : GjsAutoPointer<uint8_t, void, g_free> arg_array =
992 : : gjs_arg_steal<uint8_t*>(arg);
993 : :
994 [ + + ]: 356 : if (!arg_array)
995 : 17 : return true;
996 : :
997 [ + + ]: 339 : if (element_transfer != GI_TRANSFER_EVERYTHING)
998 : 3 : return true;
999 : :
1000 : : if constexpr (release_type == ArrayReleaseType::EXPLICIT_LENGTH) {
1001 [ + + ]: 325 : if (length == 0)
1002 : 32 : return true;
1003 : : }
1004 : :
1005 : 304 : GITypeTag type_tag = g_type_info_get_tag(param_type);
1006 : :
1007 [ + + + + ]: 597 : if (flags & GjsArgumentFlags::ARG_IN &&
1008 [ + + ]: 293 : !type_needs_release(param_type, type_tag))
1009 : 266 : return true;
1010 : :
1011 [ + + + + ]: 49 : if (flags & GjsArgumentFlags::ARG_OUT &&
1012 [ + + ]: 11 : !type_needs_out_release(param_type, type_tag))
1013 : 7 : return true;
1014 : :
1015 : 31 : size_t element_size = gjs_type_get_element_size(type_tag, param_type);
1016 [ - + ]: 31 : if G_UNLIKELY (element_size == 0)
1017 : 0 : return true;
1018 : :
1019 : 31 : bool is_pointer = g_type_info_is_pointer(param_type);
1020 [ + - + ]: 171 : for (size_t i = 0;; i++) {
1021 : : GIArgument elem;
1022 : 90 : auto* element_start = &arg_array[i * element_size];
1023 : 90 : auto* pointer =
1024 [ + + ]: 90 : is_pointer ? *reinterpret_cast<uint8_t**>(element_start) : nullptr;
1025 : :
1026 : : if constexpr (release_type == ArrayReleaseType::ZERO_TERMINATED) {
1027 [ + - ]: 34 : if (is_pointer) {
1028 [ + + ]: 34 : if (!pointer)
1029 : 9 : break;
1030 [ # # ]: 0 : } else if (*element_start == 0 &&
1031 [ # # ]: 0 : memcmp(element_start, element_start + 1,
1032 : : element_size - 1) == 0) {
1033 : 0 : break;
1034 : : }
1035 : : }
1036 : :
1037 [ + + ]: 81 : gjs_arg_set(&elem, is_pointer ? pointer : element_start);
1038 : 81 : JS::AutoSaveExceptionState saved_exc(cx);
1039 [ - + ]: 81 : if (!gjs_g_arg_release_internal(cx, element_transfer, param_type,
1040 : : type_tag, GJS_ARGUMENT_ARRAY_ELEMENT,
1041 : : flags, &elem)) {
1042 : 0 : return false;
1043 : : }
1044 : :
1045 : : if constexpr (release_type == ArrayReleaseType::EXPLICIT_LENGTH) {
1046 [ + + ]: 56 : if (i == length - 1)
1047 : 22 : break;
1048 : : }
1049 : : }
1050 : :
1051 : 31 : return true;
1052 : 356 : }
1053 : :
1054 : 6 : static GArray* garray_new_for_storage_type(unsigned length,
1055 : : GITypeTag storage_type,
1056 : : GITypeInfo* type_info) {
1057 : 6 : size_t element_size = gjs_type_get_element_size(storage_type, type_info);
1058 : 6 : return g_array_sized_new(true, false, element_size, length);
1059 : : }
1060 : :
1061 : 12 : char* gjs_argument_display_name(const char* arg_name,
1062 : : GjsArgumentType arg_type) {
1063 [ + + - - : 12 : switch (arg_type) {
- - - ]
1064 : 10 : case GJS_ARGUMENT_ARGUMENT:
1065 : 10 : return g_strdup_printf("Argument '%s'", arg_name);
1066 : 2 : case GJS_ARGUMENT_RETURN_VALUE:
1067 : 2 : return g_strdup("Return value");
1068 : 0 : case GJS_ARGUMENT_FIELD:
1069 : 0 : return g_strdup_printf("Field '%s'", arg_name);
1070 : 0 : case GJS_ARGUMENT_LIST_ELEMENT:
1071 : 0 : return g_strdup("List element");
1072 : 0 : case GJS_ARGUMENT_HASH_ELEMENT:
1073 : 0 : return g_strdup("Hash element");
1074 : 0 : case GJS_ARGUMENT_ARRAY_ELEMENT:
1075 : 0 : return g_strdup("Array element");
1076 : 0 : default:
1077 : : g_assert_not_reached ();
1078 : : }
1079 : : }
1080 : :
1081 : 12 : [[nodiscard]] static const char* type_tag_to_human_string(
1082 : : GITypeInfo* type_info) {
1083 : : GITypeTag tag;
1084 : :
1085 : 12 : tag = g_type_info_get_tag(type_info);
1086 : :
1087 [ + + ]: 12 : if (tag == GI_TYPE_TAG_INTERFACE) {
1088 : 7 : GjsAutoBaseInfo interface = g_type_info_get_interface(type_info);
1089 : 7 : return g_info_type_to_string(g_base_info_get_type(interface));
1090 : 7 : } else {
1091 : 5 : return g_type_tag_to_string(tag);
1092 : : }
1093 : : }
1094 : :
1095 : : static void
1096 : 12 : throw_invalid_argument(JSContext *context,
1097 : : JS::HandleValue value,
1098 : : GITypeInfo *arginfo,
1099 : : const char *arg_name,
1100 : : GjsArgumentType arg_type)
1101 : : {
1102 : 12 : GjsAutoChar display_name = gjs_argument_display_name(arg_name, arg_type);
1103 : :
1104 : 12 : gjs_throw(context, "Expected type %s for %s but got type '%s'",
1105 : : type_tag_to_human_string(arginfo), display_name.get(),
1106 : : JS::InformalValueTypeName(value));
1107 : 12 : }
1108 : :
1109 : : GJS_JSAPI_RETURN_CONVENTION
1110 : 368 : bool gjs_array_to_explicit_array(JSContext* context, JS::HandleValue value,
1111 : : GITypeInfo* type_info, const char* arg_name,
1112 : : GjsArgumentType arg_type, GITransfer transfer,
1113 : : GjsArgumentFlags flags, void** contents,
1114 : : size_t* length_p) {
1115 : : bool found_length;
1116 : :
1117 : : gjs_debug_marshal(
1118 : : GJS_DEBUG_GFUNCTION,
1119 : : "Converting argument '%s' JS value %s to C array, transfer %d",
1120 : : arg_name, gjs_debug_value(value).c_str(), transfer);
1121 : :
1122 : 368 : GjsAutoTypeInfo param_info = g_type_info_get_param_type(type_info, 0);
1123 : :
1124 [ + + + - : 736 : if ((value.isNull() && !(flags & GjsArgumentFlags::MAY_BE_NULL)) ||
+ + ]
1125 [ + + + + ]: 368 : (!value.isString() && !value.isObjectOrNull())) {
1126 : 4 : throw_invalid_argument(context, value, param_info, arg_name, arg_type);
1127 : 4 : return false;
1128 : : }
1129 : :
1130 [ + + ]: 364 : if (value.isNull()) {
1131 : 12 : *contents = NULL;
1132 : 12 : *length_p = 0;
1133 [ + + ]: 352 : } else if (value.isString()) {
1134 : : /* Allow strings as int8/uint8/int16/uint16 arrays */
1135 : 14 : JS::RootedString str(context, value.toString());
1136 : 14 : GITypeTag element_tag = g_type_info_get_tag(param_info);
1137 [ + + ]: 14 : if (!gjs_string_to_intarray(context, str, element_tag, contents, length_p))
1138 : 1 : return false;
1139 [ + + ]: 14 : } else {
1140 : 338 : JS::RootedObject array_obj(context, &value.toObject());
1141 : 338 : GITypeTag element_type = g_type_info_get_tag(param_info);
1142 [ + + + - : 338 : if (JS_IsUint8Array(array_obj) && (element_type == GI_TYPE_TAG_INT8 ||
+ - + + ]
1143 : : element_type == GI_TYPE_TAG_UINT8)) {
1144 : 16 : GBytes* bytes = gjs_byte_array_get_bytes(array_obj);
1145 : 16 : *contents = g_bytes_unref_to_data(bytes, length_p);
1146 : 16 : return true;
1147 : : }
1148 : :
1149 : 322 : const GjsAtoms& atoms = GjsContextPrivate::atoms(context);
1150 [ - + ]: 322 : if (!JS_HasPropertyById(context, array_obj, atoms.length(),
1151 : : &found_length))
1152 : 0 : return false;
1153 [ + + ]: 322 : if (found_length) {
1154 : : guint32 length;
1155 : :
1156 [ - + ]: 321 : if (!gjs_object_require_converted_property(
1157 : : context, array_obj, nullptr, atoms.length(), &length)) {
1158 : 4 : return false;
1159 : : } else {
1160 [ + + ]: 321 : if (!gjs_array_to_array(context,
1161 : : value,
1162 : : length,
1163 : : transfer,
1164 : : param_info,
1165 : : contents))
1166 : 4 : return false;
1167 : :
1168 : 317 : *length_p = length;
1169 : : }
1170 : : } else {
1171 : 1 : throw_invalid_argument(context, value, param_info, arg_name, arg_type);
1172 : 1 : return false;
1173 : : }
1174 [ + + ]: 338 : }
1175 : :
1176 : 342 : return true;
1177 : 368 : }
1178 : :
1179 : : namespace arg {
1180 : 17390 : [[nodiscard]] static bool is_gdk_atom(GIBaseInfo* info) {
1181 [ + + ]: 17407 : return (strcmp("Atom", g_base_info_get_name(info)) == 0 &&
1182 [ + - ]: 17407 : strcmp("Gdk", g_base_info_get_namespace(info)) == 0);
1183 : : }
1184 : : } // namespace arg
1185 : :
1186 : : static void
1187 : 5 : intern_gdk_atom(const char *name,
1188 : : GArgument *ret)
1189 : : {
1190 : : GjsAutoFunctionInfo atom_intern_fun =
1191 : 5 : g_irepository_find_by_name(nullptr, "Gdk", "atom_intern");
1192 : :
1193 : : GIArgument atom_intern_args[2];
1194 : :
1195 : : /* Can only store char * in GIArgument. First argument to gdk_atom_intern
1196 : : * is const char *, string isn't modified. */
1197 : 5 : gjs_arg_set(&atom_intern_args[0], name);
1198 : 5 : gjs_arg_set(&atom_intern_args[1], false);
1199 : :
1200 : 5 : g_function_info_invoke(atom_intern_fun,
1201 : : atom_intern_args, 2,
1202 : : nullptr, 0,
1203 : : ret,
1204 : : nullptr);
1205 : 5 : }
1206 : :
1207 : 642 : static bool value_to_interface_gi_argument(
1208 : : JSContext* cx, JS::HandleValue value, GIBaseInfo* interface_info,
1209 : : GIInfoType interface_type, GITransfer transfer, bool expect_object,
1210 : : GIArgument* arg, GjsArgumentType arg_type, GjsArgumentFlags flags,
1211 : : bool* report_type_mismatch) {
1212 : 642 : g_assert(report_type_mismatch);
1213 : : GType gtype;
1214 : :
1215 [ + - - ]: 642 : switch (interface_type) {
1216 : 642 : case GI_INFO_TYPE_BOXED:
1217 : : case GI_INFO_TYPE_ENUM:
1218 : : case GI_INFO_TYPE_FLAGS:
1219 : : case GI_INFO_TYPE_INTERFACE:
1220 : : case GI_INFO_TYPE_OBJECT:
1221 : : case GI_INFO_TYPE_STRUCT:
1222 : : case GI_INFO_TYPE_UNION:
1223 : : // These are subtypes of GIRegisteredTypeInfo for which the cast is
1224 : : // safe
1225 : 642 : gtype = g_registered_type_info_get_g_type(interface_info);
1226 : 642 : break;
1227 : :
1228 : 0 : case GI_INFO_TYPE_VALUE:
1229 : : // Special case for GValues
1230 : 0 : gtype = G_TYPE_VALUE;
1231 : 0 : break;
1232 : :
1233 : 0 : default:
1234 : 0 : gtype = G_TYPE_NONE;
1235 : : }
1236 : :
1237 : : if (gtype != G_TYPE_NONE)
1238 : : gjs_debug_marshal(GJS_DEBUG_GFUNCTION, "gtype of INTERFACE is %s",
1239 : : g_type_name(gtype));
1240 : :
1241 [ + + ]: 642 : if (gtype == G_TYPE_VALUE) {
1242 [ + - ]: 3 : if (flags & GjsArgumentFlags::CALLER_ALLOCATES) {
1243 [ - + ]: 3 : if (!gjs_value_to_g_value_no_copy(cx, value,
1244 : : gjs_arg_get<GValue*>(arg)))
1245 : 0 : return false;
1246 : :
1247 : 3 : return true;
1248 : : }
1249 : :
1250 : 0 : Gjs::AutoGValue gvalue;
1251 [ # # ]: 0 : if (!gjs_value_to_g_value(cx, value, &gvalue)) {
1252 : 0 : gjs_arg_unset<void*>(arg);
1253 : 0 : return false;
1254 : : }
1255 : :
1256 : 0 : gjs_arg_set(arg, g_boxed_copy(G_TYPE_VALUE, &gvalue));
1257 : 0 : return true;
1258 : :
1259 [ + + ]: 639 : } else if (arg::is_gdk_atom(interface_info)) {
1260 [ + + + + : 8 : if (!value.isNull() && !value.isString()) {
+ + ]
1261 : 3 : *report_type_mismatch = true;
1262 : 3 : return false;
1263 [ + + ]: 5 : } else if (value.isNull()) {
1264 : 1 : intern_gdk_atom("NONE", arg);
1265 : 1 : return true;
1266 : : }
1267 : :
1268 : 4 : JS::RootedString str(cx, value.toString());
1269 : 4 : JS::UniqueChars name(JS_EncodeStringToUTF8(cx, str));
1270 [ - + ]: 4 : if (!name)
1271 : 0 : return false;
1272 : :
1273 : 4 : intern_gdk_atom(name.get(), arg);
1274 : 4 : return true;
1275 : :
1276 [ - + ]: 635 : } else if (expect_object != value.isObjectOrNull()) {
1277 : 0 : *report_type_mismatch = true;
1278 : 0 : return false;
1279 : :
1280 [ - + ]: 631 : } else if (value.isNull()) {
1281 : 0 : gjs_arg_set(arg, nullptr);
1282 : 0 : return true;
1283 : :
1284 [ + + ]: 631 : } else if (value.isObject()) {
1285 : 525 : JS::RootedObject obj(cx, &value.toObject());
1286 [ + + - + : 927 : if (interface_type == GI_INFO_TYPE_STRUCT &&
- + ]
1287 : 402 : g_struct_info_is_gtype_struct(interface_info)) {
1288 : : GType actual_gtype;
1289 [ # # ]: 0 : if (!gjs_gtype_get_actual_gtype(cx, obj, &actual_gtype))
1290 : 0 : return false;
1291 : :
1292 [ # # ]: 0 : if (actual_gtype == G_TYPE_NONE) {
1293 : 0 : *report_type_mismatch = true;
1294 : 0 : return false;
1295 : : }
1296 : :
1297 : : // We use peek here to simplify reference counting (we just ignore
1298 : : // transfer annotation, as GType classes are never really freed)
1299 : : // We know that the GType class is referenced at least once when
1300 : : // the JS constructor is initialized.
1301 : : void* klass;
1302 [ # # # # : 0 : if (g_type_is_a(actual_gtype, G_TYPE_INTERFACE))
# # ]
1303 : 0 : klass = g_type_default_interface_peek(actual_gtype);
1304 : : else
1305 : 0 : klass = g_type_class_peek(actual_gtype);
1306 : :
1307 : 0 : gjs_arg_set(arg, klass);
1308 : 0 : return true;
1309 : : }
1310 : :
1311 : 525 : GType arg_gtype = gtype;
1312 [ + + + + : 533 : if (interface_type == GI_INFO_TYPE_STRUCT && gtype == G_TYPE_NONE &&
+ - + + ]
1313 : 8 : !g_struct_info_is_foreign(interface_info)) {
1314 : 8 : GType actual_gtype = G_TYPE_NONE;
1315 : : // In case we have no known type from gi we should try to be
1316 : : // more dynamic and try to get the type from JS, to handle the
1317 : : // case in which we're handling a gpointer such as GTypeInstance
1318 : : // FIXME(3v1n0): would be nice to know if GI would give this info
1319 [ - + ]: 8 : if (!gjs_gtype_get_actual_gtype(cx, obj, &actual_gtype))
1320 : 0 : return false;
1321 : :
1322 [ + + ]: 8 : if (G_TYPE_IS_INSTANTIATABLE(actual_gtype))
1323 : 2 : gtype = actual_gtype;
1324 : : }
1325 : :
1326 [ - + ]: 123 : if ((interface_type == GI_INFO_TYPE_STRUCT ||
1327 [ + + + + ]: 1050 : interface_type == GI_INFO_TYPE_BOXED) &&
1328 [ + + + - ]: 402 : !g_type_is_a(gtype, G_TYPE_CLOSURE)) {
1329 : : // Handle Struct/Union first since we don't necessarily need a GType
1330 : : // for them. We special case Closures later, so skip them here.
1331 [ + - - + : 362 : if (g_type_is_a(gtype, G_TYPE_BYTES) && JS_IsUint8Array(obj)) {
- - - + ]
1332 : 0 : gjs_arg_set(arg, gjs_byte_array_get_bytes(obj));
1333 : 0 : return true;
1334 : : }
1335 [ + - - + : 362 : if (g_type_is_a(gtype, G_TYPE_ERROR)) {
- + ]
1336 : 0 : return ErrorBase::transfer_to_gi_argument(
1337 : 0 : cx, obj, arg, GI_DIRECTION_IN, transfer);
1338 : : }
1339 [ + + + - ]: 8 : if (arg_gtype != G_TYPE_NONE || gtype == G_TYPE_NONE ||
1340 [ + - ]: 2 : g_type_is_a(gtype, G_TYPE_BOXED) ||
1341 [ + + + - : 372 : g_type_is_a(gtype, G_TYPE_VALUE) ||
+ - + - +
+ ]
1342 [ - + ]: 2 : g_type_is_a(gtype, G_TYPE_VARIANT)) {
1343 : 720 : return BoxedBase::transfer_to_gi_argument(
1344 : : cx, obj, arg, GI_DIRECTION_IN, transfer, gtype,
1345 : 360 : interface_info);
1346 : : }
1347 : : }
1348 : :
1349 [ - + ]: 165 : if (interface_type == GI_INFO_TYPE_UNION) {
1350 : 0 : return UnionBase::transfer_to_gi_argument(
1351 : 0 : cx, obj, arg, GI_DIRECTION_IN, transfer, gtype, interface_info);
1352 : : }
1353 : :
1354 [ + - ]: 165 : if (gtype != G_TYPE_NONE) {
1355 [ + + + + : 165 : if (g_type_is_a(gtype, G_TYPE_OBJECT)) {
+ + ]
1356 : 16 : return ObjectBase::transfer_to_gi_argument(
1357 : 8 : cx, obj, arg, GI_DIRECTION_IN, transfer, gtype);
1358 : :
1359 [ + + - + : 157 : } else if (g_type_is_a(gtype, G_TYPE_PARAM)) {
+ + ]
1360 [ - + ]: 116 : if (!gjs_typecheck_param(cx, obj, gtype, true)) {
1361 : 0 : gjs_arg_unset<void*>(arg);
1362 : 0 : return false;
1363 : : }
1364 : 116 : gjs_arg_set(arg, gjs_g_param_from_param(cx, obj));
1365 [ - + ]: 116 : if (transfer != GI_TRANSFER_NOTHING)
1366 : 0 : g_param_spec_ref(gjs_arg_get<GParamSpec*>(arg));
1367 : 116 : return true;
1368 : :
1369 [ + - + + : 41 : } else if (g_type_is_a(gtype, G_TYPE_BOXED)) {
+ + ]
1370 [ - + - - : 40 : if (g_type_is_a(gtype, G_TYPE_CLOSURE)) {
+ - ]
1371 : : GClosure* closure =
1372 : 40 : Gjs::Closure::create_marshaled(cx, obj, "boxed");
1373 : : // GI doesn't know about floating GClosure references. We
1374 : : // guess that if this is a return value going from JS::Value
1375 : : // to GArgument, it's intended to be passed to a C API that
1376 : : // will consume the floating reference.
1377 [ - + ]: 40 : if (arg_type != GJS_ARGUMENT_RETURN_VALUE) {
1378 : 0 : g_closure_ref(closure);
1379 : 0 : g_closure_sink(closure);
1380 : : }
1381 : 40 : gjs_arg_set(arg, closure);
1382 : 40 : return true;
1383 : : }
1384 : :
1385 : : // Should have been caught above as STRUCT/BOXED/UNION
1386 : 0 : gjs_throw(
1387 : : cx,
1388 : : "Boxed type %s registered for unexpected interface_type %d",
1389 : : g_type_name(gtype), interface_type);
1390 : 0 : return false;
1391 : :
1392 [ + - ]: 1 : } else if (G_TYPE_IS_INSTANTIATABLE(gtype)) {
1393 : 2 : return FundamentalBase::transfer_to_gi_argument(
1394 : 1 : cx, obj, arg, GI_DIRECTION_IN, transfer, gtype);
1395 : :
1396 [ # # ]: 0 : } else if (G_TYPE_IS_INTERFACE(gtype)) {
1397 : : // Could be a GObject interface that's missing a prerequisite,
1398 : : // or could be a fundamental
1399 [ # # ]: 0 : if (ObjectBase::typecheck(cx, obj, nullptr, gtype,
1400 : : GjsTypecheckNoThrow())) {
1401 : 0 : return ObjectBase::transfer_to_gi_argument(
1402 : 0 : cx, obj, arg, GI_DIRECTION_IN, transfer, gtype);
1403 : : }
1404 : :
1405 : : // If this typecheck fails, then it's neither an object nor a
1406 : : // fundamental
1407 : 0 : return FundamentalBase::transfer_to_gi_argument(
1408 : 0 : cx, obj, arg, GI_DIRECTION_IN, transfer, gtype);
1409 : : }
1410 : :
1411 : 0 : gjs_throw(cx, "Unhandled GType %s unpacking GIArgument from Object",
1412 : : g_type_name(gtype));
1413 : 0 : gjs_arg_unset<void*>(arg);
1414 : 0 : return false;
1415 : : }
1416 : :
1417 : 0 : gjs_debug(GJS_DEBUG_GFUNCTION,
1418 : : "conversion of JSObject value %s to type %s failed",
1419 : 0 : gjs_debug_value(value).c_str(),
1420 : : g_base_info_get_name(interface_info));
1421 : :
1422 : 0 : gjs_throw(cx,
1423 : : "Unexpected unregistered type unpacking GIArgument from "
1424 : : "Object");
1425 : 0 : return false;
1426 : :
1427 [ + + ]: 631 : } else if (value.isNumber()) {
1428 [ + + ]: 102 : if (interface_type == GI_INFO_TYPE_ENUM) {
1429 : : int64_t value_int64;
1430 : :
1431 [ + - - + ]: 196 : if (!JS::ToInt64(cx, value, &value_int64) ||
1432 [ - + ]: 98 : !_gjs_enum_value_is_valid(cx, interface_info, value_int64))
1433 : 0 : return false;
1434 : :
1435 : 98 : gjs_arg_set<int, GI_TYPE_TAG_INTERFACE>(
1436 : : arg, _gjs_enum_to_int(value_int64));
1437 : 98 : return true;
1438 : :
1439 [ + - ]: 4 : } else if (interface_type == GI_INFO_TYPE_FLAGS) {
1440 : : int64_t value_int64;
1441 : :
1442 [ + - - + ]: 8 : if (!JS::ToInt64(cx, value, &value_int64) ||
1443 [ - + ]: 4 : !_gjs_flags_value_is_valid(cx, gtype, value_int64))
1444 : 0 : return false;
1445 : :
1446 : 4 : gjs_arg_set<int, GI_TYPE_TAG_INTERFACE>(
1447 : : arg, _gjs_enum_to_int(value_int64));
1448 : 4 : return true;
1449 : :
1450 [ # # ]: 0 : } else if (gtype == G_TYPE_NONE) {
1451 : 0 : gjs_throw(cx,
1452 : : "Unexpected unregistered type unpacking GIArgument from "
1453 : : "Number");
1454 : 0 : return false;
1455 : : }
1456 : :
1457 : 0 : gjs_throw(cx, "Unhandled GType %s unpacking GIArgument from Number",
1458 : : g_type_name(gtype));
1459 : 0 : return false;
1460 : : }
1461 : :
1462 : 4 : gjs_debug(GJS_DEBUG_GFUNCTION,
1463 : : "JSObject type '%s' is neither null nor an object",
1464 : : JS::InformalValueTypeName(value));
1465 : 4 : *report_type_mismatch = true;
1466 : 4 : return false;
1467 : : }
1468 : :
1469 : : template <typename T>
1470 : 284 : GJS_JSAPI_RETURN_CONVENTION inline static bool gjs_arg_set_from_js_value(
1471 : : JSContext* cx, const JS::HandleValue& value, GArgument* arg,
1472 : : const char* arg_name, GjsArgumentType arg_type) {
1473 : 284 : bool out_of_range = false;
1474 : :
1475 [ - + ]: 284 : if (!gjs_arg_set_from_js_value<T>(cx, value, arg, &out_of_range)) {
1476 [ # # ]: 0 : if (out_of_range) {
1477 : 0 : GjsAutoChar display_name =
1478 : : gjs_argument_display_name(arg_name, arg_type);
1479 : 0 : gjs_throw(cx, "value %s is out of range for %s (type %s)",
1480 : 0 : std::to_string(gjs_arg_get<T>(arg)).c_str(),
1481 : : display_name.get(), Gjs::static_type_name<T>());
1482 : 0 : }
1483 : :
1484 : 0 : return false;
1485 : : }
1486 : :
1487 : : gjs_debug_marshal(
1488 : : GJS_DEBUG_GFUNCTION, "%s set to value %s (type %s)",
1489 : : GjsAutoChar(gjs_argument_display_name(arg_name, arg_type)).get(),
1490 : : std::to_string(gjs_arg_get<T>(arg)).c_str(),
1491 : : Gjs::static_type_name<T>());
1492 : :
1493 : 284 : return true;
1494 : : }
1495 : :
1496 : 571 : static bool check_nullable_argument(JSContext* cx, const char* arg_name,
1497 : : GjsArgumentType arg_type,
1498 : : GITypeTag type_tag, GjsArgumentFlags flags,
1499 : : GIArgument* arg) {
1500 [ + + - + : 571 : if (!(flags & GjsArgumentFlags::MAY_BE_NULL) && !gjs_arg_get<void*>(arg)) {
- + ]
1501 : : GjsAutoChar display_name =
1502 : 0 : gjs_argument_display_name(arg_name, arg_type);
1503 : 0 : gjs_throw(cx, "%s (type %s) may not be null", display_name.get(),
1504 : : g_type_tag_to_string(type_tag));
1505 : 0 : return false;
1506 : 0 : }
1507 : :
1508 : 571 : return true;
1509 : : }
1510 : :
1511 : 1114 : bool gjs_value_to_g_argument(JSContext* context, JS::HandleValue value,
1512 : : GITypeInfo* type_info, const char* arg_name,
1513 : : GjsArgumentType arg_type, GITransfer transfer,
1514 : : GjsArgumentFlags flags, GIArgument* arg) {
1515 : 1114 : GITypeTag type_tag = g_type_info_get_tag(type_info);
1516 : :
1517 : : gjs_debug_marshal(
1518 : : GJS_DEBUG_GFUNCTION,
1519 : : "Converting argument '%s' JS value %s to GIArgument type %s", arg_name,
1520 : : gjs_debug_value(value).c_str(), g_type_tag_to_string(type_tag));
1521 : :
1522 [ - + + + : 1114 : switch (type_tag) {
+ + + + +
+ + + - +
- + + + +
+ + + - ]
1523 : 0 : case GI_TYPE_TAG_VOID:
1524 : : // just so it isn't uninitialized
1525 : 0 : gjs_arg_unset<void*>(arg);
1526 : 0 : return check_nullable_argument(context, arg_name, arg_type, type_tag,
1527 : 0 : flags, arg);
1528 : :
1529 : 47 : case GI_TYPE_TAG_INT8:
1530 : 47 : return gjs_arg_set_from_js_value<int8_t>(context, value, arg, arg_name,
1531 : 47 : arg_type);
1532 : 1 : case GI_TYPE_TAG_UINT8:
1533 : 1 : return gjs_arg_set_from_js_value<uint8_t>(context, value, arg, arg_name,
1534 : 1 : arg_type);
1535 : 4 : case GI_TYPE_TAG_INT16:
1536 : 4 : return gjs_arg_set_from_js_value<int16_t>(context, value, arg, arg_name,
1537 : 4 : arg_type);
1538 : :
1539 : 2 : case GI_TYPE_TAG_UINT16:
1540 : 2 : return gjs_arg_set_from_js_value<uint16_t>(context, value, arg,
1541 : 2 : arg_name, arg_type);
1542 : :
1543 : 113 : case GI_TYPE_TAG_INT32:
1544 : 113 : return gjs_arg_set_from_js_value<int32_t>(context, value, arg, arg_name,
1545 : 113 : arg_type);
1546 : :
1547 : 7 : case GI_TYPE_TAG_UINT32:
1548 : 7 : return gjs_arg_set_from_js_value<uint32_t>(context, value, arg,
1549 : 7 : arg_name, arg_type);
1550 : :
1551 : 63 : case GI_TYPE_TAG_INT64:
1552 : 63 : return gjs_arg_set_from_js_value<int64_t>(context, value, arg, arg_name,
1553 : 63 : arg_type);
1554 : :
1555 : 4 : case GI_TYPE_TAG_UINT64:
1556 : 4 : return gjs_arg_set_from_js_value<uint64_t>(context, value, arg,
1557 : 4 : arg_name, arg_type);
1558 : :
1559 : 80 : case GI_TYPE_TAG_BOOLEAN:
1560 : 80 : gjs_arg_set(arg, JS::ToBoolean(value));
1561 : 80 : return true;
1562 : :
1563 : 17 : case GI_TYPE_TAG_FLOAT:
1564 : 17 : return gjs_arg_set_from_js_value<float>(context, value, arg, arg_name,
1565 : 17 : arg_type);
1566 : :
1567 : 26 : case GI_TYPE_TAG_DOUBLE:
1568 : 26 : return gjs_arg_set_from_js_value<double>(context, value, arg, arg_name,
1569 : 26 : arg_type);
1570 : :
1571 : 0 : case GI_TYPE_TAG_UNICHAR:
1572 [ # # ]: 0 : if (value.isString()) {
1573 [ # # ]: 0 : if (!gjs_unichar_from_string(context, value,
1574 : 0 : &gjs_arg_member<char32_t>(arg)))
1575 : 0 : return false;
1576 : : } else {
1577 : 0 : throw_invalid_argument(context, value, type_info, arg_name,
1578 : : arg_type);
1579 : 0 : return false;
1580 : : }
1581 : 0 : break;
1582 : :
1583 : 3 : case GI_TYPE_TAG_GTYPE:
1584 [ + - ]: 3 : if (value.isObjectOrNull()) {
1585 : : GType gtype;
1586 : 3 : JS::RootedObject obj(context, value.toObjectOrNull());
1587 [ - + ]: 3 : if (!gjs_gtype_get_actual_gtype(context, obj, >ype))
1588 : 0 : return false;
1589 : :
1590 [ - + ]: 3 : if (gtype == G_TYPE_INVALID)
1591 : 0 : return false;
1592 : 3 : gjs_arg_set<GType, GI_TYPE_TAG_GTYPE>(arg, gtype);
1593 [ + - ]: 3 : } else {
1594 : 0 : throw_invalid_argument(context, value, type_info, arg_name,
1595 : : arg_type);
1596 : 0 : return false;
1597 : : }
1598 : 3 : break;
1599 : :
1600 : 0 : case GI_TYPE_TAG_FILENAME:
1601 [ # # ]: 0 : if (value.isNull()) {
1602 : 0 : gjs_arg_set(arg, nullptr);
1603 [ # # ]: 0 : } else if (value.isString()) {
1604 : 0 : GjsAutoChar filename_str;
1605 [ # # ]: 0 : if (!gjs_string_to_filename(context, value, &filename_str))
1606 : 0 : return false;
1607 : :
1608 : 0 : gjs_arg_set(arg, filename_str.release());
1609 [ # # ]: 0 : } else {
1610 : 0 : throw_invalid_argument(context, value, type_info, arg_name,
1611 : : arg_type);
1612 : 0 : return false;
1613 : : }
1614 : :
1615 : 0 : return check_nullable_argument(context, arg_name, arg_type, type_tag,
1616 : 0 : flags, arg);
1617 : :
1618 : 41 : case GI_TYPE_TAG_UTF8:
1619 [ - + ]: 41 : if (value.isNull()) {
1620 : 0 : gjs_arg_set(arg, nullptr);
1621 [ + - ]: 41 : } else if (value.isString()) {
1622 : 41 : JS::RootedString str(context, value.toString());
1623 : 41 : JS::UniqueChars utf8_str(JS_EncodeStringToUTF8(context, str));
1624 [ - + ]: 41 : if (!utf8_str)
1625 : 0 : return false;
1626 : :
1627 : 82 : gjs_arg_set(arg, g_strdup(utf8_str.get()));
1628 [ + - + - ]: 41 : } else {
1629 : 0 : throw_invalid_argument(context, value, type_info, arg_name,
1630 : : arg_type);
1631 : 0 : return false;
1632 : : }
1633 : :
1634 : 41 : return check_nullable_argument(context, arg_name, arg_type, type_tag,
1635 : 41 : flags, arg);
1636 : :
1637 : 2 : case GI_TYPE_TAG_ERROR:
1638 [ - + ]: 2 : if (value.isNull()) {
1639 : 0 : gjs_arg_set(arg, nullptr);
1640 [ + - ]: 2 : } else if (value.isObject()) {
1641 : 2 : JS::RootedObject obj(context, &value.toObject());
1642 [ - + ]: 2 : if (!ErrorBase::transfer_to_gi_argument(context, obj, arg,
1643 : : GI_DIRECTION_IN, transfer))
1644 : 0 : return false;
1645 [ + - ]: 2 : } else {
1646 : 0 : throw_invalid_argument(context, value, type_info, arg_name,
1647 : : arg_type);
1648 : 0 : return false;
1649 : : }
1650 : :
1651 : 2 : return check_nullable_argument(context, arg_name, arg_type, type_tag,
1652 : 2 : flags, arg);
1653 : :
1654 : 642 : case GI_TYPE_TAG_INTERFACE:
1655 : : {
1656 : 642 : bool expect_object = true;
1657 : :
1658 : 642 : GjsAutoBaseInfo interface_info = g_type_info_get_interface(type_info);
1659 : 642 : g_assert(interface_info);
1660 : :
1661 : 642 : GIInfoType interface_type = g_base_info_get_type(interface_info);
1662 [ + + ]: 542 : if (interface_type == GI_INFO_TYPE_ENUM ||
1663 [ + + + + : 1184 : interface_type == GI_INFO_TYPE_FLAGS ||
+ + ]
1664 : 536 : arg::is_gdk_atom(interface_info))
1665 : 114 : expect_object = false;
1666 : :
1667 [ + + - + : 1055 : if (interface_type == GI_INFO_TYPE_STRUCT &&
- + ]
1668 : 413 : g_struct_info_is_foreign(interface_info)) {
1669 : 0 : return gjs_struct_foreign_convert_to_g_argument(
1670 : : context, value, interface_info, arg_name, arg_type, transfer,
1671 : 0 : flags, arg);
1672 : : }
1673 : :
1674 : 642 : bool report_type_mismatch = false;
1675 [ + + ]: 642 : if (!value_to_interface_gi_argument(
1676 : : context, value, interface_info, interface_type, transfer,
1677 : : expect_object, arg, arg_type, flags, &report_type_mismatch)) {
1678 [ + - ]: 7 : if (report_type_mismatch)
1679 : 7 : throw_invalid_argument(context, value, type_info, arg_name,
1680 : : arg_type);
1681 : :
1682 : 7 : return false;
1683 : : }
1684 : :
1685 [ + + ]: 635 : if (expect_object)
1686 : 528 : return check_nullable_argument(context, arg_name, arg_type,
1687 : 528 : type_tag, flags, arg);
1688 [ + + ]: 642 : }
1689 : 107 : break;
1690 : :
1691 : 7 : case GI_TYPE_TAG_GLIST:
1692 : 7 : return gjs_array_to_g_list(context, value, type_info, transfer,
1693 : : arg_name, arg_type,
1694 : 14 : &gjs_arg_member<GList*>(arg));
1695 : 7 : case GI_TYPE_TAG_GSLIST:
1696 : 7 : return gjs_array_to_g_list(context, value, type_info, transfer,
1697 : : arg_name, arg_type,
1698 : 14 : &gjs_arg_member<GSList*>(arg));
1699 : :
1700 : 12 : case GI_TYPE_TAG_GHASH:
1701 [ + + ]: 12 : if (value.isNull()) {
1702 : 1 : gjs_arg_set(arg, nullptr);
1703 [ - + ]: 1 : if (!(flags & GjsArgumentFlags::MAY_BE_NULL)) {
1704 : 0 : throw_invalid_argument(context, value, type_info, arg_name,
1705 : : arg_type);
1706 : 0 : return false;
1707 : : }
1708 [ - + ]: 11 : } else if (!value.isObject()) {
1709 : 0 : throw_invalid_argument(context, value, type_info, arg_name,
1710 : : arg_type);
1711 : 0 : return false;
1712 : : } else {
1713 : : GHashTable *ghash;
1714 : 11 : JS::RootedObject props(context, &value.toObject());
1715 [ - + ]: 11 : if (!gjs_object_to_g_hash(context, props, type_info, transfer,
1716 : : &ghash)) {
1717 : 0 : return false;
1718 : : }
1719 : :
1720 : 11 : gjs_arg_set(arg, ghash);
1721 [ + - ]: 11 : }
1722 : 12 : break;
1723 : :
1724 : 36 : case GI_TYPE_TAG_ARRAY: {
1725 : 36 : GjsAutoPointer<void> data;
1726 : : size_t length;
1727 : 36 : GIArrayType array_type = g_type_info_get_array_type(type_info);
1728 : :
1729 : : /* First, let's handle the case where we're passed an instance
1730 : : * of Uint8Array and it needs to be marshalled to GByteArray.
1731 : : */
1732 [ + + ]: 36 : if (value.isObject()) {
1733 : 29 : JSObject* bytearray_obj = &value.toObject();
1734 [ + + + - : 29 : if (JS_IsUint8Array(bytearray_obj) &&
+ + ]
1735 : : array_type == GI_ARRAY_TYPE_BYTE_ARRAY) {
1736 : 1 : gjs_arg_set(arg, gjs_byte_array_get_byte_array(bytearray_obj));
1737 : 1 : break;
1738 : : } else {
1739 : : /* Fall through, !handled */
1740 : : }
1741 : : }
1742 : :
1743 [ + + ]: 35 : if (!gjs_array_to_explicit_array(context, value, type_info, arg_name,
1744 : : arg_type, transfer, flags, data.out(),
1745 : : &length)) {
1746 : 5 : return false;
1747 : : }
1748 : :
1749 : 30 : GjsAutoTypeInfo param_info = g_type_info_get_param_type(type_info, 0);
1750 [ + + ]: 30 : if (array_type == GI_ARRAY_TYPE_C) {
1751 : 20 : gjs_arg_set(arg, data.release());
1752 [ + + ]: 10 : } else if (array_type == GI_ARRAY_TYPE_ARRAY) {
1753 : 6 : GITypeTag storage_type = g_type_info_get_storage_type(param_info);
1754 : : GArray* array =
1755 : 6 : garray_new_for_storage_type(length, storage_type, param_info);
1756 : :
1757 [ + - ]: 6 : if (data)
1758 : 6 : g_array_append_vals(array, data, length);
1759 : 6 : gjs_arg_set(arg, array);
1760 [ + + ]: 4 : } else if (array_type == GI_ARRAY_TYPE_BYTE_ARRAY) {
1761 : 2 : GByteArray *byte_array = g_byte_array_sized_new(length);
1762 : :
1763 [ + - ]: 2 : if (data)
1764 : 2 : g_byte_array_append(byte_array, data.as<const uint8_t>(),
1765 : : length);
1766 : 2 : gjs_arg_set(arg, byte_array);
1767 [ + - ]: 2 : } else if (array_type == GI_ARRAY_TYPE_PTR_ARRAY) {
1768 : 2 : GPtrArray *array = g_ptr_array_sized_new(length);
1769 : :
1770 : 2 : g_ptr_array_set_size(array, length);
1771 [ + - ]: 2 : if (data)
1772 : 2 : memcpy(array->pdata, data, sizeof(void*) * length);
1773 : 2 : gjs_arg_set(arg, array);
1774 : : }
1775 : 30 : break;
1776 [ + + ]: 66 : }
1777 : 0 : default:
1778 : 0 : g_warning("Unhandled type %s for JavaScript to GArgument conversion",
1779 : : g_type_tag_to_string(type_tag));
1780 : 0 : throw_invalid_argument(context, value, type_info, arg_name, arg_type);
1781 : 0 : return false;
1782 : : }
1783 : :
1784 : 153 : return true;
1785 : : }
1786 : :
1787 : : /* If a callback function with a return value throws, we still have
1788 : : * to return something to C. This function defines what that something
1789 : : * is. It basically boils down to memset(arg, 0, sizeof(*arg)), but
1790 : : * gives as a bit more future flexibility and also will work if
1791 : : * libffi passes us a buffer that only has room for the appropriate
1792 : : * branch of GArgument. (Currently it appears that the return buffer
1793 : : * has a fixed size large enough for the union of all types.)
1794 : : */
1795 : 283 : void gjs_gi_argument_init_default(GITypeInfo* type_info, GIArgument* arg) {
1796 : : GITypeTag type_tag;
1797 : :
1798 : 283 : type_tag = g_type_info_get_tag( (GITypeInfo*) type_info);
1799 : :
1800 [ - - - - : 283 : switch (type_tag) {
- + - - +
- + - - -
+ + - -
- ]
1801 : 0 : case GI_TYPE_TAG_VOID:
1802 : : // just so it isn't uninitialized
1803 : 0 : gjs_arg_unset<void*>(arg);
1804 : 0 : break;
1805 : 0 : case GI_TYPE_TAG_INT8:
1806 : 0 : gjs_arg_unset<int8_t>(arg);
1807 : 0 : break;
1808 : 0 : case GI_TYPE_TAG_UINT8:
1809 : 0 : gjs_arg_unset<uint8_t>(arg);
1810 : 0 : break;
1811 : 0 : case GI_TYPE_TAG_INT16:
1812 : 0 : gjs_arg_unset<int16_t>(arg);
1813 : 0 : break;
1814 : 0 : case GI_TYPE_TAG_UINT16:
1815 : 0 : gjs_arg_unset<uint16_t>(arg);
1816 : 0 : break;
1817 : 54 : case GI_TYPE_TAG_INT32:
1818 : 54 : gjs_arg_unset<int32_t>(arg);
1819 : 54 : break;
1820 : 0 : case GI_TYPE_TAG_UINT32:
1821 : 0 : gjs_arg_unset<uint32_t>(arg);
1822 : 0 : break;
1823 : 0 : case GI_TYPE_TAG_UNICHAR:
1824 : 0 : gjs_arg_unset<char32_t>(arg);
1825 : 0 : break;
1826 : 10 : case GI_TYPE_TAG_INT64:
1827 : 10 : gjs_arg_unset<int64_t>(arg);
1828 : 10 : break;
1829 : 0 : case GI_TYPE_TAG_UINT64:
1830 : 0 : gjs_arg_unset<uint64_t>(arg);
1831 : 0 : break;
1832 : 95 : case GI_TYPE_TAG_BOOLEAN:
1833 : 95 : gjs_arg_unset<bool>(arg);
1834 : 95 : break;
1835 : 0 : case GI_TYPE_TAG_FLOAT:
1836 : 0 : gjs_arg_unset<float>(arg);
1837 : 0 : break;
1838 : 0 : case GI_TYPE_TAG_DOUBLE:
1839 : 0 : gjs_arg_unset<double>(arg);
1840 : 0 : break;
1841 : 0 : case GI_TYPE_TAG_GTYPE:
1842 : 0 : gjs_arg_unset<GType, GI_TYPE_TAG_GTYPE>(arg);
1843 : 0 : break;
1844 : 2 : case GI_TYPE_TAG_FILENAME:
1845 : : case GI_TYPE_TAG_UTF8:
1846 : : case GI_TYPE_TAG_GLIST:
1847 : : case GI_TYPE_TAG_GSLIST:
1848 : : case GI_TYPE_TAG_ERROR:
1849 : 2 : gjs_arg_unset<void*>(arg);
1850 : 2 : break;
1851 : 122 : case GI_TYPE_TAG_INTERFACE: {
1852 : : GIInfoType interface_type;
1853 : :
1854 : : GjsAutoBaseInfo interface_info =
1855 : 122 : g_type_info_get_interface(type_info);
1856 : 122 : g_assert(interface_info != nullptr);
1857 : :
1858 : 122 : interface_type = g_base_info_get_type(interface_info);
1859 : :
1860 [ + + + + ]: 122 : if (interface_type == GI_INFO_TYPE_ENUM ||
1861 : : interface_type == GI_INFO_TYPE_FLAGS)
1862 : 79 : gjs_arg_unset<int, GI_TYPE_TAG_INTERFACE>(arg);
1863 : : else
1864 : 43 : gjs_arg_unset<void*>(arg);
1865 : 122 : } break;
1866 : 0 : case GI_TYPE_TAG_GHASH:
1867 : : // Possibly better to return an empty hash table?
1868 : 0 : gjs_arg_unset<GHashTable*>(arg);
1869 : 0 : break;
1870 : 0 : case GI_TYPE_TAG_ARRAY:
1871 : 0 : gjs_arg_unset<void*>(arg);
1872 : 0 : break;
1873 : 0 : default:
1874 : 0 : g_warning("Unhandled type %s for default GArgument initialization",
1875 : : g_type_tag_to_string(type_tag));
1876 : 0 : break;
1877 : : }
1878 : 283 : }
1879 : :
1880 : 34 : bool gjs_value_to_callback_out_arg(JSContext* context, JS::HandleValue value,
1881 : : GIArgInfo* arg_info, GIArgument* arg) {
1882 : 34 : GIDirection direction [[maybe_unused]] = g_arg_info_get_direction(arg_info);
1883 : 34 : g_assert(
1884 : : (direction == GI_DIRECTION_OUT || direction == GI_DIRECTION_INOUT) &&
1885 : : "gjs_value_to_callback_out_arg does not handle in arguments.");
1886 : :
1887 : 34 : GjsArgumentFlags flags = GjsArgumentFlags::NONE;
1888 : : GITypeInfo type_info;
1889 : :
1890 : 34 : g_arg_info_load_type(arg_info, &type_info);
1891 : :
1892 : : // If the argument is optional and we're passed nullptr,
1893 : : // ignore the GJS value.
1894 [ - + - - : 34 : if (g_arg_info_is_optional(arg_info) && !arg)
- + ]
1895 : 0 : return true;
1896 : :
1897 : : // Otherwise, throw an error to prevent a segfault.
1898 [ - + ]: 34 : if (!arg) {
1899 : 0 : gjs_throw(context,
1900 : : "Return value %s is not optional but was passed NULL",
1901 : : g_base_info_get_name(arg_info));
1902 : 0 : return false;
1903 : : }
1904 : :
1905 [ - + ]: 34 : if (g_arg_info_may_be_null(arg_info))
1906 : 0 : flags |= GjsArgumentFlags::MAY_BE_NULL;
1907 [ + + ]: 34 : if (g_arg_info_is_caller_allocates(arg_info))
1908 : 3 : flags |= GjsArgumentFlags::CALLER_ALLOCATES;
1909 : :
1910 [ - + ]: 68 : return gjs_value_to_g_argument(
1911 : : context, value, &type_info, g_base_info_get_name(arg_info),
1912 : 34 : (g_arg_info_is_return_value(arg_info) ? GJS_ARGUMENT_RETURN_VALUE
1913 : : : GJS_ARGUMENT_ARGUMENT),
1914 : 34 : g_arg_info_get_ownership_transfer(arg_info), flags, arg);
1915 : : }
1916 : :
1917 : : template <typename T>
1918 : 61 : GJS_JSAPI_RETURN_CONVENTION static bool gjs_array_from_g_list(
1919 : : JSContext* cx, JS::MutableHandleValue value_p, GITypeInfo* type_info,
1920 : : GITransfer transfer, T* list) {
1921 : : static_assert(std::is_same_v<T, GList> || std::is_same_v<T, GSList>);
1922 : : GArgument arg;
1923 : 61 : JS::RootedValueVector elems(cx);
1924 : 61 : GjsAutoTypeInfo param_info = g_type_info_get_param_type(type_info, 0);
1925 : :
1926 : 61 : g_assert(param_info);
1927 : :
1928 [ + + ]: 172 : for (size_t i = 0; list; list = list->next, ++i) {
1929 : 111 : g_type_info_argument_from_hash_pointer(param_info, list->data, &arg);
1930 : :
1931 [ - + ]: 111 : if (!elems.growBy(1)) {
1932 : 0 : JS_ReportOutOfMemory(cx);
1933 : 0 : return false;
1934 : : }
1935 : :
1936 [ - + ]: 111 : if (!gjs_value_from_g_argument(cx, elems[i], param_info,
1937 : : GJS_ARGUMENT_LIST_ELEMENT, transfer,
1938 : : &arg))
1939 : 0 : return false;
1940 : : }
1941 : :
1942 : 61 : JS::RootedObject obj(cx, JS::NewArrayObject(cx, elems));
1943 [ - + ]: 61 : if (!obj)
1944 : 0 : return false;
1945 : :
1946 : 61 : value_p.setObject(*obj);
1947 : :
1948 : 61 : return true;
1949 : 61 : }
1950 : :
1951 : : template <typename T>
1952 : 60 : GJS_JSAPI_RETURN_CONVENTION static bool gjs_g_arg_release_g_list(
1953 : : JSContext* cx, GITransfer transfer, GITypeInfo* type_info,
1954 : : GjsArgumentFlags flags, GIArgument* arg) {
1955 : : static_assert(std::is_same_v<T, GList> || std::is_same_v<T, GSList>);
1956 : 60 : GjsSmartPointer<T> list = gjs_arg_steal<T*>(arg);
1957 : :
1958 [ + + ]: 60 : if (transfer == GI_TRANSFER_CONTAINER)
1959 : 6 : return true;
1960 : :
1961 : : GIArgument elem;
1962 : 54 : GjsAutoTypeInfo param_info = g_type_info_get_param_type(type_info, 0);
1963 : 54 : g_assert(param_info);
1964 : 54 : GITypeTag type_tag = g_type_info_get_tag(param_info);
1965 : :
1966 [ + + ]: 139 : for (T* l = list; l; l = l->next) {
1967 : 85 : gjs_arg_set(&elem, l->data);
1968 : :
1969 [ - + ]: 85 : if (!gjs_g_arg_release_internal(cx, transfer, param_info, type_tag,
1970 : : GJS_ARGUMENT_LIST_ELEMENT, flags,
1971 : : &elem)) {
1972 : 0 : return false;
1973 : : }
1974 : : }
1975 : :
1976 : 54 : return true;
1977 : 60 : }
1978 : :
1979 : : template <typename T, GITypeTag TAG = GI_TYPE_TAG_VOID>
1980 : 59 : GJS_JSAPI_RETURN_CONVENTION static bool fill_vector_from_carray(
1981 : : JSContext* cx, JS::RootedValueVector& elems, // NOLINT(runtime/references)
1982 : : GITypeInfo* param_info, GIArgument* arg, void* array, size_t length,
1983 : : GITransfer transfer = GI_TRANSFER_EVERYTHING) {
1984 [ + + ]: 327 : for (size_t i = 0; i < length; i++) {
1985 : 268 : gjs_arg_set<T, TAG>(arg, *(static_cast<T*>(array) + i));
1986 : :
1987 [ - + ]: 268 : if (!gjs_value_from_g_argument(cx, elems[i], param_info,
1988 : : GJS_ARGUMENT_ARRAY_ELEMENT,
1989 : : transfer, arg))
1990 : 0 : return false;
1991 : : }
1992 : :
1993 : 59 : return true;
1994 : : }
1995 : :
1996 : : GJS_JSAPI_RETURN_CONVENTION
1997 : 82 : static bool gjs_array_from_carray_internal(
1998 : : JSContext* context, JS::MutableHandleValue value_p, GIArrayType array_type,
1999 : : GITypeInfo* param_info, GITransfer transfer, guint length, void* array) {
2000 : : GArgument arg;
2001 : : GITypeTag element_type;
2002 : : guint i;
2003 : :
2004 : 82 : element_type = g_type_info_get_tag(param_info);
2005 : :
2006 : : /* Special case array(guint8) */
2007 [ + + ]: 82 : if (element_type == GI_TYPE_TAG_UINT8) {
2008 : 4 : JSObject* obj = gjs_byte_array_from_data(context, length, array);
2009 [ - + ]: 4 : if (!obj)
2010 : 0 : return false;
2011 : 4 : value_p.setObject(*obj);
2012 : 4 : return true;
2013 : : }
2014 : :
2015 : : /* Special case array(unichar) to be a string in JS */
2016 [ + + ]: 78 : if (element_type == GI_TYPE_TAG_UNICHAR)
2017 : 1 : return gjs_string_from_ucs4(context, (gunichar *) array, length, value_p);
2018 : :
2019 : : // a null array pointer takes precedence over whatever `length` says
2020 [ + + ]: 77 : if (!array) {
2021 : 10 : JSObject* jsarray = JS::NewArrayObject(context, 0);
2022 [ - + ]: 10 : if (!jsarray)
2023 : 0 : return false;
2024 : 10 : value_p.setObject(*jsarray);
2025 : 10 : return true;
2026 : : }
2027 : :
2028 : 67 : JS::RootedValueVector elems(context);
2029 [ - + ]: 67 : if (!elems.resize(length)) {
2030 : 0 : JS_ReportOutOfMemory(context);
2031 : 0 : return false;
2032 : : }
2033 : :
2034 [ - + + - : 67 : switch (element_type) {
+ + + + -
- - + +
- ]
2035 : : /* Special cases handled above */
2036 : 0 : case GI_TYPE_TAG_UINT8:
2037 : : case GI_TYPE_TAG_UNICHAR:
2038 : : g_assert_not_reached();
2039 : 1 : case GI_TYPE_TAG_BOOLEAN:
2040 [ - + ]: 1 : if (!fill_vector_from_carray<gboolean, GI_TYPE_TAG_BOOLEAN>(
2041 : : context, elems, param_info, &arg, array, length))
2042 : 0 : return false;
2043 : 1 : break;
2044 : 2 : case GI_TYPE_TAG_INT8:
2045 [ - + ]: 2 : if (!fill_vector_from_carray<int8_t>(context, elems, param_info,
2046 : : &arg, array, length))
2047 : 0 : return false;
2048 : 2 : break;
2049 : 0 : case GI_TYPE_TAG_UINT16:
2050 [ # # ]: 0 : if (!fill_vector_from_carray<uint16_t>(context, elems, param_info,
2051 : : &arg, array, length))
2052 : 0 : return false;
2053 : 0 : break;
2054 : 1 : case GI_TYPE_TAG_INT16:
2055 [ - + ]: 1 : if (!fill_vector_from_carray<int16_t>(context, elems, param_info,
2056 : : &arg, array, length))
2057 : 0 : return false;
2058 : 1 : break;
2059 : 1 : case GI_TYPE_TAG_UINT32:
2060 [ - + ]: 1 : if (!fill_vector_from_carray<uint32_t>(context, elems, param_info,
2061 : : &arg, array, length))
2062 : 0 : return false;
2063 : 1 : break;
2064 : 23 : case GI_TYPE_TAG_INT32:
2065 [ - + ]: 23 : if (!fill_vector_from_carray<int32_t>(context, elems, param_info,
2066 : : &arg, array, length))
2067 : 0 : return false;
2068 : 23 : break;
2069 : 1 : case GI_TYPE_TAG_UINT64:
2070 [ - + ]: 1 : if (!fill_vector_from_carray<uint64_t>(context, elems, param_info,
2071 : : &arg, array, length))
2072 : 0 : return false;
2073 : 1 : break;
2074 : 0 : case GI_TYPE_TAG_INT64:
2075 [ # # ]: 0 : if (!fill_vector_from_carray<int64_t>(context, elems, param_info,
2076 : : &arg, array, length))
2077 : 0 : return false;
2078 : 0 : break;
2079 : 0 : case GI_TYPE_TAG_FLOAT:
2080 [ # # ]: 0 : if (!fill_vector_from_carray<float>(context, elems, param_info,
2081 : : &arg, array, length))
2082 : 0 : return false;
2083 : 0 : break;
2084 : 0 : case GI_TYPE_TAG_DOUBLE:
2085 [ # # ]: 0 : if (!fill_vector_from_carray<double>(context, elems, param_info,
2086 : : &arg, array, length))
2087 : 0 : return false;
2088 : 0 : break;
2089 : 13 : case GI_TYPE_TAG_INTERFACE: {
2090 : : GjsAutoBaseInfo interface_info =
2091 : 13 : g_type_info_get_interface(param_info);
2092 : 13 : GIInfoType info_type = g_base_info_get_type (interface_info);
2093 : :
2094 [ + + ]: 11 : if (array_type != GI_ARRAY_TYPE_PTR_ARRAY &&
2095 [ + - ]: 1 : (info_type == GI_INFO_TYPE_STRUCT ||
2096 [ - + ]: 1 : info_type == GI_INFO_TYPE_UNION ||
2097 [ + + + + : 24 : info_type == GI_INFO_TYPE_VALUE) &&
+ + ]
2098 : 10 : !g_type_info_is_pointer(param_info)) {
2099 : : size_t struct_size;
2100 : :
2101 [ - + ]: 8 : if (info_type == GI_INFO_TYPE_UNION)
2102 : 0 : struct_size = g_union_info_get_size(interface_info);
2103 : : else
2104 : 8 : struct_size = g_struct_info_get_size(interface_info);
2105 : :
2106 [ + + ]: 35 : for (i = 0; i < length; i++) {
2107 : 27 : gjs_arg_set(&arg,
2108 : 27 : static_cast<char*>(array) + (struct_size * i));
2109 : :
2110 [ - + ]: 27 : if (!gjs_value_from_g_argument(
2111 : : context, elems[i], param_info,
2112 : : GJS_ARGUMENT_ARRAY_ELEMENT, transfer, &arg))
2113 : 0 : return false;
2114 : : }
2115 : :
2116 : 8 : break;
2117 : : }
2118 [ + - + ]: 13 : }
2119 : : /* fallthrough */
2120 : : case GI_TYPE_TAG_GTYPE:
2121 : : case GI_TYPE_TAG_UTF8:
2122 : : case GI_TYPE_TAG_FILENAME:
2123 : : case GI_TYPE_TAG_ARRAY:
2124 : : case GI_TYPE_TAG_GLIST:
2125 : : case GI_TYPE_TAG_GSLIST:
2126 : : case GI_TYPE_TAG_GHASH:
2127 : : case GI_TYPE_TAG_ERROR:
2128 [ - + ]: 30 : if (!fill_vector_from_carray<void*>(context, elems, param_info,
2129 : : &arg, array, length, transfer))
2130 : 0 : return false;
2131 : 30 : break;
2132 : 0 : case GI_TYPE_TAG_VOID:
2133 : : default:
2134 : 0 : gjs_throw(context, "Unknown Array element-type %d", element_type);
2135 : 0 : return false;
2136 : : }
2137 : :
2138 : 134 : JS::RootedObject obj(context, JS::NewArrayObject(context, elems));
2139 [ - + ]: 67 : if (!obj)
2140 : 0 : return false;
2141 : :
2142 : 67 : value_p.setObject(*obj);
2143 : :
2144 : 67 : return true;
2145 : 67 : }
2146 : :
2147 : : GJS_JSAPI_RETURN_CONVENTION
2148 : 15 : static bool gjs_array_from_fixed_size_array(JSContext* context,
2149 : : JS::MutableHandleValue value_p,
2150 : : GITypeInfo* type_info,
2151 : : GITransfer transfer, void* array) {
2152 : : gint length;
2153 : :
2154 : 15 : length = g_type_info_get_array_fixed_size(type_info);
2155 : :
2156 : 15 : g_assert (length != -1);
2157 : :
2158 : 15 : GjsAutoTypeInfo param_info = g_type_info_get_param_type(type_info, 0);
2159 : :
2160 : 15 : return gjs_array_from_carray_internal(context, value_p,
2161 : : g_type_info_get_array_type(type_info),
2162 : 15 : param_info, transfer, length, array);
2163 : 15 : }
2164 : :
2165 : 45 : bool gjs_value_from_explicit_array(JSContext* context,
2166 : : JS::MutableHandleValue value_p,
2167 : : GITypeInfo* type_info, GITransfer transfer,
2168 : : GIArgument* arg, int length) {
2169 : 45 : GjsAutoTypeInfo param_info = g_type_info_get_param_type(type_info, 0);
2170 : :
2171 : 45 : return gjs_array_from_carray_internal(
2172 : : context, value_p, g_type_info_get_array_type(type_info), param_info,
2173 : 45 : transfer, length, gjs_arg_get<void*>(arg));
2174 : 45 : }
2175 : :
2176 : : GJS_JSAPI_RETURN_CONVENTION
2177 : 20 : static bool gjs_array_from_boxed_array(JSContext* context,
2178 : : JS::MutableHandleValue value_p,
2179 : : GIArrayType array_type,
2180 : : GITypeInfo* param_info,
2181 : : GITransfer transfer, GArgument* arg) {
2182 : : GArray *array;
2183 : : GPtrArray *ptr_array;
2184 : 20 : gpointer data = NULL;
2185 : 20 : gsize length = 0;
2186 : :
2187 [ - + ]: 20 : if (!gjs_arg_get<void*>(arg)) {
2188 : 0 : value_p.setNull();
2189 : 0 : return true;
2190 : : }
2191 : :
2192 [ + + - ]: 20 : switch(array_type) {
2193 : 10 : case GI_ARRAY_TYPE_BYTE_ARRAY:
2194 : : /* GByteArray is just a typedef for GArray internally */
2195 : : case GI_ARRAY_TYPE_ARRAY:
2196 : 10 : array = gjs_arg_get<GArray*>(arg);
2197 : 10 : data = array->data;
2198 : 10 : length = array->len;
2199 : 10 : break;
2200 : 10 : case GI_ARRAY_TYPE_PTR_ARRAY:
2201 : 10 : ptr_array = gjs_arg_get<GPtrArray*>(arg);
2202 : 10 : data = ptr_array->pdata;
2203 : 10 : length = ptr_array->len;
2204 : 10 : break;
2205 : 0 : case GI_ARRAY_TYPE_C: /* already checked in gjs_value_from_g_argument() */
2206 : : default:
2207 : : g_assert_not_reached();
2208 : : }
2209 : :
2210 : 20 : return gjs_array_from_carray_internal(context, value_p, array_type,
2211 : 20 : param_info, transfer, length, data);
2212 : : }
2213 : :
2214 : : GJS_JSAPI_RETURN_CONVENTION
2215 : 2 : bool gjs_array_from_g_value_array(JSContext* cx, JS::MutableHandleValue value_p,
2216 : : GITypeInfo* param_info, GITransfer transfer,
2217 : : const GValue* gvalue) {
2218 : 2 : void* data = nullptr;
2219 : 2 : size_t length = 0;
2220 : : GIArrayType array_type;
2221 : 2 : GType value_gtype = G_VALUE_TYPE(gvalue);
2222 : :
2223 : : // GByteArray is just a typedef for GArray internally
2224 [ + - + - : 4 : if (g_type_is_a(value_gtype, G_TYPE_BYTE_ARRAY) ||
- + ]
2225 [ + - - + ]: 2 : g_type_is_a(value_gtype, G_TYPE_ARRAY)) {
2226 [ # # ]: 0 : array_type = g_type_is_a(value_gtype, G_TYPE_BYTE_ARRAY)
2227 [ # # ]: 0 : ? GI_ARRAY_TYPE_BYTE_ARRAY
2228 : : : GI_ARRAY_TYPE_ARRAY;
2229 : 0 : auto* array = reinterpret_cast<GArray*>(g_value_get_boxed(gvalue));
2230 : 0 : data = array->data;
2231 : 0 : length = array->len;
2232 [ - + - - : 2 : } else if (g_type_is_a(value_gtype, G_TYPE_PTR_ARRAY)) {
+ - ]
2233 : 2 : array_type = GI_ARRAY_TYPE_PTR_ARRAY;
2234 : : auto* ptr_array =
2235 : 2 : reinterpret_cast<GPtrArray*>(g_value_get_boxed(gvalue));
2236 : 2 : data = ptr_array->pdata;
2237 : 2 : length = ptr_array->len;
2238 : : } else {
2239 : : g_assert_not_reached();
2240 : : }
2241 : :
2242 : 2 : return gjs_array_from_carray_internal(cx, value_p, array_type, param_info,
2243 : 2 : transfer, length, data);
2244 : : }
2245 : :
2246 : : template <typename T>
2247 : 441 : GJS_JSAPI_RETURN_CONVENTION static bool fill_vector_from_zero_terminated_carray(
2248 : : JSContext* cx, JS::RootedValueVector& elems, // NOLINT(runtime/references)
2249 : : GITypeInfo* param_info, GIArgument* arg, void* c_array,
2250 : : GITransfer transfer = GI_TRANSFER_EVERYTHING) {
2251 : 441 : T* array = static_cast<T*>(c_array);
2252 : :
2253 : 1053 : for (size_t i = 0;; i++) {
2254 : : if constexpr (std::is_scalar_v<T>) {
2255 [ + + ]: 1053 : if (!array[i])
2256 : 441 : break;
2257 : :
2258 : 612 : gjs_arg_set(arg, array[i]);
2259 : : } else {
2260 : 0 : uint8_t* element_start = reinterpret_cast<uint8_t*>(&array[i]);
2261 [ # # ]: 0 : if (*element_start == 0 &&
2262 : : // cppcheck-suppress pointerSize
2263 [ # # ]: 0 : memcmp(element_start, element_start + 1, sizeof(T) - 1) == 0)
2264 : 0 : break;
2265 : :
2266 : 0 : gjs_arg_set(arg, element_start);
2267 : : }
2268 : :
2269 [ - + ]: 612 : if (!elems.growBy(1)) {
2270 : 0 : JS_ReportOutOfMemory(cx);
2271 : 0 : return false;
2272 : : }
2273 : :
2274 [ - + ]: 612 : if (!gjs_value_from_g_argument(cx, elems[i], param_info,
2275 : : GJS_ARGUMENT_ARRAY_ELEMENT, transfer,
2276 : : arg))
2277 : 0 : return false;
2278 : : }
2279 : :
2280 : 441 : return true;
2281 : : }
2282 : :
2283 : : GJS_JSAPI_RETURN_CONVENTION
2284 : 442 : static bool gjs_array_from_zero_terminated_c_array(
2285 : : JSContext* context, JS::MutableHandleValue value_p, GITypeInfo* param_info,
2286 : : GITransfer transfer, void* c_array) {
2287 : : GArgument arg;
2288 : : GITypeTag element_type;
2289 : :
2290 : 442 : element_type = g_type_info_get_tag(param_info);
2291 : :
2292 : : /* Special case array(guint8) */
2293 [ - + ]: 442 : if (element_type == GI_TYPE_TAG_UINT8) {
2294 : 0 : size_t len = strlen(static_cast<char*>(c_array));
2295 : 0 : JSObject* obj = gjs_byte_array_from_data(context, len, c_array);
2296 [ # # ]: 0 : if (!obj)
2297 : 0 : return false;
2298 : 0 : value_p.setObject(*obj);
2299 : 0 : return true;
2300 : : }
2301 : :
2302 : : /* Special case array(gunichar) to JS string */
2303 [ + + ]: 442 : if (element_type == GI_TYPE_TAG_UNICHAR)
2304 : 1 : return gjs_string_from_ucs4(context, (gunichar *) c_array, -1, value_p);
2305 : :
2306 : 441 : JS::RootedValueVector elems(context);
2307 : :
2308 [ - - - - : 441 : switch (element_type) {
- - - - +
- + + -
- ]
2309 : : /* Special cases handled above. */
2310 : 0 : case GI_TYPE_TAG_UINT8:
2311 : : case GI_TYPE_TAG_UNICHAR:
2312 : : g_assert_not_reached();
2313 : 0 : case GI_TYPE_TAG_INT8:
2314 [ # # ]: 0 : if (!fill_vector_from_zero_terminated_carray<int8_t>(
2315 : : context, elems, param_info, &arg, c_array))
2316 : 0 : return false;
2317 : 0 : break;
2318 : 0 : case GI_TYPE_TAG_UINT16:
2319 [ # # ]: 0 : if (!fill_vector_from_zero_terminated_carray<uint16_t>(
2320 : : context, elems, param_info, &arg, c_array))
2321 : 0 : return false;
2322 : 0 : break;
2323 : 0 : case GI_TYPE_TAG_INT16:
2324 [ # # ]: 0 : if (!fill_vector_from_zero_terminated_carray<int16_t>(
2325 : : context, elems, param_info, &arg, c_array))
2326 : 0 : return false;
2327 : 0 : break;
2328 : 0 : case GI_TYPE_TAG_UINT32:
2329 [ # # ]: 0 : if (!fill_vector_from_zero_terminated_carray<uint32_t>(
2330 : : context, elems, param_info, &arg, c_array))
2331 : 0 : return false;
2332 : 0 : break;
2333 : 0 : case GI_TYPE_TAG_INT32:
2334 [ # # ]: 0 : if (!fill_vector_from_zero_terminated_carray<int32_t>(
2335 : : context, elems, param_info, &arg, c_array))
2336 : 0 : return false;
2337 : 0 : break;
2338 : 0 : case GI_TYPE_TAG_UINT64:
2339 [ # # ]: 0 : if (!fill_vector_from_zero_terminated_carray<uint64_t>(
2340 : : context, elems, param_info, &arg, c_array))
2341 : 0 : return false;
2342 : 0 : break;
2343 : 0 : case GI_TYPE_TAG_INT64:
2344 [ # # ]: 0 : if (!fill_vector_from_zero_terminated_carray<int64_t>(
2345 : : context, elems, param_info, &arg, c_array))
2346 : 0 : return false;
2347 : 0 : break;
2348 : 1 : case GI_TYPE_TAG_FLOAT:
2349 [ - + ]: 1 : if (!fill_vector_from_zero_terminated_carray<float>(
2350 : : context, elems, param_info, &arg, c_array))
2351 : 0 : return false;
2352 : 1 : break;
2353 : 0 : case GI_TYPE_TAG_DOUBLE:
2354 [ # # ]: 0 : if (!fill_vector_from_zero_terminated_carray<double>(
2355 : : context, elems, param_info, &arg, c_array))
2356 : 0 : return false;
2357 : 0 : break;
2358 : 416 : case GI_TYPE_TAG_INTERFACE: {
2359 : : GjsAutoBaseInfo interface_info =
2360 : 416 : g_type_info_get_interface(param_info);
2361 : :
2362 [ - + - - : 416 : if (!g_type_info_is_pointer(param_info) &&
- + ]
2363 : 0 : is_gvalue(interface_info,
2364 : : g_base_info_get_type(interface_info))) {
2365 [ # # ]: 0 : if (!fill_vector_from_zero_terminated_carray<GValue>(
2366 : : context, elems, param_info, &arg, c_array))
2367 : 0 : return false;
2368 : 0 : break;
2369 : : }
2370 : :
2371 : : [[fallthrough]];
2372 [ + - - ]: 416 : }
2373 : : case GI_TYPE_TAG_GTYPE:
2374 : : case GI_TYPE_TAG_UTF8:
2375 : : case GI_TYPE_TAG_FILENAME:
2376 : : case GI_TYPE_TAG_ARRAY:
2377 : : case GI_TYPE_TAG_GLIST:
2378 : : case GI_TYPE_TAG_GSLIST:
2379 : : case GI_TYPE_TAG_GHASH:
2380 : : case GI_TYPE_TAG_ERROR:
2381 [ - + ]: 440 : if (!fill_vector_from_zero_terminated_carray<void*>(
2382 : : context, elems, param_info, &arg, c_array, transfer))
2383 : 0 : return false;
2384 : 440 : break;
2385 : : /* Boolean zero-terminated array makes no sense, because FALSE is also
2386 : : * zero */
2387 : 0 : case GI_TYPE_TAG_BOOLEAN:
2388 : 0 : gjs_throw(context, "Boolean zero-terminated array not supported");
2389 : 0 : return false;
2390 : 0 : case GI_TYPE_TAG_VOID:
2391 : : default:
2392 : 0 : gjs_throw(context, "Unknown element-type %d", element_type);
2393 : 0 : return false;
2394 : : }
2395 : :
2396 : 882 : JS::RootedObject obj(context, JS::NewArrayObject(context, elems));
2397 [ - + ]: 441 : if (!obj)
2398 : 0 : return false;
2399 : :
2400 : 441 : value_p.setObject(*obj);
2401 : :
2402 : 441 : return true;
2403 : 441 : }
2404 : :
2405 : 20 : bool gjs_object_from_g_hash(JSContext* context, JS::MutableHandleValue value_p,
2406 : : GITypeInfo* key_param_info,
2407 : : GITypeInfo* val_param_info, GITransfer transfer,
2408 : : GHashTable* hash) {
2409 : : GHashTableIter iter;
2410 : : GArgument keyarg, valarg;
2411 : :
2412 : : // a NULL hash table becomes a null JS value
2413 [ + + ]: 20 : if (hash==NULL) {
2414 : 2 : value_p.setNull();
2415 : 2 : return true;
2416 : : }
2417 : :
2418 : 18 : JS::RootedObject obj(context, JS_NewPlainObject(context));
2419 [ - + ]: 18 : if (!obj)
2420 : 0 : return false;
2421 : :
2422 : 18 : value_p.setObject(*obj);
2423 : :
2424 : 18 : JS::RootedValue keyjs(context), valjs(context);
2425 : 18 : JS::RootedString keystr(context);
2426 : :
2427 : 18 : g_hash_table_iter_init(&iter, hash);
2428 : : void* key_pointer;
2429 : : void* val_pointer;
2430 [ + + ]: 78 : while (g_hash_table_iter_next(&iter, &key_pointer, &val_pointer)) {
2431 : 60 : g_type_info_argument_from_hash_pointer(key_param_info, key_pointer,
2432 : : &keyarg);
2433 [ - + ]: 60 : if (!gjs_value_from_g_argument(context, &keyjs, key_param_info,
2434 : : GJS_ARGUMENT_HASH_ELEMENT,
2435 : : transfer, &keyarg))
2436 : 0 : return false;
2437 : :
2438 : 60 : keystr = JS::ToString(context, keyjs);
2439 [ - + ]: 60 : if (!keystr)
2440 : 0 : return false;
2441 : :
2442 : 60 : JS::UniqueChars keyutf8(JS_EncodeStringToUTF8(context, keystr));
2443 [ - + ]: 60 : if (!keyutf8)
2444 : 0 : return false;
2445 : :
2446 : 60 : g_type_info_argument_from_hash_pointer(val_param_info, val_pointer,
2447 : : &valarg);
2448 [ - + ]: 60 : if (!gjs_value_from_g_argument(context, &valjs, val_param_info,
2449 : : GJS_ARGUMENT_HASH_ELEMENT,
2450 : : transfer, &valarg))
2451 : 0 : return false;
2452 : :
2453 [ - + ]: 60 : if (!JS_DefineProperty(context, obj, keyutf8.get(), valjs,
2454 : : JSPROP_ENUMERATE))
2455 : 0 : return false;
2456 [ + - ]: 60 : }
2457 : :
2458 : 18 : return true;
2459 : 18 : }
2460 : :
2461 : 40805 : bool gjs_value_from_g_argument(JSContext* context,
2462 : : JS::MutableHandleValue value_p,
2463 : : GITypeInfo* type_info,
2464 : : GjsArgumentType argument_type,
2465 : : GITransfer transfer, GArgument* arg) {
2466 : : GITypeTag type_tag;
2467 : :
2468 : 40805 : type_tag = g_type_info_get_tag( (GITypeInfo*) type_info);
2469 : :
2470 : : gjs_debug_marshal(GJS_DEBUG_GFUNCTION,
2471 : : "Converting GArgument %s to JS::Value",
2472 : : g_type_tag_to_string(type_tag));
2473 : :
2474 : 40805 : value_p.setNull();
2475 : :
2476 [ + + + + : 40805 : switch (type_tag) {
+ + + + +
+ + + + +
+ + + + +
+ + - ]
2477 : 10 : case GI_TYPE_TAG_VOID:
2478 : : // If the argument is a pointer, convert to null to match our
2479 : : // in handling.
2480 [ + - ]: 10 : if (g_type_info_is_pointer(type_info))
2481 : 10 : value_p.setNull();
2482 : : else
2483 : 0 : value_p.setUndefined();
2484 : 10 : break;
2485 : :
2486 : 1018 : case GI_TYPE_TAG_BOOLEAN:
2487 : 1018 : value_p.setBoolean(gjs_arg_get<bool>(arg));
2488 : 1018 : break;
2489 : :
2490 : 2693 : case GI_TYPE_TAG_INT32:
2491 : 2693 : value_p.setInt32(gjs_arg_get<int32_t>(arg));
2492 : 2693 : break;
2493 : :
2494 : 11158 : case GI_TYPE_TAG_UINT32:
2495 : 11158 : value_p.setNumber(gjs_arg_get<uint32_t>(arg));
2496 : 11158 : break;
2497 : :
2498 : 122 : case GI_TYPE_TAG_INT64:
2499 : 122 : value_p.setNumber(gjs_arg_get_maybe_rounded<int64_t>(arg));
2500 : 122 : break;
2501 : :
2502 : 1026 : case GI_TYPE_TAG_UINT64:
2503 : 1026 : value_p.setNumber(gjs_arg_get_maybe_rounded<uint64_t>(arg));
2504 : 1026 : break;
2505 : :
2506 : 17 : case GI_TYPE_TAG_UINT16:
2507 : 17 : value_p.setInt32(gjs_arg_get<uint16_t>(arg));
2508 : 17 : break;
2509 : :
2510 : 32 : case GI_TYPE_TAG_INT16:
2511 : 32 : value_p.setInt32(gjs_arg_get<int16_t>(arg));
2512 : 32 : break;
2513 : :
2514 : 23 : case GI_TYPE_TAG_UINT8:
2515 : 23 : value_p.setInt32(gjs_arg_get<uint8_t>(arg));
2516 : 23 : break;
2517 : :
2518 : 125 : case GI_TYPE_TAG_INT8:
2519 : 125 : value_p.setInt32(gjs_arg_get<int8_t>(arg));
2520 : 125 : break;
2521 : :
2522 : 31 : case GI_TYPE_TAG_FLOAT:
2523 : 31 : value_p.setNumber(gjs_arg_get<float>(arg));
2524 : 31 : break;
2525 : :
2526 : 40 : case GI_TYPE_TAG_DOUBLE:
2527 : 40 : value_p.setNumber(gjs_arg_get<double>(arg));
2528 : 40 : break;
2529 : :
2530 : 1391 : case GI_TYPE_TAG_GTYPE:
2531 : : {
2532 : 1391 : GType gtype = gjs_arg_get<GType, GI_TYPE_TAG_GTYPE>(arg);
2533 [ + + ]: 1391 : if (gtype == 0)
2534 : 2 : return true; /* value_p is set to JS null */
2535 : :
2536 : 1389 : JS::RootedObject obj(context, gjs_gtype_create_gtype_wrapper(context, gtype));
2537 [ - + ]: 1389 : if (!obj)
2538 : 0 : return false;
2539 : :
2540 : 1389 : value_p.setObject(*obj);
2541 : 1389 : return true;
2542 : 1389 : }
2543 : : break;
2544 : :
2545 : 3 : case GI_TYPE_TAG_UNICHAR: {
2546 : 3 : char32_t value = gjs_arg_get<char32_t>(arg);
2547 : :
2548 : : // Preserve the bidirectional mapping between 0 and ""
2549 [ + + ]: 3 : if (value == 0) {
2550 : 1 : value_p.set(JS_GetEmptyStringValue(context));
2551 : 1 : return true;
2552 [ - + ]: 2 : } else if (!g_unichar_validate(value)) {
2553 : 0 : gjs_throw(context, "Invalid unicode codepoint %" G_GUINT32_FORMAT,
2554 : : value);
2555 : 0 : return false;
2556 : : }
2557 : :
2558 : : char utf8[7];
2559 : 2 : int bytes = g_unichar_to_utf8(value, utf8);
2560 : 2 : return gjs_string_from_utf8_n(context, utf8, bytes, value_p);
2561 : : }
2562 : :
2563 : 2468 : case GI_TYPE_TAG_FILENAME:
2564 : : case GI_TYPE_TAG_UTF8: {
2565 : 2468 : const char* str = gjs_arg_get<const char*>(arg);
2566 : : // For nullptr we'll return JS::NullValue(), which is already set
2567 : : // in *value_p
2568 [ + + ]: 2468 : if (!str)
2569 : 104 : return true;
2570 : :
2571 [ + + ]: 2364 : if (type_tag == GI_TYPE_TAG_FILENAME)
2572 : 6 : return gjs_string_from_filename(context, str, -1, value_p);
2573 : :
2574 : 2358 : return gjs_string_from_utf8(context, str, value_p);
2575 : : }
2576 : :
2577 : 11 : case GI_TYPE_TAG_ERROR: {
2578 : 11 : GError* ptr = gjs_arg_get<GError*>(arg);
2579 [ + + ]: 11 : if (!ptr)
2580 : 1 : return true;
2581 : :
2582 : 10 : JSObject* obj = ErrorInstance::object_for_c_ptr(context, ptr);
2583 [ - + ]: 10 : if (!obj)
2584 : 0 : return false;
2585 : :
2586 : 10 : value_p.setObject(*obj);
2587 : 10 : return true;
2588 : : }
2589 : :
2590 : 20075 : case GI_TYPE_TAG_INTERFACE:
2591 : : {
2592 : : GIInfoType interface_type;
2593 : : GType gtype;
2594 : :
2595 : : GjsAutoBaseInfo interface_info =
2596 : 20075 : g_type_info_get_interface(type_info);
2597 : 20075 : g_assert(interface_info);
2598 : :
2599 : 20075 : interface_type = g_base_info_get_type(interface_info);
2600 : :
2601 [ - + ]: 20075 : if (interface_type == GI_INFO_TYPE_UNRESOLVED) {
2602 : 0 : gjs_throw(context,
2603 : : "Unable to resolve arg type '%s'",
2604 : : g_base_info_get_name(interface_info));
2605 : 0 : return false;
2606 : : }
2607 : :
2608 : : /* Enum/Flags are aren't pointer types, unlike the other interface subtypes */
2609 [ + + ]: 20075 : if (interface_type == GI_INFO_TYPE_ENUM) {
2610 : 2002 : int64_t value_int64 = _gjs_enum_from_int(
2611 : : interface_info,
2612 : : gjs_arg_get<int, GI_TYPE_TAG_INTERFACE>(arg));
2613 : :
2614 [ - + ]: 2002 : if (!_gjs_enum_value_is_valid(context, interface_info,
2615 : : value_int64))
2616 : 0 : return false;
2617 : :
2618 : 2002 : value_p.setNumber(static_cast<double>(value_int64));
2619 : 2002 : return true;
2620 : : }
2621 : :
2622 [ + + ]: 18073 : if (interface_type == GI_INFO_TYPE_FLAGS) {
2623 : 304 : int64_t value_int64 = _gjs_enum_from_int(
2624 : : interface_info,
2625 : : gjs_arg_get<int, GI_TYPE_TAG_INTERFACE>(arg));
2626 : :
2627 : 304 : gtype = g_registered_type_info_get_g_type((GIRegisteredTypeInfo*)interface_info);
2628 : :
2629 [ + + ]: 304 : if (gtype != G_TYPE_NONE) {
2630 : : /* check make sure 32 bit flag */
2631 [ - + ]: 80 : if (static_cast<uint32_t>(value_int64) != value_int64) { /* Not a guint32 */
2632 : 0 : gjs_throw(context,
2633 : : "0x%" G_GINT64_MODIFIER "x is not a valid value for flags %s",
2634 : : value_int64, g_type_name(gtype));
2635 : 0 : return false;
2636 : : }
2637 : :
2638 : : /* Pass only valid values*/
2639 : 80 : GjsAutoTypeClass<GFlagsClass> gflags_class(gtype);
2640 : 80 : value_int64 &= gflags_class->mask;
2641 : 80 : }
2642 : :
2643 : 304 : value_p.setNumber(static_cast<double>(value_int64));
2644 : 304 : return true;
2645 : : }
2646 : :
2647 [ + + + + : 34238 : if (interface_type == GI_INFO_TYPE_STRUCT &&
+ + ]
2648 : 16469 : g_struct_info_is_foreign((GIStructInfo*)interface_info)) {
2649 : 5 : return gjs_struct_foreign_convert_from_g_argument(
2650 : 5 : context, value_p, interface_info, arg);
2651 : : }
2652 : :
2653 : : /* Everything else is a pointer type, NULL is the easy case */
2654 [ + + ]: 17764 : if (!gjs_arg_get<void*>(arg)) {
2655 : 161 : value_p.setNull();
2656 : 161 : return true;
2657 : : }
2658 : :
2659 [ + + - + : 34048 : if (interface_type == GI_INFO_TYPE_STRUCT &&
- + ]
2660 : 16445 : g_struct_info_is_gtype_struct((GIStructInfo*)interface_info)) {
2661 : : /* XXX: here we make the implicit assumption that GTypeClass is the same
2662 : : as GTypeInterface. This is true for the GType field, which is what we
2663 : : use, but not for the rest of the structure!
2664 : : */
2665 : 0 : gtype = G_TYPE_FROM_CLASS(gjs_arg_get<GTypeClass*>(arg));
2666 : :
2667 [ # # # # : 0 : if (g_type_is_a(gtype, G_TYPE_INTERFACE)) {
# # ]
2668 : 0 : return gjs_lookup_interface_constructor(context, gtype,
2669 : 0 : value_p);
2670 : : }
2671 : 0 : return gjs_lookup_object_constructor(context, gtype, value_p);
2672 : : }
2673 : :
2674 : 17603 : gtype = g_registered_type_info_get_g_type((GIRegisteredTypeInfo*)interface_info);
2675 [ + + + + : 34244 : if (G_TYPE_IS_INSTANTIATABLE(gtype) ||
+ + ]
2676 : 16641 : G_TYPE_IS_INTERFACE(gtype))
2677 : 1156 : gtype = G_TYPE_FROM_INSTANCE(gjs_arg_get<GTypeInstance*>(arg));
2678 : :
2679 : : gjs_debug_marshal(GJS_DEBUG_GFUNCTION,
2680 : : "gtype of INTERFACE is %s", g_type_name(gtype));
2681 : :
2682 : :
2683 : : /* Test GValue and GError before Struct, or it will be handled as the latter */
2684 [ + + - + : 17603 : if (g_type_is_a(gtype, G_TYPE_VALUE)) {
+ + ]
2685 : 230 : return gjs_value_from_g_value(context, value_p,
2686 : 230 : gjs_arg_get<const GValue*>(arg));
2687 : : }
2688 : :
2689 [ + - - + : 17373 : if (g_type_is_a(gtype, G_TYPE_ERROR)) {
- + ]
2690 : 0 : JSObject* obj = ErrorInstance::object_for_c_ptr(
2691 : : context, gjs_arg_get<GError*>(arg));
2692 [ # # ]: 0 : if (!obj)
2693 : 0 : return false;
2694 : 0 : value_p.setObject(*obj);
2695 : 0 : return true;
2696 : : }
2697 : :
2698 [ + + - + ]: 17373 : if (interface_type == GI_INFO_TYPE_STRUCT || interface_type == GI_INFO_TYPE_BOXED) {
2699 [ + + ]: 16215 : if (arg::is_gdk_atom(interface_info)) {
2700 : : GjsAutoFunctionInfo atom_name_fun =
2701 : 1 : g_struct_info_find_method(interface_info, "name");
2702 : : GIArgument atom_name_ret;
2703 : :
2704 : 1 : g_function_info_invoke(atom_name_fun,
2705 : : arg, 1,
2706 : : nullptr, 0,
2707 : : &atom_name_ret,
2708 : : nullptr);
2709 : :
2710 : 1 : GjsAutoChar name = gjs_arg_get<char*>(&atom_name_ret);
2711 [ - + ]: 1 : if (g_strcmp0("NONE", name) == 0) {
2712 : 0 : value_p.setNull();
2713 : 0 : return true;
2714 : : }
2715 : :
2716 : 1 : return gjs_string_from_utf8(context, name, value_p);
2717 : 1 : }
2718 : :
2719 : : JSObject *obj;
2720 : :
2721 [ + + ]: 16214 : if (gtype == G_TYPE_VARIANT) {
2722 : 3125 : transfer = GI_TRANSFER_EVERYTHING;
2723 [ + + ]: 13089 : } else if (transfer == GI_TRANSFER_CONTAINER) {
2724 [ + - ]: 5 : switch (argument_type) {
2725 : 5 : case GJS_ARGUMENT_ARRAY_ELEMENT:
2726 : : case GJS_ARGUMENT_LIST_ELEMENT:
2727 : : case GJS_ARGUMENT_HASH_ELEMENT:
2728 : 5 : transfer = GI_TRANSFER_EVERYTHING;
2729 : 5 : default:
2730 : 5 : break;
2731 : : }
2732 : : }
2733 : :
2734 [ + + ]: 16214 : if (transfer == GI_TRANSFER_EVERYTHING)
2735 : 16207 : obj = BoxedInstance::new_for_c_struct(
2736 : : context, interface_info, gjs_arg_get<void*>(arg));
2737 : : else
2738 : 7 : obj = BoxedInstance::new_for_c_struct(
2739 : : context, interface_info, gjs_arg_get<void*>(arg),
2740 : : BoxedInstance::NoCopy());
2741 : :
2742 [ - + ]: 16214 : if (!obj)
2743 : 0 : return false;
2744 : :
2745 : 16214 : value_p.setObject(*obj);
2746 : 16214 : return true;
2747 : : }
2748 : :
2749 [ + + ]: 1158 : if (interface_type == GI_INFO_TYPE_UNION) {
2750 : 2 : JSObject* obj = UnionInstance::new_for_c_union(
2751 : : context, static_cast<GIUnionInfo*>(interface_info),
2752 : : gjs_arg_get<void*>(arg));
2753 [ - + ]: 2 : if (!obj)
2754 : 0 : return false;
2755 : :
2756 : 2 : value_p.setObject(*obj);
2757 : 2 : return true;
2758 : : }
2759 : :
2760 [ + - + + : 1156 : if (g_type_is_a(gtype, G_TYPE_OBJECT)) {
+ + ]
2761 : 1066 : g_assert(gjs_arg_get<void*>(arg) &&
2762 : : "Null arg is already handled above");
2763 : 1066 : return ObjectInstance::set_value_from_gobject(
2764 : 1066 : context, gjs_arg_get<GObject*>(arg), value_p);
2765 : : }
2766 : :
2767 [ + - + - ]: 90 : if (g_type_is_a(gtype, G_TYPE_BOXED) ||
2768 [ + - + - : 270 : g_type_is_a(gtype, G_TYPE_ENUM) ||
+ - - + ]
2769 [ - + ]: 90 : g_type_is_a(gtype, G_TYPE_FLAGS)) {
2770 : : /* Should have been handled above */
2771 : 0 : gjs_throw(context,
2772 : : "Type %s registered for unexpected interface_type %d",
2773 : : g_type_name(gtype),
2774 : : interface_type);
2775 : 0 : return false;
2776 : : }
2777 : :
2778 [ + - + + : 90 : if (g_type_is_a(gtype, G_TYPE_PARAM)) {
+ + ]
2779 : 89 : JSObject* obj = gjs_param_from_g_param(
2780 : 89 : context, G_PARAM_SPEC(gjs_arg_get<GParamSpec*>(arg)));
2781 [ - + ]: 89 : if (!obj)
2782 : 0 : return false;
2783 : 89 : value_p.setObject(*obj);
2784 : 89 : return true;
2785 : : }
2786 : :
2787 [ - + ]: 1 : if (gtype == G_TYPE_NONE) {
2788 : 0 : gjs_throw(context, "Unexpected unregistered type packing GArgument into JS::Value");
2789 : 0 : return false;
2790 : : }
2791 : :
2792 [ - + - - : 1 : if (G_TYPE_IS_INSTANTIATABLE(gtype) || G_TYPE_IS_INTERFACE(gtype)) {
+ - ]
2793 : 1 : JSObject* obj = FundamentalInstance::object_for_c_ptr(
2794 : : context, gjs_arg_get<void*>(arg));
2795 [ - + ]: 1 : if (!obj)
2796 : 0 : return false;
2797 : 1 : value_p.setObject(*obj);
2798 : 1 : return true;
2799 : : }
2800 : :
2801 : 0 : gjs_throw(context,
2802 : : "Unhandled GType %s packing GArgument into JS::Value",
2803 : : g_type_name(gtype));
2804 : 0 : return false;
2805 : 20075 : }
2806 : :
2807 : 481 : case GI_TYPE_TAG_ARRAY:
2808 [ + + ]: 481 : if (!gjs_arg_get<void*>(arg)) {
2809 : : /* OK, but no conversion to do */
2810 [ + + ]: 479 : } else if (g_type_info_get_array_type(type_info) == GI_ARRAY_TYPE_C) {
2811 [ + + ]: 457 : if (g_type_info_is_zero_terminated(type_info)) {
2812 : : GjsAutoBaseInfo param_info =
2813 : 442 : g_type_info_get_param_type(type_info, 0);
2814 : 442 : g_assert(param_info != nullptr);
2815 : :
2816 : 442 : return gjs_array_from_zero_terminated_c_array(
2817 : : context, value_p, param_info, transfer,
2818 : 442 : gjs_arg_get<void*>(arg));
2819 : 442 : } else {
2820 : : /* arrays with length are handled outside of this function */
2821 : 15 : g_assert(((void) "Use gjs_value_from_explicit_array() for "
2822 : : "arrays with length param",
2823 : : g_type_info_get_array_length(type_info) == -1));
2824 : 15 : return gjs_array_from_fixed_size_array(context, value_p,
2825 : : type_info, transfer,
2826 : 15 : gjs_arg_get<void*>(arg));
2827 : : }
2828 [ + + ]: 22 : } else if (g_type_info_get_array_type(type_info) ==
2829 : : GI_ARRAY_TYPE_BYTE_ARRAY) {
2830 : 2 : auto* byte_array = gjs_arg_get<GByteArray*>(arg);
2831 : : JSObject* array =
2832 : 2 : gjs_byte_array_from_byte_array(context, byte_array);
2833 [ - + ]: 2 : if (!array) {
2834 : 0 : gjs_throw(context,
2835 : : "Couldn't convert GByteArray to a Uint8Array");
2836 : 0 : return false;
2837 : : }
2838 : 2 : value_p.setObject(*array);
2839 : : } else {
2840 : : // this assumes the array type is GArray or GPtrArray
2841 : : GjsAutoTypeInfo param_info =
2842 : 20 : g_type_info_get_param_type(type_info, 0);
2843 : 20 : g_assert(param_info != nullptr);
2844 : :
2845 : 20 : return gjs_array_from_boxed_array(
2846 : : context, value_p, g_type_info_get_array_type(type_info),
2847 : 20 : param_info, transfer, arg);
2848 : 20 : }
2849 : 4 : break;
2850 : :
2851 : 45 : case GI_TYPE_TAG_GLIST:
2852 : 45 : return gjs_array_from_g_list(context, value_p, type_info, transfer,
2853 : 45 : gjs_arg_get<GList*>(arg));
2854 : 16 : case GI_TYPE_TAG_GSLIST:
2855 : 16 : return gjs_array_from_g_list(context, value_p, type_info, transfer,
2856 : 16 : gjs_arg_get<GSList*>(arg));
2857 : :
2858 : 20 : case GI_TYPE_TAG_GHASH:
2859 : : {
2860 : : GjsAutoTypeInfo key_param_info =
2861 : 20 : g_type_info_get_param_type(type_info, 0);
2862 : : GjsAutoTypeInfo val_param_info =
2863 : 20 : g_type_info_get_param_type(type_info, 1);
2864 : 20 : g_assert(key_param_info != nullptr);
2865 : 20 : g_assert(val_param_info != nullptr);
2866 : :
2867 : 20 : return gjs_object_from_g_hash(context, value_p, key_param_info,
2868 : : val_param_info, transfer,
2869 : 20 : gjs_arg_get<GHashTable*>(arg));
2870 : 20 : }
2871 : : break;
2872 : :
2873 : 0 : default:
2874 : 0 : g_warning("Unhandled type %s converting GArgument to JavaScript",
2875 : : g_type_tag_to_string(type_tag));
2876 : 0 : return false;
2877 : : }
2878 : :
2879 : 16299 : return true;
2880 : : }
2881 : :
2882 : : struct GHR_closure {
2883 : : JSContext *context;
2884 : : GjsAutoTypeInfo key_param_info, val_param_info;
2885 : : GITransfer transfer;
2886 : : GjsArgumentFlags flags;
2887 : : bool failed;
2888 : : };
2889 : :
2890 : : static gboolean
2891 : 60 : gjs_ghr_helper(gpointer key, gpointer val, gpointer user_data) {
2892 : 60 : GHR_closure *c = (GHR_closure *) user_data;
2893 : : GArgument key_arg, val_arg;
2894 : 60 : gjs_arg_set(&key_arg, key);
2895 : 60 : gjs_arg_set(&val_arg, val);
2896 [ - + ]: 60 : if (!gjs_g_arg_release_internal(c->context, c->transfer, c->key_param_info,
2897 : : g_type_info_get_tag(c->key_param_info),
2898 : : GJS_ARGUMENT_HASH_ELEMENT, c->flags,
2899 : : &key_arg))
2900 : 0 : c->failed = true;
2901 : :
2902 : 60 : GITypeTag val_type = g_type_info_get_tag(c->val_param_info);
2903 : :
2904 [ + + ]: 60 : switch (val_type) {
2905 : 16 : case GI_TYPE_TAG_DOUBLE:
2906 : : case GI_TYPE_TAG_FLOAT:
2907 : : case GI_TYPE_TAG_INT64:
2908 : : case GI_TYPE_TAG_UINT64:
2909 [ + - ]: 16 : g_clear_pointer(&gjs_arg_member<void*>(&val_arg), g_free);
2910 : 16 : break;
2911 : :
2912 : 44 : default:
2913 [ - + ]: 44 : if (!gjs_g_arg_release_internal(
2914 : : c->context, c->transfer, c->val_param_info, val_type,
2915 : : GJS_ARGUMENT_HASH_ELEMENT, c->flags, &val_arg))
2916 : 0 : c->failed = true;
2917 : : }
2918 : :
2919 : 60 : return true;
2920 : : }
2921 : :
2922 : : /* We need to handle GI_TRANSFER_NOTHING differently for out parameters
2923 : : * (free nothing) and for in parameters (free any temporaries we've
2924 : : * allocated
2925 : : */
2926 : 33977 : constexpr static bool is_transfer_in_nothing(GITransfer transfer,
2927 : : GjsArgumentFlags flags) {
2928 [ + + + + ]: 33977 : return (transfer == GI_TRANSFER_NOTHING) && (flags & GjsArgumentFlags::ARG_IN);
2929 : : }
2930 : :
2931 : : GJS_JSAPI_RETURN_CONVENTION
2932 : 15792 : static bool gjs_g_arg_release_internal(
2933 : : JSContext* context, GITransfer transfer, GITypeInfo* type_info,
2934 : : GITypeTag type_tag, [[maybe_unused]] GjsArgumentType argument_type,
2935 : : GjsArgumentFlags flags, GIArgument* arg) {
2936 : 15792 : g_assert(transfer != GI_TRANSFER_NOTHING ||
2937 : : flags != GjsArgumentFlags::NONE);
2938 : :
2939 [ + + + + : 15792 : switch (type_tag) {
+ + + +
- ]
2940 : 564 : case GI_TYPE_TAG_VOID:
2941 : : case GI_TYPE_TAG_BOOLEAN:
2942 : : case GI_TYPE_TAG_INT8:
2943 : : case GI_TYPE_TAG_UINT8:
2944 : : case GI_TYPE_TAG_INT16:
2945 : : case GI_TYPE_TAG_UINT16:
2946 : : case GI_TYPE_TAG_INT32:
2947 : : case GI_TYPE_TAG_UINT32:
2948 : : case GI_TYPE_TAG_INT64:
2949 : : case GI_TYPE_TAG_UINT64:
2950 : : case GI_TYPE_TAG_FLOAT:
2951 : : case GI_TYPE_TAG_DOUBLE:
2952 : : case GI_TYPE_TAG_UNICHAR:
2953 : : case GI_TYPE_TAG_GTYPE:
2954 : 564 : break;
2955 : :
2956 : 251 : case GI_TYPE_TAG_FILENAME:
2957 : : case GI_TYPE_TAG_UTF8:
2958 [ + + ]: 251 : g_clear_pointer(&gjs_arg_member<char*>(arg), g_free);
2959 : 251 : break;
2960 : :
2961 : 10 : case GI_TYPE_TAG_ERROR:
2962 [ + + ]: 10 : if (!is_transfer_in_nothing(transfer, flags))
2963 : 8 : g_clear_error(&gjs_arg_member<GError*>(arg));
2964 : 10 : break;
2965 : :
2966 : 14831 : case GI_TYPE_TAG_INTERFACE:
2967 : : {
2968 : : GIInfoType interface_type;
2969 : : GType gtype;
2970 : :
2971 : : GjsAutoBaseInfo interface_info =
2972 : 14831 : g_type_info_get_interface(type_info);
2973 : 14831 : g_assert(interface_info);
2974 : :
2975 : 14831 : interface_type = g_base_info_get_type(interface_info);
2976 : :
2977 [ + + + + : 29161 : if (interface_type == GI_INFO_TYPE_STRUCT &&
+ + ]
2978 : 14330 : g_struct_info_is_foreign((GIStructInfo*)interface_info))
2979 : 4 : return gjs_struct_foreign_release_g_argument(context,
2980 : 4 : transfer, interface_info, arg);
2981 : :
2982 [ + + + + ]: 14827 : if (interface_type == GI_INFO_TYPE_ENUM || interface_type == GI_INFO_TYPE_FLAGS)
2983 : 13 : return true;
2984 : :
2985 : : /* Anything else is a pointer */
2986 [ + + ]: 14814 : if (!gjs_arg_get<void*>(arg))
2987 : 73 : return true;
2988 : :
2989 : 14741 : gtype = g_registered_type_info_get_g_type((GIRegisteredTypeInfo*)interface_info);
2990 [ + + + + : 29124 : if (G_TYPE_IS_INSTANTIATABLE(gtype) ||
+ + ]
2991 : 14383 : G_TYPE_IS_INTERFACE(gtype))
2992 : 433 : gtype = G_TYPE_FROM_INSTANCE(gjs_arg_get<GTypeInstance*>(arg));
2993 : :
2994 : : gjs_debug_marshal(GJS_DEBUG_GFUNCTION,
2995 : : "gtype of INTERFACE is %s", g_type_name(gtype));
2996 : :
2997 : : /* In gjs_value_from_g_argument we handle Struct/Union types without a
2998 : : * registered GType, but here we are specifically handling a GArgument that
2999 : : * *owns* its value, and that is non-sensical for such types, so we
3000 : : * don't have to worry about it.
3001 : : */
3002 : :
3003 [ + - + + : 14741 : if (g_type_is_a(gtype, G_TYPE_OBJECT)) {
+ + ]
3004 [ + - ]: 336 : if (!is_transfer_in_nothing(transfer, flags))
3005 [ + - ]: 336 : g_clear_object(&gjs_arg_member<GObject*>(arg));
3006 [ + - + + : 14405 : } else if (g_type_is_a(gtype, G_TYPE_PARAM)) {
+ + ]
3007 [ + - ]: 81 : if (!is_transfer_in_nothing(transfer, flags))
3008 [ + - ]: 81 : g_clear_pointer(&gjs_arg_member<GParamSpec*>(arg),
3009 : : g_param_spec_unref);
3010 [ + - - + : 14324 : } else if (g_type_is_a(gtype, G_TYPE_CLOSURE)) {
- + ]
3011 [ # # ]: 0 : g_clear_pointer(&gjs_arg_member<GClosure*>(arg),
3012 : : g_closure_unref);
3013 [ + + - + : 14324 : } else if (g_type_is_a(gtype, G_TYPE_VALUE)) {
+ + ]
3014 : : /* G_TYPE_VALUE is-a G_TYPE_BOXED, but we special case it */
3015 [ + + ]: 29 : if (g_type_info_is_pointer (type_info))
3016 : 20 : g_boxed_free(gtype, gjs_arg_steal<void*>(arg));
3017 : : else
3018 [ + - ]: 9 : g_clear_pointer(&gjs_arg_member<GValue*>(arg),
3019 : : g_value_unset);
3020 [ + - + + : 14295 : } else if (g_type_is_a(gtype, G_TYPE_BOXED)) {
+ + ]
3021 [ + - ]: 12452 : if (!is_transfer_in_nothing(transfer, flags))
3022 : 12452 : g_boxed_free(gtype, gjs_arg_steal<void*>(arg));
3023 [ + + - + : 1843 : } else if (g_type_is_a(gtype, G_TYPE_VARIANT)) {
+ + ]
3024 [ + - ]: 1827 : if (!is_transfer_in_nothing(transfer, flags))
3025 [ + - ]: 1827 : g_clear_pointer(&gjs_arg_member<GVariant*>(arg),
3026 : : g_variant_unref);
3027 [ - + ]: 16 : } else if (gtype == G_TYPE_NONE) {
3028 [ # # ]: 0 : if (!is_transfer_in_nothing(transfer, flags)) {
3029 : 0 : gjs_throw(context, "Don't know how to release GArgument: not an object or boxed type");
3030 : 0 : return false;
3031 : : }
3032 [ + - ]: 16 : } else if (G_TYPE_IS_INSTANTIATABLE(gtype)) {
3033 [ + - ]: 16 : if (!is_transfer_in_nothing(transfer, flags)) {
3034 : : auto* priv =
3035 : 16 : FundamentalPrototype::for_gtype(context, gtype);
3036 : 16 : priv->call_unref_function(gjs_arg_steal<void*>(arg));
3037 : : }
3038 : : } else {
3039 : 0 : gjs_throw(context, "Unhandled GType %s releasing GArgument",
3040 : : g_type_name(gtype));
3041 : 0 : return false;
3042 : : }
3043 : 14741 : return true;
3044 : 14831 : }
3045 : :
3046 : 53 : case GI_TYPE_TAG_ARRAY:
3047 : : {
3048 : 53 : GIArrayType array_type = g_type_info_get_array_type(type_info);
3049 : :
3050 [ + + ]: 53 : if (!gjs_arg_get<void*>(arg)) {
3051 : : /* OK */
3052 [ + + ]: 52 : } else if (array_type == GI_ARRAY_TYPE_C) {
3053 : : GjsAutoTypeInfo param_info =
3054 : 27 : g_type_info_get_param_type(type_info, 0);
3055 : : GITypeTag element_type;
3056 : :
3057 : 27 : element_type = g_type_info_get_tag(param_info);
3058 : :
3059 [ + + + - : 27 : switch (element_type) {
- ]
3060 : 17 : case GI_TYPE_TAG_UTF8:
3061 : : case GI_TYPE_TAG_FILENAME:
3062 [ + + ]: 17 : if (transfer == GI_TRANSFER_CONTAINER)
3063 [ + - ]: 2 : g_clear_pointer(&gjs_arg_member<void*>(arg),
3064 : : g_free);
3065 : : else
3066 [ + - ]: 15 : g_clear_pointer(&gjs_arg_member<GStrv>(arg),
3067 : : g_strfreev);
3068 : 17 : break;
3069 : :
3070 : 5 : case GI_TYPE_TAG_BOOLEAN:
3071 : : case GI_TYPE_TAG_UINT8:
3072 : : case GI_TYPE_TAG_UINT16:
3073 : : case GI_TYPE_TAG_UINT32:
3074 : : case GI_TYPE_TAG_UINT64:
3075 : : case GI_TYPE_TAG_INT8:
3076 : : case GI_TYPE_TAG_INT16:
3077 : : case GI_TYPE_TAG_INT32:
3078 : : case GI_TYPE_TAG_INT64:
3079 : : case GI_TYPE_TAG_FLOAT:
3080 : : case GI_TYPE_TAG_DOUBLE:
3081 : : case GI_TYPE_TAG_UNICHAR:
3082 : : case GI_TYPE_TAG_GTYPE:
3083 [ + - ]: 5 : g_clear_pointer(&gjs_arg_member<void*>(arg), g_free);
3084 : 5 : break;
3085 : :
3086 : 5 : case GI_TYPE_TAG_INTERFACE:
3087 [ + + ]: 5 : if (!g_type_info_is_pointer(param_info)) {
3088 : : GjsAutoBaseInfo interface_info =
3089 : 2 : g_type_info_get_interface(param_info);
3090 : 2 : GIInfoType info_type = g_base_info_get_type(interface_info);
3091 [ - + - - ]: 2 : if (info_type == GI_INFO_TYPE_STRUCT ||
3092 : : info_type == GI_INFO_TYPE_UNION) {
3093 [ + - ]: 2 : g_clear_pointer(&gjs_arg_member<void*>(arg), g_free);
3094 : 2 : break;
3095 : : }
3096 [ - + ]: 2 : }
3097 : : [[fallthrough]];
3098 : : case GI_TYPE_TAG_GLIST:
3099 : : case GI_TYPE_TAG_GSLIST:
3100 : : case GI_TYPE_TAG_ARRAY:
3101 : : case GI_TYPE_TAG_GHASH:
3102 : : case GI_TYPE_TAG_ERROR: {
3103 : 3 : GITransfer element_transfer = transfer;
3104 : :
3105 [ - + - - ]: 3 : if (argument_type != GJS_ARGUMENT_ARGUMENT &&
3106 : : transfer != GI_TRANSFER_EVERYTHING)
3107 : 0 : element_transfer = GI_TRANSFER_NOTHING;
3108 : :
3109 [ + + ]: 3 : if (g_type_info_is_zero_terminated(type_info)) {
3110 : : return gjs_g_argument_release_array_internal<
3111 : 4 : ArrayReleaseType::ZERO_TERMINATED>(
3112 : : context, element_transfer,
3113 : 4 : flags | GjsArgumentFlags::ARG_OUT, param_info, 0, arg);
3114 : : } else {
3115 : : return gjs_g_argument_release_array_internal<
3116 : 2 : ArrayReleaseType::EXPLICIT_LENGTH>(
3117 : : context, element_transfer,
3118 : 2 : flags | GjsArgumentFlags::ARG_OUT, param_info,
3119 : 2 : g_type_info_get_array_fixed_size(type_info), arg);
3120 : : }
3121 : : }
3122 : :
3123 : 0 : case GI_TYPE_TAG_VOID:
3124 : : default:
3125 : 0 : gjs_throw(context,
3126 : : "Releasing a C array with explicit length, that was nested"
3127 : : "inside another container. This is not supported (and will leak)");
3128 : 0 : return false;
3129 : : }
3130 [ + + + + ]: 52 : } else if (array_type == GI_ARRAY_TYPE_ARRAY) {
3131 : : GITypeTag element_type;
3132 : :
3133 : : GjsAutoTypeInfo param_info =
3134 : 11 : g_type_info_get_param_type(type_info, 0);
3135 : 11 : element_type = g_type_info_get_tag(param_info);
3136 : :
3137 [ + + - ]: 11 : switch (element_type) {
3138 : 4 : case GI_TYPE_TAG_BOOLEAN:
3139 : : case GI_TYPE_TAG_UNICHAR:
3140 : : case GI_TYPE_TAG_UINT8:
3141 : : case GI_TYPE_TAG_UINT16:
3142 : : case GI_TYPE_TAG_UINT32:
3143 : : case GI_TYPE_TAG_UINT64:
3144 : : case GI_TYPE_TAG_INT8:
3145 : : case GI_TYPE_TAG_INT16:
3146 : : case GI_TYPE_TAG_INT32:
3147 : : case GI_TYPE_TAG_INT64:
3148 : : case GI_TYPE_TAG_FLOAT:
3149 : : case GI_TYPE_TAG_DOUBLE:
3150 : : case GI_TYPE_TAG_GTYPE:
3151 [ + - ]: 4 : g_clear_pointer(&gjs_arg_member<GArray*>(arg), g_array_unref);
3152 : 4 : break;
3153 : :
3154 : 7 : case GI_TYPE_TAG_UTF8:
3155 : : case GI_TYPE_TAG_FILENAME:
3156 : : case GI_TYPE_TAG_ARRAY:
3157 : : case GI_TYPE_TAG_INTERFACE:
3158 : : case GI_TYPE_TAG_GLIST:
3159 : : case GI_TYPE_TAG_GSLIST:
3160 : : case GI_TYPE_TAG_GHASH:
3161 : : case GI_TYPE_TAG_ERROR: {
3162 : : GjsAutoPointer<GArray, GArray, g_array_unref> array =
3163 : 7 : gjs_arg_steal<GArray*>(arg);
3164 : :
3165 [ + + + + : 12 : if (transfer != GI_TRANSFER_CONTAINER &&
+ + ]
3166 : 5 : type_needs_out_release(param_info, element_type)) {
3167 : : guint i;
3168 : :
3169 [ + + ]: 16 : for (i = 0; i < array->len; i++) {
3170 : : GArgument arg_iter;
3171 : :
3172 : 12 : gjs_arg_set(&arg_iter,
3173 : 12 : g_array_index(array, gpointer, i));
3174 [ - + ]: 12 : if (!gjs_g_arg_release_internal(
3175 : : context, transfer, param_info, element_type,
3176 : : GJS_ARGUMENT_ARRAY_ELEMENT, flags, &arg_iter))
3177 : 0 : return false;
3178 : : }
3179 : : }
3180 : :
3181 : 7 : break;
3182 [ - + ]: 7 : }
3183 : :
3184 : 0 : case GI_TYPE_TAG_VOID:
3185 : : default:
3186 : 0 : gjs_throw(context,
3187 : : "Don't know how to release GArray element-type %d",
3188 : : element_type);
3189 : 0 : return false;
3190 : : }
3191 : :
3192 [ + - + + ]: 25 : } else if (array_type == GI_ARRAY_TYPE_BYTE_ARRAY) {
3193 [ + - ]: 5 : g_clear_pointer(&gjs_arg_member<GByteArray*>(arg),
3194 : : g_byte_array_unref);
3195 [ + - ]: 9 : } else if (array_type == GI_ARRAY_TYPE_PTR_ARRAY) {
3196 : : GjsAutoTypeInfo param_info =
3197 : 9 : g_type_info_get_param_type(type_info, 0);
3198 : : GjsAutoPointer<GPtrArray, GPtrArray, g_ptr_array_unref> array =
3199 : 9 : gjs_arg_steal<GPtrArray*>(arg);
3200 : :
3201 [ + + ]: 9 : if (transfer != GI_TRANSFER_CONTAINER) {
3202 : : guint i;
3203 : :
3204 [ + + ]: 22 : for (i = 0; i < array->len; i++) {
3205 : : GArgument arg_iter;
3206 : :
3207 : 16 : gjs_arg_set(&arg_iter, g_ptr_array_index(array, i));
3208 [ - + ]: 16 : if (!gjs_g_argument_release(context, transfer, param_info,
3209 : : flags, &arg_iter))
3210 : 0 : return false;
3211 : : }
3212 : : }
3213 [ + - + - ]: 9 : } else {
3214 : : g_assert_not_reached();
3215 : : }
3216 : 50 : break;
3217 : : }
3218 : :
3219 : 44 : case GI_TYPE_TAG_GLIST:
3220 : 44 : return gjs_g_arg_release_g_list<GList>(context, transfer, type_info,
3221 : 44 : flags, arg);
3222 : :
3223 : 16 : case GI_TYPE_TAG_GSLIST:
3224 : 16 : return gjs_g_arg_release_g_list<GSList>(context, transfer, type_info,
3225 : 16 : flags, arg);
3226 : :
3227 : 23 : case GI_TYPE_TAG_GHASH:
3228 [ + + ]: 23 : if (gjs_arg_get<GHashTable*>(arg)) {
3229 : : GjsAutoPointer<GHashTable, GHashTable, g_hash_table_destroy>
3230 : 21 : hash_table = gjs_arg_steal<GHashTable*>(arg);
3231 [ + + ]: 21 : if (transfer == GI_TRANSFER_CONTAINER)
3232 : 3 : g_hash_table_remove_all(hash_table);
3233 : : else {
3234 : 18 : GHR_closure c = {context, nullptr, nullptr,
3235 : 18 : transfer, flags, false};
3236 : :
3237 : 18 : c.key_param_info = g_type_info_get_param_type(type_info, 0);
3238 : 18 : g_assert(c.key_param_info != nullptr);
3239 : 18 : c.val_param_info = g_type_info_get_param_type(type_info, 1);
3240 : 18 : g_assert(c.val_param_info != nullptr);
3241 : :
3242 : 18 : g_hash_table_foreach_steal(hash_table, gjs_ghr_helper, &c);
3243 : :
3244 [ - + ]: 18 : if (c.failed)
3245 : 0 : return false;
3246 [ + - ]: 18 : }
3247 [ + - ]: 21 : }
3248 : 23 : break;
3249 : :
3250 : 0 : default:
3251 : 0 : g_warning("Unhandled type %s releasing GArgument",
3252 : : g_type_tag_to_string(type_tag));
3253 : 0 : return false;
3254 : : }
3255 : :
3256 : 898 : return true;
3257 : : }
3258 : :
3259 : 34719 : bool gjs_g_argument_release(JSContext* cx, GITransfer transfer,
3260 : : GITypeInfo* type_info, GjsArgumentFlags flags,
3261 : : GIArgument* arg) {
3262 : : GITypeTag type_tag;
3263 : :
3264 [ + + + + ]: 53974 : if (transfer == GI_TRANSFER_NOTHING &&
3265 [ + + ]: 19255 : !is_transfer_in_nothing(transfer, flags))
3266 : 19249 : return true;
3267 : :
3268 : 15470 : type_tag = g_type_info_get_tag( (GITypeInfo*) type_info);
3269 : :
3270 : : gjs_debug_marshal(GJS_DEBUG_GFUNCTION,
3271 : : "Releasing GArgument %s out param or return value",
3272 : : g_type_tag_to_string(type_tag));
3273 : :
3274 : 15470 : return gjs_g_arg_release_internal(cx, transfer, type_info, type_tag,
3275 : 15470 : GJS_ARGUMENT_ARGUMENT, flags, arg);
3276 : : }
3277 : :
3278 : 75 : bool gjs_g_argument_release_in_arg(JSContext* cx, GITransfer transfer,
3279 : : GITypeInfo* type_info,
3280 : : GjsArgumentFlags flags, GIArgument* arg) {
3281 : : GITypeTag type_tag;
3282 : :
3283 : : /* GI_TRANSFER_EVERYTHING: we don't own the argument anymore.
3284 : : * GI_TRANSFER_CONTAINER:
3285 : : * - non-containers: treated as GI_TRANSFER_EVERYTHING
3286 : : * - containers: See FIXME in gjs_array_to_g_list(); currently
3287 : : * an error and we won't get here.
3288 : : */
3289 [ + + ]: 75 : if (transfer != GI_TRANSFER_NOTHING)
3290 : 1 : return true;
3291 : :
3292 : 74 : type_tag = g_type_info_get_tag( (GITypeInfo*) type_info);
3293 : :
3294 : : gjs_debug_marshal(GJS_DEBUG_GFUNCTION,
3295 : : "Releasing GArgument %s in param",
3296 : : g_type_tag_to_string(type_tag));
3297 : :
3298 [ + + ]: 74 : if (type_needs_release (type_info, type_tag))
3299 : 40 : return gjs_g_arg_release_internal(cx, transfer, type_info, type_tag,
3300 : 40 : GJS_ARGUMENT_ARGUMENT, flags, arg);
3301 : :
3302 : 34 : return true;
3303 : : }
3304 : :
3305 : 323 : bool gjs_g_argument_release_in_array(JSContext* context, GITransfer transfer,
3306 : : GITypeInfo* type_info, unsigned length,
3307 : : GIArgument* arg) {
3308 [ + + ]: 323 : if (transfer != GI_TRANSFER_NOTHING)
3309 : 3 : return true;
3310 : :
3311 : : gjs_debug_marshal(GJS_DEBUG_GFUNCTION,
3312 : : "Releasing GArgument array in param");
3313 : :
3314 : 320 : GjsAutoTypeInfo param_type = g_type_info_get_param_type(type_info, 0);
3315 : : return gjs_g_argument_release_array_internal<
3316 : 320 : ArrayReleaseType::EXPLICIT_LENGTH>(context, GI_TRANSFER_EVERYTHING,
3317 : : GjsArgumentFlags::ARG_IN, param_type,
3318 : 320 : length, arg);
3319 : 320 : }
3320 : :
3321 : 12 : bool gjs_g_argument_release_in_array(JSContext* context, GITransfer transfer,
3322 : : GITypeInfo* type_info, GIArgument* arg) {
3323 [ + + ]: 12 : if (transfer != GI_TRANSFER_NOTHING)
3324 : 1 : return true;
3325 : :
3326 : : gjs_debug_marshal(GJS_DEBUG_GFUNCTION,
3327 : : "Releasing GArgument array in param");
3328 : :
3329 : 11 : GjsAutoTypeInfo param_type = g_type_info_get_param_type(type_info, 0);
3330 : : return gjs_g_argument_release_array_internal<
3331 : 11 : ArrayReleaseType::ZERO_TERMINATED>(context, GI_TRANSFER_EVERYTHING,
3332 : : GjsArgumentFlags::ARG_IN, param_type,
3333 : 11 : 0, arg);
3334 : 11 : }
3335 : :
3336 : 37 : bool gjs_g_argument_release_out_array(JSContext* context, GITransfer transfer,
3337 : : GITypeInfo* type_info, unsigned length,
3338 : : GIArgument* arg) {
3339 [ + + ]: 37 : if (transfer == GI_TRANSFER_NOTHING)
3340 : 15 : return true;
3341 : :
3342 : : gjs_debug_marshal(GJS_DEBUG_GFUNCTION,
3343 : : "Releasing GArgument array out param");
3344 : :
3345 : 22 : GITransfer element_transfer = transfer == GI_TRANSFER_CONTAINER
3346 [ + + ]: 22 : ? GI_TRANSFER_NOTHING
3347 : : : GI_TRANSFER_EVERYTHING;
3348 : :
3349 : 22 : GjsAutoTypeInfo param_type = g_type_info_get_param_type(type_info, 0);
3350 : : return gjs_g_argument_release_array_internal<
3351 : 22 : ArrayReleaseType::EXPLICIT_LENGTH>(context, element_transfer,
3352 : : GjsArgumentFlags::ARG_OUT,
3353 : 22 : param_type, length, arg);
3354 : 22 : }
3355 : :
3356 : 2 : bool gjs_g_argument_release_out_array(JSContext* context, GITransfer transfer,
3357 : : GITypeInfo* type_info, GIArgument* arg) {
3358 [ + - ]: 2 : if (transfer == GI_TRANSFER_NOTHING)
3359 : 2 : return true;
3360 : :
3361 : : gjs_debug_marshal(GJS_DEBUG_GFUNCTION,
3362 : : "Releasing GArgument array out param");
3363 : :
3364 : 0 : GITransfer element_transfer = transfer == GI_TRANSFER_CONTAINER
3365 [ # # ]: 0 : ? GI_TRANSFER_NOTHING
3366 : : : GI_TRANSFER_EVERYTHING;
3367 : :
3368 : 0 : GjsAutoTypeInfo param_type = g_type_info_get_param_type(type_info, 0);
3369 : : return gjs_g_argument_release_array_internal<
3370 : 0 : ArrayReleaseType::ZERO_TERMINATED>(context, element_transfer,
3371 : : GjsArgumentFlags::ARG_OUT,
3372 : 0 : param_type, 0, arg);
3373 : 0 : }
|
