gobject-introspection 1.1.9 → 1.2.0

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

@@ -72,7 +72,7 @@ rg_n_args(VALUE self)
 }
 
 static VALUE
-rg_operator_aref(VALUE self, VALUE rb_n)
+rg_get_arg(VALUE self, VALUE rb_n)
 {
     GICallableInfo *info;
     gint n;
@@ -82,25 +82,6 @@ rg_operator_aref(VALUE self, VALUE rb_n)
     return GI_BASE_INFO2RVAL_WITH_UNREF(g_callable_info_get_arg(info, n));
 }
 
-static VALUE
-rg_args(VALUE self)
-{
-    GICallableInfo *info;
-    gint i, n;
-    VALUE rb_args;
-
-    info = SELF(self);
-    rb_args = rb_ary_new();
-    n = g_callable_info_get_n_args(info);
-    for (i = 0; i < n; i++) {
-        GIArgInfo *arg_info;
-        arg_info = g_callable_info_get_arg(info, i);
-        rb_ary_push(rb_args, GI_BASE_INFO2RVAL_WITH_UNREF(arg_info));
-    }
-
-    return rb_args;
-}
-
 void
 rb_gi_callable_info_init(VALUE rb_mGI, VALUE rb_cGIBaseInfo)
 {
@@ -114,8 +95,7 @@ rb_gi_callable_info_init(VALUE rb_mGI, VALUE rb_cGIBaseInfo)
     RG_DEF_METHOD(caller_owns, 0);
     RG_DEF_METHOD_P(may_return_null, 0);
     RG_DEF_METHOD(n_args, 0);
-    RG_DEF_METHOD_OPERATOR("[]", aref, 1);
-    RG_DEF_METHOD(args, 0);
+    RG_DEF_METHOD(get_arg, 1);
 
     rb_gi_function_info_init(rb_mGI, RG_TARGET_NAMESPACE);
     rb_gi_callback_info_init(rb_mGI, RG_TARGET_NAMESPACE);

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

@@ -35,6 +35,52 @@ gi_constructor_info_get_type(void)
     return type;
 }
 
+static void
+initialize_receiver(VALUE receiver, GITypeInfo *info, GIArgument *value)
+{
+    GIBaseInfo *interface_info;
+    GIInfoType interface_type;
+
+    if (g_type_info_get_tag(info) != GI_TYPE_TAG_INTERFACE) {
+        rb_raise(rb_eRuntimeError, "TODO: returned value isn't interface");
+    }
+
+    interface_info = g_type_info_get_interface(info);
+    interface_type = g_base_info_get_type(interface_info);
+    g_base_info_unref(interface_info);
+    switch (interface_type) {
+      case GI_INFO_TYPE_OBJECT:
+        g_object_ref_sink(value->v_pointer);
+        G_INITIALIZE(receiver, value->v_pointer);
+        break;
+      case GI_INFO_TYPE_STRUCT:
+        G_INITIALIZE(receiver, value->v_pointer);
+        break;
+      case GI_INFO_TYPE_INVALID:
+      case GI_INFO_TYPE_FUNCTION:
+      case GI_INFO_TYPE_CALLBACK:
+      case GI_INFO_TYPE_BOXED:
+      case GI_INFO_TYPE_ENUM:
+      case GI_INFO_TYPE_FLAGS:
+      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:
+      default:
+        rb_raise(rb_eRuntimeError,
+                 "TODO: returned value isn't object or struct");
+        break;
+    }
+}
+
 static VALUE
 rg_invoke(int argc, VALUE *argv, VALUE self)
 {
@@ -43,27 +89,19 @@ rg_invoke(int argc, VALUE *argv, VALUE self)
     VALUE receiver;
     GIArgument return_value;
     GITypeInfo return_value_info;
-    GIBaseInfo *interface_info;
-    GIInfoType interface_type;
 
     info = SELF(self);
     callable_info = (GICallableInfo *)info;
 
     /* TODO: check argc. */
     receiver = argv[0];
-    rb_gi_function_info_invoke_raw(info, argc - 1, argv + 1, &return_value);
-    g_callable_info_load_return_type(callable_info, &return_value_info);
+    /* TODO: use rb_protect */
+    rb_gi_function_info_invoke_raw(info, NULL,
+                                   argc - 1, argv + 1,
+                                   &return_value);
 
-    if (g_type_info_get_tag(&return_value_info) != GI_TYPE_TAG_INTERFACE) {
-        rb_raise(rb_eRuntimeError, "TODO: returned value isn't interface");
-    }
-    interface_info = g_type_info_get_interface(&return_value_info);
-    interface_type = g_base_info_get_type(interface_info);
-    if (interface_type != GI_INFO_TYPE_OBJECT) {
-        rb_raise(rb_eRuntimeError, "TODO: returned value isn't object");
-    }
-    g_object_ref_sink(return_value.v_pointer);
-    G_INITIALIZE(receiver, return_value.v_pointer);
+    g_callable_info_load_return_type(callable_info, &return_value_info);
+    initialize_receiver(receiver, &return_value_info, &return_value);
 
     return receiver;
 }

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2012-2013  Ruby-GNOME2 Project Team
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
@@ -33,8 +33,14 @@
 
 #define GI_ARGUMENT2RVAL(argument, type_info)           \
     (rb_gi_argument_to_ruby((argument), (type_info)))
