glib2 1.0.3-x86-mingw32 → 1.1.0-x86-mingw32

data/ext/glib2/extconf.rb

@@ -37,6 +37,7 @@ have_func("rb_sourceline", ruby_header)
 have_func("ruby_set_current_source", ruby_header)
 have_func("rb_thread_blocking_region", ruby_header)
 have_func("ruby_native_thread_p", ruby_header)
+have_func("rb_thread_call_with_gvl", ruby_header)
 
 have_var("curr_thread", [ruby_header, "node.h"])
 have_var("rb_curr_thread", [ruby_header, "node.h"])

data/ext/glib2/glib2.def

@@ -18,6 +18,7 @@ EXPORTS
 	rbgobj_get_ruby_object_from_gobject
 	rbgobj_create_object
 	rbgobj_gobject_new
+	rbgobj_gobject_initialize
 	rbgobj_boxed_create
 	rbgobj_boxed_get
 	rbgobj_boxed_not_copy_obj
@@ -26,6 +27,7 @@ EXPORTS
 	rbgobj_gtype_get
 	rbgobj_gtype_new
 	rbgobj_gvalue_to_rvalue
+	rbgobj_gvalue_to_rvalue_unset
 	rbgobj_rvalue_to_gvalue
 	rbgobj_initialize_gvalue
 	rbgobj_initialize_object
@@ -59,8 +61,12 @@ EXPORTS
 	rbg_string_value_ptr
 	rbg_rval2cstr
 	rbg_rval2cstr_accept_nil
+	rbg_rval2cstr_accept_symbol
+	rbg_rval2cstr_accept_symbol_accept_nil
+	rbg_rval2glibid
 	rbg_cstr2rval
         rbg_cstr2rval_len
+        rbg_cstr2rval_len_free
         rbg_cstr2rval_with_encoding
         rbg_cstr2rval_len_with_encoding
 	rbg_cstr2rval_free
@@ -75,6 +81,22 @@ EXPORTS
         rbg_rval2strv_dup_accept_nil
         rbg_strv2rval
         rbg_strv2rval_free
+        rbg_rval2gbooleans
+        rbg_rval2gints
+        rbg_rval2gint8s
+        rbg_rval2guint8s
+        rbg_rval2guint16s
+        rbg_rval2guint32s
+        rbg_rval2gdoubles
+        rbg_gints2rval
+        rbg_gints2rval_free
+        rbg_glist2rval
+        rbg_gslist2rval
+        rbg_glist2rval_with_type
+        rbg_gslist2rval_with_type
+	rbg_define_method
+	rbg_define_singleton_method
+	rbg_scan_options
 	rbgutil_id_module_eval		DATA
 	rbgutil_def_setters
 	rbgutil_glist2ary
@@ -88,6 +110,7 @@ EXPORTS
 	rbgutil_gslist2ary_and_free
 	rbgutil_gslist2ary_boxed_and_free
 	rbgutil_set_properties
+	rbgutil_glibid_r2g_func
 	rbgutil_sym_g2r_func
 	rbgutil_protect
 	rbgutil_invoke_callback

data/ext/glib2/rbgcompat.h

@@ -1,9 +1,23 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/**********************************************************************
-  rbgcompat.h -
-
-  Copyright (C) 2007  Ruby-GNOME2 Project Team
-**********************************************************************/
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2007  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 __RBGCOMPAT_H__
 #define __RBGCOMPAT_H__

data/ext/glib2/rbglib.c

@@ -1,47 +1,33 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/**********************************************************************
-
-  rbglib.c -
-
-  $Author: sakai $
-  $Date: 2007/07/14 13:42:08 $
-
-  Copyright (C) 2002,2003  Masahiro Sakai
-
-**********************************************************************/
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002,2003  Masahiro Sakai
+ *
+ *  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 <locale.h>
 #include "rbgprivate.h"
 #include "rbglib.h"
 
+#define RG_TARGET_NAMESPACE mGLib
+
 static ID id_inspect;
 
-VALUE mGLib;
-
-extern void Init_gutil();
-extern void Init_gutil_callback();
-extern void Init_glib_int64();
-extern void Init_glib_error();
-extern void Init_glib_threads();
-extern void Init_glib_convert();
-extern void Init_glib_messages();
-extern void Init_glib_spawn();
-extern void Init_glib_fileutils();
-extern void Init_glib_utils();
-extern void Init_glib_i18n();
-extern void Init_glib_win32();
-extern void Init_gobject();
-extern void Init_glib_main_loop();
-extern void Init_glib_main_context();
-extern void Init_glib_source();
-extern void Init_glib_poll_fd();
-extern void Init_glib_io_channel();
-extern void Init_glib_shell();
-extern void Init_glib_completion();
-extern void Init_glib_timer();
-extern void Init_glib_unicode();
-extern void Init_glib_keyfile();
-extern void Init_glib_bookmark_file();
+VALUE RG_TARGET_NAMESPACE;
 
 const gchar *
 rbg_rval2cstr(VALUE *str)
@@ -76,6 +62,46 @@ rbg_rval2cstr_accept_nil(VALUE *str)
     return NIL_P(*str) ? NULL : RVAL2CSTR(*str);
 }
 
