zeroc-ice 3.6.5 → 3.7.4

data/ext/Types.h

@@ -1,18 +1,15 @@
-// **********************************************************************
 //
-// 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
 
 #include <Config.h>
 #include <Util.h>
-#include <Ice/Stream.h>
+#include <Ice/FactoryTable.h>
+#include <Ice/Object.h>
+#include <Ice/SlicedData.h>
 #include <IceUtil/OutputUtil.h>
 
 namespace IceRuby
@@ -24,7 +21,10 @@ typedef std::vector ExceptionInfoList;
 
 class ClassInfo;
 typedef IceUtil::Handle<ClassInfo> ClassInfoPtr;
-typedef std::vector<ClassInfoPtr> ClassInfoList;
+
+class ProxyInfo;
+typedef IceUtil::Handle<ProxyInfo> ProxyInfoPtr;
+typedef std::vector<ProxyInfoPtr> ProxyInfoList;
 
 //
 // This class is raised as an exception when object marshaling needs to be aborted.
@@ -40,31 +40,6 @@ typedef std::map ObjectMap;
 class ObjectReader;
 typedef IceUtil::Handle<ObjectReader> ObjectReaderPtr;
 
-//
-// This class keeps track of Ruby objects (instances of Slice classes
-// and exceptions) that have preserved slices.
-//
-class SlicedDataUtil
-{
-public:
-
-    SlicedDataUtil();
-    ~SlicedDataUtil();
-
-    void add(const ObjectReaderPtr&);
-
-    void update();
-
-    static void setMember(VALUE, const Ice::SlicedDataPtr&);
-    static Ice::SlicedDataPtr getMember(VALUE, ObjectMap*);
-
-private:
-
-    std::set<ObjectReaderPtr> _readers;
-    static VALUE _slicedDataType;
-    static VALUE _sliceInfoType;
-};
-
 struct PrintObjectHistory
 {
     int index;
@@ -94,6 +69,64 @@ public:
 };
 typedef IceUtil::Handle<UnmarshalCallback> UnmarshalCallbackPtr;
 
+//
+// ReadObjectCallback retains all of the information necessary to store an unmarshaled
+// Slice value as a Ruby object.
+//
+class ReadObjectCallback : public IceUtil::Shared
+{
+public:
+
+    ReadObjectCallback(const ClassInfoPtr&, const UnmarshalCallbackPtr&, VALUE, void*);
+
+    void invoke(const ::Ice::ObjectPtr&);
+
+private:
+
+    ClassInfoPtr _info;
+    UnmarshalCallbackPtr _cb;
+    VALUE _target;
+    void* _closure;
+};
+typedef IceUtil::Handle<ReadObjectCallback> ReadObjectCallbackPtr;
+
+//
+// This class assists during unmarshaling of Slice classes and exceptions.
+// We attach an instance to a stream.
+//
+class StreamUtil
+{
+public:
+
+    StreamUtil();
+    ~StreamUtil();
+
+    //
+    // Keep a reference to a ReadObjectCallback for patching purposes.
+    //
+    void add(const ReadObjectCallbackPtr&);
+
+    //
+    // Keep track of object instances that have preserved slices.
+    //
+    void add(const ObjectReaderPtr&);
+
+    //
+    // Updated the sliced data information for all stored object instances.
+    //
+    void updateSlicedData();
+
+    static void setSlicedDataMember(VALUE, const Ice::SlicedDataPtr&);
+    static Ice::SlicedDataPtr getSlicedDataMember(VALUE, ObjectMap*);
+
+private:
+
+    std::vector<ReadObjectCallbackPtr> _callbacks;
+    std::set<ObjectReaderPtr> _readers;
+    static VALUE _slicedDataType;
+    static VALUE _sliceInfoType;
+};
+
 //
 // Base class for type information.
 //
@@ -125,8 +158,8 @@ public:
     // The marshal and unmarshal functions can raise Ice exceptions, and may raise
     // AbortMarshaling if an error occurs.
     //
