gobject-introspection 2.1.0-x86-mingw32 → 2.2.0-x86-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f7bb843dfbcb1b88ad3a77ee38edbd15e24cc101
-  data.tar.gz: de2b36422c6d3bc6e95c5f6e13f534c9b3a55d13
+  metadata.gz: 7dc58d3a16683bfc549a15a04932160e7a03962f
+  data.tar.gz: e33422fa5a785789df80009cd998fbc45614083e
 SHA512:
-  metadata.gz: ed9a13f9ab6866813cdf7ddaeedf1fc924bdd7d4e7fff65f14562c8f9e1a8b830344ea104ad423b9165c54166090988a700e9e253a66fe5a5c12f1a75b4b4f16
-  data.tar.gz: 1304a7dcb2b14e1ce1b05db0df59067b5faf6e53d34fcb1998f66e683e1db99423da56efeef8f9bbb4ee5d08a138624343be0fdd5438cbfa015cc3f36c942a36
+  metadata.gz: 5f6b837f2f656efd261f96196ed1d83ecaaca0e1c074281d762b71471374db75afedc353f89940e7af929d297f7e306900d6773997db29ac0dafa636b61da7f9
+  data.tar.gz: 94af97fd8d5d02188929b2e0ad560eed9d47add513364772c7e3b46d8efc7dc4539b7b52577f5bf13f935323b61762c2d99a6dcb60624831c2ba1e176f2369b0

data/Rakefile

@@ -81,6 +81,7 @@ namespace :native do
       Dir.chdir(g_ir_scanner_dir.to_s) do
         patch = "#{package_task.package.patches_dir}/cross-g-ir-scanner.diff"
         sh("patch -p2 < #{patch}")
+        rm_f(Dir.glob("*.{pyc,pyo}"))
       end
     end
   end

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012-2013  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2012-2014  Ruby-GNOME2 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,21 +23,22 @@
 static VALUE rb_cGLibValue = Qnil;
 
 static void
-array_c_to_ruby(const gchar **elements, GITypeInfo *type_info, VALUE rb_array)
+array_c_to_ruby(GIArgument *array, GITypeInfo *type_info, gint64 n_elements,
+                VALUE rb_array)
 {
-    gint n_elements;
+    const gchar **elements;
     gboolean fixed_size_p;
     gboolean zero_terminated_p;
 
+    elements = array->v_pointer;
     if (!elements) {
         return;
     }
 
-    n_elements = g_type_info_get_array_length(type_info);
     fixed_size_p = g_type_info_get_array_fixed_size(type_info);
     zero_terminated_p = g_type_info_is_zero_terminated(type_info);
     if (n_elements != -1) {
-        gint i;
+        gint64 i;
         for (i = 0; i < n_elements; i++) {
             rb_ary_push(rb_array, CSTR2RVAL(elements[i]));
         }
@@ -50,22 +51,91 @@ array_c_to_ruby(const gchar **elements, GITypeInfo *type_info, VALUE rb_array)
                  "TODO: GIArgument(array)[c] -> Ruby: "
                  "zero-terminated: %s "
                  "fixed-size: %s "
-                 "length: %d",
+                 "length: %" G_GINT64_FORMAT,
                  zero_terminated_p ? "true" : "false",
                  fixed_size_p ? "true" : "false",
                  n_elements);
     }
 }
 
