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

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

@@ -59,6 +59,21 @@ gi_function_info_get_type(void)
     return type;
 }
 
+static VALUE
+rg_set_unlock_gvl(VALUE self, VALUE rb_boolean)
+{
+    return rb_iv_set(self, "unlock_gvl", rb_boolean);
+}
+
+static VALUE
+rg_unlock_gvl_p(VALUE self)
+{
+    if (!RVAL2CBOOL(rb_ivar_defined(self, rb_intern("unlock_gvl")))) {
+        rb_iv_set(self, "unlock_gvl", Qfalse);
+    }
+    return rb_iv_get(self, "unlock_gvl");
+}
+
 static VALUE
 rg_symbol(VALUE self)
 {
@@ -665,10 +680,12 @@ out_argument_to_raw_data_interface(GICallableInfo *callable_info,
                                    GIArgument *argument,
                                    gpointer result,
                                    GITypeInfo *type_info,
-                                   G_GNUC_UNUSED GITransfer transfer /* TODO */)
+                                   G_GNUC_UNUSED GITransfer transfer /* TODO */,
+                                   gboolean is_return_value)
 {
     GIBaseInfo *interface_info;
     GIInfoType interface_type;
+    GIFFIReturnValue *ffi_return_value = result;
 
     interface_info = g_type_info_get_interface(type_info);
     interface_type = g_base_info_get_type(interface_info);
@@ -687,7 +704,11 @@ out_argument_to_raw_data_interface(GICallableInfo *callable_info,
                  g_base_info_get_name(interface_info));
         break;
     case GI_INFO_TYPE_ENUM:
-      *((gint *)result) = argument->v_int;
+      if (is_return_value) {
+          ffi_return_value->v_ulong = argument->v_int;
+      } else {
+          *((gint *)result) = argument->v_int;
+      }
       break;
     case GI_INFO_TYPE_FLAGS:
     case GI_INFO_TYPE_OBJECT:
@@ -725,15 +746,50 @@ out_argument_to_raw_data_interface(GICallableInfo *callable_info,
     g_base_info_unref(interface_info);
 }
 
+/*
+  We need to cast from different type for return value. (We don't
+  need it for out arguments.) Because of libffi specification:
+
+  https://github.com/libffi/libffi/blob/master/doc/libffi.texi#L190
+
+  @var{rvalue} is a pointer to a chunk of memory that will hold the
+  result of the function call.  This must be large enough to hold the
+  result, no smaller than the system register size (generally 32 or 64
+  bits), and must be suitably aligned; it is the caller's responsibility
+  to ensure this.  If @var{cif} declares that the function returns
+  @code{void} (using @code{ffi_type_void}), then @var{rvalue} is
+  ignored.
+
+  https://github.com/libffi/libffi/blob/master/doc/libffi.texi#L198
+
+  In most situations, @samp{libffi} will handle promotion according to
+  the ABI.  However, for historical reasons, there is a special case
+  with return values that must be handled by your code.  In particular,
+  for integral (not @code{struct}) types that are narrower than the
+  system register size, the return value will be widened by
+  @samp{libffi}.  @samp{libffi} provides a type, @code{ffi_arg}, that
+  can be used as the return type.  For example, if the CIF was defined
+  with a return type of @code{char}, @samp{libffi} will try to store a
+  full @code{ffi_arg} into the return value.
+
+  See also:
+    * https://github.com/ruby-gnome2/ruby-gnome2/issues/758#issuecomment-243149237
+    * https://github.com/libffi/libffi/pull/216
+
+  This ffi_return_value case implementation is based on
+  gi_type_info_extract_ffi_return_value().
+*/
 static void
 out_argument_to_raw_data(GICallableInfo *callable_info,
                          VALUE rb_result,
                          gpointer result,
                          GITypeInfo *type_info,
-                         GITransfer transfer)
+                         GITransfer transfer,
+                         gboolean is_return_value)
 {
     GIArgument argument;
     GITypeTag type_tag;
+    GIFFIReturnValue *ffi_return_value = result;
 
     rb_gi_value_argument_from_ruby(&argument,
                                    type_info,
@@ -745,25 +801,53 @@ out_argument_to_raw_data(GICallableInfo *callable_info,
         g_assert_not_reached();
         break;
       case GI_TYPE_TAG_BOOLEAN:
-        *((gboolean *)result) = argument.v_boolean;
+        if (is_return_value) {
+            ffi_return_value->v_ulong = argument.v_boolean;
+        } else {
+            *((gboolean *)result) = argument.v_boolean;
+        }
         break;
       case GI_TYPE_TAG_INT8:
-        *((gint8 *)result) = argument.v_int8;
+        if (is_return_value) {
+            ffi_return_value->v_long = argument.v_int8;
+        } else {
+            *((gint8 *)result) = argument.v_int8;
+        }
         break;
       case GI_TYPE_TAG_UINT8:
-        *((guint8 *)result) = argument.v_uint8;
+        if (is_return_value) {
+            ffi_return_value->v_ulong = argument.v_uint8;
+        } else {
+            *((guint8 *)result) = argument.v_uint8;
+        }
         break;
       case GI_TYPE_TAG_INT16:
-        *((gint16 *)result) = argument.v_int16;
+        if (is_return_value) {
+            ffi_return_value->v_long = argument.v_int16;
+        } else {
+            *((gint16 *)result) = argument.v_int16;
+        }
         break;
       case GI_TYPE_TAG_UINT16:
-        *((guint16 *)result) = argument.v_uint16;
+        if (is_return_value) {
+            ffi_return_value->v_ulong = argument.v_uint16;
+        } else {
+            *((guint16 *)result) = argument.v_uint16;
+        }
         break;
       case GI_TYPE_TAG_INT32:
-        *((gint32 *)result) = argument.v_int32;
+        if (is_return_value) {
+            ffi_return_value->v_long = argument.v_int32;
+        } else {
+            *((gint32 *)result) = argument.v_int32;
+        }
         break;
       case GI_TYPE_TAG_UINT32:
-        *((guint32 *)result) = argument.v_uint32;
+        if (is_return_value) {
+            ffi_return_value->v_ulong = argument.v_uint32;
+        } else {
+            *((guint32 *)result) = argument.v_uint32;
+        }
         break;
       case GI_TYPE_TAG_INT64:
         *((gint64 *)result) = argument.v_int64;
@@ -778,32 +862,57 @@ out_argument_to_raw_data(GICallableInfo *callable_info,
         *((gdouble *)result) = argument.v_double;
         break;
       case GI_TYPE_TAG_GTYPE:
-        *((gsize *)result) = argument.v_size;
+        if (is_return_value) {
+            ffi_return_value->v_ulong = argument.v_size;
+        } else {
+            *((gsize *)result) = argument.v_size;
+        }
         break;
       case GI_TYPE_TAG_UTF8:
       case GI_TYPE_TAG_FILENAME:
-        *((gchar **)result) = argument.v_string;
+        if (is_return_value) {
+            ffi_return_value->v_ulong = (gulong)(argument.v_string);
+        } else {
+            *((gchar **)result) = argument.v_string;
+        }
         break;
       case GI_TYPE_TAG_ARRAY:
-        *((gpointer *)result) = argument.v_pointer;
+        if (is_return_value) {
+            ffi_return_value->v_ulong = (gulong)(argument.v_pointer);
+        } else {
+            *((gpointer *)result) = argument.v_pointer;
+        }
         break;
       case GI_TYPE_TAG_INTERFACE:
         out_argument_to_raw_data_interface(callable_info,
                                            &argument,
                                            result,
                                            type_info,
-                                           transfer);
+                                           transfer,
+                                           is_return_value);
         break;
       case GI_TYPE_TAG_GLIST:
       case GI_TYPE_TAG_GSLIST:
       case GI_TYPE_TAG_GHASH:
-        *((gpointer *)result) = argument.v_pointer;
+        if (is_return_value) {
+            ffi_return_value->v_ulong = (gulong)(argument.v_pointer);
+        } else {
+            *((gpointer *)result) = argument.v_pointer;
+        }
         break;
       case GI_TYPE_TAG_ERROR:
-        *((GError **)result) = argument.v_pointer;
+        if (is_return_value) {
+            ffi_return_value->v_ulong = (gulong)(argument.v_pointer);
+        } else {
+            *((GError **)result) = argument.v_pointer;
+        }
         break;
       case GI_TYPE_TAG_UNICHAR:
-        *((gunichar *)result) = argument.v_uint32;
+        if (is_return_value) {
+            ffi_return_value->v_ulong = argument.v_uint32;
+        } else {
+            *((gunichar *)result) = argument.v_uint32;
+        }
         break;
       default:
         g_assert_not_reached();
@@ -834,13 +943,15 @@ out_arguments_to_raw_data(GICallableInfo *callable_info,
                                      rb_return_value,
                                      result,
                                      return_type_info,
-                                     transfer);
+                                     transfer,
+                                     TRUE);
         } else {
             out_argument_to_raw_data(callable_info,
                                      RARRAY_AREF(rb_results, i_rb_result),
                                      result,
                                      return_type_info,
-                                     transfer);
+                                     transfer,
+                                     TRUE);
             i_rb_result++;
         }
     }
