gobject-introspection 3.3.8 → 3.3.9

data/ext/gobject-introspection/rb-gi-array-type.c

@@ -0,0 +1,54 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2012-2019  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
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rb-gi-private.h"
+
+VALUE
+rb_gi_array_type_to_ruby(GIArrayType type)
+{
+    if (type == (GIArrayType)-1) {
+        return Qnil;
+    } else {
+        return GENUM2RVAL(type, G_TYPE_I_ARRAY_TYPE);
+    }
+}
+
+const gchar *
+rb_gi_array_type_to_string(GIArrayType type)
+{
+    switch (type) {
+      case GI_ARRAY_TYPE_C:
+        return "C";
+      case GI_ARRAY_TYPE_ARRAY:
+        return "GArray";
+      case GI_ARRAY_TYPE_PTR_ARRAY:
+        return "GPtrArray";
+      case GI_ARRAY_TYPE_BYTE_ARRAY:
+        return "GByteArray";
+      default:
+        return "unknown";
+    }
+}
+
+void
+rb_gi_array_type_init(VALUE rb_mGI)
+{
+    G_DEF_CLASS(G_TYPE_I_ARRAY_TYPE, "ArrayType", rb_mGI);
+}

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

@@ -0,0 +1,242 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2012-2019  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
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rb-gi-private.h"
+
+struct RBGICallbackData_ {
+    RBGICallback *callback;
+    RBGIArgMetadata *metadata;
+    VALUE rb_callback;
+    GObject *owner;
+    VALUE rb_owner;
+};
+
+static GPtrArray *callback_finders;
+static VALUE mGLibObject = Qnil;
+static VALUE mGI = Qnil;
+
+static void
+rb_gi_callback_free(RBGICallback *callback)
+{
+    g_callable_info_free_closure(callback->callback_info,
+                                 callback->closure);
+    g_base_info_unref(callback->callback_info);
+    g_base_info_unref(callback->type_info);
+    xfree(callback);
+}
+
+static void
+rb_gi_callback_data_weak_notify(gpointer data,
+                                G_GNUC_UNUSED GObject *where_the_object_was)
+{
+    RBGICallbackData *callback_data = data;
+    callback_data->owner = NULL;
+}
+
+RBGICallbackData *
+rb_gi_callback_data_new(RBGIArguments *args,
+                        RBGICallback *callback,
+                        RBGIArgMetadata *metadata)
+{
+    RBGICallbackData *callback_data;
+    VALUE rb_owner = args->rb_receiver;
+
+    if (rb_gi_is_debug_mode()) {
+        g_print("[rb-gi] callback: %s::%s()\n",
+                g_base_info_get_namespace(args->info),
+                g_base_info_get_name(args->info));
+        rb_p(rb_ary_new_from_args(2, args->rb_receiver, args->rb_args));
+    }
+
+    callback_data = ALLOC(RBGICallbackData);
+    callback_data->callback = callback;
+    callback_data->metadata = metadata;
+    callback_data->rb_callback = rb_block_proc();
+    if (NIL_P(rb_owner)) {
+        /* Module function case. */
+        VALUE rb_first_argument = RARRAY_AREF(args->rb_args, 0);
+        if (RVAL2CBOOL(rb_obj_is_kind_of(rb_first_argument, mGLibObject))) {
+            /* If the first argument of the module function call is
+               GObject, it's suitable for owner.
+               For example: pango_cairo_context_set_shape_renderer() */
+            rb_owner = rb_first_argument;
+        }
+    }
+    if (RVAL2CBOOL(rb_obj_is_kind_of(rb_owner, mGLibObject))) {
+        rbgobj_object_add_relative(rb_owner, callback_data->rb_callback);
+        callback_data->owner = RVAL2GOBJ(rb_owner);
+        g_object_weak_ref(callback_data->owner,
+                          rb_gi_callback_data_weak_notify,
+                          callback_data);
+        callback_data->rb_owner = Qnil;
+    } else {
+        /* Callback is GC-ed only when callback is invalidated. */
+        if (NIL_P(rb_owner)) {
+            /* Module function case. */
+            rbgobj_add_relative(mGI, callback_data->rb_callback);
+            callback_data->rb_owner = mGI;
+        } else {
+            /* Class method case. */
+            rbgobj_add_relative(rb_owner, callback_data->rb_callback);
+            callback_data->rb_owner = rb_owner;
+        }
+        callback_data->owner = NULL;
+    }
+    return callback_data;
+}
+
+void
+rb_gi_callback_data_free(RBGICallbackData *callback_data)
+{
+    if (callback_data->callback) {
+        rb_gi_callback_free(callback_data->callback);
+    }
+    if (callback_data->owner) {
+        VALUE rb_owner;
+        g_object_weak_unref(callback_data->owner,
+                            rb_gi_callback_data_weak_notify,
+                            callback_data);
+        rb_owner = rbgobj_ruby_object_from_instance2(callback_data->owner,
+                                                     FALSE);
+        if (!NIL_P(rb_owner)) {
+            rbgobj_object_remove_relative(rb_owner, callback_data->rb_callback);
+        }
+    }
+    if (!NIL_P(callback_data->rb_owner)) {
+        rbgobj_remove_relative(callback_data->rb_owner,
+                               (ID)0,
+                               callback_data->rb_callback);
+    }
+    xfree(callback_data->metadata);
+    xfree(callback_data);
+}
+
+RBGIArgMetadata *
+rb_gi_callback_data_get_metadata(RBGICallbackData *callback_data)
+{
+    return callback_data->metadata;
+}
+
+VALUE
+rb_gi_callback_data_get_rb_callback(RBGICallbackData *callback_data)
+{
+    return callback_data->rb_callback;
+}
+
+void
+rb_gi_callback_register_finder(RBGICallbackFinderFunc finder)
+{
+    g_ptr_array_add(callback_finders, finder);
+}
+
+gpointer
+rb_gi_callback_find(GIArgInfo *info)
+{
+    guint i;
+    gpointer callback = NULL;
+
+    for (i = 0; i < callback_finders->len; i++) {
+        RBGICallbackFinderFunc finder = g_ptr_array_index(callback_finders, i);
+        callback = finder(info);
+        if (callback) {
+            break;
+        }
+    }
+
+    return callback;
+}
+
+static gboolean
+source_func_p(GIArgInfo *info)
+{
+    GITypeInfo type_info;
+    GIBaseInfo *interface_info;
+    GICallableInfo *callback_info;
+    GITypeInfo return_type_info;
+    GIArgInfo first_arg_info;
+    GITypeInfo first_arg_type_info;
+
+    g_arg_info_load_type(info, &type_info);
+    if (g_type_info_get_tag(&type_info) != GI_TYPE_TAG_INTERFACE) {
+        return FALSE;
+    }
+
+    interface_info = g_type_info_get_interface(&type_info);
+    if (g_base_info_get_type(interface_info) != GI_INFO_TYPE_CALLBACK) {
+        g_base_info_unref(interface_info);
+        return FALSE;
+    }
+
+    callback_info = (GICallableInfo *)interface_info;
+    g_callable_info_load_return_type(callback_info, &return_type_info);
+    if (g_type_info_get_tag(&return_type_info) != GI_TYPE_TAG_BOOLEAN) {
+        g_base_info_unref(interface_info);
+        return FALSE;
+    }
+
+    if (g_callable_info_get_n_args(interface_info) != 1) {
+        g_base_info_unref(interface_info);
+        return FALSE;
+    }
+
+    g_callable_info_load_arg(interface_info, 0, &first_arg_info);
+    g_arg_info_load_type(&first_arg_info, &first_arg_type_info);
+    if (g_type_info_get_tag(&first_arg_type_info) != GI_TYPE_TAG_VOID) {
+        g_base_info_unref(interface_info);
+        return FALSE;
+    }
+
+    g_base_info_unref(interface_info);
+    return TRUE;
+}
+
+static gboolean
+source_func_callback(gpointer user_data)
+{
+    RBGICallbackData *callback_data = user_data;
+    VALUE rb_keep;
+    ID id_call;
+
+    CONST_ID(id_call, "call");
+    rb_keep = rb_funcall(callback_data->rb_callback, id_call, 0);
+    if (callback_data->metadata->scope_type == GI_SCOPE_TYPE_ASYNC) {
+        rb_gi_callback_data_free(callback_data);
+    }
+    return RVAL2CBOOL(rb_keep);
+}
+
+static gpointer
+source_func_callback_finder(GIArgInfo *arg_info)
+{
+    if (!source_func_p(arg_info)) {
+        return NULL;
+    }
+    return source_func_callback;
+}
+
+void
+rb_gi_callback_init(VALUE rb_mGI)
+{
+    callback_finders = g_ptr_array_new();
+    rb_gi_callback_register_finder(source_func_callback_finder);
+
+    mGLibObject = rb_const_get(mGLib, rb_intern("Object"));
+    mGI = rb_mGI;
+}

