gobject-introspection 2.0.2-x86-mingw32 → 2.0.3-x86-mingw32

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1331db1c67d720914be047015425c03c3414dbaa
+  data.tar.gz: a094b6e63bf888a009652a89ec497b97dc187269
+SHA512:
+  metadata.gz: 3f76e7a58d161f612a467016165d4f55b8494df045d86945fae857f610ab3b6cca3efc8421d83852b8c1bd9606dae8198b8392d5847ee66667417e52f0a28d0e
+  data.tar.gz: 182bf6532518ce1882d720cc3ebbdff96c2dbba1ccc1b30fe09e0cdaef8ea1ac1b2109d4252950d0b105fbe6ca56a5c5497f1345c203411515d0642398b68d9b

data/Rakefile

@@ -32,7 +32,7 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
       :name => "glib",
       :download_site => :gnome,
       :label => "GLib",
-      :version => "2.36.2",
+      :version => "2.38.2",
       :compression_method => "xz",
       :windows => {
         :build => false,
@@ -40,13 +40,14 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
       :native => {
         :build => true,
         :need_autoreconf => true,
+        :built_file => "lib/libglib-2.0.so",
       },
     },
     {
       :name => "gobject-introspection",
       :download_site => :gnome,
       :label => "gobject-introspection",
-      :version => "1.36.0",
+      :version => "1.38.0",
       :compression_method => "xz",
       :windows => {
         :configure_args => [
@@ -57,12 +58,14 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
           "0001-Support-external-g-ir-scanner.patch",
         ],
         :need_autoreconf => true,
+        :built_file => "bin/libgirepository-1.0-1.dll",
       },
       :native => {
         :build => true,
         :patches => [
           # "cross-compilable-g-ir-scanner.diff",
         ],
+        :built_file => "bin/g-ir-scanner",
       }
     },
   ]

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

@@ -29,6 +29,10 @@ array_c_to_ruby(const gchar **elements, GITypeInfo *type_info, VALUE rb_array)
     gboolean fixed_size_p;
     gboolean zero_terminated_p;
 
+    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);
@@ -257,9 +261,13 @@ rb_gi_argument_to_ruby(GIArgument *argument, GITypeInfo *type_info)
         rb_argument = interface_to_ruby(argument, type_info);
         break;
       case GI_TYPE_TAG_GLIST:
+        rb_argument = GOBJGLIST2RVAL(argument->v_pointer);
+        break;
       case GI_TYPE_TAG_GSLIST:
       case GI_TYPE_TAG_GHASH:
-        rb_raise(rb_eNotImpError, "TODO: GIArgument(unichar) -> Ruby");
+        rb_raise(rb_eNotImpError,
+                 "TODO: GIArgument(%s) -> Ruby",
+                 g_type_tag_to_string(type_tag));
         break;
       case GI_TYPE_TAG_ERROR:
         rb_argument = GERROR2RVAL(argument->v_pointer);
@@ -505,10 +513,201 @@ rb_gi_out_argument_fin(GIArgument *argument, GIArgInfo *arg_info)
     xfree(argument->v_pointer);
 }
 