+/* TODO: How do we deal with encodings? */
+const gchar *
+rbg_rval2cstr_accept_symbol(volatile VALUE *value)
+{
+    if (!SYMBOL_P(*value))
+        return rbg_rval2cstr((VALUE *)value);
+
+    return rb_id2name(SYM2ID(*value));
+}
+
+const gchar *
+rbg_rval2cstr_accept_symbol_accept_nil(volatile VALUE *value)
+{
+    return NIL_P(*value) ? NULL : rbg_rval2cstr_accept_symbol(value);
+}
+
+const gchar *
+rbg_rval2glibid(volatile VALUE *value, volatile VALUE *buf, gboolean accept_nil)
+{
+    gchar *id, *p;
+
+    if (accept_nil && NIL_P(*value))
+        return NULL;
+
+    if (SYMBOL_P(*value)) {
+        *buf = rb_String(*value);
+    } else {
+        StringValue(*value);
+        *buf = rb_str_dup(*value);
+    }
+    RB_GC_GUARD(*buf);
+
+    id = RSTRING_PTR(*buf);
+    for (p = id; *p; p++)
+        if (*p == '_')
+            *p = '-';
+
+    return id;
+}
+
 VALUE
 rbg_cstr2rval(const gchar *str)
 {
@@ -95,12 +121,43 @@ rbg_cstr2rval_len(const gchar *str, gsize len)
 #endif
 }
 
+struct rbg_cstr2rval_len_free_args {
+    gchar *str;
+    gsize len;
+};
+
+static VALUE
+rbg_cstr2rval_len_free_body(VALUE value)
+{
+    struct rbg_cstr2rval_len_free_args *args = (struct rbg_cstr2rval_len_free_args *)value;
+
+    return CSTR2RVAL_LEN(args->str, args->len);
+}
+
+static VALUE
+rbg_cstr2rval_len_free_ensure(VALUE str)
+{
+    g_free((gchar *)str);
+
+    return Qnil;
+}
+
+VALUE
+rbg_cstr2rval_len_free(gchar *str, gsize len)
+{
+    struct rbg_cstr2rval_len_free_args args = { str, len };
+
+    return str != NULL ? rb_ensure(rbg_cstr2rval_len_free_body, (VALUE)&args,
+                                   rbg_cstr2rval_len_free_ensure, (VALUE)str) : Qnil;
+}
+
 VALUE
 rbg_cstr2rval_with_encoding(const gchar *str, const gchar *encoding)
 {
     return str != NULL ? CSTR2RVAL_LEN_ENC(str, strlen(str), encoding) : Qnil;
 }
 
+#ifdef HAVE_RUBY_ENCODING_H
 VALUE
 rbg_cstr2rval_len_with_encoding(const gchar *str, gsize len,
                                 const gchar *encoding)
@@ -108,15 +165,22 @@ rbg_cstr2rval_len_with_encoding(const gchar *str, gsize len,
     if (str == NULL)
         return Qnil;
 
-#ifdef HAVE_RUBY_ENCODING_H
     return rb_external_str_new_with_enc(str, len,
                                         encoding != NULL ?
                                             rb_enc_find(encoding) :
                                             rb_utf8_encoding());
+}
 #else
+VALUE
+rbg_cstr2rval_len_with_encoding(const gchar *str, gsize len,
+                                G_GNUC_UNUSED const gchar *encoding)
+{
+    if (str == NULL)
+        return Qnil;
+
     return rb_str_new(str, len);
-#endif
 }
+#endif
 
 static VALUE
 rbg_cstr2rval_free_body(VALUE str)
@@ -258,43 +322,10 @@ rbg_filename_from_ruby(VALUE filename)
 #endif
 }
 
-static VALUE
-rbg_filename_gslist_to_array_free_body(VALUE list)
-{
-    VALUE ary = rb_ary_new();
-    GSList *p;
-
-    for (p = (GSList *)list; p != NULL; p = g_slist_next(p))
-        rb_ary_push(ary, CSTRFILENAME2RVAL(p->data));
-
-    return ary;
-}
-
-static VALUE
-rbg_filename_gslist_to_array_free_ensure(VALUE val)
-{
-    GSList *list = (GSList *)val;
-    GSList *p;
-
-    for (p = list; p != NULL; p = g_slist_next(p))
-        g_free((gchar *)p->data);
-
-    g_slist_free(list);
-
-    return Qnil;
-}
-
-VALUE
-rbg_filename_gslist_to_array_free(GSList *list)
-{
-    return rb_ensure(rbg_filename_gslist_to_array_free_body, (VALUE)list,
-                     rbg_filename_gslist_to_array_free_ensure, (VALUE)list);
-}
-
 struct rval2strv_args {
     VALUE ary;
     long n;
-    const gchar **strings;
+    const gchar **result;
 };
 
 static VALUE
@@ -304,47 +335,54 @@ rbg_rval2strv_body(VALUE value)
     struct rval2strv_args *args = (struct rval2strv_args *)value;
 
     for (i = 0; i < args->n; i++)
-            args->strings[i] = RVAL2CSTR(RARRAY_PTR(args->ary)[i]);
-    args->strings[args->n] = NULL;
+        args->result[i] = RVAL2CSTR(RARRAY_PTR(args->ary)[i]);
+    args->result[args->n] = NULL;
 
     return Qnil;
 }
 
-static VALUE
+static G_GNUC_NORETURN VALUE
 rbg_rval2strv_rescue(VALUE value)
 {
-    struct rval2strv_args *args = (struct rval2strv_args *)value;
-
-    g_free(args->strings);
+    g_free(((struct rval2strv_args *)value)->result);
 
     rb_exc_raise(rb_errinfo());
 }
 
 const gchar **
