gobject-introspection 3.0.9-x86-mingw32 → 3.1.0-x86-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e37b79911af78c040f820f823f0b6cded8d579ee
-  data.tar.gz: a53111116d85df2f99690a09fb56205a8556f222
+  metadata.gz: 1b96626e3c783f55d3c54ddf0c6628668dac9f63
+  data.tar.gz: 52a6699e85fe26f3c6489eee01463f7d957137cd
 SHA512:
-  metadata.gz: 353f2ce2bc6c52586660e3c23b66b3d80a51f63649c77de839e34a36fc7e65adfd6fc36ebaecd1fb6f9128f826f597b983a42a8b8690499a462d667efbe17431
-  data.tar.gz: eb5ea5563cb648e2047e4d5058dd5e67dc3a3fbcf6fa78477d501f10b2b3f5b81df5fa5bba8fda3383339f87f695173b8fdba286d399b9e1ad3fa6fe08ad5d66
+  metadata.gz: ea678e22b9b1c47f30aafabfef79f4a3b2c29aa6e0647ba56b51322d035b0bf33b7ee95ffba866a3f693f240075d5d4c7d50c76cbbb8454348c21f2043327024
+  data.tar.gz: fa6288864efdbfe43e70f0d83bc8407f4623d90ac9e03caba88d9b0de95177f3a07df3b9afecd8a26e9b700bed28b4180b9d2af9ed2829edf9f416394ed1bace

data/Rakefile

@@ -32,7 +32,7 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
       :name => "glib",
       :download_site => :gnome,
       :label => "GLib",
