glib2 3.0.9-x64-mingw32 → 3.1.0-x64-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9ac3c8d1b66f8cf8a3f5eb0e3602460e772574d5
-  data.tar.gz: 27a17da86f9a40398fd08947d35f87d7b6e05084
+  metadata.gz: 46c63cf3bce70bc92bb1aab164d7041b13bd23d3
+  data.tar.gz: 83f9234dfbc59637b7252c5f80d499961af10d96
 SHA512:
-  metadata.gz: b8b824907a9b8334c1d90fbd578a9c4b8fa2ec59aa8f7bf7e47af3cb061d15037bfedf251fafeee4081b5e5c10fdbdc2d4a111e6a13340d5a5db9a08527176c1
-  data.tar.gz: 12e843c349aff37647bc0979fd32a208a336970aef6f32efbb6f7b819327d2dcfcca3335f6bd7085df707a61f280e8f66f2455cb963486d27358bcb9915ab26d
+  metadata.gz: 63f5afe99552f77f8b2f66be2d537adebd99713cf3a9672911488071a85fcb6abbb78a911d6874f7fc29828ef2c11d71b3d23762bd68aea274a9f814f5da4876
+  data.tar.gz: c80150d5e6fa012fbf71a07503e799c2faa9a00ac998ef75cd9de3b9aead5b256474b2bd5c5c6a6b4cfeb39274a9e4a7a01f6f0d26f5f8f940f53ee600d57d84

data/Rakefile

@@ -85,7 +85,7 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
       :name => "glib",
       :download_site => :gnome,
       :label => "GLib",
