gobject-introspection 3.4.9 → 3.5.0

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012-2019  Ruby-GNOME Project Team
+ *  Copyright (C) 2012-2022  Ruby-GNOME Project Team
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
@@ -39,228 +39,12 @@ rb_gi_is_debug_mode(void)
     return is_debug_mode;
 }
 
-static void
-find_vfunc_info (GIBaseInfo *vfunc_info,
-                 GType implementor_gtype,
-                 gpointer *implementor_vtable_ret,
-                 GIFieldInfo **field_info_ret)
-{
-    GIBaseInfo *ancestor_info = NULL;
-    GIStructInfo *struct_info = NULL;
-    GIFieldInfo *field_info = NULL;
-
-    ancestor_info = g_base_info_get_container(vfunc_info);
-    // ancestor_gtype = g_registered_type_info_get_g_type (
-    //                       (GIRegisteredTypeInfo *) ancestor_info);
-    struct_info = g_object_info_get_class_struct((GIObjectInfo*) ancestor_info);
-    *implementor_vtable_ret = g_type_class_ref(implementor_gtype);
-
-    field_info = g_struct_info_find_field(
-            struct_info, g_base_info_get_name((GIBaseInfo*) vfunc_info));
-
-    if (field_info != NULL) {
-        GITypeInfo *type_info;
-
-        type_info = g_field_info_get_type (field_info);
-        if (g_type_info_get_tag (type_info) == GI_TYPE_TAG_INTERFACE) {
-            *field_info_ret = field_info;
-        } else {
-            g_base_info_unref (field_info);
-        }
-        g_base_info_unref (type_info);
-    }
-
-    g_base_info_unref (struct_info);
-}
-
-static VALUE
-garg2rval(GIArgument *argument, GITypeTag type_tag)
-{
-    switch (type_tag) {
-    case GI_TYPE_TAG_INT32:
-        return INT2FIX(argument->v_int32);
-    default:
-        rb_raise(rb_eTypeError, "garg2rval: not implemented");
-        break;
-    }
-}
-
-static void
-rval2garg(VALUE value, GITypeTag type_tag, GIArgument *argument)
-{
-    switch (type_tag) {
-    case GI_TYPE_TAG_INT32:
-        argument->v_int32 = FIX2INT(value);
-        break;
-    default:
-        rb_raise(rb_eTypeError, "rval2garg: not implemented");
-        break;
-    }
-}
-
-static void
-rval2ffiarg(VALUE value, ffi_arg *arg)
-{
-    switch (TYPE(value)) {
-    case T_NIL:
-        break;
-    case T_FIXNUM:
-    case T_DATA:
-        *arg = FIX2INT(value);
-        break;
-    default:
-        rb_raise(rb_eTypeError, "rval2ffiarg: not implemented");
-        break;
-    }
-}
-
-static void
-ffi_callback(G_GNUC_UNUSED ffi_cif *cif,
-             void *ret,
-             void **raw_args,
-             void *raw_data)
-{
-    GIArgument **args = NULL;
-    RBGIVFuncCallbackData *data = NULL;
-    GObject* receiver = NULL;
-    VALUE rb_receiver = 0;
-    gint n_args = 0, n_in_args = 0, n_out_args = 0;
-    size_t i = 0, j = 0;
-    VALUE *in_values = NULL;
-    VALUE rb_ret;
-    GIArgInfo arg_info;
-    GITypeInfo type_info;
-    GITypeTag type_tag;
-    GIDirection direction;
-    gboolean ret_type_is_void;
-
-    args = (GIArgument **) raw_args;
-    data = (RBGIVFuncCallbackData *) raw_data;
-
-    receiver = G_OBJECT(args[0]->v_pointer);
-    rb_receiver = GOBJ2RVAL(receiver);
-
-    n_args = g_callable_info_get_n_args(data->callable_info);
-    in_values = (VALUE *) malloc(n_args * sizeof(VALUE));
-    in_values[0] = data->name;
-    n_in_args++;
-
-    for (i = 1, j = 1; i < n_args; i++) {
-        g_callable_info_load_arg(data->callable_info, i, &arg_info);
-        g_arg_info_load_type(&arg_info, &type_info);
-        type_tag = g_type_info_get_tag(&type_info);
-        direction = g_arg_info_get_direction(&arg_info);
-
-        if (type_tag == GI_TYPE_TAG_VOID) continue;
-
-        if (direction == GI_DIRECTION_OUT || direction == GI_DIRECTION_INOUT)
-            n_out_args++;
-
-        if (direction == GI_DIRECTION_OUT) continue;
-
-        in_values[j] = garg2rval(args[i], type_tag);
-        j++; n_in_args++;
-    }
-
-    // result = rb_funcall(rb_receiver, id_send, 1, data->name);
-    rb_ret = rb_funcallv(rb_receiver, id_send, n_in_args, in_values);
-
-    g_callable_info_load_return_type(data->callable_info, &type_info);
-    ret_type_is_void = g_type_info_get_tag(&type_info) == GI_TYPE_TAG_VOID;
-
-    if (n_out_args == 0 && ret_type_is_void) {
-        // do nothing
-    } else if (n_out_args == 0) {
-        rval2ffiarg(rb_ret, ret);
-    } else if (n_out_args == 1 && ret_type_is_void) {
-        for (i = 1; i < n_args; i++) {
-            g_callable_info_load_arg(data->callable_info, i, &arg_info);
-            g_arg_info_load_type(&arg_info, &type_info);
-            type_tag = g_type_info_get_tag(&type_info);
-            direction = g_arg_info_get_direction(&arg_info);
-
-            if (type_tag == GI_TYPE_TAG_VOID || direction == GI_DIRECTION_IN)
-                continue;
-
-            rval2garg(rb_ret, type_tag, *(GIArgument **) args[i]);
-            break;
-        }
-    } else {
-        if (TYPE(rb_ret) != T_ARRAY) {
-            rb_raise(rb_eTypeError, "return type should be Array");
-        }
-
-        for (i = 1, j = 0; i < n_args; i++) {
-            g_callable_info_load_arg(data->callable_info, i, &arg_info);
-            g_arg_info_load_type(&arg_info, &type_info);
-            type_tag = g_type_info_get_tag(&type_info);
-            direction = g_arg_info_get_direction(&arg_info);
-
-            if (type_tag == GI_TYPE_TAG_VOID || direction == GI_DIRECTION_IN)
-                continue;
-
-            rval2garg(rb_ary_entry(rb_ret, j), type_tag, *(GIArgument **) args[i]);
-            j++;
-        }
-    }
-
-    free(in_values);
-}
-
-static VALUE
-rb_gi_hook_up_vfunc(G_GNUC_UNUSED VALUE self,
-                    VALUE rb_name,
-                    VALUE rb_vfunc_info,
-                    VALUE rb_gtype)
-{
-    GIVFuncInfo *vfunc_info = NULL;
-    GType gtype = 0;
-    gpointer implementor_vtable = NULL;
-    GIFieldInfo *field_info = NULL;
-
-    vfunc_info = RVAL2GI_BASE_INFO(rb_vfunc_info);
-    gtype = NUM2LONG(rb_gtype);
-    g_assert(G_TYPE_IS_CLASSED(gtype));
-
-    find_vfunc_info(vfunc_info, gtype, &implementor_vtable, &field_info);
-
-    if (field_info != NULL) {
-        GITypeInfo *type_info = NULL;
-        GIBaseInfo *interface_info = NULL;
-        RBGIVFuncCallbackData *data = NULL;
-        gint offset = 0;
-        gpointer *method_ptr = NULL;
-
-        type_info = g_field_info_get_type(field_info);
-
-        interface_info = g_type_info_get_interface(type_info);
-        g_assert(g_base_info_get_type(interface_info) == GI_INFO_TYPE_CALLBACK);
-
-        data = ALLOC(RBGIVFuncCallbackData);
-        data->name = rb_name;
-        data->callable_info = g_base_info_ref(interface_info);
-        data->closure = g_callable_info_prepare_closure(
-                interface_info, &(data->cif), ffi_callback, data);
-
-        if (data->closure) {
-            offset = g_field_info_get_offset(field_info);
-            method_ptr = G_STRUCT_MEMBER_P(implementor_vtable, offset);
-
-            *method_ptr = data->closure;
-        }
-
-        g_base_info_unref (interface_info);
-        g_base_info_unref (type_info);
-        g_base_info_unref (field_info);
-    }
-
-    return Qnil;
-}
-
 void
 Init_gobject_introspection(void)
 {
-    VALUE RG_TARGET_NAMESPACE;
+#ifdef HAVE_RB_EXT_RACTOR_SAFE
+    rb_ext_ractor_safe(true);
+#endif
 
     id_send = rb_intern("__send__");
 
@@ -271,7 +55,7 @@ Init_gobject_introspection(void)
         }
     }
 