-rbg_rval2strv(VALUE value)
+rbg_rval2strv(volatile VALUE *value, long *n)
 {
     struct rval2strv_args args;
 
-    args.ary = rb_ary_to_ary(value);
+    args.ary = *value = rb_ary_dup(rb_ary_to_ary(*value));
     args.n = RARRAY_LEN(args.ary);
-    args.strings = g_new(const gchar *, args.n + 1);
+    args.result = g_new(const gchar *, args.n + 1);
 
     rb_rescue(rbg_rval2strv_body, (VALUE)&args,
               rbg_rval2strv_rescue, (VALUE)&args);
 
-    return args.strings;
+    if (n != NULL)
+        *n = args.n;
+
+    return args.result;
 }
 
 const gchar **
-rbg_rval2strv_accept_nil(VALUE ary)
+rbg_rval2strv_accept_nil(volatile VALUE *value, long *n)
 {
-    return NIL_P(ary) ? NULL : rbg_rval2strv(ary);
+    if (!NIL_P(*value))
+        return rbg_rval2strv(value, n);
+
+    if (n != NULL)
+        *n = 0;
+
+    return NULL;
 }
 
 struct rval2strv_dup_args {
     VALUE ary;
     long n;
-    gchar **strings;
+    gchar **result;
 };
 
 static VALUE
@@ -354,41 +392,48 @@ rbg_rval2strv_dup_body(VALUE value)
     struct rval2strv_dup_args *args = (struct rval2strv_dup_args *)value;
 
     for (i = 0; i < args->n; i++)
-            args->strings[i] = g_strdup(RVAL2CSTR(RARRAY_PTR(args->ary)[i]));
-    args->strings[args->n] = NULL;
+        args->result[i] = g_strdup(RVAL2CSTR(RARRAY_PTR(args->ary)[i]));
+    args->result[args->n] = NULL;
 
     return Qnil;
 }
 
-static VALUE
+static G_GNUC_NORETURN VALUE
 rbg_rval2strv_dup_rescue(VALUE value)
 {
-    struct rval2strv_dup_args *args = (struct rval2strv_dup_args *)value;
-
-    g_free(args->strings);
+    g_free(((struct rval2strv_dup_args *)value)->result);
 
     rb_exc_raise(rb_errinfo());
 }
 
 gchar **
-rbg_rval2strv_dup(VALUE value)
+rbg_rval2strv_dup(volatile VALUE *value, long *n)
 {
     struct rval2strv_dup_args args;
 
-    args.ary = rb_ary_to_ary(value);
+    args.ary = *value = rb_ary_dup(rb_ary_to_ary(*value));
     args.n = RARRAY_LEN(args.ary);
-    args.strings = g_new(gchar *, args.n + 1);
+    args.result = g_new(gchar *, args.n + 1);
 
     rb_rescue(rbg_rval2strv_dup_body, (VALUE)&args,
               rbg_rval2strv_dup_rescue, (VALUE)&args);
 
-    return args.strings;
+    if (n != NULL)
+        *n = args.n;
+
+    return args.result;
 }
 
 gchar **
-rbg_rval2strv_dup_accept_nil(VALUE ary)
+rbg_rval2strv_dup_accept_nil(volatile VALUE *value, long *n)
 {
-    return NIL_P(ary) ? NULL : rbg_rval2strv_dup(ary);
+    if (!NIL_P(*value))
+        rbg_rval2strv_dup(value, n);
+
+    if (n != NULL)
+        *n = 0;
+
+    return NULL;
 }
 
 VALUE
@@ -428,6 +473,399 @@ rbg_strv2rval_free(gchar **strings)
                      rbg_strv2rval_free_ensure, (VALUE)strings);
 }
 