data/ext/gobject-introspection/rb-gi-conversions.h

@@ -35,23 +35,10 @@
                          in_args, out_args, args_metadata)              \
     (rb_gi_argument_to_ruby((argument), (duplicate), (type_info),       \
                             (in_args), (out_args), (args_metadata)))
-#define GI_OUT_ARGUMENT2RVAL(argument, arg_info,                        \
-                             in_args, out_args, args_metadata)          \
-    (rb_gi_out_argument_to_ruby((argument), (arg_info),                 \
-                                (in_args), (out_args), (args_metadata)))
 #define GI_RETURN_ARGUMENT2RVAL(callable_info, argument,                \
                                 in_args, out_args, args_metadata)       \
     (rb_gi_return_argument_to_ruby((callable_info), (argument),         \
                                    (in_args), (out_args), (args_metadata)))
-#define RVAL2GI_VALUE_ARGUMENT(argument, type_info, rb_argument, self)  \
-    (rb_gi_value_argument_from_ruby((argument), (type_info),            \
-                                    (rb_argument), (self)))
-#define RVAL2GI_IN_ARRAY_ARGUMENT(array_argument, length_argument,      \
-                                  array_arg_info, length_arg_info,      \
-                                  rb_argument)                          \
-    (rb_gi_in_array_argument_from_ruby((array_argument), (length_argument), \
-                                       (array_arg_info), (length_arg_info), \
-                                       (rb_argument)))
 
 
 #define RVAL2GI_REGISTERED_TYPE_INFO(rb_object)			\
