glib2 3.0.7-x64-mingw32 → 3.0.8-x64-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f989c70367eb6c422028afe9e878025102e33036
-  data.tar.gz: 66ce08f35d1cab5a2c06e5408d2a3acc697e47d6
+  metadata.gz: 2b0fe59f316e491b079c639134e8da9ed915ec7c
+  data.tar.gz: d2742ff88873abb46ca49623cc4108272233a78d
 SHA512:
-  metadata.gz: 10c815129670f971c4fb8602cd310b47ed2117ef9bd02f30685ccfc4cc53adfbcaa56802d7c076614b2e04467b13534936cbd42227f4ebeb3d5dad3a472a8429
-  data.tar.gz: 2e947379e3f1d00db38287ed4bf0bff0f90648b3618e97b542ab1c23a8e983d95cf5ee502c271f31f90aea6c15e1faae292090bf18ccd0fc5e1feba4b826646e
+  metadata.gz: 0257bb90eb2e09164ee79d7d23fab976c10f028c2760602b0b7bf3a42f9bbe8a479cca7559ba315244b35af853929f6809e6d9ac7ff15bb83100167e1f5d84a9
+  data.tar.gz: a16dd5b208ea9764bee2d2153717c4ea66ccd833411927d44bb372e90be4433bcb45fbd183ec75ee74b974c0d100a46bf993ae2e44bcf2c6f2264ebf2197ab12

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);