gobject-introspection 3.4.3 → 3.4.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49167989e84276d322d8ec6fc0e7a189924c62b5ff7daccfb76040284c75909d
-  data.tar.gz: 045e683e7f9ffef5731b9763cada4c841243fda0ac14622cff3612454dc72ae3
+  metadata.gz: 46669e91b4af175368180fc2152330751da6a7a240f942e6d7acef846822fdf7
+  data.tar.gz: 0456bafef2aca2d5c43dff46556b11d181251bc95e455b3de4b12d9ddc298f87
 SHA512:
-  metadata.gz: d8ca3007506eb8d0a91ba925678de9bbe3a1b3c2d295a968f47a1035efc031d6d8e254bb814c3638abfc415263cf991cbb9e60ff598585d2baa9b4ac02cb3ed8
-  data.tar.gz: eaf8f55fb4cf71eba636f840e8bcfea3850f127736fd9ae650fb6d8d981d31d7618a6c78e22f887d22e436f1c5fd6a897cf260281ab054b89fe560eac761db00
+  metadata.gz: a5a15ad2b14adf1be44f0924eb002c24256c77c30016f5fa0734d0035e1a5842ca70edb624614da61c8f3065bcf1f4bc832685cfc383a0e3daa5e5aa020bb312
+  data.tar.gz: e5e058654ef3ac94dd75dd1c247ee3c68fcda15eb7996f9523688ae77f6f5a7e7d3943f450864aa4acbc94cefa6da6da0a6aec221eaca9bba8de3087a853ad4d

data/ext/gobject-introspection/extconf.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 #
-# 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
@@ -62,9 +62,6 @@ end
 # TODO: Remove this when we dropped support for GObject Introspection < 1.60
 make_version_header("GI", package_id, ".")
 
-gi_headers = ["girepository.h"]
-have_func("g_interface_info_find_signal", gi_headers)
-
 enum_type_prefix = "gobject-introspection-enum-types"
 include_paths = PKGConfig.cflags_only_I(package_id)
 headers = include_paths.split.inject([]) do |result, path|

data/ext/gobject-introspection/gobject-introspection-enum-types.c

