gobject-introspection 3.4.3 → 3.4.9

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);
 }
 
@@ -70,7 +70,7 @@ struct_alloc(VALUE klass)
         is_owned = FALSE;
     } else {
         size_t size;
-        size = NUM2ULONG(rb_size);
+        size = NUM2ULL(rb_size);
         instance = xcalloc(1, size);
         is_owned = TRUE;
     }
@@ -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;
 
@@ -318,7 +365,7 @@ rg_s_instantiate_gobject_pointer(G_GNUC_UNUSED VALUE klass,
 {
     GObject *gobject;
 
-    gobject = GUINT_TO_POINTER(NUM2ULONG(rb_gobject_pointer));
+    gobject = (gpointer)(NUM2ULL(rb_gobject_pointer));
 
     return GOBJ2RVAL(gobject);
 }
@@ -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);

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-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/ext/gobject-introspection/rbgiversion.h

@@ -0,0 +1,24 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgiversion.h -
+
+  This file was generated by mkmf-gnome2.rb.
+
+************************************************/
+
+#ifndef __RBGI_VERSION_H__
+#define __RBGI_VERSION_H__
+
+#define GI_MAJOR_VERSION (1)
+#define GI_MINOR_VERSION (46)
+#define GI_MICRO_VERSION (0)
+
+#define GI_CHECK_VERSION(major,minor,micro)    \
+    (GI_MAJOR_VERSION > (major) || \
+     (GI_MAJOR_VERSION == (major) && GI_MINOR_VERSION > (minor)) || \
+     (GI_MAJOR_VERSION == (major) && GI_MINOR_VERSION == (minor) && \
+      GI_MICRO_VERSION >= (micro)))
+
+
+#endif /* __RBGI_VERSION_H__ */