gobject-introspection 3.4.0 → 3.4.5

data/ext/gobject-introspection/rb-gi-base-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
@@ -160,6 +160,15 @@ rg_namespace(VALUE self)
     return CSTR2RVAL(g_base_info_get_namespace(info));
 }
 
+static VALUE
+rg_container(VALUE self)
+{
+    GIBaseInfo *info;
+
+    info = SELF(self);
+    return rb_gi_base_info_to_ruby(g_base_info_get_container(info));
+}
+
 static VALUE
 rg_operator_aref(VALUE self, VALUE name)
 {
@@ -201,6 +210,7 @@ rb_gi_base_info_init(VALUE rb_mGI)
     RG_DEF_METHOD(type, 0);
     RG_DEF_METHOD(name, 0);
     RG_DEF_METHOD(namespace, 0);
+    RG_DEF_METHOD(container, 0);
     RG_DEF_METHOD_OPERATOR("[]", aref, 1);
     RG_DEF_METHOD(each, 0);
 

data/ext/gobject-introspection/rb-gi-callable-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_cGICallableInfo
-#define SELF(self) ((GICallableInfo *)(RVAL2GI_BASE_INFO(self)))
+#define SELF(self) RVAL2GI_CALLABLE_INFO(self)
 
 GType
 gi_callable_info_get_type(void)
@@ -35,6 +35,13 @@ gi_callable_info_get_type(void)
     return type;
 }
 