+struct rbg_rval2gbooleans_args {
+    VALUE ary;
+    long n;
+    gboolean *result;
+};
+
+static VALUE
+rbg_rval2gbooleans_body(VALUE value)
+{
+    long i;
+    struct rbg_rval2gbooleans_args *args = (struct rbg_rval2gbooleans_args *)value;
+
+    for (i = 0; i < args->n; i++)
+        args->result[i] = RVAL2CBOOL(RARRAY_PTR(args->ary)[i]);
+
+    return Qnil;
+}
+
+static G_GNUC_NORETURN VALUE
+rbg_rval2gbooleans_rescue(VALUE value)
+{
+    g_free(((struct rbg_rval2gbooleans_args *)value)->result);
+
+    rb_exc_raise(rb_errinfo());
+}
+
+gboolean *
+rbg_rval2gbooleans(volatile VALUE *value, long *n)
+{
+    struct rbg_rval2gbooleans_args args;
+
+    args.ary = *value = rb_ary_dup(rb_ary_to_ary(*value));
+    args.n = RARRAY_LEN(args.ary);
+    args.result = g_new(gboolean, args.n + 1);
+
+    rb_rescue(rbg_rval2gbooleans_body, (VALUE)&args,
+              rbg_rval2gbooleans_rescue, (VALUE)&args);
+
+    *n = args.n;
+
+    return args.result;
+}
+
+struct rbg_rval2gints_args {
+    VALUE ary;
+    long n;
+    gint *result;
+};
+
+static VALUE
+rbg_rval2gints_body(VALUE value)
+{
+    long i;
+    struct rbg_rval2gints_args *args = (struct rbg_rval2gints_args *)value;
+
+    for (i = 0; i < args->n; i++)
+        args->result[i] = NUM2INT(RARRAY_PTR(args->ary)[i]);
+
+    return Qnil;
+}
+
+static G_GNUC_NORETURN VALUE
+rbg_rval2gints_rescue(VALUE value)
+{
+    g_free(((struct rbg_rval2gints_args *)value)->result);
+
+    rb_exc_raise(rb_errinfo());
+}
+
+gint *
+rbg_rval2gints(volatile VALUE *value, long *n)
+{
+    struct rbg_rval2gints_args args;
+
+    args.ary = *value = rb_ary_dup(rb_ary_to_ary(*value));
+    args.n = RARRAY_LEN(args.ary);
+    args.result = g_new(gint, args.n + 1);
+
+    rb_rescue(rbg_rval2gints_body, (VALUE)&args,
+              rbg_rval2gints_rescue, (VALUE)&args);
+
+    *n = args.n;
+
+    return args.result;
+}
+
+struct rbg_rval2gint8s_args {
+    VALUE ary;
+    long n;
+    gint8 *result;
+};
+
+static VALUE
+rbg_rval2gint8s_body(VALUE value)
+{
+    long i;
+    struct rbg_rval2gint8s_args *args = (struct rbg_rval2gint8s_args *)value;
+
+    for (i = 0; i < args->n; i++)
+        args->result[i] = NUM2CHR(RARRAY_PTR(args->ary)[i]);
+
+    return Qnil;
+}
+
+static G_GNUC_NORETURN VALUE
+rbg_rval2gint8s_rescue(VALUE value)
+{
+    g_free(((struct rbg_rval2gint8s_args *)value)->result);
+
+    rb_exc_raise(rb_errinfo());
+}
+
+gint8 *
+rbg_rval2gint8s(volatile VALUE *value, long *n)
+{
+    struct rbg_rval2gint8s_args args;
+
+    args.ary = *value = rb_ary_dup(rb_ary_to_ary(*value));
+    args.n = RARRAY_LEN(args.ary);
+    args.result = g_new(gint8, args.n + 1);
+
+    rb_rescue(rbg_rval2gint8s_body, (VALUE)&args,
+              rbg_rval2gint8s_rescue, (VALUE)&args);
+
+    *n = args.n;
+
+    return args.result;
+}
+
+struct rbg_rval2guint8s_args {
+    VALUE ary;
+    long n;
+    guint8 *result;
+};
+
+static VALUE
+rbg_rval2guint8s_body(VALUE value)
+{
+    long i;
+    struct rbg_rval2guint8s_args *args = (struct rbg_rval2guint8s_args *)value;
+
+    for (i = 0; i < args->n; i++)
+        args->result[i] = NUM2UINT(RARRAY_PTR(args->ary)[i]);
+
+    return Qnil;
+}
+
+static G_GNUC_NORETURN VALUE
+rbg_rval2guint8s_rescue(VALUE value)
+{
+    g_free(((struct rbg_rval2guint8s_args *)value)->result);
+
+    rb_exc_raise(rb_errinfo());
+}
+
+guint8 *
+rbg_rval2guint8s(volatile VALUE *value, long *n)
+{
+    struct rbg_rval2guint8s_args args;
+
+    args.ary = *value = rb_ary_dup(rb_ary_to_ary(*value));
+    args.n = RARRAY_LEN(args.ary);
+    args.result = g_new(guint8, args.n + 1);
+
+    rb_rescue(rbg_rval2guint8s_body, (VALUE)&args,
+              rbg_rval2guint8s_rescue, (VALUE)&args);
+
+    *n = args.n;
+
+    return args.result;
+}
+
+struct rbg_rval2guint16s_args {
+    VALUE ary;
+    long n;
+    guint16 *result;
+};
+
+static VALUE
+rbg_rval2guint16s_body(VALUE value)
+{
+    long i;
+    struct rbg_rval2guint16s_args *args = (struct rbg_rval2guint16s_args *)value;
+
+    for (i = 0; i < args->n; i++)
+        args->result[i] = NUM2UINT(RARRAY_PTR(args->ary)[i]);
+
+    return Qnil;
+}
+
+static G_GNUC_NORETURN VALUE
+rbg_rval2guint16s_rescue(VALUE value)
+{
+    g_free(((struct rbg_rval2guint16s_args *)value)->result);
+
+    rb_exc_raise(rb_errinfo());
+}
+
+guint16 *
+rbg_rval2guint16s(volatile VALUE *value, long *n)
+{
+    struct rbg_rval2guint16s_args args;
+
+    args.ary = *value = rb_ary_dup(rb_ary_to_ary(*value));
+    args.n = RARRAY_LEN(args.ary);
+    args.result = g_new(guint16, args.n + 1);
+
+    rb_rescue(rbg_rval2guint16s_body, (VALUE)&args,
+              rbg_rval2guint16s_rescue, (VALUE)&args);
+
+    *n = args.n;
+
+    return args.result;
+}
+
+struct rbg_rval2guint32s_args {
+    VALUE ary;
+    long n;
+    guint32 *result;
+};
+
+static VALUE
+rbg_rval2guint32s_body(VALUE value)
+{
+    long i;
+    struct rbg_rval2guint32s_args *args = (struct rbg_rval2guint32s_args *)value;
+
+    for (i = 0; i < args->n; i++)
+        args->result[i] = NUM2UINT(RARRAY_PTR(args->ary)[i]);
+
+    return Qnil;
+}
+
+static G_GNUC_NORETURN VALUE
+rbg_rval2guint32s_rescue(VALUE value)
+{
+    g_free(((struct rbg_rval2guint32s_args *)value)->result);
+
+    rb_exc_raise(rb_errinfo());
+}
+
+guint32 *
+rbg_rval2guint32s(volatile VALUE *value, long *n)
+{
+    struct rbg_rval2guint32s_args args;
+
+    args.ary = *value = rb_ary_dup(rb_ary_to_ary(*value));
+    args.n = RARRAY_LEN(args.ary);
+    args.result = g_new(guint32, args.n + 1);
+
+    rb_rescue(rbg_rval2guint32s_body, (VALUE)&args,
+              rbg_rval2guint32s_rescue, (VALUE)&args);
+
+    *n = args.n;
+
+    return args.result;
+}
+
+struct rbg_rval2gdoubles_args {
+    VALUE ary;
+    long n;
+    gdouble *result;
+};
+
+static VALUE
+rbg_rval2gdoubles_body(VALUE value)
+{
+    long i;
+    struct rbg_rval2gdoubles_args *args = (struct rbg_rval2gdoubles_args *)value;
+
+    for (i = 0; i < args->n; i++)
+        args->result[i] = NUM2DBL(RARRAY_PTR(args->ary)[i]);
+
+    return Qnil;
+}
+
+static G_GNUC_NORETURN VALUE
+rbg_rval2gdoubles_rescue(VALUE value)
+{
+    g_free(((struct rbg_rval2gdoubles_args *)value)->result);
+
+    rb_exc_raise(rb_errinfo());
+}
+
+gdouble *
+rbg_rval2gdoubles(volatile VALUE *value, long *n)
+{
+    struct rbg_rval2gdoubles_args args;
+
+    args.ary = *value = rb_ary_dup(rb_ary_to_ary(*value));
+    args.n = RARRAY_LEN(args.ary);
+    args.result = g_new(gdouble, args.n + 1);
+
+    rb_rescue(rbg_rval2gdoubles_body, (VALUE)&args,
+              rbg_rval2gdoubles_rescue, (VALUE)&args);
+
+    *n = args.n;
+
+    return args.result;
+}
+
+VALUE
+rbg_gints2rval(const gint *gints, long n)
+{
+    long i;
+    VALUE ary = rb_ary_new();
+
+    for (i = 0; i < n; i++)
+        rb_ary_push(ary, INT2NUM(gints[i]));
+
+    return ary;
+}
+
+struct rbg_gints2rval_free_args {
+    gint *gints;
+    long n;
+};
+
+static VALUE
+rbg_gints2rval_free_body(VALUE value)
+{
+    struct rbg_gints2rval_free_args *args = (struct rbg_gints2rval_free_args *)value;
+
+    return rbg_gints2rval(args->gints, args->n);
+}
+
+static VALUE
+rbg_gints2rval_free_ensure(VALUE value)
+{
+    g_free(((struct rbg_gints2rval_free_args *)value)->gints);
+
+    return Qnil;
+}
+
+VALUE
+rbg_gints2rval_free(gint *gints, long n)
+{
+    struct rbg_gints2rval_free_args args = { gints, n };
+
+    return rb_ensure(rbg_gints2rval_free_body, (VALUE)&args,
+                     rbg_gints2rval_free_ensure, (VALUE)&args);
+}
+
+static const char *
+rbg_inspect (VALUE object)
+{
+    VALUE inspected;
+
+    inspected = rb_funcall(object, rb_intern("inspect"), 0);
+    return StringValueCStr(inspected);
+}
+
+
+void
+rbg_scan_options (VALUE options, ...)
+{
+    VALUE original_options = options;
+    VALUE available_keys;
+    const char *key;
+    VALUE *value;
+    va_list args;
+
+    options = rb_check_convert_type(options, T_HASH, "Hash", "to_hash");
+    if (NIL_P(options)) {
+        options = rb_hash_new();
+    } else if (options == original_options) {
+        options = rb_funcall(options, rb_intern("dup"), 0);
+    }
+
+    available_keys = rb_ary_new();
+    va_start(args, options);
+    key = va_arg(args, const char *);
+    while (key) {
+        VALUE rb_key;
+        value = va_arg(args, VALUE *);
+
+        rb_key = ID2SYM(rb_intern(key));
+        rb_ary_push(available_keys, rb_key);
+        *value = rb_funcall(options, rb_intern("delete"), 1, rb_key);
+
+        key = va_arg(args, const char *);
+    }
+    va_end(args);
+
+    if (RVAL2CBOOL(rb_funcall(options, rb_intern("empty?"), 0)))
+        return;
+
+    rb_raise(rb_eArgError,
+             "unexpected key(s) exist: %s: available keys: %s",
+             rbg_inspect(rb_funcall(options, rb_intern("keys"), 0)),
+             rbg_inspect(available_keys));
+}
+
 #if 0
 /*
 2004-04-15 Commented out by Masao.
@@ -476,7 +914,7 @@ Init_mem()
 #endif
 
 static VALUE
-rbg_s_os_win32(VALUE self)
+rg_m_os_win32_p(G_GNUC_UNUSED VALUE self)
 {
 #ifdef G_OS_WIN32
     return Qtrue;
@@ -486,7 +924,7 @@ rbg_s_os_win32(VALUE self)
 }
 
 static VALUE
-rbg_s_os_beos(VALUE self)
+rg_m_os_beos_p(G_GNUC_UNUSED VALUE self)
 {
 #ifdef G_OS_BEOS
     return Qtrue;
@@ -496,7 +934,7 @@ rbg_s_os_beos(VALUE self)
 }
 
 static VALUE
-rbg_s_os_unix(VALUE self)
+rg_m_os_unix_p(G_GNUC_UNUSED VALUE self)
 {
 #ifdef G_OS_UNIX
     return Qtrue;
@@ -505,8 +943,10 @@ rbg_s_os_unix(VALUE self)
 #endif
 }
 
-void 
-Init_glib2()
+extern void Init_glib2(void);
+
+void
+Init_glib2(void)
 {
 #ifdef HAVE_RUBY_ENCODING_H
     const gchar **filename_charsets;
@@ -514,82 +954,82 @@ Init_glib2()
 
     id_inspect = rb_intern("inspect");
 
-    mGLib = rb_define_module("GLib");
+    RG_TARGET_NAMESPACE = rb_define_module("GLib");
 
     setlocale (LC_CTYPE, "");
-#if LC_MESSAGES
+#ifdef LC_MESSAGES
     setlocale (LC_MESSAGES, "");
 #endif
 
     /* Version Information */
