gobject-introspection 2.0.0-x86-mingw32 → 2.0.1-x86-mingw32

data/Rakefile

@@ -34,7 +34,7 @@ package_task = GNOME2::Rake::PackageTask.new do |_package|
       :name => "glib",
       :download_site => :gnome,
       :label => "GLib",
-      :version => "2.36.0",
+      :version => "2.36.2",
       :compression_method => "xz",
       :windows => {
         :build => false,
@@ -42,6 +42,7 @@ package_task = GNOME2::Rake::PackageTask.new do |_package|
       :native => {
         :build => true,
       },
+      :need_autoreconf => true,
     },
     {
       :name => "gobject-introspection",

data/ext/gobject-introspection/extconf.rb

@@ -66,9 +66,6 @@ end
 
 make_version_header("GI", package_id, ".")
 
-ruby_headers = ["ruby.h"]
-have_type("enum ruby_value_type", ruby_headers)
-
 gi_headers = ["girepository.h"]
 have_func("g_interface_info_find_signal", gi_headers)
 

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

@@ -201,7 +201,11 @@ rb_gi_argument_to_ruby(GIArgument *argument, GITypeInfo *type_info)
     type_tag = g_type_info_get_tag(type_info);
     switch (type_tag) {
       case GI_TYPE_TAG_VOID:
-        rb_argument = Qnil;
+        if (g_type_info_is_pointer(type_info)) {
+            rb_argument = ULONG2NUM(GPOINTER_TO_UINT(argument->v_pointer));
+        } else {
+            rb_argument = Qnil;
+        }
         break;
       case GI_TYPE_TAG_BOOLEAN:
         rb_argument = CBOOL2RVAL(argument->v_boolean);
@@ -273,6 +277,66 @@ rb_gi_argument_to_ruby(GIArgument *argument, GITypeInfo *type_info)
     return rb_argument;
 }
 
+static void
+rb_gi_out_argument_init_interface(GIArgument *argument, GIArgInfo *arg_info,
+                                  GITypeInfo *type_info)
+{
+    GIBaseInfo *interface_info;
+    GIInfoType interface_type;
+
+    if (!g_arg_info_is_caller_allocates(arg_info)) {
+        argument->v_pointer = ALLOC(gpointer);
+        return;
+    }
+
+    interface_info = g_type_info_get_interface(type_info);
+    interface_type = g_base_info_get_type(interface_info);
+
+    switch (interface_type) {
+      case GI_INFO_TYPE_INVALID:
+      case GI_INFO_TYPE_FUNCTION:
+      case GI_INFO_TYPE_CALLBACK:
+        rb_raise(rb_eNotImpError,
+                 "TODO: allocates GIArgument(interface)[%s] for output",
+                 g_info_type_to_string(interface_type));
+        break;
+      case GI_INFO_TYPE_STRUCT:
+        {
+            gsize struct_size;
+
+            struct_size = g_struct_info_get_size(interface_info);
+            argument->v_pointer = xmalloc(struct_size);
+            memset(argument->v_pointer, 0, struct_size);
+        }
+        break;
+      case GI_INFO_TYPE_BOXED:
+      case GI_INFO_TYPE_ENUM:
+      case GI_INFO_TYPE_FLAGS:
+      case GI_INFO_TYPE_OBJECT:
+      case GI_INFO_TYPE_INTERFACE:
+      case GI_INFO_TYPE_CONSTANT:
+      case GI_INFO_TYPE_INVALID_0:
+      case GI_INFO_TYPE_UNION:
+      case GI_INFO_TYPE_VALUE:
+      case GI_INFO_TYPE_SIGNAL:
+      case GI_INFO_TYPE_VFUNC:
+      case GI_INFO_TYPE_PROPERTY:
+      case GI_INFO_TYPE_FIELD:
+      case GI_INFO_TYPE_ARG:
+      case GI_INFO_TYPE_TYPE:
+      case GI_INFO_TYPE_UNRESOLVED:
+        rb_raise(rb_eNotImpError,
+                 "TODO: allocates GIArgument(interface)[%s] for output",
+                 g_info_type_to_string(interface_type));
+        break;
+      default:
+        g_assert_not_reached();
+        break;
+    }
+
+    g_base_info_unref(interface_info);
+}
+
 void
 rb_gi_out_argument_init(GIArgument *argument, GIArgInfo *arg_info)
 {
@@ -330,7 +394,7 @@ rb_gi_out_argument_init(GIArgument *argument, GIArgInfo *arg_info)
         argument->v_pointer = ALLOC(gpointer);
         break;
       case GI_TYPE_TAG_INTERFACE:
-        argument->v_pointer = ALLOC(gpointer);
+        rb_gi_out_argument_init_interface(argument, arg_info, &type_info);
         break;
       case GI_TYPE_TAG_GLIST:
       case GI_TYPE_TAG_GSLIST:
@@ -408,7 +472,11 @@ rb_gi_out_argument_to_ruby(GIArgument *argument, GIArgInfo *arg_info)
       case GI_TYPE_TAG_GLIST:
       case GI_TYPE_TAG_GSLIST:
       case GI_TYPE_TAG_GHASH:
-        normalized_argument.v_pointer = *((gpointer *)(argument->v_pointer));
+        if (g_arg_info_is_caller_allocates(arg_info)) {
+            normalized_argument.v_pointer = argument->v_pointer;
+        } else {
+            normalized_argument.v_pointer = *((gpointer *)(argument->v_pointer));
+        }
         break;
       case GI_TYPE_TAG_ERROR:
         normalized_argument.v_pointer = *((GError **)(argument->v_pointer));
@@ -630,8 +698,8 @@ rb_gi_argument_from_ruby_interface(GIArgument *argument, GITypeInfo *type_info,
 
 
 GIArgument *
-rb_gi_in_argument_from_ruby(GIArgument *argument, GITypeInfo *type_info,
-                            VALUE rb_argument)
+rb_gi_value_argument_from_ruby(GIArgument *argument, GITypeInfo *type_info,
+                               VALUE rb_argument)
 {
     GITypeTag type_tag;
 
@@ -640,6 +708,9 @@ rb_gi_in_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));
+        }
         break;
       case GI_TYPE_TAG_BOOLEAN:
         argument->v_boolean = RVAL2CBOOL(rb_argument);
@@ -716,7 +787,7 @@ rb_gi_inout_argument_from_ruby(GIArgument *argument,
     GIArgument in_argument;
     GITypeTag type_tag;
 
-    rb_gi_in_argument_from_ruby(&in_argument, type_info, rb_argument);
+    rb_gi_value_argument_from_ruby(&in_argument, type_info, rb_argument);
 
     type_tag = g_type_info_get_tag(type_info);
     switch (type_tag) {
@@ -797,8 +868,123 @@ rb_gi_inout_argument_from_ruby(GIArgument *argument,
     }
 }
 
+static void
+rb_gi_in_argument_transfer_interface(GIArgument *argument,
+                                     G_GNUC_UNUSED GITransfer transfer,
+                                     GITypeInfo *type_info,
+                                     G_GNUC_UNUSED VALUE rb_argument)
+{
+    GIBaseInfo *interface_info;
+    GIInfoType interface_type;
+    G_GNUC_UNUSED 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) {
+      case GI_INFO_TYPE_INVALID:
+      case GI_INFO_TYPE_FUNCTION:
+      case GI_INFO_TYPE_CALLBACK:
+        rb_raise(rb_eNotImpError,
+                 "TODO: in transfer (interface) [%s]",
+                 g_info_type_to_string(interface_type));
+        break;
+      case GI_INFO_TYPE_STRUCT:
+        rbgobj_boxed_unown(rb_argument);
+        break;
+      case GI_INFO_TYPE_BOXED:
+      case GI_INFO_TYPE_ENUM:
+      case GI_INFO_TYPE_FLAGS:
+        rb_raise(rb_eNotImpError,
+                 "TODO: in transfer (interface) [%s]",
+                 g_info_type_to_string(interface_type));
+        break;
+      case GI_INFO_TYPE_OBJECT:
+        g_object_ref(argument->v_pointer);
+        break;
+      case GI_INFO_TYPE_INTERFACE:
+      case GI_INFO_TYPE_CONSTANT:
+        rb_raise(rb_eNotImpError,
+                 "TODO: in transfer (interface) [%s]",
+                 g_info_type_to_string(interface_type));
+        break;
+      case GI_INFO_TYPE_INVALID_0:
+        g_assert_not_reached();
+        break;
+      case GI_INFO_TYPE_UNION:
+      case GI_INFO_TYPE_VALUE:
+      case GI_INFO_TYPE_SIGNAL:
+      case GI_INFO_TYPE_VFUNC:
+      case GI_INFO_TYPE_PROPERTY:
+      case GI_INFO_TYPE_FIELD:
+      case GI_INFO_TYPE_ARG:
+      case GI_INFO_TYPE_TYPE:
+      case GI_INFO_TYPE_UNRESOLVED:
+        rb_raise(rb_eNotImpError,
+                 "TODO: in transfer (interface) [%s]",
+                 g_info_type_to_string(interface_type));
+        break;
+      default:
+        g_assert_not_reached();
+        break;
+    }
+}
+
+static void
+rb_gi_in_argument_transfer(GIArgument *argument, GITransfer transfer,
+                           GITypeInfo *type_info, VALUE rb_argument)
+{
+    GITypeTag type_tag;
+
+    if (transfer == GI_TRANSFER_NOTHING) {
+        return;
+    }
+
+    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:
+        break;
+      case GI_TYPE_TAG_UTF8:
+      case GI_TYPE_TAG_FILENAME:
+      case GI_TYPE_TAG_ARRAY:
+        rb_raise(rb_eNotImpError,
+                 "TODO: in transfer (%s)",
+                 g_type_tag_to_string(type_tag));
+        break;
+      case GI_TYPE_TAG_INTERFACE:
+        rb_gi_in_argument_transfer_interface(argument, transfer,
+                                             type_info, rb_argument);
+        break;
+      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: in transfer (%s)",
+                 g_type_tag_to_string(type_tag));
+      default:
+        g_assert_not_reached();
+        break;
+    }
+}
+
 GIArgument *