-    virtual void marshal(VALUE, const Ice::OutputStreamPtr&, ObjectMap*, bool) = 0;
-    virtual void unmarshal(const Ice::InputStreamPtr&, const UnmarshalCallbackPtr&, VALUE, void*, bool) = 0;
+    virtual void marshal(VALUE, Ice::OutputStream*, ObjectMap*, bool) = 0;
+    virtual void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool) = 0;
 
     virtual void print(VALUE, IceUtilInternal::Output&, PrintObjectHistory*) = 0;
 };
@@ -162,8 +195,8 @@ public:
     virtual int wireSize() const;
     virtual Ice::OptionalFormat optionalFormat() const;
 
-    virtual void marshal(VALUE, const Ice::OutputStreamPtr&, ObjectMap*, bool);
-    virtual void unmarshal(const Ice::InputStreamPtr&, const UnmarshalCallbackPtr&, VALUE, void*, bool);
+    virtual void marshal(VALUE, Ice::OutputStream*, ObjectMap*, bool);
+    virtual void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool);
 
     virtual void print(VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
 
@@ -192,8 +225,8 @@ public:
     virtual int wireSize() const;
     virtual Ice::OptionalFormat optionalFormat() const;
 
-    virtual void marshal(VALUE, const Ice::OutputStreamPtr&, ObjectMap*, bool);
-    virtual void unmarshal(const Ice::InputStreamPtr&, const UnmarshalCallbackPtr&, VALUE, void*, bool);
+    virtual void marshal(VALUE, Ice::OutputStream*, ObjectMap*, bool);
+    virtual void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool);
 
     virtual void print(VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
 
@@ -238,8 +271,8 @@ public:
 
     virtual bool usesClasses() const; // Default implementation returns false.
 
-    virtual void marshal(VALUE, const Ice::OutputStreamPtr&, ObjectMap*, bool);
-    virtual void unmarshal(const Ice::InputStreamPtr&, const UnmarshalCallbackPtr&, VALUE, void*, bool);
+    virtual void marshal(VALUE, Ice::OutputStream*, ObjectMap*, bool);
+    virtual void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool);
 
     virtual void print(VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
 
@@ -276,8 +309,8 @@ public:
 
     virtual bool usesClasses() const; // Default implementation returns false.
 
-    virtual void marshal(VALUE, const Ice::OutputStreamPtr&, ObjectMap*, bool);
-    virtual void unmarshal(const Ice::InputStreamPtr&, const UnmarshalCallbackPtr&, VALUE, void*, bool);
+    virtual void marshal(VALUE, Ice::OutputStream*, ObjectMap*, bool);
+    virtual void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool);
     virtual void unmarshaled(VALUE, VALUE, void*);
 
     virtual void print(VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
@@ -289,8 +322,8 @@ public:
 
 private:
 
-    void marshalPrimitiveSequence(const PrimitiveInfoPtr&, VALUE, const Ice::OutputStreamPtr&);
-    void unmarshalPrimitiveSequence(const PrimitiveInfoPtr&, const Ice::InputStreamPtr&, const UnmarshalCallbackPtr&,
+    void marshalPrimitiveSequence(const PrimitiveInfoPtr&, VALUE, Ice::OutputStream*);
+    void unmarshalPrimitiveSequence(const PrimitiveInfoPtr&, Ice::InputStream*, const UnmarshalCallbackPtr&,
                                     VALUE, void*);
 };
 typedef IceUtil::Handle<SequenceInfo> SequenceInfoPtr;
@@ -314,9 +347,9 @@ public:
 
     virtual bool usesClasses() const; // Default implementation returns false.
 
-    virtual void marshal(VALUE, const Ice::OutputStreamPtr&, ObjectMap*, bool);
-    virtual void unmarshal(const Ice::InputStreamPtr&, const UnmarshalCallbackPtr&, VALUE, void*, bool);
-    void marshalElement(VALUE, VALUE, const Ice::OutputStreamPtr&, ObjectMap*);
+    virtual void marshal(VALUE, Ice::OutputStream*, ObjectMap*, bool);
+    virtual void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool);
+    void marshalElement(VALUE, VALUE, Ice::OutputStream*, ObjectMap*);
     virtual void unmarshaled(VALUE, VALUE, void*);
 
     virtual void print(VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
@@ -353,7 +386,7 @@ public:
 
     ClassInfo(VALUE, bool);
 
-    void define(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE);
+    void define(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE);
 
     virtual std::string getId() const;
 
@@ -365,8 +398,8 @@ public:
 
     virtual bool usesClasses() const; // Default implementation returns false.
 
-    virtual void marshal(VALUE, const Ice::OutputStreamPtr&, ObjectMap*, bool);
-    virtual void unmarshal(const Ice::InputStreamPtr&, const UnmarshalCallbackPtr&, VALUE, void*, bool);
+    virtual void marshal(VALUE, Ice::OutputStream*, ObjectMap*, bool);
+    virtual void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool);
 
     virtual void print(VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
 
@@ -380,10 +413,9 @@ public:
     const Ice::Int compactId;
     const bool isBase; // Is this the ClassInfo for Ice::Object or Ice::LocalObject?
     const bool isLocal;
-    const bool isAbstract;
     const bool preserve;
+    const bool interface;
     const ClassInfoPtr base;
-    const ClassInfoList interfaces;
     const DataMemberList members;
     const DataMemberList optionalMembers;
     const VALUE rubyClass;
@@ -400,7 +432,7 @@ public:
 
     ProxyInfo(VALUE);
 
-    void define(VALUE, VALUE);
+    void define(VALUE, VALUE, VALUE);
 
     virtual std::string getId() const;
 
@@ -410,19 +442,22 @@ public:
     virtual int wireSize() const;
     virtual Ice::OptionalFormat optionalFormat() const;
 
-    virtual void marshal(VALUE, const Ice::OutputStreamPtr&, ObjectMap*, bool);
-    virtual void unmarshal(const Ice::InputStreamPtr&, const UnmarshalCallbackPtr&, VALUE, void*, bool);
+    virtual void marshal(VALUE, Ice::OutputStream*, ObjectMap*, bool);
+    virtual void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool);
 
     virtual void print(VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
 
     virtual void destroy();
 
+    bool isA(const ProxyInfoPtr&);
+
     const std::string id;
+    const bool isBase; // Is this the ClassInfo for Ice::ObjectPrx?
+    const ProxyInfoPtr base;
+    const ProxyInfoList interfaces;
     const VALUE rubyClass;
-    const ClassInfoPtr classInfo;
     const VALUE typeObj;
 };