@@ -0,0 +1,230 @@
+
+/* Generated by glib-mkenums.rb ($Id$) */ 
+
+#include "gobject-introspection-enum-types.h"
+#include <girepository.h>
+
+
+
+/* enumerations from "/usr/include/gobject-introspection-1.0/girepository.h" */
+GType
+g_i_repository_load_flags_get_type (void)
+{
+  static GType etype = 0;
+  if (etype == 0) {
+    static const GFlagsValue values[] = {
+      { G_IREPOSITORY_LOAD_FLAG_LAZY, "G_IREPOSITORY_LOAD_FLAG_LAZY", "g-irepository-load-flag-lazy" },
+      { 0, NULL, NULL }
+    };
+    etype = g_flags_register_static ("GIRepositoryLoadFlags", values);
+  }
+  return etype;
+}
+
+GType
+g_i_repository_error_get_type (void)
+{
+  static GType etype = 0;
+  if (etype == 0) {
+    static const GEnumValue values[] = {
+      { G_IREPOSITORY_ERROR_TYPELIB_NOT_FOUND, "G_IREPOSITORY_ERROR_TYPELIB_NOT_FOUND", "typelib-not-found" },
+      { G_IREPOSITORY_ERROR_NAMESPACE_MISMATCH, "G_IREPOSITORY_ERROR_NAMESPACE_MISMATCH", "namespace-mismatch" },
+      { G_IREPOSITORY_ERROR_NAMESPACE_VERSION_CONFLICT, "G_IREPOSITORY_ERROR_NAMESPACE_VERSION_CONFLICT", "namespace-version-conflict" },
+      { G_IREPOSITORY_ERROR_LIBRARY_NOT_FOUND, "G_IREPOSITORY_ERROR_LIBRARY_NOT_FOUND", "library-not-found" },
+      { 0, NULL, NULL }
+    };
+    etype = g_enum_register_static ("GIRepositoryError", values);
+  }
+  return etype;
+}
+
+
+/* enumerations from "/usr/include/gobject-introspection-1.0/gitypes.h" */
+GType
+g_i_info_type_get_type (void)
+{
+  static GType etype = 0;
+  if (etype == 0) {
+    static const GEnumValue values[] = {
+      { GI_INFO_TYPE_INVALID, "GI_INFO_TYPE_INVALID", "invalid" },
+      { GI_INFO_TYPE_FUNCTION, "GI_INFO_TYPE_FUNCTION", "function" },
+      { GI_INFO_TYPE_CALLBACK, "GI_INFO_TYPE_CALLBACK", "callback" },
+      { GI_INFO_TYPE_STRUCT, "GI_INFO_TYPE_STRUCT", "struct" },
+      { GI_INFO_TYPE_BOXED, "GI_INFO_TYPE_BOXED", "boxed" },
+      { GI_INFO_TYPE_ENUM, "GI_INFO_TYPE_ENUM", "enum" },
+      { GI_INFO_TYPE_FLAGS, "GI_INFO_TYPE_FLAGS", "flags" },
+      { GI_INFO_TYPE_OBJECT, "GI_INFO_TYPE_OBJECT", "object" },
+      { GI_INFO_TYPE_INTERFACE, "GI_INFO_TYPE_INTERFACE", "interface" },
+      { GI_INFO_TYPE_CONSTANT, "GI_INFO_TYPE_CONSTANT", "constant" },
+      { GI_INFO_TYPE_INVALID_0, "GI_INFO_TYPE_INVALID_0", "invalid-0" },
+      { GI_INFO_TYPE_UNION, "GI_INFO_TYPE_UNION", "union" },
+      { GI_INFO_TYPE_VALUE, "GI_INFO_TYPE_VALUE", "value" },
+      { GI_INFO_TYPE_SIGNAL, "GI_INFO_TYPE_SIGNAL", "signal" },
+      { GI_INFO_TYPE_VFUNC, "GI_INFO_TYPE_VFUNC", "vfunc" },
+      { GI_INFO_TYPE_PROPERTY, "GI_INFO_TYPE_PROPERTY", "property" },
+      { GI_INFO_TYPE_FIELD, "GI_INFO_TYPE_FIELD", "field" },
+      { GI_INFO_TYPE_ARG, "GI_INFO_TYPE_ARG", "arg" },
+      { GI_INFO_TYPE_TYPE, "GI_INFO_TYPE_TYPE", "type" },
+      { GI_INFO_TYPE_UNRESOLVED, "GI_INFO_TYPE_UNRESOLVED", "unresolved" },
+      { 0, NULL, NULL }
+    };
+    etype = g_enum_register_static ("GIInfoType", values);
+  }
+  return etype;
+}
+
+GType
+g_i_transfer_get_type (void)
+{
+  static GType etype = 0;
+  if (etype == 0) {
+    static const GEnumValue values[] = {
+      { GI_TRANSFER_NOTHING, "GI_TRANSFER_NOTHING", "nothing" },
+      { GI_TRANSFER_CONTAINER, "GI_TRANSFER_CONTAINER", "container" },
+      { GI_TRANSFER_EVERYTHING, "GI_TRANSFER_EVERYTHING", "everything" },
+      { 0, NULL, NULL }
+    };
+    etype = g_enum_register_static ("GITransfer", values);
+  }
+  return etype;
+}
+
+GType
+g_i_direction_get_type (void)
+{
+  static GType etype = 0;
+  if (etype == 0) {
+    static const GEnumValue values[] = {
+      { GI_DIRECTION_IN, "GI_DIRECTION_IN", "in" },
+      { GI_DIRECTION_OUT, "GI_DIRECTION_OUT", "out" },
+      { GI_DIRECTION_INOUT, "GI_DIRECTION_INOUT", "inout" },
+      { 0, NULL, NULL }
+    };
+    etype = g_enum_register_static ("GIDirection", values);
+  }
+  return etype;
+}
+
+GType
+g_i_scope_type_get_type (void)
+{
+  static GType etype = 0;
+  if (etype == 0) {
+    static const GEnumValue values[] = {
+      { GI_SCOPE_TYPE_INVALID, "GI_SCOPE_TYPE_INVALID", "invalid" },
+      { GI_SCOPE_TYPE_CALL, "GI_SCOPE_TYPE_CALL", "call" },
+      { GI_SCOPE_TYPE_ASYNC, "GI_SCOPE_TYPE_ASYNC", "async" },
+      { GI_SCOPE_TYPE_NOTIFIED, "GI_SCOPE_TYPE_NOTIFIED", "notified" },
+      { 0, NULL, NULL }
+    };
+    etype = g_enum_register_static ("GIScopeType", values);
+  }
+  return etype;
+}
+
+GType
+g_i_type_tag_get_type (void)
+{
+  static GType etype = 0;
+  if (etype == 0) {
+    static const GEnumValue values[] = {
+      { GI_TYPE_TAG_VOID, "GI_TYPE_TAG_VOID", "void" },
+      { GI_TYPE_TAG_BOOLEAN, "GI_TYPE_TAG_BOOLEAN", "boolean" },
+      { GI_TYPE_TAG_INT8, "GI_TYPE_TAG_INT8", "int8" },
+      { GI_TYPE_TAG_UINT8, "GI_TYPE_TAG_UINT8", "uint8" },
+      { GI_TYPE_TAG_INT16, "GI_TYPE_TAG_INT16", "int16" },
+      { GI_TYPE_TAG_UINT16, "GI_TYPE_TAG_UINT16", "uint16" },
+      { GI_TYPE_TAG_INT32, "GI_TYPE_TAG_INT32", "int32" },
+      { GI_TYPE_TAG_UINT32, "GI_TYPE_TAG_UINT32", "uint32" },
+      { GI_TYPE_TAG_INT64, "GI_TYPE_TAG_INT64", "int64" },
+      { GI_TYPE_TAG_UINT64, "GI_TYPE_TAG_UINT64", "uint64" },
+      { GI_TYPE_TAG_FLOAT, "GI_TYPE_TAG_FLOAT", "float" },
+      { GI_TYPE_TAG_DOUBLE, "GI_TYPE_TAG_DOUBLE", "double" },
+      { GI_TYPE_TAG_GTYPE, "GI_TYPE_TAG_GTYPE", "gtype" },
+      { GI_TYPE_TAG_UTF8, "GI_TYPE_TAG_UTF8", "utf8" },
+      { GI_TYPE_TAG_FILENAME, "GI_TYPE_TAG_FILENAME", "filename" },
+      { GI_TYPE_TAG_ARRAY, "GI_TYPE_TAG_ARRAY", "array" },
+      { GI_TYPE_TAG_INTERFACE, "GI_TYPE_TAG_INTERFACE", "interface" },
+      { GI_TYPE_TAG_GLIST, "GI_TYPE_TAG_GLIST", "glist" },
+      { GI_TYPE_TAG_GSLIST, "GI_TYPE_TAG_GSLIST", "gslist" },
+      { GI_TYPE_TAG_GHASH, "GI_TYPE_TAG_GHASH", "ghash" },
+      { GI_TYPE_TAG_ERROR, "GI_TYPE_TAG_ERROR", "error" },
+      { GI_TYPE_TAG_UNICHAR, "GI_TYPE_TAG_UNICHAR", "unichar" },
+      { 0, NULL, NULL }
+    };
+    etype = g_enum_register_static ("GITypeTag", values);
+  }
+  return etype;
+}
+
+GType
+g_i_array_type_get_type (void)
+{
+  static GType etype = 0;
+  if (etype == 0) {
+    static const GEnumValue values[] = {
+      { GI_ARRAY_TYPE_C, "GI_ARRAY_TYPE_C", "c" },
+      { GI_ARRAY_TYPE_ARRAY, "GI_ARRAY_TYPE_ARRAY", "array" },
+      { GI_ARRAY_TYPE_PTR_ARRAY, "GI_ARRAY_TYPE_PTR_ARRAY", "ptr-array" },
+      { GI_ARRAY_TYPE_BYTE_ARRAY, "GI_ARRAY_TYPE_BYTE_ARRAY", "byte-array" },
+      { 0, NULL, NULL }
+    };
+    etype = g_enum_register_static ("GIArrayType", values);
+  }
+  return etype;
+}
+
+GType
+g_i_field_info_flags_get_type (void)
+{
+  static GType etype = 0;
+  if (etype == 0) {
+    static const GFlagsValue values[] = {
+      { GI_FIELD_IS_READABLE, "GI_FIELD_IS_READABLE", "readable" },
+      { GI_FIELD_IS_WRITABLE, "GI_FIELD_IS_WRITABLE", "writable" },
+      { 0, NULL, NULL }
+    };
+    etype = g_flags_register_static ("GIFieldInfoFlags", values);
+  }
+  return etype;
+}
+
+GType
+g_iv_func_info_flags_get_type (void)
+{
+  static GType etype = 0;
+  if (etype == 0) {
+    static const GFlagsValue values[] = {
+      { GI_VFUNC_MUST_CHAIN_UP, "GI_VFUNC_MUST_CHAIN_UP", "must-chain-up" },
+      { GI_VFUNC_MUST_OVERRIDE, "GI_VFUNC_MUST_OVERRIDE", "must-override" },
+      { GI_VFUNC_MUST_NOT_OVERRIDE, "GI_VFUNC_MUST_NOT_OVERRIDE", "must-not-override" },
+      { GI_VFUNC_THROWS, "GI_VFUNC_THROWS", "throws" },
+      { 0, NULL, NULL }
+    };
+    etype = g_flags_register_static ("GIVFuncInfoFlags", values);
+  }
+  return etype;
+}
+
+GType
+g_i_function_info_flags_get_type (void)
+{
+  static GType etype = 0;
+  if (etype == 0) {
+    static const GFlagsValue values[] = {
+      { GI_FUNCTION_IS_METHOD, "GI_FUNCTION_IS_METHOD", "is-method" },
+      { GI_FUNCTION_IS_CONSTRUCTOR, "GI_FUNCTION_IS_CONSTRUCTOR", "is-constructor" },
+      { GI_FUNCTION_IS_GETTER, "GI_FUNCTION_IS_GETTER", "is-getter" },
+      { GI_FUNCTION_IS_SETTER, "GI_FUNCTION_IS_SETTER", "is-setter" },
+      { GI_FUNCTION_WRAPS_VFUNC, "GI_FUNCTION_WRAPS_VFUNC", "wraps-vfunc" },
+      { GI_FUNCTION_THROWS, "GI_FUNCTION_THROWS", "throws" },
+      { 0, NULL, NULL }
+    };
+    etype = g_flags_register_static ("GIFunctionInfoFlags", values);
+  }
+  return etype;
+}
+
+
+/* Generated data ends here */
+