-static VALUE
-array_to_ruby(gpointer array, GITypeInfo *type_info)
+static gint64
+get_array_length(GIArgument *argument, GITypeInfo *type_info)
+{
+    GITypeTag type_tag;
+    gint64 length = -1;
+
+    if (!argument) {
+        return length;
+    }
+
+    type_tag = g_type_info_get_tag(type_info);
+    switch (type_tag) {
+      case GI_TYPE_TAG_VOID:
+      case GI_TYPE_TAG_BOOLEAN:
+        rb_raise(rb_eNotImpError,
+                 "TODO: invalid array length argument?: <%s>",
+                 g_type_tag_to_string(type_tag));
+        break;
+      case GI_TYPE_TAG_INT8:
+        length = argument->v_int8;
+        break;
+      case GI_TYPE_TAG_UINT8:
+        length = argument->v_uint8;
+        break;
+      case GI_TYPE_TAG_INT16:
+        length = argument->v_int16;
+        break;
+      case GI_TYPE_TAG_UINT16:
+        length = argument->v_uint16;
+        break;
+      case GI_TYPE_TAG_INT32:
+        length = argument->v_int32;
+        break;
+      case GI_TYPE_TAG_UINT32:
+        length = argument->v_uint32;
+        break;
+      case GI_TYPE_TAG_INT64:
+        length = argument->v_int64;
+        break;
+      case GI_TYPE_TAG_UINT64:
+        length = argument->v_uint64;
+        break;
+      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:
+      case GI_TYPE_TAG_INTERFACE:
+      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:
+        rb_raise(rb_eNotImpError,
+                 "TODO: invalid array length argument?: <%s>",
+                 g_type_tag_to_string(type_tag));
+        break;
+      default:
+        g_assert_not_reached();
+        break;
+    }
+
+    return length;
+}
+
+VALUE
+rb_gi_array_argument_to_ruby(GIArgument *array_argument,
+                             GIArgument *length_argument,
+                             GITypeInfo *array_type_info,
+                             GITypeInfo *length_type_info)
 {
     VALUE rb_array;
     GIArrayType array_type;
     gint n_elements;
 
-    array_type = g_type_info_get_array_type(type_info);
-    n_elements = g_type_info_get_array_length(type_info);
+    array_type = g_type_info_get_array_type(array_type_info);
+    n_elements = get_array_length(length_argument, length_type_info);
     if (n_elements == -1) {
         rb_array = rb_ary_new();
     } else {
@@ -73,7 +143,7 @@ array_to_ruby(gpointer array, GITypeInfo *type_info)
     }
     switch (array_type) {
       case GI_ARRAY_TYPE_C:
-        array_c_to_ruby(array, type_info, rb_array);
+        array_c_to_ruby(array_argument, array_type_info, n_elements, rb_array);
         break;
       case GI_ARRAY_TYPE_ARRAY:
         rb_raise(rb_eNotImpError, "TODO: GIArgument(array)[array] -> Ruby");
@@ -118,7 +188,15 @@ interface_to_ruby(GIArgument *argument, GITypeInfo *type_info)
                  "TODO: GIArgument(interface)[callback] -> Ruby");
         break;
       case GI_INFO_TYPE_STRUCT:
-        rb_interface = BOXED2RVAL(argument->v_pointer, gtype);
+        if (gtype == G_TYPE_BYTES) {
+            GBytes *bytes = argument->v_pointer;
+            gconstpointer data;
+            gsize size;
+            data = g_bytes_get_data(bytes, &size);
+            rb_interface = rb_enc_str_new(data, size, rb_ascii8bit_encoding());
+        } else {
+            rb_interface = BOXED2RVAL(argument->v_pointer, gtype);
+        }
         break;
       case GI_INFO_TYPE_BOXED:
         rb_raise(rb_eNotImpError,
@@ -255,7 +333,8 @@ rb_gi_argument_to_ruby(GIArgument *argument, GITypeInfo *type_info)
         rb_argument = CSTR2RVAL(argument->v_string);
         break;
       case GI_TYPE_TAG_ARRAY:
-        rb_argument = array_to_ruby(argument->v_pointer, type_info);
+        rb_argument = rb_gi_array_argument_to_ruby(argument, NULL,
+                                                   type_info, NULL);
         break;
       case GI_TYPE_TAG_INTERFACE:
         rb_argument = interface_to_ruby(argument, type_info);
@@ -500,6 +579,102 @@ rb_gi_out_argument_to_ruby(GIArgument *argument, GIArgInfo *arg_info)
     return rb_gi_argument_to_ruby(&normalized_argument, &type_info);
 }
 
+static void
+normalize_out_array_length(GIArgument *normalized_argument,
+                           GIArgument *argument,
+                           GITypeInfo *type_info)
+{
+    GITypeTag type_tag;
+
+    type_tag = g_type_info_get_tag(type_info);
+    switch (type_tag) {
+      case GI_TYPE_TAG_VOID:
+      case GI_TYPE_TAG_BOOLEAN:
+        rb_raise(rb_eNotImpError,
+                 "TODO: invalid out array length argument?: <%s>",
+                 g_type_tag_to_string(type_tag));
+        break;
+      case GI_TYPE_TAG_INT8:
+        normalized_argument->v_int8 = *((gint8 *)argument->v_pointer);
+        break;
+      case GI_TYPE_TAG_UINT8:
+        normalized_argument->v_uint8 = *((guint8 *)argument->v_pointer);
+        break;
+      case GI_TYPE_TAG_INT16:
+        normalized_argument->v_int16 = *((gint16 *)argument->v_pointer);
+        break;
+      case GI_TYPE_TAG_UINT16:
+        normalized_argument->v_uint16 = *((guint16 *)argument->v_pointer);
+        break;
+      case GI_TYPE_TAG_INT32:
+        normalized_argument->v_int32 = *((gint32 *)argument->v_pointer);
+        break;
+      case GI_TYPE_TAG_UINT32:
+        normalized_argument->v_uint32 = *((guint32 *)argument->v_pointer);
+        break;
+      case GI_TYPE_TAG_INT64:
+        normalized_argument->v_int64 = *((gint64 *)argument->v_pointer);
+        break;
+      case GI_TYPE_TAG_UINT64:
+        normalized_argument->v_uint64 = *((guint64 *)argument->v_pointer);
+        break;
+      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:
+      case GI_TYPE_TAG_INTERFACE:
+      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:
+        rb_raise(rb_eNotImpError,
+                 "TODO: invalid out array length argument?: <%s>",
+                 g_type_tag_to_string(type_tag));
+        break;
+      default:
+        g_assert_not_reached();
+        break;
+    }
+}
+
+VALUE
+rb_gi_out_array_argument_to_ruby(GIArgument *array_argument,
+                                 GIArgument *length_argument,
+                                 GIArgInfo *array_arg_info,
+                                 GIArgInfo *length_arg_info)
+{
+    VALUE rb_array;
+    GIArgument normalized_array_argument;
+    GITypeInfo array_type_info;
+
+    normalized_array_argument.v_pointer =
+        *((gpointer *)(array_argument->v_pointer));
+    g_arg_info_load_type(array_arg_info, &array_type_info);
+    if (length_argument) {
+        GITypeInfo length_type_info;
+        GIArgument normalized_length_argument;
+
+        g_arg_info_load_type(length_arg_info, &length_type_info);
+        normalize_out_array_length(&normalized_length_argument,
+                                   length_argument,
+                                   &length_type_info);
+        rb_array = rb_gi_array_argument_to_ruby(&normalized_array_argument,
+                                                &normalized_length_argument,
+                                                &array_type_info,
+                                                &length_type_info);
+    } else {
+        rb_array = rb_gi_array_argument_to_ruby(&normalized_array_argument,
+                                                NULL,
+                                                &array_type_info,
+                                                NULL);
+    }
+
+    return rb_array;
+}
+
 void
 rb_gi_out_argument_fin(GIArgument *argument, GIArgInfo *arg_info)
 {
@@ -514,7 +689,7 @@ rb_gi_out_argument_fin(GIArgument *argument, GIArgInfo *arg_info)
 }
 
 static void
-rb_gi_return_argument_free_container(GIArgument *argument,
+rb_gi_return_argument_free_container(G_GNUC_UNUSED GIArgument *argument,
                                      GITypeInfo *type_info)
 {
     GITypeTag type_tag;
@@ -549,15 +724,36 @@ rb_gi_return_argument_free_everything_array(GIArgument *argument,
     }
 }
 
+static void
+rb_gi_return_argument_free_everything_interface_struct(GIArgument *argument,
+                                                       GType       gtype)
+{
+    if (!argument->v_pointer) {
+        return;
+    }
+
+    if (!gtype) {
+        xfree(argument->v_pointer);
+    }
+
+    if (G_TYPE_IS_BOXED(gtype)) {
+        g_boxed_free(gtype, argument->v_pointer);
+    } else {
+        rbgobj_instance_unref(argument->v_pointer);
+    }
+}
+
 static void
 rb_gi_return_argument_free_everything_interface(GIArgument *argument,
                                                 GITypeInfo *type_info)
 {
     GIBaseInfo *interface_info;
     GIInfoType interface_type;
+    GType gtype;
 
     interface_info = g_type_info_get_interface(type_info);
     interface_type = g_base_info_get_type(interface_info);
+    gtype = g_registered_type_info_get_g_type(interface_info);
     g_base_info_unref(interface_info);
 
     switch (interface_type) {
@@ -574,7 +770,7 @@ rb_gi_return_argument_free_everything_interface(GIArgument *argument,
                  "TODO: free GIArgument(interface)[callback] everything");
         break;
       case GI_INFO_TYPE_STRUCT:
-        rbgobj_instance_unref(argument->v_pointer);
+        rb_gi_return_argument_free_everything_interface_struct(argument, gtype);
         break;
       case GI_INFO_TYPE_BOXED:
         rb_raise(rb_eNotImpError,
@@ -594,8 +790,9 @@ rb_gi_return_argument_free_everything_interface(GIArgument *argument,
         }
         break;
       case GI_INFO_TYPE_INTERFACE:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(interface)[interface] everything");
+        if (argument->v_pointer) {
+            g_object_unref(argument->v_pointer);
+        }
         break;
       case GI_INFO_TYPE_CONSTANT:
         rb_raise(rb_eNotImpError,
@@ -734,87 +931,6 @@ rb_gi_return_argument_to_ruby(GIArgument *argument,
     return rb_argument;
 }
 
-static void
-rb_gi_argument_from_ruby_array_c(GIArgument *argument,
-                                 G_GNUC_UNUSED GITypeInfo *type_info,
-                                 GITypeInfo *element_type_info,
-                                 VALUE rb_argument)
-{
-    GITypeTag element_type_tag;
-
-    element_type_tag = g_type_info_get_tag(element_type_info);
-    switch (element_type_tag) {
-      case GI_TYPE_TAG_VOID:
-      case GI_TYPE_TAG_BOOLEAN:
-        rb_raise(rb_eNotImpError,
-                 "TODO: Ruby -> GIArgument(array)[%s]",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-      case GI_TYPE_TAG_INT8:
-      case GI_TYPE_TAG_UINT8:
-        argument->v_pointer = RSTRING_PTR(rb_argument);
-        break;
-      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:
-        rb_raise(rb_eNotImpError,
-                 "TODO: Ruby -> GIArgument(array)[%s]",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-      case GI_TYPE_TAG_UTF8:
-      case GI_TYPE_TAG_FILENAME:
-        argument->v_pointer = RVAL2STRV(rb_argument);
-        break;
-      case GI_TYPE_TAG_ARRAY:
-      case GI_TYPE_TAG_INTERFACE:
-      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:
-        rb_raise(rb_eNotImpError,
-                 "TODO: Ruby -> GIArgument(array)[%s]",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-      default:
-        g_assert_not_reached();
-        break;
-    }
-}
-
-static void
-rb_gi_argument_from_ruby_array(GIArgument *argument, GITypeInfo *type_info,
-                               VALUE rb_argument)
-{
-    GIArrayType array_type;
-    GITypeInfo *element_type_info;
-
-    array_type = g_type_info_get_array_type(type_info);
-    element_type_info = g_type_info_get_param_type(type_info, 0);
-    switch (array_type) {
-      case GI_ARRAY_TYPE_C:
-        rb_gi_argument_from_ruby_array_c(argument,
-                                         type_info, element_type_info,
-                                         rb_argument);
-        break;
-      case GI_ARRAY_TYPE_ARRAY:
-      case GI_ARRAY_TYPE_PTR_ARRAY:
-      case GI_ARRAY_TYPE_BYTE_ARRAY:
-        /* TODO */
-        break;
-      default:
-        g_assert_not_reached();
-        break;
-    }
-    g_base_info_unref(element_type_info);
-}
-
 static void
 rb_gi_argument_from_ruby_interface(GIArgument *argument, GITypeInfo *type_info,
                                    VALUE rb_argument)
@@ -907,6 +1023,20 @@ rb_gi_argument_from_ruby_interface(GIArgument *argument, GITypeInfo *type_info,
     g_base_info_unref(interface_info);
 }
 
+static void
+rb_gi_value_argument_from_ruby_void(GIArgument *argument, GITypeInfo *type_info,
+                                    VALUE rb_argument)
+{
+    if (!g_type_info_is_pointer(type_info)) {
+        return;
+    }
+
+    if (RB_TYPE_P(rb_argument, RUBY_T_STRING)) {
+        argument->v_pointer = RSTRING_PTR(rb_argument);
+    } else {
+        argument->v_pointer = GUINT_TO_POINTER(NUM2ULONG(rb_argument));
+    }
+}
 
 GIArgument *
 rb_gi_value_argument_from_ruby(GIArgument *argument, GITypeInfo *type_info,
@@ -919,9 +1049,7 @@ rb_gi_value_argument_from_ruby(GIArgument *argument, GITypeInfo *type_info,
     type_tag = g_type_info_get_tag(type_info);
     switch (type_tag) {
       case GI_TYPE_TAG_VOID:
-        if (g_type_info_is_pointer(type_info)) {
-            argument->v_pointer = GUINT_TO_POINTER(NUM2ULONG(rb_argument));
-        }
+        rb_gi_value_argument_from_ruby_void(argument, type_info, rb_argument);
         break;
       case GI_TYPE_TAG_BOOLEAN:
         argument->v_boolean = RVAL2CBOOL(rb_argument);
@@ -968,7 +1096,9 @@ rb_gi_value_argument_from_ruby(GIArgument *argument, GITypeInfo *type_info,
         argument->v_string = (gchar *)RVAL2CSTR(rb_argument);
         break;
       case GI_TYPE_TAG_ARRAY:
-        rb_gi_argument_from_ruby_array(argument, type_info, rb_argument);
+        rb_raise(rb_eNotImpError,
+                 "should not be reached: Ruby -> GIArgument(%s)",
+                 g_type_tag_to_string(type_tag));
         break;
       case GI_TYPE_TAG_INTERFACE:
         rb_gi_argument_from_ruby_interface(argument, type_info, rb_argument);
@@ -1058,6 +1188,10 @@ rb_gi_inout_argument_from_ruby(GIArgument *argument,
         *((gchar **)argument->v_pointer) = in_argument.v_string;
         break;
       case GI_TYPE_TAG_ARRAY:
+        rb_raise(rb_eNotImpError,
+                 "should not be reached: Ruby -> GIArgument(%s)",
+                 g_type_tag_to_string(type_tag));
+        break;
       case GI_TYPE_TAG_INTERFACE:
       case GI_TYPE_TAG_GLIST:
       case GI_TYPE_TAG_GSLIST:
@@ -1220,15 +1354,376 @@ rb_gi_in_argument_from_ruby(GIArgument *argument, GIArgInfo *arg_info,
     return argument;
 }
 
+static void
+set_in_array_length_argument(GIArgument *argument,
+                             GITypeInfo *type_info,
+                             gint64 length)
+{
+    GITypeTag type_tag;
+
+    if (!argument) {
+        return;
+    }
+
+    type_tag = g_type_info_get_tag(type_info);
+    switch (type_tag) {
+      case GI_TYPE_TAG_VOID:
+      case GI_TYPE_TAG_BOOLEAN:
+        rb_raise(rb_eNotImpError,
+                 "TODO: invalid argument?: length[%s]",
+                 g_type_tag_to_string(type_tag));
+        break;
+      case GI_TYPE_TAG_INT8:
+        argument->v_int8 = length;
+        break;
+      case GI_TYPE_TAG_UINT8:
+        argument->v_uint8 = length;
+        break;
+      case GI_TYPE_TAG_INT16:
+        argument->v_int16 = length;
+        break;
+      case GI_TYPE_TAG_UINT16:
+        argument->v_uint16 = length;
+        break;
+      case GI_TYPE_TAG_INT32:
+        argument->v_int32 = length;
+        break;
+      case GI_TYPE_TAG_UINT32:
+        argument->v_uint32 = length;
+        break;
+      case GI_TYPE_TAG_INT64:
+        argument->v_int64 = length;
+        break;
+      case GI_TYPE_TAG_UINT64:
+        argument->v_uint64 = length;
+        break;
+      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:
+      case GI_TYPE_TAG_INTERFACE:
+      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:
+        rb_raise(rb_eNotImpError,
+                 "TODO: invalid argument?: length[%s]",
+                 g_type_tag_to_string(type_tag));
+        break;
+      default:
+        g_assert_not_reached();
+        break;
+    }
+}
+
+static void
+in_array_c_argument_from_ruby(GIArgument *array_argument,
+                              GIArgument *length_argument,
+                              G_GNUC_UNUSED GITypeInfo *array_type_info,
+                              GITypeInfo *length_type_info,
+                              GITypeInfo *element_type_info,
+                              VALUE rb_argument)
+{
+    GITypeTag element_type_tag;
+
+    element_type_tag = g_type_info_get_tag(element_type_info);
+    switch (element_type_tag) {
+      case GI_TYPE_TAG_VOID:
+      case GI_TYPE_TAG_BOOLEAN:
+        rb_raise(rb_eNotImpError,
+                 "TODO: Ruby -> GIArgument(array)[%s]",
+                 g_type_tag_to_string(element_type_tag));
+        break;
+      case GI_TYPE_TAG_INT8:
+      case GI_TYPE_TAG_UINT8:
+        array_argument->v_pointer = RSTRING_PTR(rb_argument);
+        set_in_array_length_argument(length_argument, length_type_info,
+                                     RSTRING_LEN(rb_argument));
+        break;
+      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:
+        rb_raise(rb_eNotImpError,
+                 "TODO: Ruby -> GIArgument(array)[%s]",
+                 g_type_tag_to_string(element_type_tag));
+        break;
+      case GI_TYPE_TAG_UTF8:
+      case GI_TYPE_TAG_FILENAME:
+        array_argument->v_pointer = RVAL2STRV(rb_argument);
+        set_in_array_length_argument(length_argument, length_type_info,
+                                     RARRAY_LEN(rb_argument));
+        break;
+      case GI_TYPE_TAG_ARRAY:
+      case GI_TYPE_TAG_INTERFACE:
+      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:
+        rb_raise(rb_eNotImpError,
+                 "TODO: Ruby -> GIArgument(array)[%s]",
+                 g_type_tag_to_string(element_type_tag));
+        break;
+      default:
+        g_assert_not_reached();
+        break;
+    }
+}
+
+static void
+in_array_argument_from_ruby(GIArgument *array_argument,
+                            GIArgument *length_argument,
+                            GITypeInfo *array_type_info,
+                            GITypeInfo *length_type_info,
+                            VALUE rb_argument)
+{
+    GIArrayType array_type;
+    GITypeInfo *element_type_info;
+
+    array_type = g_type_info_get_array_type(array_type_info);
+    element_type_info = g_type_info_get_param_type(array_type_info, 0);
+    switch (array_type) {
+      case GI_ARRAY_TYPE_C:
+        in_array_c_argument_from_ruby(array_argument,
+                                      length_argument,
+                                      array_type_info,
+                                      length_type_info,
+                                      element_type_info,
+                                      rb_argument);
+        break;
+      case GI_ARRAY_TYPE_ARRAY:
+      case GI_ARRAY_TYPE_PTR_ARRAY:
+      case GI_ARRAY_TYPE_BYTE_ARRAY:
+        rb_raise(rb_eNotImpError,
+                 "TODO: Ruby -> GIArgument(array)[%s]",
+                 g_type_tag_to_string(g_type_info_get_tag(element_type_info)));
+        break;
+      default:
+        g_assert_not_reached();
+        break;
+    }
+    g_base_info_unref(element_type_info);
+}
+
+static void
+set_inout_array_length_argument(GIArgument *argument,
+                                GITypeInfo *type_info,
+                                GIArgument *length)
+{
+    GITypeTag type_tag;
+
+    if (!argument) {
+        return;
+    }
+
+    type_tag = g_type_info_get_tag(type_info);
+    switch (type_tag) {
+      case GI_TYPE_TAG_VOID:
+      case GI_TYPE_TAG_BOOLEAN:
+        rb_raise(rb_eNotImpError,
+                 "TODO: invalid argument?: length[%s]",
+                 g_type_tag_to_string(type_tag));
+        break;
+      case GI_TYPE_TAG_INT8:
+        argument->v_pointer = ALLOC(gint8);
+        *((gint8 *)argument->v_pointer) = length->v_int8;
+        break;
+      case GI_TYPE_TAG_UINT8:
+        argument->v_pointer = ALLOC(guint8);
+        *((guint8 *)argument->v_pointer) = length->v_uint8;
+        break;
+      case GI_TYPE_TAG_INT16:
+        argument->v_pointer = ALLOC(gint16);
+        *((gint16 *)argument->v_pointer) = length->v_int16;
+        break;
+      case GI_TYPE_TAG_UINT16:
+        argument->v_pointer = ALLOC(guint16);
+        *((guint16 *)argument->v_pointer) = length->v_uint16;
+        break;
+      case GI_TYPE_TAG_INT32:
+        argument->v_pointer = ALLOC(gint32);
+        *((gint32 *)argument->v_pointer) = length->v_int32;
+        break;
+      case GI_TYPE_TAG_UINT32:
+        argument->v_pointer = ALLOC(guint32);
+        *((guint32 *)argument->v_pointer) = length->v_uint32;
+        break;
+      case GI_TYPE_TAG_INT64:
+        argument->v_pointer = ALLOC(gint64);
+        *((gint64 *)argument->v_pointer) = length->v_int64;
+        break;
+      case GI_TYPE_TAG_UINT64:
+        argument->v_pointer = ALLOC(guint64);
+        *((guint64 *)argument->v_pointer) = length->v_uint64;
+        break;
+      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:
+      case GI_TYPE_TAG_INTERFACE:
+      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:
+        rb_raise(rb_eNotImpError,
+                 "TODO: invalid argument?: length[%s]",
+                 g_type_tag_to_string(type_tag));
+        break;
+      default:
+        g_assert_not_reached();
+        break;
+    }
+}
+
+static void
+inout_array_argument_from_ruby(GIArgument *array_argument,
+                               GIArgument *length_argument,
+                               GITypeInfo *array_type_info,
+                               GITypeInfo *length_type_info,
+                               VALUE rb_argument)
+{
+    GIArgument in_array_argument;
+    GIArgument in_length_argument;
+
+    in_array_argument_from_ruby(&in_array_argument,
+                                &in_length_argument,
+                                array_type_info,
+                                length_type_info,
+                                rb_argument);
+
+    array_argument->v_pointer = ALLOC(gpointer);
+    *((gpointer *)array_argument->v_pointer) = in_array_argument.v_pointer;
+    set_inout_array_length_argument(length_argument,
+                                    length_type_info,
+                                    &in_length_argument);
+}
+
+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)
+{
+    GITypeInfo array_type_info;
+    GITypeInfo length_type_info;
+    GITypeInfo *length_type_info_arg = NULL;
+
+    if (g_arg_info_may_be_null(array_arg_info) && NIL_P(rb_argument)) {
+        memset(array_argument, 0, sizeof(GIArgument));
+        if (length_argument) {
+            memset(length_argument, 0, sizeof(GIArgument));
+        }
+        return array_argument;
+    }
+
+    g_arg_info_load_type(array_arg_info, &array_type_info);
+    if (length_arg_info) {
+        g_arg_info_load_type(length_arg_info, &length_type_info);
+        length_type_info_arg = &length_type_info;
+    }
+    if (g_arg_info_get_direction(array_arg_info) == GI_DIRECTION_INOUT) {
+        inout_array_argument_from_ruby(array_argument,
+                                       length_argument,
+                                       &array_type_info,
+                                       length_type_info_arg,
+                                       rb_argument);
+    } else {
+        GITransfer transfer;
+
+        in_array_argument_from_ruby(array_argument,
+                                    length_argument,
+                                    &array_type_info,
+                                    length_type_info_arg,
+                                    rb_argument);
+        transfer = g_arg_info_get_ownership_transfer(array_arg_info);
+        rb_gi_in_argument_transfer(array_argument,
+                                   transfer,
+                                   &array_type_info,
+                                   rb_argument);
+    }
+
+    return array_argument;
+}
+
+static void
+rb_gi_value_argument_free_array_c(GIArgument *argument,
+                                  G_GNUC_UNUSED GITypeInfo *type_info,
+                                  GITypeInfo *element_type_info)
+{
+    GITypeTag element_type_tag;
+
+    element_type_tag = g_type_info_get_tag(element_type_info);
+    switch (element_type_tag) {
+      case GI_TYPE_TAG_VOID:
+      case GI_TYPE_TAG_BOOLEAN:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(array)[%s]",
+                 g_type_tag_to_string(element_type_tag));
+        break;
+      case GI_TYPE_TAG_INT8:
+      case GI_TYPE_TAG_UINT8:
+        /* Do nothing */
+        break;
+      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:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(array)[%s]",
+                 g_type_tag_to_string(element_type_tag));
+        break;
+      case GI_TYPE_TAG_UTF8:
+      case GI_TYPE_TAG_FILENAME:
+        g_free(argument->v_pointer);
+        break;
+      case GI_TYPE_TAG_ARRAY:
+      case GI_TYPE_TAG_INTERFACE:
+      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:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(array)[%s]",
+                 g_type_tag_to_string(element_type_tag));
+        break;
+      default:
+        g_assert_not_reached();
+        break;
+    }
+}
+
 static void
 rb_gi_value_argument_free_array(GIArgument *argument, GITypeInfo *type_info)
 {
     GIArrayType array_type;
+    GITypeInfo *element_type_info;
 
     array_type = g_type_info_get_array_type(type_info);
+    element_type_info = g_type_info_get_param_type(type_info, 0);
     switch (array_type) {
       case GI_ARRAY_TYPE_C:
-        g_free(argument->v_pointer);
+        rb_gi_value_argument_free_array_c(argument,
+                                          type_info,
+                                          element_type_info);
         break;
       case GI_ARRAY_TYPE_ARRAY:
       case GI_ARRAY_TYPE_PTR_ARRAY:
@@ -1238,6 +1733,7 @@ rb_gi_value_argument_free_array(GIArgument *argument, GITypeInfo *type_info)
         g_assert_not_reached();
         break;
     }
+    g_base_info_unref(element_type_info);
 }
 
 static void