gobject-introspection 3.4.4 → 3.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d072b72b786e12f881fea9bde17a9eff9a4c71bedd25f4ecdd2b18267b8ba051
-  data.tar.gz: c9e9e78f5c492cb8fea24a1b54e05c2cedad2ec6ce877030cdb3782863340673
+  metadata.gz: '073080df7a1c63c600038ca2b3f5edce7e4b090c580b530bed49ab72afc02310'
+  data.tar.gz: 9cb1dd9c3f5badc0c0a917206d42d18783626db421a701a8737fa7398c7cefa5
 SHA512:
-  metadata.gz: a24acd65c6f1ddfe47665819bbb37c6121e2c154183c23f64512e4e6ad3b9ba52cde4f035d06754f45071afed0a3db82024efe2ceac596b3d45eeb2027d182d2
-  data.tar.gz: 1cdf78cd475b3401ecbd261b182b4271989600a2aef1f572e14c460fa25a84350c0c515edd301c4af7e27ad79943d9c33e24f21fa01c2d5634e7cbd9aec51d38
+  metadata.gz: 8e0ca0522ffbc58c6276455fb7d27c90afc1d959881af569c63b17607bd46cb6fca3463a74699ac1b8f244ec159d5c09edd736eb67641631ed5da48cebff4c8f
+  data.tar.gz: f2d8856c0cb47cf65cd54753a2d0dcad71a4c2519a64ccd5a9f515ba5c8eb42dfe6dea034f7498ca8eeac438e79b83ff84bae139bcc7e799693f55aeb43347b7