@@ -866,7 +977,8 @@ out_arguments_to_raw_data(GICallableInfo *callable_info,
                                  RARRAY_AREF(rb_results, i_rb_result),
                                  argument->v_pointer,
                                  type_info,
-                                 transfer);
+                                 transfer,
+                                 FALSE);
         i_rb_result++;
         g_base_info_unref(type_info);
     }
@@ -1194,7 +1306,7 @@ arguments_free(VALUE rb_arguments,
                 GIArgument *argument;
 
                 rb_arg_index = metadata->rb_arg_index;
-                if (rb_arg_index > 0) {
+                if (RARRAY_LEN(rb_arguments) > rb_arg_index) {
                     rb_argument = RARRAY_PTR(rb_arguments)[rb_arg_index];
                 }
                 argument = &(g_array_index(in_args, GIArgument, in_arg_index));
@@ -1267,8 +1379,12 @@ gobject_based_p(GIBaseInfo *info)
 }
 
 VALUE
-rb_gi_function_info_invoke_raw(GIFunctionInfo *info, VALUE rb_options,
-                               GIArgument *return_value, VALUE *rb_return_value)
+rb_gi_function_info_invoke_raw(GIFunctionInfo *info,
+                               VALUE rb_info,
+                               VALUE rb_receiver,
+                               VALUE rb_arguments,
+                               GIArgument *return_value,
+                               VALUE *rb_return_value)
 {
     GICallableInfo *callable_info;
     GIArgument receiver;
@@ -1278,26 +1394,9 @@ rb_gi_function_info_invoke_raw(GIFunctionInfo *info, VALUE rb_options,
     gboolean succeeded;
     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;
-        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);
-    }
-
+    unlock_gvl = RVAL2CBOOL(rb_funcall(rb_info, rb_intern("unlock_gvl?"), 0));
     if (NIL_P(rb_receiver)) {
         receiver.v_pointer = NULL;
     } else {
@@ -1314,9 +1413,6 @@ rb_gi_function_info_invoke_raw(GIFunctionInfo *info, VALUE rb_options,
         }
     }
     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);