-#define RVAL2GI_ARGUMENT(argument, type_info, rb_argument) \
-    (rb_gi_argument_from_ruby((argument), (type_info), (rb_argument)))
+#define GI_OUT_ARGUMENT2RVAL(argument, arg_info)                \
+    (rb_gi_out_argument_to_ruby((argument), (arg_info)))
+#define GI_RETURN_ARGUMENT2RVAL(argument, callable_info)                \
+    (rb_gi_return_argument_to_ruby((argument), (callable_info)))
+#define RVAL2GI_IN_ARGUMENT(argument, type_info, rb_argument)           \
+    (rb_gi_in_argument_from_ruby((argument), (type_info), (rb_argument)))
+#define RVAL2GI_CALL_ARGUMENT(argument, arg_info, rb_argument)          \
+    (rb_gi_call_argument_from_ruby((argument), (arg_info), (rb_argument)))
 
 
 #define RVAL2GI_REGISTERED_TYPE_INFO(rb_object)			\
@@ -83,11 +89,26 @@ VALUE       rb_gi_base_info_to_ruby           (GIBaseInfo *info);
 VALUE       rb_gi_base_info_to_ruby_with_unref(GIBaseInfo *info);
 GIBaseInfo *rb_gi_base_info_from_ruby         (VALUE rb_info);
 
