glib2 3.0.7-x86-mingw32 → 3.0.8-x86-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: af5a0026f29e787fc6726704b05f9c8e1e627e16
-  data.tar.gz: ed8c3cc0de2fd132e75dedfe5af4620ab55a9ed4
+  metadata.gz: 8cacb9b9e2c877352a6b54a8afbc90d2a315047d
+  data.tar.gz: c977f062ab3b32e4caa3fc32f3f8fe2cebc65cb8
 SHA512:
-  metadata.gz: 724f0d89971171f694473ffe75be4ad999c0ac64bf05da0288e2b55f82d1f7943269a93f276d4d97c38d1524d5bc720d9518cbdc95e485c73df3216cd1f94aaf
-  data.tar.gz: 73028077b4621675699294ad663d198daede18f630049772d93672a3e3f7b95f87fbe7b453d152f05df79f4d51a34d32f22e93486658f92fc45798f85c95bc82
+  metadata.gz: 9992937d9125dbb1a454917b16963a3059c346e77b2c559d48e9f17be7c94cf1abdefb81a1e97d6fcbf86867dd556e5f136b7095acc97db3c56dbc5f24183108
+  data.tar.gz: 725bfb9cd730391d24268eee67c2ec94673e5a62879e9f197fa3495b6dec2fce9160e011f860ca98f4492c00840e42dd18240028ed2755721b18816bc8abe75d

data/Rakefile

@@ -54,7 +54,7 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
       :name => "gettext",
       :download_site => :gnu,
       :label => "gettext-runtime",
-      :version => "0.19.5",
+      :version => "0.19.7",
       :base_dir_in_package => "gettext-runtime",
       :windows => {
         :built_file => "bin/libintl-8.dll",
@@ -69,25 +69,37 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
         :built_file => "bin/libffi-6.dll",
       },
     },