-    RG_TARGET_NAMESPACE = rb_define_module("GObjectIntrospection");
+    VALUE RG_TARGET_NAMESPACE = rb_define_module("GObjectIntrospection");
 
     rb_define_const(RG_TARGET_NAMESPACE, "BUILD_VERSION",
                     rb_ary_new3(3,
@@ -279,8 +63,6 @@ Init_gobject_introspection(void)
                                 INT2FIX(GI_MINOR_VERSION),
                                 INT2FIX(GI_MICRO_VERSION)));
 
-    rb_gi_argument_init();
-
     rb_gi_array_type_init(RG_TARGET_NAMESPACE);
     rb_gi_type_tag_init(RG_TARGET_NAMESPACE);
     rb_gi_base_info_init(RG_TARGET_NAMESPACE);
@@ -288,6 +70,4 @@ Init_gobject_introspection(void)
     rb_gi_loader_init(RG_TARGET_NAMESPACE);
 
     rb_gi_callback_init(RG_TARGET_NAMESPACE);
-
-    rb_define_module_function(RG_TARGET_NAMESPACE, "hook_up_vfunc", rb_gi_hook_up_vfunc, 3);
 }

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

@@ -1,4 +1,4 @@
-# Copyright (C) 2019  Ruby-GNOME Project Team
+# Copyright (C) 2019-2021  Ruby-GNOME Project Team
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -18,7 +18,7 @@ module GObjectIntrospection
   class FunctionInfo
     def inspect
       super.gsub(/>\z/) do
