LCOV - code coverage report
Current view: top level - gi - boxed.cpp (source / functions) Coverage Total Hit
Test: gjs- Code Coverage Lines: 84.2 % 500 421
Test Date: 2024-04-29 05:18:28 Functions: 100.0 % 40 40
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 71.1 % 356 253

             Branch data     Line data    Source code
       1                 :             : /* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; -*- */
       2                 :             : // SPDX-License-Identifier: MIT OR LGPL-2.0-or-later
       3                 :             : // SPDX-FileCopyrightText: 2008 litl, LLC
       4                 :             : 
       5                 :             : #include <config.h>
       6                 :             : 
       7                 :             : #include <stdint.h>
       8                 :             : #include <string.h>  // for memcpy, size_t, strcmp
       9                 :             : 
      10                 :             : #include <string>
      11                 :             : #include <utility>  // for move, forward
      12                 :             : 
      13                 :             : #include <girepository.h>
      14                 :             : #include <glib-object.h>
      15                 :             : 
      16                 :             : #include <js/CallArgs.h>
      17                 :             : #include <js/Class.h>
      18                 :             : #include <js/ErrorReport.h>  // for JS_ReportOutOfMemory
      19                 :             : #include <js/Exception.h>
      20                 :             : #include <js/GCHashTable.h>  // for GCHashMap
      21                 :             : #include <js/GCVector.h>     // for MutableWrappedPtrOperations
      22                 :             : #include <js/Object.h>       // for SetReservedSlot
      23                 :             : #include <js/PropertyAndElement.h>  // for JS_DefineFunction, JS_Enumerate
      24                 :             : #include <js/String.h>
      25                 :             : #include <js/TracingAPI.h>
      26                 :             : #include <js/TypeDecls.h>
      27                 :             : #include <js/Utility.h>  // for UniqueChars
      28                 :             : #include <js/Value.h>
      29                 :             : #include <js/ValueArray.h>
      30                 :             : #include <jsapi.h>  // for IdVector
      31                 :             : #include <mozilla/HashTable.h>
      32                 :             : 
      33                 :             : #include "gi/arg-inl.h"
      34                 :             : #include "gi/arg.h"
      35                 :             : #include "gi/boxed.h"
      36                 :             : #include "gi/function.h"
      37                 :             : #include "gi/gerror.h"
      38                 :             : #include "gi/repo.h"
      39                 :             : #include "gi/wrapperutils.h"
      40                 :             : #include "gjs/atoms.h"
      41                 :             : #include "gjs/context-private.h"
      42                 :             : #include "gjs/jsapi-class.h"
      43                 :             : #include "gjs/jsapi-util.h"
      44                 :             : #include "gjs/macros.h"
      45                 :             : #include "gjs/mem-private.h"
      46                 :             : #include "util/log.h"
      47                 :             : 
      48                 :       19115 : BoxedInstance::BoxedInstance(BoxedPrototype* prototype, JS::HandleObject obj)
      49                 :             :     : GIWrapperInstance(prototype, obj),
      50                 :       19115 :       m_allocated_directly(false),
      51                 :       19115 :       m_owning_ptr(false) {
      52                 :       19115 :     GJS_INC_COUNTER(boxed_instance);
      53                 :       19115 : }
      54                 :             : 
      55                 :             : [[nodiscard]] static bool struct_is_simple(GIStructInfo* info);
      56                 :             : 
      57                 :             : // See GIWrapperBase::resolve().
      58                 :        4895 : bool BoxedPrototype::resolve_impl(JSContext* cx, JS::HandleObject obj,
      59                 :             :                                   JS::HandleId id, bool* resolved) {
      60                 :        4895 :     JS::UniqueChars prop_name;
      61         [ -  + ]:        4895 :     if (!gjs_get_string_id(cx, id, &prop_name))
      62                 :           0 :         return false;
      63         [ +  + ]:        4895 :     if (!prop_name) {
      64                 :         331 :         *resolved = false;
      65                 :         331 :         return true;  // not resolved, but no error
      66                 :             :     }
      67                 :             : 
      68                 :             :     // Look for methods and other class properties
      69                 :             :     GjsAutoFunctionInfo method_info =
      70                 :        4564 :         g_struct_info_find_method(info(), prop_name.get());
      71         [ +  + ]:        4564 :     if (!method_info) {
      72                 :        3730 :         *resolved = false;
      73                 :        3730 :         return true;
      74                 :             :     }
      75                 :             : #if GJS_VERBOSE_ENABLE_GI_USAGE
      76                 :             :     _gjs_log_info_usage(method_info);
      77                 :             : #endif
      78                 :             : 
      79         [ +  - ]:         834 :     if (g_function_info_get_flags(method_info) & GI_FUNCTION_IS_METHOD) {
      80                 :         834 :         gjs_debug(GJS_DEBUG_GBOXED, "Defining method %s in prototype for %s.%s",
      81                 :             :                   method_info.name(), ns(), name());
      82                 :             : 
      83                 :             :         /* obj is the Boxed prototype */
      84         [ -  + ]:         834 :         if (!gjs_define_function(cx, obj, gtype(), method_info))
      85                 :           0 :             return false;
      86                 :             : 
      87                 :         834 :         *resolved = true;
      88                 :             :     } else {
      89                 :           0 :         *resolved = false;
      90                 :             :     }
      91                 :             : 
      92                 :         834 :     return true;
      93                 :        4895 : }
      94                 :             : 
      95                 :             : // See GIWrapperBase::new_enumerate().
      96                 :           3 : bool BoxedPrototype::new_enumerate_impl(JSContext* cx, JS::HandleObject,
      97                 :             :                                         JS::MutableHandleIdVector properties,
      98                 :             :                                         bool only_enumerable [[maybe_unused]]) {
      99                 :           3 :     int n_methods = g_struct_info_get_n_methods(info());
     100         [ +  + ]:          36 :     for (int i = 0; i < n_methods; i++) {
     101                 :          33 :         GjsAutoFunctionInfo meth_info = g_struct_info_get_method(info(), i);
     102                 :          33 :         GIFunctionInfoFlags flags = g_function_info_get_flags(meth_info);
     103                 :             : 
     104         [ +  - ]:          33 :         if (flags & GI_FUNCTION_IS_METHOD) {
     105                 :          33 :             const char* name = meth_info.name();
     106                 :          33 :             jsid id = gjs_intern_string_to_id(cx, name);
     107         [ -  + ]:          33 :             if (id.isVoid())
     108                 :           0 :                 return false;
     109         [ -  + ]:          33 :             if (!properties.append(id)) {
     110                 :           0 :                 JS_ReportOutOfMemory(cx);
     111                 :           0 :                 return false;
     112                 :             :             }
     113                 :             :         }
     114         [ +  - ]:          33 :     }
     115                 :             : 
     116                 :           3 :     return true;
     117                 :             : }
     118                 :             : 
     119                 :             : /*
     120                 :             :  * BoxedBase::get_copy_source():
     121                 :             :  *
     122                 :             :  * Check to see if JS::Value passed in is another Boxed instance object of the
     123                 :             :  * same type, and if so, retrieve the BoxedInstance private structure for it.
     124                 :             :  * This function does not throw any JS exceptions.
     125                 :             :  */
     126                 :        1062 : BoxedBase* BoxedBase::get_copy_source(JSContext* context,
     127                 :             :                                       JS::Value value) const {
     128         [ +  + ]:        1062 :     if (!value.isObject())
     129                 :         975 :         return nullptr;
     130                 :             : 
     131                 :          87 :     JS::RootedObject object(context, &value.toObject());
     132                 :          87 :     BoxedBase* source_priv = BoxedBase::for_js(context, object);
     133   [ +  +  +  +  :          87 :     if (!source_priv || !g_base_info_equal(info(), source_priv->info()))
                   +  + ]
     134                 :          75 :         return nullptr;
     135                 :             : 
     136                 :          12 :     return source_priv;
     137                 :          87 : }
     138                 :             : 
     139                 :             : /*
     140                 :             :  * BoxedInstance::allocate_directly:
     141                 :             :  *
     142                 :             :  * Allocate a boxed object of the correct size, set all the bytes to 0, and set
     143                 :             :  * m_ptr to point to it. This is used when constructing a boxed object that can
     144                 :             :  * be allocated directly (i.e., does not need to be created by a constructor
     145                 :             :  * function.)
     146                 :             :  */
     147                 :         279 : void BoxedInstance::allocate_directly(void) {
     148                 :         279 :     g_assert(get_prototype()->can_allocate_directly());
     149                 :             : 
     150                 :         279 :     own_ptr(g_malloc0(g_struct_info_get_size(info())));
     151                 :         279 :     m_allocated_directly = true;
     152                 :             : 
     153                 :         279 :     debug_lifecycle("Boxed pointer directly allocated");
     154                 :         279 : }
     155                 :             : 
     156                 :             : // When initializing a boxed object from a hash of properties, we don't want to
     157                 :             : // do n O(n) lookups, so put put the fields into a hash table and store it on
     158                 :             : // proto->priv for fast lookup.
     159                 :          10 : std::unique_ptr<BoxedPrototype::FieldMap> BoxedPrototype::create_field_map(
     160                 :             :     JSContext* cx, GIStructInfo* struct_info) {
     161                 :             :     int n_fields;
     162                 :             :     int i;
     163                 :             : 
     164                 :          10 :     auto result = std::make_unique<BoxedPrototype::FieldMap>();
     165                 :          10 :     n_fields = g_struct_info_get_n_fields(struct_info);
     166         [ -  + ]:          10 :     if (!result->reserve(n_fields)) {
     167                 :           0 :         JS_ReportOutOfMemory(cx);
     168                 :           0 :         return nullptr;
     169                 :             :     }
     170                 :             : 
     171         [ +  + ]:          36 :     for (i = 0; i < n_fields; i++) {
     172                 :          26 :         GjsAutoFieldInfo field_info = g_struct_info_get_field(struct_info, i);
     173                 :             : 
     174                 :             :         // We get the string as a jsid later, which is interned. We intern the
     175                 :             :         // string here as well, so it will be the same string pointer
     176                 :          26 :         JSString* atom = JS_AtomizeAndPinString(cx, field_info.name());
     177                 :             : 
     178                 :          26 :         result->putNewInfallible(atom, std::move(field_info));
     179                 :          26 :     }
     180                 :             : 
     181                 :          10 :     return result;
     182                 :          10 : }
     183                 :             : 
     184                 :             : /*
     185                 :             :  * BoxedPrototype::ensure_field_map:
     186                 :             :  *
     187                 :             :  * BoxedPrototype keeps a cache of field names to introspection info.
     188                 :             :  * We only create the field cache the first time it is needed. An alternative
     189                 :             :  * would be to create it when the prototype is created, in BoxedPrototype::init.
     190                 :             :  */
     191                 :          88 : bool BoxedPrototype::ensure_field_map(JSContext* cx) {
     192         [ +  + ]:          88 :     if (!m_field_map)
     193                 :          10 :         m_field_map = create_field_map(cx, info());
     194                 :          88 :     return !!m_field_map;
     195                 :             : }
     196                 :             : 
     197                 :             : /*
     198                 :             :  * BoxedPrototype::lookup_field:
     199                 :             :  *
     200                 :             :  * Look up the introspection info corresponding to the field name @prop_name,
     201                 :             :  * creating the field cache if necessary.
     202                 :             :  */
     203                 :          88 : GIFieldInfo* BoxedPrototype::lookup_field(JSContext* cx, JSString* prop_name) {
     204         [ -  + ]:          88 :     if (!ensure_field_map(cx))
     205                 :           0 :         return nullptr;
     206                 :             : 
     207                 :          88 :     auto entry = m_field_map->lookup(prop_name);
     208         [ +  + ]:          88 :     if (!entry) {
     209                 :           4 :         gjs_throw(cx, "No field %s on boxed type %s",
     210                 :           4 :                   gjs_debug_string(prop_name).c_str(), name());
     211                 :           2 :         return nullptr;
     212                 :             :     }
     213                 :             : 
     214                 :          86 :     return entry->value().get();
     215                 :             : }
     216                 :             : 
     217                 :             : /* Initialize a newly created Boxed from an object that is a "hash" of
     218                 :             :  * properties to set as fields of the object. We don't require that every field
     219                 :             :  * of the object be set.
     220                 :             :  */
     221                 :          60 : bool BoxedInstance::init_from_props(JSContext* context, JS::Value props_value) {
     222                 :             :     size_t ix, length;
     223                 :             : 
     224         [ -  + ]:          60 :     if (!props_value.isObject()) {
     225                 :           0 :         gjs_throw(context, "argument should be a hash with fields to set");
     226                 :           0 :         return false;
     227                 :             :     }
     228                 :             : 
     229                 :          60 :     JS::RootedObject props(context, &props_value.toObject());
     230                 :          60 :     JS::Rooted<JS::IdVector> ids(context, context);
     231         [ -  + ]:          60 :     if (!JS_Enumerate(context, props, &ids)) {
     232                 :           0 :         gjs_throw(context, "Failed to enumerate fields hash");
     233                 :           0 :         return false;
     234                 :             :     }
     235                 :             : 
     236                 :          60 :     JS::RootedValue value(context);
     237         [ +  + ]:         146 :     for (ix = 0, length = ids.length(); ix < length; ix++) {
     238         [ -  + ]:          88 :         if (!ids[ix].isString()) {
     239                 :           0 :             gjs_throw(context, "Fields hash contained a non-string field");
     240                 :           0 :             return false;
     241                 :             :         }
     242                 :             : 
     243                 :             :         GIFieldInfo* field_info =
     244                 :          88 :             get_prototype()->lookup_field(context, ids[ix].toString());
     245         [ +  + ]:          88 :         if (!field_info)
     246                 :           2 :             return false;
     247                 :             : 
     248                 :             :         /* ids[ix] is reachable because props is rooted, but require_property
     249                 :             :          * doesn't know that */
     250                 :         172 :         if (!gjs_object_require_property(context, props, "property list",
     251         [ -  + ]:         172 :                                          JS::HandleId::fromMarkedLocation(ids[ix].address()),
     252                 :             :                                          &value))
     253                 :           0 :             return false;
     254                 :             : 
     255         [ -  + ]:          86 :         if (!field_setter_impl(context, field_info, value))
     256                 :           0 :             return false;
     257                 :             :     }
     258                 :             : 
     259                 :          58 :     return true;
     260                 :          60 : }
     261                 :             : 
     262                 :             : GJS_JSAPI_RETURN_CONVENTION
     263                 :        1528 : static bool boxed_invoke_constructor(JSContext* context, JS::HandleObject obj,
     264                 :             :                                      JS::HandleId constructor_name,
     265                 :             :                                      const JS::CallArgs& args) {
     266                 :        1528 :     GjsContextPrivate* gjs = GjsContextPrivate::from_cx(context);
     267                 :        1528 :     JS::RootedObject js_constructor(context);
     268                 :             : 
     269         [ -  + ]:        3056 :     if (!gjs_object_require_property(
     270                 :        1528 :             context, obj, nullptr, gjs->atoms().constructor(), &js_constructor))
     271                 :           0 :         return false;
     272                 :             : 
     273                 :        1528 :     JS::RootedValue js_constructor_func(context);
     274         [ -  + ]:        1528 :     if (!gjs_object_require_property(context, js_constructor, NULL,
     275                 :             :                                      constructor_name, &js_constructor_func))
     276                 :           0 :         return false;
     277                 :             : 
     278                 :        1528 :     return gjs->call_function(nullptr, js_constructor_func, args, args.rval());
     279                 :        1528 : }
     280                 :             : 
     281                 :             : /*
     282                 :             :  * BoxedInstance::copy_boxed:
     283                 :             :  *
     284                 :             :  * Allocate a new boxed pointer using g_boxed_copy(), either from a raw boxed
     285                 :             :  * pointer or another BoxedInstance.
     286                 :             :  */
     287                 :       13823 : void BoxedInstance::copy_boxed(void* boxed_ptr) {
     288                 :       13823 :     own_ptr(g_boxed_copy(gtype(), boxed_ptr));
     289                 :       13823 :     debug_lifecycle("Boxed pointer created with g_boxed_copy()");
     290                 :       13823 : }
     291                 :             : 
     292                 :          11 : void BoxedInstance::copy_boxed(BoxedInstance* source) {
     293                 :          11 :     copy_boxed(source->ptr());
     294                 :          11 : }
     295                 :             : 
     296                 :             : /*
     297                 :             :  * BoxedInstance::copy_memory:
     298                 :             :  *
     299                 :             :  * Allocate a new boxed pointer by copying the contents of another boxed pointer
     300                 :             :  * or another BoxedInstance.
     301                 :             :  */
     302                 :          26 : void BoxedInstance::copy_memory(void* boxed_ptr) {
     303                 :          26 :     allocate_directly();
     304                 :          26 :     memcpy(m_ptr, boxed_ptr, g_struct_info_get_size(info()));
     305                 :          26 : }
     306                 :             : 
     307                 :           1 : void BoxedInstance::copy_memory(BoxedInstance* source) {
     308                 :           1 :     copy_memory(source->ptr());
     309                 :           1 : }
     310                 :             : 
     311                 :             : // See GIWrapperBase::constructor().
     312                 :        1864 : bool BoxedInstance::constructor_impl(JSContext* context, JS::HandleObject obj,
     313                 :             :                                      const JS::CallArgs& args) {
     314                 :             :     // Short-circuit copy-construction in the case where we can use copy_boxed()
     315                 :             :     // or copy_memory()
     316                 :             :     BoxedBase* source_priv;
     317   [ +  +  +  + ]:        2923 :     if (args.length() == 1 &&
     318         [ +  + ]:        2923 :         (source_priv = get_copy_source(context, args[0]))) {
     319         [ -  + ]:          12 :         if (!source_priv->check_is_instance(context, "construct boxed object"))
     320                 :           0 :             return false;
     321                 :             : 
     322   [ +  -  +  +  :          12 :         if (g_type_is_a(gtype(), G_TYPE_BOXED)) {
                   +  + ]
     323                 :          11 :             copy_boxed(source_priv->to_instance());
     324                 :          11 :             return true;
     325         [ +  - ]:           1 :         } else if (get_prototype()->can_allocate_directly()) {
     326                 :           1 :             copy_memory(source_priv->to_instance());
     327                 :           1 :             return true;
     328                 :             :         }
     329                 :             :     }
     330                 :             : 
     331         [ +  + ]:        1852 :     if (gtype() == G_TYPE_VARIANT) {
     332                 :             :         /* Short-circuit construction for GVariants by calling into the JS packing
     333                 :             :            function */
     334                 :         447 :         const GjsAtoms& atoms = GjsContextPrivate::atoms(context);
     335         [ +  + ]:         447 :         if (!boxed_invoke_constructor(context, obj, atoms.new_internal(), args))
     336                 :           2 :             return false;
     337                 :             : 
     338                 :             :         // The return value of GLib.Variant.new_internal() gets its own
     339                 :             :         // BoxedInstance, and the one we're setting up in this constructor is
     340                 :             :         // discarded.
     341                 :         445 :         debug_lifecycle(
     342                 :             :             "Boxed construction delegated to GVariant constructor, "
     343                 :             :             "boxed object discarded");
     344                 :             : 
     345                 :         445 :         return true;
     346                 :             :     }
     347                 :             : 
     348                 :        1405 :     BoxedPrototype* proto = get_prototype();
     349                 :             : 
     350                 :             :     // If the structure is registered as a boxed, we can create a new instance
     351                 :             :     // by looking for a zero-args constructor and calling it.
     352                 :             :     // Constructors don't really make sense for non-boxed types, since there is
     353                 :             :     // no memory management for the return value, and zero_args_constructor and
     354                 :             :     // default_constructor are always -1 for them.
     355                 :             :     //
     356                 :             :     // For backward compatibility, we choose the zero args constructor if one
     357                 :             :     // exists, otherwise we malloc the correct amount of space if possible;
     358                 :             :     // finally, we fallback on the default constructor.
     359         [ +  + ]:        1405 :     if (proto->has_zero_args_constructor()) {
     360                 :          69 :         GjsAutoFunctionInfo func_info = proto->zero_args_constructor_info();
     361                 :             : 
     362                 :             :         GIArgument rval_arg;
     363                 :          69 :         GjsAutoError error;
     364                 :             : 
     365         [ -  + ]:          69 :         if (!g_function_info_invoke(func_info, NULL, 0, NULL, 0, &rval_arg, &error)) {
     366                 :           0 :             gjs_throw(context, "Failed to invoke boxed constructor: %s",
     367                 :           0 :                       error->message);
     368                 :           0 :             return false;
     369                 :             :         }
     370                 :             : 
     371                 :          69 :         own_ptr(gjs_arg_steal<void*>(&rval_arg));
     372                 :             : 
     373                 :          69 :         debug_lifecycle("Boxed pointer created from zero-args constructor");
     374                 :             : 
     375   [ +  -  +  -  :        1405 :     } else if (proto->can_allocate_directly_without_pointers()) {
                   +  + ]
     376                 :         253 :         allocate_directly();
     377         [ +  + ]:        1083 :     } else if (proto->has_default_constructor()) {
     378                 :             :         /* for simplicity, we simply delegate all the work to the actual JS
     379                 :             :          * constructor function (which we retrieve from the JS constructor,
     380                 :             :          * that is, Namespace.BoxedType, or object.constructor, given that
     381                 :             :          * object was created with the right prototype. */
     382         [ +  + ]:        1081 :         if (!boxed_invoke_constructor(context, obj,
     383                 :             :                                       proto->default_constructor_name(), args))
     384                 :           1 :             return false;
     385                 :             : 
     386                 :             :         // Define the expected Error properties
     387         [ +  + ]:        1080 :         if (gtype() == G_TYPE_ERROR) {
     388                 :           3 :             JS::RootedObject gerror(context, &args.rval().toObject());
     389         [ -  + ]:           3 :             if (!gjs_define_error_properties(context, gerror))
     390                 :           0 :                 return false;
     391         [ +  - ]:           3 :         }
     392                 :             : 
     393                 :             :         // The return value of the JS constructor gets its own BoxedInstance,
     394                 :             :         // and this one is discarded.
     395                 :        1080 :         debug_lifecycle(
     396                 :             :             "Boxed construction delegated to JS constructor, "
     397                 :             :             "boxed object discarded");
     398                 :             : 
     399                 :        1080 :         return true;
     400         [ -  + ]:           2 :     } else if (proto->can_allocate_directly()) {
     401                 :           0 :         allocate_directly();
     402                 :             :     } else {
     403                 :           2 :         gjs_throw(context,
     404                 :             :                   "Unable to construct struct type %s since it has no default "
     405                 :             :                   "constructor and cannot be allocated directly",
     406                 :             :                   name());
     407                 :           2 :         return false;
     408                 :             :     }
     409                 :             : 
     410                 :             :     /* If we reach this code, we need to init from a map of fields */
     411                 :             : 
     412         [ +  + ]:         322 :     if (args.length() == 0)
     413                 :         262 :         return true;
     414                 :             : 
     415         [ -  + ]:          60 :     if (args.length() > 1) {
     416                 :           0 :         gjs_throw(context,
     417                 :             :                   "Constructor with multiple arguments not supported for %s",
     418                 :             :                   name());
     419                 :           0 :         return false;
     420                 :             :     }
     421                 :             : 
     422                 :          60 :     return init_from_props(context, args[0]);
     423                 :             : }
     424                 :             : 
     425                 :       19112 : BoxedInstance::~BoxedInstance() {
     426         [ +  + ]:       19112 :     if (m_owning_ptr) {
     427         [ +  + ]:       17556 :         if (m_allocated_directly) {
     428         [ +  + ]:         279 :             if (gtype() == G_TYPE_VALUE)
     429                 :         194 :                 g_value_unset(m_ptr.as<GValue>());
     430                 :         279 :             g_free(m_ptr.release());
     431                 :             :         } else {
     432   [ +  -  +  +  :       17277 :             if (g_type_is_a(gtype(), G_TYPE_BOXED))
                   +  + ]
     433                 :       13890 :                 g_boxed_free(gtype(), m_ptr.release());
     434   [ -  +  -  -  :        3387 :             else if (g_type_is_a(gtype(), G_TYPE_VARIANT))
                   +  - ]
     435                 :        3387 :                 g_variant_unref(static_cast<GVariant*>(m_ptr.release()));
     436                 :             :             else
     437                 :             :                 g_assert_not_reached ();
     438                 :             :         }
     439                 :             :     }
     440                 :             : 
     441                 :       19112 :     GJS_DEC_COUNTER(boxed_instance);
     442                 :       19112 : }
     443                 :             : 
     444                 :         693 : BoxedPrototype::~BoxedPrototype(void) {
     445                 :         693 :     GJS_DEC_COUNTER(boxed_prototype);
     446                 :         693 : }
     447                 :             : 
     448                 :             : /*
     449                 :             :  * BoxedBase::get_field_info:
     450                 :             :  *
     451                 :             :  * Does the same thing as g_struct_info_get_field(), but throws a JS exception
     452                 :             :  * if there is no such field.
     453                 :             :  */
     454                 :        1944 : GIFieldInfo* BoxedBase::get_field_info(JSContext* cx, uint32_t id) const {
     455                 :        1944 :     GIFieldInfo* field_info = g_struct_info_get_field(info(), id);
     456         [ -  + ]:        1944 :     if (field_info == NULL) {
     457                 :           0 :         gjs_throw(cx, "No field %d on boxed type %s", id, name());
     458                 :           0 :         return NULL;
     459                 :             :     }
     460                 :             : 
     461                 :        1944 :     return field_info;
     462                 :             : }
     463                 :             : 
     464                 :             : /*
     465                 :             :  * BoxedInstance::get_nested_interface_object:
     466                 :             :  * @parent_obj: the BoxedInstance JS object that owns `this`
     467                 :             :  * @field_info: introspection info for the field of the parent boxed type that
     468                 :             :  *   is another boxed type
     469                 :             :  * @interface_info: introspection info for the nested boxed type
     470                 :             :  * @value: return location for a new BoxedInstance JS object
     471                 :             :  *
     472                 :             :  * Some boxed types have a field that consists of another boxed type. We want to
     473                 :             :  * be able to expose these nested boxed types without copying them, because
     474                 :             :  * changing fields of the nested boxed struct should affect the enclosing boxed
     475                 :             :  * struct.
     476                 :             :  *
     477                 :             :  * This method creates a new BoxedInstance and JS object for a nested boxed
     478                 :             :  * struct. Since both the nested JS object and the parent boxed's JS object
     479                 :             :  * refer to the same memory, the parent JS object will be prevented from being
     480                 :             :  * garbage collected while the nested JS object is active.
     481                 :             :  */
     482                 :          16 : bool BoxedInstance::get_nested_interface_object(
     483                 :             :     JSContext* context, JSObject* parent_obj, GIFieldInfo* field_info,
     484                 :             :     GIStructInfo* struct_info, JS::MutableHandleValue value) const {
     485                 :             :     int offset;
     486                 :             : 
     487         [ -  + ]:          16 :     if (!struct_is_simple(struct_info)) {
     488                 :           0 :         gjs_throw(context, "Reading field %s.%s is not supported", name(),
     489                 :             :                   g_base_info_get_name(field_info));
     490                 :             : 
     491                 :           0 :         return false;
     492                 :             :     }
     493                 :             : 
     494                 :          16 :     offset = g_field_info_get_offset (field_info);
     495                 :             : 
     496                 :             :     JS::RootedObject obj{
     497                 :          16 :         context, gjs_new_object_with_generic_prototype(context, struct_info)};
     498         [ -  + ]:          16 :     if (!obj)
     499                 :           0 :         return false;
     500                 :             : 
     501                 :          16 :     BoxedInstance* priv = BoxedInstance::new_for_js_object(context, obj);
     502                 :             : 
     503                 :             :     /* A structure nested inside a parent object; doesn't have an independent allocation */
     504                 :          16 :     priv->share_ptr(raw_ptr() + offset);
     505                 :          16 :     priv->debug_lifecycle(
     506                 :             :         "Boxed pointer created, pointing inside memory owned by parent");
     507                 :             : 
     508                 :             :     /* We never actually read the reserved slot, but we put the parent object
     509                 :             :      * into it to hold onto the parent object.
     510                 :             :      */
     511                 :          16 :     JS::SetReservedSlot(obj, BoxedInstance::PARENT_OBJECT,
     512                 :          16 :                         JS::ObjectValue(*parent_obj));
     513                 :             : 
     514                 :          16 :     value.setObject(*obj);
     515                 :          16 :     return true;
     516                 :          16 : }
     517                 :             : 
     518                 :             : /*
     519                 :             :  * BoxedBase::field_getter:
     520                 :             :  *
     521                 :             :  * JSNative property getter that is called when accessing a field defined on a
     522                 :             :  * boxed type. Delegates to BoxedInstance::field_getter_impl() if the minimal
     523                 :             :  * conditions have been met.
     524                 :             :  */
     525                 :        1859 : bool BoxedBase::field_getter(JSContext* context, unsigned argc, JS::Value* vp) {
     526   [ -  +  -  + ]:        1859 :     GJS_CHECK_WRAPPER_PRIV(context, argc, vp, args, obj, BoxedBase, priv);
     527         [ -  + ]:        1859 :     if (!priv->check_is_instance(context, "get a field"))
     528                 :           0 :         return false;
     529                 :             : 
     530                 :        1859 :     uint32_t field_ix = gjs_dynamic_property_private_slot(&args.callee())
     531                 :        1859 :         .toPrivateUint32();
     532                 :        1859 :     GjsAutoFieldInfo field_info = priv->get_field_info(context, field_ix);
     533         [ -  + ]:        1859 :     if (!field_info)
     534                 :           0 :         return false;
     535                 :             : 
     536                 :        1859 :     return priv->to_instance()->field_getter_impl(context, obj, field_info,
     537                 :        1859 :                                                   args.rval());
     538                 :        1859 : }
     539                 :             : 
     540                 :             : // See BoxedBase::field_getter().
     541                 :        1859 : bool BoxedInstance::field_getter_impl(JSContext* cx, JSObject* obj,
     542                 :             :                                       GIFieldInfo* field_info,
     543                 :             :                                       JS::MutableHandleValue rval) const {
     544                 :        1859 :     GjsAutoTypeInfo type_info = g_field_info_get_type(field_info);
     545                 :             : 
     546   [ +  +  +  +  :        2022 :     if (!g_type_info_is_pointer(type_info) &&
                   +  + ]
     547                 :         163 :         g_type_info_get_tag(type_info) == GI_TYPE_TAG_INTERFACE) {
     548                 :          55 :         GjsAutoBaseInfo interface_info = g_type_info_get_interface(type_info);
     549                 :             : 
     550   [ +  +  -  +  :          94 :         if (interface_info.type() == GI_INFO_TYPE_STRUCT ||
                   +  + ]
     551                 :          39 :             interface_info.type() == GI_INFO_TYPE_BOXED) {
     552                 :          16 :             return get_nested_interface_object(cx, obj, field_info,
     553                 :          16 :                                                interface_info, rval);
     554                 :             :         }
     555         [ +  + ]:          55 :     }
     556                 :             : 
     557                 :             :     GIArgument arg;
     558         [ -  + ]:        1843 :     if (!g_field_info_get_field(field_info, m_ptr, &arg)) {
     559                 :           0 :         gjs_throw(cx, "Reading field %s.%s is not supported", name(),
     560                 :             :                   g_base_info_get_name(field_info));
     561                 :           0 :         return false;
     562                 :             :     }
     563                 :             : 
     564   [ +  +  +  +  :        2263 :     if (g_type_info_get_tag(type_info) == GI_TYPE_TAG_ARRAY &&
                   +  + ]
     565                 :         420 :         g_type_info_get_array_length(type_info) != -1) {
     566                 :           2 :         auto length_field_ix = g_type_info_get_array_length(type_info);
     567                 :             :         GjsAutoFieldInfo length_field_info =
     568                 :           2 :             get_field_info(cx, length_field_ix);
     569         [ -  + ]:           2 :         if (!length_field_info) {
     570                 :           0 :             gjs_throw(cx, "Reading field %s.%s is not supported", name(),
     571                 :             :                       g_base_info_get_name(field_info));
     572                 :           0 :             return false;
     573                 :             :         }
     574                 :             : 
     575                 :             :         GIArgument length_arg;
     576         [ -  + ]:           2 :         if (!g_field_info_get_field(length_field_info, m_ptr, &length_arg)) {
     577                 :           0 :             gjs_throw(cx, "Reading field %s.%s is not supported", name(),
     578                 :             :                       length_field_info.name());
     579                 :           0 :             return false;
     580                 :             :         }
     581                 :             : 
     582                 :             :         GjsAutoTypeInfo length_type_info =
     583                 :           2 :             g_field_info_get_type(length_field_info);
     584                 :           2 :         size_t length = gjs_gi_argument_get_array_length(
     585                 :             :             g_type_info_get_tag(length_type_info), &length_arg);
     586                 :           2 :         return gjs_value_from_explicit_array(cx, rval, type_info, &arg, length);
     587                 :           2 :     }
     588                 :             : 
     589                 :        1841 :     return gjs_value_from_gi_argument(cx, rval, type_info, GJS_ARGUMENT_FIELD,
     590                 :        1841 :                                       GI_TRANSFER_EVERYTHING, &arg);
     591                 :        1859 : }
     592                 :             : 
     593                 :             : /*
     594                 :             :  * BoxedInstance::set_nested_interface_object:
     595                 :             :  * @field_info: introspection info for the field of the parent boxed type that
     596                 :             :  *   is another boxed type
     597                 :             :  * @interface_info: introspection info for the nested boxed type
     598                 :             :  * @value: holds a BoxedInstance JS object of type @interface_info
     599                 :             :  *
     600                 :             :  * Some boxed types have a field that consists of another boxed type. This
     601                 :             :  * method is called from BoxedInstance::field_setter_impl() when any such field
     602                 :             :  * is being set. The contents of the BoxedInstance JS object in @value are
     603                 :             :  * copied into the correct place in this BoxedInstance's memory.
     604                 :             :  */
     605                 :           3 : bool BoxedInstance::set_nested_interface_object(JSContext* context,
     606                 :             :                                                 GIFieldInfo* field_info,
     607                 :             :                                                 GIStructInfo* struct_info,
     608                 :             :                                                 JS::HandleValue value) {
     609                 :             :     int offset;
     610                 :             : 
     611         [ -  + ]:           3 :     if (!struct_is_simple(struct_info)) {
     612                 :           0 :         gjs_throw(context, "Writing field %s.%s is not supported", name(),
     613                 :             :                   g_base_info_get_name(field_info));
     614                 :             : 
     615                 :           0 :         return false;
     616                 :             :     }
     617                 :             : 
     618                 :             :     JS::RootedObject proto{context,
     619                 :           3 :                            gjs_lookup_generic_prototype(context, struct_info)};
     620                 :             : 
     621         [ -  + ]:           3 :     if (!proto)
     622                 :           0 :         return false;
     623                 :             : 
     624                 :             :     /* If we can't directly copy from the source object we need
     625                 :             :      * to construct a new temporary object.
     626                 :             :      */
     627                 :           3 :     BoxedBase* source_priv = get_copy_source(context, value);
     628         [ +  - ]:           3 :     if (!source_priv) {
     629                 :           3 :         JS::RootedValueArray<1> args(context);
     630                 :           3 :         args[0].set(value);
     631                 :             :         JS::RootedObject tmp_object(context,
     632                 :           3 :             gjs_construct_object_dynamic(context, proto, args));
     633   [ +  -  -  +  :           3 :         if (!tmp_object || !for_js_typecheck(context, tmp_object, &source_priv))
                   -  + ]
     634                 :           0 :             return false;
     635   [ +  -  +  - ]:           3 :     }
     636                 :             : 
     637         [ -  + ]:           3 :     if (!source_priv->check_is_instance(context, "copy"))
     638                 :           0 :         return false;
     639                 :             : 
     640                 :           3 :     offset = g_field_info_get_offset (field_info);
     641                 :           3 :     memcpy(raw_ptr() + offset, source_priv->to_instance()->ptr(),
     642                 :             :            g_struct_info_get_size(source_priv->info()));
     643                 :             : 
     644                 :           3 :     return true;
     645                 :           3 : }
     646                 :             : 
     647                 :             : // See BoxedBase::field_setter().
     648                 :         169 : bool BoxedInstance::field_setter_impl(JSContext* context,
     649                 :             :                                       GIFieldInfo* field_info,
     650                 :             :                                       JS::HandleValue value) {
     651                 :         169 :     GjsAutoTypeInfo type_info = g_field_info_get_type(field_info);
     652                 :             : 
     653   [ +  -  +  +  :         338 :     if (!g_type_info_is_pointer (type_info) &&
                   +  + ]
     654                 :         169 :         g_type_info_get_tag (type_info) == GI_TYPE_TAG_INTERFACE) {
     655                 :          22 :         GjsAutoBaseInfo interface_info = g_type_info_get_interface(type_info);
     656                 :             : 
     657   [ +  +  -  +  :          41 :         if (interface_info.type() == GI_INFO_TYPE_STRUCT ||
                   +  + ]
     658                 :          19 :             interface_info.type() == GI_INFO_TYPE_BOXED) {
     659                 :           3 :             return set_nested_interface_object(context, field_info,
     660                 :           3 :                                                interface_info, value);
     661                 :             :         }
     662         [ +  + ]:          22 :     }
     663                 :             : 
     664                 :             :     GIArgument arg;
     665         [ -  + ]:         166 :     if (!gjs_value_to_gi_argument(context, value, type_info,
     666                 :             :                                   g_base_info_get_name(field_info),
     667                 :             :                                   GJS_ARGUMENT_FIELD, GI_TRANSFER_NOTHING,
     668                 :             :                                   GjsArgumentFlags::MAY_BE_NULL, &arg))
     669                 :           0 :         return false;
     670                 :             : 
     671                 :         166 :     bool success = true;
     672         [ -  + ]:         166 :     if (!g_field_info_set_field(field_info, m_ptr, &arg)) {
     673                 :           0 :         gjs_throw(context, "Writing field %s.%s is not supported", name(),
     674                 :             :                   g_base_info_get_name(field_info));
     675                 :           0 :         success = false;
     676                 :             :     }
     677                 :             : 
     678                 :         166 :     JS::AutoSaveExceptionState saved_exc(context);
     679         [ -  + ]:         166 :     if (!gjs_gi_argument_release(context, GI_TRANSFER_NOTHING, type_info, &arg))
     680                 :           0 :         gjs_log_exception(context);
     681                 :         166 :     saved_exc.restore();
     682                 :             : 
     683                 :         166 :     return success;
     684                 :         169 : }
     685                 :             : 
     686                 :             : /*
     687                 :             :  * BoxedBase::field_setter:
     688                 :             :  *
     689                 :             :  * JSNative property setter that is called when writing to a field defined on a
     690                 :             :  * boxed type. Delegates to BoxedInstance::field_setter_impl() if the minimal
     691                 :             :  * conditions have been met.
     692                 :             :  */
     693                 :          83 : bool BoxedBase::field_setter(JSContext* cx, unsigned argc, JS::Value* vp) {
     694   [ -  +  -  + ]:          83 :     GJS_CHECK_WRAPPER_PRIV(cx, argc, vp, args, obj, BoxedBase, priv);
     695         [ -  + ]:          83 :     if (!priv->check_is_instance(cx, "set a field"))
     696                 :           0 :         return false;
     697                 :             : 
     698                 :          83 :     uint32_t field_ix = gjs_dynamic_property_private_slot(&args.callee())
     699                 :          83 :         .toPrivateUint32();
     700                 :          83 :     GjsAutoFieldInfo field_info = priv->get_field_info(cx, field_ix);
     701         [ -  + ]:          83 :     if (!field_info)
     702                 :           0 :         return false;
     703                 :             : 
     704         [ -  + ]:          83 :     if (!priv->to_instance()->field_setter_impl(cx, field_info, args[0]))
     705                 :           0 :         return false;
     706                 :             : 
     707                 :          83 :     args.rval().setUndefined();  /* No stored value */
     708                 :          83 :     return true;
     709                 :          83 : }
     710                 :             : 
     711                 :             : /*
     712                 :             :  * BoxedPrototype::define_boxed_class_fields:
     713                 :             :  *
     714                 :             :  * Defines properties on the JS prototype object, with JSNative getters and
     715                 :             :  * setters, for all the fields exposed by GObject introspection.
     716                 :             :  */
     717                 :         709 : bool BoxedPrototype::define_boxed_class_fields(JSContext* cx,
     718                 :             :                                                JS::HandleObject proto) {
     719                 :         709 :     int n_fields = g_struct_info_get_n_fields(info());
     720                 :             :     int i;
     721                 :             : 
     722                 :             :     // We define all fields as read/write so that the user gets an error
     723                 :             :     // message. If we omitted fields or defined them read-only we'd:
     724                 :             :     //
     725                 :             :     //  - Store a new property for a non-accessible field
     726                 :             :     //  - Silently do nothing when writing a read-only field
     727                 :             :     //
     728                 :             :     // Which is pretty confusing if the only reason a field isn't writable is
     729                 :             :     // language binding or memory-management restrictions.
     730                 :             :     //
     731                 :             :     // We just go ahead and define the fields immediately for the class; doing
     732                 :             :     // it lazily in boxed_resolve() would be possible as well if doing it ahead
     733                 :             :     // of time caused too much start-up memory overhead.
     734                 :             :     //
     735                 :             :     // At this point methods have already been defined on the prototype, so we
     736                 :             :     // may get name conflicts which we need to check for.
     737         [ +  + ]:        2096 :     for (i = 0; i < n_fields; i++) {
     738                 :        1387 :         GjsAutoFieldInfo field = g_struct_info_get_field(info(), i);
     739                 :        1387 :         JS::RootedValue private_id(cx, JS::PrivateUint32Value(i));
     740                 :        1387 :         JS::RootedId id{cx, gjs_intern_string_to_id(cx, field.name())};
     741                 :             : 
     742                 :             :         bool already_defined;
     743         [ -  + ]:        1387 :         if (!JS_HasOwnPropertyById(cx, proto, id, &already_defined))
     744                 :           0 :             return false;
     745         [ -  + ]:        1387 :         if (already_defined) {
     746                 :           0 :             gjs_debug(GJS_DEBUG_GBOXED,
     747                 :             :                       "Field %s.%s.%s overlaps with method of the same name; "
     748                 :             :                       "skipping",
     749                 :             :                       ns(), name(), field.name());
     750                 :           0 :             continue;
     751                 :             :         }
     752                 :             : 
     753         [ -  + ]:        1387 :         if (!gjs_define_property_dynamic(
     754                 :             :                 cx, proto, field.name(), id, "boxed_field",
     755                 :             :                 &BoxedBase::field_getter, &BoxedBase::field_setter, private_id,
     756                 :             :                 GJS_MODULE_PROP_FLAGS))
     757                 :           0 :             return false;
     758   [ +  -  -  +  :        1387 :     }
             -  -  +  -  
                      - ]
     759                 :             : 
     760                 :         709 :     return true;
     761                 :             : }
     762                 :             : 
     763                 :             : // Overrides GIWrapperPrototype::trace_impl().
     764                 :        1586 : void BoxedPrototype::trace_impl(JSTracer* trc) {
     765                 :        1586 :     JS::TraceEdge<jsid>(trc, &m_default_constructor_name,
     766                 :             :                         "Boxed::default_constructor_name");
     767         [ +  + ]:        1586 :     if (m_field_map)
     768                 :          10 :         m_field_map->trace(trc);
     769                 :        1586 : }
     770                 :             : 
     771                 :             : // clang-format off
     772                 :             : const struct JSClassOps BoxedBase::class_ops = {
     773                 :             :     nullptr,  // addProperty
     774                 :             :     nullptr,  // deleteProperty
     775                 :             :     nullptr,  // enumerate
     776                 :             :     &BoxedBase::new_enumerate,
     777                 :             :     &BoxedBase::resolve,
     778                 :             :     nullptr,  // mayResolve
     779                 :             :     &BoxedBase::finalize,
     780                 :             :     nullptr,  // call
     781                 :             :     nullptr,  // construct
     782                 :             :     &BoxedBase::trace
     783                 :             : };
     784                 :             : 
     785                 :             : /* We allocate 1 extra reserved slot; this is typically unused, but if the
     786                 :             :  * boxed is for a nested structure inside a parent structure, the
     787                 :             :  * reserved slot is used to hold onto the parent Javascript object and
     788                 :             :  * make sure it doesn't get freed.
     789                 :             :  */
     790                 :             : const struct JSClass BoxedBase::klass = {
     791                 :             :     "GObject_Boxed",
     792                 :             :     JSCLASS_HAS_RESERVED_SLOTS(2) | JSCLASS_FOREGROUND_FINALIZE,
     793                 :             :     &BoxedBase::class_ops
     794                 :             : };
     795                 :             : // clang-format on
     796                 :             : 
     797                 :        3207 : [[nodiscard]] static bool type_can_be_allocated_directly(
     798                 :             :     GITypeInfo* type_info) {
     799                 :        3207 :     bool is_simple = true;
     800                 :             : 
     801         [ +  + ]:        3207 :     if (g_type_info_is_pointer(type_info)) {
     802   [ +  +  +  -  :        2174 :         if (g_type_info_get_tag(type_info) == GI_TYPE_TAG_ARRAY &&
                   +  + ]
     803                 :         328 :             g_type_info_get_array_type(type_info) == GI_ARRAY_TYPE_C) {
     804                 :             :             GjsAutoTypeInfo param_info =
     805                 :         328 :                 g_type_info_get_param_type(type_info, 0);
     806                 :         328 :             return type_can_be_allocated_directly(param_info);
     807                 :         328 :         }
     808                 :             : 
     809                 :        1518 :         return true;
     810                 :             :     } else {
     811         [ +  + ]:        1361 :         switch (g_type_info_get_tag(type_info)) {
     812                 :         135 :         case GI_TYPE_TAG_INTERFACE:
     813                 :             :             {
     814                 :         135 :             GjsAutoBaseInfo interface = g_type_info_get_interface(type_info);
     815   [ +  -  +  -  :         135 :             switch (interface.type()) {
                      + ]
     816                 :           8 :                 case GI_INFO_TYPE_BOXED:
     817                 :             :                 case GI_INFO_TYPE_STRUCT:
     818                 :           8 :                     return struct_is_simple(interface.as<GIStructInfo>());
     819                 :           0 :                 case GI_INFO_TYPE_UNION:
     820                 :             :                     /* FIXME: Need to implement */
     821                 :           0 :                     is_simple = false;
     822                 :           0 :                     break;
     823                 :           1 :                 case GI_INFO_TYPE_OBJECT:
     824                 :             :                 case GI_INFO_TYPE_VFUNC:
     825                 :             :                 case GI_INFO_TYPE_CALLBACK:
     826                 :             :                 case GI_INFO_TYPE_INVALID:
     827                 :             :                 case GI_INFO_TYPE_INTERFACE:
     828                 :             :                 case GI_INFO_TYPE_FUNCTION:
     829                 :             :                 case GI_INFO_TYPE_CONSTANT:
     830                 :             :                 case GI_INFO_TYPE_VALUE:
     831                 :             :                 case GI_INFO_TYPE_SIGNAL:
     832                 :             :                 case GI_INFO_TYPE_PROPERTY:
     833                 :             :                 case GI_INFO_TYPE_FIELD:
     834                 :             :                 case GI_INFO_TYPE_ARG:
     835                 :             :                 case GI_INFO_TYPE_TYPE:
     836                 :             :                 case GI_INFO_TYPE_UNRESOLVED:
     837                 :           1 :                     is_simple = false;
     838                 :           1 :                     break;
     839                 :           0 :                 case GI_INFO_TYPE_INVALID_0:
     840                 :             :                     g_assert_not_reached();
     841                 :             :                     break;
     842                 :         126 :                 case GI_INFO_TYPE_ENUM:
     843                 :             :                 case GI_INFO_TYPE_FLAGS:
     844                 :             :                 default:
     845                 :         126 :                     break;
     846                 :             :             }
     847                 :         127 :                 break;
     848         [ +  + ]:         135 :             }
     849                 :        1226 :         case GI_TYPE_TAG_BOOLEAN:
     850                 :             :         case GI_TYPE_TAG_INT8:
     851                 :             :         case GI_TYPE_TAG_UINT8:
     852                 :             :         case GI_TYPE_TAG_INT16:
     853                 :             :         case GI_TYPE_TAG_UINT16:
     854                 :             :         case GI_TYPE_TAG_INT32:
     855                 :             :         case GI_TYPE_TAG_UINT32:
     856                 :             :         case GI_TYPE_TAG_INT64:
     857                 :             :         case GI_TYPE_TAG_UINT64:
     858                 :             :         case GI_TYPE_TAG_FLOAT:
     859                 :             :         case GI_TYPE_TAG_DOUBLE:
     860                 :             :         case GI_TYPE_TAG_UNICHAR:
     861                 :             :         case GI_TYPE_TAG_VOID:
     862                 :             :         case GI_TYPE_TAG_GTYPE:
     863                 :             :         case GI_TYPE_TAG_ERROR:
     864                 :             :         case GI_TYPE_TAG_UTF8:
     865                 :             :         case GI_TYPE_TAG_FILENAME:
     866                 :             :         case GI_TYPE_TAG_ARRAY:
     867                 :             :         case GI_TYPE_TAG_GLIST:
     868                 :             :         case GI_TYPE_TAG_GSLIST:
     869                 :             :         case GI_TYPE_TAG_GHASH:
     870                 :             :         default:
     871                 :        1226 :             break;
     872                 :             :         }
     873                 :             :     }
     874                 :        1353 :     return is_simple;
     875                 :             : }
     876                 :             : 
     877                 :             : [[nodiscard]] static bool simple_struct_has_pointers(GIStructInfo*);
     878                 :             : 
     879                 :         535 : [[nodiscard]] static bool direct_allocation_has_pointers(
     880                 :             :     GITypeInfo* type_info) {
     881         [ +  + ]:         535 :     if (g_type_info_is_pointer(type_info)) {
     882   [ -  +  -  -  :         239 :         if (g_type_info_get_tag(type_info) == GI_TYPE_TAG_ARRAY &&
                   -  + ]
     883                 :           0 :             g_type_info_get_array_type(type_info) == GI_ARRAY_TYPE_C) {
     884                 :             :             GjsAutoTypeInfo param_info =
     885                 :           0 :                 g_type_info_get_param_type(type_info, 0);
     886                 :           0 :             return direct_allocation_has_pointers(param_info);
     887                 :           0 :         }
     888                 :             : 
     889                 :         239 :         return g_type_info_get_tag(type_info) != GI_TYPE_TAG_VOID;
     890                 :             :     }
     891                 :             : 
     892         [ +  + ]:         296 :     if (g_type_info_get_tag(type_info) != GI_TYPE_TAG_INTERFACE)
     893                 :         263 :         return false;
     894                 :             : 
     895                 :          33 :     GjsAutoBaseInfo interface = g_type_info_get_interface(type_info);
     896   [ +  -  +  +  :          66 :     if (interface.type() == GI_INFO_TYPE_BOXED ||
                   +  + ]
     897                 :          33 :         interface.type() == GI_INFO_TYPE_STRUCT)
     898                 :           3 :         return simple_struct_has_pointers(interface.as<GIStructInfo>());
     899                 :             : 
     900                 :          30 :     return false;
     901                 :          33 : }
     902                 :             : 
     903                 :             : /* Check if the type of the boxed is "simple" - every field is a non-pointer
     904                 :             :  * type that we know how to assign to. If so, then we can allocate and free
     905                 :             :  * instances without needing a constructor.
     906                 :             :  */
     907                 :         954 : [[nodiscard]] static bool struct_is_simple(GIStructInfo* info) {
     908                 :         954 :     int n_fields = g_struct_info_get_n_fields(info);
     909                 :         954 :     bool is_simple = true;
     910                 :             :     int i;
     911                 :             : 
     912                 :             :     /* If it's opaque, it's not simple */
     913         [ +  + ]:         954 :     if (n_fields == 0)
     914                 :         493 :         return false;
     915                 :             : 
     916   [ +  +  +  + ]:        3340 :     for (i = 0; i < n_fields && is_simple; i++) {
     917                 :        2879 :         GjsAutoFieldInfo field_info = g_struct_info_get_field(info, i);
     918                 :        2879 :         GjsAutoTypeInfo type_info = g_field_info_get_type(field_info);
     919                 :             : 
     920                 :        2879 :         is_simple = type_can_be_allocated_directly(type_info);
     921                 :        2879 :     }
     922                 :             : 
     923                 :         461 :     return is_simple;
     924                 :             : }
     925                 :             : 
     926                 :         218 : [[nodiscard]] static bool simple_struct_has_pointers(GIStructInfo* info) {
     927                 :         218 :     g_assert(struct_is_simple(info) &&
     928                 :             :              "Don't call simple_struct_has_pointers() on a non-simple struct");
     929                 :             : 
     930                 :         218 :     int n_fields = g_struct_info_get_n_fields(info);
     931                 :         218 :     g_assert(n_fields > 0);
     932                 :             : 
     933         [ +  + ]:         567 :     for (int i = 0; i < n_fields; i++) {
     934                 :         535 :         GjsAutoFieldInfo field_info = g_struct_info_get_field(info, i);
     935                 :         535 :         GjsAutoTypeInfo type_info = g_field_info_get_type(field_info);
     936         [ +  + ]:         535 :         if (direct_allocation_has_pointers(type_info))
     937                 :         186 :             return true;
     938   [ +  +  +  + ]:         721 :     }
     939                 :          32 :     return false;
     940                 :             : }
     941                 :             : 
     942                 :         709 : BoxedPrototype::BoxedPrototype(GIStructInfo* info, GType gtype)
     943                 :             :     : GIWrapperPrototype(info, gtype),
     944                 :         709 :       m_zero_args_constructor(-1),
     945                 :         709 :       m_default_constructor(-1),
     946                 :         709 :       m_default_constructor_name(JS::PropertyKey::Void()),
     947                 :        1418 :       m_can_allocate_directly(struct_is_simple(info)) {
     948         [ +  + ]:         709 :     if (!m_can_allocate_directly) {
     949                 :         494 :         m_can_allocate_directly_without_pointers = false;
     950                 :             :     } else {
     951                 :         215 :         m_can_allocate_directly_without_pointers =
     952                 :         215 :             !simple_struct_has_pointers(info);
     953                 :             :     }
     954                 :         709 :     GJS_INC_COUNTER(boxed_prototype);
     955                 :         709 : }
     956                 :             : 
     957                 :             : // Overrides GIWrapperPrototype::init().
     958                 :         709 : bool BoxedPrototype::init(JSContext* context) {
     959                 :             :     int i, n_methods;
     960                 :         709 :     int first_constructor = -1;
     961                 :         709 :     jsid first_constructor_name = JS::PropertyKey::Void();
     962                 :         709 :     jsid zero_args_constructor_name = JS::PropertyKey::Void();
     963                 :             : 
     964         [ +  + ]:         709 :     if (m_gtype != G_TYPE_NONE) {
     965                 :             :         /* If the structure is registered as a boxed, we can create a new instance by
     966                 :             :          * looking for a zero-args constructor and calling it; constructors don't
     967                 :             :          * really make sense for non-boxed types, since there is no memory management
     968                 :             :          * for the return value.
     969                 :             :          */
     970                 :         667 :         n_methods = g_struct_info_get_n_methods(m_info);
     971                 :             : 
     972         [ +  + ]:       13604 :         for (i = 0; i < n_methods; ++i) {
     973                 :             :             GIFunctionInfoFlags flags;
     974                 :             : 
     975                 :       12937 :             GjsAutoFunctionInfo func_info = g_struct_info_get_method(m_info, i);
     976                 :             : 
     977                 :       12937 :             flags = g_function_info_get_flags(func_info);
     978         [ +  + ]:       12937 :             if ((flags & GI_FUNCTION_IS_CONSTRUCTOR) != 0) {
     979         [ +  + ]:        2190 :                 if (first_constructor < 0) {
     980                 :         529 :                     first_constructor = i;
     981                 :             :                     first_constructor_name =
     982                 :         529 :                         gjs_intern_string_to_id(context, func_info.name());
     983         [ -  + ]:         529 :                     if (first_constructor_name.isVoid())
     984                 :           0 :                         return false;
     985                 :             :                 }
     986                 :             : 
     987   [ +  +  +  +  :        4372 :                 if (m_zero_args_constructor < 0 &&
                   +  + ]
     988                 :        2182 :                     g_callable_info_get_n_args(func_info) == 0) {
     989                 :          11 :                     m_zero_args_constructor = i;
     990                 :             :                     zero_args_constructor_name =
     991                 :          11 :                         gjs_intern_string_to_id(context, func_info.name());
     992         [ -  + ]:          11 :                     if (zero_args_constructor_name.isVoid())
     993                 :           0 :                         return false;
     994                 :             :                 }
     995                 :             : 
     996   [ +  +  +  + ]:        4208 :                 if (m_default_constructor < 0 &&
     997         [ +  + ]:        2018 :                     strcmp(func_info.name(), "new") == 0) {
     998                 :         380 :                     m_default_constructor = i;
     999                 :         380 :                     const GjsAtoms& atoms = GjsContextPrivate::atoms(context);
    1000                 :         380 :                     m_default_constructor_name = atoms.new_();
    1001                 :             :                 }
    1002                 :             :             }
    1003         [ +  - ]:       12937 :         }
    1004                 :             : 
    1005         [ +  + ]:         667 :         if (m_default_constructor < 0) {
    1006                 :         287 :             m_default_constructor = m_zero_args_constructor;
    1007                 :         287 :             m_default_constructor_name = zero_args_constructor_name;
    1008                 :             :         }
    1009         [ +  + ]:         667 :         if (m_default_constructor < 0) {
    1010                 :         287 :             m_default_constructor = first_constructor;
    1011                 :         287 :             m_default_constructor_name = first_constructor_name;
    1012                 :             :         }
    1013                 :             :     }
    1014                 :             : 
    1015                 :         709 :     return true;
    1016                 :             : }
    1017                 :             : 
    1018                 :             : /*
    1019                 :             :  * BoxedPrototype::define_class:
    1020                 :             :  * @in_object: Object where the constructor is stored, typically a repo object.
    1021                 :             :  * @info: Introspection info for the boxed class.
    1022                 :             :  *
    1023                 :             :  * Define a boxed class constructor and prototype, including all the necessary
    1024                 :             :  * methods and properties.
    1025                 :             :  */
    1026                 :         709 : bool BoxedPrototype::define_class(JSContext* context,
    1027                 :             :                                   JS::HandleObject in_object,
    1028                 :             :                                   GIStructInfo* info) {
    1029                 :         709 :     JS::RootedObject prototype(context), unused_constructor(context);
    1030                 :         709 :     GType gtype = g_registered_type_info_get_g_type(info);
    1031                 :         709 :     BoxedPrototype* priv = BoxedPrototype::create_class(
    1032                 :             :         context, in_object, info, gtype, &unused_constructor, &prototype);
    1033   [ +  -  -  +  :         709 :     if (!priv || !priv->define_boxed_class_fields(context, prototype))
                   -  + ]
    1034                 :           0 :         return false;
    1035                 :             : 
    1036   [ +  +  -  + ]:         771 :     if (gtype == G_TYPE_ERROR &&
    1037         [ -  + ]:         771 :         !JS_DefineFunction(context, prototype, "toString",
    1038                 :             :                            &ErrorBase::to_string, 0, GJS_MODULE_PROP_FLAGS))
    1039                 :           0 :         return false;
    1040                 :             : 
    1041                 :         709 :     return true;
    1042                 :         709 : }
    1043                 :             : 
    1044                 :             : /* Helper function to make the public API more readable. The overloads are
    1045                 :             :  * specified explicitly in the public API, but the implementation uses
    1046                 :             :  * std::forward in order to avoid duplicating code. */
    1047                 :             : template <typename... Args>
    1048                 :       17235 : JSObject* BoxedInstance::new_for_c_struct_impl(JSContext* cx,
    1049                 :             :                                                GIStructInfo* info, void* gboxed,
    1050                 :             :                                                Args&&... args) {
    1051         [ -  + ]:       17235 :     if (gboxed == NULL)
    1052                 :           0 :         return NULL;
    1053                 :             : 
    1054                 :             :     gjs_debug_marshal(GJS_DEBUG_GBOXED,
    1055                 :             :                       "Wrapping struct %s %p with JSObject",
    1056                 :             :                       g_base_info_get_name((GIBaseInfo *)info), gboxed);
    1057                 :             : 
    1058                 :       17235 :     JS::RootedObject obj(cx, gjs_new_object_with_generic_prototype(cx, info));
    1059         [ -  + ]:       17235 :     if (!obj)
    1060                 :           0 :         return nullptr;
    1061                 :             : 
    1062                 :       17235 :     BoxedInstance* priv = BoxedInstance::new_for_js_object(cx, obj);
    1063         [ -  + ]:       17235 :     if (!priv)
    1064                 :           0 :         return nullptr;
    1065                 :             : 
    1066         [ -  + ]:       17235 :     if (!priv->init_from_c_struct(cx, gboxed, std::forward<Args>(args)...))
    1067                 :           0 :         return nullptr;
    1068                 :             : 
    1069   [ +  +  -  +  :       17235 :     if (priv->gtype() == G_TYPE_ERROR && !gjs_define_error_properties(cx, obj))
                   -  + ]
    1070                 :           0 :         return nullptr;
    1071                 :             : 
    1072                 :       17235 :     return obj;
    1073                 :       17235 : }
    1074                 :             : 
    1075                 :             : /*
    1076                 :             :  * BoxedInstance::new_for_c_struct:
    1077                 :             :  *
    1078                 :             :  * Creates a new BoxedInstance JS object from a C boxed struct pointer.
    1079                 :             :  *
    1080                 :             :  * There are two overloads of this method; the NoCopy overload will simply take
    1081                 :             :  * the passed-in pointer but not own it, while the normal method will take a
    1082                 :             :  * reference, or if the boxed type can be directly allocated, copy the memory.
    1083                 :             :  */
    1084                 :       17224 : JSObject* BoxedInstance::new_for_c_struct(JSContext* cx, GIStructInfo* info,
    1085                 :             :                                           void* gboxed) {
    1086                 :       17224 :     return new_for_c_struct_impl(cx, info, gboxed);
    1087                 :             : }
    1088                 :             : 
    1089                 :          11 : JSObject* BoxedInstance::new_for_c_struct(JSContext* cx, GIStructInfo* info,
    1090                 :             :                                           void* gboxed, NoCopy no_copy) {
    1091                 :          11 :     return new_for_c_struct_impl(cx, info, gboxed, no_copy);
    1092                 :             : }
    1093                 :             : 
    1094                 :             : /*
    1095                 :             :  * BoxedInstance::init_from_c_struct:
    1096                 :             :  *
    1097                 :             :  * Do the necessary initialization when creating a BoxedInstance JS object from
    1098                 :             :  * a C boxed struct pointer.
    1099                 :             :  *
    1100                 :             :  * There are two overloads of this method; the NoCopy overload will simply take
    1101                 :             :  * the passed-in pointer, while the normal method will take a reference, or if
    1102                 :             :  * the boxed type can be directly allocated, copy the memory.
    1103                 :             :  */
    1104                 :          11 : bool BoxedInstance::init_from_c_struct(JSContext*, void* gboxed, NoCopy) {
    1105                 :             :     // We need to create a JS Boxed which references the original C struct, not
    1106                 :             :     // a copy of it. Used for G_SIGNAL_TYPE_STATIC_SCOPE.
    1107                 :          11 :     share_ptr(gboxed);
    1108                 :          11 :     debug_lifecycle("Boxed pointer acquired, memory not owned");
    1109                 :          11 :     return true;
    1110                 :             : }
    1111                 :             : 
    1112                 :       17224 : bool BoxedInstance::init_from_c_struct(JSContext* cx, void* gboxed) {
    1113   [ +  +  +  -  :       17224 :     if (gtype() != G_TYPE_NONE && g_type_is_a(gtype(), G_TYPE_BOXED)) {
             +  +  +  + ]
    1114                 :       13812 :         copy_boxed(gboxed);
    1115                 :       13812 :         return true;
    1116         [ +  + ]:        3412 :     } else if (gtype() == G_TYPE_VARIANT) {
    1117                 :        3387 :         own_ptr(g_variant_ref_sink(static_cast<GVariant*>(gboxed)));
    1118                 :        3387 :         debug_lifecycle("Boxed pointer created by sinking GVariant ref");
    1119                 :        3387 :         return true;
    1120         [ +  - ]:          25 :     } else if (get_prototype()->can_allocate_directly()) {
    1121                 :          25 :         copy_memory(gboxed);
    1122                 :          25 :         return true;
    1123                 :             :     }
    1124                 :             : 
    1125                 :           0 :     gjs_throw(cx, "Can't create a Javascript object for %s; no way to copy",
    1126                 :             :               name());
    1127                 :           0 :     return false;
    1128                 :             : }
    1129                 :             : 
    1130                 :         107 : void* BoxedInstance::copy_ptr(JSContext* cx, GType gtype, void* ptr) {
    1131   [ +  -  +  -  :         107 :     if (g_type_is_a(gtype, G_TYPE_BOXED))
                   +  - ]
    1132                 :         107 :         return g_boxed_copy(gtype, ptr);
    1133   [ #  #  #  #  :           0 :     if (g_type_is_a(gtype, G_TYPE_VARIANT))
                   #  # ]
    1134                 :           0 :         return g_variant_ref(static_cast<GVariant*>(ptr));
    1135                 :             : 
    1136                 :           0 :     gjs_throw(cx,
    1137                 :             :               "Can't transfer ownership of a structure type not registered as "
    1138                 :             :               "boxed");
    1139                 :           0 :     return nullptr;
    1140                 :             : }
        

Generated by: LCOV version 2.0-1