zeroc-ice 3.6.5 → 3.7.4

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
     {
@@ -187,22 +182,12 @@ IceRuby_compile(int argc, VALUE* argv, VALUE self)
         }
         catch(const std::exception& ex)
         {
-            getErrorStream() << argSeq[0] << ": error:" << ex.what() << endl;
-            rc = EXIT_FAILURE;
-        }
-        catch(const std::string& msg)
-        {
-            getErrorStream() << argSeq[0] << ": error:" << msg << endl;
-            rc = EXIT_FAILURE;
-        }
-        catch(const char* msg)
-        {
-            getErrorStream() << argSeq[0] << ": error:" << msg << endl;
+            cerr << argSeq[0] << ": error:" << ex.what() << endl;
             rc = EXIT_FAILURE;
         }
         catch(...)
         {
-            getErrorStream() << argSeq[0] << ": error:" << "unknown exception" << endl;
+            cerr << argSeq[0] << ": error:" << "unknown exception" << endl;
             rc = EXIT_FAILURE;
         }
         return INT2FIX(rc);

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>
@@ -13,7 +8,9 @@
 #include <IceUtil/InputUtil.h>
 #include <IceUtil/OutputUtil.h>
 #include <IceUtil/ScopedArray.h>
+#include <Ice/InputStream.h>
 #include <Ice/LocalException.h>
+#include <Ice/OutputStream.h>
 #include <Ice/SlicedData.h>
 #include <list>
 #include <limits>
@@ -63,22 +60,6 @@ public:
 };
 static InfoMapDestroyer infoMapDestroyer;
 
-class ReadObjectCallback : public Ice::ReadObjectCallback
-{
-public:
-
-    ReadObjectCallback(const ClassInfoPtr&, const UnmarshalCallbackPtr&, VALUE, void*);
-
-    virtual void invoke(const Ice::ObjectPtr&);
-
-private:
-
-    ClassInfoPtr _info;
-    UnmarshalCallbackPtr _cb;
-    VALUE _target;
-    void* _closure;
-};
-
 string
 escapeString(const string& str)
 {
@@ -94,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;
@@ -184,16 +165,16 @@ addExceptionInfo(const string& id, const ExceptionInfoPtr& info)
 }
 
 //
-// SlicedDataUtil implementation
+// StreamUtil implementation
 //
-VALUE IceRuby::SlicedDataUtil::_slicedDataType = Qnil;
-VALUE IceRuby::SlicedDataUtil::_sliceInfoType = Qnil;
+VALUE IceRuby::StreamUtil::_slicedDataType = Qnil;
+VALUE IceRuby::StreamUtil::_sliceInfoType = Qnil;
 
-IceRuby::SlicedDataUtil::SlicedDataUtil()
+IceRuby::StreamUtil::StreamUtil()
 {
 }
 
-IceRuby::SlicedDataUtil::~SlicedDataUtil()
+IceRuby::StreamUtil::~StreamUtil()
 {
     //
     // Make sure we break any cycles among the ObjectReaders in preserved slices.
@@ -204,35 +185,41 @@ IceRuby::SlicedDataUtil::~SlicedDataUtil()
         for(Ice::SliceInfoSeq::const_iterator q = slicedData->slices.begin(); q != slicedData->slices.end(); ++q)
         {
             //
-            // Don't just call (*q)->objects.clear(), as releasing references
-            // to the objects could have unexpected side effects. We exchange
+            // Don't just call (*q)->instances.clear(), as releasing references
+            // to the instances could have unexpected side effects. We exchange
             // the vector into a temporary and then let the temporary fall out
             // of scope.
             //
             vector<Ice::ObjectPtr> tmp;
-            tmp.swap((*q)->objects);
+            tmp.swap((*q)->instances);
         }
     }
 }
 
 void
-IceRuby::SlicedDataUtil::add(const ObjectReaderPtr& reader)
+IceRuby::StreamUtil::add(const ReadObjectCallbackPtr& callback)
+{
+    _callbacks.push_back(callback);
+}
+
+void
+IceRuby::StreamUtil::add(const ObjectReaderPtr& reader)
 {
     assert(reader->getSlicedData());
     _readers.insert(reader);
 }
 
 void
-IceRuby::SlicedDataUtil::update()
+IceRuby::StreamUtil::updateSlicedData()
 {
     for(set<ObjectReaderPtr>::iterator p = _readers.begin(); p != _readers.end(); ++p)
     {
-        setMember((*p)->getObject(), (*p)->getSlicedData());
+        setSlicedDataMember((*p)->getObject(), (*p)->getSlicedData());
     }
 }
 
 void