-rb_gi_call_argument_from_ruby(GIArgument *argument, GIArgInfo *arg_info,
+rb_gi_in_argument_from_ruby(GIArgument *argument, GIArgInfo *arg_info,
                             VALUE rb_argument)
 {
     GITypeInfo type_info;
@@ -813,14 +999,18 @@ rb_gi_call_argument_from_ruby(GIArgument *argument, GIArgInfo *arg_info,
         rb_gi_inout_argument_from_ruby(argument, arg_info, &type_info,
                                        rb_argument);
     } else {
-        rb_gi_in_argument_from_ruby(argument, &type_info, rb_argument);
+        rb_gi_value_argument_from_ruby(argument, &type_info, rb_argument);
+        rb_gi_in_argument_transfer(argument,
+                                   g_arg_info_get_ownership_transfer(arg_info),
+                                   &type_info,
+                                   rb_argument);
     }
 
     return argument;
 }
 
 static void
-rb_gi_in_argument_free_array(GIArgument *argument, GITypeInfo *type_info)
+rb_gi_value_argument_free_array(GIArgument *argument, GITypeInfo *type_info)
 {
     GIArrayType array_type;
 
@@ -840,7 +1030,7 @@ rb_gi_in_argument_free_array(GIArgument *argument, GITypeInfo *type_info)
 }
 
 static void
-rb_gi_in_argument_free_interface(GIArgument *argument, GITypeInfo *type_info)
+rb_gi_value_argument_free_interface(GIArgument *argument, GITypeInfo *type_info)
 {
     GIBaseInfo *interface_info;
     GIInfoType interface_type;
@@ -863,7 +1053,7 @@ rb_gi_in_argument_free_interface(GIArgument *argument, GITypeInfo *type_info)
 }
 
 void
-rb_gi_in_argument_free(GIArgument *argument, GITypeInfo *type_info)
+rb_gi_value_argument_free(GIArgument *argument, GITypeInfo *type_info)
 {
     GITypeTag type_tag;
 
@@ -886,10 +1076,10 @@ rb_gi_in_argument_free(GIArgument *argument, GITypeInfo *type_info)
       case GI_TYPE_TAG_FILENAME:
         break;
       case GI_TYPE_TAG_ARRAY:
-        rb_gi_in_argument_free_array(argument, type_info);
+        rb_gi_value_argument_free_array(argument, type_info);
         break;
       case GI_TYPE_TAG_INTERFACE:
-        rb_gi_in_argument_free_interface(argument, type_info);
+        rb_gi_value_argument_free_interface(argument, type_info);
         break;
       case GI_TYPE_TAG_GLIST:
       case GI_TYPE_TAG_GSLIST:
@@ -991,12 +1181,12 @@ rb_gi_inout_argument_free(GIArgument *argument, GITypeInfo *type_info)
         break;
     }
 
-    rb_gi_in_argument_free(&in_argument, type_info);
+    rb_gi_value_argument_free(&in_argument, type_info);
     xfree(argument->v_pointer);
 }
 
 void
