gobject-introspection 2.2.4-x64-mingw32

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

@@ -0,0 +1,133 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2012  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
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rb-gi-private.h"
+
+#define RG_TARGET_NAMESPACE rb_cGIConstructorInfo
+#define SELF(self) RVAL2GI_FUNCTION_INFO(self)
+
+GType
+gi_constructor_info_get_type(void)
+{
+    static GType type = 0;
+    if (type == 0) {
+	type = g_boxed_type_register_static("GIConstructorInfo",
+                                            (GBoxedCopyFunc)g_base_info_ref,
+                                            (GBoxedFreeFunc)g_base_info_unref);
+    }
+    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:
+        rb_raise(rb_eRuntimeError,
+                 "TODO: returned value isn't object, struct or union");
+        break;
+      case GI_INFO_TYPE_UNION:
+        G_INITIALIZE(receiver, value->v_pointer);
+        break;
+      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, struct or union");
+        break;
+    }
+}
+
+static VALUE
+rg_invoke(VALUE self, VALUE rb_options)
+{
+    GIFunctionInfo *info;
+    GICallableInfo *callable_info;
+    VALUE receiver;
+    GIArgument return_value;
+    GITypeInfo return_value_info;
+
+    info = SELF(self);
+    callable_info = (GICallableInfo *)info;
+
+    rb_options = rbg_to_hash(rb_options);
+    receiver = rb_hash_delete(rb_options, ID2SYM(rb_intern("receiver")));
+    if (NIL_P(receiver)) {
+        receiver = rb_hash_delete(rb_options, rb_str_new_cstr("receiver"));
+    }
+    if (NIL_P(receiver)) {
+        rb_raise(rb_eArgError,
+                 "receiver is missing: %s",
+                 RBG_INSPECT(rb_options));
+    }
+    /* TODO: use rb_protect */
+    rb_gi_function_info_invoke_raw(info,
+                                   rb_options,
+                                   &return_value);
+
+    g_callable_info_load_return_type(callable_info, &return_value_info);
+    initialize_receiver(receiver, &return_value_info, &return_value);
+
+    return receiver;
+}
+
+void
+rb_gi_constructor_info_init(VALUE rb_mGI, VALUE rb_cGIFunctionInfo)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE =
+	G_DEF_CLASS_WITH_PARENT(GI_TYPE_CONSTRUCTOR_INFO,
+                                "ConstructorInfo", rb_mGI,
+				rb_cGIFunctionInfo);
+
+    RG_DEF_METHOD(invoke, 1);
+}

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