@@ -106,41 +93,11 @@ VALUE       rb_gi_argument_to_ruby            (GIArgument     *argument,
                                                GArray         *in_args,
                                                GArray         *out_args,
                                                GPtrArray      *args_metadata);
-void        rb_gi_out_argument_init           (GIArgument     *argument,
-                                               GIArgInfo      *arg_info);
-VALUE       rb_gi_out_argument_to_ruby        (GIArgument     *argument,
-                                               GIArgInfo      *arg_info,
-                                               GArray         *in_args,
-                                               GArray         *out_args,
-                                               GPtrArray      *args_metadata);
-void        rb_gi_out_argument_fin            (GIArgument     *argument,
-                                               GIArgInfo      *arg_info);
 VALUE       rb_gi_return_argument_to_ruby     (GICallableInfo *callable_info,
                                                GIArgument     *argument,
                                                GArray         *in_args,
                                                GArray         *out_args,
                                                GPtrArray      *args_metadata);
-GIArgument *rb_gi_value_argument_from_ruby    (GIArgument     *argument,
-                                               GITypeInfo     *type_info,
-                                               VALUE           rb_argument,
-                                               VALUE           self);
-GIArgument *rb_gi_in_argument_from_ruby       (GICallableInfo *callable_info,
-                                               GIArgument     *argument,
-                                               GIArgInfo      *arg_info,
-                                               guint           nth_rb_argument,
-                                               VALUE           rb_argument,
-                                               VALUE           self);
-GIArgument *rb_gi_in_array_argument_from_ruby (GIArgument     *array_argument,
-                                               GIArgument     *length_argument,
-                                               GIArgInfo      *array_arg_info,
-                                               GIArgInfo      *length_arg_info,
-                                               VALUE           rb_argument);
-void        rb_gi_value_argument_free         (VALUE           rb_argument,
-                                               GIArgument     *argument,
-                                               GITypeInfo     *type_info);
-void        rb_gi_in_argument_free            (VALUE           rb_argument,
-                                               GIArgument     *argument,
-                                               GIArgInfo      *arg_info);
 
 VALUE       rb_gi_array_type_to_ruby          (GIArrayType type);
 

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

@@ -0,0 +1,36 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2019  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
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rb-gi-private.h"
+
+const gchar *
+rb_gi_direction_to_string(GIDirection direction)
+{
+    switch (direction) {
+      case GI_DIRECTION_IN:
+        return "in";
+      case GI_DIRECTION_OUT:
+        return "out";
+      case GI_DIRECTION_INOUT:
+        return "inout";
+      default:
+        return "unknown";
+    }
+}

data/ext/gobject-introspection/rb-gi-field-info.c