@@ -1382,7 +1478,7 @@ rb_gi_function_info_invoke_raw(GIFunctionInfo *info, VALUE rb_options,
 }
 
 static VALUE
-rg_invoke(VALUE self, VALUE rb_options)
+rg_invoke(VALUE self, VALUE rb_arguments)
 {
     GIFunctionInfo *info;
     VALUE rb_out_args;
@@ -1391,7 +1487,9 @@ rg_invoke(VALUE self, VALUE rb_options)
     info = SELF(self);
     /* TODO: use rb_protect() */
     rb_out_args = rb_gi_function_info_invoke_raw(info,
-                                                 rb_options,
+                                                 self,
+                                                 Qnil,
+                                                 rb_arguments,
                                                  NULL,
                                                  &rb_return_value);
 
@@ -1426,6 +1524,9 @@ rb_gi_function_info_init(VALUE rb_mGI, VALUE rb_cGICallableInfo)
     callback_finders = g_ptr_array_new();
     rb_gi_callback_register_finder(source_func_callback_finder);
 
+    RG_DEF_METHOD(set_unlock_gvl, 1);
+    RG_DEF_METHOD_P(unlock_gvl, 0);
+
     RG_DEF_METHOD(symbol, 0);
     RG_DEF_METHOD(flags, 0);
     RG_DEF_METHOD(property, 0);

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

@@ -36,7 +36,7 @@ gi_method_info_get_type(void)
 }
 
 static VALUE