@@ -0,0 +1,145 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2012-2014  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
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#ifndef RB_GI_CONVERSIONS_H
+#define RB_GI_CONVERSIONS_H
+
+#define RVAL2GI_REPOSITORY(rb_object) (G_IREPOSITORY(RVAL2GOBJ(rb_object)))
+#define RVAL2GI_REPOSITORY_LOAD_FLAGS(rb_flags) \
+    (RVAL2GFLAGS(rb_flags, G_TYPE_I_REPOSITORY_LOAD_FLAGS))
+
+#define GI_BASE_INFO2RVAL(info)				\
+    (rb_gi_base_info_to_ruby((GIBaseInfo *)(info)))
+#define GI_BASE_INFO2RVAL_WITH_UNREF(info)		\
+    (rb_gi_base_info_to_ruby_with_unref((GIBaseInfo *)(info)))
+#define RVAL2GI_BASE_INFO(rb_object) (rb_gi_base_info_from_ruby(rb_object))
+
+#define GI_ARGUMENT2RVAL(argument, type_info)           \
+    (rb_gi_argument_to_ruby((argument), (type_info)))
+#define GI_ARRAY_ARGUMENT2RVAL(array_argument, length_argument,         \
+                               array_type_info, length_type_info)       \
+    (rb_gi_array_argument_to_ruby((array_argument),                     \
+                                  (length_argument),                    \
+                                  (array_type_info),                    \
+                                  (length_type_info)))
+#define GI_OUT_ARGUMENT2RVAL(argument, arg_info)                \
+    (rb_gi_out_argument_to_ruby((argument), (arg_info)))
+#define GI_OUT_ARRAY_ARGUMENT2RVAL(array_argument, length_argument,     \
+                                   array_arg_info, length_arg_info)     \
+    (rb_gi_out_array_argument_to_ruby((array_argument), (length_argument), \
+                                      (array_arg_info), (length_arg_info)))
+#define GI_RETURN_ARGUMENT2RVAL(argument, callable_info)                \
+    (rb_gi_return_argument_to_ruby((argument), (callable_info)))
+#define RVAL2GI_VALUE_ARGUMENT(argument, type_info, rb_argument)        \
+    (rb_gi_value_argument_from_ruby((argument), (type_info), (rb_argument)))
+#define RVAL2GI_IN_ARGUMENT(argument, arg_info, rb_argument)            \
+    (rb_gi_in_argument_from_ruby((argument), (arg_info), (rb_argument)))
+#define RVAL2GI_IN_ARRAY_ARGUMENT(array_argument, length_argument,      \
+                                  array_arg_info, length_arg_info,      \
+                                  rb_argument)                          \
+    (rb_gi_in_array_argument_from_ruby((array_argument), (length_argument), \
+                                       (array_arg_info), (length_arg_info), \
+                                       (rb_argument)))
+
+
+#define RVAL2GI_REGISTERED_TYPE_INFO(rb_object)			\
+    ((GIRegisteredTypeInfo *)RVAL2GI_BASE_INFO(rb_object))
+#define RVAL2GI_FUNCTION_INFO(rb_object)			\
+    ((GIFunctionInfo *)RVAL2GI_BASE_INFO(rb_object))
+#define RVAL2GI_STRUCT_INFO(rb_object)			\
+    ((GIStructInfo *)RVAL2GI_BASE_INFO(rb_object))
+#define RVAL2GI_ENUM_INFO(rb_object)			\
+    ((GIEnumInfo *)RVAL2GI_BASE_INFO(rb_object))
+#define RVAL2GI_OBJECT_INFO(rb_object)			\
+    ((GIObjectInfo *)RVAL2GI_BASE_INFO(rb_object))
+#define RVAL2GI_INTERFACE_INFO(rb_object)		\
+    ((GIInterfaceInfo *)RVAL2GI_BASE_INFO(rb_object))
+#define RVAL2GI_CONSTANT_INFO(rb_object)		\
+    ((GIConstantInfo *)RVAL2GI_BASE_INFO(rb_object))
+#define RVAL2GI_UNION_INFO(rb_object)			\
+    ((GIUnionInfo *)RVAL2GI_BASE_INFO(rb_object))
+#define RVAL2GI_VALUE_INFO(rb_object)			\
+    ((GIValueInfo *)RVAL2GI_BASE_INFO(rb_object))
+#define RVAL2GI_ARG_INFO(rb_object)		\
+    ((GIArgInfo *)RVAL2GI_BASE_INFO(rb_object))
+#define RVAL2GI_FIELD_INFO(rb_object)                   \
+    ((GIFieldInfo *)RVAL2GI_BASE_INFO(rb_object))
+#define RVAL2GI_TYPE_INFO(rb_object)			\
+    ((GITypeInfo *)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))
+#define GI_DIRECTION2RVAL(direction) (GENUM2RVAL(direction, G_TYPE_I_DIRECTION))
+#define GI_SCOPE_TYPE2RVAL(scope)    (GENUM2RVAL(scope, G_TYPE_I_SCOPE_TYPE))
+#define RVAL2GI_TYPE_TAG(rb_tag)     (RVAL2GENUM(rb_tag, G_TYPE_I_TYPE_TAG))
+#define GI_TYPE_TAG2RVAL(tag)        (GENUM2RVAL(tag, G_TYPE_I_TYPE_TAG))
+#define GI_ARRAY_TYPE2RVAL(type)     (rb_gi_array_type_to_ruby(type))
+
+#define GI_FUNCTION_INFO_FLAGS2RVAL(tag) \
+    (GFLAGS2RVAL(tag, G_TYPE_I_FUNCTION_INFO_FLAGS))
+#define GI_SIGNAL_FLAGS2RVAL(tag)          \
+    (GFLAGS2RVAL(tag, G_TYPE_SIGNAL_FLAGS))
+#define GI_VFUNC_INFO_FLAGS2RVAL(tag) \
+    (GFLAGS2RVAL(tag, G_TYPE_IV_FUNC_INFO_FLAGS))
+#define GI_FIELD_INFO_FLAGS2RVAL(tag)                   \
+    (GFLAGS2RVAL(tag, G_TYPE_I_FIELD_INFO_FLAGS))
+
+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);
+VALUE       rb_gi_array_argument_to_ruby      (GIArgument     *array_argument,
+                                               GIArgument     *length_argument,
+                                               GITypeInfo     *array_type_info,
+                                               GITypeInfo     *length_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);
+VALUE       rb_gi_out_array_argument_to_ruby  (GIArgument     *array_argument,
+                                               GIArgument     *length_argument,
+                                               GIArgInfo      *array_arg_info,
+                                               GIArgInfo      *length_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_value_argument_from_ruby    (GIArgument     *argument,
+                                               GITypeInfo     *type_info,
+                                               VALUE           rb_argument);
+GIArgument *rb_gi_in_argument_from_ruby       (GIArgument     *argument,
+                                               GIArgInfo      *arg_info,
+                                               VALUE           rb_argument);
+GIArgument *rb_gi_in_array_argument_from_ruby (GIArgument     *array_argument,
+                                               GIArgument     *length_argument,
+                                               GIArgInfo      *array_arg_info,
+                                               GIArgInfo      *length_arg_info,
+                                               VALUE           rb_argument);
+void        rb_gi_value_argument_free         (GIArgument     *argument,
+                                               GITypeInfo     *type_info);
+void        rb_gi_in_argument_free            (GIArgument     *argument,
+                                               GIArgInfo      *arg_info);
+
+VALUE       rb_gi_array_type_to_ruby          (GIArrayType type);
+
+#endif
+

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

@@ -0,0 +1,155 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2012-2014  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
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rb-gi-private.h"
+
+#define RG_TARGET_NAMESPACE rb_cGIEnumInfo
+#define SELF(self) (RVAL2GI_ENUM_INFO(self))
+
+GType
+gi_enum_info_get_type(void)
+{
+    static GType type = 0;
+    if (type == 0) {
+	type = g_boxed_type_register_static("GIEnumInfo",
+                                            (GBoxedCopyFunc)g_base_info_ref,
+                                            (GBoxedFreeFunc)g_base_info_unref);
+    }
+    return type;
+}
+
+static VALUE
+rg_n_values(VALUE self)
+{
+    GIEnumInfo *info;
+
+    info = SELF(self);
+    return INT2NUM(g_enum_info_get_n_values(info));
+}
+
+static VALUE
+rg_get_value(VALUE self, VALUE rb_n)
+{
+    GIEnumInfo *info;
+    gint n;
+
+    info = SELF(self);
+    n = NUM2INT(rb_n);
+    return GI_BASE_INFO2RVAL_WITH_UNREF(g_enum_info_get_value(info, n));
+}
+
+static VALUE
+rg_values(VALUE self)
+{
+    GIEnumInfo *info;
+    gint i, n;
+    VALUE rb_values;
+
+    info = SELF(self);
+
+    rb_values = rb_ary_new();
+    n = g_enum_info_get_n_values(info);
+    for (i = 0; i < n; i++) {
+        GIValueInfo *value_info;
+        value_info = g_enum_info_get_value(info, i);
+        rb_ary_push(rb_values, GI_BASE_INFO2RVAL_WITH_UNREF(value_info));
+    }
+
+    return rb_values;
+}
+
+static VALUE
+rg_n_methods(VALUE self)
+{
+    GIEnumInfo *info;
+
+    info = SELF(self);
+    return INT2NUM(g_enum_info_get_n_methods(info));
+}
+
+static VALUE
+rg_get_method(VALUE self, VALUE rb_n)
+{
+    GIEnumInfo *info;
+    gint n;
+
+    info = SELF(self);
+    n = NUM2INT(rb_n);
+    return GI_BASE_INFO2RVAL_WITH_UNREF(g_enum_info_get_method(info, n));
+}
+
+static VALUE
+rg_methods(VALUE self)
+{
+    GIEnumInfo *info;
+    gint i, n;
+    VALUE rb_methods;
+
+    info = SELF(self);
+
+    rb_methods = rb_ary_new();
+    n = g_enum_info_get_n_methods(info);
+    for (i = 0; i < n; i++) {
+        GIFunctionInfo *function_info;
+        function_info = g_enum_info_get_method(info, i);
+        rb_ary_push(rb_methods, GI_BASE_INFO2RVAL_WITH_UNREF(function_info));
+    }
+
+    return rb_methods;
+}
+
+static VALUE
+rg_storage_type(VALUE self)
+{
+    GIEnumInfo *info;
+
+    info = SELF(self);
+    return GI_TYPE_TAG2RVAL(g_enum_info_get_storage_type(info));
+}
+
+static VALUE
+rg_error_domain(VALUE self)
+{
+    GIEnumInfo *info;
+
+    info = SELF(self);
+    return CSTR2RVAL(g_enum_info_get_error_domain(info));
+}
+
+void
+rb_gi_enum_info_init(VALUE rb_mGI, VALUE rb_cGIRegisteredTypeInfo)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE =
+	G_DEF_CLASS_WITH_PARENT(GI_TYPE_ENUM_INFO, "EnumInfo", rb_mGI,
+				rb_cGIRegisteredTypeInfo);
+
+    RG_DEF_METHOD(n_values, 0);
+    RG_DEF_METHOD(get_value, 1);
+    RG_DEF_METHOD(values, 0);
+    RG_DEF_METHOD(n_methods, 0);
+    RG_DEF_METHOD(get_method, 1);
+    RG_DEF_METHOD(methods, 0);
+    RG_DEF_METHOD(storage_type, 0);
+    RG_DEF_METHOD(error_domain, 0);
+
+    rb_gi_flags_info_init(rb_mGI, RG_TARGET_NAMESPACE);
+}

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

