gobject-introspection 3.4.0 → 3.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 439904c07c9ece750e11324a9e7220e92703960c464e3096b592b4a0c60089ed
-  data.tar.gz: 43364a70a42e79df745fa61912d528b47442025f42b7456ee950dbcad7b259e6
+  metadata.gz: '073080df7a1c63c600038ca2b3f5edce7e4b090c580b530bed49ab72afc02310'
+  data.tar.gz: 9cb1dd9c3f5badc0c0a917206d42d18783626db421a701a8737fa7398c7cefa5
 SHA512:
-  metadata.gz: 96504ea3a2364df9625cf2b3846479f07cf0dbea4aeb81b5761aca751959476db272a15479c64d244ad72ab77f0b21698a3896ebec0efb1bdac56cc2f444958d
-  data.tar.gz: 9b8b9e7ad2545423e95baa93241ba7ac4679cf5e5871361ffe58f503f3abb4b8997da90d2e85ec17423ead5abe80aa2a54b4ca6c6d1d024fd399bc67be0d157f
+  metadata.gz: 8e0ca0522ffbc58c6276455fb7d27c90afc1d959881af569c63b17607bd46cb6fca3463a74699ac1b8f244ec159d5c09edd736eb67641631ed5da48cebff4c8f
+  data.tar.gz: f2d8856c0cb47cf65cd54753a2d0dcad71a4c2519a64ccd5a9f515ba5c8eb42dfe6dea034f7498ca8eeac438e79b83ff84bae139bcc7e799693f55aeb43347b7

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/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->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;
     }
 
