gobject-introspection 3.4.4 → 3.4.8

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012-2014  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
@@ -18,8 +18,7 @@
  *  MA  02110-1301  USA
  */
 
-#ifndef RB_GI_CONVERSIONS_H
-#define RB_GI_CONVERSIONS_H
+#pragma once
 
 #define RVAL2GI_REPOSITORY(rb_object) (G_IREPOSITORY(RVAL2GOBJ(rb_object)))
 #define RVAL2GI_REPOSITORY_LOAD_FLAGS(rb_flags) \
@@ -65,6 +64,10 @@
     ((GIFieldInfo *)RVAL2GI_BASE_INFO(rb_object))
 #define RVAL2GI_TYPE_INFO(rb_object)			\
     ((GITypeInfo *)RVAL2GI_BASE_INFO(rb_object))
+#define RVAL2GI_CALLABLE_INFO(rb_object)                \
+    ((GICallableInfo *)RVAL2GI_BASE_INFO(rb_object))
+#define RVAL2GI_VFUNC_INFO(rb_object)			\
+    ((GIVFuncInfo *)RVAL2GI_BASE_INFO(rb_object))
 
 #define GI_INFO_TYPE2RVAL(type)      (GENUM2RVAL(type, G_TYPE_I_INFO_TYPE))
 #define GI_TRANSFER2RVAL(transfer)   (GENUM2RVAL(transfer, G_TYPE_I_TRANSFER))
@@ -100,6 +103,3 @@ VALUE       rb_gi_return_argument_to_ruby     (GICallableInfo *callable_info,
                                                GPtrArray      *args_metadata);
 
 VALUE       rb_gi_array_type_to_ruby          (GIArrayType type);
-
-#endif
-

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012-2018  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
@@ -139,6 +139,57 @@ rg_s_define_error(int argc, VALUE *argv, G_GNUC_UNUSED VALUE klass)
     return G_DEF_ERROR(domain, name, rb_module, rb_parent, gtype);
 }
 
+static VALUE
+rg_s_implement_virtual_function(G_GNUC_UNUSED VALUE klass,
+                                VALUE rb_field_info,
+                                VALUE rb_implementor_gtype,
+                                VALUE rb_vtable_gtype,
+                                VALUE rb_method_name)
+{
+    GIFieldInfo *field_info;
+    GType implementor_gtype;
+    GType vtable_gtype;
+    const gchar *method_name;
+    RBGICallback *callback;
+
+    field_info = RVAL2GI_FIELD_INFO(rb_field_info);
+    implementor_gtype = rbgobj_gtype_from_ruby(rb_implementor_gtype);
+    vtable_gtype = rbgobj_gtype_from_ruby(rb_vtable_gtype);
+    method_name = RVAL2CSTR(rb_method_name);
+
+    {
+        GITypeInfo *type_info;
+        GICallbackInfo *callback_info;
+
+        type_info = g_field_info_get_type(field_info);
+        callback_info = g_type_info_get_interface(type_info);
+        callback = rb_gi_callback_new(callback_info, method_name);
+        g_base_info_unref(callback_info);
+        g_base_info_unref(type_info);
+    }
+
+    {
+        gpointer implementor_struct;
+        gpointer vtable_struct;
+        gint offset;
+        gpointer *method_address;
+
+        implementor_struct = g_type_class_ref(implementor_gtype);
+        if (G_TYPE_IS_INTERFACE(vtable_gtype)) {
+            vtable_struct = g_type_interface_peek(implementor_struct,
+                                                  vtable_gtype);
+        } else {
+            vtable_struct = implementor_struct;
+        }
+        offset = g_field_info_get_offset(field_info);
+        method_address = G_STRUCT_MEMBER_P(vtable_struct, offset);
+        *method_address = callback->closure;
+        g_type_class_unref(implementor_struct);
+    }
+
+    return Qnil;
+}
+
 typedef struct {
     GType type;
     VALUE rb_converters;
@@ -333,6 +384,7 @@ rb_gi_loader_init(VALUE rb_mGI)
     RG_DEF_SMETHOD(define_interface, 3);
     RG_DEF_SMETHOD(define_struct, -1);
     RG_DEF_SMETHOD(define_error, -1);
+    RG_DEF_SMETHOD(implement_virtual_function, 4);
     RG_DEF_SMETHOD(register_boxed_class_converter, 1);
     RG_DEF_SMETHOD(register_object_class_converter, 1);
     RG_DEF_SMETHOD(register_constant_rename_map, 2);

data/ext/gobject-introspection/rb-gi-object-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
@@ -272,6 +272,15 @@ rg_get_constant(VALUE self, VALUE rb_n)
     return GI_BASE_INFO2RVAL_WITH_UNREF(g_object_info_get_constant(info, n));
 }
 
+static VALUE
+rg_class_struct(VALUE self)
+{
+    GIObjectInfo *info;
+
+    info = SELF(self);
+    return GI_BASE_INFO2RVAL_WITH_UNREF(g_object_info_get_class_struct(info));
+}
+
 static VALUE
 rg_unref_function(VALUE self)
 {
@@ -338,6 +347,7 @@ rb_gi_object_info_init(VALUE rb_mGI, VALUE rb_cGIRegisteredTypeInfo)
     RG_DEF_METHOD(get_vfunc, 1);
     RG_DEF_METHOD(n_constants, 0);
     RG_DEF_METHOD(get_constant, 1);
+    RG_DEF_METHOD(class_struct, 0);
     RG_DEF_METHOD(unref_function, 0);
     RG_DEF_METHOD(ref_function, 0);
     RG_DEF_METHOD(set_value_function, 0);

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
@@ -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-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);
 }