data/ext/gobject-introspection/gobject-introspection-enum-types.h

@@ -0,0 +1,42 @@
+
+/* Generated by glib-mkenums.rb ($Id$) */ 
+
+#ifndef __GOBJECT_INTROSPECTION_ENUM_TYPES_H__
+#define __GOBJECT_INTROSPECTION_ENUM_TYPES_H__
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+/* enumerations from "/usr/include/gobject-introspection-1.0/girepository.h" */
+GType g_i_repository_load_flags_get_type (void);
+#define G_TYPE_I_REPOSITORY_LOAD_FLAGS (g_i_repository_load_flags_get_type())
+GType g_i_repository_error_get_type (void);
+#define G_TYPE_I_REPOSITORY_ERROR (g_i_repository_error_get_type())
+
+/* enumerations from "/usr/include/gobject-introspection-1.0/gitypes.h" */
+GType g_i_info_type_get_type (void);
+#define G_TYPE_I_INFO_TYPE (g_i_info_type_get_type())
+GType g_i_transfer_get_type (void);
+#define G_TYPE_I_TRANSFER (g_i_transfer_get_type())
+GType g_i_direction_get_type (void);
+#define G_TYPE_I_DIRECTION (g_i_direction_get_type())
+GType g_i_scope_type_get_type (void);
+#define G_TYPE_I_SCOPE_TYPE (g_i_scope_type_get_type())
+GType g_i_type_tag_get_type (void);
+#define G_TYPE_I_TYPE_TAG (g_i_type_tag_get_type())
+GType g_i_array_type_get_type (void);
+#define G_TYPE_I_ARRAY_TYPE (g_i_array_type_get_type())
+GType g_i_field_info_flags_get_type (void);
+#define G_TYPE_I_FIELD_INFO_FLAGS (g_i_field_info_flags_get_type())
+GType g_iv_func_info_flags_get_type (void);
+#define G_TYPE_IV_FUNC_INFO_FLAGS (g_iv_func_info_flags_get_type())
+GType g_i_function_info_flags_get_type (void);
+#define G_TYPE_I_FUNCTION_INFO_FLAGS (g_i_function_info_flags_get_type())
+
+G_END_DECLS
+
+#endif /* __GOBJECT_INTROSPECTION_ENUM_TYPES_H__ */
+
+/* Generated data ends here */
+

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
@@ -1296,7 +1296,7 @@ rb_gi_argument_to_ruby(GIArgument *argument,
     switch (type_tag) {
     case GI_TYPE_TAG_VOID:
         if (g_type_info_is_pointer(type_info)) {
-            rb_argument = ULONG2NUM(GPOINTER_TO_UINT(argument->v_pointer));
+            rb_argument = ULL2NUM((guint64)(argument->v_pointer));
         } else {
             rb_argument = Qnil;
         }
@@ -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;
     }
 
@@ -231,7 +143,7 @@ rb_gi_arguments_in_init_arg_ruby_void(RBGIArguments *args,
     } else if (rbg_is_object(metadata->rb_arg)) {
         *target = RVAL2GOBJ(metadata->rb_arg);
     } else {
-        *target = GUINT_TO_POINTER(NUM2ULONG(metadata->rb_arg));
+        *target = (gpointer)(NUM2ULL(metadata->rb_arg));
     }
 }
 