-VALUE       rb_gi_argument_to_ruby            (GIArgument *argument,
-                                               GITypeInfo *type_info);
-GIArgument *rb_gi_argument_from_ruby          (GIArgument *argument,
-                                               GITypeInfo *type_info,
-                                               VALUE       rb_argument);
+VALUE       rb_gi_argument_to_ruby            (GIArgument     *argument,
+                                               GITypeInfo     *type_info);
+void        rb_gi_out_argument_init           (GIArgument     *argument,
+                                               GIArgInfo      *arg_info);
+VALUE       rb_gi_out_argument_to_ruby        (GIArgument     *argument,
+                                               GIArgInfo      *arg_info);
+void        rb_gi_out_argument_fin            (GIArgument     *argument,
+                                               GIArgInfo      *arg_info);
+VALUE       rb_gi_return_argument_to_ruby     (GIArgument     *argument,
+                                               GICallableInfo *callable_info);
+GIArgument *rb_gi_in_argument_from_ruby       (GIArgument     *argument,
+                                               GITypeInfo     *type_info,
+                                               VALUE           rb_argument);
+GIArgument *rb_gi_call_argument_from_ruby     (GIArgument     *argument,
+                                               GIArgInfo      *arg_info,
+                                               VALUE           rb_argument);
+void        rb_gi_in_argument_free            (GIArgument     *argument,
+                                               GITypeInfo     *type_info);
+void        rb_gi_call_argument_free          (GIArgument     *argument,
+                                               GIArgInfo      *arg_info);
 
 VALUE       rb_gi_array_type_to_ruby          (GIArrayType type);
 

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2012-2013  Ruby-GNOME2 Project Team
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
@@ -95,12 +95,16 @@ rb_gi_field_info_set_field_raw(GIFieldInfo *info, gpointer memory,
 {
     GIArgument field_value;
     GITypeInfo *type_info;
+    gboolean succeeded;
 
     type_info = g_field_info_get_type(info);
-    RVAL2GI_ARGUMENT(&field_value, type_info, rb_field_value);
+    RVAL2GI_IN_ARGUMENT(&field_value, type_info, rb_field_value);
+
+    succeeded = g_field_info_set_field(info, memory, &field_value);
+    rb_gi_in_argument_free(&field_value, type_info);
     g_base_info_unref(type_info);
 
-    if (!g_field_info_set_field(info, memory, &field_value)) {
+    if (!succeeded) {
         rb_raise(rb_eArgError, "failed to set field value");
     }
 }

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2012-2013  Ruby-GNOME2 Project Team
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
@@ -23,6 +23,9 @@
 #define RG_TARGET_NAMESPACE rb_cGIFunctionInfo
 #define SELF(self) RVAL2GI_FUNCTION_INFO(self)
 
+static VALUE RG_TARGET_NAMESPACE;
+static const char *callbacks_key = "gi_callbacks";
+
 GType
 gi_function_info_get_type(void)
 {
@@ -71,81 +74,478 @@ rg_vfunc(VALUE self)
     return GI_BASE_INFO2RVAL(g_function_info_get_vfunc(info));
 }
 
+typedef struct
+{
+    GIArgInfo arg_info;
+    GIScopeType scope_type;
+    GIDirection direction;
+    gboolean callback_p;
+    gboolean closure_p;
+    gboolean destroy_p;
+    gboolean inout_argv_p;
+    gint in_arg_index;
+    gint closure_in_arg_index;
+    gint destroy_in_arg_index;
+    gint rb_arg_index;
+    gint out_arg_index;
+    gint inout_argc_arg_index;
+} ArgMetadata;
+
 static void
-fill_gi_argument_by_ruby(GIArgument *argument, GIArgInfo *arg_info,
-                         VALUE rb_argument)
+allocate_arguments(GICallableInfo *info,
+                   GArray *in_args, GArray *out_args,
+                   GPtrArray *args_metadata)
+{
+    gint i, n_args;
+    gint rb_arg_index = 0;
+
+    n_args = g_callable_info_get_n_args(info);
+    for (i = 0; i < n_args; i++) {
+        GIArgument argument;
+        ArgMetadata *metadata;
+        GIArgInfo *arg_info;
+        GIDirection direction;
+
+        memset(&argument, 0, sizeof(GIArgument));
+
+        metadata = ALLOC(ArgMetadata);
+        arg_info = &(metadata->arg_info);
+        g_callable_info_load_arg(info, i, arg_info);
+        metadata->scope_type = g_arg_info_get_scope(arg_info);
+        metadata->direction = g_arg_info_get_direction(arg_info);
+        metadata->callback_p = (metadata->scope_type != GI_SCOPE_TYPE_INVALID);
+        metadata->closure_p = FALSE;
+        metadata->destroy_p = FALSE;
+        metadata->inout_argv_p = FALSE;
+        metadata->in_arg_index = -1;
+        metadata->closure_in_arg_index = -1;
+        metadata->destroy_in_arg_index = -1;
+        metadata->rb_arg_index = -1;
+        metadata->out_arg_index = -1;
+        metadata->inout_argc_arg_index = -1;
+
+        direction = metadata->direction;
+        if (direction == GI_DIRECTION_IN || direction == GI_DIRECTION_INOUT) {
+            metadata->in_arg_index = in_args->len;
+            g_array_append_val(in_args, argument);
+            metadata->rb_arg_index = rb_arg_index++;
+        }
+        if (direction == GI_DIRECTION_OUT || direction == GI_DIRECTION_INOUT) {
+            metadata->out_arg_index = out_args->len;
+            g_array_append_val(out_args, argument);
+        }
+
+        g_ptr_array_add(args_metadata, metadata);
+    }
+}
+
+static void
+fill_metadata_inout_argv(GPtrArray *args_metadata)
+{
+    guint i;
+    gint inout_argc_arg_index = -1;
+
+    for (i = 0; i < args_metadata->len; i++) {
+        ArgMetadata *metadata;
+        GIArgInfo *arg_info;
+        const gchar *name;
+
+        metadata = g_ptr_array_index(args_metadata, i);
+        if (metadata->direction != GI_DIRECTION_INOUT) {
+            continue;
+        }
+        arg_info = &(metadata->arg_info);
+        name = g_base_info_get_name(arg_info);
+        if (strcmp(name, "argc") == 0) {
+            inout_argc_arg_index = i;
+        } else if (strcmp(name, "argv") == 0) {
+            metadata->inout_argv_p = TRUE;
+            metadata->inout_argc_arg_index = inout_argc_arg_index;
+        }
+    }
+}
+
+static void
+fill_metadata_callback(GPtrArray *args_metadata)
+{
+    guint i;
+
+    for (i = 0; i < args_metadata->len; i++) {
+        ArgMetadata *metadata;
+        GIArgInfo *arg_info;
+        gint closure_index;
+        gint destroy_index;
+
+        metadata = g_ptr_array_index(args_metadata, i);
+        if (!metadata->callback_p) {
+            continue;
+        }
+
+        arg_info = &(metadata->arg_info);
+        closure_index = g_arg_info_get_closure(arg_info);
+        if (closure_index != -1) {
+            ArgMetadata *closure_metadata;
+            closure_metadata = g_ptr_array_index(args_metadata, closure_index);
+            closure_metadata->closure_p = TRUE;
+            metadata->closure_in_arg_index = closure_metadata->in_arg_index;
+            closure_metadata->rb_arg_index = -1;
+        }
+
+        destroy_index = g_arg_info_get_destroy(arg_info);
+        if (destroy_index != -1) {
+            ArgMetadata *destroy_metadata;
+            destroy_metadata = g_ptr_array_index(args_metadata, destroy_index);
+            destroy_metadata->destroy_p = TRUE;
+            metadata->destroy_in_arg_index = destroy_metadata->in_arg_index;
+            destroy_metadata->rb_arg_index = -1;
+        }
+    }
+}
+
+static void
+fill_metadata(GPtrArray *args_metadata)
+{
+    fill_metadata_inout_argv(args_metadata);
+    fill_metadata_callback(args_metadata);
+}
+
+static gboolean
+source_callback_p(GIArgInfo *info)
 {
     GITypeInfo type_info;
+    GIBaseInfo *interface_info;
+    GICallableInfo *callback_info;
+    GITypeInfo return_type_info;
+    GIArgInfo first_arg_info;
+    GITypeInfo first_arg_type_info;
+
+    g_arg_info_load_type(info, &type_info);
+    if (g_type_info_get_tag(&type_info) != GI_TYPE_TAG_INTERFACE) {
+        return FALSE;
+    }
 
-    g_arg_info_load_type(arg_info, &type_info);
-    RVAL2GI_ARGUMENT(argument, &type_info, rb_argument);
+    interface_info = g_type_info_get_interface(&type_info);
+    if (g_base_info_get_type(interface_info) != GI_INFO_TYPE_CALLBACK) {
+        g_base_info_unref(interface_info);
+        return FALSE;
+    }
+
+    callback_info = (GICallableInfo *)interface_info;
+    g_callable_info_load_return_type(callback_info, &return_type_info);
+    if (g_type_info_get_tag(&return_type_info) != GI_TYPE_TAG_BOOLEAN) {
+        g_base_info_unref(interface_info);
+        return FALSE;
+    }
+
+    if (g_callable_info_get_n_args(interface_info) != 1) {
+        g_base_info_unref(interface_info);
+        return FALSE;
+    }
+
+    g_callable_info_load_arg(interface_info, 0, &first_arg_info);
+    g_arg_info_load_type(&first_arg_info, &first_arg_type_info);
+    if (g_type_info_get_tag(&first_arg_type_info) != GI_TYPE_TAG_VOID) {
+        g_base_info_unref(interface_info);
+        return FALSE;
+    }
+
+    g_base_info_unref(interface_info);
+    return TRUE;
 }
 
+typedef struct {
+    ArgMetadata *metadata;
+    VALUE rb_gc_guard_key;
+    VALUE rb_callback;
+} CallbackData;
+
 static void
-fill_in_argument(GIArgInfo *arg_info, GArray *in_args, int argc, VALUE *argv)
+callback_data_guard_from_gc(CallbackData *callback_data)
 {
-    VALUE rb_argument;
-    GIArgument argument;
+    VALUE rb_callbacks;
 
-    /* TODO: check argc */
-    rb_argument = argv[in_args->len];
-    fill_gi_argument_by_ruby(&argument, arg_info, rb_argument);
-    g_array_append_val(in_args, argument);
+    rb_callbacks = rb_iv_get(RG_TARGET_NAMESPACE, callbacks_key);
+    callback_data->rb_gc_guard_key = rb_class_new_instance(0, NULL, rb_cObject);
+    rb_hash_aset(rb_callbacks,
+                 callback_data->rb_gc_guard_key,
+                 callback_data->rb_callback);
 }
 
 static void
-fill_out_argument(G_GNUC_UNUSED GIArgInfo *arg_info, GArray *out_args)
+callback_data_unguard_from_gc(CallbackData *callback_data)
 {
-    GIArgument argument;
-    g_array_append_val(out_args, argument);
+    VALUE rb_callbacks;
+
+    rb_callbacks = rb_iv_get(RG_TARGET_NAMESPACE, callbacks_key);
+    rb_hash_delete(rb_callbacks, callback_data->rb_gc_guard_key);
 }
 
 static void
-fill_argument(GIArgInfo *arg_info, GArray *in_args, GArray *out_args,
-              int argc, VALUE *argv)
-{
-    switch (g_arg_info_get_direction(arg_info)) {
-      case GI_DIRECTION_IN:
-        fill_in_argument(arg_info, in_args, argc, argv);
-        break;
-      case GI_DIRECTION_OUT:
-        fill_out_argument(arg_info, out_args);
-        break;
-      case GI_DIRECTION_INOUT:
-        fill_in_argument(arg_info, in_args, argc, argv);
-        fill_out_argument(arg_info, out_args);
-        break;
-      default:
-        g_assert_not_reached();
-        break;
+callback_data_free(CallbackData *callback_data)
+{
+    callback_data_unguard_from_gc(callback_data);
+    xfree(callback_data->metadata);
+    xfree(callback_data);
+}
+
+static gboolean
+source_callback(gpointer user_data)
+{
+    CallbackData *callback_data = user_data;
+    VALUE rb_keep;
+    ID id_call;
+
+    CONST_ID(id_call, "call");
+    rb_keep = rb_funcall(callback_data->rb_callback, id_call, 0);
+    if (callback_data->metadata->scope_type == GI_SCOPE_TYPE_ASYNC) {
+        callback_data_free(callback_data);
     }
+    return RVAL2CBOOL(rb_keep);
 }
 
-void
-rb_gi_function_info_invoke_raw(GIFunctionInfo *info, int argc, VALUE *argv,
+static void
+destroy_notify(gpointer data)
+{
+    CallbackData *callback_data = data;
+    callback_data_free(callback_data);
+}
+
+static void
+in_callback_argument_from_ruby(ArgMetadata *metadata, VALUE *argv,
+                               GArray *in_args)
+{
+    GIArgument *callback_argument;
+
+    if (!source_callback_p(&(metadata->arg_info))) {
+        rb_raise(rb_eNotImpError,
+                 "TODO: GSourceFunc callback is only supported.");
+    }
+
+    callback_argument = &(g_array_index(in_args,
+                                        GIArgument,
+                                        metadata->in_arg_index));
+    callback_argument->v_pointer = source_callback;
+
+    if (metadata->closure_in_arg_index != -1) {
+        CallbackData *callback_data;
+        GIArgument *closure_argument;
+
+        callback_data = ALLOC(CallbackData);
+        callback_data->metadata = metadata;
+        callback_data->rb_callback = rb_block_proc();
+        callback_data_guard_from_gc(callback_data);
+        closure_argument = &(g_array_index(in_args,
+                                           GIArgument,
+                                           metadata->closure_in_arg_index));
+        closure_argument->v_pointer = callback_data;
+    }
+
+    if (metadata->destroy_in_arg_index != -1) {
+        GIArgument *destroy_argument;
+        destroy_argument = &(g_array_index(in_args,
+                                           GIArgument,
+                                           metadata->destroy_in_arg_index));
+        destroy_argument->v_pointer = destroy_notify;
+    }
+}
+
+static void
+in_argument_from_ruby(ArgMetadata *metadata, VALUE *argv, GArray *in_args)
+{
+    if (metadata->rb_arg_index == -1) {
+        return;
+    }
+
+    if (metadata->callback_p) {
+        in_callback_argument_from_ruby(metadata, argv, in_args);
+    } else {
+        GIArgument *argument;
+
+        argument = &(g_array_index(in_args, GIArgument, metadata->in_arg_index));
+        RVAL2GI_CALL_ARGUMENT(argument,
+                              &(metadata->arg_info),
+                              argv[metadata->rb_arg_index]);
+    }
+}
+
+static void
+out_argument_from_ruby(ArgMetadata *metadata, GArray *out_args)
+{
+    GIArgument *argument;
+
+    argument = &(g_array_index(out_args, GIArgument, metadata->out_arg_index));
+    rb_gi_out_argument_init(argument, &(metadata->arg_info));
+}
+
+static void
+arg_metadata_free(gpointer data)
+{
+    ArgMetadata *metadata = data;
+    if (metadata->scope_type == GI_SCOPE_TYPE_ASYNC ||
+        metadata->scope_type == GI_SCOPE_TYPE_NOTIFIED) {
+        return;
+    }
+    xfree(metadata);
+}
+
+static void
+arguments_from_ruby(GICallableInfo *info,
+                    int argc, VALUE *argv,
+                    GArray *in_args, GArray *out_args,
+                    GPtrArray *args_metadata)
+{
+    gint i, n_args;
+
+    allocate_arguments(info, in_args, out_args, args_metadata);
+    fill_metadata(args_metadata);
+
+    /* TODO: validate_rb_args(args_metadata); */
+
+    n_args = g_callable_info_get_n_args(info);
+    for (i = 0; i < n_args; i++) {
+        ArgMetadata *metadata;
+
+        metadata = g_ptr_array_index(args_metadata, i);
+        if (metadata->in_arg_index != -1) {
+            in_argument_from_ruby(metadata, argv, in_args);
+        } else {
+            out_argument_from_ruby(metadata, out_args);
+        }
+    }
+}
+
+static VALUE
+inout_argv_argument_to_ruby(GArray *in_args, ArgMetadata *metadata)
+{
+    GIArgument *inout_argc_argument;
+    GIArgument *inout_argv_argument;
+    gint i, argc;
+    gchar **argv;
+    VALUE rb_argv_argument;
+
+    inout_argc_argument = &g_array_index(in_args, GIArgument,
+                                         metadata->inout_argc_arg_index);
+    inout_argv_argument = &g_array_index(in_args, GIArgument,
+                                         metadata->in_arg_index);
+    argc = *((gint *)(inout_argc_argument->v_pointer));
+    argv = *((gchar ***)(inout_argv_argument->v_pointer));
+    rb_argv_argument = rb_ary_new2(argc);
+    for (i = 0; i < argc; i++) {
+        rb_ary_push(rb_argv_argument, CSTR2RVAL(argv[i]));
+    }
+    return rb_argv_argument;
+}
+
+static VALUE
+out_arguments_to_ruby(GICallableInfo *callable_info,
+                      GArray *in_args, GArray *out_args,
+                      GPtrArray *args_metadata)
+{
+    gint i, n_args;
+    VALUE rb_out_args;
+
+    rb_out_args = rb_ary_new();
+    n_args = g_callable_info_get_n_args(callable_info);
+    for (i = 0; i < n_args; i++) {
+        ArgMetadata *metadata;
+        GIArgument *argument = NULL;
+        VALUE rb_argument;
+
+        metadata = g_ptr_array_index(args_metadata, i);
+        switch (metadata->direction) {
+          case GI_DIRECTION_IN:
+            break;
+          case GI_DIRECTION_OUT:
+            argument = &g_array_index(out_args, GIArgument,
+                                      metadata->out_arg_index);
+            break;
+          case GI_DIRECTION_INOUT:
+            argument = &g_array_index(in_args, GIArgument,
+                                      metadata->in_arg_index);
+            break;
+          default:
+            g_assert_not_reached();
+            break;
+        }
+
+        if (!argument) {
+            continue;
+        }
+
+        if (metadata->inout_argv_p) {
+            rb_argument = inout_argv_argument_to_ruby(in_args, metadata);
+        } else {
+            rb_argument = GI_OUT_ARGUMENT2RVAL(argument, &(metadata->arg_info));
+        }
+        rb_ary_push(rb_out_args, rb_argument);
+    }
+
+    if (RARRAY_LEN(rb_out_args) == 0) {
+        return Qnil;
+    } else {
+        return rb_out_args;
+    }
+}
+
+static void
+arguments_init(GArray **in_args, GArray **out_args, GPtrArray **args_metadata)
+{
+    *in_args = g_array_new(FALSE, FALSE, sizeof(GIArgument));
+    *out_args = g_array_new(FALSE, FALSE, sizeof(GIArgument));
+    *args_metadata = g_ptr_array_new_with_free_func(arg_metadata_free);
+}
+
+static void
+arguments_free(GArray *in_args, GArray *out_args, GPtrArray *args_metadata)
+{
+    guint i;
+
+    for (i = 0; i < args_metadata->len; i++) {
+        ArgMetadata *metadata;
+        gint in_arg_index;
+
+        metadata = g_ptr_array_index(args_metadata, i);
+        if (metadata->direction == GI_DIRECTION_IN ||
+            metadata->direction == GI_DIRECTION_INOUT) {
+            in_arg_index = metadata->in_arg_index;
+            if (in_arg_index != -1) {
+                GIArgument *argument;
+                argument = &(g_array_index(in_args, GIArgument, in_arg_index));
+                rb_gi_call_argument_free(argument, &(metadata->arg_info));
+            }
+        } else {
+            GIArgument *argument;
+            argument = &(g_array_index(out_args, GIArgument,
+                                       metadata->out_arg_index));
+            rb_gi_out_argument_fin(argument, &(metadata->arg_info));
+        }
+    }
+
+    g_array_unref(in_args);
+    g_array_unref(out_args);
+    g_ptr_array_unref(args_metadata);
+}
+
+VALUE
+rb_gi_function_info_invoke_raw(GIFunctionInfo *info, GIArgument *receiver,
+                               int argc, VALUE *argv,
                                GIArgument *return_value)
 {
     GICallableInfo *callable_info;
-    gint i, n_args;
     GArray *in_args, *out_args;
+    GPtrArray *args_metadata;
+    VALUE rb_out_args = Qnil;
     gboolean succeeded;
     GError *error = NULL;
 
     callable_info = (GICallableInfo *)info;
-    n_args = g_callable_info_get_n_args(callable_info);
-    in_args = g_array_new(FALSE, FALSE, sizeof(GIArgument));
-    out_args = g_array_new(FALSE, FALSE, sizeof(GIArgument));
-    if (g_function_info_get_flags(callable_info) & GI_FUNCTION_IS_METHOD) {
-        GIArgument argument;
-        /* TODO: check argc */
-        argument.v_pointer = RVAL2GOBJ(argv[0]);
-        g_array_append_val(in_args, argument);
-    }
-    for (i = 0; i < n_args; i++) {
-        GIArgInfo arg_info;
-        g_callable_info_load_arg(callable_info, i, &arg_info);
-        fill_argument(&arg_info, in_args, out_args, argc, argv);
+    arguments_init(&in_args, &out_args, &args_metadata);
+    if (receiver) {
+        g_array_append_val(in_args, *receiver);
     }
+    arguments_from_ruby(callable_info,
+                        argc, argv,
+                        in_args, out_args, args_metadata);
     succeeded = g_function_info_invoke(info,
                                        (GIArgument *)(in_args->data),
                                        in_args->len,
@@ -153,11 +553,17 @@ rb_gi_function_info_invoke_raw(GIFunctionInfo *info, int argc, VALUE *argv,
                                        out_args->len,
                                        return_value,
                                        &error);
-    g_array_unref(in_args);
-    g_array_unref(out_args);
+    if (succeeded) {
+        rb_out_args = out_arguments_to_ruby(callable_info,
+                                            in_args, out_args,
+                                            args_metadata);
+    }
+    arguments_free(in_args, out_args, args_metadata);
     if (!succeeded) {
         RG_RAISE_ERROR(error);
     }
+
+    return rb_out_args;
 }
 
 static VALUE
@@ -166,26 +572,38 @@ rg_invoke(int argc, VALUE *argv, VALUE self)
     GIFunctionInfo *info;
     GICallableInfo *callable_info;
     GIArgument return_value;
-    GITypeInfo return_value_info;
+    VALUE rb_out_args;
+    VALUE rb_return_value;
 
     info = SELF(self);
-    callable_info = (GICallableInfo *)info;
+    /* TODO: use rb_protect() */
+    rb_out_args = rb_gi_function_info_invoke_raw(info, NULL, argc, argv,
+                                                 &return_value);
 
-    rb_gi_function_info_invoke_raw(info, argc, argv, &return_value);
-    g_callable_info_load_return_type(callable_info, &return_value_info);
+    callable_info = (GICallableInfo *)info;
+    rb_return_value = GI_RETURN_ARGUMENT2RVAL(&return_value, callable_info);
 
-    return GI_ARGUMENT2RVAL(&return_value, &return_value_info);
+    if (NIL_P(rb_out_args)) {
+        return rb_return_value;
+    } else {
+        GITypeInfo return_value_info;
+        g_callable_info_load_return_type(callable_info, &return_value_info);
+        if (g_type_info_get_tag(&return_value_info) != GI_TYPE_TAG_VOID) {
+            rb_ary_unshift(rb_out_args, rb_return_value);
+        }
+        return rb_out_args;
+    }
 }
 
 void
 rb_gi_function_info_init(VALUE rb_mGI, VALUE rb_cGICallableInfo)
 {
-    VALUE RG_TARGET_NAMESPACE;
-
     RG_TARGET_NAMESPACE =
 	G_DEF_CLASS_WITH_PARENT(GI_TYPE_FUNCTION_INFO, "FunctionInfo", rb_mGI,
 				rb_cGICallableInfo);
 
+    rb_iv_set(RG_TARGET_NAMESPACE, callbacks_key, rb_hash_new());
+
     RG_DEF_METHOD(symbol, 0);
     RG_DEF_METHOD(flags, 0);
     RG_DEF_METHOD(property, 0);