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: 2024-04-29 05:18:28 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                 :             : void gjs_gi_argument_init_default(GITypeInfo* type_info, GIArgument* arg);
      66                 :             : 
      67                 :             : GJS_JSAPI_RETURN_CONVENTION
      68                 :             : bool gjs_value_to_gi_argument(JSContext*, JS::HandleValue, GITypeInfo*,
      69                 :             :                               const char* arg_name, GjsArgumentType, GITransfer,
      70                 :             :                               GjsArgumentFlags, GIArgument*);
      71                 :             : 
      72                 :             : GJS_JSAPI_RETURN_CONVENTION
      73                 :         395 : bool inline gjs_value_to_gi_argument(JSContext* cx, JS::HandleValue value,
      74                 :             :                                      GITypeInfo* type_info,
      75                 :             :                                      GjsArgumentType argument_type,
      76                 :             :                                      GITransfer transfer, GIArgument* arg) {
      77                 :         395 :     return gjs_value_to_gi_argument(cx, value, type_info,
      78                 :             :                                     nullptr /* arg_name */, argument_type,
      79                 :         395 :                                     transfer, GjsArgumentFlags::NONE, arg);
      80                 :             : }
      81                 :             : 
      82                 :             : GJS_JSAPI_RETURN_CONVENTION
      83                 :             : bool gjs_value_from_gi_argument(JSContext*, JS::MutableHandleValue, GITypeInfo*,
      84                 :             :                                 GjsArgumentType, GITransfer, GIArgument*);
      85                 :             : 
      86                 :             : GJS_JSAPI_RETURN_CONVENTION
      87                 :       24730 : inline bool gjs_value_from_gi_argument(JSContext* cx,
      88                 :             :                                        JS::MutableHandleValue value_p,
      89                 :             :                                        GITypeInfo* type_info, GIArgument* arg,
      90                 :             :                                        bool copy_structs) {
      91         [ +  + ]:       24730 :     return gjs_value_from_gi_argument(
      92                 :             :         cx, value_p, type_info, GJS_ARGUMENT_ARGUMENT,
      93                 :       24730 :         copy_structs ? GI_TRANSFER_EVERYTHING : GI_TRANSFER_NOTHING, arg);
      94                 :             : }
      95                 :             : 
      96                 :             : GJS_JSAPI_RETURN_CONVENTION
      97                 :             : bool gjs_value_from_explicit_array(JSContext* context,
      98                 :             :                                    JS::MutableHandleValue value_p,
      99                 :             :                                    GITypeInfo* type_info, GITransfer transfer,
     100                 :             :                                    GIArgument* arg, int length);
     101                 :             : 
     102                 :             : GJS_JSAPI_RETURN_CONVENTION
     103                 :           2 : inline bool gjs_value_from_explicit_array(JSContext* context,
     104                 :             :                                           JS::MutableHandleValue value_p,
     105                 :             :                                           GITypeInfo* type_info,
     106                 :             :                                           GIArgument* arg, int length) {
     107                 :           2 :     return gjs_value_from_explicit_array(context, value_p, type_info,
     108                 :           2 :                                          GI_TRANSFER_EVERYTHING, arg, length);
     109                 :             : }
     110                 :             : 
     111                 :             : GJS_JSAPI_RETURN_CONVENTION
     112                 :             : bool gjs_gi_argument_release(JSContext*, GITransfer, GITypeInfo*,
     113                 :             :                              GjsArgumentFlags, GIArgument*);
     114                 :             : GJS_JSAPI_RETURN_CONVENTION
     115                 :       21582 : inline bool gjs_gi_argument_release(JSContext* cx, GITransfer transfer,
     116                 :             :                                     GITypeInfo* type_info, GIArgument* arg) {
     117                 :       21582 :     return gjs_gi_argument_release(cx, transfer, type_info,
     118                 :       21582 :                                    GjsArgumentFlags::NONE, arg);
     119                 :             : }
     120                 :             : GJS_JSAPI_RETURN_CONVENTION
     121                 :             : bool gjs_gi_argument_release_out_array(JSContext*, GITransfer, GITypeInfo*,
     122                 :             :                                        unsigned length, GIArgument*);
     123                 :             : GJS_JSAPI_RETURN_CONVENTION
     124                 :             : bool gjs_gi_argument_release_out_array(JSContext*, GITransfer, GITypeInfo*,
     125                 :             :                                        GIArgument*);
     126                 :             : GJS_JSAPI_RETURN_CONVENTION
     127                 :             : bool gjs_gi_argument_release_in_array(JSContext*, GITransfer, GITypeInfo*,
     128                 :             :                                       unsigned length, GIArgument*);
     129                 :             : GJS_JSAPI_RETURN_CONVENTION
     130                 :             : bool gjs_gi_argument_release_in_array(JSContext*, GITransfer, GITypeInfo*,
     131                 :             :                                       GIArgument*);
     132                 :             : GJS_JSAPI_RETURN_CONVENTION
     133                 :             : bool gjs_gi_argument_release_in_arg(JSContext*, GITransfer, GITypeInfo*,
     134                 :             :                                     GjsArgumentFlags, GIArgument*);
     135                 :             : GJS_JSAPI_RETURN_CONVENTION
     136                 :          49 : inline bool gjs_gi_argument_release_in_arg(JSContext* cx, GITransfer transfer,
     137                 :             :                                            GITypeInfo* type_info,
     138                 :             :                                            GIArgument* arg) {
     139                 :          49 :     return gjs_gi_argument_release_in_arg(cx, transfer, type_info,
     140                 :          49 :                                           GjsArgumentFlags::ARG_IN, arg);
     141                 :             : }
     142                 :             : 
     143                 :             : GJS_JSAPI_RETURN_CONVENTION
     144                 :             : bool _gjs_flags_value_is_valid(JSContext* cx, GType gtype, int64_t value);
     145                 :             : 
     146                 :             : [[nodiscard]] int64_t _gjs_enum_from_int(GIEnumInfo* enum_info, int int_value);
     147                 :             : 
     148                 :             : GJS_JSAPI_RETURN_CONVENTION
     149                 :             : bool gjs_array_from_strv(JSContext             *context,
     150                 :             :                          JS::MutableHandleValue value_p,
     151                 :             :                          const char           **strv);
     152                 :             : 
     153                 :             : GJS_JSAPI_RETURN_CONVENTION
     154                 :             : bool gjs_array_to_strv (JSContext   *context,
     155                 :             :                         JS::Value    array_value,
     156                 :             :                         unsigned int length,
     157                 :             :                         void       **arr_p);
     158                 :             : 
     159                 :             : GJS_JSAPI_RETURN_CONVENTION
     160                 :             : bool gjs_array_from_g_value_array(JSContext* cx, JS::MutableHandleValue value_p,
     161                 :             :                                   GITypeInfo* param_info, GITransfer,
     162                 :             :                                   const GValue* gvalue);
     163                 :             : 
     164                 :             : GJS_JSAPI_RETURN_CONVENTION
     165                 :             : bool gjs_object_from_g_hash(JSContext* cx, JS::MutableHandleValue,
     166                 :             :                             GITypeInfo* key_param_info,
     167                 :             :                             GITypeInfo* val_param_info, GITransfer transfer,
     168                 :             :                             GHashTable* hash);
     169                 :             : 
     170                 :             : #endif  // GI_ARG_H_
        

Generated by: LCOV version 2.0-1