+static VALUE
+rg_can_throw_gerror_p(VALUE self)
+{
+    GICallableInfo *info = SELF(self);
+    return CBOOL2RVAL(g_callable_info_can_throw_gerror(info));
+}
+
 static VALUE
 rg_return_type(VALUE self)
 {
@@ -91,6 +98,7 @@ rb_gi_callable_info_init(VALUE rb_mGI, VALUE rb_cGIBaseInfo)
         G_DEF_CLASS_WITH_PARENT(GI_TYPE_CALLABLE_INFO, "CallableInfo", rb_mGI,
                                 rb_cGIBaseInfo);
 
+    RG_DEF_METHOD_P(can_throw_gerror, 0);
     RG_DEF_METHOD(return_type, 0);
     RG_DEF_METHOD(caller_owns, 0);
     RG_DEF_METHOD_P(may_return_null, 0);

data/ext/gobject-introspection/rb-gi-callback.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
@@ -28,17 +28,171 @@ struct RBGICallbackData_ {
     VALUE rb_owner;
 };
 
+typedef struct {
+    RBGIArguments *args;
+    RBGICallback *callback;
+    RBGICallbackData *callback_data;
+    void *return_value;
+    VALUE rb_return_value;
+} RBGICallbackInvokeData;
+
 static GPtrArray *callback_finders;
 static VALUE mGLibObject = Qnil;
 static VALUE mGI = Qnil;
 
+static VALUE
+rb_gi_callback_invoke_without_protect(VALUE user_data)
+{
+    RBGICallbackInvokeData *data = (RBGICallbackInvokeData *)user_data;
+    VALUE rb_args = rb_gi_arguments_in_to_ruby(data->args);
+
+    if (data->callback->method_name) {
+        ID id___send__;
+        VALUE rb_receiver = rb_ary_shift(rb_args);
+        CONST_ID(id___send__, "__send__");
+        rb_ary_unshift(rb_args, rb_str_new_cstr(data->callback->method_name));
+        data->rb_return_value =
+            rb_funcallv(rb_receiver,
+                        id___send__,
+                        RARRAY_LENINT(rb_args),
+                        RARRAY_CONST_PTR(rb_args));
+    } else {
+        ID id_call;
+        CONST_ID(id_call, "call");
+        VALUE rb_callback =
+            rb_gi_callback_data_get_rb_callback(data->callback_data);
+        data->rb_return_value =
+            rb_funcallv(rb_callback,
+                        id_call,
+                        RARRAY_LENINT(rb_args),
+                        RARRAY_CONST_PTR(rb_args));
+    }
+
+    return Qnil;
+}
+
+static VALUE
+rb_gi_callback_invoke_fill_raw_results(VALUE user_data)
+{
+    RBGICallbackInvokeData *data = (RBGICallbackInvokeData *)user_data;
+    rb_gi_arguments_fill_raw_results(data->args,
+                                     data->rb_return_value,
+                                     data->return_value);
+    return Qnil;
+}
+
+static VALUE
+rb_gi_callback_invoke(VALUE user_data)
+{
+    RBGICallbackInvokeData *data = (RBGICallbackInvokeData *)user_data;
+    int state = 0;
+    rb_protect(rb_gi_callback_invoke_without_protect,
+               user_data,
+               &state);
+    if (state != 0) {
+        VALUE error = rb_errinfo();
+        rb_gi_arguments_fill_raw_out_gerror(data->args, error);
+        rb_protect(rb_gi_callback_invoke_fill_raw_results,
+                   user_data,
+                   &state);
+    } else {
+        rb_protect(rb_gi_callback_invoke_fill_raw_results,
+                   user_data,
+                   &state);
+        if (state != 0) {
+            VALUE error = rb_errinfo();
+            rb_gi_arguments_fill_raw_out_gerror(data->args, error);
+        }
+    }
+    return Qnil;
+}
+
+static void
+rb_gi_ffi_closure_callback(G_GNUC_UNUSED ffi_cif *cif,
+                           void *return_value,
+                           void **raw_args,
+                           void *data)
+{
+    RBGICallback *callback = data;
+    RBGICallbackData *callback_data = NULL;
+    RBGIArguments args;
+
+    rb_gi_arguments_init(&args,
+                         callback->callback_info,
+                         Qnil,
+                         Qnil,
+                         raw_args);
+    {
+        guint i;
+
+        for (i = 0; i < args.metadata->len; i++) {
+            RBGIArgMetadata *metadata;
+
+            metadata = g_ptr_array_index(args.metadata, i);
+            if (!metadata->closure_p) {
+                continue;
+            }
+
+            callback_data = *((RBGICallbackData **)(raw_args[i]));
+            break;
+        }
+
+        if (!callback_data && args.metadata->len > 0) {
+            RBGIArgMetadata *metadata;
+
+            i = args.metadata->len - 1;
+            metadata = g_ptr_array_index(args.metadata, i);
+            if (metadata->type.tag == GI_TYPE_TAG_VOID &&
+                metadata->type.pointer_p &&
+                strcmp(metadata->name, "data") == 0) {
+                callback_data = *((RBGICallbackData **)(raw_args[i]));
+            }
+        }
+    }
+
+    {
+        RBGICallbackInvokeData data;
+        data.args = &args;
+        data.callback = callback;
+        data.callback_data = callback_data;
+        data.return_value = return_value;
+        data.rb_return_value = Qnil;
+        rbgutil_invoke_callback(rb_gi_callback_invoke, (VALUE)&data);
+    }
+    rb_gi_arguments_clear(&args);
+
+    if (callback_data) {
+        RBGIArgMetadata *callback_metadata =
+            rb_gi_callback_data_get_metadata(callback_data);
+        if (callback_metadata->scope_type == GI_SCOPE_TYPE_ASYNC) {
+            rb_gi_callback_data_free(callback_data);
+        }
+    }
+}
+
+RBGICallback *
+rb_gi_callback_new(GICallbackInfo *callback_info,
+                   const gchar *method_name)
+{
+    RBGICallback *callback = RB_ZALLOC(RBGICallback);
+    callback->callback_info = callback_info;
+    g_base_info_ref(callback->callback_info);
+    callback->method_name = g_strdup(method_name);
+    callback->closure =
+        g_callable_info_prepare_closure(callback->callback_info,
+                                        &(callback->cif),
+                                        rb_gi_ffi_closure_callback,
+                                        callback);
+    return callback;
+}
+
 static void
 rb_gi_callback_free(RBGICallback *callback)
 {
     g_callable_info_free_closure(callback->callback_info,
                                  callback->closure);
+    g_free(callback->method_name);
     g_base_info_unref(callback->callback_info);
-    g_base_info_unref(callback->type_info);
     xfree(callback);
 }
 

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-interface-info.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012-2017  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
@@ -125,15 +125,9 @@ rg_get_signal(VALUE self, VALUE rb_n_or_name)
         n = NUM2INT(rb_n_or_name);
         signal_info = g_interface_info_get_signal(info, n);
     } else {
-#ifdef HAVE_G_INTERFACE_INFO_FIND_SIGNAL
         const char *name;
         name = RVAL2CSTR(rb_n_or_name);
         signal_info = g_interface_info_find_signal(info, name);
-#else
-        rb_raise(rb_eArgError,
-                 "g_interface_info_find_signal() is defined "
-                 "since GObjectIntrospection 1.34");
-#endif
     }
 
     return GI_BASE_INFO2RVAL_WITH_UNREF(signal_info);

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
@@ -39,7 +39,7 @@ rg_s_define_class(int argc, VALUE *argv, G_GNUC_UNUSED VALUE klass)
                      "size", &rb_size,
                      NULL);
 
