zeroc-ice 3.7.1 → 3.7.2

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>
@@ -370,15 +365,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);
@@ -1157,8 +1152,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
@@ -1705,8 +1700,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
@@ -3174,17 +3169,17 @@ IceRuby_stringify(VALUE /*self*/, VALUE obj, VALUE type)
 
 extern "C"
 VALUE
-IceRuby_stringifyException(VALUE /*self*/, VALUE ex)
+IceRuby_stringifyException(VALUE /*self*/, VALUE exc)
 {
     ICE_RUBY_TRY
     {
-        volatile VALUE cls = CLASS_OF(ex);
+        volatile VALUE cls = CLASS_OF(exc);
         volatile VALUE type = callRuby(rb_const_get, cls, rb_intern("ICE_TYPE"));
         ExceptionInfoPtr info = getException(type);
 
         ostringstream ostr;
         IceUtilInternal::Output out(ostr);
-        info->print(ex, out);
+        info->print(exc, out);
 
         string str = ostr.str();
         return createString(str);

data/ext/Types.h

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

data/ext/Util.cpp

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #include <Util.h>
 #include <Ice/LocalException.h>
@@ -22,22 +17,10 @@ using namespace IceRuby;
 namespace
 {
 
-#ifndef NDEBUG
-bool
-checkIsInstance(VALUE p, const char* type)
-{
-    volatile VALUE rbType = callRuby(rb_path2class, type);
-    assert(!NIL_P(rbType));
-    return callRuby(rb_obj_is_instance_of, p, rbType) == Qtrue;
-}
-#endif
-
 template<typename T>
 bool
-setVersion(VALUE p, const T& version, const char* type)
+setVersion(VALUE p, const T& version)
 {
-    assert(checkIsInstance(p, type));
-
     volatile VALUE major = callRuby(rb_int2inum, version.major);
     volatile VALUE minor = callRuby(rb_int2inum, version.minor);
     rb_ivar_set(p, rb_intern("@major"), major);
@@ -48,9 +31,8 @@ setVersion(VALUE p, const T& version, const char* type)
 
 template<typename T>
 bool
-getVersion(VALUE p, T& v, const char* type)
+getVersion(VALUE p, T& v)
 {
-    assert(checkIsInstance(p, type));
     volatile VALUE major = callRuby(rb_ivar_get, p, rb_intern("@major"));
     volatile VALUE minor = callRuby(rb_ivar_get, p, rb_intern("@minor"));
 
@@ -84,7 +66,7 @@ createVersion(const T& version, const char* type)
 
     volatile VALUE obj = callRuby(rb_class_new_instance, 0, static_cast<VALUE*>(0), rbType);
 
-    if(!setVersion<T>(obj, version, type))
+    if(!setVersion<T>(obj, version))
     {
         return Qnil;
     }
@@ -104,7 +86,7 @@ versionToString(VALUE p, const char* type)
     }
 
     T v;
-    if(!getVersion<T>(p, v, type))
+    if(!getVersion<T>(p, v))
     {
         return Qnil;
     }
@@ -399,6 +381,21 @@ IceRuby::stringSeqToArray(const vector<string>& seq)
     return result;
 }
 
+VALUE
+IceRuby::createNumSeq(const vector<Ice::Byte>& v)
+{
+    volatile VALUE result = createArray(v.size());
+    long i = 0;
+    if(v.size() > 0)
+    {
+        for(vector<Ice::Byte>::const_iterator p = v.begin(); p != v.end(); ++p, ++i)
+        {
+            RARRAY_ASET(result, i, INT2FIX(*p));
+        }
+    }
+    return result;
+}
+
 namespace
 {
 
@@ -552,7 +549,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 +635,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 +660,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 +695,11 @@ setExceptionMembers(const Ice::LocalException& ex, VALUE p)
         v = createString(e.host);
         callRuby(rb_iv_set, p, "@host", v);
     }
+    catch(const Ice::BadMagicException& e)
+    {
+        volatile VALUE v = createNumSeq(e.badMagic);
+        callRuby(rb_iv_set, p, "@badMagic", v);
+    }
     catch(const Ice::UnsupportedProtocolException& e)
     {
         VALUE m;
@@ -722,6 +739,10 @@ setExceptionMembers(const Ice::LocalException& ex, VALUE p)
         volatile VALUE v = createString(e.reason);
         callRuby(rb_iv_set, p, "@reason", v);
     }
+    catch(const Ice::ConnectionManuallyClosedException& e)
+    {
+        callRuby(rb_iv_set, p, "@graceful", e.graceful ? Qtrue : Qfalse);
+    }
     catch(const Ice::FeatureNotSupportedException& e)
     {
         volatile VALUE v = createString(e.unsupportedFeature);
@@ -732,10 +753,6 @@ setExceptionMembers(const Ice::LocalException& ex, VALUE p)
         volatile VALUE v = createString(e.reason);
         callRuby(rb_iv_set, p, "@reason", v);
     }
-    catch(const Ice::ConnectionManuallyClosedException& e)
-    {
-        callRuby(rb_iv_set, p, "@graceful", e.graceful ? Qtrue : Qfalse);
-    }
     catch(const Ice::LocalException&)
     {
         //

data/ext/Util.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_UTIL_H
 #define ICE_RUBY_UTIL_H
@@ -90,6 +85,12 @@ bool arrayToStringSeq(VALUE, std::vector<std::string>&);
 //
 VALUE stringSeqToArray(const std::vector<std::string>&);
 
+//
+// Convert a vector of Ice::Byte into a Ruby array of numbers.
+// May raise RubyException.
+//
+VALUE createNumSeq(const std::vector<Ice::Byte>&);
+
 //
 // Convert a Ruby hash to Ice::Context. Returns true on success
 // and false if the value is not a hash. May raise RubyException.
@@ -177,7 +178,10 @@ public:
 
     RF_0(Fun f) : _f(f) {}
     inline VALUE operator()() { return _f(); }
-    static inline VALUE call(RF_0* f) { return (*f)(); }
+    static inline VALUE call(VALUE f)
+    {
+        return (*reinterpret_cast<RF_0*>(f))();
+    }
 
 private:
 
@@ -189,7 +193,7 @@ inline VALUE callRuby(Fun fun)
 {
     typedef RF_0<Fun> RF;
     RF f(fun);
-    return callProtected(RubyFunction(RF::call), reinterpret_cast<VALUE>(&f));
+    return callProtected(RF::call, reinterpret_cast<VALUE>(&f));
 }
 
 template<typename Fun, typename T1>
@@ -199,7 +203,10 @@ public:
 
     RF_1(Fun f, T1 t1) : _f(f), _t1(t1) {}
     inline VALUE operator()() { return _f(_t1); }
-    static inline VALUE call(RF_1* f) { return (*f)(); }
+    static inline VALUE call(VALUE f)
+    {
+        return (*reinterpret_cast<RF_1*>(f))();
+    }
 
 private:
 
@@ -212,7 +219,7 @@ inline VALUE callRuby(Fun fun, T1 t1)
 {
     typedef RF_1<Fun, T1> RF;
     RF f(fun, t1);
-    return callProtected(RubyFunction(RF::call), reinterpret_cast<VALUE>(&f));
+    return callProtected(RF::call, reinterpret_cast<VALUE>(&f));
 }
 
 template<typename Fun, typename T1, typename T2>
@@ -222,7 +229,10 @@ public:
 
     RF_2(Fun f, T1 t1, T2 t2) : _f(f), _t1(t1), _t2(t2) {}
     inline VALUE operator()() { return _f(_t1, _t2); }
-    static inline VALUE call(RF_2* f) { return (*f)(); }
+    static inline VALUE call(VALUE f)
+    {
+        return (*reinterpret_cast<RF_2*>(f))();
+    }
 
 private:
 
@@ -236,7 +246,7 @@ inline VALUE callRuby(Fun fun, T1 t1, T2 t2)
 {
     typedef RF_2<Fun, T1, T2> RF;
     RF f(fun, t1, t2);
-    return callProtected(RubyFunction(RF::call), reinterpret_cast<VALUE>(&f));
+    return callProtected(RF::call, reinterpret_cast<VALUE>(&f));
 }
 
 template<typename Fun, typename T1, typename T2, typename T3>
@@ -246,7 +256,10 @@ public:
 
     RF_3(Fun f, T1 t1, T2 t2, T3 t3) : _f(f), _t1(t1), _t2(t2), _t3(t3) {}
     inline VALUE operator()() { return _f(_t1, _t2, _t3); }
-    static inline VALUE call(RF_3* f) { return (*f)(); }
+    static inline VALUE call(VALUE f)
+    {
+        return (*reinterpret_cast<RF_3*>(f))();
+    }
 
 private:
 
@@ -261,7 +274,7 @@ inline VALUE callRuby(Fun fun, T1 t1, T2 t2, T3 t3)
 {
     typedef RF_3<Fun, T1, T2, T3> RF;
     RF f(fun, t1, t2, t3);
-    return callProtected(RubyFunction(RF::call), reinterpret_cast<VALUE>(&f));
+    return callProtected(RF::call, reinterpret_cast<VALUE>(&f));
 }
 
 template<typename Fun, typename T1, typename T2, typename T3, typename T4>
@@ -271,7 +284,10 @@ public:
 
     RF_4(Fun f, T1 t1, T2 t2, T3 t3, T4 t4) : _f(f), _t1(t1), _t2(t2), _t3(t3), _t4(t4) {}
     inline VALUE operator()() { return _f(_t1, _t2, _t3, _t4); }
-    static inline VALUE call(RF_4* f) { return (*f)(); }
+    static inline VALUE call(VALUE f)
+    {
+        return (*reinterpret_cast<RF_4*>(f))();
+    }
 
 private:
 
@@ -287,7 +303,7 @@ inline VALUE callRuby(Fun fun, T1 t1, T2 t2, T3 t3, T4 t4)
 {
     typedef RF_4<Fun, T1, T2, T3, T4> RF;
     RF f(fun, t1, t2, t3, t4);
-    return callProtected(RubyFunction(RF::call), reinterpret_cast<VALUE>(&f));
+    return callProtected(RF::call, reinterpret_cast<VALUE>(&f));
 }
 
 //
@@ -318,7 +334,12 @@ public:
 
     RFV_0(Fun f) : _f(f) {}
     inline void operator()() { _f(); }
-    static inline VALUE call(RFV_0* f) { (*f)(); return Qnil; }
+
+    static inline VALUE call(VALUE f)
+    {
+        (*reinterpret_cast<RFV_0*>(f))();
+        return Qnil;
+    }
 
 private:
 
@@ -330,7 +351,7 @@ inline void callRubyVoid(Fun fun)
 {
     typedef RFV_0<Fun> RF;
     RF f(fun);
-    callProtected(RubyFunction(RF::call), reinterpret_cast<VALUE>(&f));
+    callProtected(RF::call, reinterpret_cast<VALUE>(&f));
 }
 
 template<typename Fun, typename T1>
@@ -340,7 +361,11 @@ public:
 
     RFV_1(Fun f, T1 t1) : _f(f), _t1(t1) {}
     inline void operator()() { _f(_t1); }
-    static inline VALUE call(RFV_1* f) { (*f)(); return Qnil; }
+    static inline VALUE call(VALUE f)
+    {
+        (*reinterpret_cast<RFV_1*>(f))();
+        return Qnil;
+    }
 
 private:
 
@@ -353,7 +378,7 @@ inline void callRubyVoid(Fun fun, T1 t1)
 {
     typedef RFV_1<Fun, T1> RF;
     RF f(fun, t1);
-    callProtected(RubyFunction(RF::call), reinterpret_cast<VALUE>(&f));
+    callProtected(RF::call, reinterpret_cast<VALUE>(&f));
 }
 
 template<typename Fun, typename T1, typename T2>
@@ -363,7 +388,11 @@ public:
 
     RFV_2(Fun f, T1 t1, T2 t2) : _f(f), _t1(t1), _t2(t2) {}
     inline void operator()() { _f(_t1, _t2); }
-    static inline VALUE call(RFV_2* f) { (*f)(); return Qnil; }
+    static inline VALUE call(VALUE f)
+    {
+        (*reinterpret_cast<RFV_2*>(f))();
+        return Qnil;
+    }
 
 private:
 
@@ -377,7 +406,7 @@ inline void callRubyVoid(Fun fun, T1 t1, T2 t2)
 {
     typedef RFV_2<Fun, T1, T2> RF;
     RF f(fun, t1, t2);
-    callProtected(RubyFunction(RF::call), reinterpret_cast<VALUE>(&f));
+    callProtected(RF::call, reinterpret_cast<VALUE>(&f));
 }
 
 template<typename Fun, typename T1, typename T2, typename T3>
@@ -387,7 +416,11 @@ public:
 
     RFV_3(Fun f, T1 t1, T2 t2, T3 t3) : _f(f), _t1(t1), _t2(t2), _t3(t3) {}
     inline void operator()() { _f(_t1, _t2, _t3); }
-    static inline VALUE call(RFV_3* f) { (*f)(); return Qnil; }
+    static inline VALUE call(VALUE f)
+    {
+        (*reinterpret_cast<RFV_3*>(f))();
+        return Qnil;
+    }
 
 private:
 
@@ -402,7 +435,7 @@ inline void callRubyVoid(Fun fun, T1 t1, T2 t2, T3 t3)
 {
     typedef RFV_3<Fun, T1, T2, T3> RF;
     RF f(fun, t1, t2, t3);
-    callProtected(RubyFunction(RF::call), reinterpret_cast<VALUE>(&f));
+    callProtected(RF::call, reinterpret_cast<VALUE>(&f));
 }
 
 template<typename Fun, typename T1, typename T2, typename T3, typename T4>
@@ -412,7 +445,11 @@ public:
 
     RFV_4(Fun f, T1 t1, T2 t2, T3 t3, T4 t4) : _f(f), _t1(t1), _t2(t2), _t3(t3), _t4(t4) {}
     inline void operator()() { _f(_t1, _t2, _t3, _t4); }
-    static inline VALUE call(RFV_4* f) { (*f)(); return Qnil; }
+    static inline VALUE call(VALUE f)
+    {
+        (*reinterpret_cast<RFV_4*>(f))();
+        return Qnil;
+    }
 
 private: