zeroc-ice 3.7.2 → 3.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 79ea9a56d0c6d3eaf5e8cd34f1d175cf105d39e0
-  data.tar.gz: d07d89217f5dc17aaa34856fdc133f5ee8cac13f
+SHA256:
+  metadata.gz: f061772e9d3a2a709e480d9bd0d028110838d15529c793b34367253782d649db
+  data.tar.gz: b451ddd683af4bbc6e948d76dce911204ff6c1b4314143e285b89f656ae8f0e4
 SHA512:
-  metadata.gz: d79d2329cbaa873fb11bafa7f12b701769ea8970ad8cf044f09c101aaa802d3661e1a0e8924c9a2f134e244e31fb55091339727a5c82fd3ef3fd71a813abae04
-  data.tar.gz: 2cc262447c5727446cb17de0259b0e021d45562896e466478df574506ef65fa22a665fdb8e1b0f38e525a1f4ace92def1af9146ae1b4c5cc7a2dcdf15c3c860c
+  metadata.gz: 943b478cf1ecdfb5e4332271fd025e8153b2c0a595ef7c96ce260d3d0a8caaffff2c1b5827166f687650d6fc6685f3e8c0f1c1fdd4090f7aecbb4ef237d8623a
+  data.tar.gz: 289327d910be75354d258ebc41eb31d2583738cd5b3fc7f43130442d87803000b9dac8787fd0b3ee9874bbf107606ad9c9ae12ac7a7c06f6aa9bd9f942cfdbf4

data/ext/Config.h

@@ -53,6 +53,10 @@
 #if defined(__clang__)
 #   pragma clang diagnostic push
 #   pragma clang diagnostic ignored "-Wunused-parameter"
+//
+// BUGFIX: Workaround clang conversion warnings in ruby headers
+//
+#   pragma clang diagnostic ignored "-Wconversion"
 #elif defined(__GNUC__)
 #   pragma GCC diagnostic push
 #   pragma GCC diagnostic ignored "-Wunused-parameter"

data/ext/Operation.cpp

@@ -64,8 +64,8 @@ private:
     bool _returnsClasses;
     string _deprecateMessage;
 
-    void convertParams(VALUE, ParamInfoList&, int, bool&);
-    ParamInfoPtr convertParam(VALUE, int);
+    void convertParams(VALUE, ParamInfoList&, long, bool&);
+    ParamInfoPtr convertParam(VALUE, long);
     void prepareRequest(const Ice::ObjectPrx&, VALUE, Ice::OutputStream*, pair<const Ice::Byte*, const Ice::Byte*>&);
     VALUE unmarshalResults(const vector<Ice::Byte>&, const Ice::CommunicatorPtr&);
     VALUE unmarshalException(const vector<Ice::Byte>&, const Ice::CommunicatorPtr&);
@@ -367,7 +367,7 @@ IceRuby::OperationI::deprecate(const string& msg)
 }
 
 void
