gobject-introspection 2.2.5-x64-mingw32 → 3.0.0-x64-mingw32

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

@@ -56,7 +56,7 @@ rg_value(VALUE self)
     info = SELF(self);
     type_info = g_constant_info_get_type(info);
     value_size = g_constant_info_get_value(info, &value);
-    rb_value = GI_ARGUMENT2RVAL(&value, type_info);
+    rb_value = GI_ARGUMENT2RVAL(&value, FALSE, type_info, NULL, NULL, NULL);
     g_base_info_unref(type_info);
     g_constant_info_free_value(info, &value);
 

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

@@ -50,7 +50,6 @@ initialize_receiver(VALUE receiver, GITypeInfo *info, GIArgument *value)
     g_base_info_unref(interface_info);
     switch (interface_type) {
       case GI_INFO_TYPE_OBJECT:
-        g_object_ref_sink(value->v_pointer);
         G_INITIALIZE(receiver, value->v_pointer);
         break;
       case GI_INFO_TYPE_STRUCT:
@@ -111,7 +110,8 @@ rg_invoke(VALUE self, VALUE rb_options)
     /* TODO: use rb_protect */
     rb_gi_function_info_invoke_raw(info,
                                    rb_options,
-                                   &return_value);
+                                   &return_value,
+                                   NULL);
 
     g_callable_info_load_return_type(callable_info, &return_value_info);
     initialize_receiver(receiver, &return_value_info, &return_value);

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

@@ -31,26 +31,24 @@
     (rb_gi_base_info_to_ruby_with_unref((GIBaseInfo *)(info)))
 #define RVAL2GI_BASE_INFO(rb_object) (rb_gi_base_info_from_ruby(rb_object))
 
-#define GI_ARGUMENT2RVAL(argument, type_info)           \
-    (rb_gi_argument_to_ruby((argument), (type_info)))
-#define GI_ARRAY_ARGUMENT2RVAL(array_argument, length_argument,         \
-                               array_type_info, length_type_info)       \
-    (rb_gi_array_argument_to_ruby((array_argument),                     \
-                                  (length_argument),                    \
-                                  (array_type_info),                    \
-                                  (length_type_info)))
-#define GI_OUT_ARGUMENT2RVAL(argument, arg_info)                \
-    (rb_gi_out_argument_to_ruby((argument), (arg_info)))
-#define GI_OUT_ARRAY_ARGUMENT2RVAL(array_argument, length_argument,     \
-                                   array_arg_info, length_arg_info)     \
-    (rb_gi_out_array_argument_to_ruby((array_argument), (length_argument), \
-                                      (array_arg_info), (length_arg_info)))
-#define GI_RETURN_ARGUMENT2RVAL(argument, callable_info)                \
-    (rb_gi_return_argument_to_ruby((argument), (callable_info)))
-#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 GI_ARGUMENT2RVAL(argument, duplicate, type_info,                \
+                         in_args, out_args, args_metadata)              \
+    (rb_gi_argument_to_ruby((argument), (duplicate), (type_info),       \
+                            (in_args), (out_args), (args_metadata)))
+#define GI_OUT_ARGUMENT2RVAL(argument, arg_info,                        \
+                             in_args, out_args, args_metadata)          \
+    (rb_gi_out_argument_to_ruby((argument), (arg_info),                 \
+                                (in_args), (out_args), (args_metadata)))
+#define GI_RETURN_ARGUMENT2RVAL(callable_info, argument,                \
+                                in_args, out_args, args_metadata)       \
+    (rb_gi_return_argument_to_ruby((callable_info), (argument),         \
+                                   (in_args), (out_args), (args_metadata)))
+#define RVAL2GI_VALUE_ARGUMENT(argument, type_info, rb_argument, self)  \
+    (rb_gi_value_argument_from_ruby((argument), (type_info),            \
+                                    (rb_argument), (self)))
+#define RVAL2GI_IN_ARGUMENT(argument, arg_info, rb_argument, self)      \
+    (rb_gi_in_argument_from_ruby((argument), (arg_info),                \
+                                 (rb_argument), (self)))
 #define RVAL2GI_IN_ARRAY_ARGUMENT(array_argument, length_argument,      \
                                   array_arg_info, length_arg_info,      \
                                   rb_argument)                          \