-rb_gi_call_argument_free(GIArgument *argument, GIArgInfo *arg_info)
+rb_gi_in_argument_free(GIArgument *argument, GIArgInfo *arg_info)
 {
     GITypeInfo type_info;
 
@@ -1004,7 +1194,7 @@ rb_gi_call_argument_free(GIArgument *argument, GIArgInfo *arg_info)
     if (g_arg_info_get_direction(arg_info) == GI_DIRECTION_INOUT) {
         rb_gi_inout_argument_free(argument, &type_info);
     } else {
-        rb_gi_in_argument_free(argument, &type_info);
+        rb_gi_value_argument_free(argument, &type_info);
     }
 }
 

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

@@ -82,7 +82,7 @@ initialize_receiver(VALUE receiver, GITypeInfo *info, GIArgument *value)
 }
 
 static VALUE
-rg_invoke(int argc, VALUE *argv, VALUE self)
+rg_invoke(VALUE self, VALUE rb_options)
 {
     GIFunctionInfo *info;
     GICallableInfo *callable_info;
@@ -93,11 +93,19 @@ rg_invoke(int argc, VALUE *argv, VALUE self)
     info = SELF(self);
     callable_info = (GICallableInfo *)info;
 
-    /* TODO: check argc. */
-    receiver = argv[0];
+    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));
+    }
     /* TODO: use rb_protect */
