gobject-introspection 3.4.4 → 3.4.5

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

@@ -22,6 +22,7 @@
 
 #include <ruby.h>
 #include <rbgobject.h>
+#include <rbglib2conversions.h>
 #include <glib-enum-types.h>
 
 #include <girffi.h>

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012-2019  Ruby-GNOME Project Team
+ *  Copyright (C) 2012-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
@@ -194,6 +194,17 @@ rg_get_field(VALUE self, VALUE rb_n)
     return GI_BASE_INFO2RVAL_WITH_UNREF(g_struct_info_get_field(info, n));
 }
 
+static VALUE
+rg_find_field(VALUE self, VALUE rb_name)
+{
+    GIStructInfo *info;
+    const gchar *name;
+
+    info = SELF(self);
+    name = RVAL2CSTR(rb_name);
+    return GI_BASE_INFO2RVAL_WITH_UNREF(g_struct_info_find_field(info, name));
+}
+
 static VALUE
 rg_get_field_value(VALUE self, VALUE rb_struct, VALUE rb_n)
 {
@@ -308,6 +319,7 @@ rb_gi_struct_info_init(VALUE rb_mGI, VALUE rb_cGIRegisteredTypeInfo)
 
     RG_DEF_METHOD(n_fields, 0);
     RG_DEF_METHOD(get_field, 1);
+    RG_DEF_METHOD(find_field, 1);
     RG_DEF_METHOD(get_field_value, 2);
     RG_DEF_METHOD(set_field_value, 3);
     RG_DEF_METHOD(n_methods, 0);

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2012-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
@@ -21,7 +21,7 @@
 #include "rb-gi-private.h"
 
 #define RG_TARGET_NAMESPACE rb_cGIVFuncInfo
-#define SELF(self) RVAL2GI_BASE_INFO(self)
+#define SELF(self) RVAL2GI_VFUNC_INFO(self)
 
 GType
 gi_vfunc_info_get_type(void)

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

@@ -22,6 +22,15 @@
 
 #define RG_TARGET_NAMESPACE rb_mGObjectIntrospection
 
+typedef struct {
+    ID name;
+    GICallableInfo *callable_info;
+
+    ffi_cif cif;
+    ffi_closure *closure;
+} RBGIVFuncCallbackData;
+
+static ID id_send;
 static gboolean is_debug_mode = FALSE;
 
 gboolean
@@ -30,11 +39,231 @@ 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;
 
+    id_send = rb_intern("__send__");
+
     {
         const char *rb_gi_debug_env = getenv("RB_GI_DEBUG");
         if (rb_gi_debug_env && strcmp(rb_gi_debug_env, "yes") == 0) {
@@ -59,4 +288,6 @@ 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/loader.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2012-2019  Ruby-GNOME Project Team
+# Copyright (C) 2012-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
@@ -216,6 +216,7 @@ 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)
     end
@@ -338,6 +339,20 @@ module GObjectIntrospection
       end
     end
 
+    def load_virtual_functions(info, klass)
+      klass.extend(VirtualFunctionImplementable)
+      gtype_prefix = rubyish_gtype_name(klass.gtype.name)
+      implementor = VirtualFunctionImplementor.new(self.class,
+                                                   gtype_prefix,
+                                                   info.vfuncs)
+      klass.__send__(:initialize_virtual_function_implementable,
+                     implementor)
+    end
+
+    def rubyish_gtype_name(name)
+      name.scan(/[A-Z]+[a-z\d]+/).collect(&:downcase).join("_")
+    end
+
     def initialize_post(object)
     end
 
@@ -546,6 +561,7 @@ 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)
     end
 
@@ -708,5 +724,53 @@ module GObjectIntrospection
         "#{@full_method_name}: wrong number of arguments (#{detail})"
       end
     end
+
+    class VirtualFunctionImplementor
+      def initialize(loader_class, gtype_prefix, infos)
+        @loader_class = loader_class
+        @gtype_prefix = gtype_prefix
+        @infos = {}
+        prefix = GLib::VIRTUAL_FUNCTION_IMPLEMENTATION_PREFIX
+        infos.each do |info|
+          name = info.name
+          @infos[:"#{prefix}#{name}"] = info
+          @infos[:"#{prefix}#{gtype_prefix}_#{name}"] = info
+        end
+      end
+
+      def implement(implementor_gtype, name)
+        info = @infos[name]
+        return false if info.nil?
+        container = info.container
+        vtable_gtype = container.gtype
+        if container.respond_to?(:class_struct)
+          struct = container.class_struct
+        else
+          return false unless implementor_gtype.type_is_a?(vtable_gtype)
+          struct = container.iface_struct
+        end
+        field = struct.find_field(info.name)
+        @loader_class.implement_virtual_function(field,
+                                                 implementor_gtype,
+                                                 vtable_gtype,
+                                                 name.to_s)
+        true
+      end
+    end
+
+    module VirtualFunctionImplementable
+      def initialize_virtual_function_implementable(implementor)
+        @virtual_function_implementor = implementor
+      end
+
+      def implement_virtual_function(implementor_class, name)
+        unless instance_variable_defined?(:@virtual_function_implementor)
+          return false
+        end
+        @virtual_function_implementor.implement(implementor_class.gtype,
+                                                name)
+        true
+      end
+    end
   end
 end

data/test/run-test.rb

@@ -32,4 +32,8 @@ run_test(__dir__,
     puts("Omit because typelib file doesn't exist: #{$!.message}")
     exit(true)
   end
+
+  module Gio
+    GObjectIntrospection::Loader.load("Gio", self)
+  end
 end

data/test/test-base-info.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2012  Ruby-GNOME2 Project Team
+# Copyright (C) 2012-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
@@ -28,4 +28,8 @@ class TestBaseInfo < Test::Unit::TestCase
   def test_namespace
     assert_equal("GObject", @info.namespace)
   end
+
+  def test_container
+    assert_equal("Object", @info.vfuncs.first.container.name)
+  end
 end

data/test/test-callable-info.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2012  Ruby-GNOME2 Project Team
+# Copyright (C) 2012-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
@@ -21,6 +21,12 @@ class TestCallableInfo < Test::Unit::TestCase
     @info = @repository.find("GObject", "signal_name")
   end
 
+  def test_can_throw_gerror
+    assert do
+      not @info.can_throw_gerror?
+    end
+  end
+
   def test_return_type
     assert_kind_of(GObjectIntrospection::TypeInfo,
                    @info.return_type)