-    gtype = NUM2ULONG(rb_to_int(rb_gtype));
+    gtype = rbgobj_gtype_from_ruby(rb_gtype);
     rb_class = G_DEF_CLASS_WITH_PARENT(gtype, RVAL2CSTR(rb_name),
                                        rb_module, rb_parent);
     if (!NIL_P(rb_size)) {
@@ -54,7 +54,7 @@ rg_s_define_interface(G_GNUC_UNUSED VALUE klass,
 {
     GType gtype;
 
-    gtype = rbgobj_gtype_get(rb_gtype);
+    gtype = rbgobj_gtype_from_ruby(rb_gtype);
     return G_DEF_INTERFACE(gtype, RVAL2CSTR(rb_name), rb_module);
 }
 
@@ -133,12 +133,63 @@ rg_s_define_error(int argc, VALUE *argv, G_GNUC_UNUSED VALUE klass)
     }
 
     if (!NIL_P(rb_gtype)) {
-        gtype = NUM2ULONG(rb_funcall(rb_gtype, rb_intern("to_i"), 0));
+        gtype = rbgobj_gtype_from_ruby(rb_gtype);
     }
 
     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;
@@ -173,12 +224,10 @@ rg_s_register_boxed_class_converter(VALUE klass, VALUE rb_gtype)
 {
     RGConvertTable table;
     BoxedInstance2RObjData *data;
-    ID id_to_i;
     VALUE boxed_class_converters;
 
     memset(&table, 0, sizeof(RGConvertTable));
-    CONST_ID(id_to_i, "to_i");
-    table.type = NUM2ULONG(rb_funcall(rb_gtype, id_to_i, 0));
+    table.type = rbgobj_gtype_from_ruby(rb_gtype);
     table.klass = Qnil;
     table.instance2robj = boxed_instance2robj;
 
@@ -243,12 +292,10 @@ rg_s_register_object_class_converter(VALUE klass, VALUE rb_gtype)
 {
     RGConvertTable table;
     ObjectInstance2RObjData *data;
-    ID id_to_i;
     VALUE object_class_converters;
 
     memset(&table, 0, sizeof(RGConvertTable));
-    CONST_ID(id_to_i, "to_i");
-    table.type = NUM2ULONG(rb_funcall(rb_gtype, id_to_i, 0));
+    table.type = rbgobj_gtype_from_ruby(rb_gtype);
     table.klass = Qnil;
     table.instance2robj = object_instance2robj;
 
@@ -337,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);