@@ -682,7 +594,7 @@ rb_gi_arguments_in_init_arg_ruby_array_c_gtype(RBGIArguments *args,
     raw_array = ALLOC_N(GType, n_elements);
     for (i = 0; i < n_elements; i++) {
         VALUE rb_type = RARRAY_AREF(rb_array, i);
-        raw_array[i] = rbgobj_gtype_get(rb_type);
+        raw_array[i] = rbgobj_gtype_from_ruby(rb_type);
     }
 
     rb_gi_arguments_in_init_arg_ruby_array_c_generic(args,
@@ -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));
@@ -1262,15 +1174,6 @@ rb_gi_arguments_in_init_arg_ruby_interface(RBGIArguments *args,
                  rb_gi_transfer_to_string(metadata->transfer));
         break;
       case GI_INFO_TYPE_STRUCT:
-        if (metadata->transfer != GI_TRANSFER_NOTHING) {
-            rb_raise(rb_eNotImpError,
-                     "TODO: [%s] %s Ruby -> GIArgument(interface)[%s][%s][%s]",
-                     metadata->name,
-                     rb_gi_direction_to_string(metadata->direction),
-                     g_info_type_to_string(metadata->type.interface_type),
-                     g_type_name(metadata->type.interface_gtype),
-                     rb_gi_transfer_to_string(metadata->transfer));
-        }
         metadata->free_func = rb_gi_arguments_in_free_interface_struct;
         if (metadata->type.interface_gtype == G_TYPE_VALUE) {
             GValue *gvalue;
@@ -2069,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-out.c

@@ -105,10 +105,11 @@ rb_gi_arguments_out_free_array_c_interface(RBGIArguments *args,
       case GI_TRANSFER_EVERYTHING:
       default:
         rb_raise(rb_eNotImpError,
-                 "TODO: [%s] %s free GIArgument(%s)[%s]",
+                 "TODO: [%s] %s free GIArgument(%s/%s)[%s]",
                  metadata->name,
                  rb_gi_direction_to_string(metadata->direction),
                  g_type_tag_to_string(metadata->type.tag),
+                 rb_gi_array_type_to_string(metadata->array_type),
                  rb_gi_transfer_to_string(metadata->transfer));
     }
     xfree(target);
@@ -120,17 +121,34 @@ rb_gi_arguments_out_free_array_array_interface_struct(RBGIArguments *args,
                                                       gpointer user_data)
 {
     GArray *target = metadata->out_arg->v_pointer;
+    GType gtype = metadata->element_type.interface_gtype;
     switch (metadata->transfer) {
       case GI_TRANSFER_NOTHING:
         break;
       case GI_TRANSFER_CONTAINER:
+        break;
       case GI_TRANSFER_EVERYTHING:
+        if (gtype == G_TYPE_NONE) {
+            /* If the target struct is raw (not GType-ed) struct, we
+             * can't know how to free fields in the target struct. We
+             * assume that the target struct doesn't allocate nothing
+             * for its fields.
+             *
+             * e.g.: The attributes out argument in
+             * vte_terminal_get_text_range():
+             * https://developer.gnome.org/vte/unstable/VteTerminal.html#vte-terminal-get-text-range
+             */
+            break;
+        }
       default:
         rb_raise(rb_eNotImpError,
-                 "TODO: [%s] %s free GIArgument(%s)[%s]",
+                 "TODO: [%s] %s free GIArgument(%s/%s)[interface(%s)](%s)[%s]",
                  metadata->name,
                  rb_gi_direction_to_string(metadata->direction),
                  g_type_tag_to_string(metadata->type.tag),
+                 rb_gi_array_type_to_string(metadata->array_type),
+                 g_info_type_to_string(metadata->element_type.interface_type),
+                 g_type_name(metadata->element_type.interface_gtype),
                  rb_gi_transfer_to_string(metadata->transfer));
     }
     g_array_free(target, TRUE);