zeroc-ice 3.7.0 → 3.7.5

data/ext/Operation.cpp

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2017 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 <Operation.h>
 #include <Proxy.h>
@@ -69,8 +64,8 @@ private:
     bool _returnsClasses;
     string _deprecateMessage;
 
-    void convertParams(VALUE, ParamInfoList&, int, bool&);
-    ParamInfoPtr convertParam(VALUE, int);
+    void convertParams(VALUE, ParamInfoList&, long, bool&);
+    ParamInfoPtr convertParam(VALUE, long);
     void prepareRequest(const Ice::ObjectPrx&, VALUE, Ice::OutputStream*, pair<const Ice::Byte*, const Ice::Byte*>&);
     VALUE unmarshalResults(const vector<Ice::Byte>&, const Ice::CommunicatorPtr&);
     VALUE unmarshalException(const vector<Ice::Byte>&, const Ice::CommunicatorPtr&);
@@ -372,7 +367,7 @@ IceRuby::OperationI::deprecate(const string& msg)
 }
 
 void
-IceRuby::OperationI::convertParams(VALUE v, ParamInfoList& params, int posOffset, bool& usesClasses)
+IceRuby::OperationI::convertParams(VALUE v, ParamInfoList& params, long posOffset, bool& usesClasses)
 {
     assert(TYPE(v) == T_ARRAY);
 
@@ -388,14 +383,14 @@ IceRuby::OperationI::convertParams(VALUE v, ParamInfoList& params, int posOffset
 }
 
 ParamInfoPtr
-IceRuby::OperationI::convertParam(VALUE v, int pos)
+IceRuby::OperationI::convertParam(VALUE v, long pos)
 {
     assert(TYPE(v) == T_ARRAY);
     ParamInfoPtr param = new ParamInfo;
     param->type = getType(RARRAY_AREF(v, 0));
     param->optional = static_cast<bool>(RTEST(RARRAY_AREF(v, 1)));
     param->tag = static_cast<int>(getInteger(RARRAY_AREF(v, 2)));
-    param->pos = pos;
+    param->pos = static_cast<int>(pos);
     return param;
 }
 

data/ext/Operation.h

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2017 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_OPERATION_H
 #define ICE_RUBY_OPERATION_H

data/ext/Properties.cpp

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2017 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 <Properties.h>
 #include <Util.h>
@@ -27,7 +22,7 @@ IceRuby_Properties_free(Ice::PropertiesPtr* p)
 
 extern "C"
 VALUE
-IceRuby_createProperties(int argc, VALUE* argv, VALUE self)
+IceRuby_createProperties(int argc, VALUE* argv, VALUE /*self*/)
 {
     ICE_RUBY_TRY
     {
@@ -141,7 +136,7 @@ IceRuby_Properties_getPropertyAsIntWithDefault(VALUE self, VALUE key, VALUE def)
     {
         Ice::PropertiesPtr p = getProperties(self);
         string k = getString(key);
-        Ice::Int d = getInteger(def);
+        Ice::Int d = static_cast<Ice::Int>(getInteger(def));
         Ice::Int v = p->getPropertyAsIntWithDefault(k, d);
         return INT2FIX(v);
     }

data/ext/Properties.h

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2017 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_PROPERTIES_H
 #define ICE_RUBY_PROPERTIES_H

data/ext/Proxy.cpp

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2017 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 <IceUtil/DisableWarnings.h>
 #include <Proxy.h>
@@ -13,6 +8,7 @@
 #include <Connection.h>
 #include <Endpoint.h>
 #include <Util.h>
+#include <Types.h>
 #include <Ice/LocalException.h>
 #include <Ice/Locator.h>
 #include <Ice/Proxy.h>
@@ -23,9 +19,7 @@ using namespace IceRuby;
 
 static VALUE _proxyClass;
 
-// **********************************************************************
 // ObjectPrx
-// **********************************************************************
 
 extern "C"
 void
@@ -159,7 +153,7 @@ IceRuby_ObjectPrx_ice_ids(int argc, VALUE* argv, VALUE self)
         checkArgs("ice_ids", 0, argc, argv, ctx);
 
         vector<string> ids = p->ice_ids(ctx);
-        volatile VALUE result = createArray(ids.size());
+        volatile VALUE result = createArray(static_cast<long>(ids.size()));
         long i = 0;
         for(vector<string>::iterator q = ids.begin(); q != ids.end(); ++q, ++i)
         {
@@ -313,7 +307,7 @@ IceRuby_ObjectPrx_ice_getEndpoints(VALUE self)
         Ice::ObjectPrx p = getProxy(self);
 
         Ice::EndpointSeq seq = p->ice_getEndpoints();
-        volatile VALUE result = createArray(seq.size());
+        volatile VALUE result = createArray(static_cast<long>(seq.size()));
         long i = 0;
         for(Ice::EndpointSeq::iterator q = seq.begin(); q != seq.end(); ++q, ++i)
         {
@@ -825,6 +819,27 @@ IceRuby_ObjectPrx_ice_compress(VALUE self, VALUE b)
     return Qnil;
 }
 
+extern "C"
+VALUE
+IceRuby_ObjectPrx_ice_getCompress(VALUE self)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::ObjectPrx p = getProxy(self);
+        IceUtil::Optional<bool> c = p->ice_getCompress();
+        if(c)
+        {
+            return *c ? Qtrue : Qfalse;
+        }
+        else
+        {
+            return Unset;
+        }
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
 extern "C"
 VALUE
 IceRuby_ObjectPrx_ice_timeout(VALUE self, VALUE t)
@@ -846,6 +861,27 @@ IceRuby_ObjectPrx_ice_timeout(VALUE self, VALUE t)
     return Qnil;
 }
 
+extern "C"
+VALUE
+IceRuby_ObjectPrx_ice_getTimeout(VALUE self)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::ObjectPrx p = getProxy(self);
+        IceUtil::Optional<int> t = p->ice_getTimeout();
+        if(t)
+        {
+            return INT2FIX(*t);
+        }
+        else
+        {
+            return Unset;
+        }
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
 extern "C"
 VALUE
 IceRuby_ObjectPrx_ice_connectionId(VALUE self, VALUE id)
@@ -860,6 +896,42 @@ IceRuby_ObjectPrx_ice_connectionId(VALUE self, VALUE id)
     return Qnil;
 }
 
+extern "C"
+VALUE
+IceRuby_ObjectPrx_ice_fixed(VALUE self, VALUE con)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::ObjectPrx p = getProxy(self);
+
+        Ice::ConnectionPtr connection;
+        if(!NIL_P(con))
+        {
+            if(!checkConnection(con))
+            {
+                throw RubyException(rb_eTypeError, "argument must be an Ice.Connection");
+            }
+            connection = getConnection(con);
+        }
+        return createProxy(p->ice_fixed(connection), rb_class_of(self));
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
+extern "C"
+VALUE
+IceRuby_ObjectPrx_ice_isFixed(VALUE self)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::ObjectPrx p = getProxy(self);
+        return p->ice_isFixed() ? Qtrue : Qfalse;
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
 extern "C"
 VALUE
 IceRuby_ObjectPrx_ice_getConnection(VALUE self)
@@ -991,7 +1063,7 @@ checkedCastImpl(const Ice::ObjectPrx& p, const string& id, VALUE facet, VALUE ct
 
 extern "C"
 VALUE
-IceRuby_ObjectPrx_checkedCast(int argc, VALUE* args, VALUE self)
+IceRuby_ObjectPrx_checkedCast(int argc, VALUE* args, VALUE /*self*/)
 {
     //
     // ice_checkedCast is called from generated code, therefore we always expect
@@ -1057,7 +1129,7 @@ IceRuby_ObjectPrx_checkedCast(int argc, VALUE* args, VALUE self)
 
 extern "C"
 VALUE
-IceRuby_ObjectPrx_uncheckedCast(int argc, VALUE* args, VALUE self)
+IceRuby_ObjectPrx_uncheckedCast(int argc, VALUE* args, VALUE /*self*/)
 {
     ICE_RUBY_TRY
     {
@@ -1183,7 +1255,7 @@ IceRuby_ObjectPrx_ice_uncheckedCast(VALUE self, VALUE obj, VALUE facet)
 
 extern "C"
 VALUE
-IceRuby_ObjectPrx_ice_staticId(VALUE self)
+IceRuby_ObjectPrx_ice_staticId(VALUE /*self*/)
 {
     ICE_RUBY_TRY
     {
@@ -1195,7 +1267,7 @@ IceRuby_ObjectPrx_ice_staticId(VALUE self)
 
 extern "C"
 VALUE
-IceRuby_ObjectPrx_new(int /*argc*/, VALUE* /*args*/, VALUE self)
+IceRuby_ObjectPrx_new(int /*argc*/, VALUE* /*args*/, VALUE /*self*/)
 {
     ICE_RUBY_TRY
     {
@@ -1265,8 +1337,12 @@ IceRuby::initProxy(VALUE iceModule)
     rb_define_method(_proxyClass, "ice_batchDatagram", CAST_METHOD(IceRuby_ObjectPrx_ice_batchDatagram), 0);
     rb_define_method(_proxyClass, "ice_isBatchDatagram", CAST_METHOD(IceRuby_ObjectPrx_ice_isBatchDatagram), 0);
     rb_define_method(_proxyClass, "ice_compress", CAST_METHOD(IceRuby_ObjectPrx_ice_compress), 1);
+    rb_define_method(_proxyClass, "ice_getCompress", CAST_METHOD(IceRuby_ObjectPrx_ice_getCompress), 0);
     rb_define_method(_proxyClass, "ice_timeout", CAST_METHOD(IceRuby_ObjectPrx_ice_timeout), 1);
+    rb_define_method(_proxyClass, "ice_getTimeout", CAST_METHOD(IceRuby_ObjectPrx_ice_getTimeout), 0);
     rb_define_method(_proxyClass, "ice_connectionId", CAST_METHOD(IceRuby_ObjectPrx_ice_connectionId), 1);
+    rb_define_method(_proxyClass, "ice_fixed", CAST_METHOD(IceRuby_ObjectPrx_ice_fixed), 1);
+    rb_define_method(_proxyClass, "ice_isFixed", CAST_METHOD(IceRuby_ObjectPrx_ice_isFixed), 0);
     rb_define_method(_proxyClass, "ice_getConnection", CAST_METHOD(IceRuby_ObjectPrx_ice_getConnection), 0);
     rb_define_method(_proxyClass, "ice_getCachedConnection", CAST_METHOD(IceRuby_ObjectPrx_ice_getCachedConnection), 0);
     rb_define_method(_proxyClass, "ice_flushBatchRequests", CAST_METHOD(IceRuby_ObjectPrx_ice_flushBatchRequests), 0);

data/ext/Proxy.h

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2017 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-2017 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-2017 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-2017 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);
@@ -618,7 +614,11 @@ IceRuby::PrimitiveInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap*, bool
     case PrimitiveInfo::KindString:
     {
         string val = getString(p);
-        os->write(val);
+#ifdef HAVE_RUBY_ENCODING_H
+        os->write(val, false); // Bypass string conversion.
+#else
+        os->write(val, true);
+#endif
         break;
     }
     }
@@ -683,7 +683,11 @@ IceRuby::PrimitiveInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallbackP
     case PrimitiveInfo::KindString:
     {
         string str;
-        is->read(str);
+#ifdef HAVE_RUBY_ENCODING_H
+        is->read(str, false); // Bypass string conversion.
+#else
+        is->read(str, true);
+#endif
         val = createString(str);
         break;
     }
@@ -880,7 +884,7 @@ convertDataMembers(VALUE members, DataMemberList& reqMembers, DataMemberList& op
     {
         volatile VALUE m = callRuby(rb_check_array_type, RARRAY_AREF(arr, i));
         assert(!NIL_P(m));
-        assert(RARRAY_LEN(m) == allowOptional ? 4 : 2);
+        assert(RARRAY_LEN(m) == (allowOptional ? 4 : 2));
 
         DataMemberPtr member = new DataMember;
 
@@ -1009,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)
@@ -1149,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
@@ -1184,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())
@@ -1392,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;
@@ -1418,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));
@@ -1426,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));
@@ -1443,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));
@@ -1459,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));
@@ -1487,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));
@@ -1504,20 +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.
+#else
+            os->write(&seq[0], &seq[0] + seq.size(), true);
+#endif
         }
-        os->write(&seq[0], &seq[0] + seq.size());
         break;
     }
     }
@@ -1643,16 +1658,17 @@ IceRuby::SequenceInfo::unmarshalPrimitiveSequence(const PrimitiveInfoPtr& pi, Ic
     case PrimitiveInfo::KindString:
     {
         Ice::StringSeq seq;
+#ifdef HAVE_RUBY_ENCODING_H
+        is->read(seq, false); // Bypass string conversion.
+#else
         is->read(seq, true);
+#endif
         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;
     }
@@ -1689,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
@@ -1751,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;
@@ -1837,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.
@@ -2345,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();
@@ -2728,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
@@ -2859,6 +2889,7 @@ IceRuby::ExceptionReader::ExceptionReader(const ExceptionInfoPtr& info) :
 IceRuby::ExceptionReader::~ExceptionReader()
     throw()
 {
+    rb_gc_unregister_address(&_ex);
 }
 
 string
@@ -2894,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);
 }
@@ -3158,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);