-      :version => "2.48.1",
+      :version => "2.50.2",
       :compression_method => "xz",
       :windows => {
         :build => false,
@@ -47,7 +47,7 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
       :name => "gobject-introspection",
       :download_site => :gnome,
       :label => "gobject-introspection",
-      :version => "1.48.0",
+      :version => "1.50.0",
       :compression_method => "xz",
       :windows => {
         :configure_args => [

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

@@ -537,27 +537,6 @@ rb_gi_array_argument_to_ruby(GIArgument *array_argument,
     return rb_array;
 }
 
-static VALUE
-interface_variant_to_ruby(GVariant *variant)
-{
-    VALUE rb_value = Qnil;
-    const GVariantType *type;
-
-    type = g_variant_get_type(variant);
-    if (g_variant_type_equal(type, G_VARIANT_TYPE_STRING)) {
-        const char *value;
-        g_variant_get(variant, "s", &value);
-        rb_value = CSTR2RVAL(value);
-    } else {
-        rb_raise(rb_eNotImpError,
-                 "TODO: GIArgument(interface)[GVariant][%.*s] -> Ruby",
-                 (int)g_variant_type_get_string_length(type),
-                 g_variant_type_peek_string(type));
-    }
-
-    return rb_value;
-}
-
 static VALUE
 rb_gi_argument_to_ruby_interface(GIArgument *argument,
                                  gboolean duplicate,
@@ -599,7 +578,7 @@ rb_gi_argument_to_ruby_interface(GIArgument *argument,
             rb_interface = rb_enc_str_new(data, size, rb_ascii8bit_encoding());
         } else if (gtype == G_TYPE_VARIANT) {
             GVariant *variant = argument->v_pointer;
-            rb_interface = interface_variant_to_ruby(variant);
+            rb_interface = rbg_variant_to_ruby(variant);
         } else {
             rb_interface = BOXED2RVAL(argument->v_pointer, gtype);
         }
@@ -1214,6 +1193,58 @@ rb_gi_argument_to_ruby(GIArgument *argument,
     return rb_argument;
 }
 
+static void
+rb_gi_out_argument_init_array_c(GIArgument *argument,
+                                G_GNUC_UNUSED GIArgInfo *arg_info,
+                                G_GNUC_UNUSED GITypeInfo *array_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:
+      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:
+        g_base_info_unref(element_type_info);
+        rb_raise(rb_eNotImpError,
+                 "TODO: allocates GIArgument(array)[c][%s] for output",
+                 g_type_tag_to_string(element_type_tag));
+        break;
+      case GI_TYPE_TAG_UTF8:
+        argument->v_pointer = xmalloc(sizeof(gchar **));
+        break;
+      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:
+        g_base_info_unref(element_type_info);
+        rb_raise(rb_eNotImpError,
+                 "TODO: allocates GIArgument(array)[c][%s] for output",
+                 g_type_tag_to_string(element_type_tag));
+        break;
+      default:
+        g_base_info_unref(element_type_info);
+        g_assert_not_reached();
+        break;
+    }
+}
+
 static void
 rb_gi_out_argument_init_array_array_interface(GIArgument *argument,
                                               G_GNUC_UNUSED GIArgInfo *arg_info,
@@ -1348,16 +1379,18 @@ rb_gi_out_argument_init_array(GIArgument *argument, GIArgInfo *arg_info,
 {
     GIArrayType array_type;
     GITypeInfo *element_type_info;
+    GITypeTag element_type_tag;
 
     array_type = g_type_info_get_array_type(array_type_info);
     element_type_info = g_type_info_get_param_type(array_type_info, 0);
+    element_type_tag = g_type_info_get_tag(element_type_info);
 
     switch (array_type) {
     case GI_ARRAY_TYPE_C:
-        g_base_info_unref(element_type_info);
-        rb_raise(rb_eNotImpError,
-                 "TODO: allocates GIArgument(array)[c][%s] for output",
-                 g_type_tag_to_string(g_type_info_get_tag(element_type_info)));
+        rb_gi_out_argument_init_array_c(argument,
+                                        arg_info,
+                                        array_type_info,
+                                        element_type_info);
         break;
     case GI_ARRAY_TYPE_ARRAY:
         rb_gi_out_argument_init_array_array(argument,
@@ -1369,13 +1402,13 @@ rb_gi_out_argument_init_array(GIArgument *argument, GIArgInfo *arg_info,
         g_base_info_unref(element_type_info);
         rb_raise(rb_eNotImpError,
                  "TODO: allocates GIArgument(array)[ptr-array][%s] for output",
-                 g_type_tag_to_string(g_type_info_get_tag(element_type_info)));
+                 g_type_tag_to_string(element_type_tag));
         break;
     case GI_ARRAY_TYPE_BYTE_ARRAY:
         g_base_info_unref(element_type_info);
         rb_raise(rb_eNotImpError,
                  "TODO: allocates GIArgument(array)[byte-array][%s] for output",
-                 g_type_tag_to_string(g_type_info_get_tag(element_type_info)));
+                 g_type_tag_to_string(element_type_tag));
         break;
     default:
         g_base_info_unref(element_type_info);
@@ -1709,35 +1742,101 @@ rb_gi_out_argument_to_ruby(GIArgument *argument,
                                   args_metadata);
 }
 
+
+static void
+rb_gi_out_argument_fin_array_c(GIArgument *argument,
+                               G_GNUC_UNUSED GIArgInfo *arg_info,
+                               G_GNUC_UNUSED GITypeInfo *array_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:
+      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:
+        g_base_info_unref(element_type_info);
+        rb_raise(rb_eNotImpError,
+                 "TODO: free out GIArgument(array)[c][%s]",
+                 g_type_tag_to_string(element_type_tag));
+        break;
+      case GI_TYPE_TAG_UTF8:
+        xfree(argument->v_pointer);
+        break;
+      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:
+        g_base_info_unref(element_type_info);
+        rb_raise(rb_eNotImpError,
+                 "TODO: free out GIArgument(array)[c][%s]",
+                 g_type_tag_to_string(element_type_tag));
+        break;
+      default:
+        g_base_info_unref(element_type_info);
+        g_assert_not_reached();
+        break;
+    }
+}
+
 static void
 rb_gi_out_argument_fin_array(GIArgument *argument,
-                             G_GNUC_UNUSED GIArgInfo *arg_info,
+                             GIArgInfo *arg_info,
                              GITypeInfo *array_type_info)
 {
     GIArrayType array_type;
+    GITypeInfo *element_type_info;
+    GITypeTag element_type_tag;
 
     array_type = g_type_info_get_array_type(array_type_info);
+    element_type_info = g_type_info_get_param_type(array_type_info, 0);
+    element_type_tag = g_type_info_get_tag(element_type_info);
 
     switch (array_type) {
     case GI_ARRAY_TYPE_C:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free out GIArgument(array)[c]");
+        rb_gi_out_argument_fin_array_c(argument,
+                                       arg_info,
+                                       array_type_info,
+                                       element_type_info);
         break;
     case GI_ARRAY_TYPE_ARRAY:
         g_array_free(argument->v_pointer, TRUE);
         break;
     case GI_ARRAY_TYPE_PTR_ARRAY:
+        g_base_info_unref(element_type_info);
         rb_raise(rb_eNotImpError,
-                 "TODO: free out GIArgument(array)[ptr-array]");
+                 "TODO: free out GIArgument(array)[ptr-array][%s]",
+                 g_type_tag_to_string(element_type_tag));
         break;
     case GI_ARRAY_TYPE_BYTE_ARRAY:
+        g_base_info_unref(element_type_info);
         rb_raise(rb_eNotImpError,
-                 "TODO: free out GIArgument(array)[byte-array]");
+                 "TODO: free out GIArgument(array)[byte-array][%s]",
+                 g_type_tag_to_string(element_type_tag));
         break;
     default:
+        g_base_info_unref(element_type_info);
         g_assert_not_reached();
         break;
     }
+
+    g_base_info_unref(element_type_info);
 }
 
 void
@@ -2265,6 +2364,7 @@ rb_gi_return_argument_free_everything(GIArgument *argument,
     type_tag = g_type_info_get_tag(type_info);
     switch (type_tag) {
     case GI_TYPE_TAG_VOID:
+        break;
     case GI_TYPE_TAG_BOOLEAN:
     case GI_TYPE_TAG_INT8:
     case GI_TYPE_TAG_UINT8:
@@ -2633,16 +2733,16 @@ rb_gi_value_argument_from_ruby(GIArgument *argument, GITypeInfo *type_info,
         argument->v_boolean = RVAL2CBOOL(rb_argument);
         break;
     case GI_TYPE_TAG_INT8:
-        argument->v_int8 = NUM2INT(rb_argument);
+        argument->v_int8 = NUM2CHR(rb_argument);
         break;
     case GI_TYPE_TAG_UINT8:
-        argument->v_uint8 = NUM2UINT(rb_argument);
+        argument->v_uint8 = (guint8)NUM2CHR(rb_argument);
         break;
     case GI_TYPE_TAG_INT16:
-        argument->v_int16 = NUM2INT(rb_argument);
+        argument->v_int16 = NUM2SHORT(rb_argument);
         break;
     case GI_TYPE_TAG_UINT16:
-        argument->v_uint16 = NUM2UINT(rb_argument);
+        argument->v_uint16 = NUM2USHORT(rb_argument);
         break;
     case GI_TYPE_TAG_INT32:
         argument->v_int32 = NUM2INT(rb_argument);
@@ -3005,6 +3105,38 @@ set_in_array_length_argument(GIArgument *argument,
     }
 }
 
+static void
+set_in_array_int8_arguments_from_ruby(GIArgument *array_argument,
+                                      VALUE rb_number_array)
+{
+    gint8 *numbers;
+    gint i, n_args;
+
+    n_args = RARRAY_LEN(rb_number_array);
+    numbers = ALLOC_N(gint8, n_args);
+    for (i = 0; i < n_args; i++) {
+        numbers[i] = NUM2CHR(RARRAY_PTR(rb_number_array)[i]);
+    }
+
+    array_argument->v_pointer = numbers;
+}
+
+static void
+set_in_array_uint8_arguments_from_ruby(GIArgument *array_argument,
+                                       VALUE rb_number_array)
+{
+    guint8 *numbers;
+    gint i, n_args;
+
+    n_args = RARRAY_LEN(rb_number_array);
+    numbers = ALLOC_N(guint8, n_args);
+    for (i = 0; i < n_args; i++) {
+        numbers[i] = (guint8)NUM2CHR(RARRAY_PTR(rb_number_array)[i]);
+    }
+
+    array_argument->v_pointer = numbers;
+}
+
 static void
 set_in_array_int16_arguments_from_ruby(GIArgument *array_argument,
                                        VALUE rb_number_array)
@@ -3015,7 +3147,7 @@ set_in_array_int16_arguments_from_ruby(GIArgument *array_argument,
     n_args = RARRAY_LEN(rb_number_array);
     numbers = ALLOC_N(gint16, n_args);
     for (i = 0; i < n_args; i++) {
-        numbers[i] = NUM2INT(RARRAY_PTR(rb_number_array)[i]);
+        numbers[i] = NUM2SHORT(RARRAY_PTR(rb_number_array)[i]);
     }
 
     array_argument->v_pointer = numbers;
@@ -3031,7 +3163,7 @@ set_in_array_uint16_arguments_from_ruby(GIArgument *array_argument,
     n_args = RARRAY_LEN(rb_number_array);
     numbers = ALLOC_N(guint16, n_args);
     for (i = 0; i < n_args; i++) {
-        numbers[i] = NUM2UINT(RARRAY_PTR(rb_number_array)[i]);
+        numbers[i] = NUM2USHORT(RARRAY_PTR(rb_number_array)[i]);
     }
 
     array_argument->v_pointer = numbers;
@@ -3296,10 +3428,28 @@ in_array_c_argument_from_ruby(GIArgument *array_argument,
                  g_type_tag_to_string(element_type_tag));
         break;
     case GI_TYPE_TAG_INT8:
+        if (RB_TYPE_P(rb_argument, RUBY_T_STRING)) {
+            array_argument->v_pointer = RSTRING_PTR(rb_argument);
+            set_in_array_length_argument(length_argument, length_type_info,
+                                         RSTRING_LEN(rb_argument));
+        } else {
+            rb_argument = rbg_to_array(rb_argument);
+            set_in_array_int8_arguments_from_ruby(array_argument, rb_argument);
+            set_in_array_length_argument(length_argument, length_type_info,
+                                         RARRAY_LEN(rb_argument));
+        }
+        break;
     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));
+        if (RB_TYPE_P(rb_argument, RUBY_T_STRING)) {
+            array_argument->v_pointer = RSTRING_PTR(rb_argument);
+            set_in_array_length_argument(length_argument, length_type_info,
+                                         RSTRING_LEN(rb_argument));
+        } else {
+            rb_argument = rbg_to_array(rb_argument);
+            set_in_array_uint8_arguments_from_ruby(array_argument, rb_argument);
+            set_in_array_length_argument(length_argument, length_type_info,
+                                         RARRAY_LEN(rb_argument));
+        }
         break;
     case GI_TYPE_TAG_INT16:
         rb_argument = rbg_to_array(rb_argument);
@@ -3571,7 +3721,8 @@ rb_gi_in_array_argument_from_ruby(GIArgument *array_argument,
 }
 
 static void
-rb_gi_value_argument_free_array_c(GIArgument *argument,
+rb_gi_value_argument_free_array_c(VALUE rb_argument,
+                                  GIArgument *argument,
                                   G_GNUC_UNUSED GITypeInfo *type_info,
                                   GITypeInfo *element_type_info)
 {
@@ -3587,7 +3738,11 @@ rb_gi_value_argument_free_array_c(GIArgument *argument,
         break;
     case GI_TYPE_TAG_INT8:
     case GI_TYPE_TAG_UINT8:
-        /* Do nothing */
+        if (RB_TYPE_P(rb_argument, RUBY_T_STRING)) {
+            /* Do nothing */
+        } else {
+            xfree(argument->v_pointer);
+        }
         break;
     case GI_TYPE_TAG_INT16:
     case GI_TYPE_TAG_UINT16:
@@ -3627,7 +3782,9 @@ rb_gi_value_argument_free_array_c(GIArgument *argument,
 }
 
 static void
-rb_gi_value_argument_free_array(GIArgument *argument, GITypeInfo *type_info)
+rb_gi_value_argument_free_array(VALUE rb_argument,
+                                GIArgument *argument,
+                                GITypeInfo *type_info)
 {
     GIArrayType array_type;
     GITypeInfo *element_type_info;
@@ -3636,7 +3793,8 @@ rb_gi_value_argument_free_array(GIArgument *argument, GITypeInfo *type_info)
     element_type_info = g_type_info_get_param_type(type_info, 0);
     switch (array_type) {
     case GI_ARRAY_TYPE_C:
-        rb_gi_value_argument_free_array_c(argument,
+        rb_gi_value_argument_free_array_c(rb_argument,
+                                          argument,
                                           type_info,
                                           element_type_info);
         break;
@@ -3706,7 +3864,7 @@ rb_gi_value_argument_free(VALUE rb_argument,
     case GI_TYPE_TAG_FILENAME:
         break;
     case GI_TYPE_TAG_ARRAY:
-        rb_gi_value_argument_free_array(argument, type_info);
+        rb_gi_value_argument_free_array(rb_argument, argument, type_info);
         break;
     case GI_TYPE_TAG_INTERFACE:
         rb_gi_value_argument_free_interface(rb_argument, argument, type_info);

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

@@ -86,37 +86,31 @@ initialize_receiver(VALUE receiver, GITypeInfo *info, GIArgument *value)
 }
 
 static VALUE
-rg_invoke(VALUE self, VALUE rb_options)
+rg_invoke(VALUE self, VALUE rb_receiver, VALUE rb_arguments)
 {
     GIFunctionInfo *info;
     GICallableInfo *callable_info;
-    VALUE receiver;
     GIArgument return_value;
     GITypeInfo return_value_info;
 
     info = SELF(self);
     callable_info = (GICallableInfo *)info;
 
-    rb_options = rbg_to_hash(rb_options);
-    receiver = rb_hash_delete(rb_options, ID2SYM(rb_intern("receiver")));
-    if (NIL_P(receiver)) {
-        receiver = rb_hash_delete(rb_options, rb_str_new_cstr("receiver"));
-    }
-    if (NIL_P(receiver)) {
-        rb_raise(rb_eArgError,
-                 "receiver is missing: %s",
-                 RBG_INSPECT(rb_options));
+    if (NIL_P(rb_receiver)) {
+        rb_raise(rb_eArgError, "receiver is missing");
     }
     /* TODO: use rb_protect */
     rb_gi_function_info_invoke_raw(info,
-                                   rb_options,
+                                   self,
+                                   Qnil,
+                                   rb_arguments,
                                    &return_value,
                                    NULL);
 
     g_callable_info_load_return_type(callable_info, &return_value_info);
-    initialize_receiver(receiver, &return_value_info, &return_value);
+    initialize_receiver(rb_receiver, &return_value_info, &return_value);
 
-    return receiver;
+    return rb_receiver;
 }
 
 void
@@ -129,5 +123,5 @@ rb_gi_constructor_info_init(VALUE rb_mGI, VALUE rb_cGIFunctionInfo)
                                 "ConstructorInfo", rb_mGI,
 				rb_cGIFunctionInfo);
 
-    RG_DEF_METHOD(invoke, 1);
+    RG_DEF_METHOD(invoke, 2);
 }