-rg_invoke(VALUE self, VALUE rb_options)
+rg_invoke(VALUE self, VALUE rb_receiver, VALUE rb_arguments)
 {
     GIFunctionInfo *info;
     VALUE rb_out_args;
@@ -46,7 +46,9 @@ rg_invoke(VALUE self, VALUE rb_options)
 
     /* TODO: use rb_protect */
     rb_out_args = rb_gi_function_info_invoke_raw(info,
-                                                 rb_options,
+                                                 self,
+                                                 rb_receiver,
+                                                 rb_arguments,
                                                  NULL,
                                                  &rb_return_value);
 
@@ -76,5 +78,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, 2);
 }

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

@@ -93,7 +93,9 @@ 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,
-                                      VALUE rb_options,
+                                      VALUE rb_info,
+                                      VALUE rb_receiver,
+                                      VALUE rb_arguments,
                                       GIArgument *return_value,
                                       VALUE *rb_return_value);
 

data/lib/gi.rb

@@ -0,0 +1,19 @@
+# Copyright (C) 2016  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"
+
+GI = GObjectIntrospection

data/lib/gobject-introspection.rb

@@ -47,6 +47,16 @@ GObjectIntrospection.prepend_typelib_path(vendor_girepository_dir)
 
 module GObjectIntrospection
   LOG_DOMAIN = "GObjectIntrospection"
+
+  class << self
+    def load(namespace, options={})
+      base_module = Module.new
+      loader = Loader.new(base_module)
+      loader.version = options[:version]
+      loader.load(namespace)
+      base_module
+    end
+  end
 end
 GLib::Log.set_log_domain(GObjectIntrospection::LOG_DOMAIN)
 

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

@@ -41,11 +41,7 @@ module GObjectIntrospection
     end
 
     def require_callback?
-      args.any? do |arg|
-        arg.direction == Direction::IN and
-          arg.scope != ScopeType::INVALID and
-          !arg.may_be_null?
-      end
+      (@require_callback ||= compute_require_callback) == :required
     end
 
     def out_args
@@ -63,6 +59,12 @@ module GObjectIntrospection
       out_args.size
     end
 
+    def have_return_value?
+      return true if return_type.tag != TypeTag::VOID
+      return true if return_type.pointer?
+      not n_out_args.zero?
+    end
+
     private
     def compute_in_args
       array_length_indexes = []
@@ -103,5 +105,17 @@ module GObjectIntrospection
         end
       end
     end
+
+    def compute_require_callback
+      args.each do |arg|
+        if arg.direction == Direction::IN and
+            arg.scope != ScopeType::INVALID and
+            !arg.may_be_null?
+          return :required
+        end
+      end
+
+      :not_required
+    end
   end
 end