LCOV - code coverage report
Current view: top level - gi - function.cpp (source / functions) Coverage Total Hit
Test: gjs- Code Coverage Lines: 79.0 % 694 548
Test Date: 2024-04-29 05:18:28 Functions: 74.0 % 50 37
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 73.4 % 444 326

             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, size_t
       8                 :             : #include <stdint.h>
       9                 :             : 
      10                 :             : #include <limits>
      11                 :             : #include <memory>  // for unique_ptr
      12                 :             : #include <sstream>
      13                 :             : #include <string>
      14                 :             : #include <vector>
      15                 :             : 
      16                 :             : #include <ffi.h>
      17                 :             : #include <girepository.h>
      18                 :             : #include <girffi.h>
      19                 :             : #include <glib-object.h>
      20                 :             : #include <glib.h>
      21                 :             : 
      22                 :             : #include <js/Array.h>
      23                 :             : #include <js/CallAndConstruct.h>  // for IsCallable
      24                 :             : #include <js/CallArgs.h>
      25                 :             : #include <js/Class.h>
      26                 :             : #include <js/ErrorReport.h>  // for JS_ReportOutOfMemory
      27                 :             : #include <js/Exception.h>
      28                 :             : #include <js/PropertyAndElement.h>
      29                 :             : #include <js/PropertyDescriptor.h>  // for JSPROP_PERMANENT
      30                 :             : #include <js/PropertySpec.h>
      31                 :             : #include <js/Realm.h>  // for GetRealmFunctionPrototype
      32                 :             : #include <js/RootingAPI.h>
      33                 :             : #include <js/TypeDecls.h>
      34                 :             : #include <js/Value.h>
      35                 :             : #include <js/ValueArray.h>
      36                 :             : #include <js/Warnings.h>
      37                 :             : #include <jsapi.h>        // for HandleValueArray
      38                 :             : #include <jsfriendapi.h>  // for JS_GetObjectFunction
      39                 :             : #include <jspubtd.h>      // for JSProtoKey
      40                 :             : 
      41                 :             : #include "gi/arg-cache.h"
      42                 :             : #include "gi/arg-inl.h"
      43                 :             : #include "gi/arg.h"
      44                 :             : #include "gi/closure.h"
      45                 :             : #include "gi/cwrapper.h"
      46                 :             : #include "gi/function.h"
      47                 :             : #include "gi/gerror.h"
      48                 :             : #include "gi/object.h"
      49                 :             : #include "gi/utils-inl.h"
      50                 :             : #include "gjs/context-private.h"
      51                 :             : #include "gjs/global.h"
      52                 :             : #include "gjs/jsapi-util.h"
      53                 :             : #include "gjs/macros.h"
      54                 :             : #include "gjs/mem-private.h"
      55                 :             : #include "gjs/profiler-private.h"
      56                 :             : #include "util/log.h"
      57                 :             : 
      58                 :             : /* We use guint8 for arguments; functions can't
      59                 :             :  * have more than this.
      60                 :             :  */
      61                 :             : #define GJS_ARG_INDEX_INVALID G_MAXUINT8
      62                 :             : 
      63                 :             : namespace Gjs {
      64                 :             : 
      65                 :             : class Function : public CWrapper<Function> {
      66                 :             :     friend CWrapperPointerOps<Function>;
      67                 :             :     friend CWrapper<Function>;
      68                 :             : 
      69                 :             :     static constexpr auto PROTOTYPE_SLOT = GjsGlobalSlot::PROTOTYPE_function;
      70                 :             :     static constexpr GjsDebugTopic DEBUG_TOPIC = GJS_DEBUG_GFUNCTION;
      71                 :             : 
      72                 :             :     GjsAutoCallableInfo m_info;
      73                 :             : 
      74                 :             :     ArgsCache m_arguments;
      75                 :             : 
      76                 :             :     uint8_t m_js_in_argc;
      77                 :             :     uint8_t m_js_out_argc;
      78                 :             :     GIFunctionInvoker m_invoker;
      79                 :             : 
      80                 :       10918 :     explicit Function(GICallableInfo* info)
      81                 :       10918 :         : m_info(info, GjsAutoTakeOwnership()),
      82                 :       10918 :           m_js_in_argc(0),
      83                 :       10918 :           m_js_out_argc(0),
      84                 :       10918 :           m_invoker({}) {
      85                 :       10918 :         GJS_INC_COUNTER(function);
      86                 :       10918 :     }
      87                 :             :     ~Function();
      88                 :             : 
      89                 :             :     GJS_JSAPI_RETURN_CONVENTION
      90                 :             :     bool init(JSContext* cx, GType gtype = G_TYPE_NONE);
      91                 :             : 
      92                 :             :     /**
      93                 :             :      * Like CWrapperPointerOps::for_js_typecheck(), but additionally checks that
      94                 :             :      * the pointer is not null, which is the case for prototype objects.
      95                 :             :      */
      96                 :             :     GJS_JSAPI_RETURN_CONVENTION
      97                 :          18 :     static bool for_js_instance(JSContext* cx, JS::HandleObject obj,
      98                 :             :                                 Function** out, JS::CallArgs* args) {
      99                 :             :         Function* priv;
     100         [ -  + ]:          18 :         if (!Function::for_js_typecheck(cx, obj, &priv, args))
     101                 :           0 :             return false;
     102         [ -  + ]:          18 :         if (!priv) {
     103                 :             :             // This is the prototype
     104                 :           0 :             gjs_throw(cx, "Impossible on prototype; only on instances");
     105                 :           0 :             return false;
     106                 :             :         }
     107                 :          18 :         *out = priv;
     108                 :          18 :         return true;
     109                 :             :     }
     110                 :             : 
     111                 :             :     GJS_JSAPI_RETURN_CONVENTION
     112                 :             :     static bool call(JSContext* cx, unsigned argc, JS::Value* vp);
     113                 :             : 
     114                 :             :     static void finalize_impl(JS::GCContext*, Function* priv);
     115                 :             : 
     116                 :             :     GJS_JSAPI_RETURN_CONVENTION
     117                 :             :     static bool get_length(JSContext* cx, unsigned argc, JS::Value* vp);
     118                 :             : 
     119                 :             :     GJS_JSAPI_RETURN_CONVENTION
     120                 :             :     static bool to_string(JSContext* cx, unsigned argc, JS::Value* vp);
     121                 :             : 
     122                 :             :     GJS_JSAPI_RETURN_CONVENTION
     123                 :             :     bool to_string_impl(JSContext* cx, JS::MutableHandleValue rval);
     124                 :             : 
     125                 :             :     GJS_JSAPI_RETURN_CONVENTION
     126                 :             :     bool finish_invoke(JSContext* cx, const JS::CallArgs& args,
     127                 :             :                        GjsFunctionCallState* state,
     128                 :             :                        GIArgument* r_value = nullptr);
     129                 :             : 
     130                 :             :     GJS_JSAPI_RETURN_CONVENTION
     131                 :          62 :     static JSObject* inherit_builtin_function(JSContext* cx, JSProtoKey) {
     132                 :             :         JS::RootedObject builtin_function_proto(
     133                 :          62 :             cx, JS::GetRealmFunctionPrototype(cx));
     134                 :          62 :         return JS_NewObjectWithGivenProto(cx, nullptr, builtin_function_proto);
     135                 :          62 :     }
     136                 :             : 
     137                 :             :     static const JSClassOps class_ops;
     138                 :             :     static const JSPropertySpec proto_props[];
     139                 :             :     static const JSFunctionSpec proto_funcs[];
     140                 :             : 
     141                 :             :     static constexpr js::ClassSpec class_spec = {
     142                 :             :         nullptr,  // createConstructor
     143                 :             :         &Function::inherit_builtin_function,
     144                 :             :         nullptr,  // constructorFunctions
     145                 :             :         nullptr,  // constructorProperties
     146                 :             :         Function::proto_funcs,
     147                 :             :         Function::proto_props,
     148                 :             :         nullptr,  // finishInit
     149                 :             :         js::ClassSpec::DontDefineConstructor};
     150                 :             : 
     151                 :             :     static constexpr JSClass klass = {
     152                 :             :         "GIRepositoryFunction",
     153                 :             :         JSCLASS_HAS_RESERVED_SLOTS(1) | JSCLASS_BACKGROUND_FINALIZE,
     154                 :             :         &Function::class_ops, &Function::class_spec};
     155                 :             : 
     156                 :             :  public:
     157                 :             :     GJS_JSAPI_RETURN_CONVENTION
     158                 :             :     static JSObject* create(JSContext* cx, GType gtype, GICallableInfo* info);
     159                 :             : 
     160                 :             :     [[nodiscard]] std::string format_name();
     161                 :             : 
     162                 :             :     GJS_JSAPI_RETURN_CONVENTION
     163                 :             :     bool invoke(JSContext* cx, const JS::CallArgs& args,
     164                 :             :                 JS::HandleObject this_obj = nullptr,
     165                 :             :                 GIArgument* r_value = nullptr);
     166                 :             : 
     167                 :             :     GJS_JSAPI_RETURN_CONVENTION
     168                 :          15 :     static bool invoke_constructor_uncached(JSContext* cx, GIFunctionInfo* info,
     169                 :             :                                             JS::HandleObject obj,
     170                 :             :                                             const JS::CallArgs& args,
     171                 :             :                                             GIArgument* rvalue) {
     172                 :          15 :         Function function(info);
     173         [ -  + ]:          15 :         if (!function.init(cx))
     174                 :           0 :             return false;
     175                 :          15 :         return function.invoke(cx, args, obj, rvalue);
     176                 :          15 :     }
     177                 :             : };
     178                 :             : 
     179                 :             : }  // namespace Gjs
     180                 :             : 
     181                 :             : template <typename T, GITypeTag TAG = GI_TYPE_TAG_VOID>
     182                 :         568 : static inline void set_ffi_arg(void* result, GIArgument* value) {
     183                 :             :     if constexpr (std::is_integral_v<T> && std::is_signed_v<T>) {
     184                 :         473 :         *static_cast<ffi_sarg*>(result) = gjs_arg_get<T, TAG>(value);
     185                 :             :     } else if constexpr (std::is_floating_point_v<T> || std::is_unsigned_v<T>) {
     186                 :           0 :         *static_cast<ffi_arg*>(result) = gjs_arg_get<T, TAG>(value);
     187                 :             :     } else if constexpr (std::is_pointer_v<T>) {
     188                 :          95 :         *static_cast<ffi_arg*>(result) =
     189                 :          95 :             gjs_pointer_to_int<ffi_arg>(gjs_arg_get<T, TAG>(value));
     190                 :             :     }
     191                 :         568 : }
     192                 :             : 
     193                 :         568 : static void set_return_ffi_arg_from_gi_argument(GITypeInfo* ret_type,
     194                 :             :                                                 void* result,
     195                 :             :                                                 GIArgument* return_value) {
     196                 :             :     // Be consistent with gjs_value_to_gi_argument()
     197   [ -  -  -  -  :         568 :     switch (g_type_info_get_tag(ret_type)) {
          -  +  -  +  -  
          +  +  -  -  -  
                -  +  - ]
     198                 :           0 :     case GI_TYPE_TAG_VOID:
     199                 :             :         g_assert_not_reached();
     200                 :           0 :     case GI_TYPE_TAG_INT8:
     201                 :           0 :         set_ffi_arg<int8_t>(result, return_value);
     202                 :           0 :         break;
     203                 :           0 :     case GI_TYPE_TAG_UINT8:
     204                 :           0 :         set_ffi_arg<uint8_t>(result, return_value);
     205                 :           0 :         break;
     206                 :           0 :     case GI_TYPE_TAG_INT16:
     207                 :           0 :         set_ffi_arg<int16_t>(result, return_value);
     208                 :           0 :         break;
     209                 :           0 :     case GI_TYPE_TAG_UINT16:
     210                 :           0 :         set_ffi_arg<uint16_t>(result, return_value);
     211                 :           0 :         break;
     212                 :         100 :     case GI_TYPE_TAG_INT32:
     213                 :         100 :         set_ffi_arg<int32_t>(result, return_value);
     214                 :         100 :         break;
     215                 :           0 :     case GI_TYPE_TAG_UINT32:
     216                 :           0 :         set_ffi_arg<uint32_t>(result, return_value);
     217                 :           0 :         break;
     218                 :         183 :     case GI_TYPE_TAG_BOOLEAN:
     219                 :         183 :         set_ffi_arg<gboolean, GI_TYPE_TAG_BOOLEAN>(result, return_value);
     220                 :         183 :         break;
     221                 :           0 :     case GI_TYPE_TAG_UNICHAR:
     222                 :           0 :         set_ffi_arg<char32_t>(result, return_value);
     223                 :           0 :         break;
     224                 :          18 :     case GI_TYPE_TAG_INT64:
     225                 :          18 :         set_ffi_arg<int64_t>(result, return_value);
     226                 :          18 :         break;
     227                 :         263 :     case GI_TYPE_TAG_INTERFACE:
     228                 :             :         {
     229                 :         263 :             GjsAutoBaseInfo interface_info(g_type_info_get_interface(ret_type));
     230                 :         263 :             GIInfoType interface_type = interface_info.type();
     231                 :             : 
     232   [ +  +  +  + ]:         263 :             if (interface_type == GI_INFO_TYPE_ENUM ||
     233                 :             :                 interface_type == GI_INFO_TYPE_FLAGS)
     234                 :         172 :                 set_ffi_arg<int, GI_TYPE_TAG_INTERFACE>(result, return_value);
     235                 :             :             else
     236                 :          91 :                 set_ffi_arg<void*>(result, return_value);
     237                 :         263 :         }
     238                 :         263 :         break;
     239                 :           0 :     case GI_TYPE_TAG_UINT64:
     240                 :             :         // Other primitive types need to squeeze into 64-bit ffi_arg too
     241                 :           0 :         set_ffi_arg<uint64_t>(result, return_value);
     242                 :           0 :         break;
     243                 :           0 :     case GI_TYPE_TAG_FLOAT:
     244                 :           0 :         set_ffi_arg<float>(result, return_value);
     245                 :           0 :         break;
     246                 :           0 :     case GI_TYPE_TAG_DOUBLE:
     247                 :           0 :         set_ffi_arg<double>(result, return_value);
     248                 :           0 :         break;
     249                 :           0 :     case GI_TYPE_TAG_GTYPE:
     250                 :           0 :         set_ffi_arg<GType, GI_TYPE_TAG_GTYPE>(result, return_value);
     251                 :           0 :         break;
     252                 :           4 :     case GI_TYPE_TAG_UTF8:
     253                 :             :     case GI_TYPE_TAG_FILENAME:
     254                 :           4 :         set_ffi_arg<char*>(result, return_value);
     255                 :           4 :         break;
     256                 :           0 :     case GI_TYPE_TAG_ARRAY:
     257                 :             :     case GI_TYPE_TAG_GLIST:
     258                 :             :     case GI_TYPE_TAG_GSLIST:
     259                 :             :     case GI_TYPE_TAG_GHASH:
     260                 :             :     case GI_TYPE_TAG_ERROR:
     261                 :             :     default:
     262                 :           0 :         set_ffi_arg<void*>(result, return_value);
     263                 :           0 :         break;
     264                 :             :     }
     265                 :         568 : }
     266                 :             : 
     267                 :           4 : void GjsCallbackTrampoline::warn_about_illegal_js_callback(const char* when,
     268                 :             :                                                            const char* reason,
     269                 :             :                                                            bool        dump_stack) {
     270                 :           4 :     std::ostringstream message;
     271                 :             : 
     272                 :             :     message << "Attempting to run a JS callback " << when << ". "
     273                 :             :             << "This is most likely caused by " << reason << ". "
     274                 :           4 :             << "Because it would crash the application, it has been blocked.";
     275         [ +  - ]:           4 :     if (m_info) {
     276                 :             :         message << "\nThe offending callback was " << m_info.name() << "()"
     277         [ +  - ]:           4 :                 << (m_is_vfunc ? ", a vfunc." : ".");
     278                 :             :     }
     279         [ +  - ]:           4 :     if (dump_stack) {
     280                 :           4 :         message << "\n" << gjs_dumpstack_string();
     281                 :             :     }
     282                 :           4 :     g_critical("%s", message.str().c_str());
     283                 :           4 : }
     284                 :             : 
     285                 :             : /* This is our main entry point for ffi_closure callbacks.
     286                 :             :  * ffi_prep_closure is doing pure magic and replaces the original
     287                 :             :  * function call with this one which gives us the ffi arguments,
     288                 :             :  * a place to store the return value and our use data.
     289                 :             :  * In other words, everything we need to call the JS function and
     290                 :             :  * getting the return value back.
     291                 :             :  */
     292                 :         488 : void GjsCallbackTrampoline::callback_closure(GIArgument** args, void* result) {
     293                 :             :     GITypeInfo ret_type;
     294                 :             : 
     295                 :             :     // Fill in the result with some hopefully neutral value
     296                 :         488 :     g_callable_info_load_return_type(m_info, &ret_type);
     297         [ +  + ]:         488 :     if (g_type_info_get_tag(&ret_type) != GI_TYPE_TAG_VOID) {
     298                 :         295 :         GIArgument argument = {};
     299                 :         295 :         gjs_gi_argument_init_default(&ret_type, &argument);
     300                 :         295 :         set_return_ffi_arg_from_gi_argument(&ret_type, result, &argument);
     301                 :             :     }
     302                 :             : 
     303         [ -  + ]:         488 :     if (G_UNLIKELY(!is_valid())) {
     304                 :           0 :         warn_about_illegal_js_callback(
     305                 :             :             "during shutdown",
     306                 :             :             "destroying a Clutter actor or GTK widget with ::destroy signal "
     307                 :             :             "connected, or using the destroy(), dispose(), or remove() vfuncs",
     308                 :             :             true);
     309                 :          12 :         return;
     310                 :             :     }
     311                 :             : 
     312                 :         488 :     JSContext* context = this->context();
     313                 :         488 :     GjsContextPrivate* gjs = GjsContextPrivate::from_cx(context);
     314         [ +  + ]:         488 :     if (G_UNLIKELY(gjs->sweeping())) {
     315                 :           4 :         warn_about_illegal_js_callback(
     316                 :             :             "during garbage collection",
     317                 :             :             "destroying a Clutter actor or GTK widget with ::destroy signal "
     318                 :             :             "connected, or using the destroy(), dispose(), or remove() vfuncs",
     319                 :             :             true);
     320                 :           4 :         return;
     321                 :             :     }
     322                 :             : 
     323         [ -  + ]:         484 :     if (G_UNLIKELY(!gjs->is_owner_thread())) {
     324                 :           0 :         warn_about_illegal_js_callback("on a different thread",
     325                 :             :                                        "an API not intended to be used in JS",
     326                 :             :                                        false);
     327                 :           0 :         return;
     328                 :             :     }
     329                 :             : 
     330                 :         484 :     JSAutoRealm ar(context, callable());
     331                 :             : 
     332                 :         484 :     int n_args = g_callable_info_get_n_args(m_info);
     333                 :         484 :     g_assert(n_args >= 0);
     334                 :             : 
     335                 :             :     struct AutoCallbackData {
     336                 :         484 :         AutoCallbackData(GjsCallbackTrampoline* trampoline,
     337                 :             :                          GjsContextPrivate* gjs)
     338                 :         484 :             : trampoline(trampoline), gjs(gjs) {}
     339                 :         482 :         ~AutoCallbackData() {
     340         [ +  + ]:         482 :             if (trampoline->m_scope == GI_SCOPE_TYPE_ASYNC) {
     341                 :             :                 // We don't release the trampoline here as we've an extra ref
     342                 :             :                 // that has been set in gjs_marshal_callback_in()
     343                 :             :                 gjs_debug_closure("Saving async closure for gc cleanup %p",
     344                 :             :                                   trampoline);
     345                 :         113 :                 gjs->async_closure_enqueue_for_gc(trampoline);
     346                 :             :             }
     347                 :         482 :             gjs->schedule_gc_if_needed();
     348                 :         482 :         }
     349                 :             : 
     350                 :             :         GjsCallbackTrampoline* trampoline;
     351                 :             :         GjsContextPrivate* gjs;
     352                 :             :     };
     353                 :             : 
     354                 :         484 :     AutoCallbackData callback_data(this, gjs);
     355                 :         484 :     JS::RootedObject this_object(context);
     356                 :         484 :     int c_args_offset = 0;
     357                 :         484 :     GObject* gobj = nullptr;
     358         [ +  + ]:         484 :     if (m_is_vfunc) {
     359                 :         106 :         gobj = G_OBJECT(gjs_arg_get<GObject*>(args[0]));
     360         [ +  - ]:         106 :         if (gobj) {
     361                 :         106 :             this_object = ObjectInstance::wrapper_from_gobject(context, gobj);
     362         [ -  + ]:         106 :             if (!this_object) {
     363         [ #  # ]:           0 :                 if (g_object_get_qdata(gobj, ObjectBase::disposed_quark())) {
     364                 :           0 :                     warn_about_illegal_js_callback(
     365                 :             :                         "on disposed object",
     366                 :             :                         "using the destroy(), dispose(), or remove() vfuncs",
     367                 :             :                         false);
     368                 :             :                 }
     369                 :           0 :                 gjs_log_exception(context);
     370                 :           0 :                 return;
     371                 :             :             }
     372                 :             :         }
     373                 :             : 
     374                 :             :         /* "this" is not included in the GI signature, but is in the C (and
     375                 :             :          * FFI) signature */
     376                 :         106 :         c_args_offset = 1;
     377                 :             :     }
     378                 :             : 
     379                 :         484 :     JS::RootedValue rval(context);
     380                 :             : 
     381         [ +  + ]:         484 :     if (!callback_closure_inner(context, this_object, gobj, &rval, args,
     382                 :             :                                 &ret_type, n_args, c_args_offset, result)) {
     383         [ +  + ]:          25 :         if (!JS_IsExceptionPending(context)) {
     384                 :             :             // "Uncatchable" exception thrown, we have to exit. We may be in a
     385                 :             :             // main loop, or maybe not, but there's no way to tell, so we have
     386                 :             :             // to exit here instead of propagating the exception back to the
     387                 :             :             // original calling JS code.
     388                 :             :             uint8_t code;
     389         [ +  - ]:           1 :             if (gjs->should_exit(&code))
     390                 :           1 :                 gjs->exit_immediately(code);
     391                 :             : 
     392                 :             :             // Some other uncatchable exception, e.g. out of memory
     393                 :           0 :             JSFunction* fn = JS_GetObjectFunction(callable());
     394                 :             :             std::string descr =
     395                 :           0 :                 fn ? "function " + gjs_debug_string(JS_GetFunctionDisplayId(fn))
     396   [ #  #  #  #  :           0 :                    : "callable object " + gjs_debug_object(callable());
                   #  # ]
     397                 :           0 :             g_error("Call to %s (%s.%s) terminated with uncatchable exception",
     398                 :             :                     descr.c_str(), m_info.ns(), m_info.name());
     399                 :             :         }
     400                 :             : 
     401                 :             :         // If the callback has a GError** argument, then make a GError from the
     402                 :             :         // value that was thrown. Otherwise, log it as "uncaught" (critical
     403                 :             :         // instead of warning)
     404                 :             : 
     405         [ +  + ]:          24 :         if (!g_callable_info_can_throw_gerror(m_info)) {
     406                 :           8 :             gjs_log_exception_uncaught(context);
     407                 :           8 :             return;
     408                 :             :         }
     409                 :             : 
     410                 :             :         // The GError** pointer is the last argument, and is not included in
     411                 :             :         // the n_args
     412                 :          16 :         GIArgument* error_argument = args[n_args + c_args_offset];
     413                 :          16 :         auto* gerror = gjs_arg_get<GError**>(error_argument);
     414                 :          16 :         GError* local_error = gjs_gerror_make_from_thrown_value(context);
     415                 :          16 :         g_propagate_error(gerror, local_error);
     416                 :             :     }
     417   [ +  +  +  +  :         506 : }
             +  +  +  + ]
     418                 :             : 
     419                 :          34 : inline GIArgument* get_argument_for_arg_info(GIArgInfo* arg_info,
     420                 :             :                                              GIArgument** args, int index) {
     421         [ +  + ]:          34 :     if (!g_arg_info_is_caller_allocates(arg_info))
     422                 :          31 :         return *reinterpret_cast<GIArgument**>(args[index]);
     423                 :             :     else
     424                 :           3 :         return args[index];
     425                 :             : }
     426                 :             : 
     427                 :         484 : bool GjsCallbackTrampoline::callback_closure_inner(
     428                 :             :     JSContext* context, JS::HandleObject this_object, GObject* gobject,
     429                 :             :     JS::MutableHandleValue rval, GIArgument** args, GITypeInfo* ret_type,
     430                 :             :     int n_args, int c_args_offset, void* result) {
     431                 :         484 :     int n_outargs = 0;
     432                 :         484 :     JS::RootedValueVector jsargs(context);
     433                 :             : 
     434         [ -  + ]:         484 :     if (!jsargs.reserve(n_args))
     435                 :           0 :         g_error("Unable to reserve space for vector");
     436                 :             : 
     437                 :         484 :     GITypeTag ret_tag = g_type_info_get_tag(ret_type);
     438                 :         484 :     bool ret_type_is_void = ret_tag == GI_TYPE_TAG_VOID;
     439                 :         484 :     bool in_args_to_cleanup = false;
     440                 :             : 
     441         [ +  + ]:        1787 :     for (int i = 0, n_jsargs = 0; i < n_args; i++) {
     442                 :             :         GIArgInfo arg_info;
     443                 :             :         GITypeInfo type_info;
     444                 :             :         GjsParamType param_type;
     445                 :             : 
     446                 :        1303 :         g_callable_info_load_arg(m_info, i, &arg_info);
     447                 :        1303 :         g_arg_info_load_type(&arg_info, &type_info);
     448                 :             : 
     449                 :             :         /* Skip void * arguments */
     450         [ +  + ]:        1303 :         if (g_type_info_get_tag(&type_info) == GI_TYPE_TAG_VOID)
     451                 :         399 :             continue;
     452                 :             : 
     453         [ +  + ]:         943 :         if (g_arg_info_get_direction(&arg_info) == GI_DIRECTION_OUT) {
     454                 :          33 :             n_outargs++;
     455                 :          33 :             continue;
     456                 :             :         }
     457                 :             : 
     458         [ +  + ]:         910 :         if (g_arg_info_get_direction(&arg_info) == GI_DIRECTION_INOUT)
     459                 :           6 :             n_outargs++;
     460                 :             : 
     461         [ +  + ]:         910 :         if (g_arg_info_get_ownership_transfer(&arg_info) != GI_TRANSFER_NOTHING)
     462                 :           7 :             in_args_to_cleanup = m_scope != GI_SCOPE_TYPE_FOREVER;
     463                 :             : 
     464                 :         910 :         param_type = m_param_types[i];
     465                 :             : 
     466   [ +  +  +  - ]:         910 :         switch (param_type) {
     467                 :           6 :             case PARAM_SKIPPED:
     468                 :           6 :                 continue;
     469                 :           6 :             case PARAM_ARRAY: {
     470                 :           6 :                 gint array_length_pos = g_type_info_get_array_length(&type_info);
     471                 :             :                 GIArgInfo array_length_arg;
     472                 :             :                 GITypeInfo arg_type_info;
     473                 :             : 
     474                 :           6 :                 g_callable_info_load_arg(m_info, array_length_pos,
     475                 :             :                                          &array_length_arg);
     476                 :           6 :                 g_arg_info_load_type(&array_length_arg, &arg_type_info);
     477                 :           6 :                 size_t length = gjs_gi_argument_get_array_length(
     478                 :             :                     g_type_info_get_tag(&arg_type_info),
     479                 :           6 :                     args[array_length_pos + c_args_offset]);
     480                 :             : 
     481         [ -  + ]:           6 :                 if (!jsargs.growBy(1))
     482                 :           0 :                     g_error("Unable to grow vector");
     483                 :             : 
     484         [ -  + ]:           6 :                 if (!gjs_value_from_explicit_array(
     485                 :           6 :                         context, jsargs[n_jsargs++], &type_info,
     486                 :             :                         g_arg_info_get_ownership_transfer(&arg_info),
     487                 :           6 :                         args[i + c_args_offset], length))
     488                 :           0 :                     return false;
     489                 :           6 :                 break;
     490                 :             :             }
     491                 :         898 :             case PARAM_NORMAL: {
     492         [ -  + ]:         898 :                 if (!jsargs.growBy(1))
     493                 :           0 :                     g_error("Unable to grow vector");
     494                 :             : 
     495                 :         898 :                 GIArgument* arg = args[i + c_args_offset];
     496   [ +  +  +  -  :         904 :                 if (g_arg_info_get_direction(&arg_info) == GI_DIRECTION_INOUT &&
                   +  + ]
     497                 :           6 :                     !g_arg_info_is_caller_allocates(&arg_info))
     498                 :           6 :                     arg = *reinterpret_cast<GIArgument**>(arg);
     499                 :             : 
     500         [ -  + ]:         898 :                 if (!gjs_value_from_gi_argument(context, jsargs[n_jsargs++],
     501                 :             :                                                 &type_info, arg, false))
     502                 :           0 :                     return false;
     503                 :         898 :                 break;
     504                 :             :             }
     505                 :           0 :             case PARAM_CALLBACK:
     506                 :             :                 /* Callbacks that accept another callback as a parameter are not
     507                 :             :                  * supported, see gjs_callback_trampoline_new() */
     508                 :             :             case PARAM_UNKNOWN:
     509                 :             :                 // PARAM_UNKNOWN is currently not ever set on a callback's args.
     510                 :             :             default:
     511                 :             :                 g_assert_not_reached();
     512                 :           6 :         }
     513                 :             :     }
     514                 :             : 
     515         [ +  + ]:         484 :     if (!invoke(this_object, jsargs, rval))
     516                 :          17 :         return false;
     517                 :             : 
     518   [ +  +  +  + ]:         466 :     if (n_outargs == 0 && ret_type_is_void) {
     519                 :             :         /* void return value, no out args, nothing to do */
     520         [ +  + ]:         296 :     } else if (n_outargs == 0) {
     521                 :             :         GIArgument argument;
     522                 :             :         GITransfer transfer;
     523                 :             : 
     524                 :         265 :         transfer = g_callable_info_get_caller_owns(m_info);
     525                 :             :         /* non-void return value, no out args. Should
     526                 :             :          * be a single return value. */
     527         [ +  + ]:         265 :         if (!gjs_value_to_gi_argument(context, rval, ret_type, "callback",
     528                 :             :                                       GJS_ARGUMENT_RETURN_VALUE, transfer,
     529                 :             :                                       GjsArgumentFlags::MAY_BE_NULL, &argument))
     530                 :           2 :             return false;
     531                 :             : 
     532                 :         263 :         set_return_ffi_arg_from_gi_argument(ret_type, result, &argument);
     533   [ +  +  +  + ]:          31 :     } else if (n_outargs == 1 && ret_type_is_void) {
     534                 :             :         /* void return value, one out args. Should
     535                 :             :          * be a single return value. */
     536         [ +  - ]:          17 :         for (int i = 0; i < n_args; i++) {
     537                 :             :             GIArgInfo arg_info;
     538                 :          17 :             g_callable_info_load_arg(m_info, i, &arg_info);
     539         [ +  + ]:          17 :             if (g_arg_info_get_direction(&arg_info) == GI_DIRECTION_IN)
     540                 :           2 :                 continue;
     541                 :             : 
     542         [ +  + ]:          15 :             if (!gjs_value_to_callback_out_arg(
     543                 :             :                     context, rval, &arg_info,
     544                 :             :                     get_argument_for_arg_info(&arg_info, args,
     545                 :             :                                               i + c_args_offset)))
     546                 :           3 :                 return false;
     547                 :             : 
     548                 :          12 :             break;
     549                 :             :         }
     550                 :          12 :     } else {
     551                 :          16 :         bool is_array = rval.isObject();
     552         [ -  + ]:          16 :         if (!JS::IsArrayObject(context, rval, &is_array))
     553                 :           3 :             return false;
     554                 :             : 
     555         [ +  + ]:          16 :         if (!is_array) {
     556                 :           3 :             JSFunction* fn = JS_GetObjectFunction(callable());
     557                 :             :             std::string descr =
     558                 :           6 :                 fn ? "function " + gjs_debug_string(JS_GetFunctionDisplayId(fn))
     559   [ +  -  -  +  :           6 :                    : "callable object " + gjs_debug_object(callable());
                   +  - ]
     560                 :           3 :             gjs_throw(context,
     561                 :             :                       "Call to %s (%s.%s) returned unexpected value, expecting "
     562                 :             :                       "an Array",
     563                 :             :                       descr.c_str(), m_info.ns(), m_info.name());
     564                 :           3 :             return false;
     565                 :           3 :         }
     566                 :             : 
     567                 :          13 :         JS::RootedValue elem(context);
     568                 :          13 :         JS::RootedObject out_array(context, rval.toObjectOrNull());
     569                 :          13 :         gsize elem_idx = 0;
     570                 :             :         /* more than one of a return value or an out argument.
     571                 :             :          * Should be an array of output values. */
     572                 :             : 
     573         [ +  + ]:          13 :         if (!ret_type_is_void) {
     574                 :             :             GIArgument argument;
     575                 :          10 :             GITransfer transfer = g_callable_info_get_caller_owns(m_info);
     576                 :             : 
     577         [ -  + ]:          10 :             if (!JS_GetElement(context, out_array, elem_idx, &elem))
     578                 :           0 :                 return false;
     579                 :             : 
     580         [ -  + ]:          10 :             if (!gjs_value_to_gi_argument(context, elem, ret_type, "callback",
     581                 :             :                                           GJS_ARGUMENT_RETURN_VALUE, transfer,
     582                 :             :                                           GjsArgumentFlags::MAY_BE_NULL,
     583                 :             :                                           &argument))
     584                 :           0 :                 return false;
     585                 :             : 
     586   [ +  -  +  + ]:          10 :             if ((ret_tag == GI_TYPE_TAG_FILENAME ||
     587         [ +  - ]:           2 :                  ret_tag == GI_TYPE_TAG_UTF8) &&
     588                 :             :                 transfer == GI_TRANSFER_NOTHING) {
     589                 :             :                 // We duplicated the string so not to leak we need to both
     590                 :             :                 // ensure that the string is bound to the object lifetime or
     591                 :             :                 // created once
     592         [ +  - ]:           2 :                 if (gobject) {
     593                 :           2 :                     ObjectInstance::associate_string(
     594                 :             :                         gobject, gjs_arg_get<char*>(&argument));
     595                 :             :                 } else {
     596                 :           0 :                     GjsAutoChar str = gjs_arg_steal<char*>(&argument);
     597                 :           0 :                     gjs_arg_set<const char*>(&argument, g_intern_string(str));
     598                 :           0 :                 }
     599                 :             :             }
     600                 :             : 
     601                 :          10 :             set_return_ffi_arg_from_gi_argument(ret_type, result, &argument);
     602                 :             : 
     603                 :          10 :             elem_idx++;
     604                 :             :         }
     605                 :             : 
     606         [ +  + ]:          40 :         for (int i = 0; i < n_args; i++) {
     607                 :             :             GIArgInfo arg_info;
     608                 :          27 :             g_callable_info_load_arg(m_info, i, &arg_info);
     609         [ +  + ]:          27 :             if (g_arg_info_get_direction(&arg_info) == GI_DIRECTION_IN)
     610                 :           8 :                 continue;
     611                 :             : 
     612         [ -  + ]:          19 :             if (!JS_GetElement(context, out_array, elem_idx, &elem))
     613                 :           0 :                 return false;
     614                 :             : 
     615         [ -  + ]:          19 :             if (!gjs_value_to_callback_out_arg(
     616                 :             :                     context, elem, &arg_info,
     617                 :             :                     get_argument_for_arg_info(&arg_info, args,
     618                 :             :                                               i + c_args_offset)))
     619                 :           0 :                 return false;
     620                 :             : 
     621                 :          19 :             elem_idx++;
     622                 :             :         }
     623   [ +  -  +  - ]:          13 :     }
     624                 :             : 
     625         [ +  + ]:         458 :     if (!in_args_to_cleanup)
     626                 :         453 :         return true;
     627                 :             : 
     628         [ +  + ]:          12 :     for (int i = 0; i < n_args; i++) {
     629                 :             :         GIArgInfo arg_info;
     630                 :           7 :         g_callable_info_load_arg(m_info, i, &arg_info);
     631                 :           7 :         GITransfer transfer = g_arg_info_get_ownership_transfer(&arg_info);
     632                 :             : 
     633         [ -  + ]:           7 :         if (transfer == GI_TRANSFER_NOTHING)
     634                 :           7 :             continue;
     635                 :             : 
     636         [ +  + ]:           7 :         if (g_arg_info_get_direction(&arg_info) != GI_DIRECTION_IN)
     637                 :           6 :             continue;
     638                 :             : 
     639                 :           1 :         GIArgument* arg = args[i + c_args_offset];
     640         [ +  - ]:           1 :         if (m_scope == GI_SCOPE_TYPE_CALL) {
     641                 :             :             GITypeInfo type_info;
     642                 :           1 :             g_arg_info_load_type(&arg_info, &type_info);
     643                 :             : 
     644         [ -  + ]:           1 :             if (!gjs_gi_argument_release(context, transfer, &type_info, arg))
     645                 :           0 :                 return false;
     646                 :             : 
     647                 :           1 :             continue;
     648                 :           1 :         }
     649                 :             : 
     650                 :             :         struct InvalidateData {
     651                 :             :             GIArgInfo arg_info;
     652                 :             :             GIArgument arg;
     653                 :             :         };
     654                 :             : 
     655                 :           0 :         auto* data = new InvalidateData({arg_info, *arg});
     656                 :           0 :         g_closure_add_invalidate_notifier(
     657                 :           0 :             this, data, [](void* invalidate_data, GClosure* c) {
     658                 :           0 :                 auto* self = static_cast<GjsCallbackTrampoline*>(c);
     659                 :             :                 std::unique_ptr<InvalidateData> data(
     660                 :           0 :                     static_cast<InvalidateData*>(invalidate_data));
     661                 :             :                 GITransfer transfer =
     662                 :           0 :                     g_arg_info_get_ownership_transfer(&data->arg_info);
     663                 :             : 
     664                 :             :                 GITypeInfo type_info;
     665                 :           0 :                 g_arg_info_load_type(&data->arg_info, &type_info);
     666         [ #  # ]:           0 :                 if (!gjs_gi_argument_release(self->context(), transfer,
     667                 :           0 :                                              &type_info, &data->arg)) {
     668                 :           0 :                     gjs_throw(self->context(),
     669                 :             :                               "Impossible to release closure argument '%s'",
     670                 :           0 :                               g_base_info_get_name(&data->arg_info));
     671                 :             :                 }
     672                 :           0 :             });
     673                 :             :     }
     674                 :             : 
     675                 :           5 :     return true;
     676                 :         483 : }
     677                 :             : 
     678                 :         298 : GjsCallbackTrampoline* GjsCallbackTrampoline::create(
     679                 :             :     JSContext* cx, JS::HandleObject callable, GICallableInfo* callable_info,
     680                 :             :     GIScopeType scope, bool has_scope_object, bool is_vfunc) {
     681                 :         298 :     g_assert(JS::IsCallable(callable) &&
     682                 :             :              "tried to create a callback trampoline for a non-callable object");
     683                 :             : 
     684                 :             :     auto* trampoline = new GjsCallbackTrampoline(
     685                 :         298 :         cx, callable, callable_info, scope, has_scope_object, is_vfunc);
     686                 :             : 
     687         [ +  + ]:         298 :     if (!trampoline->initialize()) {
     688                 :           1 :         g_closure_unref(trampoline);
     689                 :           1 :         return nullptr;
     690                 :             :     }
     691                 :             : 
     692                 :         297 :     return trampoline;
     693                 :             : }
     694                 :             : 
     695                 :             : decltype(GjsCallbackTrampoline::s_forever_closure_list)
     696                 :             :     GjsCallbackTrampoline::s_forever_closure_list;
     697                 :             : 
     698                 :         298 : GjsCallbackTrampoline::GjsCallbackTrampoline(
     699                 :             :     JSContext* cx, JS::HandleObject callable, GICallableInfo* callable_info,
     700                 :         298 :     GIScopeType scope, bool has_scope_object, bool is_vfunc)
     701                 :             :     // The rooting rule is:
     702                 :             :     // - notify callbacks in GObject methods are traced from the scope object
     703                 :             :     // - async and call callbacks, and other notify callbacks, are rooted
     704                 :             :     // - vfuncs are traced from the GObject prototype
     705                 :             :     : Closure(cx, callable,
     706   [ +  +  +  + ]:         298 :               scope != GI_SCOPE_TYPE_NOTIFIED || !has_scope_object,
     707                 :             :               g_base_info_get_name(callable_info)),
     708                 :         298 :       m_info(callable_info, GjsAutoTakeOwnership()),
     709                 :         298 :       m_param_types(std::make_unique<GjsParamType[]>(
     710                 :         298 :           g_callable_info_get_n_args(callable_info))),
     711                 :         298 :       m_scope(scope),
     712                 :         894 :       m_is_vfunc(is_vfunc) {
     713                 :         298 :     add_finalize_notifier<GjsCallbackTrampoline>();
     714                 :         298 : }
     715                 :             : 
     716                 :         282 : GjsCallbackTrampoline::~GjsCallbackTrampoline() {
     717   [ +  -  +  +  :         282 :     if (m_info && m_closure) {
                   +  + ]
     718                 :             : #if GI_CHECK_VERSION(1, 71, 0)
     719                 :         281 :         g_callable_info_destroy_closure(m_info, m_closure);
     720                 :             : #else
     721                 :             :         g_callable_info_free_closure(m_info, m_closure);
     722                 :             : #endif
     723                 :             :     }
     724                 :         282 : }
     725                 :             : 
     726                 :           1 : void GjsCallbackTrampoline::mark_forever() {
     727                 :           1 :     s_forever_closure_list.emplace_back(this, GjsAutoTakeOwnership{});
     728                 :           1 : }
     729                 :             : 
     730                 :         239 : void GjsCallbackTrampoline::prepare_shutdown() {
     731                 :         239 :     s_forever_closure_list.clear();
     732                 :         239 : }
     733                 :             : 
     734                 :         297 : ffi_closure* GjsCallbackTrampoline::create_closure() {
     735                 :         488 :     auto callback = [](ffi_cif*, void* result, void** ffi_args, void* data) {
     736                 :         488 :         auto** args = reinterpret_cast<GIArgument**>(ffi_args);
     737                 :         488 :         g_assert(data && "Trampoline data is not set");
     738                 :             :         Gjs::Closure::Ptr trampoline(static_cast<GjsCallbackTrampoline*>(data),
     739                 :         488 :                                      GjsAutoTakeOwnership());
     740                 :             : 
     741                 :         488 :         trampoline.as<GjsCallbackTrampoline>()->callback_closure(args, result);
     742                 :         486 :     };
     743                 :             : 
     744                 :             : #if GI_CHECK_VERSION(1, 71, 0)
     745                 :         297 :     return g_callable_info_create_closure(m_info, &m_cif, callback, this);
     746                 :             : #else
     747                 :             :     return g_callable_info_prepare_closure(m_info, &m_cif, callback, this);
     748                 :             : #endif
     749                 :             : }
     750                 :             : 
     751                 :         298 : bool GjsCallbackTrampoline::initialize() {
     752                 :         298 :     g_assert(is_valid());
     753                 :         298 :     g_assert(!m_closure);
     754                 :             : 
     755                 :             :     /* Analyze param types and directions, similarly to
     756                 :             :      * init_cached_function_data */
     757                 :         298 :     int n_param_types = g_callable_info_get_n_args(m_info);
     758         [ +  + ]:         906 :     for (int i = 0; i < n_param_types; i++) {
     759                 :             :         GIDirection direction;
     760                 :             :         GIArgInfo arg_info;
     761                 :             :         GITypeInfo type_info;
     762                 :             :         GITypeTag type_tag;
     763                 :             : 
     764         [ +  + ]:         609 :         if (m_param_types[i] == PARAM_SKIPPED)
     765                 :          45 :             continue;
     766                 :             : 
     767                 :         606 :         g_callable_info_load_arg(m_info, i, &arg_info);
     768                 :         606 :         g_arg_info_load_type(&arg_info, &type_info);
     769                 :             : 
     770                 :         606 :         direction = g_arg_info_get_direction(&arg_info);
     771                 :         606 :         type_tag = g_type_info_get_tag(&type_info);
     772                 :             : 
     773         [ +  + ]:         606 :         if (direction != GI_DIRECTION_IN) {
     774                 :             :             /* INOUT and OUT arguments are handled differently. */
     775                 :          42 :             continue;
     776                 :             :         }
     777                 :             : 
     778         [ +  + ]:         564 :         if (type_tag == GI_TYPE_TAG_INTERFACE) {
     779                 :             :             GjsAutoBaseInfo interface_info =
     780                 :         308 :                 g_type_info_get_interface(&type_info);
     781                 :         308 :             GIInfoType interface_type = interface_info.type();
     782         [ +  + ]:         308 :             if (interface_type == GI_INFO_TYPE_CALLBACK) {
     783                 :           2 :                 gjs_throw(context(),
     784                 :             :                           "%s %s accepts another callback as a parameter. This "
     785                 :             :                           "is not supported",
     786         [ +  - ]:           1 :                           m_is_vfunc ? "VFunc" : "Callback", m_info.name());
     787                 :           1 :                 return false;
     788                 :             :             }
     789   [ +  +  +  + ]:         564 :         } else if (type_tag == GI_TYPE_TAG_ARRAY) {
     790         [ +  - ]:           3 :             if (g_type_info_get_array_type(&type_info) == GI_ARRAY_TYPE_C) {
     791                 :           3 :                 int array_length_pos = g_type_info_get_array_length(&type_info);
     792                 :             : 
     793         [ -  + ]:           3 :                 if (array_length_pos < 0)
     794                 :           0 :                     continue;
     795                 :             : 
     796         [ +  - ]:           3 :                 if (array_length_pos < n_param_types) {
     797                 :             :                     GIArgInfo length_arg_info;
     798                 :             : 
     799                 :           3 :                     g_callable_info_load_arg(m_info, array_length_pos,
     800                 :             :                                              &length_arg_info);
     801         [ -  + ]:           3 :                     if (g_arg_info_get_direction(&length_arg_info) != direction) {
     802                 :           0 :                         gjs_throw(context(),
     803                 :             :                                   "%s %s has an array with different-direction "
     804                 :             :                                   "length argument. This is not supported",
     805         [ #  # ]:           0 :                                   m_is_vfunc ? "VFunc" : "Callback",
     806                 :             :                                   m_info.name());
     807                 :           0 :                         return false;
     808                 :             :                     }
     809                 :             : 
     810                 :           3 :                     m_param_types[array_length_pos] = PARAM_SKIPPED;
     811                 :           3 :                     m_param_types[i] = PARAM_ARRAY;
     812                 :             :                 }
     813                 :             :             }
     814                 :             :         }
     815                 :             :     }
     816                 :             : 
     817                 :         297 :     m_closure = create_closure();
     818                 :         297 :     return true;
     819                 :             : }
     820                 :             : 
     821                 :             : // Intended for error messages
     822                 :       64466 : std::string Gjs::Function::format_name() {
     823                 :       64466 :     bool is_method = g_callable_info_is_method(m_info);
     824         [ +  + ]:       64466 :     std::string retval = is_method ? "method" : "function";
     825                 :       64466 :     retval += ' ';
     826                 :       64466 :     retval += m_info.ns();
     827                 :       64466 :     retval += '.';
     828         [ +  + ]:       64466 :     if (is_method) {
     829                 :       35479 :         retval += g_base_info_get_name(g_base_info_get_container(m_info));
     830                 :       35479 :         retval += '.';
     831                 :             :     }
     832                 :       64466 :     retval += m_info.name();
     833                 :       64466 :     return retval;
     834                 :             : }
     835                 :             : 
     836                 :             : namespace Gjs {
     837                 :             : 
     838                 :       64405 : static void* get_return_ffi_pointer_from_gi_argument(
     839                 :             :     GITypeTag tag, GITypeInfo* return_type, GIFFIReturnValue* return_value) {
     840   [ +  +  +  +  :       64405 :     if (return_type && g_type_info_is_pointer(return_type))
                   +  + ]
     841                 :       17619 :         return &gjs_arg_member<void*>(return_value);
     842   [ +  +  +  +  :       46786 :     switch (tag) {
          +  +  +  +  +  
          +  +  +  +  +  
                      + ]
     843                 :       28753 :         case GI_TYPE_TAG_VOID:
     844                 :       28753 :             return nullptr;
     845                 :          14 :         case GI_TYPE_TAG_INT8:
     846                 :          14 :             return &gjs_arg_member<int8_t>(return_value);
     847                 :          20 :         case GI_TYPE_TAG_INT16:
     848                 :          20 :             return &gjs_arg_member<int16_t>(return_value);
     849                 :         129 :         case GI_TYPE_TAG_INT32:
     850                 :         129 :             return &gjs_arg_member<int32_t>(return_value);
     851                 :          21 :         case GI_TYPE_TAG_UINT8:
     852                 :          21 :             return &gjs_arg_member<uint8_t>(return_value);
     853                 :          13 :         case GI_TYPE_TAG_UINT16:
     854                 :          13 :             return &gjs_arg_member<uint16_t>(return_value);
     855                 :       11667 :         case GI_TYPE_TAG_UINT32:
     856                 :       11667 :             return &gjs_arg_member<uint32_t>(return_value);
     857                 :        1058 :         case GI_TYPE_TAG_BOOLEAN:
     858                 :        1058 :             return &gjs_arg_member<gboolean, GI_TYPE_TAG_BOOLEAN>(return_value);
     859                 :           3 :         case GI_TYPE_TAG_UNICHAR:
     860                 :           3 :             return &gjs_arg_member<uint32_t>(return_value);
     861                 :          72 :         case GI_TYPE_TAG_INT64:
     862                 :          72 :             return &gjs_arg_member<int64_t>(return_value);
     863                 :         657 :         case GI_TYPE_TAG_UINT64:
     864                 :         657 :             return &gjs_arg_member<uint64_t>(return_value);
     865                 :          11 :         case GI_TYPE_TAG_FLOAT:
     866                 :          11 :             return &gjs_arg_member<float>(return_value);
     867                 :          18 :         case GI_TYPE_TAG_DOUBLE:
     868                 :          18 :             return &gjs_arg_member<double>(return_value);
     869                 :        2276 :         case GI_TYPE_TAG_INTERFACE: {
     870         [ -  + ]:        2276 :             if (!return_type)
     871                 :           0 :                 return nullptr;
     872                 :             : 
     873                 :        2276 :             GjsAutoBaseInfo info = g_type_info_get_interface(return_type);
     874                 :             : 
     875         [ +  - ]:        2276 :             switch (info.type()) {
     876                 :        2276 :                 case GI_INFO_TYPE_ENUM:
     877                 :             :                 case GI_INFO_TYPE_FLAGS:
     878                 :        2276 :                     return &gjs_arg_member<int, GI_TYPE_TAG_INTERFACE>(
     879                 :        2276 :                         return_value);
     880                 :           0 :                 default:
     881                 :           0 :                     return &gjs_arg_member<void*>(return_value);
     882                 :             :             }
     883                 :             :             break;
     884                 :        2276 :         }
     885                 :        2074 :         default:
     886                 :        2074 :             return &gjs_arg_member<void*>(return_value);
     887                 :             :     }
     888                 :             : }
     889                 :             : 
     890                 :             : // This function can be called in two different ways. You can either use it to
     891                 :             : // create JavaScript objects by calling it without @r_value, or you can decide
     892                 :             : // to keep the return values in GIArgument format by providing a @r_value
     893                 :             : // argument.
     894                 :       64469 : bool Function::invoke(JSContext* context, const JS::CallArgs& args,
     895                 :             :                       JS::HandleObject this_obj /* = nullptr */,
     896                 :             :                       GIArgument* r_value /* = nullptr */) {
     897                 :       64469 :     g_assert((args.isConstructing() || !this_obj) &&
     898                 :             :              "If not a constructor, then pass the 'this' object via CallArgs");
     899                 :             : 
     900                 :             :     void* return_value_p;  // will point inside the return GIArgument union
     901                 :             :     GIFFIReturnValue return_value;
     902                 :             : 
     903                 :       64469 :     unsigned ffi_argc = m_invoker.cif.nargs;
     904                 :       64469 :     GjsFunctionCallState state(context, m_info);
     905                 :             : 
     906         [ -  + ]:       64469 :     if (state.gi_argc > Argument::MAX_ARGS) {
     907                 :           0 :         gjs_throw(context, "Function %s has too many arguments",
     908                 :           0 :                   format_name().c_str());
     909                 :           0 :         return false;
     910                 :             :     }
     911                 :             : 
     912                 :             :     // ffi_argc is the number of arguments that the underlying C function takes.
     913                 :             :     // state.gi_argc is the number of arguments the GICallableInfo describes
     914                 :             :     // (which does not include "this" or GError**). m_js_in_argc is the number
     915                 :             :     // of arguments we expect the JS function to take (which does not include
     916                 :             :     // PARAM_SKIPPED args).
     917                 :             :     // args.length() is the number of arguments that were actually passed.
     918         [ +  + ]:       64469 :     if (args.length() > m_js_in_argc) {
     919                 :           2 :         if (!JS::WarnUTF8(context,
     920                 :             :                           "Too many arguments to %s: expected %u, got %u",
     921         [ -  + ]:           2 :                           format_name().c_str(), m_js_in_argc, args.length()))
     922                 :           0 :             return false;
     923         [ +  + ]:       64468 :     } else if (args.length() < m_js_in_argc) {
     924                 :           3 :         args.reportMoreArgsNeeded(context, format_name().c_str(), m_js_in_argc,
     925                 :             :                                   args.length());
     926                 :           3 :         return false;
     927                 :             :     }
     928                 :             : 
     929                 :             :     // These arrays hold argument pointers.
     930                 :             :     // - state.in_cvalue(): C values which are passed on input (in or inout)
     931                 :             :     // - state.out_cvalue(): C values which are returned as arguments (out or
     932                 :             :     //   inout)
     933                 :             :     // - state.inout_original_cvalue(): For the special case of (inout) args,
     934                 :             :     //   we need to keep track of the original values we passed into the
     935                 :             :     //   function, in case we need to free it.
     936                 :             :     // - ffi_arg_pointers: For passing data to FFI, we need to create another
     937                 :             :     //   layer of indirection; this array is a pointer to an element in
     938                 :             :     //   state.in_cvalue() or state.out_cvalue().
     939                 :             :     // - return_value: The actual return value of the C function, i.e. not an
     940                 :             :     //   (out) param
     941                 :             :     //
     942                 :             :     // The 3 GIArgument arrays are indexed by the GI argument index.
     943                 :             :     // ffi_arg_pointers, on the other hand, represents the actual C arguments,
     944                 :             :     // in the way ffi expects them.
     945                 :             : 
     946                 :       64466 :     auto ffi_arg_pointers = std::make_unique<void*[]>(ffi_argc);
     947                 :             : 
     948                 :       64466 :     int gi_arg_pos = 0;        // index into GIArgument array
     949                 :       64466 :     unsigned ffi_arg_pos = 0;  // index into ffi_arg_pointers
     950                 :       64466 :     unsigned js_arg_pos = 0;   // index into args
     951                 :             : 
     952                 :       64466 :     JS::RootedObject obj(context, this_obj);
     953   [ +  +  -  +  :       64466 :     if (!args.isConstructing() && !args.computeThis(context, &obj))
                   -  + ]
     954                 :           0 :         return false;
     955                 :             : 
     956                 :       64466 :     std::string dynamicString("(unknown)");
     957                 :             : 
     958         [ +  + ]:       64466 :     if (state.is_method) {
     959                 :       35482 :         GIArgument* in_value = state.instance();
     960                 :       35482 :         JS::RootedValue in_js_value(context, JS::ObjectValue(*obj));
     961                 :             : 
     962         [ +  + ]:       35482 :         if (!m_arguments.instance()->in(context, &state, in_value, in_js_value))
     963                 :           4 :             return false;
     964                 :             : 
     965                 :       35478 :         ffi_arg_pointers[ffi_arg_pos] = in_value;
     966                 :       35478 :         ++ffi_arg_pos;
     967                 :             : 
     968                 :             :         // Callback lifetimes will be attached to the instance object if it is
     969                 :             :         // a GObject or GInterface
     970                 :       35478 :         GType gtype = m_arguments.instance_type();
     971         [ +  + ]:       35478 :         if (gtype != G_TYPE_NONE) {
     972   [ +  +  +  +  :       69036 :             if (g_type_is_a(gtype, G_TYPE_OBJECT) ||
             +  -  +  + ]
     973         [ +  + ]:       33814 :                 g_type_is_a(gtype, G_TYPE_INTERFACE))
     974                 :        1411 :                 state.instance_object = obj;
     975                 :             : 
     976   [ +  +  +  +  :       35222 :             if (g_type_is_a(gtype, G_TYPE_OBJECT)) {
                   +  + ]
     977                 :        1408 :                 auto* o = ObjectBase::for_js(context, obj);
     978                 :        1408 :                 dynamicString = o->format_name();
     979                 :             :             }
     980                 :             :         }
     981         [ +  + ]:       35482 :     }
     982                 :             : 
     983                 :       64462 :     dynamicString += '.';
     984                 :       64462 :     dynamicString += format_name();
     985                 :       64462 :     AutoProfilerLabel label(context, "", dynamicString.c_str());
     986                 :             : 
     987                 :       64462 :     g_assert(ffi_arg_pos + state.gi_argc <
     988                 :             :              std::numeric_limits<decltype(state.processed_c_args)>::max());
     989                 :             : 
     990                 :       64462 :     state.processed_c_args = ffi_arg_pos;
     991         [ +  + ]:      135803 :     for (gi_arg_pos = 0; gi_arg_pos < state.gi_argc;
     992                 :       71341 :          gi_arg_pos++, ffi_arg_pos++) {
     993                 :       71398 :         GIArgument* in_value = &state.in_cvalue(gi_arg_pos);
     994                 :       71398 :         Argument* gjs_arg = m_arguments.argument(gi_arg_pos);
     995                 :             : 
     996                 :             :         gjs_debug_marshal(GJS_DEBUG_GFUNCTION,
     997                 :             :                           "Marshalling argument '%s' in, %d/%d GI args, %u/%u "
     998                 :             :                           "C args, %u/%u JS args",
     999                 :             :                           gjs_arg ? gjs_arg->arg_name() : "<unknown>",
    1000                 :             :                           gi_arg_pos, state.gi_argc, ffi_arg_pos, ffi_argc,
    1001                 :             :                           js_arg_pos, args.length());
    1002                 :             : 
    1003                 :       71398 :         ffi_arg_pointers[ffi_arg_pos] = in_value;
    1004                 :             : 
    1005         [ -  + ]:       71398 :         if (!gjs_arg) {
    1006                 :             :             GIArgInfo arg_info;
    1007                 :           0 :             g_callable_info_load_arg(m_info, gi_arg_pos, &arg_info);
    1008                 :           0 :             gjs_throw(context,
    1009                 :             :                       "Error invoking %s: impossible to determine what to pass "
    1010                 :             :                       "to the '%s' argument. It may be that the function is "
    1011                 :             :                       "unsupported, or there may be a bug in its annotations.",
    1012                 :           0 :                       format_name().c_str(), g_base_info_get_name(&arg_info));
    1013                 :           0 :             state.failed = true;
    1014                 :           0 :             break;
    1015                 :             :         }
    1016                 :             : 
    1017                 :       71398 :         JS::RootedValue js_in_arg(context);
    1018         [ +  + ]:       71398 :         if (js_arg_pos < args.length())
    1019                 :       70143 :             js_in_arg = args[js_arg_pos];
    1020                 :             : 
    1021         [ +  + ]:       71398 :         if (!gjs_arg->in(context, &state, in_value, js_in_arg)) {
    1022                 :          57 :             state.failed = true;
    1023                 :          57 :             break;
    1024                 :             :         }
    1025                 :             : 
    1026         [ +  + ]:       71341 :         if (!gjs_arg->skip_in())
    1027                 :       69959 :             js_arg_pos++;
    1028                 :             : 
    1029                 :       71341 :         state.processed_c_args++;
    1030         [ +  + ]:       71398 :     }
    1031                 :             : 
    1032                 :             :     // This pointer needs to exist on the stack across the ffi_call() call
    1033                 :       64462 :     GError** errorp = &state.local_error;
    1034                 :             : 
    1035                 :             :     /* Did argument conversion fail?  In that case, skip invocation and jump to release
    1036                 :             :      * processing. */
    1037         [ +  + ]:       64462 :     if (state.failed)
    1038                 :          57 :         return finish_invoke(context, args, &state, r_value);
    1039                 :             : 
    1040         [ +  + ]:       64405 :     if (state.can_throw_gerror) {
    1041                 :         320 :         g_assert(ffi_arg_pos < ffi_argc && "GError** argument number mismatch");
    1042                 :         320 :         ffi_arg_pointers[ffi_arg_pos] = &errorp;
    1043                 :         320 :         ffi_arg_pos++;
    1044                 :             : 
    1045                 :             :         /* don't update state.processed_c_args as we deal with local_error
    1046                 :             :          * separately */
    1047                 :             :     }
    1048                 :             : 
    1049                 :       64405 :     g_assert_cmpuint(ffi_arg_pos, ==, ffi_argc);
    1050                 :       64405 :     g_assert_cmpuint(gi_arg_pos, ==, state.gi_argc);
    1051                 :             : 
    1052                 :       64405 :     GITypeTag return_tag = m_arguments.return_tag();
    1053                 :       64405 :     GITypeInfo* return_type = m_arguments.return_type();
    1054                 :       64405 :     return_value_p = get_return_ffi_pointer_from_gi_argument(
    1055                 :             :         return_tag, return_type, &return_value);
    1056                 :       64405 :     ffi_call(&m_invoker.cif, FFI_FN(m_invoker.native_address), return_value_p,
    1057                 :             :              ffi_arg_pointers.get());
    1058                 :             : 
    1059                 :             :     /* Return value and out arguments are valid only if invocation doesn't
    1060                 :             :      * return error. In arguments need to be released always.
    1061                 :             :      */
    1062         [ +  + ]:       64403 :     if (!r_value)
    1063                 :       64388 :         args.rval().setUndefined();
    1064                 :             : 
    1065         [ +  + ]:       64403 :     if (return_type) {
    1066                 :       21284 :         gi_type_info_extract_ffi_return_value(return_type, &return_value,
    1067                 :             :                                               state.return_value());
    1068         [ +  + ]:       43119 :     } else if (return_tag != GI_TYPE_TAG_VOID) {
    1069                 :       14368 :         g_assert(GI_TYPE_TAG_IS_BASIC(return_tag));
    1070                 :       14368 :         gi_type_tag_extract_ffi_return_value(return_tag, GI_INFO_TYPE_INVALID,
    1071                 :             :                                              &return_value,
    1072                 :             :                                              state.return_value());
    1073                 :             :     }
    1074                 :             : 
    1075                 :             :     // Process out arguments and return values. This loop is skipped if we fail
    1076                 :             :     // the type conversion above, or if state.did_throw_gerror is true.
    1077                 :       64403 :     js_arg_pos = 0;
    1078         [ +  + ]:      200139 :     for (gi_arg_pos = -1; gi_arg_pos < state.gi_argc; gi_arg_pos++) {
    1079                 :             :         Argument* gjs_arg;
    1080                 :             :         GIArgument* out_value;
    1081                 :             : 
    1082         [ +  + ]:      135736 :         if (gi_arg_pos == -1) {
    1083                 :       64403 :             out_value = state.return_value();
    1084                 :       64403 :             gjs_arg = m_arguments.return_value();
    1085                 :             :         } else {
    1086                 :       71333 :             out_value = &state.out_cvalue(gi_arg_pos);
    1087                 :       71333 :             gjs_arg = m_arguments.argument(gi_arg_pos);
    1088                 :             :         }
    1089                 :             : 
    1090                 :             :         gjs_debug_marshal(GJS_DEBUG_GFUNCTION,
    1091                 :             :                           "Marshalling argument '%s' out, %d/%d GI args",
    1092                 :             :                           gjs_arg ? gjs_arg->arg_name() : "<unknown>",
    1093                 :             :                           gi_arg_pos, state.gi_argc);
    1094                 :             : 
    1095                 :      135736 :         JS::RootedValue js_out_arg(context);
    1096         [ +  + ]:      135736 :         if (!r_value) {
    1097   [ +  +  -  + ]:      135706 :             if (!gjs_arg && gi_arg_pos >= 0) {
    1098                 :             :                 GIArgInfo arg_info;
    1099                 :           0 :                 g_callable_info_load_arg(m_info, gi_arg_pos, &arg_info);
    1100                 :           0 :                 gjs_throw(
    1101                 :             :                     context,
    1102                 :             :                     "Error invoking %s.%s: impossible to determine what "
    1103                 :             :                     "to pass to the out '%s' argument. It may be that the "
    1104                 :             :                     "function is unsupported, or there may be a bug in "
    1105                 :             :                     "its annotations.",
    1106                 :             :                     m_info.ns(), m_info.name(),
    1107                 :             :                     g_base_info_get_name(&arg_info));
    1108                 :           0 :                 state.failed = true;
    1109                 :           0 :                 break;
    1110                 :             :             }
    1111                 :             : 
    1112         [ +  + ]:      242661 :             if (gjs_arg &&
    1113   [ -  +  -  + ]:      242661 :                 !gjs_arg->out(context, &state, out_value, &js_out_arg)) {
    1114                 :           0 :                 state.failed = true;
    1115                 :           0 :                 break;
    1116                 :             :             }
    1117                 :             :         }
    1118                 :             : 
    1119   [ +  +  +  +  :      135736 :         if (gjs_arg && !gjs_arg->skip_out()) {
                   +  + ]
    1120         [ +  + ]:       36414 :             if (!r_value) {
    1121         [ -  + ]:       36399 :                 if (!state.return_values.append(js_out_arg)) {
    1122                 :           0 :                     JS_ReportOutOfMemory(context);
    1123                 :           0 :                     state.failed = true;
    1124                 :           0 :                     break;
    1125                 :             :                 }
    1126                 :             :             }
    1127                 :       36414 :             js_arg_pos++;
    1128                 :             :         }
    1129         [ +  - ]:      135736 :     }
    1130                 :             : 
    1131                 :       64403 :     g_assert(state.failed || state.did_throw_gerror() ||
    1132                 :             :              js_arg_pos == m_js_out_argc);
    1133                 :             : 
    1134                 :             :     // If we failed before calling the function, or if the function threw an
    1135                 :             :     // exception, then any GI_TRANSFER_EVERYTHING or GI_TRANSFER_CONTAINER
    1136                 :             :     // in-parameters were not transferred. Treat them as GI_TRANSFER_NOTHING so
    1137                 :             :     // that they are freed.
    1138                 :       64403 :     return finish_invoke(context, args, &state, r_value);
    1139                 :       64467 : }
    1140                 :             : 
    1141                 :       64460 : bool Function::finish_invoke(JSContext* cx, const JS::CallArgs& args,
    1142                 :             :                              GjsFunctionCallState* state,
    1143                 :             :                              GIArgument* r_value /* = nullptr */) {
    1144                 :             :     // In this loop we use ffi_arg_pos just to ensure we don't release stuff
    1145                 :             :     // we haven't allocated yet, if we failed in type conversion above.
    1146                 :             :     // If we start from -1 (the return value), we need to process 1 more than
    1147                 :             :     // state.processed_c_args.
    1148                 :             :     // If we start from -2 (the instance parameter), we need to process 2 more
    1149                 :       64460 :     unsigned ffi_arg_pos = state->first_arg_offset() - 1;
    1150                 :       64460 :     unsigned ffi_arg_max = state->last_processed_index();
    1151                 :       64460 :     bool postinvoke_release_failed = false;
    1152                 :       64460 :     for (int gi_arg_pos = -(state->first_arg_offset());
    1153   [ +  +  +  + ]:      235737 :          gi_arg_pos < state->gi_argc && ffi_arg_pos < ffi_arg_max;
    1154                 :      171277 :          gi_arg_pos++, ffi_arg_pos++) {
    1155                 :             :         Argument* gjs_arg;
    1156                 :      171277 :         GIArgument* in_value = nullptr;
    1157                 :      171277 :         GIArgument* out_value = nullptr;
    1158                 :             : 
    1159         [ +  + ]:      171277 :         if (gi_arg_pos == -2) {
    1160                 :       35476 :             in_value = state->instance();
    1161                 :       35476 :             gjs_arg = m_arguments.instance();
    1162         [ +  + ]:      135801 :         } else if (gi_arg_pos == -1) {
    1163                 :       64460 :             out_value = state->return_value();
    1164                 :       64460 :             gjs_arg = m_arguments.return_value();
    1165                 :             :         } else {
    1166                 :       71341 :             in_value = &state->in_cvalue(gi_arg_pos);
    1167                 :       71341 :             out_value = &state->out_cvalue(gi_arg_pos);
    1168                 :       71341 :             gjs_arg = m_arguments.argument(gi_arg_pos);
    1169                 :             :         }
    1170                 :             : 
    1171         [ +  + ]:      171277 :         if (!gjs_arg)
    1172                 :       28758 :             continue;
    1173                 :             : 
    1174                 :             :         gjs_debug_marshal(
    1175                 :             :             GJS_DEBUG_GFUNCTION,
    1176                 :             :             "Releasing argument '%s', %d/%d GI args, %u/%u C args",
    1177                 :             :             gjs_arg->arg_name(), gi_arg_pos, state->gi_argc, ffi_arg_pos,
    1178                 :             :             state->processed_c_args);
    1179                 :             : 
    1180                 :             :         // Only process in or inout arguments if we failed, the rest is garbage
    1181   [ +  +  +  +  :      142519 :         if (state->failed && gjs_arg->skip_in())
                   +  + ]
    1182                 :          55 :             continue;
    1183                 :             : 
    1184                 :             :         // Save the return GIArgument if it was requested
    1185   [ +  +  +  + ]:      142464 :         if (r_value && gi_arg_pos == -1) {
    1186                 :          15 :             *r_value = *out_value;
    1187                 :          15 :             continue;
    1188                 :             :         }
    1189                 :             : 
    1190         [ -  + ]:      142449 :         if (!gjs_arg->release(cx, state, in_value, out_value)) {
    1191                 :           0 :             postinvoke_release_failed = true;
    1192                 :             :             // continue with the release even if we fail, to avoid leaks
    1193                 :             :         }
    1194                 :             :     }
    1195                 :             : 
    1196         [ -  + ]:       64460 :     if (postinvoke_release_failed)
    1197                 :           0 :         state->failed = true;
    1198                 :             : 
    1199                 :       64460 :     g_assert(ffi_arg_pos == state->last_processed_index());
    1200                 :             : 
    1201   [ +  +  +  +  :       64460 :     if (!r_value && m_js_out_argc > 0 && state->call_completed()) {
             +  +  +  + ]
    1202                 :             :         // If we have one return value or out arg, return that item on its
    1203                 :             :         // own, otherwise return a JavaScript array with [return value,
    1204                 :             :         // out arg 1, out arg 2, ...]
    1205         [ +  + ]:       35775 :         if (m_js_out_argc == 1) {
    1206                 :       35221 :             args.rval().set(state->return_values[0]);
    1207                 :             :         } else {
    1208                 :         554 :             JSObject* array = JS::NewArrayObject(cx, state->return_values);
    1209         [ -  + ]:         554 :             if (!array) {
    1210                 :           0 :                 state->failed = true;
    1211                 :             :             } else {
    1212                 :         554 :                 args.rval().setObject(*array);
    1213                 :             :             }
    1214                 :             :         }
    1215                 :             :     }
    1216                 :             : 
    1217   [ +  +  +  +  :       64460 :     if (!state->failed && state->did_throw_gerror()) {
                   +  + ]
    1218                 :          39 :         return gjs_throw_gerror(cx, state->local_error.release());
    1219         [ +  + ]:       64421 :     } else if (state->failed) {
    1220                 :          57 :         return false;
    1221                 :             :     } else {
    1222                 :       64364 :         return true;
    1223                 :             :     }
    1224                 :             : }
    1225                 :             : 
    1226                 :       64454 : bool Function::call(JSContext* context, unsigned js_argc, JS::Value* vp) {
    1227                 :       64454 :     JS::CallArgs js_argv = JS::CallArgsFromVp(js_argc, vp);
    1228                 :       64454 :     JS::RootedObject callee(context, &js_argv.callee());
    1229                 :             : 
    1230                 :             :     Function* priv;
    1231         [ -  + ]:       64454 :     if (!Function::for_js_typecheck(context, callee, &priv, &js_argv))
    1232                 :           0 :         return false;
    1233                 :             : 
    1234                 :             :     gjs_debug_marshal(GJS_DEBUG_GFUNCTION, "Call callee %p priv %p",
    1235                 :             :                       callee.get(), priv);
    1236                 :             : 
    1237                 :       64454 :     g_assert(priv);
    1238                 :       64454 :     return priv->invoke(context, js_argv);
    1239                 :       64452 : }
    1240                 :             : 
    1241                 :       10745 : Function::~Function() {
    1242                 :       10745 :     g_function_invoker_destroy(&m_invoker);
    1243                 :       10745 :     GJS_DEC_COUNTER(function);
    1244                 :       10745 : }
    1245                 :             : 
    1246                 :       10730 : void Function::finalize_impl(JS::GCContext*, Function* priv) {
    1247                 :       10730 :     g_assert(priv);
    1248         [ +  - ]:       10730 :     delete priv;
    1249                 :       10730 : }
    1250                 :             : 
    1251                 :          18 : bool Function::get_length(JSContext* cx, unsigned argc, JS::Value* vp) {
    1252         [ -  + ]:          18 :     GJS_GET_THIS(cx, argc, vp, args, this_obj);
    1253                 :             :     Function* priv;
    1254         [ -  + ]:          18 :     if (!Function::for_js_instance(cx, this_obj, &priv, &args))
    1255                 :           0 :         return false;
    1256                 :          18 :     args.rval().setInt32(priv->m_js_in_argc);
    1257                 :          18 :     return true;
    1258                 :          18 : }
    1259                 :             : 
    1260                 :           0 : bool Function::to_string(JSContext* context, unsigned argc, JS::Value* vp) {
    1261   [ #  #  #  # ]:           0 :     GJS_CHECK_WRAPPER_PRIV(context, argc, vp, rec, this_obj, Function, priv);
    1262                 :           0 :     return priv->to_string_impl(context, rec.rval());
    1263                 :           0 : }
    1264                 :             : 
    1265                 :           0 : bool Function::to_string_impl(JSContext* cx, JS::MutableHandleValue rval) {
    1266                 :             :     int i, n_jsargs;
    1267                 :             : 
    1268                 :           0 :     int n_args = g_callable_info_get_n_args(m_info);
    1269                 :           0 :     n_jsargs = 0;
    1270                 :           0 :     std::string arg_names;
    1271         [ #  # ]:           0 :     for (i = 0; i < n_args; i++) {
    1272                 :           0 :         Argument* gjs_arg = m_arguments.argument(i);
    1273   [ #  #  #  #  :           0 :         if (!gjs_arg || gjs_arg->skip_in())
                   #  # ]
    1274                 :           0 :             continue;
    1275                 :             : 
    1276         [ #  # ]:           0 :         if (n_jsargs > 0)
    1277                 :           0 :             arg_names += ", ";
    1278                 :             : 
    1279                 :           0 :         n_jsargs++;
    1280                 :           0 :         arg_names += gjs_arg->arg_name();
    1281                 :             :     }
    1282                 :             : 
    1283                 :           0 :     GjsAutoChar descr;
    1284         [ #  # ]:           0 :     if (m_info.type() == GI_INFO_TYPE_FUNCTION) {
    1285                 :             :         descr = g_strdup_printf(
    1286                 :             :             "%s(%s) {\n\t/* wrapper for native symbol %s() */\n}",
    1287                 :           0 :             format_name().c_str(), arg_names.c_str(),
    1288                 :           0 :             g_function_info_get_symbol(m_info));
    1289                 :             :     } else {
    1290                 :             :         descr =
    1291                 :             :             g_strdup_printf("%s(%s) {\n\t/* wrapper for native symbol */\n}",
    1292                 :           0 :                             format_name().c_str(), arg_names.c_str());
    1293                 :             :     }
    1294                 :             : 
    1295                 :           0 :     return gjs_string_from_utf8(cx, descr, rval);
    1296                 :           0 : }
    1297                 :             : 
    1298                 :             : const JSClassOps Function::class_ops = {
    1299                 :             :     nullptr,  // addProperty
    1300                 :             :     nullptr,  // deleteProperty
    1301                 :             :     nullptr,  // enumerate
    1302                 :             :     nullptr,  // newEnumerate
    1303                 :             :     nullptr,  // resolve
    1304                 :             :     nullptr,  // mayResolve
    1305                 :             :     &Function::finalize,
    1306                 :             :     &Function::call,
    1307                 :             : };
    1308                 :             : 
    1309                 :             : const JSPropertySpec Function::proto_props[] = {
    1310                 :             :     JS_PSG("length", &Function::get_length, JSPROP_PERMANENT),
    1311                 :             :     JS_STRING_SYM_PS(toStringTag, "GIRepositoryFunction", JSPROP_READONLY),
    1312                 :             :     JS_PS_END};
    1313                 :             : 
    1314                 :             : /* The original Function.prototype.toString complains when
    1315                 :             :    given a GIRepository function as an argument */
    1316                 :             : // clang-format off
    1317                 :             : const JSFunctionSpec Function::proto_funcs[] = {
    1318                 :             :     JS_FN("toString", &Function::to_string, 0, 0),
    1319                 :             :     JS_FS_END};
    1320                 :             : // clang-format on
    1321                 :             : 
    1322                 :       10918 : bool Function::init(JSContext* context, GType gtype /* = G_TYPE_NONE */) {
    1323                 :             :     guint8 i;
    1324                 :       10918 :     GjsAutoError error;
    1325                 :             : 
    1326         [ +  + ]:       10918 :     if (m_info.type() == GI_INFO_TYPE_FUNCTION) {
    1327         [ -  + ]:       10917 :         if (!g_function_info_prep_invoker(m_info, &m_invoker, &error))
    1328                 :           0 :             return gjs_throw_gerror(context, error);
    1329         [ +  - ]:           1 :     } else if (m_info.type() == GI_INFO_TYPE_VFUNC) {
    1330                 :           1 :         void* addr = g_vfunc_info_get_address(m_info, gtype, &error);
    1331         [ -  + ]:           1 :         if (error) {
    1332         [ #  # ]:           0 :             if (error->code != G_INVOKE_ERROR_SYMBOL_NOT_FOUND)
    1333                 :           0 :                 return gjs_throw_gerror(context, error);
    1334                 :             : 
    1335                 :           0 :             gjs_throw(context, "Virtual function not implemented: %s",
    1336                 :           0 :                       error->message);
    1337                 :           0 :             return false;
    1338                 :             :         }
    1339                 :             : 
    1340         [ -  + ]:           1 :         if (!g_function_invoker_new_for_address(addr, m_info, &m_invoker,
    1341                 :             :                                                 &error))
    1342                 :           0 :             return gjs_throw_gerror(context, error);
    1343                 :             :     }
    1344                 :             : 
    1345                 :       10918 :     uint8_t n_args = g_callable_info_get_n_args(m_info);
    1346                 :             : 
    1347         [ -  + ]:       10918 :     if (!m_arguments.initialize(context, m_info))
    1348                 :           0 :         return false;
    1349                 :             : 
    1350                 :       10918 :     m_arguments.build_instance(m_info);
    1351                 :             : 
    1352                 :             :     bool inc_counter;
    1353                 :       10918 :     m_arguments.build_return(m_info, &inc_counter);
    1354                 :             : 
    1355         [ +  + ]:       10918 :     if (inc_counter)
    1356                 :        8621 :         m_js_out_argc++;
    1357                 :             : 
    1358         [ +  + ]:       31596 :     for (i = 0; i < n_args; i++) {
    1359                 :       20678 :         Argument* gjs_arg = m_arguments.argument(i);
    1360                 :             :         GIDirection direction;
    1361                 :             :         GIArgInfo arg_info;
    1362                 :             : 
    1363   [ +  +  -  +  :       20678 :         if (gjs_arg && (gjs_arg->skip_in() || gjs_arg->skip_out())) {
             -  -  +  + ]
    1364                 :        1640 :             continue;
    1365                 :             :         }
    1366                 :             : 
    1367                 :       19038 :         g_callable_info_load_arg(m_info, i, &arg_info);
    1368                 :       19038 :         direction = g_arg_info_get_direction(&arg_info);
    1369                 :             : 
    1370                 :       19038 :         m_arguments.build_arg(i, direction, &arg_info, m_info, &inc_counter);
    1371                 :             : 
    1372         [ +  + ]:       19038 :         if (inc_counter) {
    1373   [ +  +  +  - ]:       18806 :             switch (direction) {
    1374                 :          61 :                 case GI_DIRECTION_INOUT:
    1375                 :          61 :                     m_js_out_argc++;
    1376                 :             :                     [[fallthrough]];
    1377                 :       18156 :                 case GI_DIRECTION_IN:
    1378                 :       18156 :                     m_js_in_argc++;
    1379                 :       18156 :                     break;
    1380                 :         650 :                 case GI_DIRECTION_OUT:
    1381                 :         650 :                     m_js_out_argc++;
    1382                 :         650 :                     break;
    1383                 :           0 :                 default:
    1384                 :             :                     g_assert_not_reached();
    1385                 :             :             }
    1386                 :             :         }
    1387                 :             :     }
    1388                 :             : 
    1389                 :       10918 :     return true;
    1390                 :       10918 : }
    1391                 :             : 
    1392                 :       10903 : JSObject* Function::create(JSContext* context, GType gtype,
    1393                 :             :                            GICallableInfo* info) {
    1394                 :       10903 :     JS::RootedObject proto(context, Function::create_prototype(context));
    1395         [ -  + ]:       10903 :     if (!proto)
    1396                 :           0 :         return nullptr;
    1397                 :             : 
    1398                 :             :     JS::RootedObject function(
    1399                 :       10903 :         context, JS_NewObjectWithGivenProto(context, &Function::klass, proto));
    1400         [ -  + ]:       10903 :     if (!function) {
    1401                 :           0 :         gjs_debug(GJS_DEBUG_GFUNCTION, "Failed to construct function");
    1402                 :           0 :         return NULL;
    1403                 :             :     }
    1404                 :             : 
    1405                 :       10903 :     auto* priv = new Function(info);
    1406                 :             : 
    1407                 :       10903 :     Function::init_private(function, priv);
    1408                 :             : 
    1409                 :       10903 :     debug_lifecycle(function, priv, "Constructor");
    1410                 :             : 
    1411         [ -  + ]:       10903 :     if (!priv->init(context, gtype))
    1412                 :           0 :         return nullptr;
    1413                 :             : 
    1414                 :       10903 :     return function;
    1415                 :       10903 : }
    1416                 :             : 
    1417                 :             : }  // namespace Gjs
    1418                 :             : 
    1419                 :             : GJS_JSAPI_RETURN_CONVENTION
    1420                 :             : JSObject*
    1421                 :       10903 : gjs_define_function(JSContext       *context,
    1422                 :             :                     JS::HandleObject in_object,
    1423                 :             :                     GType            gtype,
    1424                 :             :                     GICallableInfo  *info)
    1425                 :             : {
    1426                 :             :     GIInfoType info_type;
    1427                 :       10903 :     std::string name;
    1428                 :             : 
    1429                 :       10903 :     info_type = g_base_info_get_type((GIBaseInfo *)info);
    1430                 :             : 
    1431                 :             :     JS::RootedObject function(context,
    1432                 :       10903 :                               Gjs::Function::create(context, gtype, info));
    1433         [ -  + ]:       10903 :     if (!function)
    1434                 :           0 :         return NULL;
    1435                 :             : 
    1436         [ +  + ]:       10903 :     if (info_type == GI_INFO_TYPE_FUNCTION) {
    1437                 :       10902 :         name = g_base_info_get_name(info);
    1438         [ +  - ]:           1 :     } else if (info_type == GI_INFO_TYPE_VFUNC) {
    1439                 :           2 :         name = "vfunc_" + std::string(g_base_info_get_name(info));
    1440                 :             :     } else {
    1441                 :             :         g_assert_not_reached ();
    1442                 :             :     }
    1443                 :             : 
    1444         [ -  + ]:       10903 :     if (!JS_DefineProperty(context, in_object, name.c_str(), function,
    1445                 :             :                            GJS_MODULE_PROP_FLAGS)) {
    1446                 :           0 :         gjs_debug(GJS_DEBUG_GFUNCTION, "Failed to define function");
    1447                 :           0 :         function = NULL;
    1448                 :             :     }
    1449                 :             : 
    1450                 :       10903 :     return function;
    1451                 :       10903 : }
    1452                 :             : 
    1453                 :          15 : bool gjs_invoke_constructor_from_c(JSContext* context, GIFunctionInfo* info,
    1454                 :             :                                    JS::HandleObject obj,
    1455                 :             :                                    const JS::CallArgs& args,
    1456                 :             :                                    GIArgument* rvalue) {
    1457                 :          15 :     return Gjs::Function::invoke_constructor_uncached(context, info, obj, args,
    1458                 :          15 :                                                       rvalue);
    1459                 :             : }
        

Generated by: LCOV version 2.0-1