-IceRuby::SlicedDataUtil::setMember(VALUE obj, const Ice::SlicedDataPtr& slicedData)
+IceRuby::StreamUtil::setSlicedDataMember(VALUE obj, const Ice::SlicedDataPtr& slicedData)
 {
     //
     // Create a Ruby equivalent of the SlicedData object.
@@ -253,8 +240,7 @@ IceRuby::SlicedDataUtil::setMember(VALUE obj, const Ice::SlicedDataPtr& slicedDa
 
     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);
 
@@ -284,27 +270,29 @@ IceRuby::SlicedDataUtil::setMember(VALUE obj, const Ice::SlicedDataPtr& slicedDa
         //
         // 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);
 
         //
-        // objects
+        // instances
         //
-        volatile VALUE objects = createArray((*p)->objects.size());
-        callRuby(rb_iv_set, slice, "@objects", objects);
+        volatile VALUE instances = createArray(static_cast<long>((*p)->instances.size()));
+        callRuby(rb_iv_set, slice, "@instances", instances);
 
         int j = 0;
-        for(vector<Ice::ObjectPtr>::iterator q = (*p)->objects.begin(); q != (*p)->objects.end(); ++q)
+        for(vector<Ice::ObjectPtr>::iterator q = (*p)->instances.begin(); q != (*p)->instances.end(); ++q)
         {
             //
-            // Each element in the objects list is an instance of ObjectReader that wraps a Ruby object.
+            // Each element in the instances list is an instance of ObjectReader that wraps a Ruby object.
             //
             assert(*q);
             ObjectReaderPtr r = ObjectReaderPtr::dynamicCast(*q);
             assert(r);
             VALUE o = r->getObject();
             assert(o != Qnil); // Should be non-nil.
-            RARRAY_ASET(objects, j, o);
+            RARRAY_ASET(instances, j, o);
             j++;
         }
 
@@ -327,7 +315,7 @@ IceRuby::SlicedDataUtil::setMember(VALUE obj, const Ice::SlicedDataPtr& slicedDa
 // named _ice_slicedData which is an instance of the Ruby class Ice::SlicedData.
 //
 Ice::SlicedDataPtr
-IceRuby::SlicedDataUtil::getMember(VALUE obj, ObjectMap* objectMap)
+IceRuby::StreamUtil::getSlicedDataMember(VALUE obj, ObjectMap* objectMap)
 {
     Ice::SlicedDataPtr slicedData;
 
@@ -369,27 +357,27 @@ IceRuby::SlicedDataUtil::getMember(VALUE obj, ObjectMap* objectMap)
                     info->bytes.swap(vtmp);
                 }
 
-                volatile VALUE objects = callRuby(rb_iv_get, s, "@objects");
-                assert(TYPE(objects) == T_ARRAY);
-                long osz = RARRAY_LEN(objects);
+                volatile VALUE instances = callRuby(rb_iv_get, s, "@instances");
+                assert(TYPE(instances) == T_ARRAY);
+                long osz = RARRAY_LEN(instances);
                 for(long j = 0; j < osz; ++j)
                 {
-                    VALUE o = RARRAY_AREF(objects, j);
+                    VALUE o = RARRAY_AREF(instances, j);
 
                     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);
+                        writer = new ObjectWriter(o, objectMap, 0);
                         objectMap->insert(ObjectMap::value_type(o, writer));
                     }
                     else
                     {
-                        writer = i->second;
+                        writer = k->second;
                     }
 
-                    info->objects.push_back(writer);
+                    info->instances.push_back(writer);
                 }
 
                 volatile VALUE hasOptionalMembers = callRuby(rb_iv_get, s, "@hasOptionalMembers");
@@ -546,7 +534,7 @@ IceRuby::PrimitiveInfo::optionalFormat() const
 }
 
 void
