zeroc-ice 3.7.1 → 3.7.6

data/ext/Proxy.h

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #ifndef ICE_RUBY_PROXY_H
 #define ICE_RUBY_PROXY_H

data/ext/Slice.cpp

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #include <Slice.h>
 #include <Util.h>
@@ -21,7 +16,7 @@ using namespace Slice::Ruby;
 
 extern "C"
 VALUE
-IceRuby_loadSlice(int argc, VALUE* argv, VALUE self)
+IceRuby_loadSlice(int argc, VALUE* argv, VALUE /*self*/)
 {
     ICE_RUBY_TRY
     {
@@ -163,7 +158,7 @@ IceRuby_loadSlice(int argc, VALUE* argv, VALUE self)
 
 extern "C"
 VALUE
-IceRuby_compile(int argc, VALUE* argv, VALUE self)
+IceRuby_compile(int argc, VALUE* argv, VALUE /*self*/)
 {
     ICE_RUBY_TRY
     {
@@ -190,16 +185,6 @@ IceRuby_compile(int argc, VALUE* argv, VALUE self)
             cerr << argSeq[0] << ": error:" << ex.what() << endl;
             rc = EXIT_FAILURE;
         }
-        catch(const std::string& msg)
-        {
-            cerr << argSeq[0] << ": error:" << msg << endl;
-            rc = EXIT_FAILURE;
-        }
-        catch(const char* msg)
-        {
-            cerr << argSeq[0] << ": error:" << msg << endl;
-            rc = EXIT_FAILURE;
-        }
         catch(...)
         {
             cerr << argSeq[0] << ": error:" << "unknown exception" << endl;

data/ext/Slice.h

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #ifndef ICE_RUBY_SLICE_H
 #define ICE_RUBY_SLICE_H

data/ext/Types.cpp

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #include <Types.h>
 #include <Proxy.h>
@@ -80,9 +75,9 @@ escapeString(const string& str)
     {
         if(charSet.find(*c) == charSet.end())
         {
-            unsigned char uc = *c;                  // char may be signed, so make it positive
+            unsigned char uc = static_cast<unsigned char>(*c); // char may be signed, so make it positive
             ostringstream s;
-            s << "\\";                              // Print as octal if not in basic source character set
+            s << "\\";                                         // Print as octal if not in basic source character set
             s.width(3);
             s.fill('0');
             s << oct;
@@ -245,8 +240,7 @@ IceRuby::StreamUtil::setSlicedDataMember(VALUE obj, const Ice::SlicedDataPtr& sl
 
     volatile VALUE sd = callRuby(rb_class_new_instance, 0, static_cast<VALUE*>(0), _slicedDataType);
 
-    Ice::Int sz = slicedData->slices.size();
-    volatile VALUE slices = createArray(sz);
+    volatile VALUE slices = createArray(static_cast<long>(slicedData->slices.size()));
 
     callRuby(rb_iv_set, sd, "@slices", slices);
 
@@ -276,13 +270,15 @@ IceRuby::StreamUtil::setSlicedDataMember(VALUE obj, const Ice::SlicedDataPtr& sl
         //
         // bytes
         //
-        volatile VALUE bytes = callRuby(rb_str_new, reinterpret_cast<const char*>(&(*p)->bytes[0]), (*p)->bytes.size());
+        volatile VALUE bytes = callRuby(rb_str_new,
+                                        (*p)->bytes.empty() ? 0 : reinterpret_cast<const char*>(&(*p)->bytes[0]),
+                                        static_cast<long>((*p)->bytes.size()));
         callRuby(rb_iv_set, slice, "@bytes", bytes);
 
         //
         // instances
         //
-        volatile VALUE instances = createArray((*p)->instances.size());
+        volatile VALUE instances = createArray(static_cast<long>((*p)->instances.size()));
         callRuby(rb_iv_set, slice, "@instances", instances);
 
         int j = 0;
@@ -370,15 +366,15 @@ IceRuby::StreamUtil::getSlicedDataMember(VALUE obj, ObjectMap* objectMap)
 
                     Ice::ObjectPtr writer;
 
-                    ObjectMap::iterator i = objectMap->find(o);
-                    if(i == objectMap->end())
+                    ObjectMap::iterator k = objectMap->find(o);
+                    if(k == objectMap->end())
                     {
                         writer = new ObjectWriter(o, objectMap, 0);
                         objectMap->insert(ObjectMap::value_type(o, writer));
                     }
                     else
                     {
-                        writer = i->second;
+                        writer = k->second;
                     }
 
                     info->instances.push_back(writer);
@@ -1017,7 +1013,7 @@ IceRuby::StructInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap* objectMa
         p = _nullMarshalValue;
     }
 
-    Ice::OutputStream::size_type sizePos = -1;
+    Ice::OutputStream::size_type sizePos = 0;
     if(optional)
     {
         if(_variableLength)
@@ -1157,8 +1153,8 @@ IceRuby::SequenceInfo::validate(VALUE val)
             return true;
         }
     }
-    ID id = rb_intern("to_ary");
-    return callRuby(rb_respond_to, val, id) != 0;
+    ID rbid = rb_intern("to_ary");
+    return callRuby(rb_respond_to, val, rbid) != 0;
 }
 
 bool
@@ -1192,7 +1188,7 @@ IceRuby::SequenceInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap* object
 
     volatile VALUE arr = Qnil;
 
-    Ice::OutputStream::size_type sizePos = -1;
+    Ice::OutputStream::size_type sizePos = 0;
     if(optional)
     {
         if(elementType->variableLength())
@@ -1400,10 +1396,10 @@ IceRuby::SequenceInfo::marshalPrimitiveSequence(const PrimitiveInfoPtr& pi, VALU
     case PrimitiveInfo::KindBool:
     {
         long sz = RARRAY_LEN(arr);
-        Ice::BoolSeq seq(sz);
+        Ice::BoolSeq seq(static_cast<size_t>(sz));
         for(long i = 0; i < sz; ++i)
         {
-            seq[i] = RTEST(RARRAY_AREF(arr, i));
+            seq[static_cast<size_t>(i)] = RTEST(RARRAY_AREF(arr, i));
         }
         os->write(seq);
         break;
@@ -1426,7 +1422,7 @@ IceRuby::SequenceInfo::marshalPrimitiveSequence(const PrimitiveInfoPtr& pi, VALU
         else
         {
             long sz = RARRAY_LEN(arr);
-            Ice::ByteSeq seq(sz);
+            Ice::ByteSeq seq(static_cast<size_t>(sz));
             for(long i = 0; i < sz; ++i)
             {
                 long val = getInteger(RARRAY_AREF(arr, i));
@@ -1434,16 +1430,16 @@ IceRuby::SequenceInfo::marshalPrimitiveSequence(const PrimitiveInfoPtr& pi, VALU
                 {
                     throw RubyException(rb_eTypeError, "invalid value for element %ld of sequence<byte>", i);
                 }
-                seq[i] = static_cast<Ice::Byte>(val);
+                seq[static_cast<size_t>(i)] = static_cast<Ice::Byte>(val);
             }
-            os->write(&seq[0], &seq[0] + seq.size());
+            os->write(seq);
         }
         break;
     }
     case PrimitiveInfo::KindShort:
     {
         long sz = RARRAY_LEN(arr);
-        Ice::ShortSeq seq(sz);
+        Ice::ShortSeq seq(static_cast<size_t>(sz));
         for(long i = 0; i < sz; ++i)
         {
             long val = getInteger(RARRAY_AREF(arr, i));
@@ -1451,15 +1447,15 @@ IceRuby::SequenceInfo::marshalPrimitiveSequence(const PrimitiveInfoPtr& pi, VALU
             {
                 throw RubyException(rb_eTypeError, "invalid value for element %ld of sequence<short>", i);
             }
-            seq[i] = static_cast<Ice::Short>(val);
+            seq[static_cast<size_t>(i)] = static_cast<Ice::Short>(val);
         }
-        os->write(&seq[0], &seq[0] + seq.size());
+        os->write(seq);
         break;
     }
     case PrimitiveInfo::KindInt:
     {
         long sz = RARRAY_LEN(arr);
-        Ice::IntSeq seq(sz);
+        Ice::IntSeq seq(static_cast<size_t>(sz));
         for(long i = 0; i < sz; ++i)
         {
             long val = getInteger(RARRAY_AREF(arr, i));
@@ -1467,26 +1463,26 @@ IceRuby::SequenceInfo::marshalPrimitiveSequence(const PrimitiveInfoPtr& pi, VALU
             {
                 throw RubyException(rb_eTypeError, "invalid value for element %ld of sequence<int>", i);
             }
-            seq[i] = static_cast<Ice::Int>(val);
+            seq[static_cast<size_t>(i)] = static_cast<Ice::Int>(val);
         }
-        os->write(&seq[0], &seq[0] + seq.size());
+        os->write(seq);
         break;
     }
     case PrimitiveInfo::KindLong:
     {
         long sz = RARRAY_LEN(arr);
-        Ice::LongSeq seq(sz);
+        Ice::LongSeq seq(static_cast<size_t>(sz));
         for(long i = 0; i < sz; ++i)
         {
-            seq[i] = getLong(RARRAY_AREF(arr, i));
+            seq[static_cast<size_t>(i)] = getLong(RARRAY_AREF(arr, i));
         }
-        os->write(&seq[0], &seq[0] + seq.size());
+        os->write(seq);
         break;
     }
     case PrimitiveInfo::KindFloat:
     {
         long sz = RARRAY_LEN(arr);
-        Ice::FloatSeq seq(sz);
+        Ice::FloatSeq seq(static_cast<size_t>(sz));
         for(long i = 0; i < sz; ++i)
         {
             volatile VALUE v = callRuby(rb_Float, RARRAY_AREF(arr, i));
@@ -1495,15 +1491,15 @@ IceRuby::SequenceInfo::marshalPrimitiveSequence(const PrimitiveInfoPtr& pi, VALU
                 throw RubyException(rb_eTypeError, "unable to convert array element %ld to a float", i);
             }
             assert(TYPE(v) == T_FLOAT);
-            seq[i] = static_cast<Ice::Float>(RFLOAT_VALUE(v));
+            seq[static_cast<size_t>(i)] = static_cast<Ice::Float>(RFLOAT_VALUE(v));
         }
-        os->write(&seq[0], &seq[0] + seq.size());
+        os->write(seq);
         break;
     }
     case PrimitiveInfo::KindDouble:
     {
         long sz = RARRAY_LEN(arr);
-        Ice::DoubleSeq seq(sz);
+        Ice::DoubleSeq seq(static_cast<size_t>(sz));
         for(long i = 0; i < sz; ++i)
         {
             volatile VALUE v = callRuby(rb_Float, RARRAY_AREF(arr, i));
@@ -1512,24 +1508,31 @@ IceRuby::SequenceInfo::marshalPrimitiveSequence(const PrimitiveInfoPtr& pi, VALU
                 throw RubyException(rb_eTypeError, "unable to convert array element %ld to a double", i);
             }
             assert(TYPE(v) == T_FLOAT);
-            seq[i] = RFLOAT_VALUE(v);
+            seq[static_cast<size_t>(i)] = RFLOAT_VALUE(v);
         }
-        os->write(&seq[0], &seq[0] + seq.size());
+        os->write(seq);
         break;
     }
     case PrimitiveInfo::KindString:
     {
         long sz = RARRAY_LEN(arr);
-        Ice::StringSeq seq(sz);
+        Ice::StringSeq seq(static_cast<size_t>(sz));
         for(long i = 0; i < sz; ++i)
         {
-            seq[i] = getString(RARRAY_AREF(arr, i));
+            seq[static_cast<size_t>(i)] = getString(RARRAY_AREF(arr, i));
+        }
+        if(seq.empty())
+        {
+            os->write(seq);
         }
+        else
+        {
 #ifdef HAVE_RUBY_ENCODING_H
-        os->write(&seq[0], &seq[0] + seq.size(), false); // Bypass string conversion.
+            os->write(&seq[0], &seq[0] + seq.size(), false); // Bypass string conversion.
 #else
-        os->write(&seq[0], &seq[0] + seq.size(), true);
+            os->write(&seq[0], &seq[0] + seq.size(), true);
 #endif
+        }
         break;
     }
     }
@@ -1663,12 +1666,9 @@ IceRuby::SequenceInfo::unmarshalPrimitiveSequence(const PrimitiveInfoPtr& pi, Ic
         long sz = static_cast<long>(seq.size());
         result = createArray(sz);
 
-        if(sz > 0)
+        for(long i = 0; i < sz; ++i)
         {
-            for(long i = 0; i < sz; ++i)
-            {
-                RARRAY_ASET(result, i, createString(seq[i]));
-            }
+            RARRAY_ASET(result, i, createString(seq[static_cast<size_t>(i)]));
         }
         break;
     }
@@ -1705,8 +1705,8 @@ IceRuby::DictionaryInfo::validate(VALUE val)
     {
         return true;
     }
-    ID id = rb_intern("to_hash");
-    return callRuby(rb_respond_to, val, id) != 0;
+    ID rbid = rb_intern("to_hash");
+    return callRuby(rb_respond_to, val, rbid) != 0;
 }
 
 bool
@@ -1767,10 +1767,10 @@ IceRuby::DictionaryInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap* obje
         }
     }
 
-    int sz = 0;
+    Ice::Int sz = 0;
     if(!NIL_P(hash))
     {
-        sz = RHASH_SIZE(hash);
+        sz = static_cast<Ice::Int>(RHASH_SIZE(hash));
     }
 
     Ice::OutputStream::size_type sizePos = 0;
@@ -1853,7 +1853,18 @@ IceRuby::DictionaryInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallback
         //
         keyType->unmarshal(is, keyCB, Qnil, 0, false);
         assert(!NIL_P(keyCB->key));
-
+        if (valueType->usesClasses())
+        {
+            // Temporarily set the entry with a Qnil value to ensure the key is not GC
+            // while unmarshaling a value class
+            if (RB_TYPE_P(keyCB->key, T_STRING))
+            {
+                // For string keys create a frozen string to ensure that the key used
+                // in the map matches the one keep in the closure
+                keyCB->key = rb_str_new_frozen(keyCB->key);
+            }
+            callRuby(rb_hash_aset, hash, keyCB->key, Qnil);
+        }
         //
         // The callback will set the dictionary entry with the unmarshaled value,
         // so we pass it the key.
@@ -2361,7 +2372,7 @@ IceRuby::ProxyInfo::optionalFormat() const
 void
 IceRuby::ProxyInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap*, bool optional)
 {
-    Ice::OutputStream::size_type sizePos = -1;
+    Ice::OutputStream::size_type sizePos = 0;
     if(optional)
     {
         sizePos = os->startSize();
@@ -2744,7 +2755,10 @@ IceRuby::ReadObjectCallback::invoke(const Ice::ObjectPtr& p)
             ex.expectedType = _info->id;
             throw ex;
         }
-
+#ifndef NDEBUG
+        // With debug builds we force a GC to ensure that all data members are correctly keep alive.
+        rb_gc();
+#endif
         _cb->unmarshaled(obj, _target, _closure);
     }
     else
@@ -2875,6 +2889,7 @@ IceRuby::ExceptionReader::ExceptionReader(const ExceptionInfoPtr& info) :
 IceRuby::ExceptionReader::~ExceptionReader()
     throw()
 {
+    rb_gc_unregister_address(&_ex);
 }
 
 string
@@ -2910,6 +2925,7 @@ IceRuby::ExceptionReader::_read(Ice::InputStream* is)
     is->startException();
 
     const_cast<VALUE&>(_ex) = _info->unmarshal(is);
+    rb_gc_register_address(&_ex);
 
     const_cast<Ice::SlicedDataPtr&>(_slicedData) = is->endException(_info->preserve);
 }
@@ -3174,17 +3190,17 @@ IceRuby_stringify(VALUE /*self*/, VALUE obj, VALUE type)
 
 extern "C"
 VALUE
-IceRuby_stringifyException(VALUE /*self*/, VALUE ex)
+IceRuby_stringifyException(VALUE /*self*/, VALUE exc)
 {
     ICE_RUBY_TRY
     {
-        volatile VALUE cls = CLASS_OF(ex);
+        volatile VALUE cls = CLASS_OF(exc);
         volatile VALUE type = callRuby(rb_const_get, cls, rb_intern("ICE_TYPE"));
         ExceptionInfoPtr info = getException(type);
 
         ostringstream ostr;
         IceUtilInternal::Output out(ostr);
-        info->print(ex, out);
+        info->print(exc, out);
 
         string str = ostr.str();
         return createString(str);

data/ext/Types.h

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #ifndef ICE_RUBY_TYPES_H
 #define ICE_RUBY_TYPES_H

data/ext/Util.cpp

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #include <Util.h>
 #include <Ice/LocalException.h>
@@ -22,22 +17,10 @@ using namespace IceRuby;
 namespace
 {
 
-#ifndef NDEBUG
-bool
-checkIsInstance(VALUE p, const char* type)
-{
-    volatile VALUE rbType = callRuby(rb_path2class, type);
-    assert(!NIL_P(rbType));
-    return callRuby(rb_obj_is_instance_of, p, rbType) == Qtrue;
-}
-#endif
-
 template<typename T>
 bool
-setVersion(VALUE p, const T& version, const char* type)
+setVersion(VALUE p, const T& version)
 {
-    assert(checkIsInstance(p, type));
-
     volatile VALUE major = callRuby(rb_int2inum, version.major);
     volatile VALUE minor = callRuby(rb_int2inum, version.minor);
     rb_ivar_set(p, rb_intern("@major"), major);
@@ -48,9 +31,8 @@ setVersion(VALUE p, const T& version, const char* type)
 
 template<typename T>
 bool
-getVersion(VALUE p, T& v, const char* type)
+getVersion(VALUE p, T& v)
 {
-    assert(checkIsInstance(p, type));
     volatile VALUE major = callRuby(rb_ivar_get, p, rb_intern("@major"));
     volatile VALUE minor = callRuby(rb_ivar_get, p, rb_intern("@minor"));
 
@@ -84,7 +66,7 @@ createVersion(const T& version, const char* type)
 
     volatile VALUE obj = callRuby(rb_class_new_instance, 0, static_cast<VALUE*>(0), rbType);
 
-    if(!setVersion<T>(obj, version, type))
+    if(!setVersion<T>(obj, version))
     {
         return Qnil;
     }
@@ -104,7 +86,7 @@ versionToString(VALUE p, const char* type)
     }
 
     T v;
-    if(!getVersion<T>(p, v, type))
+    if(!getVersion<T>(p, v))
     {
         return Qnil;
     }
@@ -399,6 +381,21 @@ IceRuby::stringSeqToArray(const vector<string>& seq)
     return result;
 }
 
+VALUE
+IceRuby::createNumSeq(const vector<Ice::Byte>& v)
+{
+    volatile VALUE result = createArray(v.size());
+    long i = 0;
+    if(v.size() > 0)
+    {
+        for(vector<Ice::Byte>::const_iterator p = v.begin(); p != v.end(); ++p, ++i)
+        {
+            RARRAY_ASET(result, i, INT2FIX(*p));
+        }
+    }
+    return result;
+}
+
 namespace
 {
 
@@ -451,7 +448,11 @@ IceRuby::contextToHash(const Ice::Context& ctx)
 
 extern "C"
 VALUE
-IceRuby_Util_hash_foreach_callback(VALUE val, VALUE arg)
+#ifdef RUBY_BLOCK_CALL_FUNC_TAKES_BLOCKARG // Defined Ruby >= 2.1
+IceRuby_Util_hash_foreach_callback(VALUE val, VALUE arg, int, const VALUE*, VALUE)
+#else
+IceRuby_Util_hash_foreach_callback(VALUE val, VALUE arg, int, VALUE*)
+#endif
 {
     VALUE key = rb_ary_entry(val, 0);
     VALUE value = rb_ary_entry(val, 1);
@@ -470,14 +471,22 @@ IceRuby_Util_hash_foreach_callback(VALUE val, VALUE arg)
 
 extern "C"
 {
-typedef VALUE (*ICE_RUBY_HASH_FOREACH_CALLBACK)(...);
+
+// Defined Ruby >= 2.1. Ruby 2.7 enables RB_BLOCK_CALL_FUNC_STRICT by default
+#ifdef RB_BLOCK_CALL_FUNC_STRICT
+    typedef rb_block_call_func_t ICE_RUBY_HASH_FOREACH_CALLBACK;
+#else
+    typedef VALUE (*ICE_RUBY_HASH_FOREACH_CALLBACK)(...);
+#endif
+
 }
 
 void
 IceRuby::hashIterate(VALUE h, HashIterator& iter)
 {
     assert(TYPE(h) == T_HASH);
-    callRuby(rb_iterate, rb_each, h,
+
+    callRuby(::rb_block_call, h, rb_intern("each"), 0, static_cast<VALUE*>(0),
              reinterpret_cast<ICE_RUBY_HASH_FOREACH_CALLBACK>(IceRuby_Util_hash_foreach_callback),
              reinterpret_cast<VALUE>(&iter));
 }
@@ -552,7 +561,7 @@ IceRuby::getEncodingVersion(VALUE p, Ice::EncodingVersion& v)
         throw RubyException(rb_eTypeError, "value is not an Ice::EncodingVersion");
     }
 
-    if(!getVersion<Ice::EncodingVersion>(p, v, Ice_EncodingVersion))
+    if(!getVersion<Ice::EncodingVersion>(p, v))
     {
         return false;
     }
@@ -638,6 +647,16 @@ setExceptionMembers(const Ice::LocalException& ex, VALUE p)
         volatile VALUE v = createString(e.str);
         callRuby(rb_iv_set, p, "@str", v);
     }
+    catch(const Ice::EndpointSelectionTypeParseException& e)
+    {
+        volatile VALUE v = createString(e.str);
+        callRuby(rb_iv_set, p, "@str", v);
+    }
+    catch(const Ice::VersionParseException& e)
+    {
+        volatile VALUE v = createString(e.str);
+        callRuby(rb_iv_set, p, "@str", v);
+    }
     catch(const Ice::IdentityParseException& e)
     {
         volatile VALUE v = createString(e.str);
@@ -653,6 +672,11 @@ setExceptionMembers(const Ice::LocalException& ex, VALUE p)
         volatile VALUE v = IceRuby::createIdentity(e.id);
         callRuby(rb_iv_set, p, "@id", v);
     }
+    catch(const Ice::IllegalServantException& e)
+    {
+        volatile VALUE v = createString(e.reason);
+        callRuby(rb_iv_set, p, "@reason", v);
+    }
     catch(const Ice::RequestFailedException& e)
     {
         volatile VALUE v;
@@ -683,6 +707,11 @@ setExceptionMembers(const Ice::LocalException& ex, VALUE p)
         v = createString(e.host);
         callRuby(rb_iv_set, p, "@host", v);
     }
+    catch(const Ice::BadMagicException& e)
+    {
+        volatile VALUE v = createNumSeq(e.badMagic);
+        callRuby(rb_iv_set, p, "@badMagic", v);
+    }
     catch(const Ice::UnsupportedProtocolException& e)
     {
         VALUE m;
@@ -722,6 +751,10 @@ setExceptionMembers(const Ice::LocalException& ex, VALUE p)
         volatile VALUE v = createString(e.reason);
         callRuby(rb_iv_set, p, "@reason", v);
     }
+    catch(const Ice::ConnectionManuallyClosedException& e)
+    {
+        callRuby(rb_iv_set, p, "@graceful", e.graceful ? Qtrue : Qfalse);
+    }
     catch(const Ice::FeatureNotSupportedException& e)
     {
         volatile VALUE v = createString(e.unsupportedFeature);
@@ -732,10 +765,6 @@ setExceptionMembers(const Ice::LocalException& ex, VALUE p)
         volatile VALUE v = createString(e.reason);
         callRuby(rb_iv_set, p, "@reason", v);
     }
-    catch(const Ice::ConnectionManuallyClosedException& e)
-    {
-        callRuby(rb_iv_set, p, "@graceful", e.graceful ? Qtrue : Qfalse);
-    }
     catch(const Ice::LocalException&)
     {
         //
@@ -745,7 +774,7 @@ setExceptionMembers(const Ice::LocalException& ex, VALUE p)
 }
 
 VALUE
-IceRuby::createArrayHelper(long sz)
+IceRuby::createArray(long sz)
 {
     volatile VALUE arr = callRuby(rb_ary_new2, sz);
     if(sz > 0)