data/ext/gobject-introspection/rb-gi-argument.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012-2019  Ruby-GNOME Project Team
+ *  Copyright (C) 2012-2021  Ruby-GNOME Project Team
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
@@ -2011,11 +2011,18 @@ rb_gi_return_argument_to_ruby(GICallableInfo *callable_info,
     GITypeInfo return_value_info;
 
     may_return_null = g_callable_info_may_return_null(callable_info);
+    g_callable_info_load_return_type(callable_info, &return_value_info);
     if (may_return_null && !argument->v_pointer) {
-        return Qnil;
+        GITypeTag return_value_tag = g_type_info_get_tag(&return_value_info);
+        switch (return_value_tag) {
+          case GI_TYPE_TAG_GLIST:
+          case GI_TYPE_TAG_GSLIST:
+            return rb_ary_new();
+          default:
+            return Qnil;
+        }
     }
 
-    g_callable_info_load_return_type(callable_info, &return_value_info);
     rb_argument = rb_gi_argument_to_ruby(argument, FALSE, &return_value_info,
                                          in_args, out_args, args_metadata);
     switch (g_callable_info_get_caller_owns(callable_info)) {

data/ext/gobject-introspection/rb-gi-arguments-in.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012-2019  Ruby-GNOME Project Team
+ *  Copyright (C) 2012-2021  Ruby-GNOME Project Team
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
@@ -27,13 +27,7 @@ rb_gi_callback_data_destroy_notify(gpointer data)
     rb_gi_callback_data_free(callback_data);
 }
 
-typedef struct {
-    RBGIArguments *args;
-    RBGICallback *callback;
-    RBGICallbackData *callback_data;
-} RBGICallbackInvokeData;
-
-static VALUE
+VALUE
 rb_gi_arguments_in_to_ruby(RBGIArguments *args)
 {
     VALUE rb_in_args;
@@ -68,85 +62,6 @@ rb_gi_arguments_in_to_ruby(RBGIArguments *args)
     return rb_in_args;
 }
 
-static VALUE
-rb_gi_callback_invoke(VALUE user_data)
-{
-    RBGICallbackInvokeData *data = (RBGICallbackInvokeData *)user_data;
-    ID id_call;
-    VALUE rb_callback = rb_gi_callback_data_get_rb_callback(data->callback_data);
-    VALUE rb_args = rb_gi_arguments_in_to_ruby(data->args);
-
-    CONST_ID(id_call, "call");
-    return rb_funcallv(rb_callback,
-                       id_call,
-                       RARRAY_LENINT(rb_args),
-                       RARRAY_CONST_PTR(rb_args));
-}
-
-static void
-rb_gi_ffi_closure_callback(G_GNUC_UNUSED ffi_cif *cif,
-                           void *return_value,
-                           void **raw_args,
-                           void *data)
-{
-    RBGICallback *callback = data;
-    RBGICallbackData *callback_data = NULL;
-    RBGIArguments args;
-    VALUE rb_results;
-
-    rb_gi_arguments_init(&args,
-                         callback->callback_info,
-                         Qnil,
-                         Qnil,
-                         raw_args);
-    {
-        guint i;
-
-        for (i = 0; i < args.metadata->len; i++) {
-            RBGIArgMetadata *metadata;
-
-            metadata = g_ptr_array_index(args.metadata, i);
-            if (!metadata->closure_p) {
-                continue;
-            }
-
-            callback_data = *((RBGICallbackData **)(raw_args[i]));
-            break;
-        }
-
-        if (!callback_data && args.metadata->len > 0) {
-            RBGIArgMetadata *metadata;
-
-            i = args.metadata->len - 1;
-            metadata = g_ptr_array_index(args.metadata, i);
-            if (metadata->type.tag == GI_TYPE_TAG_VOID &&
-                metadata->type.pointer_p &&
-                strcmp(metadata->name, "data") == 0) {
-                callback_data = *((RBGICallbackData **)(raw_args[i]));
-            }
-        }
-    }
-
-    {
-        RBGICallbackInvokeData data;
-        data.args = &args;
-        data.callback = callback;
-        data.callback_data = callback_data;
-        rb_results = rbgutil_invoke_callback(rb_gi_callback_invoke,
-                                             (VALUE)&data);
-    }
-    rb_gi_arguments_fill_raw_results(&args, rb_results, return_value);
-    rb_gi_arguments_clear(&args);
-
-    {
-        RBGIArgMetadata *callback_metadata =
-            rb_gi_callback_data_get_metadata(callback_data);
-        if (callback_metadata->scope_type == GI_SCOPE_TYPE_ASYNC) {
-            rb_gi_callback_data_free(callback_data);
-        }
-    }
-}
-
 static void
 rb_gi_arguments_in_init_arg_ruby_callback(RBGIArguments *args,
                                           RBGIArgMetadata *metadata)
@@ -187,14 +102,11 @@ rb_gi_arguments_in_init_arg_ruby_callback(RBGIArguments *args,
     if (callback_function) {
         callback_argument->v_pointer = callback_function;
     } else {
-        callback = RB_ZALLOC(RBGICallback);
-        callback->type_info = g_arg_info_get_type(arg_info);
-        callback->callback_info = g_type_info_get_interface(callback->type_info);
-        callback->closure =
-            g_callable_info_prepare_closure(callback->callback_info,
-                                            &(callback->cif),
-                                            rb_gi_ffi_closure_callback,
-                                            callback);
+        GITypeInfo *type_info = g_arg_info_get_type(arg_info);
+        GICallbackInfo *callback_info = g_type_info_get_interface(type_info);
+        callback = rb_gi_callback_new(callback_info, NULL);
+        g_base_info_unref(callback_info);
+        g_base_info_unref(type_info);
         callback_argument->v_pointer = callback->closure;
     }
 
@@ -1007,7 +919,7 @@ rb_gi_arguments_in_init_arg_ruby_array_c(RBGIArguments *args,
         /* Workaround for rsvg_handle_set_stylesheet():
            https://gitlab.gnome.org/GNOME/librsvg/-/issues/596 */
         if (strcmp(metadata->name, "css") == 0) {
-            metadata->in_arg->v_pointer = RVAL2CSTR(rb_arg);
+            metadata->in_arg->v_pointer = (char *)RVAL2CSTR(rb_arg);
             rb_gi_arguments_in_init_arg_ruby_array_set_length(args,
                                                               metadata,
                                                               RSTRING_LEN(rb_arg));
@@ -2060,13 +1972,30 @@ rb_gi_arguments_in_init_arg_ruby(RBGIArguments *args,
       case GI_TYPE_TAG_UNICHAR:
         {
             gunichar *target;
+            VALUE rb_unichar;
             if (metadata->direction == GI_DIRECTION_INOUT) {
                 target = ALLOC(gunichar);
                 metadata->in_arg->v_pointer = target;
             } else {
                 target = &(metadata->in_arg->v_uint32);
             }
-            *target = NUM2UINT(metadata->rb_arg);
+            if (RB_TYPE_P(metadata->rb_arg, RUBY_T_STRING)) {
+                VALUE rb_codepoints;
+                if (rb_str_strlen(metadata->rb_arg) != 1) {
+                    rb_raise(rb_eArgError,
+                             "[%s][%s] must be one character: %+" PRIsVALUE,
+                             metadata->name,
+                             g_type_tag_to_string(metadata->type.tag),
+                             metadata->rb_arg);
+                }
+                rb_codepoints = rb_funcall(metadata->rb_arg,
+                                           rb_intern("codepoints"),
+                                           0);
+                rb_unichar = RARRAY_PTR(rb_codepoints)[0];
+            } else {
+                rb_unichar = metadata->rb_arg;
+            }
+            *target = NUM2UINT(rb_unichar);
         }
         break;
       default:

data/ext/gobject-introspection/rb-gi-arguments.c

@@ -497,6 +497,48 @@ rb_gi_arguments_get_rb_out_args(RBGIArguments *args)
     return rb_gi_arguments_out_to_ruby(args);
 }
 
+void
+rb_gi_arguments_fill_raw_out_gerror(RBGIArguments *args,
+                                    VALUE rb_error)
+{
+    if (!g_callable_info_can_throw_gerror(args->info)) {
+        return;
+    }
+
+    gint n_args = g_callable_info_get_n_args(args->info);
+    /* GError ** isn't listed in args. */
+    GError **gerror = *((gpointer *)(args->raw_args[n_args]));
+    VALUE cGLibError = rb_const_get(mGLib, rb_intern("Error"));
+    if (NIL_P(rb_error)) {
+        g_set_error(gerror,
+                    RBG_RUBY_ERROR,
+                    RBG_RUBY_ERROR_UNKNOWN,
+                    "Unknown error");
+    } else {
+        VALUE message = rb_funcall(rb_error, rb_intern("message"), 0);
+        VALUE backtrace = rb_funcall(rb_error, rb_intern("backtrace"), 0);
+        VALUE formatted_backtrace =
+            rb_ary_join(backtrace, rb_str_new_cstr("  \n"));
+        if (CBOOL2RVAL(rb_obj_is_kind_of(rb_error, cGLibError))) {
+            VALUE domain = rb_funcall(rb_error, rb_intern("domain"), 0);
+            VALUE code = rb_funcall(rb_error, rb_intern("code"), 0);
+            g_set_error(gerror,
+                        g_quark_from_string(RVAL2CSTR(domain)),
+                        NUM2INT(code),
+                        "%s\n  %s\n",
+                        RVAL2CSTR(message),
+                        RVAL2CSTR(formatted_backtrace));
+        } else {
+            g_set_error(gerror,
+                        RBG_RUBY_ERROR,
+                        RBG_RUBY_ERROR_UNKNOWN,
+                        "%s\n  %s\n",
+                        RVAL2CSTR(message),
+                        RVAL2CSTR(formatted_backtrace));
+        }
+    }
+}
+
 static void
 rb_gi_arguments_fill_raw_result_interface(RBGIArguments *args,
                                           VALUE rb_result,
@@ -577,6 +619,160 @@ rb_gi_arguments_fill_raw_result_interface(RBGIArguments *args,
     g_base_info_unref(interface_info);
 }
 
+static void
+rb_gi_arguments_fill_raw_result_glist_interface(
+    RBGIArguments *args,
+    VALUE rb_result,
+    gpointer raw_result,
+    GITypeInfo *type_info,
+    GITypeInfo *element_type_info,
+    G_GNUC_UNUSED GITransfer transfer /* TODO */,
+    gboolean is_return_value)
+{
+    GIFFIReturnValue *ffi_return_value = raw_result;
+    GIBaseInfo *interface_info;
+    GIInfoType interface_type;
+    const gchar *interface_name;
+    GType gtype;
+    GList *list = NULL;
+
+    interface_info = g_type_info_get_interface(element_type_info);
+    interface_type = g_base_info_get_type(interface_info);
+    interface_name = g_info_type_to_string(interface_type);
+    gtype = g_registered_type_info_get_g_type(interface_info);
+
+    switch (interface_type) {
+    case GI_INFO_TYPE_INVALID:
+    case GI_INFO_TYPE_FUNCTION:
+    case GI_INFO_TYPE_CALLBACK:
+    case GI_INFO_TYPE_STRUCT:
+    case GI_INFO_TYPE_BOXED:
+    case GI_INFO_TYPE_ENUM:
+    case GI_INFO_TYPE_FLAGS:
+      g_base_info_unref(interface_info);
+      g_base_info_unref(element_type_info);
+      rb_raise(rb_eNotImpError,
+               "TODO: %s::%s: out raw result(glist)[interface(%s)](%s)",
+               g_base_info_get_namespace(args->info),
+               g_base_info_get_name(args->info),
+               interface_name,
+               g_type_name(gtype));
+      break;
+    case GI_INFO_TYPE_OBJECT:
+      list = RVAL2GOBJGLIST(rb_result);
+      if (transfer == GI_TRANSFER_EVERYTHING) {
+          g_list_foreach(list, (GFunc)g_object_ref, NULL);
+      }
+      break;
+    case GI_INFO_TYPE_INTERFACE:
+    case GI_INFO_TYPE_CONSTANT:
+    case GI_INFO_TYPE_INVALID_0:
+    case GI_INFO_TYPE_UNION:
+    case GI_INFO_TYPE_VALUE:
+    case GI_INFO_TYPE_SIGNAL:
+    case GI_INFO_TYPE_VFUNC:
+    case GI_INFO_TYPE_PROPERTY:
+    case GI_INFO_TYPE_FIELD:
+    case GI_INFO_TYPE_ARG:
+    case GI_INFO_TYPE_TYPE:
+    case GI_INFO_TYPE_UNRESOLVED:
+      g_base_info_unref(interface_info);
+      g_base_info_unref(element_type_info);
+      rb_raise(rb_eNotImpError,
+               "TODO: %s::%s: out raw result(glist)[interface(%s)](%s)",
+               g_base_info_get_namespace(args->info),
+               g_base_info_get_name(args->info),
+               interface_name,
+               g_type_name(gtype));
+      break;
+    default:
+      g_base_info_unref(interface_info);
+      g_base_info_unref(element_type_info);
+      g_assert_not_reached();
+      break;
+    }
+
+    if (is_return_value) {
+        ffi_return_value->v_ulong = (gulong)list;
+    } else {
+        *((gpointer *)raw_result) = list;
+    }
+}
+
+static void
+rb_gi_arguments_fill_raw_result_glist(RBGIArguments *args,
+                                      VALUE rb_result,
+                                      gpointer raw_result,
+                                      GITypeInfo *type_info,
+                                      GITransfer transfer,
+                                      gboolean is_return_value)
+{
+    GIFFIReturnValue *ffi_return_value = raw_result;
+    GITypeInfo *element_type_info;
+    GITypeTag element_type_tag;
+
+    element_type_info = g_type_info_get_param_type(type_info, 0);
+    element_type_tag = g_type_info_get_tag(element_type_info);
+
+    if (is_return_value) {
+        ffi_return_value->v_ulong = (gulong)NULL;
+    } else {
+        *((gpointer *)raw_result) = NULL;
+    }
+
+    switch (element_type_tag) {
+    case GI_TYPE_TAG_VOID:
+    case GI_TYPE_TAG_BOOLEAN:
+    case GI_TYPE_TAG_INT8:
+    case GI_TYPE_TAG_UINT8:
+    case GI_TYPE_TAG_INT16:
+    case GI_TYPE_TAG_UINT16:
+    case GI_TYPE_TAG_INT32:
+    case GI_TYPE_TAG_UINT32:
+    case GI_TYPE_TAG_INT64:
+    case GI_TYPE_TAG_UINT64:
+    case GI_TYPE_TAG_FLOAT:
+    case GI_TYPE_TAG_DOUBLE:
+    case GI_TYPE_TAG_GTYPE:
+    case GI_TYPE_TAG_UTF8:
+    case GI_TYPE_TAG_FILENAME:
+    case GI_TYPE_TAG_ARRAY:
+      g_base_info_unref(element_type_info);
+      rb_raise(rb_eNotImpError,
+               "TODO: %s::%s: out raw result(GList)[%s]",
+               g_base_info_get_namespace(args->info),
+               g_base_info_get_name(args->info),
+               g_type_tag_to_string(element_type_tag));
+      break;
+    case GI_TYPE_TAG_INTERFACE:
+      rb_gi_arguments_fill_raw_result_glist_interface(
+          args,
+          rb_result,
+          raw_result,
+          type_info,
+          element_type_info,
+          transfer,
+          is_return_value);
+      break;
+    case GI_TYPE_TAG_GLIST:
+    case GI_TYPE_TAG_GSLIST:
+    case GI_TYPE_TAG_GHASH:
+    case GI_TYPE_TAG_ERROR:
+    case GI_TYPE_TAG_UNICHAR:
+      g_base_info_unref(element_type_info);
+      rb_raise(rb_eNotImpError,
+               "TODO: %s::%s: out raw result(GList)[%s]",
+               g_base_info_get_namespace(args->info),
+               g_base_info_get_name(args->info),
+               g_type_tag_to_string(element_type_tag));
+      break;
+    default:
+      g_base_info_unref(element_type_info);
+      g_assert_not_reached();
+      break;
+    }
+}
+
 /*
   We need to cast from different type for return value. (We don't
   need it for out arguments.) Because of libffi specification:
@@ -695,12 +891,16 @@ rb_gi_arguments_fill_raw_result(RBGIArguments *args,
         }
         break;
       case GI_TYPE_TAG_UTF8:
-        if (is_return_value) {
-            ffi_return_value->v_ulong =
-                (gulong)RVAL2CSTR_ACCEPT_SYMBOL(rb_result);
-        } else {
-            *((gchar **)raw_result) =
-                (gchar *)RVAL2CSTR_ACCEPT_SYMBOL(rb_result);
+        {
+            gchar *result = (gchar *)RVAL2CSTR_ACCEPT_SYMBOL(rb_result);
+            if (transfer == GI_TRANSFER_EVERYTHING) {
+                result = g_strdup(result);
+            }
+            if (is_return_value) {
+                ffi_return_value->v_ulong = (gulong)result;
+            } else {
+                *((gchar **)raw_result) = (gchar *)result;
+            }
         }
         break;
       case GI_TYPE_TAG_FILENAME:
@@ -739,6 +939,13 @@ rb_gi_arguments_fill_raw_result(RBGIArguments *args,
                                                   is_return_value);
         break;
       case GI_TYPE_TAG_GLIST:
+        rb_gi_arguments_fill_raw_result_glist(args,
+                                              rb_result,
+                                              raw_result,
+                                              type_info,
+                                              transfer,
+                                              is_return_value);
+        break;
       case GI_TYPE_TAG_GSLIST:
       case GI_TYPE_TAG_GHASH:
         rb_raise(rb_eNotImpError,
@@ -833,7 +1040,7 @@ rb_gi_arguments_fill_raw_results(RBGIArguments *args,
         rb_gi_arguments_fill_raw_result(args,
                                         RARRAY_AREF(rb_results, i_rb_result),
                                         argument->v_pointer,
-                                        return_type_info,
+                                        type_info,
                                         transfer,
                                         FALSE);
         i_rb_result++;