glib2 1.0.3 → 1.1.0

data/ext/glib2/rbglib_utf16.c

@@ -0,0 +1,78 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2006  Kouhei Sutou
+ *
+ *  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 "rbgprivate.h"
+#include "rbglib.h"
+
+#define RG_TARGET_NAMESPACE mUTF16
+
+static VALUE
+rg_m_to_ucs4(G_GNUC_UNUSED VALUE self, VALUE rb_utf16)
+{
+    VALUE result;
+    gunichar *ucs4;
+    gunichar2 *utf16;
+    glong len, items_written;
+    GError *error = NULL;
+
+    utf16 = (gunichar2 *)StringValueCStr(rb_utf16);
+    len = RSTRING_LEN(rb_utf16) / sizeof(*utf16);
+
+    ucs4 = g_utf16_to_ucs4(utf16, len, NULL, &items_written, &error);
+
+    if (error)
+        RAISE_GERROR(error);
+
+    result = CSTR2RVAL_LEN_UCS4((char *)ucs4, items_written * sizeof(*ucs4));
+    g_free(ucs4);
+    return result;
+}
+
+static VALUE
+rg_m_to_utf8(G_GNUC_UNUSED VALUE self, VALUE rb_utf16)
+{
+    VALUE result;
+    gchar *utf8;
+    gunichar2 *utf16;
+    glong len, items_written;
+    GError *error = NULL;
+
+    utf16 = (gunichar2 *)StringValueCStr(rb_utf16);
+    len = RSTRING_LEN(rb_utf16) / sizeof(*utf16);
+
+    utf8 = g_utf16_to_utf8(utf16, len, NULL, &items_written, &error);
+
+    if (error)
+        RAISE_GERROR(error);
+
+    result = CSTR2RVAL_LEN(utf8, items_written * sizeof(*utf8));
+    g_free(utf8);
+    return result;
+}
+
+void
+Init_glib_utf16(void)
+{
+    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(mGLib, "UTF16");
+
+    RG_DEF_MODFUNC(to_ucs4, 1);
+    RG_DEF_MODFUNC(to_utf8, 1);
+}

data/ext/glib2/rbglib_utf8.c