-IceRuby::PrimitiveInfo::marshal(VALUE p, const Ice::OutputStreamPtr& os, ObjectMap*, bool)
+IceRuby::PrimitiveInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap*, bool)
 {
     switch(kind)
     {
@@ -603,8 +591,8 @@ IceRuby::PrimitiveInfo::marshal(VALUE p, const Ice::OutputStreamPtr& os, ObjectM
 #if defined(_MSC_VER) && (_MSC_VER <= 1700)
             _finite(val) &&
 #else
-            isfinite(d) && 
-#endif            
+            isfinite(d) &&
+#endif
             (d > numeric_limits<float>::max() || d < -numeric_limits<float>::max()))
         {
             throw RubyException(rb_eTypeError, "value is out of range for a float");
@@ -626,14 +614,18 @@ IceRuby::PrimitiveInfo::marshal(VALUE p, const Ice::OutputStreamPtr& os, ObjectM
     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;
     }
     }
 }
 
 void
-IceRuby::PrimitiveInfo::unmarshal(const Ice::InputStreamPtr& is, const UnmarshalCallbackPtr& cb, VALUE target,
+IceRuby::PrimitiveInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallbackPtr& cb, VALUE target,
                                   void* closure, bool)
 {
     volatile VALUE val = Qnil;
@@ -691,7 +683,11 @@ IceRuby::PrimitiveInfo::unmarshal(const Ice::InputStreamPtr& is, const Unmarshal
     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;
     }
@@ -822,7 +818,7 @@ IceRuby::EnumInfo::optionalFormat() const
 }
 
 void
-IceRuby::EnumInfo::marshal(VALUE p, const Ice::OutputStreamPtr& os, ObjectMap*, bool)
+IceRuby::EnumInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap*, bool)
 {
     assert(callRuby(rb_obj_is_instance_of, p, rubyClass) == Qtrue); // validate() should have caught this.
 
@@ -840,7 +836,7 @@ IceRuby::EnumInfo::marshal(VALUE p, const Ice::OutputStreamPtr& os, ObjectMap*,
 }
 
 void
-IceRuby::EnumInfo::unmarshal(const Ice::InputStreamPtr& is, const UnmarshalCallbackPtr& cb, VALUE target, void* closure,
+IceRuby::EnumInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallbackPtr& cb, VALUE target, void* closure,
                              bool)
 {
     Ice::Int val = is->readEnum(maxValue);
@@ -1003,7 +999,7 @@ IceRuby::StructInfo::usesClasses() const
 }
 
 void
-IceRuby::StructInfo::marshal(VALUE p, const Ice::OutputStreamPtr& os, ObjectMap* objectMap, bool optional)
+IceRuby::StructInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap* objectMap, bool optional)
 {
     assert(NIL_P(p) || callRuby(rb_obj_is_kind_of, p, rubyClass) == Qtrue); // validate() should have caught this.
 
@@ -1017,7 +1013,7 @@ IceRuby::StructInfo::marshal(VALUE p, const Ice::OutputStreamPtr& os, ObjectMap*
         p = _nullMarshalValue;
     }
 
-    Ice::OutputStream::size_type sizePos = -1;
+    Ice::OutputStream::size_type sizePos = 0;
     if(optional)
     {
         if(_variableLength)
@@ -1049,7 +1045,7 @@ IceRuby::StructInfo::marshal(VALUE p, const Ice::OutputStreamPtr& os, ObjectMap*
 }
 
 void
-IceRuby::StructInfo::unmarshal(const Ice::InputStreamPtr& is, const UnmarshalCallbackPtr& cb, VALUE target,
+IceRuby::StructInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallbackPtr& cb, VALUE target,
                                void* closure, bool optional)
 {
     volatile VALUE obj = callRuby(rb_class_new_instance, 0, static_cast<VALUE*>(0), rubyClass);
@@ -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
@@ -1186,13 +1182,13 @@ IceRuby::SequenceInfo::usesClasses() const
 }
 
 void
-IceRuby::SequenceInfo::marshal(VALUE p, const Ice::OutputStreamPtr& os, ObjectMap* objectMap, bool optional)
+IceRuby::SequenceInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap* objectMap, bool optional)
 {
     PrimitiveInfoPtr pi = PrimitiveInfoPtr::dynamicCast(elementType);
 
     volatile VALUE arr = Qnil;
 
-    Ice::OutputStream::size_type sizePos = -1;
+    Ice::OutputStream::size_type sizePos = 0;
     if(optional)
     {
         if(elementType->variableLength())
@@ -1264,7 +1260,7 @@ IceRuby::SequenceInfo::marshal(VALUE p, const Ice::OutputStreamPtr& os, ObjectMa
 }
 
 void
-IceRuby::SequenceInfo::unmarshal(const Ice::InputStreamPtr& is, const UnmarshalCallbackPtr& cb, VALUE target,
+IceRuby::SequenceInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallbackPtr& cb, VALUE target,
                                  void* closure, bool optional)
 {
     if(optional)
@@ -1363,7 +1359,7 @@ IceRuby::SequenceInfo::destroy()
 }
 
 void
-IceRuby::SequenceInfo::marshalPrimitiveSequence(const PrimitiveInfoPtr& pi, VALUE p, const Ice::OutputStreamPtr& os)
+IceRuby::SequenceInfo::marshalPrimitiveSequence(const PrimitiveInfoPtr& pi, VALUE p, Ice::OutputStream* os)
 {
     volatile VALUE arr = Qnil;
     volatile VALUE str = Qnil;
@@ -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,27 +1508,38 @@ 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, true);
         break;
     }
     }
 }
 
 void
