LCOV - code coverage report
Current view: top level - gi - arg.h (source / functions) Coverage Total Hit
Test: gjs- Code Coverage Lines: 100.0 % 15 15
Test Date: 2025-04-13 21:33:23 Functions: 100.0 % 5 5
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 100.0 % 2 2

             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                 :             : #ifndef GI_ARG_H_
       6                 :             : #define GI_ARG_H_
       7                 :             : 
       8                 :             : #include <config.h>
       9                 :             : 
      10                 :             : #include <stddef.h>  // for size_t
      11                 :             : #include <stdint.h>
      12                 :             : 
      13                 :             : #include <girepository.h>
      14                 :             : #include <glib-object.h>
      15                 :             : #include <glib.h>  // for GHashTable
      16                 :             : 
      17                 :             : #include <js/RootingAPI.h>
      18                 :             : #include <js/TypeDecls.h>
      19                 :             : 
      20                 :             : #include "gjs/macros.h"
      21                 :             : 
      22                 :             : // Different roles for a GIArgument; currently used only in exception and debug
      23                 :             : // messages.
      24                 :             : typedef enum {
      25                 :             :     GJS_ARGUMENT_ARGUMENT,
      26                 :             :     GJS_ARGUMENT_RETURN_VALUE,
      27                 :             :     GJS_ARGUMENT_FIELD,
      28                 :             :     GJS_ARGUMENT_LIST_ELEMENT,
      29                 :             :     GJS_ARGUMENT_HASH_ELEMENT,
      30                 :             :     GJS_ARGUMENT_ARRAY_ELEMENT
      31                 :             : } GjsArgumentType;
      32                 :             : 
      33                 :             : enum class GjsArgumentFlags : uint8_t {
      34                 :             :     NONE = 0,
      35                 :             :     MAY_BE_NULL = 1 << 0,
      36                 :             :     CALLER_ALLOCATES = 1 << 1,
      37                 :             :     SKIP_IN = 1 << 2,
      38                 :             :     SKIP_OUT = 1 << 3,
      39                 :             :     SKIP_ALL = SKIP_IN | SKIP_OUT,
      40                 :             :     ARG_IN = 1 << 4,
      41                 :             :     ARG_OUT = 1 << 5,
      42                 :             :     ARG_INOUT = ARG_IN | ARG_OUT,
      43                 :             : };
      44                 :             : 
      45                 :             : // Overload operator| so that Visual Studio won't complain
      46                 :             : // when converting unsigned char to GjsArgumentFlags
      47                 :             : GjsArgumentFlags operator|(GjsArgumentFlags const& v1, GjsArgumentFlags const& v2);
      48                 :             : 
      49                 :             : [[nodiscard]] char* gjs_argument_display_name(const char* arg_name,
      50                 :             :                                               GjsArgumentType arg_type);
      51                 :             : 
      52                 :             : GJS_JSAPI_RETURN_CONVENTION
      53                 :             : bool gjs_value_to_callback_out_arg(JSContext* context, JS::HandleValue value,
      54                 :             :                                    GIArgInfo* arg_info, GIArgument* arg);
      55                 :             : 
      56                 :             : GJS_JSAPI_RETURN_CONVENTION
      57                 :             : bool gjs_array_to_explicit_array(JSContext* cx, JS::HandleValue value,
      58                 :             :                                  GITypeInfo* type_info, const char* arg_name,
      59                 :             :                                  GjsArgumentType arg_type, GITransfer transfer,
      60                 :             :                                  GjsArgumentFlags flags, void** contents,
      61                 :             :                                  size_t* length_p);
      62                 :             : 
      63                 :             : size_t gjs_type_get_element_size(GITypeTag element_type, GITypeInfo* type_info);
      64                 :             : 
      65                 :             : GJS_JSAPI_RETURN_CONVENTION
      66                 :             : bool gjs_value_to_gi_argument(JSContext*, JS::HandleValue, GITypeInfo*,
      67                 :             :                               const char* arg_name, GjsArgumentType, GITransfer,
      68                 :             :                               GjsArgumentFlags, GIArgument*);
      69                 :             : 
      70                 :             : GJS_JSAPI_RETURN_CONVENTION
      71                 :         423 : bool inline gjs_value_to_gi_argument(JSContext* cx, JS::HandleValue value,
      72                 :             :                                      GITypeInfo* type_info,
      73                 :             :                                      GjsArgumentType argument_type,
      74                 :             :                                      GITransfer transfer, GIArgument* arg) {
      75                 :         423 :     return gjs_value_to_gi_argument(cx, value, type_info,
      76                 :             :                                     nullptr /* arg_name */, argument_type,
      77                 :         423 :                                     transfer, GjsArgumentFlags::NONE, arg);
      78                 :             : }
      79                 :             : GJS_JSAPI_RETURN_CONVENTION
      80                 :             : bool gjs_value_to_basic_gi_argument(JSContext*, JS::HandleValue, GITypeTag,
      81                 :             :                                     GIArgument*, const char* arg_name,
      82                 :             :                                     GjsArgumentType, GjsArgumentFlags);
      83                 :             : GJS_JSAPI_RETURN_CONVENTION
      84                 :             : bool gjs_value_to_gerror_gi_argument(JSContext*, JS::HandleValue, GITransfer,
      85                 :             :                                      GIArgument*, const char* arg_name,
      86                 :             :                                      GjsArgumentType, GjsArgumentFlags);
      87                 :             : GJS_JSAPI_RETURN_CONVENTION
      88                 :             : bool gjs_value_to_basic_glist_gi_argument(JSContext*, JS::HandleValue,
      89                 :             :                                           GITypeTag element_tag, GIArgument*,
      90                 :             :                                           const char* arg_name,
      91                 :             :                                           GjsArgumentType);
      92                 :             : GJS_JSAPI_RETURN_CONVENTION
      93                 :             : bool gjs_value_to_basic_gslist_gi_argument(JSContext*, JS::HandleValue,
      94                 :             :                                            GITypeTag element_tag, GIArgument*,
      95                 :             :                                            const char* arg_name,
      96                 :             :                                            GjsArgumentType);
      97                 :             : GJS_JSAPI_RETURN_CONVENTION
      98                 :             : bool gjs_value_to_basic_ghash_gi_argument(JSContext*, JS::HandleValue,
      99                 :             :                                           GITypeTag key_tag,
     100                 :             :                                           GITypeTag value_tag, GITransfer,
     101                 :             :                                           GIArgument*, const char* arg_name,
     102                 :             :                                           GjsArgumentType, GjsArgumentFlags);
     103                 :             : GJS_JSAPI_RETURN_CONVENTION
     104                 :             : bool gjs_value_to_basic_array_gi_argument(JSContext*, JS::HandleValue,
     105                 :             :                                           GITypeTag element_tag, GIArrayType,
     106                 :             :                                           GIArgument*, const char* arg_name,
     107                 :             :                                           GjsArgumentType, GjsArgumentFlags);
     108                 :             : GJS_JSAPI_RETURN_CONVENTION
     109                 :             : bool gjs_value_to_byte_array_gi_argument(JSContext*, JS::HandleValue,
     110                 :             :                                          GIArgument*, const char* arg_name,
     111                 :             :                                          GjsArgumentFlags);
     112                 :             : GJS_JSAPI_RETURN_CONVENTION
     113                 :             : bool gjs_array_to_basic_explicit_array(JSContext*, JS::HandleValue,
     114                 :             :                                        GITypeTag element_tag,
     115                 :             :                                        const char* arg_name, GjsArgumentType,
     116                 :             :                                        GjsArgumentFlags, void** contents_out,
     117                 :             :                                        size_t* length_out);
     118                 :             : GJS_JSAPI_RETURN_CONVENTION
     119                 :             : bool gjs_value_to_gdk_atom_gi_argument(JSContext*, JS::HandleValue, GIArgument*,
     120                 :             :                                        const char* arg_name, GjsArgumentType);
     121                 :             : GJS_JSAPI_RETURN_CONVENTION
     122                 :             : bool gjs_value_to_interface_gi_argument(JSContext*, JS::HandleValue,
     123                 :             :                                         GIBaseInfo* interface_info, GITransfer,
     124                 :             :                                         GIArgument*, const char* arg_name,
     125                 :             :                                         GjsArgumentType, GjsArgumentFlags);
     126                 :             : GJS_JSAPI_RETURN_CONVENTION
     127                 :             : bool gjs_value_from_basic_gi_argument(JSContext*, JS::MutableHandleValue,
     128                 :             :                                       GITypeTag, GIArgument*);
     129                 :             : GJS_JSAPI_RETURN_CONVENTION
     130                 :             : bool gjs_value_from_gi_argument(JSContext*, JS::MutableHandleValue, GITypeInfo*,
     131                 :             :                                 GjsArgumentType, GITransfer, GIArgument*);
     132                 :             : 
     133                 :             : GJS_JSAPI_RETURN_CONVENTION
     134                 :       27329 : inline bool gjs_value_from_gi_argument(JSContext* cx,
     135                 :             :                                        JS::MutableHandleValue value_p,
     136                 :             :                                        GITypeInfo* type_info, GIArgument* arg,
     137                 :             :                                        bool copy_structs) {
     138         [ +  + ]:       27329 :     return gjs_value_from_gi_argument(
     139                 :             :         cx, value_p, type_info, GJS_ARGUMENT_ARGUMENT,
     140                 :       27329 :         copy_structs ? GI_TRANSFER_EVERYTHING : GI_TRANSFER_NOTHING, arg);
     141                 :             : }
     142                 :             : 
     143                 :             : GJS_JSAPI_RETURN_CONVENTION
     144                 :             : bool gjs_value_from_basic_ghash(JSContext*, JS::MutableHandleValue,
     145                 :             :                                 GITypeTag key_tag, GITypeTag value_tag,
     146                 :             :                                 GHashTable*);
     147                 :             : GJS_JSAPI_RETURN_CONVENTION
     148                 :             : bool gjs_array_from_basic_glist_gi_argument(JSContext*, JS::MutableHandleValue,
     149                 :             :                                             GITypeTag element_tag, GIArgument*);
     150                 :             : GJS_JSAPI_RETURN_CONVENTION
     151                 :             : bool gjs_array_from_basic_gslist_gi_argument(JSContext*, JS::MutableHandleValue,
     152                 :             :                                              GITypeTag element_tag,
     153                 :             :                                              GIArgument*);
     154                 :             : GJS_JSAPI_RETURN_CONVENTION
     155                 :             : bool gjs_array_from_basic_zero_terminated_array(JSContext*,
     156                 :             :                                                 JS::MutableHandleValue,
     157                 :             :                                                 GITypeTag element_tag,
     158                 :             :                                                 void* c_array);
     159                 :             : GJS_JSAPI_RETURN_CONVENTION
     160                 :             : bool gjs_value_from_basic_fixed_size_array_gi_argument(JSContext*,
     161                 :             :                                                        JS::MutableHandleValue,
     162                 :             :                                                        GITypeTag element_tag,
     163                 :             :                                                        size_t fixed_size,
     164                 :             :                                                        GIArgument*);
     165                 :             : GJS_JSAPI_RETURN_CONVENTION
     166                 :             : bool gjs_value_from_basic_explicit_array(JSContext*, JS::MutableHandleValue,
     167                 :             :                                          GITypeTag element_tag, GIArgument*,
     168                 :             :                                          size_t length);
     169                 :             : GJS_JSAPI_RETURN_CONVENTION
     170                 :             : bool gjs_value_from_explicit_array(JSContext* context,
     171                 :             :                                    JS::MutableHandleValue value_p,
     172                 :             :                                    GITypeInfo* type_info, GITransfer transfer,
     173                 :             :                                    GIArgument* arg, int length);
     174                 :             : 
     175                 :             : GJS_JSAPI_RETURN_CONVENTION
     176                 :           2 : inline bool gjs_value_from_explicit_array(JSContext* context,
     177                 :             :                                           JS::MutableHandleValue value_p,
     178                 :             :                                           GITypeInfo* type_info,
     179                 :             :                                           GIArgument* arg, int length) {
     180                 :           2 :     return gjs_value_from_explicit_array(context, value_p, type_info,
     181                 :           2 :                                          GI_TRANSFER_EVERYTHING, arg, length);
     182                 :             : }
     183                 :             : GJS_JSAPI_RETURN_CONVENTION
     184                 :             : bool gjs_value_from_byte_array_gi_argument(JSContext*, JS::MutableHandleValue,
     185                 :             :                                            GIArgument*);
     186                 :             : GJS_JSAPI_RETURN_CONVENTION
     187                 :             : bool gjs_value_from_basic_garray_gi_argument(JSContext*, JS::MutableHandleValue,
     188                 :             :                                              GITypeTag element_tag,
     189                 :             :                                              GIArgument*);
     190                 :             : GJS_JSAPI_RETURN_CONVENTION
     191                 :             : bool gjs_value_from_basic_gptrarray_gi_argument(JSContext*,
     192                 :             :                                                 JS::MutableHandleValue,
     193                 :             :                                                 GITypeTag element_tag,
     194                 :             :                                                 GIArgument*);
     195                 :             : GJS_JSAPI_RETURN_CONVENTION
     196                 :             : bool gjs_gi_argument_release(JSContext*, GITransfer, GITypeInfo*,
     197                 :             :                              GjsArgumentFlags, GIArgument*);
     198                 :             : GJS_JSAPI_RETURN_CONVENTION
     199                 :       21687 : inline bool gjs_gi_argument_release(JSContext* cx, GITransfer transfer,
     200                 :             :                                     GITypeInfo* type_info, GIArgument* arg) {
     201                 :       21687 :     return gjs_gi_argument_release(cx, transfer, type_info,
     202                 :       21687 :                                    GjsArgumentFlags::NONE, arg);
     203                 :             : }
     204                 :             : void gjs_gi_argument_release_basic(GITransfer, GITypeTag, GjsArgumentFlags,
     205                 :             :                                    GIArgument*);
     206                 :             : void gjs_gi_argument_release_basic_glist(GITransfer, GITypeTag element_tag,
     207                 :             :                                          GIArgument*);
     208                 :             : void gjs_gi_argument_release_basic_gslist(GITransfer, GITypeTag element_tag,
     209                 :             :                                           GIArgument*);
     210                 :             : void gjs_gi_argument_release_basic_ghash(GITransfer, GITypeTag key_tag,
     211                 :             :                                          GITypeTag value_tag, GIArgument*);
     212                 :             : void gjs_gi_argument_release_basic_garray(GITransfer transfer,
     213                 :             :                                           GITypeTag element_tag,
     214                 :             :                                           GIArgument* arg);
     215                 :             : void gjs_gi_argument_release_basic_gptrarray(GITransfer transfer,
     216                 :             :                                              GITypeTag element_tag,
     217                 :             :                                              GIArgument* arg);
     218                 :             : void gjs_gi_argument_release_basic_c_array(GITransfer, GITypeTag element_tag,
     219                 :             :                                            GIArgument*);
     220                 :             : void gjs_gi_argument_release_basic_c_array(GITransfer, GITypeTag element_tag,
     221                 :             :                                            size_t length, GIArgument*);
     222                 :             : void gjs_gi_argument_release_basic_in_array(GITransfer, GITypeTag element_tag,
     223                 :             :                                             GIArgument*);
     224                 :             : void gjs_gi_argument_release_basic_in_array(GITransfer, GITypeTag element_tag,
     225                 :             :                                             size_t length, GIArgument*);
     226                 :             : void gjs_gi_argument_release_basic_out_array(GITransfer, GITypeTag element_tag,
     227                 :             :                                              GIArgument*);
     228                 :             : void gjs_gi_argument_release_basic_out_array(GITransfer, GITypeTag element_tag,
     229                 :             :                                              size_t length, GIArgument*);
     230                 :             : void gjs_gi_argument_release_byte_array(GIArgument* arg);
     231                 :             : GJS_JSAPI_RETURN_CONVENTION
     232                 :             : bool gjs_gi_argument_release_out_array(JSContext*, GITransfer, GITypeInfo*,
     233                 :             :                                        unsigned length, GIArgument*);
     234                 :             : GJS_JSAPI_RETURN_CONVENTION
     235                 :             : bool gjs_gi_argument_release_out_array(JSContext*, GITransfer, GITypeInfo*,
     236                 :             :                                        GIArgument*);
     237                 :             : GJS_JSAPI_RETURN_CONVENTION
     238                 :             : bool gjs_gi_argument_release_in_array(JSContext*, GITransfer, GITypeInfo*,
     239                 :             :                                       unsigned length, GIArgument*);
     240                 :             : GJS_JSAPI_RETURN_CONVENTION
     241                 :             : bool gjs_gi_argument_release_in_array(JSContext*, GITransfer, GITypeInfo*,
     242                 :             :                                       GIArgument*);
     243                 :             : GJS_JSAPI_RETURN_CONVENTION
     244                 :             : bool gjs_gi_argument_release_in_arg(JSContext*, GITransfer, GITypeInfo*,
     245                 :             :                                     GjsArgumentFlags, GIArgument*);
     246                 :             : GJS_JSAPI_RETURN_CONVENTION
     247                 :          69 : inline bool gjs_gi_argument_release_in_arg(JSContext* cx, GITransfer transfer,
     248                 :             :                                            GITypeInfo* type_info,
     249                 :             :                                            GIArgument* arg) {
     250                 :          69 :     return gjs_gi_argument_release_in_arg(cx, transfer, type_info,
     251                 :          69 :                                           GjsArgumentFlags::ARG_IN, arg);
     252                 :             : }
     253                 :             : 
     254                 :             : GJS_JSAPI_RETURN_CONVENTION
     255                 :             : bool _gjs_flags_value_is_valid(JSContext* cx, GType gtype, int64_t value);
     256                 :             : 
     257                 :             : [[nodiscard]] int64_t _gjs_enum_from_int(GIEnumInfo* enum_info, int int_value);
     258                 :             : 
     259                 :             : GJS_JSAPI_RETURN_CONVENTION
     260                 :             : bool gjs_array_from_strv(JSContext             *context,
     261                 :             :                          JS::MutableHandleValue value_p,
     262                 :             :                          const char           **strv);
     263                 :             : 
     264                 :             : GJS_JSAPI_RETURN_CONVENTION
     265                 :             : bool gjs_array_to_strv (JSContext   *context,
     266                 :             :                         JS::Value    array_value,
     267                 :             :                         unsigned int length,
     268                 :             :                         void       **arr_p);
     269                 :             : 
     270                 :             : GJS_JSAPI_RETURN_CONVENTION
     271                 :             : bool gjs_array_from_g_value_array(JSContext* cx, JS::MutableHandleValue value_p,
     272                 :             :                                   GITypeInfo* param_info, GITransfer,
     273                 :             :                                   const GValue* gvalue);
     274                 :             : 
     275                 :             : GJS_JSAPI_RETURN_CONVENTION
     276                 :             : bool gjs_object_from_g_hash(JSContext* cx, JS::MutableHandleValue,
     277                 :             :                             GITypeInfo* key_param_info,
     278                 :             :                             GITypeInfo* val_param_info, GITransfer transfer,
     279                 :             :                             GHashTable* hash);
     280                 :             : 
     281                 :             : #endif  // GI_ARG_H_
        

Generated by: LCOV version 2.0-1