Hello community, here is the log from the commit of package swig for openSUSE:Factory checked in at 2013-06-05 14:32:20 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/swig (Old) and /work/SRC/openSUSE:Factory/.swig.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "swig" Changes: -------- --- /work/SRC/openSUSE:Factory/swig/swig.changes 2013-04-02 13:22:54.000000000 +0200 +++ /work/SRC/openSUSE:Factory/.swig.new/swig.changes 2013-06-05 14:32:21.000000000 +0200 @@ -1,0 +2,41 @@ +Wed May 29 08:10:19 UTC 2013 - [email protected] + +- Ruby 1.8.6 (SLE10) tracks objects differently + Add ruby-1.8.6-newobject.patch + +- Remove skip-python-li_std_containers_int.patch, fixed upstream +- Remove python-2.4.patch, fixed upstream + +- Fix Fedora/RHEL builds (BuildRequires: perl-Test-Simple) + +------------------------------------------------------------------- +Tue May 28 14:37:51 UTC 2013 - [email protected] + +- Change Ruby 1.9+ object tracking to use C hashes, fixes all + failed Ruby tests. + Patch added: 0001-Fix-Ruby-tracking-code-to-use-C-hash.patch + Patch removed: 0008-Ruby-Disable-broken-tests.patch + +------------------------------------------------------------------- +Tue May 28 13:04:21 UTC 2013 - [email protected] + +- Ruby 2.0 strictly enforces encoding + Add ruby-2.0-encoding-utf8.patch + +------------------------------------------------------------------- +Tue May 28 06:43:48 UTC 2013 - [email protected] + +- Update to SWIG 2.0.10 + - Ruby 1.9 support is now complete. + - Add support for Guile 2.0 and Guile 1.6 support (GH interface) has + been dropped. + - Various small language neutral improvements and fixes. + - Various bug fixes and minor improvements specific to C#, CFFI, D, + Java, Octave, PHP, Python, + - Minor bug fix in ccache-swig. + - Development has moved to Github with Travis continuous integration + testing - patches using https://github.com/swig/swig are welcome. + +- drop 0012-Python-Disable-broken-test-in-threads_exception.patch + +------------------------------------------------------------------- Old: ---- 0008-Ruby-Disable-broken-tests.patch 0012-Python-Disable-broken-test-in-threads_exception.patch python-2.4.patch skip-python-li_std_containers_int.patch swig-2.0.9.tar.gz New: ---- 0001-Fix-Ruby-tracking-code-to-use-C-hash.patch ruby-1.8.6-newobject.patch ruby-2.0-encoding-utf8.patch swig-2.0.10.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ swig.spec ++++++ --- /var/tmp/diff_new_pack.HBYdnw/_old 2013-06-05 14:32:22.000000000 +0200 +++ /var/tmp/diff_new_pack.HBYdnw/_new 2013-06-05 14:32:22.000000000 +0200 @@ -17,7 +17,7 @@ Name: swig -Version: 2.0.9 +Version: 2.0.10 Release: 0 Summary: Simplified Wrapper and Interface Generator License: GPL-3.0+ and BSD-3-Clause @@ -25,16 +25,14 @@ Url: http://www.swig.org/ Source: http://sourceforge.net/projects/swig/files/swig/%{name}-%{version}/%{name}-%{version}.tar.gz Source1: %{name}.rpmlintrc -# Disable test failing on Python 2.4 -Patch5: python-2.4.patch -# Disable tests failing on Ruby 1.9 -Patch6: 0008-Ruby-Disable-broken-tests.patch -# Disable test failing in Python -Patch7: 0012-Python-Disable-broken-test-in-threads_exception.patch -# Test fails in openSUSE 12.1 only -Patch8: skip-python-li_std_containers_int.patch # Fix the return type in declaration of caml_array_length Patch9: swig-fix_ocaml_type.patch +# Ruby 2.0 encodes to UTF-8, SWIG to US-ASCII-8BIT, [email protected] +Patch10: ruby-2.0-encoding-utf8.patch +# Fix SWIG object tracking to use C hash, not Ruby Hash, [email protected] +Patch11: 0001-Fix-Ruby-tracking-code-to-use-C-hash.patch +# Ruby 1.8.6 (SLE 10) differs in object tracking, [email protected] +Patch12: ruby-1.8.6-newobject.patch BuildRequires: autoconf BuildRequires: automake BuildRequires: boost-devel @@ -55,6 +53,7 @@ BuildRequires: ruby-devel %endif %if 0%{?fedora} > 0 || 0%{?rhel_version} >= 600 ||0%{?centos_version} >= 600 +BuildRequires: perl-Test-Simple BuildRequires: perl-devel %endif %endif @@ -127,15 +126,17 @@ %prep %setup -q -# Ruby 1.9 from 12.1 %if 0%{?suse_version} == 1010 -%patch5 -p1 +%patch12 -p1 +%endif +# Ruby 1.9 for openSUSE 12.x +%if 0%{?suse_version} >= 1220 +%patch11 -p1 +# Ruby 2.0 for openSUSE 13.1 +%if 0%{?suse_version} > 1230 +%patch10 -p1 %endif -%if 0%{?suse_version} >= 1210 -%patch6 -p1 -%patch8 -p1 %endif -%patch7 -p1 %patch9 %build ++++++ 0001-Fix-Ruby-tracking-code-to-use-C-hash.patch ++++++ >From 84d26240922e5f5b4c0365b0348e856c3c6aaf84 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Klaus=20K=C3=A4mpf?= <[email protected]> Date: Thu, 3 Jan 2013 11:56:25 +0100 Subject: [PATCH] Fix Ruby tracking code to use C hash Patch id #330 This is a patch to resolve bug #2034216. The bug is that the tracking code uses a ruby hash and thus may allocate objects (Bignum) while running the GC. This was tolerated in 1.8 but is invalid (raises an exception) in 1.9. The patch uses a C hash (also used by ruby) instead. --- Lib/ruby/rubytracking.swg | 129 ++++++++++++++++++--------------------------- 1 file changed, 50 insertions(+), 79 deletions(-) diff --git a/Lib/ruby/rubytracking.swg b/Lib/ruby/rubytracking.swg index 0a36f4a..02e92ad 100644 --- a/Lib/ruby/rubytracking.swg +++ b/Lib/ruby/rubytracking.swg @@ -22,19 +22,19 @@ extern "C" { # error sizeof(void*) is not the same as long or long long #endif - -/* Global Ruby hash table to store Trackings from C/C++ +/* Global hash table to store Trackings from C/C++ structs to Ruby Objects. */ -static VALUE swig_ruby_trackings = Qnil; +static st_table* swig_ruby_trackings = NULL; + +VALUE get_swig_trackings_count(ANYARGS) { + return SWIG2NUM(swig_ruby_trackings->num_entries); +} -/* Global variable that stores a reference to the ruby - hash table delete function. */ -static ID swig_ruby_hash_delete; -/* Setup a Ruby hash table to store Trackings */ +/* Setup a hash table to store Trackings */ SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) { - /* Create a ruby hash table to store Trackings from C++ + /* Create a hash table to store Trackings from C++ objects to Ruby objects. */ /* Try to see if some other .so has already created a @@ -43,87 +43,47 @@ SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) { This is done to allow multiple DSOs to share the same tracking table. */ - ID trackings_id = rb_intern( "@__trackings__" ); + VALUE trackings_value = Qnil; + /* change the variable name so that we can mix modules + compiled with older SWIG's */ + ID trackings_id = rb_intern( "@__safetrackings__" ); VALUE verbose = rb_gv_get("VERBOSE"); rb_gv_set("VERBOSE", Qfalse); - swig_ruby_trackings = rb_ivar_get( _mSWIG, trackings_id ); + trackings_value = rb_ivar_get( _mSWIG, trackings_id ); rb_gv_set("VERBOSE", verbose); - /* No, it hasn't. Create one ourselves */ - if ( swig_ruby_trackings == Qnil ) - { - swig_ruby_trackings = rb_hash_new(); - rb_ivar_set( _mSWIG, trackings_id, swig_ruby_trackings ); - } - - /* Now store a reference to the hash table delete function - so that we only have to look it up once.*/ - swig_ruby_hash_delete = rb_intern("delete"); -} - -/* Get a Ruby number to reference a pointer */ -SWIGRUNTIME VALUE SWIG_RubyPtrToReference(void* ptr) { - /* We cast the pointer to an unsigned long - and then store a reference to it using - a Ruby number object. */ - - /* Convert the pointer to a Ruby number */ - return SWIG2NUM(ptr); -} - -/* Get a Ruby number to reference an object */ -SWIGRUNTIME VALUE SWIG_RubyObjectToReference(VALUE object) { - /* We cast the object to an unsigned long - and then store a reference to it using - a Ruby number object. */ - - /* Convert the Object to a Ruby number */ - return SWIG2NUM(object); -} - -/* Get a Ruby object from a previously stored reference */ -SWIGRUNTIME VALUE SWIG_RubyReferenceToObject(VALUE reference) { - /* The provided Ruby number object is a reference - to the Ruby object we want.*/ - - /* Convert the Ruby number to a Ruby object */ - return NUM2SWIG(reference); + /* The trick here is that we have to store the hash table + pointer in a Ruby variable. We do not want Ruby's GC to + treat this pointer as a Ruby object, so we convert it to + a Ruby numeric value. */ + if (trackings_value == Qnil) { + /* No, it hasn't. Create one ourselves */ + swig_ruby_trackings = st_init_numtable(); + rb_ivar_set( _mSWIG, trackings_id, SWIG2NUM(swig_ruby_trackings) ); + } + else { + swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value); + } + + rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", get_swig_trackings_count, NULL); } /* Add a Tracking from a C/C++ struct to a Ruby object */ SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) { - /* In a Ruby hash table we store the pointer and - the associated Ruby object. The trick here is - that we cannot store the Ruby object directly - if - we do then it cannot be garbage collected. So - instead we typecast it as a unsigned long and - convert it to a Ruby number object.*/ - - /* Get a reference to the pointer as a Ruby number */ - VALUE key = SWIG_RubyPtrToReference(ptr); - - /* Get a reference to the Ruby object as a Ruby number */ - VALUE value = SWIG_RubyObjectToReference(object); - /* Store the mapping to the global hash table. */ - rb_hash_aset(swig_ruby_trackings, key, value); + st_insert(swig_ruby_trackings, (st_data_t)ptr, object); } /* Get the Ruby object that owns the specified C/C++ struct */ SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) { - /* Get a reference to the pointer as a Ruby number */ - VALUE key = SWIG_RubyPtrToReference(ptr); - /* Now lookup the value stored in the global hash table */ - VALUE value = rb_hash_aref(swig_ruby_trackings, key); - - if (value == Qnil) { - /* No object exists - return nil. */ - return Qnil; + VALUE value; + + if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) { + return value; } else { - /* Convert this value to Ruby object */ - return SWIG_RubyReferenceToObject(value); + return Qnil; } } @@ -132,12 +92,8 @@ SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) { since the same memory address may be reused later to create a new object. */ SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) { - /* Get a reference to the pointer as a Ruby number */ - VALUE key = SWIG_RubyPtrToReference(ptr); - - /* Delete the object from the hash table by calling Ruby's - do this we need to call the Hash.delete method.*/ - rb_funcall(swig_ruby_trackings, swig_ruby_hash_delete, 1, key); + /* Delete the object from the hash table */ + st_delete(swig_ruby_trackings, (st_data_t *)&ptr, NULL); } /* This is a helper method that unlinks a Ruby object from its @@ -147,10 +103,25 @@ SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) { VALUE object = SWIG_RubyInstanceFor(ptr); if (object != Qnil) { + if (TYPE(object) != T_DATA) + abort(); DATA_PTR(object) = 0; } } +/* This is a helper method that iterates over all the trackings + passing the C++ object pointer and its related Ruby object + to the passed callback function. */ + +/* Proxy method to abstract the internal trackings datatype */ +static int _ruby_internal_iterate_callback(void* ptr, VALUE obj, void(*meth)(void* ptr, VALUE obj)) { + (*meth)(ptr, obj); + return ST_CONTINUE; +} + +SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) { + st_foreach(swig_ruby_trackings, (int (*)(ANYARGS))&_ruby_internal_iterate_callback, (st_data_t)meth); +} #ifdef __cplusplus } -- 1.7.10.4 ++++++ ruby-1.8.6-newobject.patch ++++++ diff -wruN -x '*~' -x '*.o' -x '*.a' -x '*.so' -x '*.so.[0-9]' -x autom4te.cache -x .deps -x .libs -x Makefile -x Makefile ../orig-swig-2.0.10/Examples/test-suite/ruby/newobject1_runme.rb ./Examples/test-suite/ruby/newobject1_runme.rb --- ../orig-swig-2.0.10/Examples/test-suite/ruby/newobject1_runme.rb 2013-05-27 20:24:04.000000000 +0200 +++ ./Examples/test-suite/ruby/newobject1_runme.rb 2013-05-29 09:55:57.922485272 +0200 @@ -29,5 +29,5 @@ GC.stats if $VERBOSE swig_assert( 'Foo.fooCount == 200', binding, "but is #{Foo.fooCount}" ) GC.start -swig_assert( 'Foo.fooCount <= 2', binding, "but is #{Foo.fooCount}" ) +swig_assert( 'Foo.fooCount <= 3', binding, "but is #{Foo.fooCount}" ) ++++++ ruby-2.0-encoding-utf8.patch ++++++ diff -wruN -x '*~' -x '*.o' -x '*.a' -x '*.so' -x '*.so.[0-9]' -x autom4te.cache -x .deps -x .libs -x Makefile -x Makefile ../orig-swig-2.0.10/Examples/test-suite/ruby/char_constant_runme.rb ./Examples/test-suite/ruby/char_constant_runme.rb --- ../orig-swig-2.0.10/Examples/test-suite/ruby/char_constant_runme.rb 2013-05-27 20:24:04.000000000 +0200 +++ ./Examples/test-suite/ruby/char_constant_runme.rb 2013-05-28 14:48:44.924421929 +0200 @@ -28,7 +28,7 @@ raise RuntimeError, "Invalid value for NULL_CONST." end -if Char_constant::SPECIALCHAR != "\341" #'�' +if Char_constant::SPECIALCHAR.ord != 225 # "\341" #'�' raise RuntimeError, "Invalid value for SPECIALCHAR." end ++++++ swig-2.0.9.tar.gz -> swig-2.0.10.tar.gz ++++++ ++++ 56000 lines of diff (skipped) -- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
