zeroc-ice 3.7.0 → 3.7.5

data/ext/Types.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_TYPES_H
 #define ICE_RUBY_TYPES_H

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

data/ext/Util.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_UTIL_H
 #define ICE_RUBY_UTIL_H
@@ -13,6 +8,14 @@
 #include <Config.h>
 #include <Ice/Ice.h>
 
+//
+// Avoid clang conversion warnings in "callRuby" calls
+//
+#if defined(__clang__)
+#   pragma clang diagnostic ignored "-Wconversion"
+#   pragma clang diagnostic ignored "-Wsign-conversion"
+#endif
+
 namespace IceRuby
 {
 
@@ -90,6 +93,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.
@@ -166,6 +175,9 @@ VALUE callRuby(Fun fun, T1 t1, T2 t2, T3 t3);
 template<typename Fun, typename T1, typename T2, typename T3, typename T4>
 VALUE callRuby(Fun fun, T1 t1, T2 t2, T3 t3, T4 t4);
 
+template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+VALUE callRuby(Fun fun, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6);
+
 extern "C" typedef VALUE (*RubyFunction)(VALUE);
 
 VALUE callProtected(RubyFunction, VALUE);
@@ -177,7 +189,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 +204,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 +214,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 +230,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>
@@ -221,8 +239,11 @@ class RF_2
 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)(); }
+    inline VALUE operator()(){ return _f(_t1, _t2); }
+    static inline VALUE call(VALUE f)
+    {
+        return (*reinterpret_cast<RF_2*>(f))();
+    }
 
 private:
 
@@ -236,7 +257,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 +267,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 +285,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 +295,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 +314,40 @@ 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));
+}
+
+template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+class RF_6
+{
+public:
+
+    RF_6(Fun f, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) : _f(f), _t1(t1), _t2(t2), _t3(t3), _t4(t4), _t5(t5), _t6(t6)
+    {
+    }
+    inline VALUE operator()() { return _f(_t1, _t2, _t3, _t4, _t5, _t6); }
+    static inline VALUE call(VALUE f)
+    {
+        return (*reinterpret_cast<RF_6*>(f))();
+    }
+
+private:
+
+    Fun _f;
+    T1 _t1;
+    T2 _t2;
+    T3 _t3;
+    T4 _t4;
+    T5 _t5;
+    T6 _t6;
+};
+
+template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+inline VALUE callRuby(Fun fun, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)
+{
+    typedef RF_6<Fun, T1, T2, T3, T4, T5, T6> RF;
+    RF f(fun, t1, t2, t3, t4, t5, t6);
+    return callProtected(RF::call, reinterpret_cast<VALUE>(&f));
 }
 
 //
@@ -318,7 +378,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 +395,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 +405,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 +422,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 +432,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 +450,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 +460,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 +479,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 +489,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:
 
@@ -431,8 +512,6 @@ inline void callRubyVoid(Fun fun, T1 t1, T2 t2, T3 t3, T4 t4)
     callProtected(RubyFunction(RF::call), reinterpret_cast<VALUE>(&f));
 }
 
-VALUE createArrayHelper(long);
-
 //
 // Create an array with the given size. May raise RubyException.
 //
@@ -448,11 +527,7 @@ VALUE createArrayHelper(long);
 //     RARRAY_ASET(arr, i, val);
 // }
 //
-template<typename T>
-inline VALUE createArray(T sz)
-{
-    return createArrayHelper(static_cast<long>(sz));
-}
+VALUE createArray(long);
 
 //
 // Create the Ruby equivalent of an Ice local exception.