@@ -0,0 +1,259 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2006  Kouhei Sutou
+ *
+ *  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 "rbgprivate.h"
+#include "rbglib.h"
+
+#define RG_TARGET_NAMESPACE mUTF8
+
+static VALUE
+rg_m_get_char(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
+{
+    VALUE utf8, validate;
+    gunichar result;
+
+    rb_scan_args(argc, argv, "11", &utf8, &validate);
+
+    if (RVAL2CBOOL(validate)) {
+        StringValue(utf8);
+        result = g_utf8_get_char_validated(RSTRING_PTR(utf8),
+                                           RSTRING_LEN(utf8));
+        if (result == (gunichar)-1) {
+            return INT2NUM(-1);
+        } else if (result == (gunichar)-2) {
+            return INT2NUM(-2);
+        }
+    } else {
+        result = g_utf8_get_char(StringValueCStr(utf8));
+    }
+
+    return UINT2NUM(result);
+}
+
+static VALUE
+rg_m_size(G_GNUC_UNUSED VALUE self, VALUE rb_utf8)
+{
+    gchar *utf8;
+
+    utf8 = StringValueCStr(rb_utf8);
+    return INT2NUM(g_utf8_strlen(utf8, RSTRING_LEN(rb_utf8)));
+}
+
+static VALUE
+rg_m_reverse(G_GNUC_UNUSED VALUE self, VALUE rb_utf8)
+{
+    VALUE result;
+    gchar *utf8, *reversed_utf8;
+
+    utf8 = StringValueCStr(rb_utf8);
+    reversed_utf8 = g_utf8_strreverse(utf8, RSTRING_LEN(rb_utf8));
+    result = CSTR2RVAL(reversed_utf8);
+    g_free(reversed_utf8);
+    return result;
+}
+
+static VALUE
+rg_m_validate(G_GNUC_UNUSED VALUE self, VALUE str)
+{
+    StringValue(str);
+    return CBOOL2RVAL(g_utf8_validate(RSTRING_PTR(str), RSTRING_LEN(str),
+                                      NULL));
+}
+
+static VALUE
+rg_m_upcase(G_GNUC_UNUSED VALUE self, VALUE rb_utf8)
+{
+    VALUE result;
+    gchar *utf8, *upcased_utf8;
+
+    utf8 = StringValueCStr(rb_utf8);
+    upcased_utf8 = g_utf8_strup(utf8, RSTRING_LEN(rb_utf8));
+    result = CSTR2RVAL(upcased_utf8);
+    g_free(upcased_utf8);
+    return result;
+}
+
+static VALUE
+rg_m_downcase(G_GNUC_UNUSED VALUE self, VALUE rb_utf8)
+{
+    VALUE result;
+    gchar *utf8, *downcased_utf8;
+
+    utf8 = StringValueCStr(rb_utf8);
+    downcased_utf8 = g_utf8_strdown(utf8, RSTRING_LEN(rb_utf8));
+    result = CSTR2RVAL(downcased_utf8);
+    g_free(downcased_utf8);
+    return result;
+}
+
+static VALUE
+rg_m_casefold(G_GNUC_UNUSED VALUE self, VALUE rb_utf8)
+{
+    VALUE result;
+    gchar *utf8, *casefolded_utf8;
+
+    utf8 = StringValueCStr(rb_utf8);
+    casefolded_utf8 = g_utf8_casefold(utf8, RSTRING_LEN(rb_utf8));
+    result = CSTR2RVAL(casefolded_utf8);
+    g_free(casefolded_utf8);
+    return result;
+}
+
+static VALUE
+rg_m_normalize(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
+{
+    VALUE rb_utf8, rb_mode, result;
+    gchar *utf8, *normalized_utf8;
+    GNormalizeMode mode = G_NORMALIZE_DEFAULT;
+
+    rb_scan_args(argc, argv, "11", &rb_utf8, &rb_mode);
+
+    if (!NIL_P(rb_mode))
+        mode = RVAL2GENUM(rb_mode, G_TYPE_NORMALIZE_MODE);
+
+    utf8 = StringValueCStr(rb_utf8);
+    normalized_utf8 = g_utf8_normalize(utf8, RSTRING_LEN(rb_utf8), mode);
+    result = CSTR2RVAL(normalized_utf8);
+    g_free(normalized_utf8);
+    return result;
+}
+
+static VALUE
+rg_m_collate(G_GNUC_UNUSED VALUE self, VALUE utf8a, VALUE utf8b)
+{
+    return INT2NUM(g_utf8_collate(StringValueCStr(utf8a),
+                                  StringValueCStr(utf8b)));
+}
+
+static VALUE
+rg_m_collate_key(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
+{
+    VALUE result, rb_utf8, for_filename;
+    gchar *key, *utf8;
+    gssize len;
+
+    rb_scan_args(argc, argv, "11", &rb_utf8, &for_filename);
+
+    utf8 = StringValueCStr(rb_utf8);
+    len = RSTRING_LEN(rb_utf8);
+#if GLIB_CHECK_VERSION(2,8,0)
+    if (RVAL2CBOOL(for_filename))
+        key = g_utf8_collate_key_for_filename(utf8, len);
+    else
+#endif
+        key = g_utf8_collate_key(utf8, len);
+
+    result = CSTR2RVAL(key);
+    g_free(key);
+    return result;
+}
+
+static VALUE
+rg_m_to_utf16(G_GNUC_UNUSED VALUE self, VALUE rb_utf8)
+{
+    VALUE result;
+    gchar *utf8;
+    gunichar2 *utf16;
+    glong len, items_written;
+    GError *error = NULL;
+
+    utf8 = StringValueCStr(rb_utf8);
+    len = RSTRING_LEN(rb_utf8);
+
+    utf16 = g_utf8_to_utf16(utf8, len, NULL, &items_written, &error);
+
+    if (error)
+        RAISE_GERROR(error);
+
+    result = CSTR2RVAL_LEN_UTF16((char *)utf16,
+                                   items_written * sizeof(*utf16));
+    g_free(utf16);
+    return result;
+}
+
+static VALUE
+rg_m_to_ucs4(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
+{
+    VALUE result, rb_utf8, is_fast;
+    gchar *utf8;
+    gunichar *ucs4;
+    glong len, items_written;
+
+    rb_scan_args(argc, argv, "11", &rb_utf8, &is_fast);
+
+    utf8 = StringValueCStr(rb_utf8);
+    len = RSTRING_LEN(rb_utf8);
+
+    if (RVAL2CBOOL(is_fast)) {
+        ucs4 = g_utf8_to_ucs4_fast(utf8, len, &items_written);
+    } else {
+        GError *error = NULL;
+        ucs4 = g_utf8_to_ucs4(utf8, len, NULL, &items_written, &error);
+
+        if (error)
+            RAISE_GERROR(error);
+    }
+
+    result = CSTR2RVAL_LEN_UCS4((char *)ucs4, items_written * sizeof(*ucs4));
+    g_free(ucs4);
+    return result;
+}
+
+void
+Init_glib_utf8(void)
+{
+    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(mGLib, "UTF8");
+
+    /*
+      Not implemented.
+      g_utf8_next_char
+    */
+    RG_DEF_MODFUNC(get_char, -1);
+    /*
+      Not implemented.
+      g_utf8_offset_to_pointer
+      g_utf8_pointer_to_offset
+      g_utf8_prev_char
+      g_utf8_find_next_char
+      g_utf8_find_prev_char
+      g_utf8_prev_char
+    */
+    RG_DEF_MODFUNC(size, 1);
+    /*
+      Not implemented.
+      g_utf8_strncpy
+      g_utf8_strrchr
+    */
+    RG_DEF_MODFUNC(reverse, 1);
+    RG_DEF_MODFUNC(validate, 1);
+
+    RG_DEF_MODFUNC(upcase, 1);
+    RG_DEF_MODFUNC(downcase, 1);
+    RG_DEF_MODFUNC(casefold, 1);
+
+    RG_DEF_MODFUNC(normalize, -1);
+
+    RG_DEF_MODFUNC(collate, 2);
+    RG_DEF_MODFUNC(collate_key, -1);
+
+    RG_DEF_MODFUNC(to_utf16, 1);
+    RG_DEF_MODFUNC(to_ucs4, -1);
+}

data/ext/glib2/rbglib_utils.c

@@ -1,63 +1,74 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/**********************************************************************
-
-  rbglib_utils.c -
-
-  $Author: ggc $
-  $Date: 2007/07/13 16:07:28 $
-
-  Copyright (C) 2004 Ruby-GNOME2 Project Team
-  Copyright (C) 2004 Pascal Terjan
-
-**********************************************************************/
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2004  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2004  Pascal Terjan
+ *
+ *  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 "rbgprivate.h"
 
+#define RG_TARGET_NAMESPACE mGLib
+
 #if GLIB_CHECK_VERSION(2,2,0)
 static VALUE
-rbglib_m_application_name(VALUE self)
+rg_m_application_name(G_GNUC_UNUSED VALUE self)
 {
     return CSTR2RVAL(g_get_application_name());
 }
 
 static VALUE
-rbglib_m_set_application_name(VALUE self, VALUE application_name)
+rg_m_set_application_name(VALUE self, VALUE application_name)
 {
-    g_set_prgname(NIL_P(application_name) ? NULL : RVAL2CSTR(application_name));
+    g_set_prgname(RVAL2CSTR_ACCEPT_NIL(application_name));
     return self;
 }
 #endif
 
 static VALUE
-rbglib_m_prgname(VALUE self)
+rg_m_prgname(G_GNUC_UNUSED VALUE self)
 {
     return CSTR2RVAL(g_get_prgname());
 }
 
 static VALUE
-rbglib_m_set_prgname(VALUE self, VALUE prgname)
+rg_m_set_prgname(VALUE self, VALUE prgname)
 {
-    g_set_prgname(NIL_P(prgname) ? NULL : RVAL2CSTR(prgname));
+    g_set_prgname(RVAL2CSTR_ACCEPT_NIL(prgname));
     return self;
 }
 
 static VALUE
-rbglib_m_env(VALUE self, VALUE variable)
+rg_m_getenv(G_GNUC_UNUSED VALUE self, VALUE variable)
 {
     return CSTR2RVAL(g_getenv(RVAL2CSTR(variable)));
 }
 
 #if GLIB_CHECK_VERSION(2,4,0)
 static VALUE
-rbglib_m_setenv(VALUE self, VALUE variable, VALUE value, VALUE overwrite)
+rg_m_setenv(G_GNUC_UNUSED VALUE self, VALUE variable, VALUE value, VALUE overwrite)
 {
     return CBOOL2RVAL(g_setenv(RVAL2CSTR(variable), 
-                               NIL_P(value) ? NULL : RVAL2CSTR(value),
+                               RVAL2CSTR_ACCEPT_NIL(value),
                                RVAL2CBOOL(overwrite)));
 }
 
 static VALUE
-rbglib_m_unsetenv(VALUE self, VALUE variable)
+rg_m_unsetenv(VALUE self, VALUE variable)
 {
     g_unsetenv(RVAL2CSTR(variable));
     return self;
@@ -65,9 +76,9 @@ rbglib_m_unsetenv(VALUE self, VALUE variable)
 #endif
 
 #if GLIB_CHECK_VERSION(2,8,0)
-#if HAVE_G_LISTENV
+#ifdef HAVE_G_LISTENV
 static VALUE
-rbglib_m_listenv(VALUE self)
+rg_m_listenv(VALUE self)
 {
     gchar** c_list;
     gchar** c_var;
@@ -83,51 +94,51 @@ rbglib_m_listenv(VALUE self)
 #endif
 
 static VALUE
-rbglib_m_host_name(VALUE self)
+rg_m_host_name(G_GNUC_UNUSED VALUE self)
 {
     return CSTR2RVAL(g_get_host_name());
 }
 #endif
 
 static VALUE
-rbglib_m_user_name(VALUE self)
+rg_m_user_name(G_GNUC_UNUSED VALUE self)
 {
     return CSTR2RVAL(g_get_user_name());
 }
 
 static VALUE
-rbglib_m_real_name(VALUE self)
+rg_m_real_name(G_GNUC_UNUSED VALUE self)
 {
     return CSTR2RVAL(g_get_real_name());
 }
 
 #if GLIB_CHECK_VERSION(2, 6, 0)
 static VALUE
-rbglib_m_user_cache_dir(VALUE self)
+rg_m_user_cache_dir(G_GNUC_UNUSED VALUE self)
 {
     return CSTR2RVAL(g_get_user_cache_dir());
 }
 
 static VALUE
-rbglib_m_user_data_dir(VALUE self)
+rg_m_user_data_dir(G_GNUC_UNUSED VALUE self)
 {
     return CSTR2RVAL(g_get_user_data_dir());
 }
 
 static VALUE
-rbglib_m_user_config_dir(VALUE self)
+rg_m_user_config_dir(G_GNUC_UNUSED VALUE self)
 {
     return CSTR2RVAL(g_get_user_config_dir());
 }
 
 static VALUE
-rbglib_m_system_data_dirs(VALUE self)
+rg_m_system_data_dirs(G_GNUC_UNUSED VALUE self)
 {
     return STRV2RVAL((const gchar **)g_get_system_data_dirs());
 }
 
 static VALUE
-rbglib_m_system_config_dirs(VALUE self)
+rg_m_system_config_dirs(G_GNUC_UNUSED VALUE self)
 {
     return STRV2RVAL((const gchar **)g_get_system_config_dirs());
 }
@@ -135,27 +146,27 @@ rbglib_m_system_config_dirs(VALUE self)
 
 #if GLIB_CHECK_VERSION(2, 14, 0)
 static VALUE
-rbglib_m_get_user_special_dir(VALUE self, VALUE directory)
+rg_m_get_user_special_dir(G_GNUC_UNUSED VALUE self, VALUE directory)
 {
     return CSTR2RVAL(g_get_user_special_dir(RVAL2GENUM(directory,
-						       G_TYPE_USER_DIRECTORY)));
+                                           G_TYPE_USER_DIRECTORY)));
 }
 #endif
 
 static VALUE
-rbglib_m_home_dir(VALUE self)
+rg_m_home_dir(G_GNUC_UNUSED VALUE self)
 {
     return CSTR2RVAL(g_get_home_dir());
 }
 
 static VALUE
-rbglib_m_tmp_dir(VALUE self)
+rg_m_tmp_dir(G_GNUC_UNUSED VALUE self)
 {
     return CSTR2RVAL(g_get_tmp_dir());
 }
 
 static VALUE
-rbglib_m_current_dir(VALUE self)
+rg_m_current_dir(G_GNUC_UNUSED VALUE self)
 {
     gchar* dir = g_get_current_dir();
     VALUE ret = CSTR2RVAL(dir);
@@ -164,25 +175,25 @@ rbglib_m_current_dir(VALUE self)
 }
 
 static VALUE
-rbglib_m_path_is_absolute(VALUE self, VALUE fname)
+rg_m_path_is_absolute_p(G_GNUC_UNUSED VALUE self, VALUE fname)
 {
     return CBOOL2RVAL(g_path_is_absolute(RVAL2CSTR(fname)));
 }
 
 static VALUE
-rbglib_m_path_skip_root(VALUE self, VALUE fname)
+rg_m_path_skip_root(G_GNUC_UNUSED VALUE self, VALUE fname)
 {
     return CSTR2RVAL(g_path_skip_root(RVAL2CSTR(fname)));
 }
 
 static VALUE
-rbglib_m_path_get_basename(VALUE self, VALUE fname)
+rg_m_path_get_basename(G_GNUC_UNUSED VALUE self, VALUE fname)
 {
     return CSTR2RVAL(g_path_get_basename(RVAL2CSTR(fname)));
 }
 
 static VALUE
-rbglib_m_path_get_dirname(VALUE self, VALUE fname)
+rg_m_path_get_dirname(G_GNUC_UNUSED VALUE self, VALUE fname)
 {
     return CSTR2RVAL(g_path_get_dirname(RVAL2CSTR(fname)));
 }
@@ -200,7 +211,7 @@ gchar*      g_build_pathv                   (const gchar *separator,
 */
 
 static VALUE
-rbglib_m_find_program_in_path(VALUE self, VALUE program)
+rg_m_find_program_in_path(G_GNUC_UNUSED VALUE self, VALUE program)
 {
     gchar* path = g_find_program_in_path(RVAL2CSTR(program));
     VALUE ret = CSTR2RVAL(path);
@@ -209,25 +220,25 @@ rbglib_m_find_program_in_path(VALUE self, VALUE program)
 }
 
 static VALUE
-rbglib_m_bit_nth_lsf(VALUE self, VALUE mask, VALUE nth_bit)
+rg_m_bit_nth_lsf(G_GNUC_UNUSED VALUE self, VALUE mask, VALUE nth_bit)
 {
     return INT2NUM(g_bit_nth_lsf(NUM2ULONG(mask), NUM2INT(nth_bit)));
 }
 
 static VALUE
-rbglib_m_bit_nth_msf(VALUE self, VALUE mask, VALUE nth_bit)
+rg_m_bit_nth_msf(G_GNUC_UNUSED VALUE self, VALUE mask, VALUE nth_bit)
 {
     return INT2NUM(g_bit_nth_msf(NUM2ULONG(mask), NUM2INT(nth_bit)));
 }
 
 static VALUE
-rbglib_m_bit_storage(VALUE self, VALUE number)
+rg_m_bit_storage(G_GNUC_UNUSED VALUE self, VALUE number)
 {
     return UINT2NUM(g_bit_storage(NUM2ULONG(number)));
 }
 
 static VALUE
-rbglib_m_spaced_primes_closest(VALUE self, VALUE num)
+rg_m_spaced_primes_closest(G_GNUC_UNUSED VALUE self, VALUE num)
 {
     return UINT2NUM(g_spaced_primes_closest(NUM2UINT(num)));
 }
@@ -238,7 +249,7 @@ void        g_atexit                        (GVoidFunc func);
 */
 
 static VALUE
-rbglib_m_parse_debug_string(VALUE self, VALUE string, VALUE keys)
+rg_m_parse_debug_string(G_GNUC_UNUSED VALUE self, VALUE string, VALUE keys)
 {
     gint i, nkeys;
     VALUE ary;
@@ -252,7 +263,7 @@ rbglib_m_parse_debug_string(VALUE self, VALUE string, VALUE keys)
         gkeys[i].key = RVAL2CSTR(RARRAY_PTR(RARRAY_PTR(ary)[i])[0]);
         gkeys[i].value = NUM2UINT(RARRAY_PTR(RARRAY_PTR(ary)[i])[1]);
     }
-   
+
     return UINT2NUM(g_parse_debug_string(RVAL2CSTR(string), gkeys, nkeys));
 }
 
@@ -271,7 +282,7 @@ void        g_nullify_pointer               (gpointer *nullify_location);
 */
 
 static VALUE
-rbglib_m_check_version(VALUE self, VALUE major, VALUE minor, VALUE micro)
+rg_m_check_version_p(G_GNUC_UNUSED VALUE self, VALUE major, VALUE minor, VALUE micro)
 {
     return CBOOL2RVAL(glib_major_version > NUM2UINT(major) ||
                       (glib_major_version == NUM2UINT(major) && 
@@ -282,65 +293,58 @@ rbglib_m_check_version(VALUE self, VALUE major, VALUE minor, VALUE micro)
 }
 
 void
-Init_glib_utils()
+Init_glib_utils(void)
 {
     /* glib/gutils.h */
 #if GLIB_CHECK_VERSION(2, 14, 0)
-    G_DEF_CLASS(G_TYPE_USER_DIRECTORY, "UserDirectory", mGLib);
-    G_DEF_CONSTANTS(mGLib, G_TYPE_USER_DIRECTORY, "G_");
+    G_DEF_CLASS(G_TYPE_USER_DIRECTORY, "UserDirectory", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, G_TYPE_USER_DIRECTORY, "G_");
 #endif
 
 #if GLIB_CHECK_VERSION(2,2,0)
-    rb_define_module_function(mGLib, "application_name", rbglib_m_application_name, 0);
-    rb_define_module_function(mGLib, "set_application_name", rbglib_m_set_application_name, 1);
+    RG_DEF_MODFUNC(application_name, 0);
+    RG_DEF_MODFUNC(set_application_name, 1);
 #endif
-    rb_define_module_function(mGLib, "prgname", rbglib_m_prgname, 0);
-    rb_define_module_function(mGLib, "set_prgname", rbglib_m_set_prgname, 1);
-    rb_define_module_function(mGLib, "getenv", rbglib_m_env, 1);
+    RG_DEF_MODFUNC(prgname, 0);
+    RG_DEF_MODFUNC(set_prgname, 1);
+    RG_DEF_MODFUNC(getenv, 1);
 #if GLIB_CHECK_VERSION(2,4,0)
-    rb_define_module_function(mGLib, "setenv", rbglib_m_setenv, 2);
-    rb_define_module_function(mGLib, "unsetenv", rbglib_m_unsetenv, 1);
+    RG_DEF_MODFUNC(setenv, 2);
+    RG_DEF_MODFUNC(unsetenv, 1);
 #endif
 #if GLIB_CHECK_VERSION(2,8,0)
-#if HAVE_G_LISTENV
-    rb_define_module_function(mGLib, "listenv", rbglib_m_listenv, 0);
+#ifdef HAVE_G_LISTENV
+    RG_DEF_MODFUNC(listenv, 0);
 #endif
-    rb_define_module_function(mGLib, "host_name", rbglib_m_host_name, 0);
+    RG_DEF_MODFUNC(host_name, 0);
 #endif
-    rb_define_module_function(mGLib, "user_name", rbglib_m_user_name, 0);
-    rb_define_module_function(mGLib, "real_name", rbglib_m_real_name, 0);
+    RG_DEF_MODFUNC(user_name, 0);
+    RG_DEF_MODFUNC(real_name, 0);
 
 #if GLIB_CHECK_VERSION(2, 6, 0)
-    rb_define_module_function(mGLib, "user_cache_dir",
-			      rbglib_m_user_cache_dir, 0);
-    rb_define_module_function(mGLib, "user_data_dir",
-			      rbglib_m_user_data_dir, 0);
-    rb_define_module_function(mGLib, "user_config_dir",
-			      rbglib_m_user_config_dir, 0);
-    rb_define_module_function(mGLib, "system_data_dirs",
-			      rbglib_m_system_data_dirs, 0);
-    rb_define_module_function(mGLib, "system_config_dirs",
-			      rbglib_m_system_config_dirs, 0);
+    RG_DEF_MODFUNC(user_cache_dir, 0);
+    RG_DEF_MODFUNC(user_data_dir, 0);
+    RG_DEF_MODFUNC(user_config_dir, 0);
+    RG_DEF_MODFUNC(system_data_dirs, 0);
+    RG_DEF_MODFUNC(system_config_dirs, 0);
 #endif
 #if GLIB_CHECK_VERSION(2, 14, 0)
-    rb_define_module_function(mGLib, "get_user_special_dir",
-			      rbglib_m_get_user_special_dir, 1);
+    RG_DEF_MODFUNC(get_user_special_dir, 1);
 #endif
-    rb_define_module_function(mGLib, "home_dir", rbglib_m_home_dir, 0);
-    rb_define_module_function(mGLib, "tmp_dir", rbglib_m_tmp_dir, 0);
-    rb_define_module_function(mGLib, "current_dir", rbglib_m_current_dir, 0);
-
-    rb_define_module_function(mGLib, "path_is_absolute?", rbglib_m_path_is_absolute, 1);
-    rb_define_module_function(mGLib, "path_skip_root", rbglib_m_path_skip_root, 1);
-    rb_define_module_function(mGLib, "path_get_basename", rbglib_m_path_get_basename, 1);
-    rb_define_module_function(mGLib, "path_get_dirname", rbglib_m_path_get_dirname, 1);
-    rb_define_module_function(mGLib, "find_program_in_path", rbglib_m_find_program_in_path, 1);
-    rb_define_module_function(mGLib, "bit_nth_lsf", rbglib_m_bit_nth_lsf, 2);
-    rb_define_module_function(mGLib, "bit_nth_msf", rbglib_m_bit_nth_msf, 2);
-    rb_define_module_function(mGLib, "bit_storage", rbglib_m_bit_storage, 1);
-    rb_define_module_function(mGLib, "spaced_primes_closest", rbglib_m_spaced_primes_closest, 1);
-    rb_define_module_function(mGLib, "parse_debug_string", rbglib_m_parse_debug_string, 2);
-    rb_define_module_function(mGLib, "check_version?", rbglib_m_check_version, 3);
+    RG_DEF_MODFUNC(home_dir, 0);
+    RG_DEF_MODFUNC(tmp_dir, 0);
+    RG_DEF_MODFUNC(current_dir, 0);
+
+    RG_DEF_MODFUNC_P(path_is_absolute, 1);
+    RG_DEF_MODFUNC(path_skip_root, 1);
+    RG_DEF_MODFUNC(path_get_basename, 1);
+    RG_DEF_MODFUNC(path_get_dirname, 1);
+    RG_DEF_MODFUNC(find_program_in_path, 1);
+    RG_DEF_MODFUNC(bit_nth_lsf, 2);
+    RG_DEF_MODFUNC(bit_nth_msf, 2);
+    RG_DEF_MODFUNC(bit_storage, 1);
+    RG_DEF_MODFUNC(spaced_primes_closest, 1);
+    RG_DEF_MODFUNC(parse_debug_string, 2);
+    RG_DEF_MODFUNC_P(check_version, 3);
 
 }
-