-    rb_define_const(mGLib, "VERSION",
+    rb_define_const(RG_TARGET_NAMESPACE, "VERSION",
                     rb_ary_new3(3,
                                 INT2FIX(glib_major_version),
                                 INT2FIX(glib_minor_version),
                                 INT2FIX(glib_micro_version)));
-    rb_define_const(mGLib, "MAJOR_VERSION", INT2FIX(glib_major_version));
-    rb_define_const(mGLib, "MINOR_VERSION", INT2FIX(glib_minor_version));
-    rb_define_const(mGLib, "MICRO_VERSION", INT2FIX(glib_micro_version));
-    rb_define_const(mGLib, "INTERFACE_AGE", INT2FIX(glib_interface_age));
-    rb_define_const(mGLib, "BINARY_AGE", INT2FIX(glib_binary_age));
+    rb_define_const(RG_TARGET_NAMESPACE, "MAJOR_VERSION", INT2FIX(glib_major_version));
+    rb_define_const(RG_TARGET_NAMESPACE, "MINOR_VERSION", INT2FIX(glib_minor_version));
+    rb_define_const(RG_TARGET_NAMESPACE, "MICRO_VERSION", INT2FIX(glib_micro_version));
+    rb_define_const(RG_TARGET_NAMESPACE, "INTERFACE_AGE", INT2FIX(glib_interface_age));
+    rb_define_const(RG_TARGET_NAMESPACE, "BINARY_AGE", INT2FIX(glib_binary_age));
 
-    rb_define_const(mGLib, "BINDING_VERSION",
+    rb_define_const(RG_TARGET_NAMESPACE, "BINDING_VERSION",
                     rb_ary_new3(3,
                                 INT2FIX(RBGLIB_MAJOR_VERSION),
                                 INT2FIX(RBGLIB_MINOR_VERSION),
                                 INT2FIX(RBGLIB_MICRO_VERSION)));
 
-    rb_define_const(mGLib, "BUILD_VERSION",
+    rb_define_const(RG_TARGET_NAMESPACE, "BUILD_VERSION",
                     rb_ary_new3(3,
                                 INT2FIX(GLIB_MAJOR_VERSION),
                                 INT2FIX(GLIB_MINOR_VERSION),
                                 INT2FIX(GLIB_MICRO_VERSION)));
 
     /* Limits of Basic Types */
-    rb_define_const(mGLib, "MININT", INT2FIX(G_MININT));
-    rb_define_const(mGLib, "MAXINT", INT2NUM(G_MAXINT));
-    rb_define_const(mGLib, "MAXUINT", UINT2NUM(G_MAXUINT));
-    
-    rb_define_const(mGLib, "MINSHORT", INT2FIX(G_MINSHORT));
-    rb_define_const(mGLib, "MAXSHORT", INT2FIX(G_MAXSHORT));
-    rb_define_const(mGLib, "MAXUSHORT", UINT2NUM(G_MAXUSHORT));
-
-    rb_define_const(mGLib, "MINLONG", INT2FIX(G_MINLONG));
-    rb_define_const(mGLib, "MAXLONG", INT2NUM(G_MAXLONG));
-    rb_define_const(mGLib, "MAXULONG", UINT2NUM(G_MAXULONG));
+    rb_define_const(RG_TARGET_NAMESPACE, "MININT", INT2FIX(G_MININT));
+    rb_define_const(RG_TARGET_NAMESPACE, "MAXINT", INT2NUM(G_MAXINT));
+    rb_define_const(RG_TARGET_NAMESPACE, "MAXUINT", UINT2NUM(G_MAXUINT));
+
+    rb_define_const(RG_TARGET_NAMESPACE, "MINSHORT", INT2FIX(G_MINSHORT));
+    rb_define_const(RG_TARGET_NAMESPACE, "MAXSHORT", INT2FIX(G_MAXSHORT));
+    rb_define_const(RG_TARGET_NAMESPACE, "MAXUSHORT", UINT2NUM(G_MAXUSHORT));
+
+    rb_define_const(RG_TARGET_NAMESPACE, "MINLONG", INT2FIX(G_MINLONG));
+    rb_define_const(RG_TARGET_NAMESPACE, "MAXLONG", INT2NUM(G_MAXLONG));
+    rb_define_const(RG_TARGET_NAMESPACE, "MAXULONG", UINT2NUM(G_MAXULONG));
 
 #if GLIB_CHECK_VERSION(2,4,0)
-    rb_define_const(mGLib, "MININT8", INT2FIX(G_MININT8));
-    rb_define_const(mGLib, "MAXINT8", INT2FIX(G_MAXINT8));
-    rb_define_const(mGLib, "MAXUINT8", UINT2NUM(G_MAXUINT8));
+    rb_define_const(RG_TARGET_NAMESPACE, "MININT8", INT2FIX(G_MININT8));
+    rb_define_const(RG_TARGET_NAMESPACE, "MAXINT8", INT2FIX(G_MAXINT8));
+    rb_define_const(RG_TARGET_NAMESPACE, "MAXUINT8", UINT2NUM(G_MAXUINT8));
 
-    rb_define_const(mGLib, "MININT16", INT2FIX(G_MININT16));
-    rb_define_const(mGLib, "MAXINT16", INT2FIX(G_MAXINT16));
-    rb_define_const(mGLib, "MAXUINT16", UINT2NUM(G_MAXUINT16));
+    rb_define_const(RG_TARGET_NAMESPACE, "MININT16", INT2FIX(G_MININT16));
+    rb_define_const(RG_TARGET_NAMESPACE, "MAXINT16", INT2FIX(G_MAXINT16));
+    rb_define_const(RG_TARGET_NAMESPACE, "MAXUINT16", UINT2NUM(G_MAXUINT16));
 
-    rb_define_const(mGLib, "MININT32", INT2FIX(G_MININT32));
-    rb_define_const(mGLib, "MAXINT32", INT2NUM(G_MAXINT32));
-    rb_define_const(mGLib, "MAXUINT32", UINT2NUM(G_MAXUINT32));
+    rb_define_const(RG_TARGET_NAMESPACE, "MININT32", INT2FIX(G_MININT32));
+    rb_define_const(RG_TARGET_NAMESPACE, "MAXINT32", INT2NUM(G_MAXINT32));
+    rb_define_const(RG_TARGET_NAMESPACE, "MAXUINT32", UINT2NUM(G_MAXUINT32));
 #endif
-    rb_define_const(mGLib, "MININT64", INT2FIX(G_MININT64));
-    rb_define_const(mGLib, "MAXINT64", LL2NUM(G_MAXINT64));
-    rb_define_const(mGLib, "MAXUINT64", ULL2NUM(G_MAXUINT64));
+    rb_define_const(RG_TARGET_NAMESPACE, "MININT64", INT2FIX(G_MININT64));
+    rb_define_const(RG_TARGET_NAMESPACE, "MAXINT64", LL2NUM(G_MAXINT64));
+    rb_define_const(RG_TARGET_NAMESPACE, "MAXUINT64", ULL2NUM(G_MAXUINT64));
 #if GLIB_CHECK_VERSION(2,4,0)
-    rb_define_const(mGLib, "MAXSIZE", UINT2NUM(G_MAXSIZE));
+    rb_define_const(RG_TARGET_NAMESPACE, "MAXSIZE", UINT2NUM(G_MAXSIZE));
 #endif
-    rb_define_const(mGLib, "MINFLOAT", INT2FIX(G_MINFLOAT));
-    rb_define_const(mGLib, "MAXFLOAT", DBL2NUM(G_MAXFLOAT));
+    rb_define_const(RG_TARGET_NAMESPACE, "MINFLOAT", INT2FIX(G_MINFLOAT));
+    rb_define_const(RG_TARGET_NAMESPACE, "MAXFLOAT", DBL2NUM(G_MAXFLOAT));
 
-    rb_define_const(mGLib, "MINDOUBLE", INT2FIX(G_MINDOUBLE));
-    rb_define_const(mGLib, "MAXDOUBLE", DBL2NUM(G_MAXDOUBLE));
+    rb_define_const(RG_TARGET_NAMESPACE, "MINDOUBLE", INT2FIX(G_MINDOUBLE));
+    rb_define_const(RG_TARGET_NAMESPACE, "MAXDOUBLE", DBL2NUM(G_MAXDOUBLE));
 
     /* Standard Macros */
-    rb_define_module_function(mGLib, "os_win32?", rbg_s_os_win32, 0);
-    rb_define_module_function(mGLib, "os_beos?", rbg_s_os_beos, 0);
-    rb_define_module_function(mGLib, "os_unix?", rbg_s_os_unix, 0);
+    RG_DEF_MODFUNC_P(os_win32, 0);
+    RG_DEF_MODFUNC_P(os_beos, 0);
+    RG_DEF_MODFUNC_P(os_unix, 0);
 
-    rb_define_const(mGLib, "DIR_SEPARATOR", CSTR2RVAL(G_DIR_SEPARATOR_S));
-    rb_define_const(mGLib, "SEARCHPATH_SEPARATOR", CSTR2RVAL(G_SEARCHPATH_SEPARATOR_S));
+    rb_define_const(RG_TARGET_NAMESPACE, "DIR_SEPARATOR", CSTR2RVAL(G_DIR_SEPARATOR_S));
+    rb_define_const(RG_TARGET_NAMESPACE, "SEARCHPATH_SEPARATOR", CSTR2RVAL(G_SEARCHPATH_SEPARATOR_S));
 
     /* discover and store glib filename encoding */
 #ifdef HAVE_RUBY_ENCODING_H
@@ -631,22 +1071,21 @@ Init_glib2()
 union       GFloatIEEE754;
 union       GDoubleIEEE754;
 */
-    rb_define_const(mGLib, "E", CSTR2RVAL(G_STRINGIFY(G_E)));
-    rb_define_const(mGLib, "LN2", CSTR2RVAL(G_STRINGIFY(G_LN2)));
-    rb_define_const(mGLib, "LN10", CSTR2RVAL(G_STRINGIFY(G_LN10)));
-    rb_define_const(mGLib, "PI", CSTR2RVAL(G_STRINGIFY(G_PI)));
-    rb_define_const(mGLib, "PI_2", CSTR2RVAL(G_STRINGIFY(G_PI_2)));
-    rb_define_const(mGLib, "PI_4", CSTR2RVAL(G_STRINGIFY(G_PI_4)));
-    rb_define_const(mGLib, "SQRT2", CSTR2RVAL(G_STRINGIFY(G_SQRT2)));
-    rb_define_const(mGLib, "LOG_2_BASE_10", CSTR2RVAL(G_STRINGIFY(G_LOG_2_BASE_10)));
+    rb_define_const(RG_TARGET_NAMESPACE, "E", CSTR2RVAL(G_STRINGIFY(G_E)));
+    rb_define_const(RG_TARGET_NAMESPACE, "LN2", CSTR2RVAL(G_STRINGIFY(G_LN2)));
+    rb_define_const(RG_TARGET_NAMESPACE, "LN10", CSTR2RVAL(G_STRINGIFY(G_LN10)));
+    rb_define_const(RG_TARGET_NAMESPACE, "PI", CSTR2RVAL(G_STRINGIFY(G_PI)));
+    rb_define_const(RG_TARGET_NAMESPACE, "PI_2", CSTR2RVAL(G_STRINGIFY(G_PI_2)));
+    rb_define_const(RG_TARGET_NAMESPACE, "PI_4", CSTR2RVAL(G_STRINGIFY(G_PI_4)));
+    rb_define_const(RG_TARGET_NAMESPACE, "SQRT2", CSTR2RVAL(G_STRINGIFY(G_SQRT2)));
+    rb_define_const(RG_TARGET_NAMESPACE, "LOG_2_BASE_10", CSTR2RVAL(G_STRINGIFY(G_LOG_2_BASE_10)));
 
     /* From "The Main Event Loop" */
-    rb_define_const(mGLib, "PRIORITY_HIGH", INT2FIX(G_PRIORITY_HIGH));
-    rb_define_const(mGLib, "PRIORITY_DEFAULT", INT2FIX(G_PRIORITY_DEFAULT));
-    rb_define_const(mGLib, "PRIORITY_HIGH_IDLE", INT2FIX(G_PRIORITY_HIGH_IDLE));
-    rb_define_const(mGLib, "PRIORITY_DEFAULT_IDLE", INT2FIX(G_PRIORITY_DEFAULT_IDLE));
-    rb_define_const(mGLib, "PRIORITY_LOW", INT2FIX(G_PRIORITY_LOW));
-
+    rb_define_const(RG_TARGET_NAMESPACE, "PRIORITY_HIGH", INT2FIX(G_PRIORITY_HIGH));
+    rb_define_const(RG_TARGET_NAMESPACE, "PRIORITY_DEFAULT", INT2FIX(G_PRIORITY_DEFAULT));
+    rb_define_const(RG_TARGET_NAMESPACE, "PRIORITY_HIGH_IDLE", INT2FIX(G_PRIORITY_HIGH_IDLE));
+    rb_define_const(RG_TARGET_NAMESPACE, "PRIORITY_DEFAULT_IDLE", INT2FIX(G_PRIORITY_DEFAULT_IDLE));
+    rb_define_const(RG_TARGET_NAMESPACE, "PRIORITY_LOW", INT2FIX(G_PRIORITY_LOW));
 
 /*    Init_mem(); */
     Init_gutil();
@@ -665,18 +1104,26 @@ union       GDoubleIEEE754;
     /* Require GBoxed/GObject */
     Init_glib_utils();
     Init_glib_spawn();
+    Init_glib_spawnerror();
     Init_glib_main_loop();
     Init_glib_source();
     Init_glib_main_context();
     Init_glib_poll_fd();
     Init_glib_io_channel();
+    Init_glib_io_channelerror();
+    Init_glib_io_channel_win32_socket();
     Init_glib_shell();
+    Init_glib_shellerror();
     Init_glib_completion();
     Init_glib_timer();
     Init_glib_unicode();
+    Init_glib_utf8();
+    Init_glib_utf16();
+    Init_glib_ucs4();
+    Init_glib_unichar();
     Init_glib_keyfile();
     Init_glib_bookmark_file();
 
     /* This is called here once. */
-    G_DEF_SETTERS(mGLib);
+    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
 }