-    rb_gi_function_info_invoke_raw(info, NULL,
-                                   argc - 1, argv + 1,
+    rb_gi_function_info_invoke_raw(info,
+                                   rb_options,
                                    &return_value);
 
     g_callable_info_load_return_type(callable_info, &return_value_info);
@@ -116,5 +124,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, 1);
 }

data/ext/gobject-introspection/rb-gi-conversions.h

@@ -37,10 +37,10 @@
     (rb_gi_out_argument_to_ruby((argument), (arg_info)))
 #define GI_RETURN_ARGUMENT2RVAL(argument, callable_info)                \
     (rb_gi_return_argument_to_ruby((argument), (callable_info)))
-#define RVAL2GI_IN_ARGUMENT(argument, type_info, rb_argument)           \
-    (rb_gi_in_argument_from_ruby((argument), (type_info), (rb_argument)))
-#define RVAL2GI_CALL_ARGUMENT(argument, arg_info, rb_argument)          \
-    (rb_gi_call_argument_from_ruby((argument), (arg_info), (rb_argument)))
+#define RVAL2GI_VALUE_ARGUMENT(argument, type_info, rb_argument)        \
+    (rb_gi_value_argument_from_ruby((argument), (type_info), (rb_argument)))
+#define RVAL2GI_IN_ARGUMENT(argument, arg_info, rb_argument)            \
+    (rb_gi_in_argument_from_ruby((argument), (arg_info), (rb_argument)))
 
 
 #define RVAL2GI_REGISTERED_TYPE_INFO(rb_object)			\
@@ -99,15 +99,15 @@ void        rb_gi_out_argument_fin            (GIArgument     *argument,
                                                GIArgInfo      *arg_info);
 VALUE       rb_gi_return_argument_to_ruby     (GIArgument     *argument,
                                                GICallableInfo *callable_info);
-GIArgument *rb_gi_in_argument_from_ruby       (GIArgument     *argument,
+GIArgument *rb_gi_value_argument_from_ruby    (GIArgument     *argument,
                                                GITypeInfo     *type_info,
                                                VALUE           rb_argument);
-GIArgument *rb_gi_call_argument_from_ruby     (GIArgument     *argument,
+GIArgument *rb_gi_in_argument_from_ruby       (GIArgument     *argument,
                                                GIArgInfo      *arg_info,
                                                VALUE           rb_argument);
-void        rb_gi_in_argument_free            (GIArgument     *argument,
+void        rb_gi_value_argument_free         (GIArgument     *argument,
                                                GITypeInfo     *type_info);
-void        rb_gi_call_argument_free          (GIArgument     *argument,
+void        rb_gi_in_argument_free            (GIArgument     *argument,
                                                GIArgInfo      *arg_info);
 
 VALUE       rb_gi_array_type_to_ruby          (GIArrayType type);

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

@@ -98,10 +98,10 @@ rb_gi_field_info_set_field_raw(GIFieldInfo *info, gpointer memory,
     gboolean succeeded;
 
     type_info = g_field_info_get_type(info);
-    RVAL2GI_IN_ARGUMENT(&field_value, type_info, rb_field_value);
+    RVAL2GI_VALUE_ARGUMENT(&field_value, type_info, rb_field_value);
 
     succeeded = g_field_info_set_field(info, memory, &field_value);
-    rb_gi_in_argument_free(&field_value, type_info);
+    rb_gi_value_argument_free(&field_value, type_info);
     g_base_info_unref(type_info);
 
     if (!succeeded) {

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

@@ -20,6 +20,17 @@
 
 #include "rb-gi-private.h"
 
+#ifdef HAVE_RUBY_THREAD_H
+#  include <ruby/thread.h>
+#  define RB_THREAD_CALL_WITHOUT_GVL_FUNC_RETURN_TYPE void *
+#  define RB_THREAD_CALL_WITHOUT_GVL_FUNC_RETURN_VALUE NULL
+#else
+#  define rb_thread_call_without_gvl(func, func_data, ubf, ubf_data) \
+    rb_thread_blocking_region(func, func_data, ubf, ubf_data)
+#  define RB_THREAD_CALL_WITHOUT_GVL_FUNC_RETURN_TYPE VALUE
+#  define RB_THREAD_CALL_WITHOUT_GVL_FUNC_RETURN_VALUE Qnil
+#endif
+
 #define RG_TARGET_NAMESPACE rb_cGIFunctionInfo
 #define SELF(self) RVAL2GI_FUNCTION_INFO(self)
 
@@ -322,8 +333,7 @@ source_func_callback_finder(GIArgInfo *arg_info)
 }
 
 static void
-in_callback_argument_from_ruby(RBGIArgMetadata *metadata, VALUE *argv,
-                               GArray *in_args)
+in_callback_argument_from_ruby(RBGIArgMetadata *metadata, GArray *in_args)
 {
     gpointer callback;
     GIArgInfo *arg_info;
@@ -374,21 +384,26 @@ in_callback_argument_from_ruby(RBGIArgMetadata *metadata, VALUE *argv,
 }
 
 static void
-in_argument_from_ruby(RBGIArgMetadata *metadata, VALUE *argv, GArray *in_args)
+in_argument_from_ruby(RBGIArgMetadata *metadata, VALUE rb_arguments,
+                      GArray *in_args)
 {
     if (metadata->rb_arg_index == -1) {
         return;
     }
 
     if (metadata->callback_p) {
-        in_callback_argument_from_ruby(metadata, argv, in_args);
+        in_callback_argument_from_ruby(metadata, in_args);
     } else {
         GIArgument *argument;
+        VALUE rb_argument = Qnil;
 
+        if (RARRAY_LEN(rb_arguments) > metadata->rb_arg_index) {
+            rb_argument = RARRAY_PTR(rb_arguments)[metadata->rb_arg_index];
+        }
         argument = &(g_array_index(in_args, GIArgument, metadata->in_arg_index));
-        RVAL2GI_CALL_ARGUMENT(argument,
-                              &(metadata->arg_info),
-                              argv[metadata->rb_arg_index]);
+        RVAL2GI_IN_ARGUMENT(argument,
+                            &(metadata->arg_info),
+                            rb_argument);
     }
 }
 
@@ -413,8 +428,7 @@ arg_metadata_free(gpointer data)
 }
 
 static void
-arguments_from_ruby(GICallableInfo *info,
-                    int argc, VALUE *argv,
+arguments_from_ruby(GICallableInfo *info, VALUE rb_arguments,
                     GArray *in_args, GArray *out_args,
                     GPtrArray *args_metadata)
 {
@@ -423,15 +437,13 @@ arguments_from_ruby(GICallableInfo *info,
     allocate_arguments(info, in_args, out_args, args_metadata);
     fill_metadata(args_metadata);
 
-    /* TODO: validate_rb_args(args_metadata); */
-
     n_args = g_callable_info_get_n_args(info);
     for (i = 0; i < n_args; i++) {
         RBGIArgMetadata *metadata;
 
         metadata = g_ptr_array_index(args_metadata, i);
         if (metadata->in_arg_index != -1) {
-            in_argument_from_ruby(metadata, argv, in_args);
+            in_argument_from_ruby(metadata, rb_arguments, in_args);
         } else {
             out_argument_from_ruby(metadata, out_args);
         }
@@ -535,7 +547,7 @@ arguments_free(GArray *in_args, GArray *out_args, GPtrArray *args_metadata)
             if (in_arg_index != -1) {
                 GIArgument *argument;
                 argument = &(g_array_index(in_args, GIArgument, in_arg_index));
-                rb_gi_call_argument_free(argument, &(metadata->arg_info));
+                rb_gi_in_argument_free(argument, &(metadata->arg_info));
             }
         } else {
             GIArgument *argument;
@@ -550,33 +562,126 @@ arguments_free(GArray *in_args, GArray *out_args, GPtrArray *args_metadata)
     g_ptr_array_unref(args_metadata);
 }
 
+typedef struct {
+    GIFunctionInfo *info;
+    GArray *in_args;
+    GArray *out_args;
+    GIArgument *return_value;
+    GError **error;
+    gboolean succeeded;
+} InvokeData;
+
+static void
+rb_gi_function_info_invoke_raw_call(InvokeData *data)
+{
+    data->succeeded =
+        g_function_info_invoke(data->info,
+                               (GIArgument *)(data->in_args->data),
+                               data->in_args->len,
+                               (GIArgument *)(data->out_args->data),
+                               data->out_args->len,
+                               data->return_value,
+                               data->error);
+}
+
+static RB_THREAD_CALL_WITHOUT_GVL_FUNC_RETURN_TYPE
+rb_gi_function_info_invoke_raw_call_without_gvl_body(void *user_data)
+{
+    InvokeData *data = (InvokeData *)user_data;
+
+    rb_gi_function_info_invoke_raw_call(data);
+
+    return RB_THREAD_CALL_WITHOUT_GVL_FUNC_RETURN_VALUE;
+}
+
+static gboolean
+gobject_based_p(GIBaseInfo *info)
+{
+    GIBaseInfo *container_info;
+    GIRegisteredTypeInfo *registered_type_info;
+
+    container_info = g_base_info_get_container(info);
+    if (g_base_info_get_type(container_info) != GI_INFO_TYPE_STRUCT) {
+        return TRUE;
+    }
+
+    registered_type_info = (GIRegisteredTypeInfo *)container_info;
+    if (g_registered_type_info_get_type_init(registered_type_info)) {
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
 VALUE
-rb_gi_function_info_invoke_raw(GIFunctionInfo *info, GIArgument *receiver,
-                               int argc, VALUE *argv,
+rb_gi_function_info_invoke_raw(GIFunctionInfo *info, VALUE rb_options,
                                GIArgument *return_value)
 {
     GICallableInfo *callable_info;
+    GIArgument receiver;
     GArray *in_args, *out_args;
     GPtrArray *args_metadata;
     VALUE rb_out_args = Qnil;
     gboolean succeeded;
     GError *error = NULL;
+    gboolean unlock_gvl = FALSE;
+    VALUE rb_receiver, rb_arguments, rb_unlock_gvl;
+
+    if (RB_TYPE_P(rb_options, RUBY_T_ARRAY)) {
+        rb_receiver = Qnil;
+        rb_arguments = rb_options;
+        rb_unlock_gvl = Qnil;
+    } else if (NIL_P(rb_options)) {
+        rb_receiver = Qnil;
+        rb_arguments = rb_ary_new();
+        rb_unlock_gvl = Qnil;
+    } else {
+        rb_options = rbg_check_hash_type(rb_options);
+        rbg_scan_options(rb_options,
+                         "receiver", &rb_receiver,
+                         "arguments", &rb_arguments,
+                         "unlock_gvl", &rb_unlock_gvl,
+                         NULL);
+    }
+
+    if (NIL_P(rb_receiver)) {
+        receiver.v_pointer = NULL;
+    } else {
+        if (gobject_based_p((GIBaseInfo *)info)) {
+            receiver.v_pointer = RVAL2GOBJ(rb_receiver);
+        } else {
+            receiver.v_pointer = DATA_PTR(rb_receiver);
+        }
+    }
+    rb_arguments = rbg_to_array(rb_arguments);
+    if (!NIL_P(rb_unlock_gvl) && RVAL2CBOOL(rb_unlock_gvl)) {
+        unlock_gvl = TRUE;
+    }
 
     callable_info = (GICallableInfo *)info;
     arguments_init(&in_args, &out_args, &args_metadata);
-    if (receiver) {
-        g_array_append_val(in_args, *receiver);
+    if (receiver.v_pointer) {
+        g_array_append_val(in_args, receiver);
     }
-    arguments_from_ruby(callable_info,
-                        argc, argv,
+    arguments_from_ruby(callable_info, rb_arguments,
                         in_args, out_args, args_metadata);
-    succeeded = g_function_info_invoke(info,
-                                       (GIArgument *)(in_args->data),
-                                       in_args->len,
-                                       (GIArgument *)(out_args->data),
-                                       out_args->len,
-                                       return_value,
-                                       &error);
+    {
+        InvokeData data;
+        data.info = info;
+        data.in_args = in_args;
+        data.out_args = out_args;
+        data.return_value = return_value;
+        data.error = &error;
+        if (unlock_gvl) {
+            rb_thread_call_without_gvl(
+                rb_gi_function_info_invoke_raw_call_without_gvl_body, &data,
+                NULL, NULL);
+        } else {
+            rb_gi_function_info_invoke_raw_call(&data);
+        }
+        succeeded = data.succeeded;
+    }
+
     if (succeeded) {
         rb_out_args = out_arguments_to_ruby(callable_info,
                                             in_args, out_args,
@@ -599,7 +704,7 @@ rb_gi_function_info_invoke_raw(GIFunctionInfo *info, GIArgument *receiver,
 }
 
 static VALUE
-rg_invoke(int argc, VALUE *argv, VALUE self)
+rg_invoke(VALUE self, VALUE rb_options)
 {
     GIFunctionInfo *info;
     GICallableInfo *callable_info;
@@ -609,7 +714,8 @@ rg_invoke(int argc, VALUE *argv, VALUE self)
 
     info = SELF(self);
     /* TODO: use rb_protect() */
-    rb_out_args = rb_gi_function_info_invoke_raw(info, NULL, argc, argv,
+    rb_out_args = rb_gi_function_info_invoke_raw(info,
+                                                 rb_options,
                                                  &return_value);
 
     callable_info = (GICallableInfo *)info;
@@ -649,7 +755,7 @@ rb_gi_function_info_init(VALUE rb_mGI, VALUE rb_cGICallableInfo)
     RG_DEF_METHOD(flags, 0);
     RG_DEF_METHOD(property, 0);
     RG_DEF_METHOD(vfunc, 0);
-    RG_DEF_METHOD(invoke, -1);
+    RG_DEF_METHOD(invoke, 1);
 
     G_DEF_CLASS(G_TYPE_I_FUNCTION_INFO_FLAGS, "FunctionInfoFlags", rb_mGI);
 

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

@@ -35,46 +35,20 @@ gi_method_info_get_type(void)
     return type;
 }
 
-static gboolean
-gobject_based_p(GIFunctionInfo *info)
-{
-    GIBaseInfo *container_info;
-    GIRegisteredTypeInfo *registered_type_info;
-
-    container_info = g_base_info_get_container((GIBaseInfo *)info);
-    if (g_base_info_get_type(container_info) != GI_INFO_TYPE_STRUCT) {
-        return TRUE;
-    }
-
-    registered_type_info = (GIRegisteredTypeInfo *)container_info;
-    if (g_registered_type_info_get_type_init(registered_type_info)) {
-        return TRUE;
-    }
-
-    return FALSE;
-}
-
 static VALUE
-rg_invoke(int argc, VALUE *argv, VALUE self)
+rg_invoke(VALUE self, VALUE rb_options)
 {
     GIFunctionInfo *info;
     GICallableInfo *callable_info;
-    GIArgument receiver;
     GIArgument return_value;
     VALUE rb_out_args;
     VALUE rb_return_value;
 
     info = SELF(self);
 
-    /* TODO: check argc >= 1 */
-    if (gobject_based_p(info)) {
-        receiver.v_pointer = RVAL2GOBJ(argv[0]);
-    } else {
-        receiver.v_pointer = DATA_PTR(argv[0]);
-    }
     /* TODO: use rb_protect */
-    rb_out_args = rb_gi_function_info_invoke_raw(info, &receiver,
-                                                 argc - 1, argv + 1,
+    rb_out_args = rb_gi_function_info_invoke_raw(info,
+                                                 rb_options,
                                                  &return_value);
 
     callable_info = (GICallableInfo *)info;
@@ -105,5 +79,5 @@ rb_gi_method_info_init(VALUE rb_mGI, VALUE rb_cGIFunctionInfo)
 	G_DEF_CLASS_WITH_PARENT(GI_TYPE_METHOD_INFO, "MethodInfo", rb_mGI,
 				rb_cGIFunctionInfo);
 
-    RG_DEF_METHOD(invoke, -1);
+    RG_DEF_METHOD(invoke, 1);
 }

data/ext/gobject-introspection/rb-gi-private.h

@@ -39,10 +39,6 @@
 #  define RB_TYPE_P(object, type) (TYPE(object) == type)
 #endif
 
-#ifndef HAVE_TYPE_ENUM_RUBY_VALUE_TYPE
-#  define RUBY_T_FIXNUM T_FIXNUM
-#endif
-
 extern void Init_gobject_introspection(void);
 
 void rb_gi_argument_init             (void);
@@ -97,8 +93,7 @@ void rb_gi_repository_init           (VALUE rb_mGI);
 void rb_gi_loader_init               (VALUE rb_mGI);
 
 VALUE rb_gi_function_info_invoke_raw (GIFunctionInfo *info,
-                                      GIArgument *receiver,
-                                      int argc, VALUE *argv,
+                                      VALUE rb_options,
                                       GIArgument *return_value);
 
 VALUE rb_gi_field_info_get_field_raw (GIFieldInfo *info,

data/lib/gobject-introspection.rb

@@ -48,5 +48,6 @@ require "gobject-introspection/callable-info"
 require "gobject-introspection/object-info"
 require "gobject-introspection/interface-info"
 require "gobject-introspection/struct-info"
+require "gobject-introspection/boxed-info"
 require "gobject-introspection/union-info"
 require "gobject-introspection/loader"

data/lib/gobject-introspection/boxed-info.rb

@@ -0,0 +1,28 @@
+# Copyright (C) 2013  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
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require "gobject-introspection/collection-reader"
+
+module GObjectIntrospection
+  class BoxedInfo
+    extend CollectionReader
+
+    alias_method :__methods__, :methods
+
+    collection_reader("fields")
+    collection_reader("methods")
+  end
+end

data/lib/gobject-introspection/loader.rb

@@ -53,6 +53,8 @@ module GObjectIntrospection
         load_function_info(info)
       when StructInfo
         load_struct_info(info)
+      when BoxedInfo
+        load_boxed_info(info)
       when FlagsInfo
         load_flags_info(info)
       when EnumInfo
@@ -74,6 +76,7 @@ module GObjectIntrospection
     end
 
     def define_module_function(target_module, name, function_info)
+      unlock_gvl = should_unlock_gvl?(function_info, target_module)
       validate = lambda do |arguments|
         method_name = "#{target_module}\#.#{name}"
         validate_arguments(function_info, method_name, arguments)
@@ -81,7 +84,11 @@ module GObjectIntrospection
       target_module.module_eval do
         define_method(name) do |*arguments, &block|
           validate.call(arguments, &block)
-          function_info.invoke(*arguments, &block)
+          function_info.invoke({
+                                 :arguments => arguments,
+                                 :unlock_gvl => unlock_gvl,
+                               },
+                               &block)
         end
         module_function(name)
       end
@@ -105,6 +112,17 @@ module GObjectIntrospection
       define_struct(info)
     end
 
+    def define_boxed(info)
+      klass = self.class.define_class(info.gtype, info.name, @base_module)
+      # TODO
+      # load_fields(info, klass)
+      # load_methods(info, klass)
+    end
+
+    def load_boxed_info(info)
+      define_boxed(info)
+    end
+
     def load_enum_value(value_info, enum_module)
       enum_module.const_set(value_info.name.upcase, value_info.value)
     end
@@ -146,19 +164,23 @@ module GObjectIntrospection
     def load_fields(info, klass)
       info.n_fields.times do |i|
         field_info = info.get_field(i)
-        name = field_info.name
-        flags = field_info.flags
+        load_field(info, i, field_info, klass)
+      end
+    end
 
-        if flags.readable?
-          klass.__send__(:define_method, name) do ||
-            info.get_field_value(self, i)
-          end
+    def load_field(info, i, field_info, klass)
+      name = field_info.name
+      flags = field_info.flags
+
+      if flags.readable?
+        klass.__send__(:define_method, name) do ||
+          info.get_field_value(self, i)
         end
+      end
 
-        if flags.writable?
-          klass.__send__(:define_method, "#{name}=") do |value|
-            info.set_field_value(self, i, value)
-          end
+      if flags.writable?
+        klass.__send__(:define_method, "#{name}=") do |value|
+          info.set_field_value(self, i, value)
         end
       end
     end
@@ -190,9 +212,15 @@ module GObjectIntrospection
       end
       infos.each do |info|
         name = "initialize_#{info.name}"
+        unlock_gvl = should_unlock_gvl?(info, klass)
         klass.__send__(:define_method, name) do |*arguments, &block|
           validate.call(info, name, arguments, &block)
-          info.invoke(self, *arguments, &block)
+          info.invoke({
+                        :receiver  => self,
+                        :arguments => arguments,
+                        :unlock_gvl => unlock_gvl,
+                      },
+                      &block)
         end
         klass.__send__(:private, name)
       end
@@ -265,6 +293,10 @@ module GObjectIntrospection
       end
     end
 
+    def should_unlock_gvl?(function_info, klass)
+      false
+    end
+
     def load_method_infos(infos, klass)
       infos.each do |info|
         method_name = rubyish_method_name(info)
@@ -276,6 +308,7 @@ module GObjectIntrospection
     end
 
     def load_method_info(info, klass, method_name)
+      unlock_gvl = should_unlock_gvl?(info, klass)
       validate = lambda do |arguments|
         validate_arguments(info, "#{klass}\##{method_name}", arguments)
       end
@@ -284,7 +317,12 @@ module GObjectIntrospection
         if block.nil? and info.require_callback?
           Enumerator.new(self, method_name, *arguments)
         else
-          info.invoke(self, *arguments, &block)
+          info.invoke({
+                        :receiver  => self,
+                        :arguments => arguments,
+                        :unlock_gvl => unlock_gvl,
+                      },
+                      &block)
         end
       end
     end
@@ -294,6 +332,7 @@ module GObjectIntrospection
         name = rubyish_method_name(info)
         next if name == "new"
         next if name == "alloc"
+        unlock_gvl = should_unlock_gvl?(info, klass)
         validate = lambda do |arguments|
           validate_arguments(info, "#{klass}.#{name}", arguments)
         end
@@ -303,7 +342,11 @@ module GObjectIntrospection
           if block.nil? and info.require_callback?
             Enumerator.new(self, name, *arguments)
           else
-            info.invoke(*arguments, &block)
+            info.invoke({
+                          :arguments => arguments,
+                          :unlock_gvl => unlock_gvl,
+                        },
+                        &block)
           end
         end
       end

data/vendor/local/share/gir-1.0/GLib-2.0.gir

@@ -12140,7 +12140,7 @@ linked against at application run time.</doc>
       <doc xml:whitespace="preserve">The maximum value which can be held in a #guint8.</doc>
       <type name="guint8" c:type="guint8"/>
     </constant>
-    <constant name="MICRO_VERSION" value="0" c:type="GLIB_MICRO_VERSION">
+    <constant name="MICRO_VERSION" value="2" c:type="GLIB_MICRO_VERSION">
       <doc xml:whitespace="preserve">The micro version number of the GLib library.
 
 Like #gtk_micro_version, but from the headers used at

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gobject-introspection
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
   prerelease: 
 platform: x86-mingw32
 authors:
@@ -9,24 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-29 00:00:00.000000000 Z
+date: 2013-05-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: glib2
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - '='
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 2.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - '='
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 2.0.1
 - !ruby/object:Gem::Dependency
   name: test-unit
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +52,7 @@ files:
 - Rakefile
 - extconf.rb
 - lib/gobject-introspection.rb
+- lib/gobject-introspection/boxed-info.rb
 - lib/gobject-introspection/callable-info.rb
 - lib/gobject-introspection/collection-reader.rb
 - lib/gobject-introspection/interface-info.rb