-        " unlock_gvl?=#{unlock_gvl?.inspect}>"
+        " lock_gvl_default=#{lock_gvl?.inspect}>"
       end
     end
   end

data/lib/gobject-introspection/loader.rb

@@ -24,6 +24,9 @@ module GObjectIntrospection
         loader.version = options[:version]
         loader.load(namespace)
       end
+
+      def initialize_instance_post(object)
+      end
     end
 
     attr_accessor :version
@@ -35,14 +38,16 @@ module GObjectIntrospection
     def load(namespace)
       repository = Repository.default
       repository.require(namespace, @version)
-      pre_load(repository, namespace)
-      repository.each(namespace) do |info|
-        load_info(info) if info.is_a?(InterfaceInfo)
-      end
-      repository.each(namespace) do |info|
-        load_info(info) unless info.is_a?(InterfaceInfo)
+      prepare_class(@base_module) do
+        pre_load(repository, namespace)
+        repository.each(namespace) do |info|
+          load_info(info) if info.is_a?(InterfaceInfo)
+        end
+        repository.each(namespace) do |info|
+          load_info(info) unless info.is_a?(InterfaceInfo)
+        end
+        post_load(repository, namespace)
       end
-      post_load(repository, namespace)
     end
 
     private
@@ -85,23 +90,28 @@ module GObjectIntrospection
     end
 
     def define_module_function(target_module, name, function_info)
-      function_info.unlock_gvl = should_unlock_gvl?(function_info, target_module)
+      prepare_function_info_lock_gvl(function_info, target_module)
       full_method_name = "#{target_module}\#.#{name}"
       invoker = Invoker.new(function_info, name, full_method_name)
-      target_module.module_eval do
-        define_method(name) do |*arguments, &block|
-          invoker.invoke(nil, arguments, block)
+      target_module::INVOKERS[name] = invoker
+      target_module.module_eval(<<-DEFINE_METHOD, __FILE__, __LINE__ + 1)
+        def #{name}(*arguments, &block)
+          INVOKERS["#{name}"].invoke(nil, arguments, block)
         end
-        module_function(name)
-      end
+        module_function(:#{name})
+      DEFINE_METHOD
     end
 
     def define_singleton_method(klass, name, info)
-      info.unlock_gvl = should_unlock_gvl?(info, klass)
+      prepare_function_info_lock_gvl(info, klass)
       invoker = Invoker.new(info, name, "#{klass}.#{name}")
-      klass.singleton_class.__send__(:define_method, name) do |*arguments, &block|
-        invoker.invoke(nil, arguments, block)
-      end
+      singleton_class = klass.singleton_class
+      singleton_class::INVOKERS[name] = invoker
+      singleton_class.class_eval(<<-DEFINE_METHOD, __FILE__, __LINE__ + 1)
+        def #{name}(*arguments, &block)
+          INVOKERS["#{name}"].invoke(nil, arguments, block)
+        end
+      DEFINE_METHOD
     end
 
     def define_struct(info, options={})
@@ -116,8 +126,10 @@ module GObjectIntrospection
                                         :parent => options[:parent],
                                         :size   => size)
       end
-      load_fields(info, klass)
-      load_methods(info, klass)
+      prepare_class(klass) do
+        load_fields(info, klass)
+        load_methods(info, klass)
+      end
     end
 
     def load_struct_info(info)
