gobject-introspection 3.4.4 → 3.4.8

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

@@ -497,12 +497,53 @@ rb_gi_arguments_get_rb_out_args(RBGIArguments *args)
     return rb_gi_arguments_out_to_ruby(args);
 }
 
+void
+rb_gi_arguments_fill_raw_out_gerror(RBGIArguments *args,
+                                    VALUE rb_error)
+{
+    if (!g_callable_info_can_throw_gerror(args->info)) {
+        return;
+    }
+
+    gint n_args = g_callable_info_get_n_args(args->info);
+    /* GError ** isn't listed in args. */
+    GError **gerror = *((gpointer *)(args->raw_args[n_args]));
+    VALUE cGLibErrorInfo = rb_const_get(mGLib, rb_intern("ErrorInfo"));
+    if (NIL_P(rb_error)) {
+        g_set_error(gerror,
+                    RBG_RUBY_ERROR,
+                    RBG_RUBY_ERROR_UNKNOWN,
+                    "Unknown error");
+    } else {
+        VALUE message = rb_funcall(rb_error, rb_intern("message"), 0);
+        VALUE backtrace = rb_funcall(rb_error, rb_intern("backtrace"), 0);
+        VALUE formatted_backtrace =
+            rb_ary_join(backtrace, rb_str_new_cstr("  \n"));
+        GQuark gdomain = RBG_RUBY_ERROR;
+        gint gcode = RBG_RUBY_ERROR_UNKNOWN;
+        if (RVAL2CBOOL(rb_obj_is_kind_of(rb_error, cGLibErrorInfo))) {
+            VALUE domain = rb_funcall(rb_error, rb_intern("domain"), 0);
+            VALUE code = rb_funcall(rb_error, rb_intern("code"), 0);
+            if (!NIL_P(domain) && !NIL_P(code)) {
+                gdomain = g_quark_from_string(RVAL2CSTR(domain));
+                gcode = NUM2INT(code);
+            }
+        }
+        g_set_error(gerror,
+                    gdomain,
+                    gcode,
+                    "%s\n  %s\n",
+                    RVAL2CSTR(message),
+                    RVAL2CSTR(formatted_backtrace));
+    }
+}
+
 static void
 rb_gi_arguments_fill_raw_result_interface(RBGIArguments *args,
                                           VALUE rb_result,
                                           gpointer raw_result,
                                           GITypeInfo *type_info,
-                                          G_GNUC_UNUSED GITransfer transfer /* TODO */,
+                                          GITransfer transfer,
                                           gboolean is_return_value)
 {
     GIBaseInfo *interface_info;
@@ -542,8 +583,37 @@ rb_gi_arguments_fill_raw_result_interface(RBGIArguments *args,
       }
       break;
     case GI_INFO_TYPE_FLAGS:
+        rb_raise(rb_eNotImpError,
+                 "TODO: %s::%s: out raw result(interface)[%s]: <%s>",
+                 g_base_info_get_namespace(args->info),
+                 g_base_info_get_name(args->info),
+                 g_info_type_to_string(interface_type),
+                 g_base_info_get_name(interface_info));
+        break;
     case GI_INFO_TYPE_OBJECT:
     case GI_INFO_TYPE_INTERFACE:
+      {
+          GObject *value = RVAL2GOBJ(rb_result);
+          GType gtype = g_registered_type_info_get_g_type(interface_info);
+          if (gtype != G_TYPE_NONE &&
+              !G_TYPE_CHECK_INSTANCE_TYPE(value, gtype)) {
+              rb_raise(rb_eArgError,
+                       "%s::%s: must return <%s> object: <%" PRIsVALUE ">",
+                       g_base_info_get_namespace(args->info),
+                       g_base_info_get_name(args->info),
+                       g_type_name(gtype),
+                       rb_result);
+          }
+          if (transfer == GI_TRANSFER_EVERYTHING) {
+              g_object_ref(value);
+          }
+          if (is_return_value) {
+              ffi_return_value->v_pointer = value;
+          } else {
+              *((gpointer *)raw_result) = value;
+          }
+      }
+      break;
     case GI_INFO_TYPE_CONSTANT:
         rb_raise(rb_eNotImpError,
                  "TODO: %s::%s: out raw result(interface)[%s]: <%s>",
@@ -577,6 +647,160 @@ rb_gi_arguments_fill_raw_result_interface(RBGIArguments *args,
     g_base_info_unref(interface_info);
 }
 
+static void
+rb_gi_arguments_fill_raw_result_glist_interface(
+    RBGIArguments *args,
+    VALUE rb_result,
+    gpointer raw_result,
+    GITypeInfo *type_info,
+    GITypeInfo *element_type_info,
+    G_GNUC_UNUSED GITransfer transfer /* TODO */,
+    gboolean is_return_value)
+{
+    GIFFIReturnValue *ffi_return_value = raw_result;
+    GIBaseInfo *interface_info;
+    GIInfoType interface_type;
+    const gchar *interface_name;
+    GType gtype;
+    GList *list = NULL;
+
+    interface_info = g_type_info_get_interface(element_type_info);
+    interface_type = g_base_info_get_type(interface_info);
+    interface_name = g_info_type_to_string(interface_type);
+    gtype = g_registered_type_info_get_g_type(interface_info);
+
+    switch (interface_type) {
+    case GI_INFO_TYPE_INVALID:
+    case GI_INFO_TYPE_FUNCTION:
+    case GI_INFO_TYPE_CALLBACK:
+    case GI_INFO_TYPE_STRUCT:
+    case GI_INFO_TYPE_BOXED:
+    case GI_INFO_TYPE_ENUM:
+    case GI_INFO_TYPE_FLAGS:
+      g_base_info_unref(interface_info);
+      g_base_info_unref(element_type_info);
+      rb_raise(rb_eNotImpError,
+               "TODO: %s::%s: out raw result(glist)[interface(%s)](%s)",
+               g_base_info_get_namespace(args->info),
+               g_base_info_get_name(args->info),
+               interface_name,
+               g_type_name(gtype));
+      break;
+    case GI_INFO_TYPE_OBJECT:
+      list = RVAL2GOBJGLIST(rb_result);
+      if (transfer == GI_TRANSFER_EVERYTHING) {
+          g_list_foreach(list, (GFunc)g_object_ref, NULL);
+      }
+      break;
+    case GI_INFO_TYPE_INTERFACE:
+    case GI_INFO_TYPE_CONSTANT:
+    case GI_INFO_TYPE_INVALID_0:
+    case GI_INFO_TYPE_UNION:
+    case GI_INFO_TYPE_VALUE:
+    case GI_INFO_TYPE_SIGNAL:
+    case GI_INFO_TYPE_VFUNC:
+    case GI_INFO_TYPE_PROPERTY:
+    case GI_INFO_TYPE_FIELD:
+    case GI_INFO_TYPE_ARG:
+    case GI_INFO_TYPE_TYPE:
+    case GI_INFO_TYPE_UNRESOLVED:
+      g_base_info_unref(interface_info);
+      g_base_info_unref(element_type_info);
+      rb_raise(rb_eNotImpError,
+               "TODO: %s::%s: out raw result(glist)[interface(%s)](%s)",
+               g_base_info_get_namespace(args->info),
+               g_base_info_get_name(args->info),
+               interface_name,
+               g_type_name(gtype));
+      break;
+    default:
+      g_base_info_unref(interface_info);
+      g_base_info_unref(element_type_info);
+      g_assert_not_reached();
+      break;
+    }
+
+    if (is_return_value) {
+        ffi_return_value->v_ulong = (gulong)list;
+    } else {
+        *((gpointer *)raw_result) = list;
+    }
+}
+
+static void
+rb_gi_arguments_fill_raw_result_glist(RBGIArguments *args,
+                                      VALUE rb_result,
+                                      gpointer raw_result,
+                                      GITypeInfo *type_info,
+                                      GITransfer transfer,
+                                      gboolean is_return_value)
+{
+    GIFFIReturnValue *ffi_return_value = raw_result;
+    GITypeInfo *element_type_info;
+    GITypeTag element_type_tag;
+
+    element_type_info = g_type_info_get_param_type(type_info, 0);
+    element_type_tag = g_type_info_get_tag(element_type_info);
+
+    if (is_return_value) {
+        ffi_return_value->v_ulong = (gulong)NULL;
+    } else {
+        *((gpointer *)raw_result) = NULL;
+    }
+
+    switch (element_type_tag) {
+    case GI_TYPE_TAG_VOID:
+    case GI_TYPE_TAG_BOOLEAN:
+    case GI_TYPE_TAG_INT8:
+    case GI_TYPE_TAG_UINT8:
+    case GI_TYPE_TAG_INT16:
+    case GI_TYPE_TAG_UINT16:
+    case GI_TYPE_TAG_INT32:
+    case GI_TYPE_TAG_UINT32:
+    case GI_TYPE_TAG_INT64:
+    case GI_TYPE_TAG_UINT64:
+    case GI_TYPE_TAG_FLOAT:
+    case GI_TYPE_TAG_DOUBLE:
+    case GI_TYPE_TAG_GTYPE:
+    case GI_TYPE_TAG_UTF8:
+    case GI_TYPE_TAG_FILENAME:
+    case GI_TYPE_TAG_ARRAY:
+      g_base_info_unref(element_type_info);
+      rb_raise(rb_eNotImpError,
+               "TODO: %s::%s: out raw result(GList)[%s]",
+               g_base_info_get_namespace(args->info),
+               g_base_info_get_name(args->info),
+               g_type_tag_to_string(element_type_tag));
+      break;
+    case GI_TYPE_TAG_INTERFACE:
+      rb_gi_arguments_fill_raw_result_glist_interface(
+          args,
+          rb_result,
+          raw_result,
+          type_info,
+          element_type_info,
+          transfer,
+          is_return_value);
+      break;
+    case GI_TYPE_TAG_GLIST:
+    case GI_TYPE_TAG_GSLIST:
+    case GI_TYPE_TAG_GHASH:
+    case GI_TYPE_TAG_ERROR:
+    case GI_TYPE_TAG_UNICHAR:
+      g_base_info_unref(element_type_info);
+      rb_raise(rb_eNotImpError,
+               "TODO: %s::%s: out raw result(GList)[%s]",
+               g_base_info_get_namespace(args->info),
+               g_base_info_get_name(args->info),
+               g_type_tag_to_string(element_type_tag));
+      break;
+    default:
+      g_base_info_unref(element_type_info);
+      g_assert_not_reached();
+      break;
+    }
+}
+
 /*
   We need to cast from different type for return value. (We don't
   need it for out arguments.) Because of libffi specification:
@@ -695,12 +919,16 @@ rb_gi_arguments_fill_raw_result(RBGIArguments *args,
         }
         break;
       case GI_TYPE_TAG_UTF8:
-        if (is_return_value) {
-            ffi_return_value->v_ulong =
-                (gulong)RVAL2CSTR_ACCEPT_SYMBOL(rb_result);
-        } else {
-            *((gchar **)raw_result) =
-                (gchar *)RVAL2CSTR_ACCEPT_SYMBOL(rb_result);
+        {
+            gchar *result = (gchar *)RVAL2CSTR_ACCEPT_SYMBOL(rb_result);
+            if (transfer == GI_TRANSFER_EVERYTHING) {
+                result = g_strdup(result);
+            }
+            if (is_return_value) {
+                ffi_return_value->v_ulong = (gulong)result;
+            } else {
+                *((gchar **)raw_result) = (gchar *)result;
+            }
         }
         break;
       case GI_TYPE_TAG_FILENAME:
@@ -739,6 +967,13 @@ rb_gi_arguments_fill_raw_result(RBGIArguments *args,
                                                   is_return_value);
         break;
       case GI_TYPE_TAG_GLIST:
+        rb_gi_arguments_fill_raw_result_glist(args,
+                                              rb_result,
+                                              raw_result,
+                                              type_info,
+                                              transfer,
+                                              is_return_value);
+        break;
       case GI_TYPE_TAG_GSLIST:
       case GI_TYPE_TAG_GHASH:
         rb_raise(rb_eNotImpError,
@@ -833,7 +1068,7 @@ rb_gi_arguments_fill_raw_results(RBGIArguments *args,
         rb_gi_arguments_fill_raw_result(args,
                                         RARRAY_AREF(rb_results, i_rb_result),
                                         argument->v_pointer,
-                                        return_type_info,
+                                        type_info,
                                         transfer,
                                         FALSE);
         i_rb_result++;

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