-      :version => "2.48.1",
+      :version => "2.50.2",
       :compression_method => "xz",
       :windows => {
         :need_autoreconf => true,
@@ -168,7 +168,7 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
       :name => "glib-networking",
       :download_site => :gnome,
       :label => "glib-networking",
-      :version => "2.48.2",
+      :version => "2.50.0",
       :compression_method => "xz",
       :windows => {
         :configure_args => [

data/ext/glib2/extconf.rb

@@ -41,9 +41,6 @@ have_func("rb_check_array_type", ruby_header)
 have_func("rb_check_hash_type", ruby_header)
 have_func("rb_exec_recursive", ruby_header)
 have_func("rb_errinfo", ruby_header)
-have_func("rb_sourcefile", ruby_header)
-have_func("rb_sourceline", ruby_header)
-have_func("ruby_set_current_source", ruby_header)
 have_func("rb_thread_call_without_gvl", ruby_header)
 have_func("ruby_native_thread_p", ruby_header)
 have_func("rb_thread_call_with_gvl", ruby_header)

data/ext/glib2/glib2.def

@@ -56,10 +56,13 @@ EXPORTS
 	rbgobj_register_type
 	rbgobj_set_signal_func
 	rbgobj_get_signal_func
+	rbgobj_set_signal_call_func
+	rbgobj_get_signal_call_func
 	rbgobj_add_constants
 	rbgobj_constant_remap
 	rbgobj_signal_wrap
 	g_rclosure_new
+	g_rclosure_new_call
 	g_rclosure_attach
 	g_rclosure_set_tag
 	rbgobj_ruby_value_get_type

data/ext/glib2/rbglib.c

@@ -854,47 +854,79 @@ rbg_check_hash_type (VALUE object)
 void
 rbg_scan_options (VALUE options, ...)
 {
-    VALUE original_options = options;
-    VALUE available_keys;
     const char *key;
-    VALUE *value;
+    gsize n_keys = 0;
+    gsize n_found_keys = 0;
     va_list args;
+    va_list args_copy;
 
-    if (NIL_P(options)) {
-        options = rb_hash_new();
-    } else {
+    if (!NIL_P(options)) {
+        VALUE original_options = options;
         options = rbg_check_hash_type(options);
-        if (options == original_options) {
-            options = rb_funcall(options, rb_intern("dup"), 0);
-        } else if (NIL_P(options)) {
+        if (NIL_P(options)) {
             rb_raise(rb_eArgError,
                      "options must be Hash or nil: %+" PRIsVALUE,
                      original_options);
         }
     }
 
-    available_keys = rb_ary_new();
     va_start(args, options);
+    va_copy(args_copy, args);
     key = va_arg(args, const char *);
+    n_keys = 0;
+    n_found_keys = 0;
     while (key) {
-        VALUE rb_key;
-        value = va_arg(args, VALUE *);
+        VALUE *value;
 
-        rb_key = ID2SYM(rb_intern(key));
-        rb_ary_push(available_keys, rb_key);
-        *value = rb_funcall(options, rb_intern("delete"), 1, rb_key);
+        value = va_arg(args, VALUE *);
+        if (NIL_P(options)) {
+            *value = Qnil;
+        } else {
+            VALUE rb_key;
+            rb_key = ID2SYM(rb_intern(key));
+            if (RTEST(rb_funcall(options, rb_intern("key?"), 1, rb_key))) {
+                n_found_keys++;
+            }
+            *value = rb_hash_aref(options, rb_key);
+        }
+        n_keys++;
 
         key = va_arg(args, const char *);
     }
     va_end(args);
 
-    if (RVAL2CBOOL(rb_funcall(options, rb_intern("empty?"), 0)))
+    if (NIL_P(options)) {
+        return;
+    }
+
+    if (n_found_keys == RHASH_SIZE(options)) {
         return;
+    }
+
+    {
+        VALUE rb_available_keys;
 
-    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));
+        rb_available_keys = rb_ary_new();
+        key = va_arg(args_copy, const char *);
+        while (key) {
+            VALUE rb_key;
+
+            va_arg(args_copy, VALUE *);
+            rb_key = ID2SYM(rb_intern(key));
+            rb_ary_push(rb_available_keys, rb_key);
+            key = va_arg(args_copy, const char *);
+        }
+        va_end(args_copy);
+
+        rb_raise(rb_eArgError,
+                 "unexpected key(s) exist: %+" PRIsVALUE
+                 ": available keys: %+" PRIsVALUE,
+                 rb_funcall(rb_funcall(options, rb_intern("keys"), 0),
+                            rb_intern("-"),
+                            1,
+                            rb_available_keys),
+                 rb_available_keys);
+    }
 }
 
 #if 0

data/ext/glib2/rbglib.h

@@ -35,8 +35,8 @@ extern "C" {
 #endif /* __cplusplus */
 
 #define RBGLIB_MAJOR_VERSION 3
-#define RBGLIB_MINOR_VERSION 0
-#define RBGLIB_MICRO_VERSION 9
+#define RBGLIB_MINOR_VERSION 1
+#define RBGLIB_MICRO_VERSION 0
 
 #ifndef RB_ZALLOC
 #  ifdef ZALLOC

data/ext/glib2/rbglib_iochannel.c

@@ -42,7 +42,7 @@ ioc_error(GIOStatus status, GError *err)
     } else if (status == G_IO_STATUS_NORMAL){
         /* Do nothing */
     } else {
-        rb_raise(rb_eRuntimeError, "An error occured. status = %d\n", status);
+        rb_raise(rb_eRuntimeError, "An error occurred. status = %d\n", status);
     }
 }
 

data/ext/glib2/rbglib_mainloop.c

@@ -57,34 +57,57 @@ rg_initialize(int argc, VALUE *argv, VALUE self)
     return Qnil;
 }
 
+typedef struct {
+    GMainLoop *loop;
+    int state;
+} CheckInterruptData;
+
+static VALUE
+check_interrupt_raw(G_GNUC_UNUSED VALUE user_data)
+{
+    rb_thread_check_ints();
+    return Qnil;
+}
+
 static gboolean
-quit_loop(gpointer user_data)
+check_interrupt(gpointer user_data)
 {
-    GMainLoop *loop = user_data;
-    g_main_loop_quit(loop);
-    return G_SOURCE_REMOVE;
+    CheckInterruptData *data = user_data;
+
+    rb_protect(check_interrupt_raw, Qnil, &(data->state));
+    if (data->state == 0) {
+        return G_SOURCE_CONTINUE;
+    } else {
+        g_main_loop_quit(data->loop);
+        return G_SOURCE_REMOVE;
+    }
 }
 
 static VALUE
 rg_run(VALUE self)
 {
-    GMainLoop *loop;
+    CheckInterruptData data;
     GSource *interrupt_source;
 
-    loop = _SELF(self);
+    data.loop = _SELF(self);
+    data.state = 0;
 
     interrupt_source = rbg_interrupt_source_new();
     g_source_set_callback(interrupt_source,
-                          quit_loop,
-                          loop,
+                          check_interrupt,
+                          &data,
                           NULL);
     g_source_attach(interrupt_source,
-                    g_main_loop_get_context(loop));
-    g_main_loop_run(loop);
+                    g_main_loop_get_context(data.loop));
+    g_main_loop_run(data.loop);
     g_source_destroy(interrupt_source);
     g_source_unref(interrupt_source);
 
-    rb_thread_check_ints();
+    if (data.state == 0) {
+        rb_thread_check_ints();
+    } else {
+        rb_jump_tag(data.state);
+    }
 
     return self;
 }

data/ext/glib2/rbglib_messages.c

@@ -24,14 +24,6 @@
 
 #include "rbgprivate.h"
 