@@ -129,7 +141,12 @@ module GObjectIntrospection
         end
         unless method_infos.empty?
           base_class = @base_module.const_get(base_class_name)
-          load_methods_method(method_infos, base_class.singleton_class)
+          singleton_class = base_class.singleton_class
+          invokers = singleton_class::INVOKERS.dup
+          singleton_class.__send__(:remove_const, :INVOKERS)
+          singleton_class.const_set(:INVOKERS, invokers)
+          load_methods_method(method_infos, singleton_class)
+          Ractor.make_shareable(singleton_class::INVOKERS) if defined?(Ractor)
         end
       else
         return if info.gtype_struct?
@@ -152,7 +169,9 @@ module GObjectIntrospection
     end
 
     def load_enum_value(value_info, enum_module)
-      enum_module.const_set(value_info.name.upcase, value_info.value)
+      value = value_info.value
+      Ractor.make_shareable(value) if defined?(Ractor)
+      enum_module.const_set(value_info.name.upcase, value)
     end
 
     def define_enum(info)
@@ -216,9 +235,11 @@ module GObjectIntrospection
       klass = self.class.define_class(info.gtype,
                                       rubyish_class_name(info),
                                       @base_module)
-      load_virtual_functions(info, klass)
-      load_fields(info, klass)
-      load_methods(info, klass)
+      prepare_class(klass) do
+        load_virtual_functions(info, klass)
+        load_fields(info, klass)
+        load_methods(info, klass)
+      end
     end
 
     def load_fields(info, klass)
@@ -300,43 +321,46 @@ module GObjectIntrospection
     def load_methods_constructor(infos, klass)
       return if infos.empty?
 
-      call_initialize_post = lambda do |object|
-        initialize_post(object)
-      end
-      invokers = []
+      klass.const_set(:LOADER_CLASS, self.class)
+      invokers = {}
+      klass.const_set(:INITIALIZE_INVOKERS, invokers)
       infos.each do |info|
         name = "initialize_#{info.name}"
-        info.unlock_gvl = should_unlock_gvl?(info, klass)
+        prepare_function_info_lock_gvl(info, klass)
         invoker = Invoker.new(info, name, "#{klass}\##{name}")
-        invokers << invoker
-        klass.__send__(:define_method, name) do |*arguments, &block|
-          invoker.invoke(self, arguments, block)
-          call_initialize_post.call(self)
-        end
-        klass.__send__(:private, name)
-      end
-
-      initialize = lambda do |receiver, arguments, block|
-        invokers.each do |invoker|
-          catch do |tag|
-            invoker.invoke(receiver, arguments.dup, block, tag)
-            call_initialize_post.call(receiver)
-            return
+        invokers[name] = invoker
+        klass.class_eval(<<-DEFINE_METHOD, __FILE__, __LINE__ + 1)
+          def #{name}(*arguments, &block)
+            invoker = INITIALIZE_INVOKERS["#{name}"]
+            invoker.invoke(self, arguments, block)
+            LOADER_CLASS.initialize_instance_post(self)
           end
+          private :#{name}
+        DEFINE_METHOD
+      end
+
+      klass.class_eval(<<-DEFINE_METHOD, __FILE__, __LINE__ + 1)
+        def initialize(*arguments, &block)
+          invokers = INITIALIZE_INVOKERS
+          invokers.values.each do |invoker|
+            catch do |tag|
+              invoker.invoke(self, arguments.dup, block, tag)
+              LOADER_CLASS.initialize_instance_post(self)
+              return
+            end
+          end
+          message = "wrong arguments: "
+          message << "\#{self.class.name}#initialize("
+          message << arguments.collect(&:inspect).join(", ")
+          message << "): "
+          message << "available signatures"
+          invokers.each do |invoker|
+            message << ": \#{invoker.signature}"
+          end
+          raise ArgumentError, message
         end
-        message = "wrong arguments: "
-        message << "#{klass.name}#initialize("
-        message << arguments.collect(&:inspect).join(", ")
-        message << "): "
-        message << "available signatures"
-        invokers.each do |invoker|
-          message << ": #{invoker.signature}"
-        end
-        raise ArgumentError, message
-      end
-      klass.__send__(:define_method, "initialize") do |*arguments, &block|
-        initialize.call(self, arguments, block)
-      end
+      DEFINE_METHOD
+      Ractor.make_shareable(klass::INITIALIZE_INVOKERS) if defined?(Ractor)
     end
 
     def load_virtual_functions(info, klass)
