gobject-introspection 3.4.0 → 3.4.5

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  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
@@ -20,6 +20,8 @@
 
 #pragma once
 
+G_GNUC_INTERNAL VALUE
+rb_gi_arguments_in_to_ruby(RBGIArguments *args);
 G_GNUC_INTERNAL void
 rb_gi_arguments_in_init(RBGIArguments *args);
 G_GNUC_INTERNAL void

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  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
@@ -40,6 +40,7 @@ typedef void (*RBGIArgFreeFunc)(RBGIArguments *args,
 
 typedef struct {
     GITypeInfo *info;
+    gboolean pointer_p;
     GITypeTag tag;
     GIBaseInfo *interface_info;
     GIInfoType interface_type;
@@ -64,7 +65,6 @@ struct RBGIArgMetadata_ {
     gboolean array_length_p;
     gboolean interface_p;
     gboolean may_be_null_p;
-    gboolean pointer_p;
     gboolean caller_allocates_p;
     gboolean zero_terminated_p;
     gboolean output_buffer_p;
@@ -101,6 +101,10 @@ G_GNUC_INTERNAL VALUE
 rb_gi_arguments_get_rb_return_value(RBGIArguments *args,
                                     GIArgument *return_value);
 
+G_GNUC_INTERNAL void
+rb_gi_arguments_fill_raw_out_gerror(RBGIArguments *args,
+                                    VALUE rb_error);
+
 G_GNUC_INTERNAL void
 rb_gi_arguments_fill_raw_results(RBGIArguments *args,
                                  VALUE rb_results,

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  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
@@ -22,8 +22,8 @@
 
 typedef struct RBGICallback_ {
     GIArgInfo *arg_info;
-    GITypeInfo *type_info;
     GICallbackInfo *callback_info;
+    gchar *method_name;
     ffi_cif cif;
     ffi_closure *closure;
 } RBGICallback;
@@ -34,8 +34,11 @@ rb_gi_callback_init(VALUE rb_mGI);
 G_GNUC_INTERNAL gpointer
 rb_gi_callback_find(GIArgInfo *info);
 
+G_GNUC_INTERNAL RBGICallback *
+rb_gi_callback_new(GICallbackInfo *callback_info,
+                   const gchar *method_name);
+
 G_GNUC_INTERNAL RBGICallbackData *
 rb_gi_callback_data_new(RBGIArguments *args,
                         RBGICallback *callback,
                         RBGIArgMetadata *metadata);
-

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-repository.c

@@ -228,7 +228,7 @@ rg_find(int argc, VALUE *argv, VALUE self)
         VALUE rb_gtype;
         GType gtype;
         rb_gtype = argv[0];
-        gtype = NUM2UINT(rb_gtype);
+        gtype = rbgobj_gtype_from_ruby(rb_gtype);
         info = g_irepository_find_by_gtype(SELF(self), gtype);
     } else {
         VALUE rb_namespace, rb_name;

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
@@ -84,7 +84,7 @@ rb_gi_struct_get_raw(VALUE rb_struct, GType gtype)
         if (rb_respond_to(rb_struct_class, rb_intern("gtype"))) {
             VALUE rb_gtype;
             rb_gtype = rb_funcall(rb_struct_class, rb_intern("gtype"), 0);
-            gtype = NUM2ULONG(rb_funcall(rb_gtype, rb_intern("to_i"), 0));
+            gtype = rbgobj_gtype_from_ruby(rb_gtype);
         }
     }
     if (gtype == G_TYPE_NONE) {
@@ -146,7 +146,7 @@ rb_gi_struct_info_to_ruby(GIStructInfo *info,
         GType gtype;
 
         rb_gtype = rb_funcall(rb_class, rb_intern("gtype"), 0);
-        gtype = NUM2ULONG(rb_funcall(rb_gtype, rb_intern("to_i"), 0));
+        gtype = rbgobj_gtype_from_ruby(rb_gtype);
         return BOXED2RVAL(object, gtype);
     }
 
@@ -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
 
@@ -681,10 +697,10 @@ module GObjectIntrospection
       def normalize_arguments!(arguments, abort_tag)
         arguments.size.times do |i|
           argument = arguments[i]
-          next if argument.nil?
           type = @in_arg_types[i]
           converted_argument = type.try_convert(argument)
           if converted_argument.nil?
+            next if argument.nil?
             if abort_tag
               throw(abort_tag)
             elsif @on_invalid == :fallback
@@ -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