-#ifndef HAVE_RB_SOURCEFILE
-#define rb_sourcefile() (ruby_sourcefile)
-#endif
-
-#ifndef HAVE_RB_SOURCELINE
-#define rb_sourceline() (ruby_sourceline)
-#endif
-
 #define RG_TARGET_NAMESPACE mLog
 
 static VALUE rbglib_log_handler_procs;
@@ -56,15 +48,30 @@ logmessage(GLogLevelFlags level)
     return "UNKNOWN";
 }
 
+static VALUE
+rbg_printerr(VALUE message, G_GNUC_UNUSED VALUE user_data)
+{
+    g_printerr("\tfrom %.*s\n",
+               (int)RSTRING_LEN(message),
+               RSTRING_PTR(message));
+    return Qnil;
+}
+
 static void
 rbglib_log_handler(const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer user_data)
 {
-    if (! log_canceled){
-#ifdef HAVE_RUBY_SET_CURRENT_SOURCE
-        ruby_set_current_source();
-#endif
-        g_printerr("%s: line %d\n", rb_sourcefile(), rb_sourceline());
-        g_printerr("   %s-%s **:%s\n", log_domain, logmessage(log_level), message);
+    if (!log_canceled) {
+        g_printerr("%s-%s **: %s\n",
+                   log_domain, logmessage(log_level), message);
+        if (rb_during_gc()) {
+            g_printerr("\tfrom %s:%d\n", rb_sourcefile(), rb_sourceline());
+        } else {
+            VALUE backtrace;
+
+            backtrace = rb_funcall(rb_mKernel, rb_intern("caller"), 0);
+            rb_iterate(rb_each, backtrace,
+                       rbg_printerr, Qnil);
+        }
     } else {
         g_log_default_handler(log_domain, log_level, message, user_data);
     }

data/ext/glib2/rbgobj_closure.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2011-2013  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2011-2016  Ruby-GNOME2 Project Team
  *  Copyright (C) 2002-2006  Ruby-GNOME2 Project
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
@@ -38,6 +38,7 @@ struct _GRClosure
     gint count;
     GList *objects;
     GValToRValSignalFunc g2r_func;
+    RGClosureCallFunc call_func;
     gchar tag[TAG_SIZE];
 };
 
@@ -70,38 +71,51 @@ rclosure_alive_p(GRClosure *rclosure)
 static VALUE
 rclosure_marshal_do(VALUE arg_)
 {
+    VALUE ret = Qnil;
     struct marshal_arg *arg;
-    GRClosure*      rclosure;
-    GValue*         return_value;
-    guint           n_param_values;
-    const GValue*   param_values;
-    /* gpointer        invocation_hint;*/
-    /* gpointer        marshal_data; */
+    GRClosure  *rclosure;
+    GValue *return_value;
 
-    VALUE ret = Qnil;
-    VALUE args;
-    GValToRValSignalFunc func;
-
-    arg = (struct marshal_arg*)arg_;
-    rclosure        = (GRClosure *)(arg->closure);
-    return_value    = arg->return_value;   
-    n_param_values  = arg->n_param_values; 
-    param_values    = arg->param_values;
-    /* invocation_hint = arg->invocation_hint; */
-    /* marshal_data    = arg->marshal_data; */
-
-    if (rclosure->g2r_func){
-        func = (GValToRValSignalFunc)rclosure->g2r_func;
-    } else { 
-        func = (GValToRValSignalFunc)rclosure_default_g2r_func;
-    }
-    args = (*func)(n_param_values, param_values);
+    arg = (struct marshal_arg *)arg_;
+    rclosure = (GRClosure *)(arg->closure);
+    return_value = arg->return_value;
 
     if (rclosure_alive_p(rclosure)) {
-        VALUE callback, extra_args;
+        guint n_param_values;
+        const GValue *param_values;
+        /* gpointer invocation_hint;*/
+        /* gpointer marshal_data; */
+        GValToRValSignalFunc g2r_func;
+        VALUE callback;
+        VALUE extra_args;
+        VALUE args;
+
+        n_param_values  = arg->n_param_values;
+        param_values = arg->param_values;
+        /* invocation_hint = arg->invocation_hint; */
+        /* marshal_data = arg->marshal_data; */
+
         callback = rclosure->callback;
         extra_args = rclosure->extra_args;
 
+        if (rclosure->call_func) {
+            RGClosureCallData data;
+            data.return_value = return_value;
+            data.n_param_values = n_param_values;
+            data.param_values = param_values;
+            data.callback = callback;
+            data.extra_args = extra_args;
+            rclosure->call_func(&data);
+            return Qnil;
+        }
+
+        if (rclosure->g2r_func) {
+            g2r_func = (GValToRValSignalFunc)rclosure->g2r_func;
+        } else {
+            g2r_func = (GValToRValSignalFunc)rclosure_default_g2r_func;
+        }
+        args = (*g2r_func)(n_param_values, param_values);
+
         if (!NIL_P(extra_args)) {
             args = rb_ary_concat(args, extra_args);
         }
@@ -210,8 +224,11 @@ gr_closure_holder_free(GRClosure *rclosure)
     }
 }
 
-GClosure*
-g_rclosure_new(VALUE callback_proc, VALUE extra_args, GValToRValSignalFunc g2r_func)
+static GClosure *
+g_rclosure_new_raw(VALUE callback_proc,
+                   VALUE extra_args,
+                   GValToRValSignalFunc g2r_func,
+                   RGClosureCallFunc call_func)
 {
     GRClosure* closure;
 
@@ -219,6 +236,7 @@ g_rclosure_new(VALUE callback_proc, VALUE extra_args, GValToRValSignalFunc g2r_f
 
     closure->count      = 1;
     closure->g2r_func   = g2r_func;
+    closure->call_func  = call_func;
     closure->objects    = NULL;
     closure->callback   = callback_proc;
     closure->extra_args = extra_args;
@@ -235,6 +253,25 @@ g_rclosure_new(VALUE callback_proc, VALUE extra_args, GValToRValSignalFunc g2r_f
     return (GClosure*)closure;
 }
 
+GClosure *
+g_rclosure_new(VALUE callback_proc,
+               VALUE extra_args,
+               GValToRValSignalFunc g2r_func)
+{
+    return g_rclosure_new_raw(callback_proc, extra_args, g2r_func, NULL);
+}
+
+GClosure *
+g_rclosure_new_call(VALUE callback_proc,
+                    VALUE extra_args,
+                    RGClosureCallFunc call_func)
+{
+    return g_rclosure_new_raw(callback_proc,
+                              extra_args,
+                              NULL,
+                              call_func);
+}
+
 static void
 rclosure_weak_notify(gpointer data, GObject* where_the_object_was)
 {

data/ext/glib2/rbgobj_signal.c

@@ -51,6 +51,28 @@ rbgobj_get_signal_func(guint signal_id)
     return func;
 }
 
+static VALUE signal_call_func_table;
+
+void
+rbgobj_set_signal_call_func(VALUE klass,
+                            const gchar *signal_name,
+                            RGClosureCallFunc func)
+{
+    VALUE obj = Data_Wrap_Struct(rb_cData, NULL, NULL, func);
+    guint signal_id = g_signal_lookup(signal_name, CLASS2GTYPE(klass));
+    rb_hash_aset(signal_call_func_table, UINT2NUM(signal_id), obj);
+}
+
+RGClosureCallFunc
+rbgobj_get_signal_call_func(guint signal_id)
+{
+    RGClosureCallFunc func = NULL;
+    VALUE func_obj = rb_hash_aref(signal_call_func_table, UINT2NUM(signal_id));
+    if (!NIL_P(func_obj))
+        Data_Get_Struct(func_obj, void, func);
+    return func;
+}
+
 /**********************************************************************/
 
 static VALUE eNoSignalError;
@@ -321,8 +343,19 @@ gobj_sig_connect_impl(gboolean after, int argc, VALUE *argv, VALUE self)
                           rb_str_new_cstr(normalized_signal_name),
                           rb_block_proc());
     }
-    rclosure = g_rclosure_new(func, rest, 
-                              rbgobj_get_signal_func(signal_id));
+    {
+        RGClosureCallFunc call_func;
+        call_func = rbgobj_get_signal_call_func(signal_id);
+        if (call_func) {
+            rclosure = g_rclosure_new_call(func,
+                                           rest,
+                                           call_func);
+        } else {
+            rclosure = g_rclosure_new(func,
+                                      rest,
+                                      rbgobj_get_signal_func(signal_id));
+        }
+    }
     g_rclosure_attach((GClosure *)rclosure, self);
     g_object = RVAL2GOBJ(self);
     tag = g_strdup_printf("%s::%s",
@@ -947,6 +980,9 @@ Init_gobject_gsignal(void)
     signal_func_table = rb_hash_new();
     rb_global_variable(&signal_func_table);
 
+    signal_call_func_table = rb_hash_new();
+    rb_global_variable(&signal_call_func_table);
+
     rbg_define_method(mMetaInterface, "signal_new", gobj_s_signal_new, -1);
     rbg_define_method(mMetaInterface, "signals", gobj_s_signals, -1);
     rbg_define_method(mMetaInterface, "signal", gobj_s_signal, 1);