@@ -353,9 +377,6 @@ module GObjectIntrospection
       name.scan(/[A-Z]+[a-z\d]+/).collect(&:downcase).join("_")
     end
 
-    def initialize_post(object)
-    end
-
     def rubyish_method_name(function_info, options={})
       name = function_info.name
       if options[:prefix]
@@ -498,8 +519,12 @@ module GObjectIntrospection
       end
     end
 
-    def should_unlock_gvl?(function_info, klass)
-      false
+    def prepare_function_info_lock_gvl(function_info, target_module)
+      # For backward compatiblity
+      if respond_to?(:should_unlock_gvl?)
+        function_info.lock_gvl_default =
+          !should_unlock_gvl?(function_info, target_module)
+      end
     end
 
     def load_methods_method(infos, klass)
@@ -522,12 +547,18 @@ module GObjectIntrospection
     end
 
     def define_method(info, klass, method_name)
-      info.unlock_gvl = should_unlock_gvl?(info, klass)
+      return if method_name.empty?
+      prepare_function_info_lock_gvl(info, klass)
       remove_existing_method(klass, method_name)
       invoker = Invoker.new(info, method_name, "#{klass}\##{method_name}")
-      klass.__send__(:define_method, method_name) do |*arguments, &block|
-        invoker.invoke(self, arguments, block)
-      end
+      invokers = klass::INVOKERS
+      invokers[method_name] = invoker
+      klass.class_eval(<<-DEFINE_METHOD, __FILE__, __LINE__ + 1)
+        def #{method_name}(*arguments, &block)
+          invoker = INVOKERS["#{method_name}"]
+          invoker.invoke(self, arguments, block)
+        end
+      DEFINE_METHOD
     end
 
     def define_equal_style_setter(info, klass, method_name)
@@ -540,9 +571,11 @@ module GObjectIntrospection
 
     def define_inspect(info, klass, method_name)
       if method_name == "to_s" and info.n_args.zero?
-        klass.__send__(:define_method, "inspect") do ||
-          super().gsub(/\>\z/) {" #{to_s}>"}
-        end
+        klass.class_eval(<<-DEFINE_METHOD, __FILE__, __LINE__ + 1)
+          def inspect
+            super.gsub(/>\z/) {" \#{to_s}>"}
+          end
+        DEFINE_METHOD
       end
     end
 
@@ -561,8 +594,10 @@ module GObjectIntrospection
         self.class.define_interface(info.gtype,
                                     rubyish_class_name(info),
                                     @base_module)
-      load_virtual_functions(info, interface_module)
-      load_methods(info, interface_module)
+      prepare_class(interface_module) do
+        load_virtual_functions(info, interface_module)
+        load_methods(info, interface_module)
+      end
     end
 
     def load_constant_info(info)
@@ -576,8 +611,44 @@ module GObjectIntrospection
     def load_union_info(info)
       return if info.gtype == GLib::Type::NONE
       klass = self.class.define_class(info.gtype, info.name, @base_module)
-      load_fields(info, klass)
-      load_methods(info, klass)
+      prepare_class(klass) do
+        load_fields(info, klass)
+        load_methods(info, klass)
+      end
+    end
+
+    def prepare_class(klass)
+      pre_prepare_class(klass)
+      yield
+      post_prepare_class(klass)
+    end
+
+    def pre_prepare_class(klass)
+      klass.const_set(:INVOKERS, {})
+      klass.singleton_class.const_set(:INVOKERS, {})
+    end
+
+    def post_prepare_class(klass)
+      return unless defined?(Ractor)
+      Ractor.make_shareable(klass::INVOKERS)
+      Ractor.make_shareable(klass.singleton_class::INVOKERS)
+    end
+
+    def define_methods_module(name)
+      mod = Module.new
+      @base_module.const_set(name, mod)
+      mod.const_set(:INVOKERS, {})
+      mod
+    end
+
+    def apply_methods_module(mod, target)
+      target.include(mod)
+      post_methods_module(mod)
+    end
+
+    def post_methods_module(mod)
+      return unless defined?(Ractor)
+      Ractor.make_shareable(mod::INVOKERS)
     end
 
     class Invoker
@@ -586,6 +657,7 @@ module GObjectIntrospection
         @method_name = method_name
         @full_method_name = full_method_name
         @prepared = false
+        ensure_prepared if defined?(Ractor)
       end
 
       def invoke(receiver, arguments, block, abort_tag=nil)
@@ -769,7 +841,6 @@ module GObjectIntrospection
         end
         @virtual_function_implementor.implement(implementor_class.gtype,
                                                 name)
-        true
       end
     end
   end