+static void
+rb_gi_return_argument_free_container(GIArgument *argument,
+                                     GITypeInfo *type_info)
+{
+    GITypeTag type_tag;
+
+    type_tag = g_type_info_get_tag(type_info);
+
+    rb_raise(rb_eNotImpError,
+             "TODO: free GIArgument(%s) as container",
+             g_type_tag_to_string(type_tag));
+}
+
+static void
+rb_gi_return_argument_free_everything_array(GIArgument *argument,
+                                            GITypeInfo *type_info)
+{
+    switch (g_type_info_get_array_type(type_info)) {
+      case GI_ARRAY_TYPE_C:
+        g_strfreev(argument->v_pointer);
+        break;
+      case GI_ARRAY_TYPE_ARRAY:
+        g_array_free(argument->v_pointer, TRUE);
+        break;
+      case GI_ARRAY_TYPE_PTR_ARRAY:
+        g_ptr_array_free(argument->v_pointer, TRUE);
+        break;
+      case GI_ARRAY_TYPE_BYTE_ARRAY:
+        g_ptr_array_free(argument->v_pointer, TRUE);
+        break;
+      default:
+        g_assert_not_reached();
+        break;
+    }
+}
+
+static void
+rb_gi_return_argument_free_everything_interface(GIArgument *argument,
+                                                GITypeInfo *type_info)
+{
+    GIBaseInfo *interface_info;
+    GIInfoType interface_type;
+
+    interface_info = g_type_info_get_interface(type_info);
+    interface_type = g_base_info_get_type(interface_info);
+    g_base_info_unref(interface_info);
+
+    switch (interface_type) {
+      case GI_INFO_TYPE_INVALID:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[invalid] everything");
+        break;
+      case GI_INFO_TYPE_FUNCTION:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[function] everything");
+        break;
+      case GI_INFO_TYPE_CALLBACK:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[callback] everything");
+        break;
+      case GI_INFO_TYPE_STRUCT:
+        rbgobj_instance_unref(argument->v_pointer);
+        break;
+      case GI_INFO_TYPE_BOXED:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[boxed] everything");
+        break;
+      case GI_INFO_TYPE_ENUM:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[enum] everything");
+        break;
+      case GI_INFO_TYPE_FLAGS:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[flags] everything");
+        break;
+      case GI_INFO_TYPE_OBJECT:
+        if (argument->v_pointer) {
+            g_object_unref(argument->v_pointer);
+        }
+        break;
+      case GI_INFO_TYPE_INTERFACE:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[interface] everything");
+        break;
+      case GI_INFO_TYPE_CONSTANT:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[constant] everything");
+        break;
+      case GI_INFO_TYPE_INVALID_0:
+        g_assert_not_reached();
+        break;
+      case GI_INFO_TYPE_UNION:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[union] everything");
+        break;
+      case GI_INFO_TYPE_VALUE:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[value] everything");
+        break;
+      case GI_INFO_TYPE_SIGNAL:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[signal] everything");
+        break;
+      case GI_INFO_TYPE_VFUNC:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[vfunc] everything");
+        break;
+      case GI_INFO_TYPE_PROPERTY:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[property] everything");
+        break;
+      case GI_INFO_TYPE_FIELD:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[field] everything");
+        break;
+      case GI_INFO_TYPE_ARG:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[arg] everything");
+        break;
+      case GI_INFO_TYPE_TYPE:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[type] everything");
+        break;
+      case GI_INFO_TYPE_UNRESOLVED:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[unresolved] everything");
+        break;
+      default:
+        g_assert_not_reached();
+        break;
+    }
+}
+
+static void
+rb_gi_return_argument_free_everything(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:
+      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:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(%s) everything",
+                 g_type_tag_to_string(type_tag));
+        break;
+      case GI_TYPE_TAG_UTF8:
+        g_free(argument->v_string);
+        break;
+      case GI_TYPE_TAG_FILENAME:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(%s) everything",
+                 g_type_tag_to_string(type_tag));
+        break;
+      case GI_TYPE_TAG_ARRAY:
+        rb_gi_return_argument_free_everything_array(argument, type_info);
+        break;
+      case GI_TYPE_TAG_INTERFACE:
+        rb_gi_return_argument_free_everything_interface(argument, type_info);
+        break;
+      case GI_TYPE_TAG_GLIST:
+        g_list_foreach(argument->v_pointer, (GFunc)g_object_unref, NULL);
+        g_list_free(argument->v_pointer);
+        break;
+      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(%s) everything",
+                 g_type_tag_to_string(type_tag));
+        break;
+      default:
+        g_assert_not_reached();
+        break;
+    }
+}
+
 VALUE
 rb_gi_return_argument_to_ruby(GIArgument *argument,
                               GICallableInfo *callable_info)
 {
+    VALUE rb_argument;
     gboolean may_return_null;
     GITypeInfo return_value_info;
 
@@ -518,7 +717,21 @@ rb_gi_return_argument_to_ruby(GIArgument *argument,
     }
 
     g_callable_info_load_return_type(callable_info, &return_value_info);
-    return rb_gi_argument_to_ruby(argument, &return_value_info);
+    rb_argument = rb_gi_argument_to_ruby(argument, &return_value_info);
+    switch (g_callable_info_get_caller_owns(callable_info)) {
+      case GI_TRANSFER_NOTHING:
+        break;
+      case GI_TRANSFER_CONTAINER:
+        rb_gi_return_argument_free_container(argument, &return_value_info);
+        break;
+      case GI_TRANSFER_EVERYTHING:
+        rb_gi_return_argument_free_everything(argument, &return_value_info);
+        break;
+      default:
+        g_assert_not_reached();
+        break;
+    }
+    return rb_argument;
 }
 
 static void