-IceRuby::OperationI::convertParams(VALUE v, ParamInfoList& params, int posOffset, bool& usesClasses)
+IceRuby::OperationI::convertParams(VALUE v, ParamInfoList& params, long posOffset, bool& usesClasses)
 {
     assert(TYPE(v) == T_ARRAY);
 
@@ -383,14 +383,14 @@ IceRuby::OperationI::convertParams(VALUE v, ParamInfoList& params, int posOffset
 }
 
 ParamInfoPtr
-IceRuby::OperationI::convertParam(VALUE v, int pos)
+IceRuby::OperationI::convertParam(VALUE v, long pos)
 {
     assert(TYPE(v) == T_ARRAY);
     ParamInfoPtr param = new ParamInfo;
     param->type = getType(RARRAY_AREF(v, 0));
     param->optional = static_cast<bool>(RTEST(RARRAY_AREF(v, 1)));
     param->tag = static_cast<int>(getInteger(RARRAY_AREF(v, 2)));
-    param->pos = pos;
+    param->pos = static_cast<int>(pos);
     return param;
 }
 

data/ext/Properties.cpp

@@ -136,7 +136,7 @@ IceRuby_Properties_getPropertyAsIntWithDefault(VALUE self, VALUE key, VALUE def)
     {
         Ice::PropertiesPtr p = getProperties(self);
         string k = getString(key);
-        Ice::Int d = getInteger(def);
+        Ice::Int d = static_cast<Ice::Int>(getInteger(def));
         Ice::Int v = p->getPropertyAsIntWithDefault(k, d);
         return INT2FIX(v);
     }

data/ext/Proxy.cpp

@@ -153,7 +153,7 @@ IceRuby_ObjectPrx_ice_ids(int argc, VALUE* argv, VALUE self)
         checkArgs("ice_ids", 0, argc, argv, ctx);
 
         vector<string> ids = p->ice_ids(ctx);
-        volatile VALUE result = createArray(ids.size());
+        volatile VALUE result = createArray(static_cast<long>(ids.size()));
         long i = 0;
         for(vector<string>::iterator q = ids.begin(); q != ids.end(); ++q, ++i)
         {
@@ -307,7 +307,7 @@ IceRuby_ObjectPrx_ice_getEndpoints(VALUE self)
         Ice::ObjectPrx p = getProxy(self);
 
         Ice::EndpointSeq seq = p->ice_getEndpoints();
-        volatile VALUE result = createArray(seq.size());
+        volatile VALUE result = createArray(static_cast<long>(seq.size()));
         long i = 0;
         for(Ice::EndpointSeq::iterator q = seq.begin(); q != seq.end(); ++q, ++i)
         {
@@ -919,6 +919,19 @@ IceRuby_ObjectPrx_ice_fixed(VALUE self, VALUE con)
     return Qnil;
 }
 
+extern "C"
+VALUE
+IceRuby_ObjectPrx_ice_isFixed(VALUE self)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::ObjectPrx p = getProxy(self);
+        return p->ice_isFixed() ? Qtrue : Qfalse;
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
 extern "C"
 VALUE
 IceRuby_ObjectPrx_ice_getConnection(VALUE self)
@@ -1329,6 +1342,7 @@ IceRuby::initProxy(VALUE iceModule)
     rb_define_method(_proxyClass, "ice_getTimeout", CAST_METHOD(IceRuby_ObjectPrx_ice_getTimeout), 0);
     rb_define_method(_proxyClass, "ice_connectionId", CAST_METHOD(IceRuby_ObjectPrx_ice_connectionId), 1);
     rb_define_method(_proxyClass, "ice_fixed", CAST_METHOD(IceRuby_ObjectPrx_ice_fixed), 1);
+    rb_define_method(_proxyClass, "ice_isFixed", CAST_METHOD(IceRuby_ObjectPrx_ice_isFixed), 0);
     rb_define_method(_proxyClass, "ice_getConnection", CAST_METHOD(IceRuby_ObjectPrx_ice_getConnection), 0);
     rb_define_method(_proxyClass, "ice_getCachedConnection", CAST_METHOD(IceRuby_ObjectPrx_ice_getCachedConnection), 0);
     rb_define_method(_proxyClass, "ice_flushBatchRequests", CAST_METHOD(IceRuby_ObjectPrx_ice_flushBatchRequests), 0);

data/ext/Types.cpp

@@ -75,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;
@@ -240,8 +240,7 @@ IceRuby::StreamUtil::setSlicedDataMember(VALUE obj, const Ice::SlicedDataPtr& sl
 
     volatile VALUE sd = callRuby(rb_class_new_instance, 0, static_cast<VALUE*>(0), _slicedDataType);
 
-    Ice::Int sz = slicedData->slices.size();
-    volatile VALUE slices = createArray(sz);
+    volatile VALUE slices = createArray(static_cast<long>(slicedData->slices.size()));
 
     callRuby(rb_iv_set, sd, "@slices", slices);
 
@@ -271,13 +270,15 @@ IceRuby::StreamUtil::setSlicedDataMember(VALUE obj, const Ice::SlicedDataPtr& sl
         //
         // bytes
         //
-        volatile VALUE bytes = callRuby(rb_str_new, reinterpret_cast<const char*>(&(*p)->bytes[0]), (*p)->bytes.size());
+        volatile VALUE bytes = callRuby(rb_str_new,
+                                        (*p)->bytes.empty() ? 0 : reinterpret_cast<const char*>(&(*p)->bytes[0]),
+                                        static_cast<long>((*p)->bytes.size()));
         callRuby(rb_iv_set, slice, "@bytes", bytes);
 
         //
         // instances
         //
-        volatile VALUE instances = createArray((*p)->instances.size());
+        volatile VALUE instances = createArray(static_cast<long>((*p)->instances.size()));
         callRuby(rb_iv_set, slice, "@instances", instances);
 
         int j = 0;
@@ -1012,7 +1013,7 @@ IceRuby::StructInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap* objectMa
         p = _nullMarshalValue;
     }
 
-    Ice::OutputStream::size_type sizePos = -1;
+    Ice::OutputStream::size_type sizePos = 0;
     if(optional)
     {
         if(_variableLength)
@@ -1187,7 +1188,7 @@ IceRuby::SequenceInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap* object
 
     volatile VALUE arr = Qnil;
 
-    Ice::OutputStream::size_type sizePos = -1;
+    Ice::OutputStream::size_type sizePos = 0;
     if(optional)
     {
         if(elementType->variableLength())
@@ -1395,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;
@@ -1421,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));
@@ -1429,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));
@@ -1446,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));
@@ -1462,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));
@@ -1490,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));
@@ -1507,24 +1508,31 @@ IceRuby::SequenceInfo::marshalPrimitiveSequence(const PrimitiveInfoPtr& pi, VALU
                 throw RubyException(rb_eTypeError, "unable to convert array element %ld to a double", i);
             }
             assert(TYPE(v) == T_FLOAT);
