glib2 1.0.0-x86-mingw32 → 1.0.1-x86-mingw32

data/ChangeLog

@@ -1,3 +1,110 @@
+2011-09-18  Kouhei Sutou  <kou@cozmixng.org>
+
+	* ext/glib2/rbgutil_callback.c: don't include unistd.h on Win32
+	environment.
+
+	* ext/glib2/rbgutil_callback.c (queue_callback_request): use
+	G_GSSIZE_FORMAT instead of 'z' for portability.
+
+	* lib/glib2.rb (GLib#__add_one_arg_setter): cleanup.
+
+	* ext/glib2/rbgutil_callback.c (queue_callback_request): add
+	missing 'z' for size_t format parameter.
+
+	* lib/glib2.rb (GLib.__add_one_arg_setter): convert method names
+	to String not Symbol to work on Ruby 1.8.
+
+	* test/glib-test-init.rb: require "rubygems".
+
+	* ext/glib2/rbgutil_callback.c (queue_callback_request): suppress
+	a warning. (variable ‘written’ set but not used
+	[-Wunused-but-set-variable])
+
+	* ext/glib2/rbgutil_callback.c, ext/glib2/rbgprivate.h: work
+	rb_errinfo() on Ruby 1.8 in all files.
+
+	* ext/glib2/rbglib.c, ext/glib2/rbglib.h, ext/glib2/glib2.def:
+	rbg_cstr2rval_with_free() -> rbg_cstr2rval_free().
+
+	* ext/glib2/rbglib.c: don't export internal functions.
+
+	* ext/glib2/rbglib.c (rbg_filename_to_ruby_body)
+	(rbg_filename_to_ruby_ensure): don't define on Ruby 1.8.
+
+	* ext/glib2/rbglib.c (rbg_filename_to_ruby): use
+	rb_external_str_new_with_enc().
+
+	* ext/glib2/rbglib.h: 1.0.0 -> 1.0.1.
+
+2011-09-16  Nikolai Weibull  <now@bitwi.se>
+
+	* lib/glib2.rb: Remove unused variable.
+	* ext/glib2/rbglib.c: Don’t use ALLOCA_N() on user-supplied input.
+	* ext/glib2/rbglib.c, ext/glib2/rbglib.h, ext/glib2/glib2.def: Remove
+	rbg_rval2argv() and RVAL2ARGV().
+	* glib2/ext/glib2/rbglib_spawn.c: Use RVAL2STRV() instead of
+	RVAL2ARGV().
+
+2011-09-15  Nikolai Weibull  <now@bitwi.se>
+
+	* ext/glib2/rbgobj_strv.c: Plug memory leak.
+	* ext/glib2/rbgutil.h: Add G_REPLACE_SET_PROPERTY(),
+	G_REPLACE_GET_PROPERTY(), and G_REPLACE_ACTION() macros for replacing
+	automatically defined property getters and setters and actions (from
+	G_SIGNAL_ACTION).  These are primarily useful for making it clear why
+	we’re undefining a method and then redefining it.
+
+2011-09-14  Nikolai Weibull  <now@bitwi.se>
+
+	* ext/glib2/rbglib_iochannel.c: Fix broken code under Win32.
+	* ext/glib2/*.c: Fix warnings on Win32.
+	* ext/glib2/glib2.def: Add new externs.
+
+2011-09-12  Nikolai Weibull  <now@bitwi.se>
+
+	* lib/glib2.rb (__add_one_arg_setter): Ruby 1.9-proof this method.
+	* ext/glib2/rbglib.c: Fix coding style.
+	* ext/glib2/rbglib.c: Don’t use StringValue(RARRAY_PTR(ary)[i]), as
+	that changes the Array.
+	* ext/glib2/rbglib.c: Add rbg_strv2rval().
+	* ext/glib2/rbglib.h: Add RVAL2STRV and STRV2RVAL().
+	* ext/glib2/rbgobj_strv.c: Use RVAL2STRV() and STRV2RVAL().
+	* ext/glib2/rbglib.c: Ensure that memory is freed.
+	* ext/glib2/rbglib.h: Add CSTRFILENAME2RVAL().
+	* ext/glib2/rbglib.c: Add rbg_strv2rval_free().
+	* ext/glib2/rbglib.h: Add RVAL2STRV_FREE().
+
+2011-09-10  Nikolai Weibull  <now@bitwi.se>
+
+	* ChangeLog: Fix date header for previous entry.
+	* lib/mkmf-gnome2.rb: Make last change backwards compatible with older
+	RubyGems.  I don’t like RubyGems.
+	* ext/glib2/rbglib.c (rbg_rval2cstr_filename): Fix allocation.
+	* ext/glib2/rbglib_bookmarkfile.c: Fix RVAL2CSTRFILENAME calls.
+
+2011-09-09  Nikolai Weibull  <now@bitwi.se>
+
+	* lib/mkmf-gnome2.rb: Use new RubyGems APIs.
+	* ext/glib2/*.c: Fix all warnings generated with gcc 4.4.5.
+	* ext/glib2/*.c: Fix all RVAL2CSTR calls.
+
+2011-08-04  Kouhei Sutou  <kou@cozmixng.org>
+
+	* ext/glib2/rbglib_iochannel.c (ioc_win32_socket_initialize): use
+	rb_w32_get_osfhandle() to get raw socket handle on Windows.
+	Suggested by NAKAMURA Usaku. Thanks!!!
+
+2011-08-03  Kouhei Sutou  <kou@cozmixng.org>
+
+	* ext/glib2/rbglib_iochannel.c (ioc_s_open): add missing Windows
+	support.
+	Reported by OBATA Akio. Thanks!!!
+
+2011-07-13  Kouhei Sutou  <kou@cozmixng.org>
+
+	* ext/glib2/rbglib_iochannel.c (ioc_win32_socket_initialize): fix
+	variable name.
+
 2011-06-30  Kouhei Sutou  <kou@cozmixng.org>
 
 	* ext/glib2/rbglib_iochannel.c: bind g_io_channel_win32_new_socket().

data/ext/glib2/glib2.def

@@ -56,14 +56,25 @@ EXPORTS
 	g_value_set_ruby_value
 	g_key_file_get_type
 	rbg_rval_inspect
+	rbg_string_value_ptr
 	rbg_rval2cstr
 	rbg_rval2cstr_accept_nil
 	rbg_cstr2rval
+        rbg_cstr2rval_len
+        rbg_cstr2rval_with_encoding
+        rbg_cstr2rval_len_with_encoding
+	rbg_cstr2rval_free
 	rbg_cstr2rval_with_free
+        rbg_filename_to_ruby
         rbg_filename_to_ruby_free
         rbg_filename_from_ruby
         rbg_filename_gslist_to_array_free
-	rbg_string_value_ptr
+        rbg_rval2strv
+        rbg_rval2strv_accept_nil
+        rbg_rval2strv_dup
+        rbg_rval2strv_dup_accept_nil
+        rbg_strv2rval
+        rbg_strv2rval_free
 	rbgutil_id_module_eval		DATA
 	rbgutil_def_setters
 	rbgutil_glist2ary

data/ext/glib2/rbglib.c

@@ -43,24 +43,24 @@ extern void Init_glib_unicode();
 extern void Init_glib_keyfile();
 extern void Init_glib_bookmark_file();
 
-gchar *
+const gchar *
 rbg_rval2cstr(VALUE *str)
 {
     StringValue(*str);
+
 #ifdef HAVE_RUBY_ENCODING_H
-    if (rb_enc_get(*str) != rb_utf8_encoding()) {
+    if (rb_enc_get(*str) != rb_utf8_encoding())
         *str = rb_str_export_to_enc(*str, rb_utf8_encoding());
-    }
 #endif
+
     return RSTRING_PTR(*str);
 }
 
 const gchar *
 rbg_rval_inspect(VALUE object)
 {
-    VALUE inspected;
+    VALUE inspected = rb_funcall(object, id_inspect, 0);
 
-    inspected = rb_funcall(object, id_inspect, 0);
     return RVAL2CSTR(inspected);
 }
 
@@ -70,25 +70,22 @@ rbg_string_value_ptr(volatile VALUE *ptr)
     return rb_string_value_ptr(ptr);
 }
 
-gchar *
+const gchar *
 rbg_rval2cstr_accept_nil(VALUE *str)
 {
     return NIL_P(*str) ? NULL : RVAL2CSTR(*str);
 }
 
 VALUE
-rbg_cstr2rval(const gchar* str)
+rbg_cstr2rval(const gchar *str)
 {
-    if (!str)
-        return Qnil;
-
-    return CSTR2RVAL_LEN(str, strlen(str));
+    return str != NULL ? CSTR2RVAL_LEN(str, strlen(str)) : Qnil;
 }
 
 VALUE
-rbg_cstr2rval_len(const gchar* str, gsize len)
+rbg_cstr2rval_len(const gchar *str, gsize len)
 {
-    if (!str)
+    if (str == NULL)
         return Qnil;
 
 #ifdef HAVE_RUBY_ENCODING_H
@@ -99,76 +96,126 @@ rbg_cstr2rval_len(const gchar* str, gsize len)
 }
 
 VALUE
-rbg_cstr2rval_with_encoding(const gchar* str, const gchar *encoding)
+rbg_cstr2rval_with_encoding(const gchar *str, const gchar *encoding)
 {
-    if (!str)
-        return Qnil;
-
-    return CSTR2RVAL_LEN_ENC(str, strlen(str), encoding);
+    return str != NULL ? CSTR2RVAL_LEN_ENC(str, strlen(str), encoding) : Qnil;
 }
 
 VALUE
-rbg_cstr2rval_len_with_encoding(const gchar* str, gsize len,
+rbg_cstr2rval_len_with_encoding(const gchar *str, gsize len,
                                 const gchar *encoding)
 {
-    if (!str)
+    if (str == NULL)
         return Qnil;
 
 #ifdef HAVE_RUBY_ENCODING_H
-    {
-        rb_encoding *rb_encoding;
-
-        if (encoding) {
-            rb_encoding = rb_enc_find(encoding);
-        } else {
-            rb_encoding = rb_utf8_encoding();
-        }
-        return rb_external_str_new_with_enc(str, len, rb_encoding);
-    }
+    return rb_external_str_new_with_enc(str, len,
+                                        encoding != NULL ?
+                                            rb_enc_find(encoding) :
+                                            rb_utf8_encoding());
 #else
     return rb_str_new(str, len);
 #endif
 }
 
 static VALUE
-rbg_cstr2rval_with_free_body(VALUE str)
+rbg_cstr2rval_free_body(VALUE str)
 {
     return CSTR2RVAL((const gchar *)str);
 }
 
 static VALUE
-rbg_cstr2rval_with_free_ensure(VALUE str)
+rbg_cstr2rval_free_ensure(VALUE str)
 {
     g_free((gchar *)str);
 
     return Qnil;
 }
 
+VALUE
+rbg_cstr2rval_free(gchar *str)
+{
+    return str != NULL? rb_ensure(rbg_cstr2rval_free_body, (VALUE)str,
+                                  rbg_cstr2rval_free_ensure, (VALUE)str) : Qnil;
+}
+
+/* just for backward compatibility. */
 VALUE
 rbg_cstr2rval_with_free(gchar *str)
 {
-    return str ? rb_ensure(rbg_cstr2rval_with_free_body, (VALUE)str,
-                           rbg_cstr2rval_with_free_ensure, (VALUE)str) : Qnil;
+    return rbg_cstr2rval_free(str);
 }
 
 #ifdef HAVE_RUBY_ENCODING_H
 static rb_encoding *filename_encoding_if_not_utf8;
 #endif
 
+#ifdef HAVE_RUBY_ENCODING_H
+static VALUE
+rbg_filename_to_ruby_body(VALUE filename)
+{
+    const gchar *filename_utf8 = (const gchar *)filename;
+    VALUE rb_filename;
+
+    rb_filename = rb_external_str_new_with_enc(filename_utf8,
+                                               strlen(filename_utf8),
+                                               rb_utf8_encoding());
+
+    /* if needed, change encoding of Ruby String to filename encoding, so that
+       upcoming File operations will work properly */
+    return filename_encoding_if_not_utf8 != NULL ?
+        rb_str_export_to_enc(rb_filename, filename_encoding_if_not_utf8) :
+        rb_filename;
+}
+
+static VALUE
+rbg_filename_to_ruby_ensure(VALUE filename)
+{
+    g_free((gchar *)filename);
+
+    return Qnil;
+}
+#endif
+
 VALUE
-rbg_filename_to_ruby_free(gchar *filename)
+rbg_filename_to_ruby(const gchar *filename)
 {
 #ifdef HAVE_RUBY_ENCODING_H
     gchar *filename_utf8;
+    gsize written;
     GError *error = NULL;
+
+    if (filename == NULL)
+        return Qnil;
+
+    if (filename_encoding_if_not_utf8 == NULL)
+        return CSTR2RVAL(filename);
+
+    filename_utf8 = g_filename_to_utf8(filename, -1, NULL, &written, &error);
+    if (error != NULL)
+        RAISE_GERROR(error);
+
+    return rb_ensure(rbg_filename_to_ruby_body, (VALUE)filename_utf8,
+                     rbg_filename_to_ruby_ensure, (VALUE)filename_utf8);
+#else
+    return CSTR2RVAL(filename);
+#endif
+}
+
+VALUE
+rbg_filename_to_ruby_free(gchar *filename)
+{
+#ifdef HAVE_RUBY_ENCODING_H
+    gchar *filename_utf8;
     gsize written;
-    VALUE rb_filename = Qnil;
 
     if (filename == NULL)
         return Qnil;
-       
+
     /* convert filename to UTF-8 if needed */
     if (filename_encoding_if_not_utf8 != NULL) {
+        GError *error = NULL;
+
         filename_utf8 = g_filename_to_utf8(filename, -1, NULL, &written, &error);
         g_free(filename);
         if (error != NULL)
@@ -177,20 +224,8 @@ rbg_filename_to_ruby_free(gchar *filename)
         filename_utf8 = filename;
     }
 
-    /* create Ruby String in UTF-8 */
-    rb_filename = rb_external_str_new_with_enc(filename_utf8,
-                                               strlen(filename_utf8),
-                                               rb_utf8_encoding());
-    g_free(filename_utf8);
-
-    /* if needed, change encoding of Ruby String to filename encoding, so that
-       upcoming File operations will work properly */
-    if (filename_encoding_if_not_utf8 != NULL) {
-        return rb_str_export_to_enc(rb_filename, filename_encoding_if_not_utf8);
-    } else {
-        return rb_filename;
-    }
-
+    return rb_ensure(rbg_filename_to_ruby_body, (VALUE)filename_utf8,
+                     rbg_filename_to_ruby_ensure, (VALUE)filename_utf8);
 #else
     return CSTR2RVAL_FREE(filename);
 #endif
@@ -200,44 +235,198 @@ gchar *
 rbg_filename_from_ruby(VALUE filename)
 {
 #ifdef HAVE_RUBY_ENCODING_H
-    GError *error = NULL;
     gchar *retval;
     gsize written;
+    GError *error = NULL;
 
     /* if needed, change encoding of Ruby String to UTF-8 */
     StringValue(filename);
-    if (rb_enc_get(filename) != rb_utf8_encoding()) {
+    if (rb_enc_get(filename) != rb_utf8_encoding())
         filename = rb_str_export_to_enc(filename, rb_utf8_encoding());
-    }
 
     /* convert it to filename encoding if needed */
-    if (filename_encoding_if_not_utf8 != NULL) {
-        retval = g_filename_from_utf8(RSTRING_PTR(filename), -1, NULL, &written, &error);
-        if (error != NULL)
-            RAISE_GERROR(error);
-    } else {
-        retval = RSTRING_PTR(filename);
-    }
+    if (filename_encoding_if_not_utf8 == NULL)
+        return g_strdup(RSTRING_PTR(filename));
 
-    return retval;
+    retval = g_filename_from_utf8(RSTRING_PTR(filename), -1, NULL, &written, &error);
+    if (error != NULL)
+        RAISE_GERROR(error);
 
+    return retval;
 #else
-    return RVAL2CSTR(filename);
+    return g_strdup(RVAL2CSTR(filename));
 #endif
 }
 
-VALUE
-rbg_filename_gslist_to_array_free(GSList *list)
+static VALUE
+rbg_filename_gslist_to_array_free_body(VALUE list)
 {
-    GSList *l;
     VALUE ary = rb_ary_new();
-    for (l = list; l != NULL; l = g_slist_next(l)) {
-        rb_ary_push(ary, rbg_filename_to_ruby_free(l->data));
-    }
+    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;
+};
+
+static VALUE
+rbg_rval2strv_body(VALUE value)
+{
+    long i;
+    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;
+
+    return Qnil;
+}
+
+static VALUE
+rbg_rval2strv_rescue(VALUE value)
+{
+    struct rval2strv_args *args = (struct rval2strv_args *)value;
+
+    g_free(args->strings);
+
+    rb_exc_raise(rb_errinfo());
+}
+
+const gchar **
+rbg_rval2strv(VALUE value)
+{
+    struct rval2strv_args args;
+
+    args.ary = rb_ary_to_ary(value);
+    args.n = RARRAY_LEN(args.ary);
+    args.strings = g_new(const gchar *, args.n + 1);
+
+    rb_rescue(rbg_rval2strv_body, (VALUE)&args,
+              rbg_rval2strv_rescue, (VALUE)&args);
+
+    return args.strings;
+}
+
+const gchar **
+rbg_rval2strv_accept_nil(VALUE ary)
+{
+    return NIL_P(ary) ? NULL : rbg_rval2strv(ary);
+}
+
+struct rval2strv_dup_args {
+    VALUE ary;
+    long n;
+    gchar **strings;
+};
+
+static VALUE
+rbg_rval2strv_dup_body(VALUE value)
+{
+    long i;
+    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;
+
+    return Qnil;
+}
+
+static VALUE
+rbg_rval2strv_dup_rescue(VALUE value)
+{
+    struct rval2strv_dup_args *args = (struct rval2strv_dup_args *)value;
+
+    g_free(args->strings);
+
+    rb_exc_raise(rb_errinfo());
+}
+
+gchar **
+rbg_rval2strv_dup(VALUE value)
+{
+    struct rval2strv_dup_args args;
+
+    args.ary = rb_ary_to_ary(value);
+    args.n = RARRAY_LEN(args.ary);
+    args.strings = g_new(gchar *, args.n + 1);
+
+    rb_rescue(rbg_rval2strv_dup_body, (VALUE)&args,
+              rbg_rval2strv_dup_rescue, (VALUE)&args);
+
+    return args.strings;
+}
+
+gchar **
+rbg_rval2strv_dup_accept_nil(VALUE ary)
+{
+    return NIL_P(ary) ? NULL : rbg_rval2strv_dup(ary);
+}
+
+VALUE
+rbg_strv2rval(const gchar **strings)
+{
+    VALUE ary;
+    const gchar **p;
+
+    if (strings == NULL)
+        return Qnil;
+
+    ary = rb_ary_new();
+    for (p = strings; *p != NULL; p++)
+        rb_ary_push(ary, CSTR2RVAL(*p));
+
     return ary;
 }
 
+static VALUE
+rbg_strv2rval_free_body(VALUE strings)
+{
+    return STRV2RVAL((const gchar **)strings);
+}
+
+static VALUE
+rbg_strv2rval_free_ensure(VALUE strings)
+{
+    g_strfreev((gchar **)strings);
+
+    return Qnil;
+}
+
+VALUE
+rbg_strv2rval_free(gchar **strings)
+{
+    return rb_ensure(rbg_strv2rval_free_body, (VALUE)strings,
+                     rbg_strv2rval_free_ensure, (VALUE)strings);
+}
 
 #if 0
 /*