gobject-introspection 3.2.5-x64-mingw32 → 3.2.6-x64-mingw32

data/README.md

@@ -0,0 +1,24 @@
+# Ruby/GObjectIntrospection
+
+Ruby/GObjectIntrospection is a Ruby binding of GObject Introspect.
+
+## Requirements
+
+* Ruby/GLib2 in
+  [Ruby-GNOME2](https://ruby-gnome2.osdn.jp/)
+* [GObject Introspection](http://live.gnome.org/GObjectIntrospection)
+
+## Install
+
+    gem install gobject-introspection
+
+## License
+
+Copyright (c) 2013 Ruby-GNOME2 Project Team
+
+This program is free software. You can distribute/modify this program
+under the terms of the GNU LESSER GENERAL PUBLIC LICENSE Version 2.1.
+
+## Project Website
+
+https://ruby-gnome2.osdn.jp/

data/Rakefile

@@ -1,6 +1,6 @@
 # -*- ruby -*-
 #
-# Copyright (C) 2012-2015  Ruby-GNOME2 Project Team
+# Copyright (C) 2012-2018  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
@@ -19,7 +19,10 @@
 $LOAD_PATH.unshift("./../glib2/lib")
 require "gnome2/rake/package-task"
 
-package_task = GNOME2::Rake::PackageTask.new do |package|
+package_name = File.basename(__dir__)
+spec = Gem::Specification.load("#{package_name}.gemspec")
+
+package_task = GNOME2::Rake::PackageTask.new(spec, __dir__) do |package|
   package.summary = "Ruby/GObjectIntrospection is a Ruby binding of GObjectIntrospection."
   package.description = "Ruby/GObjectIntrospection is a Ruby binding of GObjectIntrospection."
   package.dependency.gem.runtime = ["glib2"]
@@ -32,7 +35,7 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
       :name => "glib",
       :download_site => :gnome,
       :label => "GLib",
-      :version => "2.56.0",
+      :version => "2.56.1",
       :compression_method => "xz",
       :windows => {
         :build => false,
@@ -47,7 +50,7 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
       :name => "gobject-introspection",
       :download_site => :gnome,
       :label => "gobject-introspection",
-      :version => "1.56.0",
+      :version => "1.56.1",
       :compression_method => "xz",
       :windows => {
         :configure_args => [

data/ext/gobject-introspection/gobject_introspection.def

@@ -1,5 +1,10 @@
 EXPORTS
 	Init_gobject_introspection
 
-	rb_gi_callback_data_free
 	rb_gi_callback_register_finder
+	rb_gi_callback_data_free
+	rb_gi_callback_data_get_metadata
+	rb_gi_callback_data_get_rb_callback
+
+	rb_gi_struct_new_raw
+	rb_gi_struct_get_raw

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

@@ -22,6 +22,7 @@
 
 static VALUE rb_cGLibValue = Qnil;
 static VALUE rb_cGLibBytes = Qnil;
+static VALUE rb_cGLibBoxed = Qnil;
 
 static gboolean
 rb_gi_arg_info_may_be_null(GIArgInfo *arg_info)
@@ -2883,7 +2884,7 @@ rb_gi_value_argument_from_ruby_interface(GIArgument *argument,
     case GI_INFO_TYPE_STRUCT:
         gtype = g_registered_type_info_get_g_type(interface_info);
         if (gtype == G_TYPE_NONE) {
-            argument->v_pointer = DATA_PTR(rb_argument);
+            argument->v_pointer = rb_gi_struct_get_raw(rb_argument, gtype);
         } else if (gtype == G_TYPE_VALUE) {
             GValue *gvalue;
             if (RVAL2CBOOL(rb_obj_is_kind_of(rb_argument, rb_cGLibValue))) {
@@ -4470,4 +4471,5 @@ rb_gi_argument_init(void)
 {
     rb_cGLibValue = rb_const_get(mGLib, rb_intern("Value"));
     rb_cGLibBytes = rb_const_get(mGLib, rb_intern("Bytes"));
+    rb_cGLibBoxed = rb_const_get(mGLib, rb_intern("Boxed"));
 }

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

@@ -28,7 +28,7 @@ gi_constructor_info_get_type(void)
 {
     static GType type = 0;
     if (type == 0) {
-	type = g_boxed_type_register_static("GIConstructorInfo",
+        type = g_boxed_type_register_static("GIConstructorInfo",
                                             (GBoxedCopyFunc)g_base_info_ref,
                                             (GBoxedFreeFunc)g_base_info_unref);
     }
@@ -141,9 +141,9 @@ rb_gi_constructor_info_init(VALUE rb_mGI, VALUE rb_cGIFunctionInfo)
     VALUE RG_TARGET_NAMESPACE;
 
     RG_TARGET_NAMESPACE =
-	G_DEF_CLASS_WITH_PARENT(GI_TYPE_CONSTRUCTOR_INFO,
+        G_DEF_CLASS_WITH_PARENT(GI_TYPE_CONSTRUCTOR_INFO,
                                 "ConstructorInfo", rb_mGI,
-				rb_cGIFunctionInfo);
+                                rb_cGIFunctionInfo);
 
     RG_DEF_METHOD(invoke, 2);
 }

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

@@ -79,24 +79,36 @@ rb_gi_field_info_get_field_raw_interface(GIFieldInfo *info,
     VALUE rb_field_value = Qnil;
     GIBaseInfo *interface_info;
     GIInfoType interface_type;
+    GType gtype;
+    gint offset;
 
     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);
+    offset = g_field_info_get_offset(info);
     switch (interface_type) {
       case GI_INFO_TYPE_INVALID:
       case GI_INFO_TYPE_FUNCTION:
       case GI_INFO_TYPE_CALLBACK:
+        rb_raise(rb_eNotImpError,
+                 "TODO: GIField(interface)[%s](%s)",
+                 g_info_type_to_string(interface_type),
+                 g_type_name(gtype));
         break;
       case GI_INFO_TYPE_STRUCT:
         {
             GIStructInfo *struct_info = (GIStructInfo *)interface_info;
-            gint offset;
+            gboolean is_pointer;
+            gpointer target;
 
-            offset = g_field_info_get_offset(info);
-            rb_field_value = rb_gi_struct_info_to_ruby(
-                struct_info,
-                (gchar *)memory + offset,
-                g_type_info_is_pointer(type_info));
+            is_pointer = g_type_info_is_pointer(type_info);
+            target = (gpointer)((guint8 *)memory + offset);
+            if (is_pointer) {
+                target = *((gpointer *)target);
+            }
+            rb_field_value = rb_gi_struct_info_to_ruby(struct_info,
+                                                       target,
+                                                       is_pointer);
             break;
         }
       case GI_INFO_TYPE_BOXED:
@@ -104,16 +116,36 @@ rb_gi_field_info_get_field_raw_interface(GIFieldInfo *info,
       case GI_INFO_TYPE_OBJECT:
         {
             GIArgument argument;
-            gint offset;
 
-            offset = g_field_info_get_offset(info);
             argument.v_pointer = G_STRUCT_MEMBER(gpointer, memory, offset);
             rb_field_value = GI_ARGUMENT2RVAL(&argument, FALSE, type_info,
                                               NULL, NULL, NULL);
         }
         break;
       case GI_INFO_TYPE_ENUM:
+        {
+            gint32 raw_value;
+
+            raw_value = G_STRUCT_MEMBER(gint32, memory, offset);
+            if (gtype == G_TYPE_NONE) {
+                rb_field_value = INT2NUM(raw_value);
+            } else {
+                rb_field_value = GENUM2RVAL(raw_value, gtype);
+            }
+        }
+        break;
       case GI_INFO_TYPE_FLAGS:
+        {
+            gint32 raw_value;
+
+            raw_value = G_STRUCT_MEMBER(gint32, memory, offset);
+            if (gtype == G_TYPE_NONE) {
+                rb_field_value = INT2NUM(raw_value);
+            } else {
+                rb_field_value = GFLAGS2RVAL(raw_value, gtype);
+            }
+        }
+        break;
       case GI_INFO_TYPE_INTERFACE:
       case GI_INFO_TYPE_CONSTANT:
       case GI_INFO_TYPE_INVALID_0:
@@ -125,6 +157,10 @@ rb_gi_field_info_get_field_raw_interface(GIFieldInfo *info,
       case GI_INFO_TYPE_ARG:
       case GI_INFO_TYPE_TYPE:
       case GI_INFO_TYPE_UNRESOLVED:
+        rb_raise(rb_eNotImpError,
+                 "TODO: GIField(interface)[%s](%s)",
+                 g_info_type_to_string(interface_type),
+                 g_type_name(gtype));
         break;
       default:
         break;

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012-2016  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2012-2018  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
@@ -42,6 +42,12 @@ typedef struct _RBGICallback {
     ffi_closure *closure;
 } RBGICallback;
 
+struct RBGICallbackData_ {
+    RBGICallback *callback;
+    RBGIArgMetadata *metadata;
+    VALUE rb_callback;
+};
+
 static VALUE RG_TARGET_NAMESPACE;
 static VALUE rb_cGLibError;
 static const char *callbacks_key = "gi_callbacks";
@@ -300,22 +306,13 @@ fill_metadata(GPtrArray *args_metadata, GICallableInfo *info)
 static void
 callback_data_guard_from_gc(RBGICallbackData *callback_data)
 {
-    VALUE rb_callbacks;
-
-    rb_callbacks = rb_iv_get(RG_TARGET_NAMESPACE, callbacks_key);
-    callback_data->rb_gc_guard_key = rb_class_new_instance(0, NULL, rb_cObject);
-    rb_hash_aset(rb_callbacks,
-                 callback_data->rb_gc_guard_key,
-                 callback_data->rb_callback);
+    rbg_gc_guard(callback_data, callback_data->rb_callback);
 }
 
 static void
 callback_data_unguard_from_gc(RBGICallbackData *callback_data)
 {
-    VALUE rb_callbacks;
-
-    rb_callbacks = rb_iv_get(RG_TARGET_NAMESPACE, callbacks_key);
-    rb_hash_delete(rb_callbacks, callback_data->rb_gc_guard_key);
+    rbg_gc_unguard(callback_data);
 }
 
 static void
@@ -339,6 +336,18 @@ rb_gi_callback_data_free(RBGICallbackData *callback_data)
     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;
+}
+
 static void
 destroy_notify(gpointer data)
 {
@@ -1023,6 +1032,29 @@ ffi_closure_callback(G_GNUC_UNUSED ffi_cif *cif,
             callback_data = *((RBGICallbackData **)(raw_args[i]));
             break;
         }
+
+        if (!callback_data && args_metadata->len > 0) {
+            RBGIArgMetadata *metadata;
+            GIArgInfo *arg_info;
+            GITypeInfo *type_info;
+            GITypeTag type_tag;
+            gboolean is_pointer;
+            const gchar *arg_name;
+
+            i = args_metadata->len - 1;
+            metadata = g_ptr_array_index(args_metadata, i);
+            arg_info = &(metadata->arg_info);
+            type_info = g_arg_info_get_type(arg_info);
+            type_tag = g_type_info_get_tag(type_info);
+            is_pointer = g_type_info_is_pointer(type_info);
+            g_base_info_unref(type_info);
+            arg_name = g_base_info_get_name(arg_info);
+            if (type_tag == GI_TYPE_TAG_VOID &&
+                is_pointer &&
+                strcmp(arg_name, "data") == 0) {
+                callback_data = *((RBGICallbackData **)(raw_args[i]));
+            }
+        }
     }
 
     {
@@ -1421,7 +1453,7 @@ rb_gi_function_info_invoke_raw(GIFunctionInfo *info,
             object_class = g_type_class_ref(CLASS2GTYPE(rb_receiver));
             receiver.v_pointer = object_class;
         } else {
-            receiver.v_pointer = DATA_PTR(rb_receiver);
+            receiver.v_pointer = rb_gi_struct_get_raw(rb_receiver, G_TYPE_NONE);
         }
     }
     rb_arguments = rbg_to_array(rb_arguments);

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012-2017  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2012-2018  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
@@ -58,23 +58,23 @@ rg_s_define_interface(G_GNUC_UNUSED VALUE klass,
     return G_DEF_INTERFACE(gtype, RVAL2CSTR(rb_name), rb_module);
 }
 
-static void
-struct_free(void *pointer)
-{
-    xfree(pointer);
-}
-
 static VALUE
 struct_alloc(VALUE klass)
 {
     VALUE rb_size;
     size_t size;
     gpointer instance;
+    gboolean is_owned;
 
     rb_size = rb_iv_get(klass, "@size");
-    size = NUM2ULONG(rb_size);
-    instance = xcalloc(1, size);
-    return Data_Wrap_Struct(klass, NULL, struct_free, instance);
+    if (NIL_P(rb_size)) {
+        is_owned = FALSE;
+    } else {
+        size = NUM2ULONG(rb_size);
+        instance = xcalloc(1, size);
+        is_owned = TRUE;
+    }
+    return rb_gi_struct_new_raw(klass, instance, is_owned);
 }
 
 static VALUE

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012-2013  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2012-2018  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
@@ -35,6 +35,72 @@ gi_struct_info_get_type(void)
     return type;
 }
 
+typedef struct {
+    gpointer instance;
+    gboolean is_owned;
+} RBGIStructData;
+
+static void
+struct_free(void *data)
+{
+    RBGIStructData *struct_data = data;
+    if (struct_data->is_owned) {
+        xfree(struct_data->instance);
+    }
+    xfree(struct_data);
+}
+
+static const rb_data_type_t rb_gi_struct_type = {
+    "GObjectIntrospection::Struct",
+    {
+        NULL,
+        struct_free,
+        NULL,
+    },
+    NULL,
+    NULL,
+    RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+VALUE
+rb_gi_struct_new_raw(VALUE klass, gpointer instance, gboolean is_owned)
+{
+    RBGIStructData *data;
+    data = RB_ALLOC(RBGIStructData);
+    data->instance = instance;
+    data->is_owned = is_owned;
+    return TypedData_Wrap_Struct(klass, &rb_gi_struct_type, data);
+}
+
+gpointer
+rb_gi_struct_get_raw(VALUE rb_struct, GType gtype)
+{
+    gpointer raw_struct;
+
+    if (gtype == G_TYPE_NONE) {
+        VALUE rb_struct_class;
+
+        rb_struct_class = rb_class_of(rb_struct);
+        if (rb_respond_to(rb_struct_class, rb_intern("gtype"))) {
+            VALUE rb_gtype;
+            rb_gtype = rb_funcall(rb_struct_class, rb_intern("gtype"), 0);
+            gtype = NUM2ULONG(rb_funcall(rb_gtype, rb_intern("to_i"), 0));
+        }
+    }
+    if (gtype == G_TYPE_NONE) {
+        RBGIStructData *data;
+        TypedData_Get_Struct(rb_struct,
+                             RBGIStructData,
+                             &rb_gi_struct_type,
+                             data);
+        raw_struct = data->instance;
+    } else {
+        raw_struct = RVAL2BOXED(rb_struct, gtype);
+    }
+
+    return raw_struct;
+}
+
 VALUE
 rb_gi_struct_info_to_ruby(GIStructInfo *info,
                           gpointer object,
@@ -47,15 +113,13 @@ rb_gi_struct_info_to_ruby(GIStructInfo *info,
     const char *name;
     VALUE rb_module;
     VALUE rb_class;
-    gpointer target_object = object;
-    RUBY_DATA_FUNC free_func = NULL;
 
     gtype = g_registered_type_info_get_g_type(registered_type_info);
     if (gtype == G_TYPE_VARIANT) {
         GVariant *variant = object;
         return rbg_variant_to_ruby(variant);
     } else if (gtype != G_TYPE_NONE) {
-        return BOXED2RVAL(target_object, gtype);
+        return BOXED2RVAL(object, gtype);
     }
 
     namespace = g_base_info_get_namespace(base_info);
@@ -68,7 +132,7 @@ rb_gi_struct_info_to_ruby(GIStructInfo *info,
         gtype_name = g_strdup_printf("Cairo%s", name);
         gtype = g_type_from_name(gtype_name);
         g_free(gtype_name);
-        return BOXED2RVAL(target_object, gtype);
+        return BOXED2RVAL(object, gtype);
     }
 
     rb_module = rb_const_get(rb_cObject, rb_intern(namespace));
@@ -79,18 +143,21 @@ rb_gi_struct_info_to_ruby(GIStructInfo *info,
 
         rb_gtype = rb_funcall(rb_class, rb_intern("gtype"), 0);
         gtype = NUM2ULONG(rb_funcall(rb_gtype, rb_intern("to_i"), 0));
-        return BOXED2RVAL(target_object, gtype);
+        return BOXED2RVAL(object, gtype);
     }
 
-    if (!is_pointer) {
+    if (is_pointer) {
+        return rb_gi_struct_new_raw(rb_class, object, FALSE);
+    } else {
         size_t object_size;
+        gpointer copied_object;
+
         object_size = g_struct_info_get_size(info);
-        target_object = xmalloc(object_size);
-        memcpy(target_object, object, object_size);
-        free_func = xfree;
-    }
+        copied_object = xmalloc(object_size);
+        memcpy(copied_object, object, object_size);
 
-    return Data_Wrap_Struct(rb_class, NULL, free_func, target_object);
+        return rb_gi_struct_new_raw(rb_class, copied_object, TRUE);
+    }
 }
 
 gpointer
@@ -100,11 +167,7 @@ rb_gi_struct_info_from_ruby(GIStructInfo *info, VALUE rb_object)
     GType gtype;
 
     gtype = g_registered_type_info_get_g_type(registerd_type_info);
-    if (gtype == G_TYPE_NONE) {
-        return DATA_PTR(rb_object);
-    } else {
-        return RVAL2BOXED(rb_object, gtype);
-    }
+    return rb_gi_struct_get_raw(rb_object, gtype);
 }
 
 static VALUE
@@ -127,28 +190,6 @@ rg_get_field(VALUE self, VALUE rb_n)
     return GI_BASE_INFO2RVAL_WITH_UNREF(g_struct_info_get_field(info, n));
 }
 
-static gpointer
-extract_raw_struct(VALUE rb_struct,
-                   GIStructInfo *struct_info)
-{
-    GType gtype;
-    gpointer raw_struct;
-
-    gtype = g_registered_type_info_get_g_type(struct_info);
-    if (gtype == G_TYPE_NONE && rb_respond_to(rb_struct, rb_intern("gtype"))) {
-        VALUE rb_gtype;
-        rb_gtype = rb_funcall(rb_struct, rb_intern("gtype"), 0);
-        gtype = NUM2ULONG(rb_funcall(rb_gtype, rb_intern("to_i"), 0));
-    }
-    if (gtype == G_TYPE_NONE) {
-        raw_struct = DATA_PTR(rb_struct);
-    } else {
-        raw_struct = RVAL2BOXED(rb_struct, gtype);
-    }
-
-    return raw_struct;
-}
-
 static VALUE
 rg_get_field_value(VALUE self, VALUE rb_struct, VALUE rb_n)
 {
@@ -159,7 +200,7 @@ rg_get_field_value(VALUE self, VALUE rb_struct, VALUE rb_n)
     VALUE rb_value;
 
     info = SELF(self);
-    raw_struct = extract_raw_struct(rb_struct, info);
+    raw_struct = rb_gi_struct_info_from_ruby(info, rb_struct);
     n = NUM2INT(rb_n);
     field_info = g_struct_info_get_field(info, n);
     rb_value = rb_gi_field_info_get_field_raw(field_info, raw_struct);
@@ -177,7 +218,7 @@ rg_set_field_value(VALUE self, VALUE rb_struct, VALUE rb_n, VALUE rb_value)
     GIFieldInfo *field_info;
 
     info = SELF(self);
-    raw_struct = extract_raw_struct(rb_struct, info);
+    raw_struct = rb_gi_struct_info_from_ruby(info, rb_struct);
     n = NUM2INT(rb_n);
     field_info = g_struct_info_get_field(info, n);
     rb_gi_field_info_set_field_raw(field_info, raw_struct, rb_value);