-IceRuby::SequenceInfo::unmarshalPrimitiveSequence(const PrimitiveInfoPtr& pi, const Ice::InputStreamPtr& is,
+IceRuby::SequenceInfo::unmarshalPrimitiveSequence(const PrimitiveInfoPtr& pi, Ice::InputStream* is,
                                                   const UnmarshalCallbackPtr& cb, VALUE target, void* closure)
 {
     volatile VALUE result = Qnil;
@@ -1651,16 +1658,17 @@ IceRuby::SequenceInfo::unmarshalPrimitiveSequence(const PrimitiveInfoPtr& pi, co
     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;
     }
@@ -1697,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
@@ -1729,7 +1737,7 @@ namespace
 {
 struct DictionaryMarshalIterator : public IceRuby::HashIterator
 {
-    DictionaryMarshalIterator(const IceRuby::DictionaryInfoPtr& d, const Ice::OutputStreamPtr o, IceRuby::ObjectMap* m)
+    DictionaryMarshalIterator(const IceRuby::DictionaryInfoPtr& d, Ice::OutputStream* o, IceRuby::ObjectMap* m)
         : dict(d), os(o), objectMap(m)
     {
     }
@@ -1740,13 +1748,13 @@ struct DictionaryMarshalIterator : public IceRuby::HashIterator
     }
 
     IceRuby::DictionaryInfoPtr dict;
-    Ice::OutputStreamPtr os;
+    Ice::OutputStream* os;
     IceRuby::ObjectMap* objectMap;
 };
 }
 
 void
-IceRuby::DictionaryInfo::marshal(VALUE p, const Ice::OutputStreamPtr& os, ObjectMap* objectMap, bool optional)
+IceRuby::DictionaryInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap* objectMap, bool optional)
 {
     volatile VALUE hash = Qnil;
 
@@ -1759,10 +1767,10 @@ IceRuby::DictionaryInfo::marshal(VALUE p, const Ice::OutputStreamPtr& os, Object
         }
     }
 
-    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;
@@ -1799,7 +1807,7 @@ IceRuby::DictionaryInfo::marshal(VALUE p, const Ice::OutputStreamPtr& os, Object
 }
 
 void