@@ -106,37 +104,43 @@ VALUE       rb_gi_base_info_to_ruby_with_unref(GIBaseInfo *info);
 GIBaseInfo *rb_gi_base_info_from_ruby         (VALUE rb_info);
 
 VALUE       rb_gi_argument_to_ruby            (GIArgument     *argument,
-                                               GITypeInfo     *type_info);
-VALUE       rb_gi_array_argument_to_ruby      (GIArgument     *array_argument,
-                                               GIArgument     *length_argument,
-                                               GITypeInfo     *array_type_info,
-                                               GITypeInfo     *length_type_info);
+                                               gboolean        duplicate,
+                                               GITypeInfo     *type_info,
+                                               GArray         *in_args,
+                                               GArray         *out_args,
+                                               GPtrArray      *args_metadata);
 void        rb_gi_out_argument_init           (GIArgument     *argument,
                                                GIArgInfo      *arg_info);
 VALUE       rb_gi_out_argument_to_ruby        (GIArgument     *argument,
-                                               GIArgInfo      *arg_info);
-VALUE       rb_gi_out_array_argument_to_ruby  (GIArgument     *array_argument,
-                                               GIArgument     *length_argument,
-                                               GIArgInfo      *array_arg_info,
-                                               GIArgInfo      *length_arg_info);
+                                               GIArgInfo      *arg_info,
+                                               GArray         *in_args,
+                                               GArray         *out_args,
+                                               GPtrArray      *args_metadata);
 void        rb_gi_out_argument_fin            (GIArgument     *argument,
                                                GIArgInfo      *arg_info);
-VALUE       rb_gi_return_argument_to_ruby     (GIArgument     *argument,
-                                               GICallableInfo *callable_info);
+VALUE       rb_gi_return_argument_to_ruby     (GICallableInfo *callable_info,
+                                               GIArgument     *argument,
+                                               GArray         *in_args,
+                                               GArray         *out_args,
+                                               GPtrArray      *args_metadata);
 GIArgument *rb_gi_value_argument_from_ruby    (GIArgument     *argument,
                                                GITypeInfo     *type_info,
-                                               VALUE           rb_argument);
+                                               VALUE           rb_argument,
+                                               VALUE           self);
 GIArgument *rb_gi_in_argument_from_ruby       (GIArgument     *argument,
                                                GIArgInfo      *arg_info,
-                                               VALUE           rb_argument);
+                                               VALUE           rb_argument,
+                                               VALUE           self);
 GIArgument *rb_gi_in_array_argument_from_ruby (GIArgument     *array_argument,
                                                GIArgument     *length_argument,
                                                GIArgInfo      *array_arg_info,
                                                GIArgInfo      *length_arg_info,
                                                VALUE           rb_argument);