-typedef IceUtil::Handle<ProxyInfo> ProxyInfoPtr;
 
 //
 // Exception information.
@@ -431,7 +466,7 @@ class ExceptionInfo : public IceUtil::Shared
 {
 public:
 
-    VALUE unmarshal(const Ice::InputStreamPtr&);
+    VALUE unmarshal(Ice::InputStream*);
 
     void print(VALUE, IceUtilInternal::Output&);
     void printMembers(VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
@@ -448,30 +483,32 @@ public:
 //
 // ObjectWriter wraps a Ruby object for marshaling.
 //
-class ObjectWriter : public Ice::ObjectWriter
+class ObjectWriter : public Ice::Object
 {
 public:
 
-    ObjectWriter(VALUE, ObjectMap*);
+    ObjectWriter(VALUE, ObjectMap*, const ClassInfoPtr&);
     virtual ~ObjectWriter();
 
     virtual void ice_preMarshal();
 
-    virtual void write(const Ice::OutputStreamPtr&) const;
+    virtual void _iceWrite(Ice::OutputStream*) const;
+    virtual void _iceRead(Ice::InputStream*);
 
 private:
 
-    void writeMembers(const Ice::OutputStreamPtr&, const DataMemberList&) const;
+    void writeMembers(Ice::OutputStream*, const DataMemberList&) const;
 
     VALUE _object;
     ObjectMap* _map;
     ClassInfoPtr _info;
+    ClassInfoPtr _formal;
 };
 
 //
 // ObjectReader unmarshals the state of an Ice object.
 //
-class ObjectReader : public Ice::ObjectReader
+class ObjectReader : public Ice::Object
 {
 public:
 
@@ -480,7 +517,8 @@ public:
 
     virtual void ice_postUnmarshal();
 
-    virtual void read(const Ice::InputStreamPtr&);
+    virtual void _iceWrite(Ice::OutputStream*) const;
+    virtual void _iceRead(Ice::InputStream*);
 
     virtual ClassInfoPtr getInfo() const;
 
@@ -498,24 +536,33 @@ private:
 //
 // ExceptionReader creates a Ruby user exception and unmarshals it.
 //
-class ExceptionReader : public Ice::UserExceptionReader
+class ExceptionReader : public Ice::UserException
 {
 public:
 
-    ExceptionReader(const Ice::CommunicatorPtr&, const ExceptionInfoPtr&);
+    ExceptionReader(const ExceptionInfoPtr&);
     ~ExceptionReader() throw();
 
-    virtual void read(const Ice::InputStreamPtr&) const;
-    virtual bool usesClasses() const;
-
-    virtual std::string ice_name() const;
+    virtual std::string ice_id() const;
+#ifndef ICE_CPP11_MAPPING
     virtual Ice::UserException* ice_clone() const;
+#endif
     virtual void ice_throw() const;
 
+    virtual void _write(Ice::OutputStream*) const;
+    virtual void _read(Ice::InputStream*);
+
+    virtual bool _usesClasses() const;
+
     VALUE getException() const;
 
     Ice::SlicedDataPtr getSlicedData() const;
 
+protected:
+
+    virtual void _writeImpl(Ice::OutputStream*) const {}
+    virtual void _readImpl(Ice::InputStream*) {}
+
 private:
 
     ExceptionInfoPtr _info;

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;
     }
@@ -311,7 +293,7 @@ IceRuby::createString(const string& str)
 namespace
 {
 
-template <typename T> 
+template <typename T>
 struct RubyCallArgs
 {
     volatile VALUE val;
@@ -399,6 +381,21 @@ IceRuby::stringSeqToArray(const vector& 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
 {
 
@@ -442,8 +439,8 @@ IceRuby::contextToHash(const Ice::Context& ctx)
     volatile VALUE result = callRuby(rb_hash_new);
     for(Ice::Context::const_iterator p = ctx.begin(); p != ctx.end(); ++p)
     {
-        volatile VALUE key = callRuby(rb_str_new, p->first.c_str(), static_cast<long>(p->first.size()));
-        volatile VALUE value = callRuby(rb_str_new, p->second.c_str(), static_cast<long>(p->second.size()));
+        volatile VALUE key = createString(p->first);
+        volatile VALUE value = createString(p->second);
         callRuby(rb_hash_aset, result, key, value);
     }
     return result;
@@ -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));
 }
@@ -522,8 +531,8 @@ IceRuby::createIdentity(const Ice::Identity& id)
     assert(!NIL_P(cls));
 
     volatile VALUE result = callRuby(rb_class_new_instance, 0, reinterpret_cast<VALUE*>(0), cls);
-    volatile VALUE name = callRuby(rb_str_new, id.name.c_str(), static_cast<long>(id.name.size()));
-    volatile VALUE category = callRuby(rb_str_new, id.category.c_str(), static_cast<long>(id.category.size()));
+    volatile VALUE name = createString(id.name);
+    volatile VALUE category = createString(id.category);
     callRuby(rb_iv_set, result, "@name", name);
     callRuby(rb_iv_set, result, "@category", category);
     return result;
@@ -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;
@@ -699,7 +728,7 @@ setExceptionMembers(const Ice::LocalException& ex, VALUE p)
         m = createEncodingVersion(e.supported);
         callRuby(rb_iv_set, p, "@supported", m);
     }
-    catch(const Ice::NoObjectFactoryException& e)
+    catch(const Ice::NoValueFactoryException& e)
     {
         volatile VALUE v;
         v = createString(e.reason);
@@ -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);
@@ -741,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)
@@ -761,7 +794,7 @@ IceRuby::convertLocalException(const Ice::LocalException& ex)
     //
     try
     {
-        string name = ex.ice_name();
+        string name = ex.ice_id().substr(2);
         volatile VALUE cls = callRuby(rb_path2class, name.c_str());
         if(NIL_P(cls))
         {
@@ -777,7 +810,7 @@ IceRuby::convertLocalException(const Ice::LocalException& ex)
     }
     catch(...)
     {
-        string msg = "failure occurred while converting exception " + ex.ice_name();
+        string msg = "failure occurred while converting exception " + ex.ice_id();
         return rb_exc_new2(rb_eRuntimeError, msg.c_str());
     }
 }