LCOV - code coverage report
Current view: top level - gi - value.cpp (source / functions) Coverage Total Hit
Test: gjs- Code Coverage Lines: 72.1 % 659 475
Test Date: 2024-04-29 05:18:28 Functions: 100.0 % 13 13
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 68.7 % 611 420

             Branch data     Line data    Source code
       1                 :             : /* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; -*- */
       2                 :             : // SPDX-License-Identifier: MIT OR LGPL-2.0-or-later
       3                 :             : // SPDX-FileCopyrightText: 2008 litl, LLC
       4                 :             : 
       5                 :             : #include <config.h>
       6                 :             : 
       7                 :             : #include <stddef.h>  // for NULL
       8                 :             : #include <stdint.h>
       9                 :             : 
      10                 :             : #include <sstream>
      11                 :             : #include <string>
      12                 :             : 
      13                 :             : #include <girepository.h>
      14                 :             : #include <glib-object.h>
      15                 :             : #include <glib.h>
      16                 :             : 
      17                 :             : #include <js/Array.h>
      18                 :             : #include <js/BigInt.h>
      19                 :             : #include <js/CharacterEncoding.h>
      20                 :             : #include <js/Conversions.h>
      21                 :             : #include <js/Exception.h>
      22                 :             : #include <js/GCVector.h>  // for RootedVector
      23                 :             : #include <js/Realm.h>
      24                 :             : #include <js/RootingAPI.h>
      25                 :             : #include <js/TypeDecls.h>
      26                 :             : #include <js/Utility.h>  // for UniqueChars
      27                 :             : #include <js/Value.h>
      28                 :             : #include <js/ValueArray.h>
      29                 :             : #include <js/experimental/TypedData.h>
      30                 :             : #include <jsapi.h>  // for InformalValueTypeName, JS_Get...
      31                 :             : #include <jsfriendapi.h>  // for JS_GetObjectFunction
      32                 :             : 
      33                 :             : #include "gi/arg-inl.h"
      34                 :             : #include "gi/arg.h"
      35                 :             : #include "gi/boxed.h"
      36                 :             : #include "gi/closure.h"
      37                 :             : #include "gi/foreign.h"
      38                 :             : #include "gi/fundamental.h"
      39                 :             : #include "gi/gerror.h"
      40                 :             : #include "gi/gtype.h"
      41                 :             : #include "gi/js-value-inl.h"
      42                 :             : #include "gi/object.h"
      43                 :             : #include "gi/param.h"
      44                 :             : #include "gi/repo.h"
      45                 :             : #include "gi/union.h"
      46                 :             : #include "gi/value.h"
      47                 :             : #include "gi/wrapperutils.h"
      48                 :             : #include "gjs/byteArray.h"
      49                 :             : #include "gjs/context-private.h"
      50                 :             : #include "gjs/jsapi-util.h"
      51                 :             : #include "gjs/macros.h"
      52                 :             : #include "gjs/objectbox.h"
      53                 :             : #include "util/log.h"
      54                 :             : 
      55                 :             : GJS_JSAPI_RETURN_CONVENTION
      56                 :             : static bool gjs_value_from_g_value_internal(JSContext*, JS::MutableHandleValue,
      57                 :             :                                             const GValue*, bool no_copy = false,
      58                 :             :                                             bool is_introspected_signal = false,
      59                 :             :                                             GIArgInfo* = nullptr,
      60                 :             :                                             GITypeInfo* = nullptr);
      61                 :             : 
      62                 :             : GJS_JSAPI_RETURN_CONVENTION
      63                 :           7 : static bool gjs_arg_set_from_gvalue(JSContext* cx, GIArgument* arg,
      64                 :             :                                     const GValue* value) {
      65   [ -  -  -  -  :           7 :     switch (G_VALUE_TYPE(value)) {
          -  -  -  -  -  
          -  -  -  -  -  
                      + ]
      66                 :           0 :         case G_TYPE_CHAR:
      67                 :           0 :             gjs_arg_set(arg, g_value_get_schar(value));
      68                 :           0 :             return true;
      69                 :           0 :         case G_TYPE_UCHAR:
      70                 :           0 :             gjs_arg_set(arg, g_value_get_uchar(value));
      71                 :           0 :             return true;
      72                 :           0 :         case G_TYPE_BOOLEAN:
      73                 :           0 :             gjs_arg_set(arg, g_value_get_boolean(value));
      74                 :           0 :             return true;
      75                 :           0 :         case G_TYPE_INT:
      76                 :           0 :             gjs_arg_set(arg, g_value_get_int(value));
      77                 :           0 :             return true;
      78                 :           0 :         case G_TYPE_UINT:
      79                 :           0 :             gjs_arg_set(arg, g_value_get_uint(value));
      80                 :           0 :             return true;
      81                 :           0 :         case G_TYPE_LONG:
      82                 :           0 :             gjs_arg_set<long, GJS_TYPE_TAG_LONG>(  // NOLINT(runtime/int)
      83                 :             :                 arg, g_value_get_long(value));
      84                 :           0 :             return true;
      85                 :           0 :         case G_TYPE_ULONG:
      86                 :             :             gjs_arg_set<unsigned long,  // NOLINT(runtime/int)
      87                 :           0 :                         GJS_TYPE_TAG_LONG>(arg, g_value_get_ulong(value));
      88                 :           0 :             return true;
      89                 :           0 :         case G_TYPE_INT64:
      90                 :           0 :             gjs_arg_set(arg, int64_t{g_value_get_int64(value)});
      91                 :           0 :             return true;
      92                 :           0 :         case G_TYPE_UINT64:
      93                 :           0 :             gjs_arg_set(arg, uint64_t{g_value_get_uint64(value)});
      94                 :           0 :             return true;
      95                 :           0 :         case G_TYPE_FLOAT:
      96                 :           0 :             gjs_arg_set(arg, g_value_get_float(value));
      97                 :           0 :             return true;
      98                 :           0 :         case G_TYPE_DOUBLE:
      99                 :           0 :             gjs_arg_set(arg, g_value_get_double(value));
     100                 :           0 :             return true;
     101                 :           0 :         case G_TYPE_STRING:
     102                 :           0 :             gjs_arg_set(arg, g_value_get_string(value));
     103                 :           0 :             return true;
     104                 :           0 :         case G_TYPE_POINTER:
     105                 :           0 :             gjs_arg_set(arg, g_value_get_pointer(value));
     106                 :           0 :             return true;
     107                 :           0 :         case G_TYPE_VARIANT:
     108                 :           0 :             gjs_arg_set(arg, g_value_get_variant(value));
     109                 :           0 :             return true;
     110                 :           7 :         default: {
     111         [ +  - ]:           7 :             if (g_value_fits_pointer(value)) {
     112                 :           7 :                 gjs_arg_set(arg, g_value_peek_pointer(value));
     113                 :           7 :                 return true;
     114                 :             :             }
     115                 :             : 
     116                 :           0 :             GType gtype = G_VALUE_TYPE(value);
     117                 :             : 
     118   [ #  #  #  #  :           0 :             if (g_type_is_a(gtype, G_TYPE_FLAGS)) {
                   #  # ]
     119                 :           0 :                 gjs_arg_set(arg, g_value_get_flags(value));
     120                 :           0 :                 return true;
     121                 :             :             }
     122                 :             : 
     123   [ #  #  #  #  :           0 :             if (g_type_is_a(gtype, G_TYPE_ENUM)) {
                   #  # ]
     124                 :           0 :                 gjs_arg_set(arg, g_value_get_enum(value));
     125                 :           0 :                 return true;
     126                 :             :             }
     127                 :             : 
     128   [ #  #  #  #  :           0 :             if (g_type_is_a(gtype, G_TYPE_GTYPE)) {
                   #  # ]
     129                 :           0 :                 gjs_arg_set<GType, GI_TYPE_TAG_GTYPE>(arg,
     130                 :             :                                                       g_value_get_gtype(value));
     131                 :           0 :                 return true;
     132                 :             :             }
     133                 :             : 
     134   [ #  #  #  #  :           0 :             if (g_type_is_a(gtype, G_TYPE_PARAM)) {
                   #  # ]
     135                 :           0 :                 gjs_arg_set(arg, g_value_get_param(value));
     136                 :           0 :                 return true;
     137                 :             :             }
     138                 :             :         }
     139                 :             :     }
     140                 :             : 
     141                 :           0 :     gjs_throw(cx, "No know GArgument conversion for %s",
     142                 :             :               G_VALUE_TYPE_NAME(value));
     143                 :           0 :     return false;
     144                 :             : }
     145                 :             : 
     146                 :             : GJS_JSAPI_RETURN_CONVENTION
     147                 :           7 : static bool maybe_release_signal_value(JSContext* cx,
     148                 :             :                                        GjsAutoArgInfo const& arg_info,
     149                 :             :                                        GITypeInfo* type_info,
     150                 :             :                                        const GValue* gvalue,
     151                 :             :                                        GITransfer transfer) {
     152         [ -  + ]:           7 :     if (transfer == GI_TRANSFER_NOTHING)
     153                 :           0 :         return true;
     154                 :             : 
     155                 :             :     GIArgument arg;
     156         [ -  + ]:           7 :     if (!gjs_arg_set_from_gvalue(cx, &arg, gvalue))
     157                 :           0 :         return false;
     158                 :             : 
     159         [ -  + ]:           7 :     if (!gjs_gi_argument_release(cx, transfer, type_info,
     160                 :             :                                  GjsArgumentFlags::ARG_OUT, &arg)) {
     161                 :           0 :         gjs_throw(cx, "Cannot release argument %s value, we're gonna leak!",
     162                 :             :                   arg_info.name());
     163                 :           0 :         return false;
     164                 :             :     }
     165                 :             : 
     166                 :           7 :     return true;
     167                 :             : }
     168                 :             : 
     169                 :             : /*
     170                 :             :  * Gets signal introspection info about closure, or NULL if not found. Currently
     171                 :             :  * only works for signals on introspected GObjects, not signals on GJS-defined
     172                 :             :  * GObjects nor standalone closures. The return value must be unreffed.
     173                 :             :  */
     174                 :        8418 : [[nodiscard]] static GjsAutoSignalInfo get_signal_info_if_available(
     175                 :             :     GSignalQuery* signal_query) {
     176         [ +  + ]:        8418 :     if (!signal_query->itype)
     177                 :        8047 :         return nullptr;
     178                 :             : 
     179                 :             :     GjsAutoBaseInfo obj =
     180                 :         371 :         g_irepository_find_by_gtype(nullptr, signal_query->itype);
     181         [ +  + ]:         371 :     if (!obj)
     182                 :          66 :         return nullptr;
     183                 :             : 
     184                 :         305 :     GIInfoType info_type = obj.type();
     185         [ +  + ]:         305 :     if (info_type == GI_INFO_TYPE_OBJECT)
     186                 :         304 :         return g_object_info_find_signal(obj, signal_query->signal_name);
     187         [ +  - ]:           1 :     else if (info_type == GI_INFO_TYPE_INTERFACE)
     188                 :           1 :         return g_interface_info_find_signal(obj, signal_query->signal_name);
     189                 :             : 
     190                 :           0 :     return nullptr;
     191                 :         371 : }
     192                 :             : 
     193                 :             : /*
     194                 :             :  * Fill in value_p with a JS array, converted from a C array stored as a pointer
     195                 :             :  * in array_value, with its length stored in array_length_value.
     196                 :             :  */
     197                 :             : GJS_JSAPI_RETURN_CONVENTION
     198                 :           1 : static bool gjs_value_from_array_and_length_values(
     199                 :             :     JSContext* context, JS::MutableHandleValue value_p,
     200                 :             :     GITypeInfo* array_type_info, const GValue* array_value,
     201                 :             :     GIArgInfo* array_length_arg_info, GITypeInfo* array_length_type_info,
     202                 :             :     const GValue* array_length_value, bool no_copy,
     203                 :             :     bool is_introspected_signal) {
     204                 :           1 :     JS::RootedValue array_length(context);
     205                 :             : 
     206                 :           1 :     g_assert(G_VALUE_HOLDS_POINTER(array_value));
     207                 :           1 :     g_assert(G_VALUE_HOLDS_INT(array_length_value));
     208                 :             : 
     209         [ -  + ]:           1 :     if (!gjs_value_from_g_value_internal(
     210                 :             :             context, &array_length, array_length_value, no_copy, is_introspected_signal,
     211                 :             :             array_length_arg_info, array_length_type_info))
     212                 :           0 :         return false;
     213                 :             : 
     214                 :             :     GIArgument array_arg;
     215                 :           1 :     gjs_arg_set(&array_arg, g_value_get_pointer(array_value));
     216                 :             : 
     217         [ -  + ]:           1 :     return gjs_value_from_explicit_array(
     218                 :             :         context, value_p, array_type_info,
     219                 :             :         no_copy ? GI_TRANSFER_NOTHING : GI_TRANSFER_EVERYTHING, &array_arg,
     220                 :           1 :         array_length.toInt32());
     221                 :           1 : }
     222                 :             : 
     223                 :             : // FIXME(3v1n0): Move into closure.cpp one day...
     224                 :        8418 : void Gjs::Closure::marshal(GValue* return_value, unsigned n_param_values,
     225                 :             :                            const GValue* param_values, void* invocation_hint,
     226                 :             :                            void* marshal_data) {
     227                 :             :     JSContext *context;
     228                 :             :     unsigned i;
     229                 :        8418 :     GSignalQuery signal_query = { 0, };
     230                 :             : 
     231                 :             :     gjs_debug_marshal(GJS_DEBUG_GCLOSURE, "Marshal closure %p", this);
     232                 :             : 
     233         [ -  + ]:        8418 :     if (!is_valid()) {
     234                 :             :         /* We were destroyed; become a no-op */
     235                 :           8 :         return;
     236                 :             :     }
     237                 :             : 
     238                 :        8418 :     context = m_cx;
     239                 :        8418 :     GjsContextPrivate* gjs = GjsContextPrivate::from_cx(context);
     240         [ -  + ]:        8418 :     if (G_UNLIKELY(gjs->sweeping())) {
     241                 :           0 :         GSignalInvocationHint *hint = (GSignalInvocationHint*) invocation_hint;
     242                 :           0 :         std::ostringstream message;
     243                 :             : 
     244                 :             :         message << "Attempting to call back into JSAPI during the sweeping "
     245                 :             :                    "phase of GC. This is most likely caused by not destroying "
     246                 :             :                    "a Clutter actor or Gtk+ widget with ::destroy signals "
     247                 :             :                    "connected, but can also be caused by using the destroy(), "
     248                 :             :                    "dispose(), or remove() vfuncs. Because it would crash the "
     249                 :             :                    "application, it has been blocked and the JS callback not "
     250                 :           0 :                    "invoked.";
     251         [ #  # ]:           0 :         if (hint) {
     252                 :             :             gpointer instance;
     253                 :           0 :             g_signal_query(hint->signal_id, &signal_query);
     254                 :             : 
     255                 :           0 :             instance = g_value_peek_pointer(&param_values[0]);
     256                 :             :             message << "\nThe offending signal was " << signal_query.signal_name
     257                 :           0 :                     << " on " << g_type_name(G_TYPE_FROM_INSTANCE(instance))
     258                 :           0 :                     << " " << instance << ".";
     259                 :             :         }
     260                 :           0 :         message << "\n" << gjs_dumpstack_string();
     261                 :           0 :         g_critical("%s", message.str().c_str());
     262                 :           0 :         return;
     263                 :           0 :     }
     264                 :             : 
     265                 :        8418 :     JSAutoRealm ar(context, callable());
     266                 :             : 
     267         [ +  + ]:        8418 :     if (marshal_data) {
     268                 :             :         /* we are used for a signal handler */
     269                 :             :         guint signal_id;
     270                 :             : 
     271                 :         371 :         signal_id = GPOINTER_TO_UINT(marshal_data);
     272                 :             : 
     273                 :         371 :         g_signal_query(signal_id, &signal_query);
     274                 :             : 
     275         [ -  + ]:         371 :         if (!signal_query.signal_id) {
     276                 :           0 :             gjs_debug(GJS_DEBUG_GCLOSURE,
     277                 :             :                       "Signal handler being called on invalid signal");
     278                 :           0 :             return;
     279                 :             :         }
     280                 :             : 
     281         [ -  + ]:         371 :         if (signal_query.n_params + 1 != n_param_values) {
     282                 :           0 :             gjs_debug(GJS_DEBUG_GCLOSURE,
     283                 :             :                       "Signal handler being called with wrong number of parameters");
     284                 :           0 :             return;
     285                 :             :         }
     286                 :             :     }
     287                 :             : 
     288                 :             :     /* Check if any parameters, such as array lengths, need to be eliminated
     289                 :             :      * before we invoke the closure.
     290                 :             :      */
     291                 :             :     struct ArgumentDetails {
     292                 :             :         int array_len_index_for = -1;
     293                 :             :         bool skip = false;
     294                 :             :         GITypeInfo type_info;
     295                 :             :         GjsAutoArgInfo arg_info;
     296                 :             :     };
     297                 :        8418 :     std::vector<ArgumentDetails> args_details(n_param_values);
     298                 :        8418 :     bool needs_cleanup = false;
     299                 :             : 
     300                 :        8418 :     GjsAutoSignalInfo signal_info = get_signal_info_if_available(&signal_query);
     301         [ +  + ]:        8418 :     if (signal_info) {
     302                 :             :         /* Start at argument 1, skip the instance parameter */
     303         [ +  + ]:         693 :         for (i = 1; i < n_param_values; ++i) {
     304                 :             :             int array_len_pos;
     305                 :             : 
     306                 :         388 :             ArgumentDetails& arg_details = args_details[i];
     307                 :         388 :             arg_details.arg_info = g_callable_info_get_arg(signal_info, i - 1);
     308                 :         388 :             g_arg_info_load_type(arg_details.arg_info, &arg_details.type_info);
     309                 :             : 
     310                 :             :             array_len_pos =
     311                 :         388 :                 g_type_info_get_array_length(&arg_details.type_info);
     312         [ +  + ]:         388 :             if (array_len_pos != -1) {
     313                 :           1 :                 args_details[array_len_pos + 1].skip = true;
     314                 :           1 :                 arg_details.array_len_index_for = array_len_pos + 1;
     315                 :             :             }
     316                 :             : 
     317   [ +  -  +  +  :         776 :             if (!needs_cleanup &&
                   +  + ]
     318                 :         388 :                 g_arg_info_get_ownership_transfer(arg_details.arg_info) !=
     319                 :             :                     GI_TRANSFER_NOTHING)
     320                 :           7 :                 needs_cleanup = true;
     321                 :             :         }
     322                 :             :     }
     323                 :             : 
     324                 :        8418 :     JS::RootedValueVector argv(context);
     325                 :             :     /* May end up being less */
     326         [ -  + ]:        8418 :     if (!argv.reserve(n_param_values))
     327                 :           0 :         g_error("Unable to reserve space");
     328                 :        8418 :     JS::RootedValue argv_to_append(context);
     329                 :        8418 :     bool is_introspected_signal = !!signal_info;
     330         [ +  + ]:        9289 :     for (i = 0; i < n_param_values; ++i) {
     331                 :         871 :         const GValue* gval = &param_values[i];
     332                 :         871 :         ArgumentDetails& arg_details = args_details[i];
     333                 :             :         bool no_copy;
     334                 :             :         bool res;
     335                 :             : 
     336         [ +  + ]:         871 :         if (arg_details.skip)
     337                 :           1 :             continue;
     338                 :             : 
     339                 :         870 :         no_copy = false;
     340                 :             : 
     341   [ +  +  +  + ]:         870 :         if (i >= 1 && signal_query.signal_id) {
     342                 :         436 :             no_copy = (signal_query.param_types[i - 1] & G_SIGNAL_TYPE_STATIC_SCOPE) != 0;
     343                 :             :         }
     344                 :             : 
     345         [ +  + ]:         870 :         if (arg_details.array_len_index_for != -1) {
     346                 :           1 :             const GValue* array_len_gval =
     347                 :           1 :                 &param_values[arg_details.array_len_index_for];
     348                 :             :             ArgumentDetails& array_len_details =
     349                 :           1 :                 args_details[arg_details.array_len_index_for];
     350                 :           1 :             res = gjs_value_from_array_and_length_values(
     351                 :             :                 context, &argv_to_append, &arg_details.type_info, gval,
     352                 :             :                 array_len_details.arg_info, &array_len_details.type_info,
     353                 :             :                 array_len_gval, no_copy, is_introspected_signal);
     354                 :             :         } else {
     355                 :         869 :             res = gjs_value_from_g_value_internal(
     356                 :             :                 context, &argv_to_append, gval, no_copy, is_introspected_signal,
     357                 :             :                 arg_details.arg_info, &arg_details.type_info);
     358                 :             :         }
     359                 :             : 
     360         [ -  + ]:         870 :         if (!res) {
     361                 :           0 :             gjs_debug(GJS_DEBUG_GCLOSURE,
     362                 :             :                       "Unable to convert arg %d in order to invoke closure",
     363                 :             :                       i);
     364                 :           0 :             gjs_log_exception(context);
     365                 :           0 :             return;
     366                 :             :         }
     367                 :             : 
     368                 :         870 :         argv.infallibleAppend(argv_to_append);
     369                 :             :     }
     370                 :             : 
     371                 :        8418 :     JS::RootedValue rval(context);
     372                 :             : 
     373         [ +  + ]:        8418 :     if (!invoke(nullptr, argv, &rval)) {
     374         [ -  + ]:           1 :         if (JS_IsExceptionPending(context)) {
     375                 :           0 :             gjs_log_exception_uncaught(context);
     376                 :             :         } else {
     377                 :             :             // "Uncatchable" exception thrown, we have to exit. This
     378                 :             :             // matches the closure exit handling in function.cpp
     379                 :             :             uint8_t code;
     380         [ +  - ]:           1 :             if (gjs->should_exit(&code))
     381                 :           1 :                 gjs->exit_immediately(code);
     382                 :             : 
     383                 :             :             // Some other uncatchable exception, e.g. out of memory
     384                 :           0 :             JSFunction* fn = JS_GetObjectFunction(callable());
     385                 :             :             std::string descr =
     386                 :           0 :                 fn ? "function " + gjs_debug_string(JS_GetFunctionDisplayId(fn))
     387   [ #  #  #  #  :           0 :                    : "callable object " + gjs_debug_object(callable());
                   #  # ]
     388                 :           0 :             g_error("Call to %s terminated with uncatchable exception",
     389                 :             :                     descr.c_str());
     390                 :             :         }
     391                 :             :     }
     392                 :             : 
     393         [ +  + ]:        8417 :     if (needs_cleanup) {
     394         [ +  + ]:          21 :         for (i = 0; i < n_param_values; ++i) {
     395                 :          14 :             ArgumentDetails& arg_details = args_details[i];
     396         [ +  + ]:          14 :             if (!arg_details.arg_info)
     397                 :           7 :                 continue;
     398                 :             : 
     399                 :             :             GITransfer transfer =
     400                 :           7 :                 g_arg_info_get_ownership_transfer(arg_details.arg_info);
     401                 :             : 
     402         [ -  + ]:           7 :             if (transfer == GI_TRANSFER_NOTHING)
     403                 :           0 :                 continue;
     404                 :             : 
     405         [ -  + ]:           7 :             if (!maybe_release_signal_value(context, arg_details.arg_info,
     406                 :             :                                             &arg_details.type_info,
     407                 :           7 :                                             &param_values[i], transfer)) {
     408                 :           0 :                 gjs_log_exception(context);
     409                 :           0 :                 return;
     410                 :             :             }
     411                 :             :         }
     412                 :             :     }
     413                 :             : 
     414                 :             :     // null return_value means the closure wasn't expected to return a value.
     415                 :             :     // Discard the JS function's return value in that case.
     416         [ +  + ]:        8417 :     if (return_value != NULL) {
     417         [ +  + ]:        8023 :         if (rval.isUndefined()) {
     418                 :             :             // Either an exception was thrown and logged, or the JS function
     419                 :             :             // returned undefined. Leave the GValue uninitialized.
     420                 :             :             // FIXME: not sure what happens on the other side with an
     421                 :             :             // uninitialized GValue!
     422                 :           4 :             return;
     423                 :             :         }
     424                 :             : 
     425         [ +  + ]:        8019 :         if (!gjs_value_to_g_value(context, rval, return_value)) {
     426                 :           4 :             gjs_debug(GJS_DEBUG_GCLOSURE,
     427                 :             :                       "Unable to convert return value when invoking closure");
     428                 :           4 :             gjs_log_exception(context);
     429                 :           4 :             return;
     430                 :             :         }
     431                 :             :     }
     432   [ +  +  +  +  :        8457 : }
          +  +  +  +  +  
                +  +  + ]
     433                 :             : 
     434                 :             : GJS_JSAPI_RETURN_CONVENTION
     435                 :          76 : static bool gjs_value_guess_g_type(JSContext* context, JS::Value value,
     436                 :             :                                    GType* gtype_out) {
     437                 :          76 :     g_assert(gtype_out && "Invalid return location");
     438                 :             : 
     439         [ +  + ]:          76 :     if (value.isNull()) {
     440                 :           1 :         *gtype_out = G_TYPE_POINTER;
     441                 :           1 :         return true;
     442                 :             :     }
     443         [ +  + ]:          75 :     if (value.isString()) {
     444                 :           6 :         *gtype_out = G_TYPE_STRING;
     445                 :           6 :         return true;
     446                 :             :     }
     447         [ +  + ]:          69 :     if (value.isInt32()) {
     448                 :          22 :         *gtype_out = G_TYPE_INT;
     449                 :          22 :         return true;
     450                 :             :     }
     451         [ +  + ]:          47 :     if (value.isDouble()) {
     452                 :           5 :         *gtype_out = G_TYPE_DOUBLE;
     453                 :           5 :         return true;
     454                 :             :     }
     455         [ +  + ]:          42 :     if (value.isBoolean()) {
     456                 :           2 :         *gtype_out = G_TYPE_BOOLEAN;
     457                 :           2 :         return true;
     458                 :             :     }
     459         [ +  + ]:          40 :     if (value.isBigInt()) {
     460                 :             :         // Assume that if the value is negative or within the int64_t limit,
     461                 :             :         // then we're handling a signed integer, otherwise unsigned.
     462                 :             :         int64_t ignored;
     463   [ +  +  +  +  :           5 :         if (JS::BigIntIsNegative(value.toBigInt()) ||
                   +  + ]
     464                 :           2 :             JS::BigIntFits(value.toBigInt(), &ignored))
     465                 :           2 :             *gtype_out = G_TYPE_INT64;
     466                 :             :         else
     467                 :           1 :             *gtype_out = G_TYPE_UINT64;
     468                 :           3 :         return true;
     469                 :             :     }
     470         [ +  - ]:          37 :     if (value.isObject()) {
     471                 :          37 :         JS::RootedObject obj(context, &value.toObject());
     472                 :          37 :         return gjs_gtype_get_actual_gtype(context, obj, gtype_out);
     473                 :          37 :     }
     474                 :             : 
     475                 :           0 :     *gtype_out = G_TYPE_INVALID;
     476                 :           0 :     return true;
     477                 :             : }
     478                 :             : 
     479                 :          27 : static bool throw_expect_type(JSContext* cx, JS::HandleValue value,
     480                 :             :                               const char* expected_type, GType gtype = 0,
     481                 :             :                               bool out_of_range = false) {
     482                 :          27 :     JS::UniqueChars val_str;
     483   [ +  +  +  - ]:          27 :     out_of_range = (out_of_range && value.isNumeric());
     484                 :             : 
     485         [ +  + ]:          27 :     if (out_of_range) {
     486                 :           7 :         JS::RootedString str(cx, JS::ToString(cx, value));
     487         [ +  - ]:           7 :         if (str)
     488                 :           7 :             val_str = JS_EncodeStringToUTF8(cx, str);
     489                 :           7 :     }
     490                 :             : 
     491   [ +  +  +  +  :          52 :     gjs_throw(cx, "Wrong type %s; %s%s%s expected%s%s",
             +  +  +  + ]
     492                 :             :               JS::InformalValueTypeName(value), expected_type, gtype ? " " : "",
     493                 :          18 :               gtype ? g_type_name(gtype) : "",
     494                 :             :               out_of_range ? ". But it's out of range: " : "",
     495                 :           7 :               out_of_range ? val_str.get() : "");
     496                 :          54 :     return false;  /* for convenience */
     497                 :          27 : }
     498                 :             : 
     499                 :             : GJS_JSAPI_RETURN_CONVENTION
     500                 :             : static bool
     501                 :        8967 : gjs_value_to_g_value_internal(JSContext      *context,
     502                 :             :                               JS::HandleValue value,
     503                 :             :                               GValue         *gvalue,
     504                 :             :                               bool            no_copy)
     505                 :             : {
     506                 :             :     GType gtype;
     507                 :        8967 :     bool out_of_range = false;
     508                 :             : 
     509                 :        8967 :     gtype = G_VALUE_TYPE(gvalue);
     510                 :             : 
     511         [ +  + ]:        8967 :     if (value.isObject()) {
     512                 :         230 :         JS::RootedObject obj(context, &value.toObject());
     513                 :             :         GType boxed_gtype;
     514                 :             : 
     515         [ -  + ]:         230 :         if (!gjs_gtype_get_actual_gtype(context, obj, &boxed_gtype))
     516                 :           0 :             return false;
     517                 :             : 
     518                 :             :         // Don't unbox GValue if the GValue's gtype is GObject.Value
     519   [ +  +  -  +  :         230 :         if (g_type_is_a(boxed_gtype, G_TYPE_VALUE) && gtype != G_TYPE_VALUE) {
             +  +  +  + ]
     520         [ -  + ]:           4 :             if (no_copy) {
     521                 :           0 :                 gjs_throw(
     522                 :             :                     context,
     523                 :             :                     "Cannot convert GObject.Value object without copying.");
     524                 :           0 :                 return false;
     525                 :             :             }
     526                 :             : 
     527                 :           4 :             GValue* source = BoxedBase::to_c_ptr<GValue>(context, obj);
     528                 :             :             // Only initialize the value if it doesn't have a type
     529                 :             :             // and our source GValue has been initialized
     530                 :           4 :             GType source_gtype = G_VALUE_TYPE(source);
     531         [ +  - ]:           4 :             if (gtype == 0) {
     532         [ +  + ]:           4 :                 if (source_gtype == 0) {
     533                 :           1 :                     gjs_throw(context,
     534                 :             :                               "GObject.Value is not initialized with a type");
     535                 :           1 :                     return false;
     536                 :             :                 }
     537                 :           3 :                 g_value_init(gvalue, source_gtype);
     538                 :             :             }
     539                 :             : 
     540                 :           3 :             GType dest_gtype = G_VALUE_TYPE(gvalue);
     541         [ -  + ]:           3 :             if (!g_value_type_compatible(source_gtype, dest_gtype)) {
     542                 :           0 :                 gjs_throw(context, "GObject.Value expected GType %s, found %s",
     543                 :             :                           g_type_name(dest_gtype), g_type_name(source_gtype));
     544                 :           0 :                 return false;
     545                 :             :             }
     546                 :             : 
     547                 :           3 :             g_value_copy(source, gvalue);
     548                 :           3 :             return true;
     549                 :             :         }
     550         [ +  + ]:         230 :     }
     551                 :             : 
     552         [ +  + ]:        8963 :     if (gtype == 0) {
     553         [ -  + ]:          66 :         if (!gjs_value_guess_g_type(context, value, &gtype))
     554                 :           0 :             return false;
     555                 :             : 
     556         [ -  + ]:          66 :         if (gtype == G_TYPE_INVALID) {
     557                 :           0 :             gjs_throw(context, "Could not guess unspecified GValue type");
     558                 :           0 :             return false;
     559                 :             :         }
     560                 :             : 
     561                 :             :         gjs_debug_marshal(GJS_DEBUG_GCLOSURE,
     562                 :             :                           "Guessed GValue type %s from JS Value",
     563                 :             :                           g_type_name(gtype));
     564                 :             : 
     565                 :          66 :         g_value_init(gvalue, gtype);
     566                 :             :     }
     567                 :             : 
     568                 :             :     gjs_debug_marshal(GJS_DEBUG_GCLOSURE,
     569                 :             :                       "Converting JS::Value to gtype %s",
     570                 :             :                       g_type_name(gtype));
     571                 :             : 
     572                 :             : 
     573         [ +  + ]:        8963 :     if (gtype == G_TYPE_STRING) {
     574                 :             :         /* Don't use ValueToString since we don't want to just toString()
     575                 :             :          * everything automatically
     576                 :             :          */
     577         [ +  + ]:         109 :         if (value.isNull()) {
     578                 :           3 :             g_value_set_string(gvalue, NULL);
     579         [ +  + ]:         106 :         } else if (value.isString()) {
     580                 :         104 :             JS::RootedString str(context, value.toString());
     581                 :         104 :             JS::UniqueChars utf8_string(JS_EncodeStringToUTF8(context, str));
     582         [ -  + ]:         104 :             if (!utf8_string)
     583                 :           0 :                 return false;
     584                 :             : 
     585                 :         104 :             g_value_set_string(gvalue, utf8_string.get());
     586   [ +  -  +  - ]:         104 :         } else {
     587                 :           2 :             return throw_expect_type(context, value, "string");
     588                 :             :         }
     589         [ +  + ]:        8854 :     } else if (gtype == G_TYPE_CHAR) {
     590                 :             :         int32_t i;
     591                 :          16 :         if (Gjs::js_value_to_c_checked<signed char>(context, value, &i,
     592   [ +  -  +  - ]:          32 :                                                     &out_of_range) &&
     593         [ +  - ]:          16 :             !out_of_range) {
     594                 :          16 :             g_value_set_schar(gvalue, static_cast<signed char>(i));
     595                 :             :         } else {
     596                 :           0 :             return throw_expect_type(context, value, "char", 0, out_of_range);
     597                 :             :         }
     598         [ +  + ]:        8838 :     } else if (gtype == G_TYPE_UCHAR) {
     599                 :             :         uint32_t i;
     600                 :          16 :         if (Gjs::js_value_to_c_checked<unsigned char>(context, value, &i,
     601   [ +  -  +  - ]:          32 :                                                       &out_of_range) &&
     602         [ +  - ]:          16 :             !out_of_range) {
     603                 :          16 :             g_value_set_uchar(gvalue, (unsigned char)i);
     604                 :             :         } else {
     605                 :           0 :             return throw_expect_type(context, value, "unsigned char", 0,
     606                 :           0 :                                      out_of_range);
     607                 :             :         }
     608         [ +  + ]:        8822 :     } else if (gtype == G_TYPE_INT) {
     609                 :             :         gint32 i;
     610         [ +  - ]:         178 :         if (Gjs::js_value_to_c(context, value, &i)) {
     611                 :         178 :             g_value_set_int(gvalue, i);
     612                 :             :         } else {
     613                 :           0 :             return throw_expect_type(context, value, "integer");
     614                 :             :         }
     615         [ +  + ]:        8644 :     } else if (gtype == G_TYPE_INT64) {
     616                 :             :         int64_t i;
     617                 :          35 :         if (Gjs::js_value_to_c_checked<int64_t>(context, value, &i,
     618   [ +  -  +  + ]:          70 :                                                 &out_of_range) &&
     619         [ +  + ]:          35 :             !out_of_range) {
     620                 :          30 :             g_value_set_int64(gvalue, i);
     621                 :             :         } else {
     622                 :           5 :             return throw_expect_type(context, value, "64-bit integer", 0,
     623                 :           5 :                                      out_of_range);
     624                 :             :         }
     625         [ +  + ]:        8609 :     } else if (gtype == G_TYPE_DOUBLE) {
     626                 :             :         gdouble d;
     627         [ +  - ]:          84 :         if (Gjs::js_value_to_c(context, value, &d)) {
     628                 :          84 :             g_value_set_double(gvalue, d);
     629                 :             :         } else {
     630                 :           0 :             return throw_expect_type(context, value, "double");
     631                 :             :         }
     632         [ +  + ]:        8525 :     } else if (gtype == G_TYPE_FLOAT) {
     633                 :             :         gdouble d;
     634                 :          79 :         if (Gjs::js_value_to_c_checked<float>(context, value, &d,
     635   [ +  -  +  - ]:         158 :                                               &out_of_range) &&
     636         [ +  - ]:          79 :             !out_of_range) {
     637                 :          79 :             g_value_set_float(gvalue, d);
     638                 :             :         } else {
     639                 :           0 :             return throw_expect_type(context, value, "float", 0, out_of_range);
     640                 :             :         }
     641         [ +  + ]:        8446 :     } else if (gtype == G_TYPE_UINT) {
     642                 :             :         guint32 i;
     643         [ +  - ]:          17 :         if (Gjs::js_value_to_c(context, value, &i)) {
     644                 :          17 :             g_value_set_uint(gvalue, i);
     645                 :             :         } else {
     646                 :           0 :             return throw_expect_type(context, value, "unsigned integer");
     647                 :             :         }
     648         [ +  + ]:        8429 :     } else if (gtype == G_TYPE_UINT64) {
     649                 :             :         uint64_t i;
     650                 :          22 :         if (Gjs::js_value_to_c_checked<uint64_t>(context, value, &i,
     651   [ +  -  +  + ]:          44 :                                                  &out_of_range) &&
     652         [ +  + ]:          22 :             !out_of_range) {
     653                 :          20 :             g_value_set_uint64(gvalue, i);
     654                 :             :         } else {
     655                 :           2 :             return throw_expect_type(context, value, "unsigned 64-bit integer",
     656                 :           2 :                                      0, out_of_range);
     657                 :             :         }
     658         [ +  + ]:        8407 :     } else if (gtype == G_TYPE_BOOLEAN) {
     659                 :             :         /* JS::ToBoolean() can't fail */
     660                 :        8018 :         g_value_set_boolean(gvalue, JS::ToBoolean(value));
     661   [ +  +  +  +  :         730 :     } else if (g_type_is_a(gtype, G_TYPE_OBJECT) ||
                   +  + ]
     662   [ +  -  -  + ]:         341 :                g_type_is_a(gtype, G_TYPE_INTERFACE)) {
     663                 :             :         GObject *gobj;
     664                 :             : 
     665                 :          48 :         gobj = NULL;
     666         [ +  + ]:          48 :         if (value.isNull()) {
     667                 :             :             /* nothing to do */
     668         [ +  - ]:          45 :         } else if (value.isObject()) {
     669                 :          45 :             JS::RootedObject obj(context, &value.toObject());
     670         [ +  - ]:          90 :             if (!ObjectBase::typecheck(context, obj, nullptr, gtype) ||
     671   [ -  +  -  + ]:          90 :                 !ObjectBase::to_c_ptr(context, obj, &gobj))
     672                 :           0 :                 return false;
     673         [ -  + ]:          45 :             if (!gobj)
     674                 :           0 :                 return true;  // treat disposed object as if value.isNull()
     675         [ +  - ]:          45 :         } else {
     676                 :           0 :             return throw_expect_type(context, value, "object", gtype);
     677                 :             :         }
     678                 :             : 
     679                 :          48 :         g_value_set_object(gvalue, gobj);
     680         [ +  + ]:         341 :     } else if (gtype == G_TYPE_STRV) {
     681         [ -  + ]:           9 :         if (value.isNull())
     682                 :           0 :             return true;
     683                 :             : 
     684                 :             :         bool is_array;
     685         [ -  + ]:           9 :         if (!JS::IsArrayObject(context, value, &is_array))
     686                 :           0 :             return false;
     687         [ -  + ]:           9 :         if (!is_array)
     688                 :           0 :             return throw_expect_type(context, value, "strv");
     689                 :             : 
     690                 :           9 :         JS::RootedObject array_obj(context, &value.toObject());
     691                 :             :         uint32_t length;
     692         [ -  + ]:           9 :         if (!JS::GetArrayLength(context, array_obj, &length))
     693                 :           0 :             return throw_expect_type(context, value, "strv");
     694                 :             : 
     695                 :             :         void* result;
     696         [ -  + ]:           9 :         if (!gjs_array_to_strv(context, value, length, &result))
     697                 :           0 :             return false;
     698                 :             : 
     699                 :           9 :         g_value_take_boxed(gvalue, static_cast<char**>(result));
     700   [ +  -  +  -  :         341 :     } else if (g_type_is_a(gtype, G_TYPE_BOXED)) {
             +  +  +  + ]
     701                 :             :         void *gboxed;
     702                 :             : 
     703                 :         149 :         gboxed = NULL;
     704         [ +  + ]:         149 :         if (value.isNull())
     705                 :          23 :             return true;
     706                 :             : 
     707                 :             :         /* special case GValue */
     708         [ +  + ]:         126 :         if (gtype == G_TYPE_VALUE) {
     709                 :             :             /* explicitly handle values that are already GValues
     710                 :             :                to avoid infinite recursion */
     711         [ +  + ]:          18 :             if (value.isObject()) {
     712                 :          10 :                 JS::RootedObject obj(context, &value.toObject());
     713                 :             :                 GType guessed_gtype;
     714                 :             : 
     715         [ -  + ]:          10 :                 if (!gjs_value_guess_g_type(context, value, &guessed_gtype))
     716                 :           0 :                     return false;
     717                 :             : 
     718         [ +  - ]:          10 :                 if (guessed_gtype == G_TYPE_VALUE) {
     719                 :          10 :                     gboxed = BoxedBase::to_c_ptr<GValue>(context, obj);
     720                 :          10 :                     g_value_set_boxed(gvalue, gboxed);
     721                 :          10 :                     return true;
     722                 :             :                 }
     723         [ -  + ]:          10 :             }
     724                 :             : 
     725                 :           8 :             Gjs::AutoGValue nested_gvalue;
     726         [ -  + ]:           8 :             if (!gjs_value_to_g_value(context, value, &nested_gvalue))
     727                 :           0 :                 return false;
     728                 :             : 
     729                 :           8 :             g_value_set_boxed(gvalue, &nested_gvalue);
     730                 :           8 :             return true;
     731                 :           8 :         }
     732                 :             : 
     733         [ +  + ]:         108 :         if (value.isObject()) {
     734                 :          90 :             JS::RootedObject obj(context, &value.toObject());
     735                 :             : 
     736         [ +  + ]:          90 :             if (gtype == ObjectBox::gtype()) {
     737                 :          35 :                 g_value_set_boxed(gvalue, ObjectBox::boxed(context, obj).get());
     738                 :          35 :                 return true;
     739         [ +  + ]:          55 :             } else if (gtype == G_TYPE_ERROR) {
     740                 :             :                 /* special case GError */
     741                 :           1 :                 gboxed = ErrorBase::to_c_ptr(context, obj);
     742         [ -  + ]:           1 :                 if (!gboxed)
     743                 :           0 :                     return false;
     744         [ +  + ]:          54 :             } else if (gtype == G_TYPE_BYTE_ARRAY) {
     745                 :             :                 /* special case GByteArray */
     746                 :           9 :                 JS::RootedObject obj(context, &value.toObject());
     747         [ +  - ]:           9 :                 if (JS_IsUint8Array(obj)) {
     748                 :           9 :                     g_value_take_boxed(gvalue,
     749                 :           9 :                                        gjs_byte_array_get_byte_array(obj));
     750                 :           9 :                     return true;
     751                 :             :                 }
     752   [ -  +  -  + ]:          54 :             } else if (gtype == G_TYPE_ARRAY) {
     753                 :           0 :                 gjs_throw(context, "Converting %s to GArray is not supported",
     754                 :             :                           JS::InformalValueTypeName(value));
     755                 :           0 :                 return false;
     756         [ -  + ]:          45 :             } else if (gtype == G_TYPE_PTR_ARRAY) {
     757                 :           0 :                 gjs_throw(context, "Converting %s to GArray is not supported",
     758                 :             :                           JS::InformalValueTypeName(value));
     759                 :           0 :                 return false;
     760         [ -  + ]:          45 :             } else if (gtype == G_TYPE_HASH_TABLE) {
     761                 :           0 :                 gjs_throw(context,
     762                 :             :                           "Converting %s to GHashTable is not supported",
     763                 :             :                           JS::InformalValueTypeName(value));
     764                 :           0 :                 return false;
     765                 :             :             } else {
     766                 :             :                 GjsAutoBaseInfo registered =
     767                 :          45 :                     g_irepository_find_by_gtype(nullptr, gtype);
     768                 :             : 
     769                 :             :                 /* We don't necessarily have the typelib loaded when
     770                 :             :                    we first see the structure... */
     771         [ +  - ]:          45 :                 if (registered) {
     772                 :          45 :                     GIInfoType info_type = registered.type();
     773                 :             : 
     774   [ +  +  +  +  :          89 :                     if (info_type == GI_INFO_TYPE_STRUCT &&
                   +  + ]
     775                 :          44 :                         g_struct_info_is_foreign(
     776                 :             :                             registered.as<GIStructInfo>())) {
     777                 :             :                         GIArgument arg;
     778                 :             : 
     779         [ -  + ]:           2 :                         if (!gjs_struct_foreign_convert_to_gi_argument(
     780                 :             :                                 context, value, registered, nullptr,
     781                 :             :                                 GJS_ARGUMENT_ARGUMENT, GI_TRANSFER_NOTHING,
     782                 :             :                                 GjsArgumentFlags::MAY_BE_NULL, &arg))
     783                 :           0 :                             return false;
     784                 :             : 
     785                 :           2 :                         gboxed = gjs_arg_get<void*>(&arg);
     786                 :             :                     }
     787                 :             :                 }
     788                 :             : 
     789                 :             :                 /* First try a union, if that fails,
     790                 :             :                    assume a boxed struct. Distinguishing
     791                 :             :                    which one is expected would require checking
     792                 :             :                    the associated GIBaseInfo, which is not necessary
     793                 :             :                    possible, if e.g. we see the GType without
     794                 :             :                    loading the typelib.
     795                 :             :                 */
     796         [ +  + ]:          45 :                 if (!gboxed) {
     797         [ +  + ]:          43 :                     if (UnionBase::typecheck(context, obj, nullptr, gtype,
     798                 :             :                                              GjsTypecheckNoThrow())) {
     799                 :           1 :                         gboxed = UnionBase::to_c_ptr(context, obj);
     800                 :             :                     } else {
     801         [ -  + ]:          42 :                         if (!BoxedBase::typecheck(context, obj, nullptr, gtype))
     802                 :           0 :                             return false;
     803                 :             : 
     804                 :          42 :                         gboxed = BoxedBase::to_c_ptr(context, obj);
     805                 :             :                     }
     806         [ -  + ]:          43 :                     if (!gboxed)
     807                 :           0 :                         return false;
     808                 :             :                 }
     809         [ +  - ]:          45 :             }
     810         [ +  + ]:          90 :         } else {
     811                 :          18 :             return throw_expect_type(context, value, "boxed type", gtype);
     812                 :             :         }
     813                 :             : 
     814         [ +  + ]:          46 :         if (no_copy)
     815                 :           2 :             g_value_set_static_boxed(gvalue, gboxed);
     816                 :             :         else
     817                 :          44 :             g_value_set_boxed(gvalue, gboxed);
     818         [ +  + ]:         183 :     } else if (gtype == G_TYPE_VARIANT) {
     819                 :          45 :         GVariant *variant = NULL;
     820                 :             : 
     821         [ +  + ]:          45 :         if (value.isNull()) {
     822                 :             :             /* nothing to do */
     823         [ +  - ]:          43 :         } else if (value.isObject()) {
     824                 :          43 :             JS::RootedObject obj(context, &value.toObject());
     825                 :             : 
     826         [ -  + ]:          43 :             if (!BoxedBase::typecheck(context, obj, nullptr, G_TYPE_VARIANT))
     827                 :           0 :                 return false;
     828                 :             : 
     829                 :          43 :             variant = BoxedBase::to_c_ptr<GVariant>(context, obj);
     830         [ -  + ]:          43 :             if (!variant)
     831                 :           0 :                 return false;
     832         [ +  - ]:          43 :         } else {
     833                 :           0 :             return throw_expect_type(context, value, "boxed type", gtype);
     834                 :             :         }
     835                 :             : 
     836                 :          45 :         g_value_set_variant (gvalue, variant);
     837   [ +  -  +  +  :         138 :     } else if (g_type_is_a(gtype, G_TYPE_ENUM)) {
                   +  + ]
     838                 :             :         int64_t value_int64;
     839                 :             : 
     840         [ +  - ]:          59 :         if (Gjs::js_value_to_c(context, value, &value_int64)) {
     841                 :             :             GEnumValue *v;
     842                 :          59 :             GjsAutoTypeClass<GEnumClass> enum_class(gtype);
     843                 :             : 
     844                 :             :             /* See arg.c:_gjs_enum_to_int() */
     845                 :          59 :             v = g_enum_get_value(enum_class, (int)value_int64);
     846         [ -  + ]:          59 :             if (v == NULL) {
     847                 :           0 :                 gjs_throw(context,
     848                 :             :                           "%d is not a valid value for enumeration %s",
     849                 :             :                           value.toInt32(), g_type_name(gtype));
     850                 :           0 :                 return false;
     851                 :             :             }
     852                 :             : 
     853                 :          59 :             g_value_set_enum(gvalue, v->value);
     854         [ +  - ]:          59 :         } else {
     855                 :           0 :             return throw_expect_type(context, value, "enum", gtype);
     856                 :             :         }
     857   [ +  -  +  +  :          79 :     } else if (g_type_is_a(gtype, G_TYPE_FLAGS)) {
                   +  + ]
     858                 :             :         int64_t value_int64;
     859                 :             : 
     860         [ +  - ]:          13 :         if (Gjs::js_value_to_c(context, value, &value_int64)) {
     861         [ -  + ]:          13 :             if (!_gjs_flags_value_is_valid(context, gtype, value_int64))
     862                 :           0 :                 return false;
     863                 :             : 
     864                 :             :             /* See arg.c:_gjs_enum_to_int() */
     865                 :          13 :             g_value_set_flags(gvalue, (int)value_int64);
     866                 :             :         } else {
     867                 :           0 :             return throw_expect_type(context, value, "flags", gtype);
     868                 :             :         }
     869   [ +  +  -  +  :          66 :     } else if (g_type_is_a(gtype, G_TYPE_PARAM)) {
                   +  + ]
     870                 :             :         void *gparam;
     871                 :             : 
     872                 :           2 :         gparam = NULL;
     873         [ +  - ]:           2 :         if (value.isNull()) {
     874                 :             :             /* nothing to do */
     875         [ +  - ]:           2 :         } else if (value.isObject()) {
     876                 :           2 :             JS::RootedObject obj(context, &value.toObject());
     877                 :             : 
     878         [ -  + ]:           2 :             if (!gjs_typecheck_param(context, obj, gtype, true))
     879                 :           0 :                 return false;
     880                 :             : 
     881                 :           2 :             gparam = gjs_g_param_from_param(context, obj);
     882         [ +  - ]:           2 :         } else {
     883                 :           0 :             return throw_expect_type(context, value, "param type", gtype);
     884                 :             :         }
     885                 :             : 
     886                 :           2 :         g_value_set_param(gvalue, (GParamSpec*) gparam);
     887         [ +  + ]:          64 :     } else if (gtype == G_TYPE_GTYPE) {
     888                 :             :         GType type;
     889                 :             : 
     890         [ -  + ]:          10 :         if (!value.isObject())
     891                 :           0 :             return throw_expect_type(context, value, "GType object");
     892                 :             : 
     893                 :          10 :         JS::RootedObject obj(context, &value.toObject());
     894         [ -  + ]:          10 :         if (!gjs_gtype_get_actual_gtype(context, obj, &type))
     895                 :           0 :             return false;
     896                 :          10 :         g_value_set_gtype(gvalue, type);
     897   [ +  -  +  +  :          64 :     } else if (g_type_is_a(gtype, G_TYPE_POINTER)) {
             -  +  +  + ]
     898         [ -  + ]:          11 :         if (value.isNull()) {
     899                 :             :             /* Nothing to do */
     900                 :             :         } else {
     901                 :           0 :             gjs_throw(context,
     902                 :             :                       "Cannot convert non-null JS value to G_POINTER");
     903                 :           0 :             return false;
     904                 :             :         }
     905   [ +  +  +  -  :          75 :     } else if (value.isNumber() &&
                   +  + ]
     906                 :          32 :                g_value_type_transformable(G_TYPE_INT, gtype)) {
     907                 :             :         /* Only do this crazy gvalue transform stuff after we've
     908                 :             :          * exhausted everything else. Adding this for
     909                 :             :          * e.g. ClutterUnit.
     910                 :             :          */
     911                 :             :         gint32 i;
     912         [ +  - ]:          32 :         if (Gjs::js_value_to_c(context, value, &i)) {
     913                 :          32 :             GValue int_value = { 0, };
     914                 :          32 :             g_value_init(&int_value, G_TYPE_INT);
     915                 :          32 :             g_value_set_int(&int_value, i);
     916                 :          32 :             g_value_transform(&int_value, gvalue);
     917                 :             :         } else {
     918                 :           0 :             return throw_expect_type(context, value, "integer");
     919                 :             :         }
     920         [ +  - ]:          11 :     } else if (G_TYPE_IS_INSTANTIATABLE(gtype)) {
     921                 :             :         // The gtype is none of the above, it should be derived from a custom
     922                 :             :         // fundamental type.
     923         [ -  + ]:          11 :         if (!value.isObject())
     924                 :           2 :             return throw_expect_type(context, value, "object", gtype);
     925                 :             : 
     926                 :          11 :         JS::RootedObject fundamental_object(context, &value.toObject());
     927         [ +  + ]:          11 :         if (!FundamentalBase::to_gvalue(context, fundamental_object, gvalue))
     928                 :           2 :             return false;
     929         [ +  + ]:          11 :     } else {
     930                 :           0 :         gjs_debug(GJS_DEBUG_GCLOSURE, "JS::Value is number %d gtype fundamental %d transformable to int %d from int %d",
     931                 :           0 :                   value.isNumber(),
     932                 :             :                   G_TYPE_IS_FUNDAMENTAL(gtype),
     933                 :             :                   g_value_type_transformable(gtype, G_TYPE_INT),
     934                 :             :                   g_value_type_transformable(G_TYPE_INT, gtype));
     935                 :             : 
     936                 :           0 :         gjs_throw(context,
     937                 :             :                   "Don't know how to convert JavaScript object to GType %s",
     938                 :             :                   g_type_name(gtype));
     939                 :           0 :         return false;
     940                 :             :     }
     941                 :             : 
     942                 :        8849 :     return true;
     943                 :             : }
     944                 :             : 
     945                 :             : bool
     946                 :        8961 : gjs_value_to_g_value(JSContext      *context,
     947                 :             :                      JS::HandleValue value,
     948                 :             :                      GValue         *gvalue)
     949                 :             : {
     950                 :        8961 :     return gjs_value_to_g_value_internal(context, value, gvalue, false);
     951                 :             : }
     952                 :             : 
     953                 :             : bool
     954                 :           6 : gjs_value_to_g_value_no_copy(JSContext      *context,
     955                 :             :                              JS::HandleValue value,
     956                 :             :                              GValue         *gvalue)
     957                 :             : {
     958                 :           6 :     return gjs_value_to_g_value_internal(context, value, gvalue, true);
     959                 :             : }
     960                 :             : 
     961                 :           9 : [[nodiscard]] static JS::Value convert_int_to_enum(GType gtype, int v) {
     962                 :             :     double v_double;
     963                 :             : 
     964   [ +  +  +  - ]:           9 :     if (v > 0 && v < G_MAXINT) {
     965                 :             :         /* Optimize the unambiguous case */
     966                 :           8 :         v_double = v;
     967                 :             :     } else {
     968                 :             :         /* Need to distinguish between negative integers and unsigned integers */
     969                 :           1 :         GjsAutoEnumInfo info = g_irepository_find_by_gtype(nullptr, gtype);
     970                 :             : 
     971                 :             :         // Native enums don't have type info, assume
     972                 :             :         // they are signed to avoid crashing when
     973                 :             :         // they are exposed to JS.
     974         [ +  - ]:           1 :         if (!info) {
     975                 :           1 :             v_double = int64_t(v);
     976                 :             :         } else {
     977                 :           0 :             v_double = _gjs_enum_from_int(info, v);
     978                 :             :         }
     979                 :           1 :     }
     980                 :             : 
     981                 :           9 :     return JS::NumberValue(v_double);
     982                 :             : }
     983                 :             : 
     984                 :             : GJS_JSAPI_RETURN_CONVENTION
     985                 :        1719 : static bool gjs_value_from_g_value_internal(JSContext* context,
     986                 :             :                                             JS::MutableHandleValue value_p,
     987                 :             :                                             const GValue* gvalue, bool no_copy,
     988                 :             :                                             bool is_introspected_signal,
     989                 :             :                                             GIArgInfo* arg_info,
     990                 :             :                                             GITypeInfo* type_info) {
     991                 :             :     GType gtype;
     992                 :             : 
     993                 :        1719 :     gtype = G_VALUE_TYPE(gvalue);
     994                 :             : 
     995                 :             :     gjs_debug_marshal(GJS_DEBUG_GCLOSURE,
     996                 :             :                       "Converting gtype %s to JS::Value",
     997                 :             :                       g_type_name(gtype));
     998                 :             : 
     999   [ +  +  +  +  :        3036 :     if (gtype != G_TYPE_STRV && g_value_fits_pointer(gvalue) &&
             +  +  +  + ]
    1000                 :        1317 :         g_value_peek_pointer(gvalue) == nullptr) {
    1001                 :             :         // In theory here we should throw if !g_arg_info_may_be_null(arg_info)
    1002                 :             :         // however most signals don't explicitly mark themselves as nullable,
    1003                 :             :         // so better to avoid this.
    1004                 :             :         gjs_debug_marshal(GJS_DEBUG_GCLOSURE,
    1005                 :             :                           "Converting NULL %s to JS::NullValue()",
    1006                 :             :                           g_type_name(gtype));
    1007                 :          93 :         value_p.setNull();
    1008                 :          93 :         return true;
    1009                 :             :     }
    1010                 :             : 
    1011         [ +  + ]:        1626 :     if (gtype == G_TYPE_STRING) {
    1012                 :         282 :         return gjs_string_from_utf8(context, g_value_get_string(gvalue),
    1013                 :         282 :                                     value_p);
    1014         [ +  + ]:        1344 :     } else if (gtype == G_TYPE_CHAR) {
    1015                 :             :         signed char v;
    1016                 :          21 :         v = g_value_get_schar(gvalue);
    1017                 :          21 :         value_p.setInt32(v);
    1018         [ +  + ]:        1323 :     } else if (gtype == G_TYPE_UCHAR) {
    1019                 :             :         unsigned char v;
    1020                 :          14 :         v = g_value_get_uchar(gvalue);
    1021                 :          14 :         value_p.setInt32(v);
    1022         [ +  + ]:        1309 :     } else if (gtype == G_TYPE_INT) {
    1023                 :             :         int v;
    1024                 :         163 :         v = g_value_get_int(gvalue);
    1025                 :         163 :         value_p.set(JS::NumberValue(v));
    1026         [ +  + ]:        1146 :     } else if (gtype == G_TYPE_UINT) {
    1027                 :             :         guint v;
    1028                 :          16 :         v = g_value_get_uint(gvalue);
    1029                 :          16 :         value_p.setNumber(v);
    1030         [ +  + ]:        1130 :     } else if (gtype == G_TYPE_DOUBLE) {
    1031                 :             :         double d;
    1032                 :          17 :         d = g_value_get_double(gvalue);
    1033                 :          17 :         value_p.setNumber(JS::CanonicalizeNaN(d));
    1034         [ +  + ]:        1113 :     } else if (gtype == G_TYPE_FLOAT) {
    1035                 :             :         double d;
    1036                 :          15 :         d = g_value_get_float(gvalue);
    1037                 :          15 :         value_p.setNumber(JS::CanonicalizeNaN(d));
    1038         [ +  + ]:        1098 :     } else if (gtype == G_TYPE_BOOLEAN) {
    1039                 :             :         bool v;
    1040                 :          40 :         v = g_value_get_boolean(gvalue);
    1041                 :          40 :         value_p.setBoolean(!!v);
    1042   [ +  +  +  +  :        1058 :     } else if (g_type_is_a(gtype, G_TYPE_OBJECT) || g_type_is_a(gtype, G_TYPE_INTERFACE)) {
          +  -  -  +  +  
                      + ]
    1043                 :         525 :         return ObjectInstance::set_value_from_gobject(
    1044                 :         525 :             context, static_cast<GObject*>(g_value_get_object(gvalue)),
    1045                 :         525 :             value_p);
    1046         [ +  + ]:         533 :     } else if (gtype == G_TYPE_STRV) {
    1047         [ -  + ]:          15 :         if (!gjs_array_from_strv (context,
    1048                 :             :                                   value_p,
    1049                 :          15 :                                   (const char**) g_value_get_boxed (gvalue))) {
    1050                 :           0 :             gjs_throw(context, "Failed to convert strv to array");
    1051                 :           0 :             return false;
    1052                 :             :         }
    1053   [ +  -  +  + ]:         518 :     } else if (gtype == G_TYPE_ARRAY || gtype == G_TYPE_BYTE_ARRAY ||
    1054         [ +  + ]:         509 :                gtype == G_TYPE_PTR_ARRAY) {
    1055         [ +  + ]:          15 :         if (gtype == G_TYPE_BYTE_ARRAY) {
    1056                 :           9 :             auto* byte_array = static_cast<GByteArray*>(g_value_get_boxed(gvalue));
    1057                 :             :             JSObject* array =
    1058                 :           9 :                 gjs_byte_array_from_byte_array(context, byte_array);
    1059         [ -  + ]:           9 :             if (!array) {
    1060                 :           0 :                 gjs_throw(context,
    1061                 :             :                           "Couldn't convert GByteArray to a Uint8Array");
    1062                 :           9 :                 return false;
    1063                 :             :             }
    1064                 :           9 :             value_p.setObject(*array);
    1065                 :           9 :             return true;
    1066                 :             :         }
    1067                 :             : 
    1068   [ +  -  -  + ]:           6 :         if (!is_introspected_signal || !arg_info) {
    1069                 :           0 :             gjs_throw(context, "Unknown signal");
    1070                 :           0 :             return false;
    1071                 :             :         }
    1072                 :             : 
    1073                 :           6 :         GITransfer transfer = g_arg_info_get_ownership_transfer(arg_info);
    1074                 :           6 :         GjsAutoTypeInfo element_info = g_type_info_get_param_type(type_info, 0);
    1075         [ -  + ]:           6 :         if (!gjs_array_from_g_value_array(context, value_p, element_info,
    1076                 :             :                                           transfer, gvalue)) {
    1077                 :           0 :             gjs_throw(context, "Failed to convert array");
    1078                 :           0 :             return false;
    1079                 :             :         }
    1080   [ +  -  +  + ]:         515 :     } else if (gtype == G_TYPE_HASH_TABLE) {
    1081         [ -  + ]:           3 :         if (!arg_info) {
    1082                 :           0 :             gjs_throw(context, "Failed to get GValue from Hash Table without"
    1083                 :             :                       "signal information");
    1084                 :           0 :             return false;
    1085                 :             :         }
    1086                 :           3 :         GjsAutoTypeInfo key_info = g_type_info_get_param_type(type_info, 0);
    1087                 :           3 :         GjsAutoTypeInfo value_info = g_type_info_get_param_type(type_info, 1);
    1088                 :           3 :         GITransfer transfer = g_arg_info_get_ownership_transfer(arg_info);
    1089                 :             : 
    1090         [ -  + ]:           3 :         if (!gjs_object_from_g_hash(
    1091                 :             :                 context, value_p, key_info, value_info, transfer,
    1092                 :           3 :                 static_cast<GHashTable*>(g_value_get_boxed(gvalue)))) {
    1093                 :           0 :             gjs_throw(context, "Failed to convert Hash Table");
    1094                 :           0 :             return false;
    1095                 :             :         }
    1096   [ +  -  +  -  :         503 :     } else if (g_type_is_a(gtype, G_TYPE_BOXED) || gtype == G_TYPE_VARIANT) {
          +  -  +  +  +  
                +  +  + ]
    1097                 :             :         void *gboxed;
    1098                 :             :         JSObject *obj;
    1099                 :             : 
    1100   [ +  -  +  +  :         205 :         if (g_type_is_a(gtype, G_TYPE_BOXED))
                   +  + ]
    1101                 :         121 :             gboxed = g_value_get_boxed(gvalue);
    1102                 :             :         else
    1103                 :          84 :             gboxed = g_value_get_variant(gvalue);
    1104                 :             : 
    1105         [ +  + ]:         205 :         if (gtype == ObjectBox::gtype()) {
    1106                 :          30 :             obj = ObjectBox::object_for_c_ptr(context,
    1107                 :             :                                               static_cast<ObjectBox*>(gboxed));
    1108         [ -  + ]:          30 :             if (!obj)
    1109                 :          41 :                 return false;
    1110                 :          30 :             value_p.setObject(*obj);
    1111                 :          30 :             return true;
    1112                 :             :         }
    1113                 :             : 
    1114                 :             :         /* special case GError */
    1115         [ +  + ]:         175 :         if (gtype == G_TYPE_ERROR) {
    1116                 :           2 :             obj = ErrorInstance::object_for_c_ptr(context,
    1117                 :             :                                                   static_cast<GError*>(gboxed));
    1118         [ -  + ]:           2 :             if (!obj)
    1119                 :           0 :                 return false;
    1120                 :           2 :             value_p.setObject(*obj);
    1121                 :           2 :             return true;
    1122                 :             :         }
    1123                 :             : 
    1124                 :             :         /* special case GValue */
    1125         [ +  + ]:         173 :         if (gtype == G_TYPE_VALUE) {
    1126                 :           8 :             return gjs_value_from_g_value(context, value_p,
    1127                 :           8 :                                           static_cast<GValue *>(gboxed));
    1128                 :             :         }
    1129                 :             : 
    1130                 :             :         /* The only way to differentiate unions and structs is from
    1131                 :             :          * their g-i info as both GBoxed */
    1132                 :         165 :         GjsAutoBaseInfo info = gjs_lookup_gtype(nullptr, gtype);
    1133         [ -  + ]:         165 :         if (!info) {
    1134                 :           0 :             gjs_throw(context,
    1135                 :             :                       "No introspection information found for %s",
    1136                 :             :                       g_type_name(gtype));
    1137                 :           0 :             return false;
    1138                 :             :         }
    1139                 :             : 
    1140   [ +  -  +  +  :         330 :         if (info.type() == GI_INFO_TYPE_STRUCT &&
                   +  + ]
    1141                 :         165 :             g_struct_info_is_foreign(info)) {
    1142                 :             :             GIArgument arg;
    1143                 :           1 :             gjs_arg_set(&arg, gboxed);
    1144                 :           1 :             return gjs_struct_foreign_convert_from_gi_argument(context, value_p,
    1145                 :           1 :                                                                info, &arg);
    1146                 :             :         }
    1147                 :             : 
    1148                 :         164 :         GIInfoType type = info.type();
    1149   [ +  -  +  - ]:         164 :         if (type == GI_INFO_TYPE_BOXED || type == GI_INFO_TYPE_STRUCT) {
    1150         [ +  + ]:         164 :             if (no_copy)
    1151                 :           1 :                 obj = BoxedInstance::new_for_c_struct(context, info, gboxed,
    1152                 :             :                                                       BoxedInstance::NoCopy());
    1153                 :             :             else
    1154                 :         163 :                 obj = BoxedInstance::new_for_c_struct(context, info, gboxed);
    1155         [ #  # ]:           0 :         } else if (type == GI_INFO_TYPE_UNION) {
    1156                 :           0 :             obj = UnionInstance::new_for_c_union(context, info, gboxed);
    1157                 :             :         } else {
    1158                 :           0 :             gjs_throw(context, "Unexpected introspection type %d for %s",
    1159                 :           0 :                       info.type(), g_type_name(gtype));
    1160                 :           0 :             return false;
    1161                 :             :         }
    1162                 :             : 
    1163                 :         164 :         value_p.setObjectOrNull(obj);
    1164   [ +  +  +  +  :         460 :     } else if (g_type_is_a(gtype, G_TYPE_ENUM)) {
             +  +  +  + ]
    1165                 :           9 :         value_p.set(convert_int_to_enum(gtype, g_value_get_enum(gvalue)));
    1166   [ +  +  -  +  :         286 :     } else if (g_type_is_a(gtype, G_TYPE_PARAM)) {
                   +  + ]
    1167                 :             :         GParamSpec *gparam;
    1168                 :             :         JSObject *obj;
    1169                 :             : 
    1170                 :         179 :         gparam = g_value_get_param(gvalue);
    1171                 :             : 
    1172                 :         179 :         obj = gjs_param_from_g_param(context, gparam);
    1173                 :         179 :         value_p.setObjectOrNull(obj);
    1174   [ -  +  -  -  :         107 :     } else if (is_introspected_signal && g_type_is_a(gtype, G_TYPE_POINTER)) {
             -  -  -  + ]
    1175         [ #  # ]:           0 :         if (!arg_info) {
    1176                 :           0 :             gjs_throw(context, "Unknown signal.");
    1177                 :           0 :             return false;
    1178                 :             :         }
    1179                 :             : 
    1180                 :           0 :         g_assert(((void)"Check gjs_value_from_array_and_length_values() before"
    1181                 :             :                         " calling gjs_value_from_g_value_internal()",
    1182                 :             :                   g_type_info_get_array_length(type_info) == -1));
    1183                 :             : 
    1184                 :             :         GIArgument arg;
    1185                 :           0 :         gjs_arg_set(&arg, g_value_get_pointer(gvalue));
    1186                 :             : 
    1187                 :           0 :         return gjs_value_from_gi_argument(context, value_p, type_info, &arg,
    1188                 :           0 :                                           true);
    1189         [ +  + ]:         107 :     } else if (gtype == G_TYPE_GTYPE) {
    1190                 :           3 :         GType gvalue_gtype = g_value_get_gtype(gvalue);
    1191                 :             : 
    1192         [ -  + ]:           3 :         if (gvalue_gtype == 0) {
    1193                 :           0 :             value_p.setNull();
    1194                 :           0 :             return true;
    1195                 :             :         }
    1196                 :             : 
    1197                 :             :         JS::RootedObject obj(
    1198                 :           3 :             context, gjs_gtype_create_gtype_wrapper(context, gvalue_gtype));
    1199         [ -  + ]:           3 :         if (!obj)
    1200                 :           0 :             return false;
    1201                 :             : 
    1202                 :           3 :         value_p.setObject(*obj);
    1203   [ +  -  +  -  :         107 :     } else if (g_type_is_a(gtype, G_TYPE_POINTER)) {
             -  +  -  + ]
    1204         [ #  # ]:           0 :         if (g_value_get_pointer(gvalue) != nullptr) {
    1205                 :           0 :             gjs_throw(context,
    1206                 :             :                       "Can't convert non-null pointer to JS value");
    1207                 :           0 :             return false;
    1208                 :             :         }
    1209         [ +  + ]:         104 :     } else if (g_value_type_transformable(gtype, G_TYPE_DOUBLE)) {
    1210                 :          83 :         GValue double_value = { 0, };
    1211                 :             :         double v;
    1212                 :          83 :         g_value_init(&double_value, G_TYPE_DOUBLE);
    1213                 :          83 :         g_value_transform(gvalue, &double_value);
    1214                 :          83 :         v = g_value_get_double(&double_value);
    1215                 :          83 :         value_p.setNumber(v);
    1216         [ +  + ]:          21 :     } else if (g_value_type_transformable(gtype, G_TYPE_INT)) {
    1217                 :           9 :         GValue int_value = { 0, };
    1218                 :             :         int v;
    1219                 :           9 :         g_value_init(&int_value, G_TYPE_INT);
    1220                 :           9 :         g_value_transform(gvalue, &int_value);
    1221                 :           9 :         v = g_value_get_int(&int_value);
    1222                 :           9 :         value_p.set(JS::NumberValue(v));
    1223         [ +  - ]:          12 :     } else if (G_TYPE_IS_INSTANTIATABLE(gtype)) {
    1224                 :             :         /* The gtype is none of the above, it should be a custom
    1225                 :             :            fundamental type. */
    1226                 :          12 :         JS::RootedObject obj(context);
    1227         [ -  + ]:          12 :         if (!FundamentalInstance::object_for_gvalue(context, gvalue, gtype,
    1228                 :             :                                                     &obj))
    1229                 :           0 :             return false;
    1230                 :             : 
    1231                 :          12 :         value_p.setObjectOrNull(obj);
    1232         [ +  - ]:          12 :     } else {
    1233                 :           0 :         gjs_throw(context,
    1234                 :             :                   "Don't know how to convert GType %s to JavaScript object",
    1235                 :             :                   g_type_name(gtype));
    1236                 :           0 :         return false;
    1237                 :             :     }
    1238                 :             : 
    1239                 :         769 :     return true;
    1240                 :             : }
    1241                 :             : 
    1242                 :             : bool
    1243                 :         849 : gjs_value_from_g_value(JSContext             *context,
    1244                 :             :                        JS::MutableHandleValue value_p,
    1245                 :             :                        const GValue          *gvalue)
    1246                 :             : {
    1247                 :         849 :     return gjs_value_from_g_value_internal(context, value_p, gvalue, false);
    1248                 :             : }
        

Generated by: LCOV version 2.0-1