-void        rb_gi_value_argument_free         (GIArgument     *argument,
+void        rb_gi_value_argument_free         (VALUE           rb_argument,
+                                               GIArgument     *argument,
                                                GITypeInfo     *type_info);
-void        rb_gi_in_argument_free            (GIArgument     *argument,
+void        rb_gi_in_argument_free            (VALUE           rb_argument,
+                                               GIArgument     *argument,
                                                GIArgInfo      *arg_info);
 
 VALUE       rb_gi_array_type_to_ruby          (GIArrayType type);

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

@@ -76,14 +76,27 @@ rb_gi_field_info_get_field_raw(GIFieldInfo *info, gpointer memory)
 {
     GIArgument argument;
     GITypeInfo *type_info;
+    GITypeTag type_tag;
     VALUE rb_field_value;
 
+    type_info = g_field_info_get_type(info);
+    type_tag = g_type_info_get_tag(type_info);
+
     if (!g_field_info_get_field(info, memory, &argument)) {
-        rb_raise(rb_eArgError, "failed to get field value");
+        g_base_info_unref(type_info);
+        rb_raise(rb_eArgError, "failed to get field value: %s[%s]",
+                 g_base_info_get_name(info),
+                 g_type_tag_to_string(type_tag));
     }
 
-    type_info = g_field_info_get_type(info);
-    rb_field_value = GI_ARGUMENT2RVAL(&argument, type_info);
+    if (type_tag == GI_TYPE_TAG_UTF8) {
+        int offset;
+        offset = g_field_info_get_offset(info);
+        argument.v_string = G_STRUCT_MEMBER(gchar *, memory, offset);
+    }
+
+    rb_field_value = GI_ARGUMENT2RVAL(&argument, FALSE, type_info,
+                                      NULL, NULL, NULL);
     g_base_info_unref(type_info);
 
     return rb_field_value;
@@ -95,17 +108,30 @@ rb_gi_field_info_set_field_raw(GIFieldInfo *info, gpointer memory,
 {
     GIArgument field_value;
     GITypeInfo *type_info;
+    GITypeTag type_tag;
     gboolean succeeded;
 
     type_info = g_field_info_get_type(info);
-    RVAL2GI_VALUE_ARGUMENT(&field_value, type_info, rb_field_value);
+    type_tag = g_type_info_get_tag(type_info);
+    RVAL2GI_VALUE_ARGUMENT(&field_value, type_info, rb_field_value, Qnil);
 
     succeeded = g_field_info_set_field(info, memory, &field_value);
-    rb_gi_value_argument_free(&field_value, type_info);
+    if (!succeeded) {
+        if (type_tag == GI_TYPE_TAG_UTF8) {
+            int offset;
+            offset = g_field_info_get_offset(info);
+            G_STRUCT_MEMBER(gchar *, memory, offset) = field_value.v_string;
+            succeeded = TRUE;
+        }
+    }
+    rb_gi_value_argument_free(rb_field_value, &field_value, type_info);
     g_base_info_unref(type_info);
 
     if (!succeeded) {
-        rb_raise(rb_eArgError, "failed to set field value");
+        rb_raise(rb_eArgError,
+                 "failed to set field value: %s[%s]",
+                 g_base_info_get_name(info),
+                 g_type_tag_to_string(type_tag));
     }
 }
 

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012-2014  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2012-2015  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
@@ -220,6 +220,10 @@ fill_metadata_rb_arg_index(GPtrArray *args_metadata)
 
         metadata = g_ptr_array_index(args_metadata, i);
 
+        if (metadata->callback_p) {
+            continue;
+        }
+
         if (metadata->closure_p) {
             continue;
         }
@@ -382,8 +386,36 @@ in_callback_argument_from_ruby(RBGIArgMetadata *metadata, GArray *in_args)
     gpointer callback;
     GIArgInfo *arg_info;
     GIArgument *callback_argument;
+    GIArgument *closure_argument = NULL;
+    GIArgument *destroy_argument = NULL;
 
     arg_info = &(metadata->arg_info);
+
+    callback_argument = &(g_array_index(in_args,
+                                        GIArgument,
+                                        metadata->in_arg_index));
+    if (metadata->closure_in_arg_index != -1) {
+        closure_argument = &(g_array_index(in_args,
+                                           GIArgument,
+                                           metadata->closure_in_arg_index));
+    }
+    if (metadata->destroy_in_arg_index != -1) {
+        destroy_argument = &(g_array_index(in_args,
+                                           GIArgument,
+                                           metadata->destroy_in_arg_index));
+    }
+
+    if (!rb_block_given_p() && g_arg_info_may_be_null(arg_info)) {
+        callback_argument->v_pointer = NULL;
+        if (closure_argument) {
+            closure_argument->v_pointer = NULL;
+        }
+        if (destroy_argument) {
+            destroy_argument->v_pointer = NULL;
+        }
+        return;
+    }
+
     callback = find_callback_function(arg_info);
     if (!callback) {
         GITypeInfo type_info;
@@ -398,46 +430,38 @@ in_callback_argument_from_ruby(RBGIArgMetadata *metadata, GArray *in_args)
                  RVAL2CSTR(rb_type_name),
                  g_base_info_get_name(arg_info));
     }
-
-    callback_argument = &(g_array_index(in_args,
-                                        GIArgument,
-                                        metadata->in_arg_index));
     callback_argument->v_pointer = callback;
 
-    if (metadata->closure_in_arg_index != -1) {
+    if (closure_argument) {
         RBGICallbackData *callback_data;
-        GIArgument *closure_argument;
 
         callback_data = ALLOC(RBGICallbackData);
         callback_data->metadata = metadata;
         callback_data->rb_callback = rb_block_proc();
         callback_data_guard_from_gc(callback_data);
-        closure_argument = &(g_array_index(in_args,
-                                           GIArgument,
-                                           metadata->closure_in_arg_index));
         closure_argument->v_pointer = callback_data;
     }
 
-    if (metadata->destroy_in_arg_index != -1) {
-        GIArgument *destroy_argument;
-        destroy_argument = &(g_array_index(in_args,
-                                           GIArgument,
-                                           metadata->destroy_in_arg_index));
+    if (destroy_argument) {
         destroy_argument->v_pointer = destroy_notify;
     }
 }
 
 static void
 in_argument_from_ruby(RBGIArgMetadata *metadata, VALUE rb_arguments,
-                      GArray *in_args, GPtrArray *args_metadata)
+                      GArray *in_args, GPtrArray *args_metadata,
+                      VALUE self)
 {
+    if (metadata->callback_p && !metadata->destroy_p) {
+        in_callback_argument_from_ruby(metadata, in_args);
+        return;
+    }
+
     if (metadata->rb_arg_index == -1) {
         return;
     }
 
-    if (metadata->callback_p) {
-        in_callback_argument_from_ruby(metadata, in_args);
-    } else if (metadata->array_p) {
+    if (metadata->array_p) {
         GIArgument *array_argument;
         GIArgument *length_argument = NULL;
         GIArgInfo *length_arg_info = NULL;
@@ -475,7 +499,8 @@ in_argument_from_ruby(RBGIArgMetadata *metadata, VALUE rb_arguments,
         argument = &(g_array_index(in_args, GIArgument, metadata->in_arg_index));
         RVAL2GI_IN_ARGUMENT(argument,
                             &(metadata->arg_info),
-                            rb_argument);
+                            rb_argument,
+                            self);
     }
 }
 
@@ -500,7 +525,7 @@ arg_metadata_free(gpointer data)
 }
 
 static void
-arguments_from_ruby(GICallableInfo *info, VALUE rb_arguments,
+arguments_from_ruby(GICallableInfo *info, VALUE self, VALUE rb_arguments,
                     GArray *in_args, GArray *out_args,
                     GPtrArray *args_metadata)
 {
@@ -516,7 +541,7 @@ arguments_from_ruby(GICallableInfo *info, VALUE rb_arguments,
         metadata = g_ptr_array_index(args_metadata, i);
         if (metadata->in_arg_index != -1) {
             in_argument_from_ruby(metadata, rb_arguments,
-                                  in_args, args_metadata);
+                                  in_args, args_metadata, self);
         } else {
             out_argument_from_ruby(metadata, out_args);
         }
@@ -563,33 +588,11 @@ out_arguments_to_ruby(GICallableInfo *callable_info,
             continue;
         }
 
-        if (metadata->array_p) {
-            GIArgument *length_argument = NULL;
-            GIArgInfo *length_arg_info = NULL;
-
-            if (metadata->array_length_in_arg_index != -1) {
-                RBGIArgMetadata *length_metadata;
-                length_metadata =
-                    g_ptr_array_index(args_metadata,
-                                      metadata->array_length_arg_index);
-                if (length_metadata->direction == GI_DIRECTION_OUT) {
-                    length_argument =
-                        &g_array_index(in_args, GIArgument,
-                                       length_metadata->out_arg_index);
-                } else {
-                    length_argument =
-                        &g_array_index(in_args, GIArgument,
-                                       length_metadata->in_arg_index);
-                }
-                length_arg_info = &(length_metadata->arg_info);
-            }
-            rb_argument = GI_OUT_ARRAY_ARGUMENT2RVAL(argument,
-                                                     length_argument,
-                                                     &(metadata->arg_info),
-                                                     length_arg_info);
-        } else {
-            rb_argument = GI_OUT_ARGUMENT2RVAL(argument, &(metadata->arg_info));
-        }
+        rb_argument = GI_OUT_ARGUMENT2RVAL(argument,
+                                           &(metadata->arg_info),
+                                           in_args,
+                                           out_args,
+                                           args_metadata);
         rb_ary_push(rb_out_args, rb_argument);
     }
 
@@ -609,7 +612,8 @@ arguments_init(GArray **in_args, GArray **out_args, GPtrArray **args_metadata)
 }
 
 static void
-arguments_free(GArray *in_args, GArray *out_args, GPtrArray *args_metadata)
+arguments_free(VALUE rb_arguments,
+               GArray *in_args, GArray *out_args, GPtrArray *args_metadata)
 {
     guint i;
 
@@ -622,9 +626,18 @@ arguments_free(GArray *in_args, GArray *out_args, GPtrArray *args_metadata)
             metadata->direction == GI_DIRECTION_INOUT) {
             in_arg_index = metadata->in_arg_index;
             if (in_arg_index != -1) {
+                gint rb_arg_index;
+                VALUE rb_argument = Qnil;
                 GIArgument *argument;
+
+                rb_arg_index = metadata->rb_arg_index;
+                if (rb_arg_index > 0) {
+                    rb_argument = RARRAY_PTR(rb_arguments)[rb_arg_index];
+                }
                 argument = &(g_array_index(in_args, GIArgument, in_arg_index));
-                rb_gi_in_argument_free(argument, &(metadata->arg_info));
+                rb_gi_in_argument_free(rb_argument,
+                                       argument,
+                                       &(metadata->arg_info));
             }
         } else {
             GIArgument *argument;
@@ -643,7 +656,7 @@ typedef struct {
     GIFunctionInfo *info;
     GArray *in_args;
     GArray *out_args;
-    GIArgument *return_value;
+    GIArgument return_value;
     GError **error;
     gboolean succeeded;
 } InvokeData;
@@ -657,7 +670,7 @@ rb_gi_function_info_invoke_raw_call(InvokeData *data)
                                data->in_args->len,
                                (GIArgument *)((void *)(data->out_args->data)),
                                data->out_args->len,
-                               data->return_value,
+                               &(data->return_value),
                                data->error);
 }
 
@@ -692,7 +705,7 @@ gobject_based_p(GIBaseInfo *info)
 
 VALUE
 rb_gi_function_info_invoke_raw(GIFunctionInfo *info, VALUE rb_options,
-                               GIArgument *return_value)
+                               GIArgument *return_value, VALUE *rb_return_value)
 {
     GICallableInfo *callable_info;
     GIArgument receiver;
@@ -703,6 +716,7 @@ rb_gi_function_info_invoke_raw(GIFunctionInfo *info, VALUE rb_options,
     GError *error = NULL;
     gboolean unlock_gvl = FALSE;
     VALUE rb_receiver, rb_arguments, rb_unlock_gvl;
+    gboolean rb_receiver_is_class = FALSE;
 
     if (RB_TYPE_P(rb_options, RUBY_T_ARRAY)) {
         rb_receiver = Qnil;
@@ -726,6 +740,12 @@ rb_gi_function_info_invoke_raw(GIFunctionInfo *info, VALUE rb_options,
     } else {
         if (gobject_based_p((GIBaseInfo *)info)) {
             receiver.v_pointer = RVAL2GOBJ(rb_receiver);
+        } else if (RVAL2CBOOL(rb_obj_is_kind_of(rb_receiver, rb_cClass)) &&
+                   rb_respond_to(rb_receiver, rb_intern("gtype"))) {
+            GObjectClass *object_class;
+            rb_receiver_is_class = TRUE;
+            object_class = g_type_class_ref(CLASS2GTYPE(rb_receiver));
+            receiver.v_pointer = object_class;
         } else {
             receiver.v_pointer = DATA_PTR(rb_receiver);
         }
@@ -740,14 +760,13 @@ rb_gi_function_info_invoke_raw(GIFunctionInfo *info, VALUE rb_options,
     if (receiver.v_pointer) {
         g_array_append_val(in_args, receiver);
     }
-    arguments_from_ruby(callable_info, rb_arguments,
+    arguments_from_ruby(callable_info, rb_receiver, rb_arguments,
                         in_args, out_args, args_metadata);
     {
         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(
@@ -757,6 +776,25 @@ rb_gi_function_info_invoke_raw(GIFunctionInfo *info, VALUE rb_options,
             rb_gi_function_info_invoke_raw_call(&data);
         }
         succeeded = data.succeeded;
+
+        if (rb_receiver_is_class) {
+            g_type_class_unref(receiver.v_pointer);
+        }
+
+        if (return_value) {
+            *return_value = data.return_value;
+        }
+        if (rb_return_value) {
+            if (succeeded) {
+                *rb_return_value = GI_RETURN_ARGUMENT2RVAL(callable_info,
+                                                           &(data.return_value),
+                                                           in_args,
+                                                           out_args,
+                                                           args_metadata);
+            } else {
+                *rb_return_value = Qnil;
+            }
+        }
     }
 
     if (succeeded) {
@@ -764,7 +802,7 @@ rb_gi_function_info_invoke_raw(GIFunctionInfo *info, VALUE rb_options,
                                             in_args, out_args,
                                             args_metadata);
     }
-    arguments_free(in_args, out_args, args_metadata);
+    arguments_free(rb_arguments, in_args, out_args, args_metadata);
     if (!succeeded) {
         RG_RAISE_ERROR(error);
     }
@@ -784,8 +822,6 @@ static VALUE
 rg_invoke(VALUE self, VALUE rb_options)
 {
     GIFunctionInfo *info;
-    GICallableInfo *callable_info;
-    GIArgument return_value;
     VALUE rb_out_args;
     VALUE rb_return_value;
 
@@ -793,14 +829,13 @@ rg_invoke(VALUE self, VALUE rb_options)
     /* TODO: use rb_protect() */
     rb_out_args = rb_gi_function_info_invoke_raw(info,
                                                  rb_options,
-                                                 &return_value);
-
-    callable_info = (GICallableInfo *)info;
-    rb_return_value = GI_RETURN_ARGUMENT2RVAL(&return_value, callable_info);
+                                                 NULL,
+                                                 &rb_return_value);
 
     if (NIL_P(rb_out_args)) {
         return rb_return_value;
     } else {
+        GICallableInfo *callable_info = (GICallableInfo *)info;
         GITypeInfo return_value_info;
         g_callable_info_load_return_type(callable_info, &return_value_info);
         if (g_type_info_get_tag(&return_value_info) != GI_TYPE_TAG_VOID) {