gobject-introspection 3.0.9-x64-mingw32 → 3.1.0-x64-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d0bc2284cca56f4a2387ad477e3c2dad10ae1a82
-  data.tar.gz: 54fce020c48c4f56b5269f16568feb6c7e0ebbf5
+  metadata.gz: 3ee5d78c0de22a2e01e57020eec6c61dd66d9b95
+  data.tar.gz: 1440200d25f98954ac84f066c83dd3303532ea2d
 SHA512:
-  metadata.gz: 14af21663b2f053c1d01a38b3cfcd7aa8a5ed12cf03f4083c306710b7fe00d6335398c3f7e45ca863d669dd200df2cd95e2b5799b8e0cb59e56b12aa5116de37
-  data.tar.gz: 8000394c87c1fb0b4ec39be777113b1d52febffac102c10bb9acd297d43d9b1f77c9692dbfa89ae902e31903555d23095e0930e63d3a890e533728c193a8ca73
+  metadata.gz: a251544fd4f6839535dd4f7bc80b2d480d3bc7732f83c13f7934ee66798f1b0cc988338e2706812ec5f65bc5089185f253c22d2d4ad4f2dda52c3a5271fd9c52
+  data.tar.gz: a3b1cad486eb121c8802b2721b0b75f06c58c5dcb8938f79d7d267deadc975a42372932fc65c736c5c7e6521cd7ea92a9b6d04aeb81520de1ba226de6efb01bd

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);
 }