@@ -248,99 +248,190 @@ void
 rb_gi_field_info_set_field_raw(GIFieldInfo *info, gpointer memory,
                                VALUE rb_field_value)
 {
-    GIArgument field_value;
+    gint offset;
     GITypeInfo *type_info;
     GITypeTag type_tag;
-    gboolean succeeded;
+    gboolean succeeded = TRUE;
 
+    offset = g_field_info_get_offset(info);
     type_info = g_field_info_get_type(info);
     type_tag = g_type_info_get_tag(type_info);
-    RVAL2GI_VALUE_ARGUMENT(&field_value, type_info, rb_field_value, Qnil);
 
-    succeeded = g_field_info_set_field(info, memory, &field_value);
-    if (!succeeded) {
-        switch (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:
-            break;
-          case GI_TYPE_TAG_UTF8:
-            {
-                int offset;
-                offset = g_field_info_get_offset(info);
-                G_STRUCT_MEMBER(gchar *, memory, offset) = field_value.v_string;
-                succeeded = TRUE;
-            }
-            break;
-          case GI_TYPE_TAG_FILENAME:
-          case GI_TYPE_TAG_ARRAY:
-            break;
-          case GI_TYPE_TAG_INTERFACE:
-            {
-                GIBaseInfo *interface_info;
-                GIInfoType interface_type;
-
-                interface_info = g_type_info_get_interface(type_info);
-                interface_type = g_base_info_get_type(interface_info);
-                switch (interface_type) {
-                  case GI_INFO_TYPE_INVALID:
-                  case GI_INFO_TYPE_FUNCTION:
-                  case GI_INFO_TYPE_CALLBACK:
-                    break;
-                  case GI_INFO_TYPE_STRUCT:
-                  case GI_INFO_TYPE_BOXED:
-                  case GI_INFO_TYPE_UNION:
-                    {
-                        int offset;
-
-                        offset = g_field_info_get_offset(info);
+    if ((g_field_info_get_flags(info) & GI_FIELD_IS_WRITABLE) == 0) {
+        g_base_info_unref(type_info);
+        rb_raise(rb_eArgError,
+                 "failed to set field value: not writable: %s[%s]",
+                 g_base_info_get_name(info),
+                 g_type_tag_to_string(type_tag));
+    }
+
+    /* TODO: Use g_field_info_set_field() again? */
+    switch (type_tag) {
+      case GI_TYPE_TAG_VOID:
+        succeeded = FALSE;
+        break;
+      case GI_TYPE_TAG_BOOLEAN:
+        G_STRUCT_MEMBER(gboolean, memory, offset) = RVAL2CBOOL(rb_field_value);
+        break;
+      case GI_TYPE_TAG_INT8:
+        G_STRUCT_MEMBER(gint8, memory, offset) = NUM2CHR(rb_field_value);
+        break;
+      case GI_TYPE_TAG_UINT8:
+        G_STRUCT_MEMBER(guint8, memory, offset) =
+            (guint8)NUM2CHR(rb_field_value);
+        break;
+      case GI_TYPE_TAG_INT16:
+        G_STRUCT_MEMBER(gint16, memory, offset) = NUM2SHORT(rb_field_value);
+        break;
+      case GI_TYPE_TAG_UINT16:
+        G_STRUCT_MEMBER(guint16, memory, offset) = NUM2USHORT(rb_field_value);
+        break;
+      case GI_TYPE_TAG_INT32:
+        G_STRUCT_MEMBER(gint32, memory, offset) = NUM2INT(rb_field_value);
+        break;
+      case GI_TYPE_TAG_UINT32:
+        G_STRUCT_MEMBER(guint32, memory, offset) = NUM2UINT(rb_field_value);
+        break;
+      case GI_TYPE_TAG_INT64:
+        G_STRUCT_MEMBER(gint64, memory, offset) = NUM2LL(rb_field_value);
+        break;
+      case GI_TYPE_TAG_UINT64:
+        G_STRUCT_MEMBER(guint64, memory, offset) = NUM2ULL(rb_field_value);
+        break;
+      case GI_TYPE_TAG_FLOAT:
+        G_STRUCT_MEMBER(gfloat, memory, offset) = NUM2DBL(rb_field_value);
+        break;
+      case GI_TYPE_TAG_DOUBLE:
+        G_STRUCT_MEMBER(gdouble, memory, offset) = NUM2DBL(rb_field_value);
+        break;
+      case GI_TYPE_TAG_GTYPE:
+        G_STRUCT_MEMBER(GType, memory, offset) =
+            rbgobj_gtype_from_ruby(rb_field_value);
+        break;
+      case GI_TYPE_TAG_UTF8:
+        G_STRUCT_MEMBER(const gchar *, memory, offset) =
+            RVAL2CSTR_ACCEPT_SYMBOL(rb_field_value);
+        break;
+      case GI_TYPE_TAG_FILENAME:
+        /* TODO: How to free? */
+        /* G_STRUCT_MEMBER(gchar *, memory, offset) = */
+        /*     rbg_filename_from_ruby(rb_field_value); */
+        succeeded = FALSE;
+        break;
+      case GI_TYPE_TAG_ARRAY:
+        succeeded = FALSE;
+        break;
+      case GI_TYPE_TAG_INTERFACE:
+        {
+            GIBaseInfo *interface_info;
+            GIInfoType interface_type;
+
+            interface_info = g_type_info_get_interface(type_info);
+            interface_type = g_base_info_get_type(interface_info);
+            switch (interface_type) {
+              case GI_INFO_TYPE_INVALID:
+              case GI_INFO_TYPE_FUNCTION:
+              case GI_INFO_TYPE_CALLBACK:
+                succeeded = FALSE;
+                break;
+              case GI_INFO_TYPE_STRUCT:
+                {
+                    GType gtype =
+                        g_registered_type_info_get_g_type(interface_info);
+                    G_STRUCT_MEMBER(gpointer, memory, offset) =
+                        rb_gi_struct_get_raw(rb_field_value, gtype);
+                }
+                break;
+              case GI_INFO_TYPE_BOXED:
+              case GI_INFO_TYPE_UNION:
+                {
+                    GType gtype =
+                        g_registered_type_info_get_g_type(interface_info);
+                    if (gtype == G_TYPE_NONE) {
+                        succeeded = FALSE;
+                    } else {
                         G_STRUCT_MEMBER(gpointer, memory, offset) =
-                            field_value.v_pointer;
-                        succeeded = TRUE;
+                            RVAL2BOXED(rb_field_value, gtype);
                     }
-                    break;
-                  case GI_INFO_TYPE_ENUM:
-                  case GI_INFO_TYPE_FLAGS:
-                  case GI_INFO_TYPE_OBJECT:
-                  case GI_INFO_TYPE_INTERFACE:
-                  case GI_INFO_TYPE_CONSTANT:
-                  case GI_INFO_TYPE_INVALID_0:
-                  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:
-                    break;
-                  default:
-                    break;
                 }
-                g_base_info_unref(interface_info);
+                break;
+              case GI_INFO_TYPE_ENUM:
+              case GI_INFO_TYPE_FLAGS:
+                {
+                    GType gtype =
+                        g_registered_type_info_get_g_type(interface_info);
+                    GITypeTag storage_type =
+                        g_enum_info_get_storage_type(interface_info);
+                    gint value;
+                    if (gtype == G_TYPE_NONE) {
+                        value = NUM2INT(rb_field_value);
+                    } else {
+                        if (interface_type == GI_INFO_TYPE_ENUM) {
+                            value = RVAL2GENUM(rb_field_value, gtype);
+                        } else {
+                            value = RVAL2GFLAGS(rb_field_value, gtype);
+                        }
+                    }
+                    switch (storage_type) {
+                      case GI_TYPE_TAG_INT8:
+                      case GI_TYPE_TAG_UINT8:
+                        G_STRUCT_MEMBER(guint8, memory, offset) =
+                            (guint8)value;
+                        break;
+                      case GI_TYPE_TAG_INT16:
+                      case GI_TYPE_TAG_UINT16:
+                        G_STRUCT_MEMBER(guint16, memory, offset) =
+                            (guint16)value;
+                        break;
+                      case GI_TYPE_TAG_INT32:
+                      case GI_TYPE_TAG_UINT32:
+                        G_STRUCT_MEMBER(guint32, memory, offset) =
+                            (guint32)value;
+                        break;
+                      case GI_TYPE_TAG_INT64:
+                      case GI_TYPE_TAG_UINT64:
+                        G_STRUCT_MEMBER(guint64, memory, offset) =
+                            (guint64)value;
+                        break;
+                      default:
+                        succeeded = FALSE;
+                        break;
+                    }
+                }
+                break;
+              case GI_INFO_TYPE_OBJECT:
+                G_STRUCT_MEMBER(gpointer, memory, offset) =
+                    RVAL2GOBJ(rb_field_value);
+                break;
+              case GI_INFO_TYPE_INTERFACE:
+              case GI_INFO_TYPE_CONSTANT:
+              case GI_INFO_TYPE_INVALID_0:
+              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:
+                succeeded = FALSE;
+                break;
+              default:
+                break;
             }
-            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:
-            break;
-          default:
-            break;
+            g_base_info_unref(interface_info);
         }
+        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:
+        succeeded = FALSE;
+        break;
+      default:
+        break;
     }
-    rb_gi_value_argument_free(rb_field_value, &field_value, type_info);
     g_base_info_unref(type_info);
 
     if (!succeeded) {