@@ -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,
@@ -721,26 +633,50 @@ rb_gi_arguments_in_init_arg_ruby_array_c_interface_struct(RBGIArguments *args,
 {
     GIStructInfo *struct_info =
         (GIStructInfo *)(metadata->element_type.interface_info);
-    guint8 *raw_array;
-    gsize struct_size;
     long i, n_elements;
 
     n_elements = RARRAY_LEN(rb_array);
-    struct_size = g_struct_info_get_size(struct_info);
-    raw_array = ALLOC_N(guint8, struct_size * n_elements);
-    for (i = 0; i < n_elements; i++) {
-        VALUE rb_element = RARRAY_AREF(rb_array, i);
-        gpointer element;
-        element = rb_gi_struct_info_from_ruby(struct_info, rb_element);
-        memcpy(raw_array + (struct_size * i),
-               element,
-               struct_size);
+    if (metadata->element_type.pointer_p) {
+        if (metadata->transfer != GI_TRANSFER_NOTHING) {
+            rb_raise(rb_eNotImpError,
+                     "TODO: [%s::%s] %s "
+                     "Ruby -> GIArgument(array/%s)[interface(%s)](%s)[%s]",
+                     args->name,
+                     metadata->name,
+                     rb_gi_direction_to_string(metadata->direction),
+                     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));
+        }
+        gpointer *raw_array = ALLOC_N(gpointer, n_elements);
+        for (i = 0; i < n_elements; i++) {
+            VALUE rb_element = RARRAY_AREF(rb_array, i);
+            gpointer element;
+            element = rb_gi_struct_info_from_ruby(struct_info, rb_element);
+            raw_array[i] = element;
+        }
+        rb_gi_arguments_in_init_arg_ruby_array_c_generic(args,
+                                                         metadata,
+                                                         rb_array,
+                                                         raw_array);
+    } else {
+        gsize struct_size = g_struct_info_get_size(struct_info);
+        guint8 *raw_array = ALLOC_N(guint8, struct_size * n_elements);
+        for (i = 0; i < n_elements; i++) {
+            VALUE rb_element = RARRAY_AREF(rb_array, i);
+            gpointer element;
+            element = rb_gi_struct_info_from_ruby(struct_info, rb_element);
+            memcpy(raw_array + (struct_size * i),
+                   element,
+                   struct_size);
+        }
+        rb_gi_arguments_in_init_arg_ruby_array_c_generic(args,
+                                                         metadata,
+                                                         rb_array,
+                                                         raw_array);
     }
 
-    rb_gi_arguments_in_init_arg_ruby_array_c_generic(args,
-                                                     metadata,
-                                                     rb_array,
-                                                     raw_array);
     metadata->free_func = rb_gi_arguments_in_free_array_c_interface_struct;
 }
 
@@ -980,7 +916,15 @@ rb_gi_arguments_in_init_arg_ruby_array_c(RBGIArguments *args,
                                                        rb_arg);
         break;
       case GI_TYPE_TAG_UTF8:
-        {
+        /* 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 = (char *)RVAL2CSTR(rb_arg);
+            rb_gi_arguments_in_init_arg_ruby_array_set_length(args,
+                                                              metadata,
+                                                              RSTRING_LEN(rb_arg));
+            metadata->free_func = NULL;
+        } else {
             GIArgument *array_argument = metadata->in_arg;
             gchar **raw_array;
             long length;
@@ -1230,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;
@@ -1645,7 +1580,15 @@ rb_gi_arguments_in_init_arg_ruby_ghash_body(VALUE value_data)
       case GI_TYPE_TAG_FLOAT:
       case GI_TYPE_TAG_DOUBLE:
       case GI_TYPE_TAG_GTYPE:
+        rb_raise(rb_eNotImpError,
+                 "TODO: Ruby -> GIArgument(GHash)[value][%s]",
+                 g_type_tag_to_string(metadata->value_type.tag));
+        break;
       case GI_TYPE_TAG_UTF8:
+        value_destroy_func = g_free;
+        value_ruby_to_c_func = ruby_to_c_utf8;
+        value_ruby_to_c_data.context = "Ruby -> GIArgument(GHash)[value][utf8]";
+        break;
       case GI_TYPE_TAG_FILENAME:
       case GI_TYPE_TAG_ARRAY:
         rb_raise(rb_eNotImpError,
@@ -2029,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);
@@ -505,16 +523,18 @@ rb_gi_arguments_out_init_arg_interface(RBGIArguments *args,
                  g_info_type_to_string(metadata->type.interface_type));
         break;
       case GI_INFO_TYPE_STRUCT:
-        {
-            gsize struct_size;
-
-            /* Should we care gtype?
-               Related: rb_gi_arguments_out_arg_clear_interface() */
-            struct_size = g_struct_info_get_size(metadata->type.interface_info);
+        /* Should we care gtype? */
+        if (metadata->type.pointer_p) {
+            gpointer *struct_location = RB_ALLOC(gpointer);
+            *struct_location = NULL;
+            argument->v_pointer = struct_location;
+        } else {
+            gsize struct_size =
+                g_struct_info_get_size(metadata->type.interface_info);
             argument->v_pointer = xmalloc(struct_size);
             memset(argument->v_pointer, 0, struct_size);
-            metadata->free_func = rb_gi_arguments_out_free_interface_struct;
         }
+        metadata->free_func = rb_gi_arguments_out_free_interface_struct;
         break;
       case GI_INFO_TYPE_BOXED:
         rb_raise(rb_eNotImpError,
@@ -584,7 +604,7 @@ rb_gi_arguments_out_init_arg(RBGIArguments *args,
     memset(argument, 0, sizeof(GIArgument));
     switch (metadata->type.tag) {
       case GI_TYPE_TAG_VOID:
-        if (metadata->pointer_p) {
+        if (metadata->type.pointer_p) {
             gpointer *pointer = ALLOC(gpointer);
             *pointer = NULL;
             argument->v_pointer = pointer;
@@ -800,7 +820,7 @@ rb_gi_arguments_out_to_ruby_arg(RBGIArguments *args,
     memset(&normalized_argument, 0, sizeof(GIArgument));
     switch (metadata->type.tag) {
       case GI_TYPE_TAG_VOID:
-        if (metadata->pointer_p) {
+        if (metadata->type.pointer_p) {
             normalized_argument.v_pointer = *((gpointer *)(argument->v_pointer));
         }
         break;

data/ext/gobject-introspection/rb-gi-arguments.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
@@ -23,16 +23,7 @@
 static gboolean
 rb_gi_arg_info_may_be_null(GIArgInfo *arg_info)
 {
-#if GI_CHECK_VERSION(1, 42, 0)
     return g_arg_info_may_be_null(arg_info);
-#else
-    /*
-      GObject Introspection < 1.42 doesn't support "(nullable)" yet.
-      So, we assume that all argument may be NULL. It's danger but
-      convenient.
-    */
-    return TRUE;
-#endif
 }
 
 static gboolean
@@ -57,12 +48,14 @@ rb_gi_arg_metadata_type_init(RBGIArgMetadataType *type,
                              GITypeInfo *type_info)
 {
     type->info = type_info;
+    type->pointer_p = FALSE;
     type->tag = GI_TYPE_TAG_VOID;
     type->interface_info = NULL;
     type->interface_type = GI_INFO_TYPE_INVALID;
     type->interface_gtype = G_TYPE_INVALID;
 
     if (type->info) {
+        type->pointer_p = g_type_info_is_pointer(type->info);
         type->tag = g_type_info_get_tag(type->info);
     }
     if (type->tag == GI_TYPE_TAG_INTERFACE) {
@@ -114,7 +107,6 @@ rb_gi_arg_metadata_new(GICallableInfo *callable_info, gint i)
     metadata->array_p = (metadata->type.tag == GI_TYPE_TAG_ARRAY);
     metadata->array_length_p = FALSE;
     metadata->may_be_null_p = rb_gi_arg_info_may_be_null(arg_info);
-    metadata->pointer_p = g_type_info_is_pointer(type_info);
     metadata->caller_allocates_p = g_arg_info_is_caller_allocates(arg_info);
     metadata->zero_terminated_p = FALSE;
     metadata->output_buffer_p = rb_gi_arg_info_is_output_buffer(arg_info);
@@ -505,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,
@@ -585,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:
@@ -703,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:
@@ -747,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,
@@ -841,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++;