-IceRuby::DictionaryInfo::marshalElement(VALUE key, VALUE value, const Ice::OutputStreamPtr& os, ObjectMap* objectMap)
+IceRuby::DictionaryInfo::marshalElement(VALUE key, VALUE value, Ice::OutputStream* os, ObjectMap* objectMap)
 {
     if(!keyType->validate(key))
     {
@@ -1816,7 +1824,7 @@ IceRuby::DictionaryInfo::marshalElement(VALUE key, VALUE value, const Ice::Outpu
 }
 
 void
-IceRuby::DictionaryInfo::unmarshal(const Ice::InputStreamPtr& is, const UnmarshalCallbackPtr& cb, VALUE target,
+IceRuby::DictionaryInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallbackPtr& cb, VALUE target,
                                    void* closure, bool optional)
 {
     if(optional)
@@ -1952,7 +1960,7 @@ IceRuby::DictionaryInfo::destroy()
 // ClassInfo implementation.
 //
 IceRuby::ClassInfo::ClassInfo(VALUE ident, bool loc) :
-    compactId(-1), isBase(false), isLocal(loc), isAbstract(false), preserve(false), rubyClass(Qnil), typeObj(Qnil),
+    compactId(-1), isBase(false), isLocal(loc), preserve(false), interface(false), rubyClass(Qnil), typeObj(Qnil),
     defined(false)
 {
     const_cast<string&>(id) = getString(ident);
@@ -1968,7 +1976,7 @@ IceRuby::ClassInfo::ClassInfo(VALUE ident, bool loc) :
 }
 
 void
-IceRuby::ClassInfo::define(VALUE t, VALUE compact, VALUE abstr, VALUE pres, VALUE b, VALUE i, VALUE m)
+IceRuby::ClassInfo::define(VALUE t, VALUE compact, VALUE pres, VALUE intf, VALUE b, VALUE m)
 {
     if(!NIL_P(b))
     {
@@ -1977,23 +1985,9 @@ IceRuby::ClassInfo::define(VALUE t, VALUE compact, VALUE abstr, VALUE pres, VALU
     }
 
     const_cast<Ice::Int&>(compactId) = static_cast<Ice::Int>(getInteger(compact));
-    const_cast<bool&>(isAbstract) = RTEST(abstr);
     const_cast<bool&>(preserve) = RTEST(pres);
-
-    long n;
-    volatile VALUE arr;
-
-    arr = callRuby(rb_check_array_type, i);
-    assert(!NIL_P(arr));
-    for(n = 0; n < RARRAY_LEN(arr); ++n)
-    {
-        ClassInfoPtr iface = ClassInfoPtr::dynamicCast(getType(RARRAY_AREF(arr, n)));
-        assert(iface);
-        const_cast<ClassInfoList&>(interfaces).push_back(iface);
-    }
-
+    const_cast<bool&>(interface) = RTEST(intf);
     convertDataMembers(m, const_cast<DataMemberList&>(members), const_cast<DataMemberList&>(optionalMembers), true);
-
     const_cast<VALUE&>(rubyClass) = t;
     const_cast<bool&>(defined) = true;
 }
@@ -2042,7 +2036,7 @@ IceRuby::ClassInfo::validate(VALUE val)
     assert(!NIL_P(type));
     ClassInfoPtr info = ClassInfoPtr::dynamicCast(getType(type));
     assert(info);
-    return info->isA(this);
+    return this->interface || info->isA(this);
 }
 
 bool
@@ -2070,7 +2064,7 @@ IceRuby::ClassInfo::usesClasses() const
 }
 
 void
-IceRuby::ClassInfo::marshal(VALUE p, const Ice::OutputStreamPtr& os, ObjectMap* objectMap, bool)
+IceRuby::ClassInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap* objectMap, bool)
 {
     if(!defined)
     {
@@ -2079,7 +2073,8 @@ IceRuby::ClassInfo::marshal(VALUE p, const Ice::OutputStreamPtr& os, ObjectMap*
 
     if(NIL_P(p))
     {
-        os->writeObject(0);
+        Ice::ObjectPtr nil;
+        os->write(nil);
         return;
     }
 
@@ -2094,7 +2089,7 @@ IceRuby::ClassInfo::marshal(VALUE p, const Ice::OutputStreamPtr& os, ObjectMap*
     ObjectMap::iterator q = objectMap->find(p);
     if(q == objectMap->end())
     {
-        writer = new ObjectWriter(p, objectMap);
+        writer = new ObjectWriter(p, objectMap, this);
         objectMap->insert(ObjectMap::value_type(p, writer));
     }
     else
@@ -2105,19 +2100,40 @@ IceRuby::ClassInfo::marshal(VALUE p, const Ice::OutputStreamPtr& os, ObjectMap*
     //
     // Give the writer to the stream. The stream will eventually call write() on it.
     //
-    os->writeObject(writer);
+    os->write(writer);
+}
+
+namespace
+{
+
+void
+patchObject(void* addr, const Ice::ObjectPtr& v)
+{
+    ReadObjectCallback* cb = static_cast<ReadObjectCallback*>(addr);
+    assert(cb);
+    cb->invoke(v);
+}
+
 }
 
 void
-IceRuby::ClassInfo::unmarshal(const Ice::InputStreamPtr& is, const UnmarshalCallbackPtr& cb, VALUE target,
-                              void* closure, bool)
+IceRuby::ClassInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallbackPtr& cb, VALUE target, void* closure, bool)
 {
     if(!defined)
     {
         throw RubyException(rb_eRuntimeError, "class %s is declared but not defined", id.c_str());
     }
 
-    is->readObject(new ReadObjectCallback(this, cb, target, closure));
+    //
+    // This callback is notified when the Slice value is actually read. The StreamUtil object
+    // attached to the stream keeps a reference to the callback object to ensure it lives
+    // long enough.
+    //
+    ReadObjectCallbackPtr rocb = new ReadObjectCallback(this, cb, target, closure);
+    StreamUtil* util = reinterpret_cast<StreamUtil*>(is->getClosure());
+    assert(util);
+    util->add(rocb);
+    is->read(patchObject, rocb.get());
 }
 
 void
@@ -2190,7 +2206,6 @@ void
 IceRuby::ClassInfo::destroy()
 {
     const_cast<ClassInfoPtr&>(base) = 0;
-    const_cast<ClassInfoList&>(interfaces).clear();
     if(!members.empty())
     {
         DataMemberList ml = members;
@@ -2264,40 +2279,40 @@ IceRuby::ClassInfo::isA(const ClassInfoPtr& info)
     {
         return true;
     }
-    else if(base && base->isA(info))
-    {
-        return true;
-    }
-    else if(!interfaces.empty())
-    {
-        for(ClassInfoList::const_iterator p = interfaces.begin(); p != interfaces.end(); ++p)
-        {
-            if((*p)->isA(info))
-            {
-                return true;
-            }
-        }
-    }
 
-    return false;
+    return base && base->isA(info);
 }
 
 //
 // ProxyInfo implementation.
 //
 IceRuby::ProxyInfo::ProxyInfo(VALUE ident) :
-    rubyClass(Qnil), typeObj(Qnil)
+    isBase(false), rubyClass(Qnil), typeObj(Qnil)
 {
     const_cast<string&>(id) = getString(ident);
+    const_cast<bool&>(isBase) = id == "::Ice::Object";
     const_cast<VALUE&>(typeObj) = createType(this);
 }
 
 void
-IceRuby::ProxyInfo::define(VALUE t, VALUE i)
+IceRuby::ProxyInfo::define(VALUE t, VALUE b, VALUE i)
 {
+    if(!NIL_P(b))
+    {
+        const_cast<ProxyInfoPtr&>(base) = ProxyInfoPtr::dynamicCast(getType(b));
+        assert(base);
+    }
+
+    volatile VALUE arr = callRuby(rb_check_array_type, i);
+    assert(!NIL_P(arr));
+    for(int n = 0; n < RARRAY_LEN(arr); ++n)
+    {
+        ProxyInfoPtr iface = ProxyInfoPtr::dynamicCast(getType(RARRAY_AREF(arr, n)));
+        assert(iface);
+        const_cast<ProxyInfoList&>(interfaces).push_back(iface);
+    }
+
     const_cast<VALUE&>(rubyClass) = t;
-    const_cast<ClassInfoPtr&>(classInfo) = ClassInfoPtr::dynamicCast(getType(i));
-    assert(classInfo);
 }
 
 string
@@ -2320,7 +2335,7 @@ IceRuby::ProxyInfo::validate(VALUE val)
         assert(!NIL_P(type));
         ProxyInfoPtr info = ProxyInfoPtr::dynamicCast(getType(type));
         assert(info);
-        return info->classInfo->isA(classInfo);
+        return info->isA(this);
     }
     return true;
 }
@@ -2344,9 +2359,9 @@ IceRuby::ProxyInfo::optionalFormat() const
 }
 
 void
-IceRuby::ProxyInfo::marshal(VALUE p, const Ice::OutputStreamPtr& os, ObjectMap*, bool optional)
+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();
@@ -2369,7 +2384,7 @@ IceRuby::ProxyInfo::marshal(VALUE p, const Ice::OutputStreamPtr& os, ObjectMap*,
 }
 
 void
-IceRuby::ProxyInfo::unmarshal(const Ice::InputStreamPtr& is, const UnmarshalCallbackPtr& cb, VALUE target,
+IceRuby::ProxyInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallbackPtr& cb, VALUE target,
                               void* closure, bool optional)
 {
     if(optional)
@@ -2414,28 +2429,63 @@ IceRuby::ProxyInfo::print(VALUE value, IceUtilInternal::Output& out, PrintObject
     }
 }
 
+bool
+IceRuby::ProxyInfo::isA(const ProxyInfoPtr& info)
+{
+    //
+    // Return true if this class has an is-a relationship with info.
+    //
+    if(info->isBase)
+    {
+        return true;
+    }
+    else if(this == info.get())
+    {
+        return true;
+    }
+    else if(base && base->isA(info))
+    {
+        return true;
+    }
+    else if(!interfaces.empty())
+    {
+        for(ProxyInfoList::const_iterator p = interfaces.begin(); p != interfaces.end(); ++p)
+        {
+            if((*p)->isA(info))
+            {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
 void
 IceRuby::ProxyInfo::destroy()
 {
-    const_cast<ClassInfoPtr&>(classInfo) = 0;
+    const_cast<ProxyInfoPtr&>(base) = 0;
+    const_cast<ProxyInfoList&>(interfaces).clear();
 }
 
 //
 // ObjectWriter implementation.
 //
-IceRuby::ObjectWriter::ObjectWriter(VALUE object, ObjectMap* objectMap) :
-    _object(object), _map(objectMap)
+IceRuby::ObjectWriter::ObjectWriter(VALUE object, ObjectMap* objectMap, const ClassInfoPtr& formal) :
+    _object(object), _map(objectMap), _formal(formal)
 {
     //
     // Mark the object as in use for the lifetime of this wrapper.
     //
     rb_gc_register_address(&_object);
-
-    volatile VALUE cls = CLASS_OF(object);
-    volatile VALUE type = callRuby(rb_const_get, cls, rb_intern("ICE_TYPE"));
-    assert(!NIL_P(type));
-    _info = ClassInfoPtr::dynamicCast(getType(type));
-    assert(_info);
+    if(!_formal || !_formal->interface)
+    {
+        volatile VALUE cls = CLASS_OF(object);
+        volatile VALUE type = callRuby(rb_const_get, cls, rb_intern("ICE_TYPE"));
+        assert(!NIL_P(type));
+        _info = ClassInfoPtr::dynamicCast(getType(type));
+        assert(_info);
+    }
 }
 
 IceRuby::ObjectWriter::~ObjectWriter()
@@ -2454,41 +2504,55 @@ IceRuby::ObjectWriter::ice_preMarshal()
 }
 
 void
-IceRuby::ObjectWriter::write(const Ice::OutputStreamPtr& os) const
+IceRuby::ObjectWriter::_iceWrite(Ice::OutputStream* os) const
 {
     Ice::SlicedDataPtr slicedData;
 
-    if(_info->preserve)
+    if(_info && _info->preserve)
     {
         //
         // Retrieve the SlicedData object that we stored as a hidden member of the Ruby object.
         //
-        slicedData = SlicedDataUtil::getMember(_object, const_cast<ObjectMap*>(_map));
+        slicedData = StreamUtil::getSlicedDataMember(_object, const_cast<ObjectMap*>(_map));
     }
 
-    os->startObject(slicedData);
-
-    if(_info->id != "::Ice::UnknownSlicedObject")
+    os->startValue(slicedData);
+    if(_formal && _formal->interface)
     {
-        ClassInfoPtr info = _info;
-        while(info)
+        ID op = rb_intern("ice_id");
+        string id = getString(callRuby(rb_funcall, _object, op, 0));
+        os->startSlice(id, -1, true);
+        os->endSlice();
+    }
+    else
+    {
+        if(_info->id != "::Ice::UnknownSlicedValue")
         {
-            os->startSlice(info->id, info->compactId, !info->base);
+            ClassInfoPtr info = _info;
+            while(info)
+            {
+                os->startSlice(info->id, info->compactId, !info->base);
 
-            writeMembers(os, info->members);
-            writeMembers(os, info->optionalMembers); // The optional members have already been sorted by tag.
+                writeMembers(os, info->members);
+                writeMembers(os, info->optionalMembers); // The optional members have already been sorted by tag.
 
-            os->endSlice();
+                os->endSlice();
 
-            info = info->base;
+                info = info->base;
+            }
         }
     }
+    os->endValue();
+}
 
-    os->endObject();
+void
+IceRuby::ObjectWriter::_iceRead(Ice::InputStream*)
+{
+    assert(false);
 }
 
 void
-IceRuby::ObjectWriter::writeMembers(const Ice::OutputStreamPtr& os, const DataMemberList& members) const
+IceRuby::ObjectWriter::writeMembers(Ice::OutputStream* os, const DataMemberList& members) const
 {
     for(DataMemberList::const_iterator q = members.begin(); q != members.end(); ++q)
     {
@@ -2539,11 +2603,17 @@ IceRuby::ObjectReader::ice_postUnmarshal()
 }
 
 void
-IceRuby::ObjectReader::read(const Ice::InputStreamPtr& is)
+IceRuby::ObjectReader::_iceWrite(Ice::OutputStream*) const
 {
-    is->startObject();
+    assert(false);
+}
+
+void
+IceRuby::ObjectReader::_iceRead(Ice::InputStream* is)
+{
+    is->startValue();
 
-    const bool unknown = _info->id == "::Ice::UnknownSlicedObject";
+    const bool unknown = _info->id == "::Ice::UnknownSlicedValue";
 
     //
     // Unmarshal the slices of a user-defined class.
@@ -2585,16 +2655,16 @@ IceRuby::ObjectReader::read(const Ice::InputStreamPtr& is)
         }
     }
 
-    _slicedData = is->endObject(_info->preserve);
+    _slicedData = is->endValue(_info->preserve);
 
     if(_slicedData)
     {
-        SlicedDataUtil* util = reinterpret_cast<SlicedDataUtil*>(is->closure());
+        StreamUtil* util = reinterpret_cast<StreamUtil*>(is->getClosure());
         assert(util);
         util->add(this);
 
         //
-        // Define the "unknownTypeId" member for an instance of UnknownSlicedObject.
+        // Define the "unknownTypeId" member for an instance of UnknownSlicedValue.
         //
         if(unknown)
         {
@@ -2666,7 +2736,7 @@ IceRuby::ReadObjectCallback::invoke(const Ice::ObjectPtr& p)
         // Verify that the unmarshaled object is compatible with the formal type.
         //
         volatile VALUE obj = reader->getObject();
-        if(!_info->validate(obj))
+        if(!_info->interface && !_info->validate(obj))
         {
             Ice::UnexpectedObjectException ex(__FILE__, __LINE__);
             ex.reason = "unmarshaled object is not an instance of " + _info->id;
@@ -2687,7 +2757,7 @@ IceRuby::ReadObjectCallback::invoke(const Ice::ObjectPtr& p)
 // ExceptionInfo implementation.
 //
 VALUE
-IceRuby::ExceptionInfo::unmarshal(const Ice::InputStreamPtr& is)
+IceRuby::ExceptionInfo::unmarshal(Ice::InputStream* is)
 {
     volatile VALUE obj = callRuby(rb_class_new_instance, 0, static_cast<VALUE*>(0), rubyClass);
 
@@ -2797,8 +2867,8 @@ IceRuby::ExceptionInfo::printMembers(VALUE value, IceUtilInternal::Output& out,
 //
 // ExceptionReader implementation.
 //
-IceRuby::ExceptionReader::ExceptionReader(const Ice::CommunicatorPtr& communicator, const ExceptionInfoPtr& info) :
-    Ice::UserExceptionReader(communicator), _info(info)
+IceRuby::ExceptionReader::ExceptionReader(const ExceptionInfoPtr& info) :
+    _info(info)
 {
 }
 
@@ -2807,34 +2877,20 @@ IceRuby::ExceptionReader::~ExceptionReader()
 {
 }
 
-void
-IceRuby::ExceptionReader::read(const Ice::InputStreamPtr& is) const
-{
-    is->startException();
-
-    const_cast<VALUE&>(_ex) = _info->unmarshal(is);
-
-    const_cast<Ice::SlicedDataPtr&>(_slicedData) = is->endException(_info->preserve);
-}
-
-bool
-IceRuby::ExceptionReader::usesClasses() const
-{
-    return _info->usesClasses;
-}
-
 string
-IceRuby::ExceptionReader::ice_name() const
+IceRuby::ExceptionReader::ice_id() const
 {
     return _info->id;
 }
 
+#ifndef ICE_CPP11_MAPPING
 Ice::UserException*
 IceRuby::ExceptionReader::ice_clone() const
 {
     assert(false);
     return 0;
 }
+#endif
 
 void
 IceRuby::ExceptionReader::ice_throw() const
@@ -2842,6 +2898,28 @@ IceRuby::ExceptionReader::ice_throw() const
     throw *this;
 }
 
+void
+IceRuby::ExceptionReader::_write(Ice::OutputStream*) const
+{
+    assert(false);
+}
+
+void
+IceRuby::ExceptionReader::_read(Ice::InputStream* is)
+{
+    is->startException();
+
+    const_cast<VALUE&>(_ex) = _info->unmarshal(is);
+
+    const_cast<Ice::SlicedDataPtr&>(_slicedData) = is->endException(_info->preserve);
+}
+
+bool
+IceRuby::ExceptionReader::_usesClasses() const
+{
+    return _info->usesClasses;
+}
+
 VALUE
 IceRuby::ExceptionReader::getException() const
 {
@@ -3026,14 +3104,16 @@ IceRuby_defineException(VALUE /*self*/, VALUE id, VALUE type, VALUE preserve, VA
 
 extern "C"
 VALUE
-IceRuby_TypeInfo_defineProxy(VALUE self, VALUE type, VALUE classInfo)
+IceRuby_TypeInfo_defineProxy(VALUE self, VALUE type, VALUE base, VALUE interfaces)
 {
     ICE_RUBY_TRY
     {
         ProxyInfoPtr info = ProxyInfoPtr::dynamicCast(getType(self));
         assert(info);
 
-        info->define(type, classInfo);
+        info->define(type, base, interfaces);
+        rb_define_const(type, "ICE_TYPE", self);
+        rb_define_const(type, "ICE_ID", createString(info->id));
     }
     ICE_RUBY_CATCH
     return Qnil;
@@ -3041,22 +3121,31 @@ IceRuby_TypeInfo_defineProxy(VALUE self, VALUE type, VALUE classInfo)
 
 extern "C"
 VALUE
-IceRuby_TypeInfo_defineClass(VALUE self, VALUE type, VALUE compactId, VALUE isAbstract, VALUE preserve, VALUE base,
-                             VALUE interfaces, VALUE members)
+IceRuby_TypeInfo_defineClass(VALUE self, VALUE type, VALUE compactId, VALUE preserve, VALUE interface, VALUE base,
+                             VALUE members)
 {
     ICE_RUBY_TRY
     {
         ClassInfoPtr info = ClassInfoPtr::dynamicCast(getType(self));
         assert(info);
 
-        info->define(type, compactId, isAbstract, preserve, base, interfaces, members);
+        info->define(type, compactId, preserve, interface, base, members);
+
+        if(info->compactId != -1)
+        {
+            CompactIdMap::iterator q = _compactIdMap.find(info->compactId);
+            if(q != _compactIdMap.end())
+            {
+                _compactIdMap.erase(q);
+            }
+            _compactIdMap.insert(CompactIdMap::value_type(info->compactId, info));
+        }
 
-        CompactIdMap::iterator q = _compactIdMap.find(info->compactId);
-        if(q != _compactIdMap.end())
+        if(type != Qnil && !info->interface)
         {
-            _compactIdMap.erase(q);
+            rb_define_const(type, "ICE_TYPE", self);
+            rb_define_const(type, "ICE_ID", createString(info->id));
         }
-        _compactIdMap.insert(CompactIdMap::value_type(info->compactId, info));
     }
     ICE_RUBY_CATCH
     return Qnil;
@@ -3085,17 +3174,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);
@@ -3159,8 +3248,8 @@ IceRuby::initTypes(VALUE iceModule)
     rb_define_module_function(iceModule, "__declareLocalClass", CAST_METHOD(IceRuby_declareLocalClass), 1);
     rb_define_module_function(iceModule, "__defineException", CAST_METHOD(IceRuby_defineException), 5);
 
-    rb_define_method(_typeInfoClass, "defineClass", CAST_METHOD(IceRuby_TypeInfo_defineClass), 7);
-    rb_define_method(_typeInfoClass, "defineProxy", CAST_METHOD(IceRuby_TypeInfo_defineProxy), 2);
+    rb_define_method(_typeInfoClass, "defineClass", CAST_METHOD(IceRuby_TypeInfo_defineClass), 6);
+    rb_define_method(_typeInfoClass, "defineProxy", CAST_METHOD(IceRuby_TypeInfo_defineProxy), 3);
 
     rb_define_module_function(iceModule, "__stringify", CAST_METHOD(IceRuby_stringify), 2);
     rb_define_module_function(iceModule, "__stringifyException", CAST_METHOD(IceRuby_stringifyException), 1);