@@ -0,0 +1,153 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  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
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rb-gi-private.h"
+
+#define RG_TARGET_NAMESPACE rb_cGIFieldInfo
+#define SELF(self) (RVAL2GI_FIELD_INFO(self))
+
+GType
+gi_field_info_get_type(void)
+{
+    static GType type = 0;
+    if (type == 0) {
+	type = g_boxed_type_register_static("GIFieldInfo",
+                                            (GBoxedCopyFunc)g_base_info_ref,
+                                            (GBoxedFreeFunc)g_base_info_unref);
+    }
+    return type;
+}
+
+static VALUE
+rg_flags(VALUE self)
+{
+    GIFieldInfo *info;
+
+    info = SELF(self);
+    return GI_FIELD_INFO_FLAGS2RVAL(g_field_info_get_flags(info));
+}
+
+static VALUE
+rg_size(VALUE self)
+{
+    GIFieldInfo *info;
+
+    info = SELF(self);
+    return INT2NUM(g_field_info_get_size(info));
+}
+
+static VALUE
+rg_offset(VALUE self)
+{
+    GIFieldInfo *info;
+
+    info = SELF(self);
+    return INT2NUM(g_field_info_get_offset(info));
+}
+
+static VALUE
+rg_type(VALUE self)
+{
+    GIFieldInfo *info;
+
+    info = SELF(self);
+    return GI_BASE_INFO2RVAL_WITH_UNREF(g_field_info_get_type(info));
+}
+
+VALUE
+rb_gi_field_info_get_field_raw(GIFieldInfo *info, gpointer memory)
+{
+    GIArgument argument;
+    GITypeInfo *type_info;
+    VALUE rb_field_value;
+
+    if (!g_field_info_get_field(info, memory, &argument)) {
+        rb_raise(rb_eArgError, "failed to get field value");
+    }
+
+    type_info = g_field_info_get_type(info);
+    rb_field_value = GI_ARGUMENT2RVAL(&argument, type_info);
+    g_base_info_unref(type_info);
+
+    return rb_field_value;
+}
+
+void
+rb_gi_field_info_set_field_raw(GIFieldInfo *info, gpointer memory,
+                               VALUE rb_field_value)
+{
+    GIArgument field_value;
+    GITypeInfo *type_info;
+    gboolean succeeded;
+
+    type_info = g_field_info_get_type(info);
+    RVAL2GI_VALUE_ARGUMENT(&field_value, type_info, rb_field_value);
+
+    succeeded = g_field_info_set_field(info, memory, &field_value);
+    rb_gi_value_argument_free(&field_value, type_info);
+    g_base_info_unref(type_info);
+
+    if (!succeeded) {
+        rb_raise(rb_eArgError, "failed to set field value");
+    }
+}
+
+static VALUE
+rg_get_field(VALUE self, VALUE rb_memory)
+{
+    GIFieldInfo *info;
+    gpointer memory;
+
+    info = SELF(self);
+    memory = GUINT_TO_POINTER(NUM2ULONG(rb_memory));
+    return rb_gi_field_info_get_field_raw(info, memory);
+}
+
+static VALUE
+rg_set_field(VALUE self, VALUE rb_memory, VALUE rb_field_value)
+{
+    GIFieldInfo *info;
+    gpointer memory;
+
+    info = SELF(self);
+    memory = GUINT_TO_POINTER(NUM2ULONG(rb_memory));
+    rb_gi_field_info_set_field_raw(info, memory, rb_field_value);
+
+    return Qnil;
+}
+
+void
+rb_gi_field_info_init(VALUE rb_mGI, VALUE rb_cGIBaseInfo)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE =
+	G_DEF_CLASS_WITH_PARENT(GI_TYPE_FIELD_INFO, "FieldInfo", rb_mGI,
+				rb_cGIBaseInfo);
+
+    RG_DEF_METHOD(flags, 0);
+    RG_DEF_METHOD(size, 0);
+    RG_DEF_METHOD(offset, 0);
+    RG_DEF_METHOD(type, 0);
+    RG_DEF_METHOD(get_field, 1);
+    RG_DEF_METHOD(set_field, 2);
+
+    G_DEF_CLASS(G_TYPE_I_FIELD_INFO_FLAGS, "FieldInfoFlags", rb_mGI);
+}