+    {
+      :name => "pcre",
+      :download_base_url => "ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre",
+      :label => "PCRE",
+      :version => "8.38",
+      :windows => {
+        :configure_args => [
+          "--enable-unicode-properties",
+        ],
+        :built_file => "bin/libpcre-1.dll",
+      },
+    },
     {
       :name => "glib",
       :download_site => :gnome,
       :label => "GLib",
-      :version => "2.44.1",
+      :version => "2.48.0",
       :compression_method => "xz",
       :windows => {
         :need_autoreconf => true,
         :patches => [
-          "glib-2.38.2-add-missing-exeext.diff",
+          "glib-2.48.0-add-missing-exeext.diff",
         ],
         :built_file => "bin/libglib-2.0-0.dll",
       },
     },
     {
       :name => "gmp",
-      :download_base_url => "ftp://ftp.gmplib.org/pub/gmp-6.0.0",
+      :download_base_url => "ftp://ftp.gmplib.org/pub/gmp-6.1.0",
       :label => "GNU MP",
-      :version => "6.0.0",
+      :version => "6.1.0",
       :compression_method => "xz",
       :windows => {
         :configure_args => [
@@ -101,17 +113,17 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
       :name => "nettle",
       :download_base_url => "http://www.lysator.liu.se/~nisse/archive",
       :label => "Nettle",
-      :version => "3.1.1",
+      :version => "3.2",
       :windows => {
         :configure_args => [],
-        :built_file => "bin/libnettle-6-1.dll",
+        :built_file => "bin/libnettle-6-2.dll",
       },
     },
     {
       :name => "libtasn1",
       :download_site => :gnu,
       :label => "Libtasn1",
-      :version => "4.6",
+      :version => "4.7",
       :windows => {
         :built_file => "bin/libtasn1-6.dll",
       },
@@ -127,9 +139,9 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
     },
     {
       :name => "p11-kit",
-      :download_base_url => "http://p11-glue.freedesktop.org/releases",
+      :download_base_url => "https://p11-glue.freedesktop.org/releases",
       :label => "p11-kit",
-      :version => "0.23.1",
+      :version => "0.23.2",
       :windows => {
         :built_file => "bin/libp11-kit-0.dll",
       },
@@ -138,7 +150,7 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
       :name => "gnutls",
       :download_base_url => "ftp://ftp.gnutls.org/gcrypt/gnutls/v3.4",
       :label => "GnuTLS",
-      :version => "3.4.4",
+      :version => "3.4.10",
       :compression_method => "xz",
       :windows => {
         :configure_args => [
@@ -156,7 +168,7 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
       :name => "glib-networking",
       :download_site => :gnome,
       :label => "glib-networking",
-      :version => "2.44.0",
+      :version => "2.48.0",
       :compression_method => "xz",
       :windows => {
         :configure_args => [

data/ext/glib2/extconf.rb

@@ -17,6 +17,7 @@ require 'mkmf-gnome2'
 setup_windows(module_name, base_dir)
 
 unless required_pkg_config_package([package_id, 2, 12, 0],
+                                   :altlinux => "glib2-devel",
                                    :debian => "libglib2.0-dev",
                                    :redhat => "glib2-devel",
                                    :arch => "glib2",

data/ext/glib2/glib2.def

@@ -69,8 +69,11 @@ EXPORTS
 	rbg_rval_inspect
 	rbg_string_value_ptr
 	rbg_rval2cstr
+	rbg_rval2cstr_raw
 	rbg_rval2cstr_ptr
 	rbg_rval2cstr_accept_nil
+	rbg_rval2cstr_raw_accept_nil
+	rbg_rval2cstr_ptr_accept_nil
 	rbg_rval2cstr_accept_symbol
 	rbg_rval2cstr_accept_symbol_accept_nil
 	rbg_rval2glibid
@@ -116,6 +119,7 @@ EXPORTS
 	rbg_inspect
 	rbg_interrupt_source_new
 	rbg_name_to_nick
+	rbg_memzero
 	rbgutil_id_module_eval		DATA
 	rbgutil_def_setters
 	rbgutil_glist2ary

data/ext/glib2/rbglib-variant.c

@@ -39,11 +39,45 @@ rbg_variant_to_ruby(GVariant *variant)
 
     if (g_variant_type_equal(type, G_VARIANT_TYPE_BOOLEAN)) {
         return CBOOL2RVAL(g_variant_get_boolean(variant));
-    } else if (g_variant_type_equal(type, G_VARIANT_TYPE_STRING)) {
+    } else if (g_variant_type_equal(type, G_VARIANT_TYPE_BYTE)) {
+        return UINT2NUM(g_variant_get_byte(variant));
+    } else if (g_variant_type_equal(type, G_VARIANT_TYPE_INT16)) {
+        return INT2NUM(g_variant_get_int16(variant));
+    } else if (g_variant_type_equal(type, G_VARIANT_TYPE_UINT16)) {
+        return UINT2NUM(g_variant_get_uint16(variant));
+    } else if (g_variant_type_equal(type, G_VARIANT_TYPE_INT32)) {
+        return INT2NUM(g_variant_get_int32(variant));
+    } else if (g_variant_type_equal(type, G_VARIANT_TYPE_UINT32)) {
+        return UINT2NUM(g_variant_get_uint32(variant));
+    } else if (g_variant_type_equal(type, G_VARIANT_TYPE_INT64)) {
+        return rbglib_int64_to_num(g_variant_get_int64(variant));
+    } else if (g_variant_type_equal(type, G_VARIANT_TYPE_UINT64)) {
+        return rbglib_uint64_to_num(g_variant_get_uint64(variant));
+    } else if (g_variant_type_equal(type, G_VARIANT_TYPE_DOUBLE)) {
+        return rb_float_new(g_variant_get_double(variant));
+    } else if (g_variant_type_equal(type, G_VARIANT_TYPE_STRING) ||
+               g_variant_type_equal(type, G_VARIANT_TYPE_OBJECT_PATH) ||
+               g_variant_type_equal(type, G_VARIANT_TYPE_SIGNATURE)) {
         const gchar *string;
         gsize string_length;
         string = g_variant_get_string(variant, &string_length);
         return CSTR2RVAL_LEN(string, string_length);
+    } else if (g_variant_type_equal(type, G_VARIANT_TYPE_HANDLE)) {
+        return INT2NUM(g_variant_get_handle(variant));
+    } else if (g_variant_type_equal(type, G_VARIANT_TYPE_VARIANT)) {
+        GVariant *val = g_variant_get_variant(variant);
+        VALUE value = rbg_variant_to_ruby(val);
+        g_variant_unref(val);
+        return value;
+    } else if (g_variant_type_is_array(type)) {
+        gsize i, len = g_variant_n_children(variant);
+        VALUE ary = rb_ary_new2(len);
+        for (i = 0; i < len; i++) {
+            GVariant *val = g_variant_get_child_value(variant, i);
+            rb_ary_store(ary, i, rbg_variant_to_ruby(val));
+            g_variant_unref(val);
+        }
+        return ary;
     } else {
         rb_raise(rb_eNotImpError,
                  "TODO: GVariant(%.*s) -> Ruby",
@@ -78,21 +112,138 @@ rg_variant_allocate(VALUE klass)
     return Data_Wrap_Struct(klass, NULL, rg_variant_free, NULL);
 }
 
-static VALUE
-rg_initialize(VALUE self, VALUE rb_value)
+static GVariant *
+rg_ruby_to_variant(VALUE rb_value, VALUE rb_variant_type)
 {
-    GVariant *variant;
+    const GVariantType *variant_type;
+
+    if (NIL_P(rb_variant_type)) {
+        switch (rb_type(rb_value)) {
+          case RUBY_T_TRUE:
+          case RUBY_T_FALSE:
+            variant_type = G_VARIANT_TYPE_BOOLEAN;
+            break;
+          case RUBY_T_FIXNUM:
+            variant_type = G_VARIANT_TYPE_INT64;
+            break;
+          case RUBY_T_FLOAT:
+            variant_type = G_VARIANT_TYPE_DOUBLE;
+            break;
+          case RUBY_T_STRING:
+            variant_type = G_VARIANT_TYPE_STRING;
+            break;
+          case RUBY_T_ARRAY:
+            variant_type = G_VARIANT_TYPE_ARRAY;
+            break;
+          default:
+            rb_raise(rb_eNotImpError,
+                     "TODO: Ruby -> GVariantType: %s",
+                     RBG_INSPECT(rb_value));
+            break;
+        }
+    } else {
+        variant_type = RVAL2GVARIANTTYPE(rb_variant_type);
+    }
+
+    if (g_variant_type_equal(variant_type, G_VARIANT_TYPE_BOOLEAN)) {
+        return g_variant_new_boolean(RVAL2CBOOL(rb_value));
+    } else if (g_variant_type_equal(variant_type, G_VARIANT_TYPE_BYTE)) {
+        return g_variant_new_byte(NUM2UINT(rb_value));
+    } else if (g_variant_type_equal(variant_type, G_VARIANT_TYPE_INT16)) {
+        return g_variant_new_int16(NUM2INT(rb_value));
+    } else if (g_variant_type_equal(variant_type, G_VARIANT_TYPE_UINT16)) {
+        return g_variant_new_uint16(NUM2UINT(rb_value));
+    } else if (g_variant_type_equal(variant_type, G_VARIANT_TYPE_INT32)) {
+        return g_variant_new_int32(NUM2INT(rb_value));
+    } else if (g_variant_type_equal(variant_type, G_VARIANT_TYPE_UINT32)) {
+        return g_variant_new_uint32(NUM2UINT(rb_value));
+    } else if (g_variant_type_equal(variant_type, G_VARIANT_TYPE_INT64)) {
+        return g_variant_new_int64(NUM2LONG(rb_value));
+    } else if (g_variant_type_equal(variant_type, G_VARIANT_TYPE_UINT64)) {
+        return g_variant_new_uint64(NUM2ULONG(rb_value));
+    } else if (g_variant_type_equal(variant_type, G_VARIANT_TYPE_HANDLE)) {
+        return g_variant_new_handle(NUM2INT(rb_value));
+    } else if (g_variant_type_equal(variant_type, G_VARIANT_TYPE_DOUBLE)) {
+        return g_variant_new_double(NUM2DBL(rb_value));
+    } else if (g_variant_type_equal(variant_type, G_VARIANT_TYPE_STRING)) {
+        return g_variant_new_string(RVAL2CSTR_ACCEPT_NIL(rb_value));
+    } else if (g_variant_type_equal(variant_type, G_VARIANT_TYPE_OBJECT_PATH)) {
+        return g_variant_new_object_path(RVAL2CSTR_ACCEPT_NIL(rb_value));
+    } else if (g_variant_type_equal(variant_type, G_VARIANT_TYPE_SIGNATURE)) {
+        return g_variant_new_signature(RVAL2CSTR_ACCEPT_NIL(rb_value));
+    } else if (g_variant_type_equal(variant_type, G_VARIANT_TYPE_VARIANT)) {
+        return g_variant_new_variant(rbg_variant_from_ruby(rb_value));
+    } else if (g_variant_type_equal(variant_type,
+                                    G_VARIANT_TYPE_STRING_ARRAY) ||
+               g_variant_type_equal(variant_type,
+                                    G_VARIANT_TYPE_OBJECT_PATH_ARRAY)) {
+        const gchar **strings;
+        gssize length;
+        if (NIL_P(rb_value)) {
+            strings = NULL;
+            length = 0;
+        } else {
+            gssize i;
+
+            length = RARRAY_LEN(rb_value);
+            strings = ALLOCA_N(const gchar *, length);
+            for (i = 0; i < length; i++) {
+                VALUE rb_string = RARRAY_PTR(rb_value)[i];
+                strings[i] = RVAL2CSTR_ACCEPT_NIL(rb_string);
+            }
+        }
+        if (g_variant_type_equal(variant_type, G_VARIANT_TYPE_STRING_ARRAY)) {
+            return g_variant_new_strv(strings, length);
+        } else {
+            return g_variant_new_objv(strings, length);
+        }
+    } else if (g_variant_type_equal(variant_type, G_VARIANT_TYPE_ARRAY)) {
+        int i;
+        GVariantBuilder builder;
+        g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
+        for (i = 0; i < RARRAY_LEN(rb_value); i++) {
+            GVariant *val = rg_ruby_to_variant(rb_ary_entry(rb_value, i), Qnil);
+            g_variant_builder_add_value(&builder, val);
+        }
+        return g_variant_builder_end(&builder);
+    } else if (g_variant_type_equal(variant_type, G_VARIANT_TYPE_BYTESTRING)) {
+        return g_variant_new_bytestring(RVAL2CSTR_RAW_ACCEPT_NIL(rb_value));
+    } else if (g_variant_type_equal(variant_type,
+                                    G_VARIANT_TYPE_BYTESTRING_ARRAY)) {
+        const gchar **strings;
+        gssize length;
+        if (NIL_P(rb_value)) {
+            strings = NULL;
+            length = 0;
+        } else {
+            gssize i;
 
-    switch (rb_type(rb_value)) {
-      case RUBY_T_STRING:
-        variant = g_variant_new_string(RVAL2CSTR(rb_value));
-        break;
-      default:
+            length = RARRAY_LEN(rb_value);
+            strings = ALLOCA_N(const gchar *, length);
+            for (i = 0; i < length; i++) {
+                VALUE rb_string = RARRAY_PTR(rb_value)[i];
+                strings[i] = RVAL2CSTR_RAW_ACCEPT_NIL(rb_string);
+            }
+        }
+        return g_variant_new_bytestring_array(strings, length);
+    } else {
         rb_raise(rb_eNotImpError,
-                 "TODO: Ruby -> GVariant: %s",
+                 "TODO: Ruby -> GVariant(%.*s): %s",
+                 (int)g_variant_type_get_string_length(variant_type),
+                 g_variant_type_peek_string(variant_type),
                  RBG_INSPECT(rb_value));
-        break;
     }
+}
+
+static VALUE
+rg_initialize(int argc, VALUE *argv, VALUE self)
+{
+    GVariant *variant;
+    VALUE rb_value;
+    VALUE rb_variant_type;
+
+    rb_scan_args(argc, argv, "11", &rb_value, &rb_variant_type);
+    variant = rg_ruby_to_variant(rb_value, rb_variant_type);
     g_variant_ref_sink(variant);
     DATA_PTR(self) = variant;
 
@@ -126,7 +277,7 @@ Init_glib_variant(void)
 
     rb_define_alloc_func(RG_TARGET_NAMESPACE, rg_variant_allocate);
 
-    RG_DEF_METHOD(initialize, 1);
+    RG_DEF_METHOD(initialize, -1);
     RG_DEF_METHOD(value, 0);
     RG_DEF_METHOD(type, 0);
 }

data/ext/glib2/rbglib.c

@@ -43,14 +43,17 @@ rbg_rval2cstr(VALUE *str)
 }
 
 const gchar *
-rbg_rval2cstr_ptr(VALUE *str)
+rbg_rval2cstr_raw(VALUE *str)
 {
     StringValue(*str);
 
-#ifdef HAVE_RUBY_ENCODING_H
-    if (rb_enc_get(*str) != rb_utf8_encoding())
-        *str = rb_str_export_to_enc(*str, rb_utf8_encoding());
-#endif
+    return StringValueCStr(*str);
+}
+
+const gchar *
+rbg_rval2cstr_ptr(VALUE *str)
+{
+    StringValue(*str);
 
     return RSTRING_PTR(*str);
 }
@@ -75,6 +78,18 @@ rbg_rval2cstr_accept_nil(VALUE *str)
     return NIL_P(*str) ? NULL : RVAL2CSTR(*str);
 }
 
+const gchar *
+rbg_rval2cstr_raw_accept_nil(VALUE *str)
+{
+    return NIL_P(*str) ? NULL : RVAL2CSTR_RAW(*str);
+}
+
+const gchar *
+rbg_rval2cstr_ptr_accept_nil(VALUE *str)
+{
+    return NIL_P(*str) ? NULL : RVAL2CSTR_PTR(*str);
+}
+
 /* TODO: How do we deal with encodings? */
 const gchar *
 rbg_rval2cstr_accept_symbol(volatile VALUE *value)
@@ -879,11 +894,17 @@ rbg_scan_options (VALUE options, ...)
     VALUE *value;
     va_list args;
 
-    options = rbg_check_hash_type(options);
     if (NIL_P(options)) {
         options = rb_hash_new();
-    } else if (options == original_options) {
-        options = rb_funcall(options, rb_intern("dup"), 0);
+    } else {
+        options = rbg_check_hash_type(options);
+        if (options == original_options) {
+            options = rb_funcall(options, rb_intern("dup"), 0);
+        } else if (NIL_P(options)) {
+            rb_raise(rb_eArgError,
+                     "options must be Hash or nil: %+" PRIsVALUE,
+                     original_options);
+        }
     }
 
     available_keys = rb_ary_new();
@@ -1170,4 +1191,6 @@ union       GDoubleIEEE754;
     Init_glib_bookmark_file();
     Init_glib_variant_type();
     Init_glib_variant();
+    Init_glib_regex();
+    Init_glib_matchinfo();
 }

data/ext/glib2/rbglib.h

@@ -36,7 +36,15 @@ extern "C" {
 
 #define RBGLIB_MAJOR_VERSION 3
 #define RBGLIB_MINOR_VERSION 0
-#define RBGLIB_MICRO_VERSION 7
+#define RBGLIB_MICRO_VERSION 8
+
+#ifndef RB_ZALLOC
+#  ifdef ZALLOC
+#    define RB_ZALLOC(type) ZALLOC(type)
+#  else
+#    define RB_ZALLOC(type) rbg_memzero(ALLOC(type), sizeof(type))
+#  endif
+#endif
 
 #ifndef RSTRING_PTR
 #  define RSTRING_PTR(s) (RSTRING(s)->ptr)
@@ -71,8 +79,11 @@ extern "C" {
 #define RBG_INSPECT(object) (rbg_rval_inspect(object))
 
 #define RVAL2CSTR(v) (rbg_rval2cstr(&(v)))
+#define RVAL2CSTR_RAW(v) (rbg_rval2cstr_raw(&(v)))
 #define RVAL2CSTR_PTR(v) (rbg_rval2cstr_ptr(&(v)))
 #define RVAL2CSTR_ACCEPT_NIL(v) (rbg_rval2cstr_accept_nil(&(v)))
+#define RVAL2CSTR_RAW_ACCEPT_NIL(v) (rbg_rval2cstr_raw_accept_nil(&(v)))
+#define RVAL2CSTR_PTR_ACCEPT_NIL(v) (rbg_rval2cstr_ptr_accept_nil(&(v)))
 #define RVAL2CSTR2(v) (RVAL2CSTR_ACCEPT_NIL(v))
 #define RVAL2CSTR_ACCEPT_SYMBOL(v) (rbg_rval2cstr_accept_symbol(&(v)))
 #define RVAL2CSTR_ACCEPT_SYMBOL_ACCEPT_NIL(v) (rbg_rval2cstr_accept_symbol_accept_nil(&(v)))
@@ -147,8 +158,11 @@ extern const gchar *rbg_rval_inspect(VALUE object);
 
 extern gchar* rbg_string_value_ptr(volatile VALUE* ptr); /* no longer used */
 extern const gchar *rbg_rval2cstr(VALUE *str);
+extern const gchar *rbg_rval2cstr_raw(VALUE *str);
 extern const gchar *rbg_rval2cstr_ptr(VALUE *str);
 extern const gchar *rbg_rval2cstr_accept_nil(VALUE *str);
+extern const gchar *rbg_rval2cstr_raw_accept_nil(VALUE *str);
+extern const gchar *rbg_rval2cstr_ptr_accept_nil(VALUE *str);
 extern const gchar *rbg_rval2cstr_accept_symbol(volatile VALUE *value);
 extern const gchar *rbg_rval2cstr_accept_symbol_accept_nil(volatile VALUE *value);
 extern const gchar *rbg_rval2glibid(volatile VALUE *value, volatile VALUE *buf, gboolean accept_nil);

data/ext/glib2/rbglib2conversions.h

@@ -59,4 +59,7 @@
 
 #define RVAL2GBINDINGFLAGS(o)              (RVAL2GFLAGS(o, G_TYPE_BINDING_FLAGS))
 #define GBINDINGFLAGS2RVAL(o)              (GFLAGS2RVAL(o, G_TYPE_BINDING_FLAGS))
+#define RVAL2GREGEXMATCHOPTIONSFLAGS(o)    (RVAL2GFLAGS(o, G_TYPE_REGEX_MATCH_FLAGS))
+#define RVAL2GREGEXCOMPILEOPTIONSFLAGS(o)  (RVAL2GFLAGS(o, G_TYPE_REGEX_COMPILE_FLAGS))
+#define GMATCHINFO2RVAL(o)                 (BOXED2RVAL(o, G_TYPE_MATCH_INFO))
 #endif /* __GLIB2CONVERSIONS_H__ */

data/ext/glib2/rbglib_iochannel.c

@@ -52,7 +52,6 @@ rg_initialize(gint argc, VALUE *argv, VALUE self)
     VALUE arg1, arg2;
 
     GIOChannel* io = NULL;
-    rb_secure(4);
     rb_scan_args(argc, argv, "11", &arg1, &arg2);
 
     if (TYPE(arg1) != T_STRING){
@@ -406,7 +405,6 @@ rg_write(VALUE self, VALUE buf)
     GIOStatus status;
     GError* err = NULL;
 
-    rb_secure(4);
     buf = rb_obj_as_string(buf);
 
     StringValue(buf);
@@ -426,7 +424,6 @@ rg_putc(VALUE self, VALUE thechar)
     GIOStatus status;
     gunichar unichar;
 
-    rb_secure(4);
     if (TYPE(thechar) == T_FIXNUM) {
         unichar = NUM2UINT(thechar);
     } else {

data/ext/glib2/rbglib_iochannel_win32_socket.c

@@ -31,7 +31,6 @@ rg_initialize(VALUE self, VALUE socket)
     GIOChannel *io = NULL;
     int fd;
 
-    rb_secure(4);
     /* TODO: support IO object */
     fd = NUM2INT(socket);
     io = g_io_channel_win32_new_socket(rb_w32_get_osfhandle(fd));

data/ext/glib2/rbglib_matchinfo.c

@@ -0,0 +1,179 @@
+/*
+ *  Copyright (C) 2015-2016  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 "rbgprivate.h"
+
+#define RG_TARGET_NAMESPACE cMatchInfo
+#define _SELF(s) ((GMatchInfo*)RVAL2BOXED(s, G_TYPE_MATCH_INFO))
+
+static VALUE
+rg_regex(VALUE self)
+{
+    GRegex *regex;
+    regex = g_match_info_get_regex(_SELF(self));
+    return BOXED2RVAL(regex, G_TYPE_REGEX);
+}
+
+static VALUE
+rg_string(VALUE self)
+{
+    return rb_iv_get(self, "@string");
+}
+
+static VALUE
+rg_matches_p(VALUE self)
+{
+    return CBOOL2RVAL(g_match_info_matches(_SELF(self)));
+}
+
+static VALUE
+rg_match_count(VALUE self)
+{
+    return INT2NUM(g_match_info_get_match_count(_SELF(self)));
+}
+
+static VALUE
+rg_partial_match_p(VALUE self)
+{
+    return CBOOL2RVAL(g_match_info_is_partial_match(_SELF(self)));
+}
+
+static VALUE
+rg_fetch(VALUE self, VALUE rb_match_reference)
+{
+    gchar *match;
+
+    switch (TYPE(rb_match_reference)) {
+      case RUBY_T_FIXNUM:
+        {
+            gint match_num;
+            match_num = NUM2INT(rb_match_reference);
+            match = g_match_info_fetch(_SELF(self), match_num);
+        }
+        break;
+      case RUBY_T_STRING:
+      case RUBY_T_SYMBOL:
+        {
+            const gchar *match_name;
+            match_name = RVAL2CSTR_ACCEPT_SYMBOL(rb_match_reference);
+            match = g_match_info_fetch_named(_SELF(self), match_name);
+        }
+        break;
+      default:
+        rb_raise(rb_eArgError, "Expected a String, a Symbol or an Integer");
+        break;
+    }
+
+    return CSTR2RVAL_FREE(match);
+}
+
+static VALUE
+rg_fetch_pos(VALUE self, VALUE rb_match_reference)
+{
+    gint start_pos = 0;
+    gint end_pos = 0;
+    gboolean fetched = FALSE;
+
+    switch (TYPE(rb_match_reference)) {
+      case RUBY_T_FIXNUM:
+        {
+            gint match_num;
+            match_num = NUM2INT(rb_match_reference);
+            fetched = g_match_info_fetch_pos(_SELF(self), match_num,
+                                             &start_pos, &end_pos);
+        }
+        break;
+      case RUBY_T_STRING:
+      case RUBY_T_SYMBOL:
+        {
+            const gchar *match_name;
+            match_name = RVAL2CSTR_ACCEPT_SYMBOL(rb_match_reference);
+            fetched = g_match_info_fetch_named_pos(_SELF(self), match_name,
+                                                   &start_pos, &end_pos);
+        }
+        break;
+      default:
+        rb_raise(rb_eArgError, "Expected a String, a Symbol or an Integer");
+        break;
+    }
+
+    if (!fetched) {
+        return Qnil;
+    }
+
+    return rb_ary_new_from_args(2, INT2NUM(start_pos), INT2NUM(end_pos));
+}
+
+static VALUE
+rg_fetch_all(VALUE self)
+{
+    gchar **strings;
+    strings = g_match_info_fetch_all(_SELF(self));
+    return STRV2RVAL_FREE(strings);
+}
+
+static VALUE
+rg_next(VALUE self)
+{
+    gboolean matched;
+    GError *error = NULL;
+
+    matched = g_match_info_next(_SELF(self), &error);
+
+    if (error)
+        RAISE_GERROR(error);
+
+    return CBOOL2RVAL(matched);
+}
+
+static VALUE
+rg_expand_references(VALUE self, VALUE rb_string)
+{
+    const gchar *string = RVAL2CSTR(rb_string);
+    gchar *expanded_string = NULL;
+    GError *error = NULL;
+
+    expanded_string = g_match_info_expand_references(_SELF(self),
+                                                     string,
+                                                     &error);
+    if (error)
+        RAISE_GERROR(error);
+
+    return CSTR2RVAL_FREE(expanded_string);
+}
+
+void
+Init_glib_matchinfo(void)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_MATCH_INFO, "MatchInfo", mGLib);
+    RG_DEF_METHOD(regex, 0);
+    RG_DEF_METHOD(string, 0);
+    RG_DEF_METHOD_P(matches, 0);
+    RG_DEF_METHOD(match_count, 0);
+    RG_DEF_METHOD_P(partial_match, 0);
+    RG_DEF_METHOD(fetch, 1);
+    RG_DEF_ALIAS("[]", "fetch");
+    RG_DEF_METHOD(fetch_pos, 1);
+    RG_DEF_ALIAS("fetch_position", "fetch_pos");
+    RG_DEF_METHOD(fetch_all, 0);
+    RG_DEF_METHOD(next, 0);
+    RG_DEF_METHOD(expand_references, 1);
+}