@@ -538,8 +751,6 @@ rb_gi_argument_from_ruby_array_c(GIArgument *argument,
                  g_type_tag_to_string(element_type_tag));
         break;
       case GI_TYPE_TAG_INT8:
-        argument->v_pointer = StringValueCStr(rb_argument);
-        break;
       case GI_TYPE_TAG_UINT8:
         argument->v_pointer = RSTRING_PTR(rb_argument);
         break;

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

@@ -55,9 +55,14 @@ static VALUE
 struct_alloc(VALUE klass)
 {
     VALUE rb_size;
+    size_t size;
+    gpointer instance;
 
     rb_size = rb_iv_get(klass, "@size");
-    return Data_Wrap_Struct(klass, NULL, xfree, xmalloc(NUM2ULONG(rb_size)));
+    size = NUM2ULONG(rb_size);
+    instance = xmalloc(size);
+    memset(instance, 0, size);
+    return Data_Wrap_Struct(klass, NULL, xfree, instance);
 }
 
 static VALUE
@@ -121,7 +126,7 @@ rg_s_register_boxed_class_converter(VALUE klass, VALUE rb_gtype)
 
     memset(&table, 0, sizeof(RGConvertTable));
     CONST_ID(id_to_i, "to_i");
-    table.type = NUM2UINT(rb_funcall(rb_gtype, id_to_i, 0));
+    table.type = NUM2ULONG(rb_funcall(rb_gtype, id_to_i, 0));
     table.klass = Qnil;
     table.instance2robj = boxed_instance2robj;
 

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

@@ -71,7 +71,7 @@ rg_get_field_value(VALUE self, VALUE rb_struct, VALUE rb_n)
         VALUE rb_gtype;
         GType gtype;
         rb_gtype = rb_funcall(rb_struct, rb_intern("gtype"), 0);
-        gtype = NUM2UINT(rb_funcall(rb_gtype, rb_intern("to_i"), 0));
+        gtype = NUM2ULONG(rb_funcall(rb_gtype, rb_intern("to_i"), 0));
         instance = RVAL2BOXED(rb_struct, gtype);
     } else {
         Data_Get_Struct(rb_struct, void, instance);

data/test/test-function-info.rb

@@ -31,7 +31,9 @@ class TestFunctionInfo < Test::Unit::TestCase
   end
 
   def test_invoke
-    assert_equal("notify", @info.invoke(1))
+    # TODO: "#invoke" expects Array. We should confirm specification.
+    #assert_equal("notify", @info.invoke(1))
+    assert_equal("notify", @info.invoke([1]))
   end
 end
 

data/vendor/local/lib/gobject-introspection/giscanner/annotationmain.py

@@ -26,6 +26,7 @@ from giscanner.scannermain import (get_preprocessor_option_group,
                                    create_source_scanner,
                                    process_packages)
 
+
 def annotation_main(args):
     parser = optparse.OptionParser('%prog [options] sources')