-            seq[i] = RFLOAT_VALUE(v);
+            seq[static_cast<size_t>(i)] = RFLOAT_VALUE(v);
         }
-        os->write(&seq[0], &seq[0] + seq.size());
+        os->write(seq);
         break;
     }
     case PrimitiveInfo::KindString:
     {
         long sz = RARRAY_LEN(arr);
-        Ice::StringSeq seq(sz);
+        Ice::StringSeq seq(static_cast<size_t>(sz));
         for(long i = 0; i < sz; ++i)
         {
-            seq[i] = getString(RARRAY_AREF(arr, i));
+            seq[static_cast<size_t>(i)] = getString(RARRAY_AREF(arr, i));
+        }
+        if(seq.empty())
+        {
+            os->write(seq);
         }
+        else
+        {
 #ifdef HAVE_RUBY_ENCODING_H
-        os->write(&seq[0], &seq[0] + seq.size(), false); // Bypass string conversion.
+            os->write(&seq[0], &seq[0] + seq.size(), false); // Bypass string conversion.
 #else
-        os->write(&seq[0], &seq[0] + seq.size(), true);
+            os->write(&seq[0], &seq[0] + seq.size(), true);
 #endif
+        }
         break;
     }
     }
@@ -1658,12 +1666,9 @@ IceRuby::SequenceInfo::unmarshalPrimitiveSequence(const PrimitiveInfoPtr& pi, Ic
         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;
     }
@@ -1762,10 +1767,10 @@ IceRuby::DictionaryInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap* obje
         }
     }
 
-    int sz = 0;
+    Ice::Int sz = 0;
     if(!NIL_P(hash))
     {
-        sz = RHASH_SIZE(hash);
+        sz = static_cast<Ice::Int>(RHASH_SIZE(hash));
     }
 
     Ice::OutputStream::size_type sizePos = 0;
@@ -2356,7 +2361,7 @@ IceRuby::ProxyInfo::optionalFormat() const
 void
 IceRuby::ProxyInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap*, bool optional)
 {
-    Ice::OutputStream::size_type sizePos = -1;
+    Ice::OutputStream::size_type sizePos = 0;
     if(optional)
     {
         sizePos = os->startSize();

data/ext/Util.cpp

@@ -762,7 +762,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

@@ -8,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
 {
 
@@ -228,7 +236,7 @@ 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); }
+    inline VALUE operator()(){ return _f(_t1, _t2); }
     static inline VALUE call(VALUE f)
     {
         return (*reinterpret_cast<RF_2*>(f))();
@@ -468,8 +476,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.
 //
@@ -485,11 +491,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.

data/ext/ice/cpp/include/Ice/Config.h

@@ -26,6 +26,10 @@
 #   endif
 #endif
 
+#ifdef ICE_SWIFT
+#   include <dispatch/dispatch.h>
+#endif
+
 //
 // Define the Ice and IceInternal namespace, so that we can use the following
 // everywhere in our code:

data/ext/ice/cpp/include/Ice/FactoryTableInit.h

@@ -21,7 +21,7 @@ public:
 
 static FactoryTableInit factoryTableInitializer;    // Dummy variable to force initialization of factoryTable
 
-extern ICE_API FactoryTable* factoryTable;
+extern ICE_API FactoryTable* factoryTable ICE_GLOBAL_VAR_SUFFIX;
 
 class ICE_API CompactIdInit
 {

data/ext/ice/cpp/include/Ice/IconvStringConverter.h

@@ -267,7 +267,7 @@ IconvStringConverter<charT>::toUTF8(const charT* sourceStart,
 #else
     char* inbuf = reinterpret_cast<char*>(const_cast<charT*>(sourceStart));
 #endif
-    size_t inbytesleft = (sourceEnd - sourceStart) * sizeof(charT);
+    size_t inbytesleft = static_cast<size_t>(sourceEnd - sourceStart) * sizeof(charT);
     char* outbuf  = 0;
 
     size_t count = 0;
@@ -311,7 +311,8 @@ IconvStringConverter<charT>::fromUTF8(const Ice::Byte* sourceStart, const Ice::B
 #else
     char* inbuf = reinterpret_cast<char*>(const_cast<Ice::Byte*>(sourceStart));
 #endif
-    size_t inbytesleft = sourceEnd - sourceStart;
+    assert(sourceEnd > sourceStart);
+    size_t inbytesleft = static_cast<size_t>(sourceEnd - sourceStart);
 
     char* outbuf = 0;
     size_t outbytesleft = 0;
@@ -325,7 +326,7 @@ IconvStringConverter<charT>::fromUTF8(const Ice::Byte* sourceStart, const Ice::B
         size_t bytesused = 0;
         if(outbuf != 0)
         {
-            bytesused = outbuf - reinterpret_cast<const char*>(target.data());
+            bytesused = static_cast<size_t>(outbuf - reinterpret_cast<const char*>(target.data()));
         }
 
         const size_t increment = std::max<size_t>(inbytesleft, 4);