ICE-7023 - Ruby 2.3 compatibility

6 files changed, 61 insertions, 48 deletions

diff --git a/ruby/src/IceRuby/Config.h b/ruby/src/IceRuby/Config.h
index daf7e65423a..f8117b4d554 100644
--- a/ruby/src/IceRuby/Config.h
+++ b/ruby/src/IceRuby/Config.h
@@ -87,4 +87,15 @@ typedef VALUE(*ICE_RUBY_ENTRY_POINT)(...);
 #   define RFLOAT_VALUE(v) RFLOAT(v)->value
 #endif
 
+//
+// The RARRAY_AREF and RARRAY_ASET macros were added in Ruby 2.1.
+//
+#ifndef RARRAY_AREF
+#   define RARRAY_AREF(a, i) (RARRAY_PTR(a)[i])
+#endif
+
+#ifndef RARRAY_ASET
+#   define RARRAY_ASET(a, i, v) RARRAY_PTR(a)[i] = v
+#endif
+
 #endif
diff --git a/ruby/src/IceRuby/Operation.cpp b/ruby/src/IceRuby/Operation.cpp
index 2f4d34210ca..53778ec253b 100644
--- a/ruby/src/IceRuby/Operation.cpp
+++ b/ruby/src/IceRuby/Operation.cpp
@@ -175,7 +175,7 @@ IceRuby::ParamInfo::unmarshaled(VALUE val, VALUE target, void* closure)
 #else
     long i = reinterpret_cast<long>(closure);
 #endif
-    RARRAY_PTR(target)[i] = val;
+    RARRAY_ASET(target, i, val);
 }
 
 //
@@ -287,7 +287,7 @@ IceRuby::OperationI::OperationI(VALUE name, VALUE mode, VALUE sendMode, VALUE am
     //
     for(long i = 0; i < RARRAY_LEN(exceptions); ++i)
     {
-        _exceptions.push_back(getException(RARRAY_PTR(exceptions)[i]));
+        _exceptions.push_back(getException(RARRAY_AREF(exceptions, i)));
     }
 }
 
@@ -359,7 +359,7 @@ IceRuby::OperationI::invoke(const Ice::ObjectPrx& proxy, VALUE args, VALUE hctx)
             }
             else
             {
-                return RARRAY_PTR(results)[0];
+                return RARRAY_AREF(results, 0);
             }
         }
     }
@@ -387,7 +387,7 @@ IceRuby::OperationI::convertParams(VALUE v, ParamInfoList& params, int posOffset
 
     for(long i = 0; i < RARRAY_LEN(v); ++i)
     {
-        ParamInfoPtr param = convertParam(RARRAY_PTR(v)[i], i + posOffset);
+        ParamInfoPtr param = convertParam(RARRAY_AREF(v, i), i + posOffset);
         params.push_back(param);
         if(!param->optional && !usesClasses)
         {
@@ -401,9 +401,9 @@ IceRuby::OperationI::convertParam(VALUE v, int pos)
 {
     assert(TYPE(v) == T_ARRAY);
     ParamInfoPtr param = new ParamInfo;
-    param->type = getType(RARRAY_PTR(v)[0]);
-    param->optional = static_cast<bool>(RTEST(RARRAY_PTR(v)[1]));
-    param->tag = static_cast<int>(getInteger(RARRAY_PTR(v)[2]));
+    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;
     return param;
 }
@@ -442,7 +442,7 @@ IceRuby::OperationI::prepareRequest(const Ice::ObjectPrx& proxy, VALUE args, Ice
         for(p = _inParams.begin(); p != _inParams.end(); ++p)
         {
             ParamInfoPtr info = *p;
-            volatile VALUE arg = RARRAY_PTR(args)[info->pos];
+            volatile VALUE arg = RARRAY_AREF(args, info->pos);
             if((!info->optional || arg != Unset) && !info->type->validate(arg))
             {
                 string opName = fixIdent(_name, IdentNormal);
@@ -459,7 +459,7 @@ IceRuby::OperationI::prepareRequest(const Ice::ObjectPrx& proxy, VALUE args, Ice
             ParamInfoPtr info = *p;
             if(!info->optional)
             {
-                volatile VALUE arg = RARRAY_PTR(args)[info->pos];
+                volatile VALUE arg = RARRAY_AREF(args, info->pos);
                 info->type->marshal(arg, os, &objectMap, false);
             }
         }
@@ -470,7 +470,7 @@ IceRuby::OperationI::prepareRequest(const Ice::ObjectPrx& proxy, VALUE args, Ice
         for(p = _optionalInParams.begin(); p != _optionalInParams.end(); ++p)
         {
             ParamInfoPtr info = *p;
-            volatile VALUE arg = RARRAY_PTR(args)[info->pos];
+            volatile VALUE arg = RARRAY_AREF(args, info->pos);
             if(arg != Unset && os->writeOptional(info->tag, info->type->optionalFormat()))
             {
                 info->type->marshal(arg, os, &objectMap, true);
@@ -553,7 +553,7 @@ IceRuby::OperationI::unmarshalResults(const vector<Ice::Byte>& bytes, const Ice:
         }
         else
         {
-            RARRAY_PTR(results)[info->pos] = Unset;
+            RARRAY_ASET(results, info->pos, Unset);
         }
     }
 
diff --git a/ruby/src/IceRuby/Proxy.cpp b/ruby/src/IceRuby/Proxy.cpp
index 86da9b3e5c9..0029cad3378 100644
--- a/ruby/src/IceRuby/Proxy.cpp
+++ b/ruby/src/IceRuby/Proxy.cpp
@@ -188,7 +188,7 @@ IceRuby_ObjectPrx_ice_ids(int argc, VALUE* argv, VALUE self)
         long i = 0;
         for(vector<string>::iterator q = ids.begin(); q != ids.end(); ++q, ++i)
         {
-            RARRAY_PTR(result)[i] = createString(*q);
+            RARRAY_ASET(result, i, createString(*q));
         }
 
         return result;
@@ -352,7 +352,7 @@ IceRuby_ObjectPrx_ice_getEndpoints(VALUE self)
         long i = 0;
         for(Ice::EndpointSeq::iterator q = seq.begin(); q != seq.end(); ++q, ++i)
         {
-            RARRAY_PTR(result)[i] = createEndpoint(*q);
+            RARRAY_ASET(result, i, createEndpoint(*q));
         }
         return result;
     }
@@ -383,11 +383,11 @@ IceRuby_ObjectPrx_ice_endpoints(VALUE self, VALUE seq)
             }
             for(long i = 0; i < RARRAY_LEN(arr); ++i)
             {
-                if(!checkEndpoint(RARRAY_PTR(arr)[i]))
+                if(!checkEndpoint(RARRAY_AREF(arr, i)))
                 {
                     throw RubyException(rb_eTypeError, "array element is not an Ice::Endpoint");
                 }
-                Ice::EndpointPtr* e = reinterpret_cast<Ice::EndpointPtr*>(DATA_PTR(RARRAY_PTR(arr)[i]));
+                Ice::EndpointPtr* e = reinterpret_cast<Ice::EndpointPtr*>(DATA_PTR(RARRAY_AREF(arr, i)));
                 assert(e);
                 endpoints.push_back(*e);
             }
diff --git a/ruby/src/IceRuby/Types.cpp b/ruby/src/IceRuby/Types.cpp
index 4834320d1e2..53f25058e54 100644
--- a/ruby/src/IceRuby/Types.cpp
+++ b/ruby/src/IceRuby/Types.cpp
@@ -266,7 +266,8 @@ IceRuby::SlicedDataUtil::setMember(VALUE obj, const Ice::SlicedDataPtr& slicedDa
     {
         volatile VALUE slice = callRuby(rb_class_new_instance, 0, static_cast<VALUE*>(0), _sliceInfoType);
 
-        RARRAY_PTR(slices)[i++] = slice;
+        RARRAY_ASET(slices, i, slice);
+        i++;
 
         //
         // typeId
@@ -303,7 +304,8 @@ IceRuby::SlicedDataUtil::setMember(VALUE obj, const Ice::SlicedDataPtr& slicedDa
             assert(r);
             VALUE o = r->getObject();
             assert(o != Qnil); // Should be non-nil.
-            RARRAY_PTR(objects)[j++] = o;
+            RARRAY_ASET(objects, j, o);
+            j++;
         }
 
         //
@@ -346,7 +348,7 @@ IceRuby::SlicedDataUtil::getMember(VALUE obj, ObjectMap* objectMap)
             long sz = RARRAY_LEN(sl);
             for(long i = 0; i < sz; ++i)
             {
-                volatile VALUE s = RARRAY_PTR(sl)[i];
+                volatile VALUE s = RARRAY_AREF(sl, i);
 
                 Ice::SliceInfoPtr info = new Ice::SliceInfo;
 
@@ -372,7 +374,7 @@ IceRuby::SlicedDataUtil::getMember(VALUE obj, ObjectMap* objectMap)
                 long osz = RARRAY_LEN(objects);
                 for(long j = 0; j < osz; ++j)
                 {
-                    VALUE o = RARRAY_PTR(objects)[j];
+                    VALUE o = RARRAY_AREF(objects, j);
 
                     Ice::ObjectPtr writer;
 
@@ -884,21 +886,21 @@ convertDataMembers(VALUE members, DataMemberList& reqMembers, DataMemberList& op
     assert(!NIL_P(arr));
     for(long i = 0; i < RARRAY_LEN(arr); ++i)
     {
-        volatile VALUE m = callRuby(rb_check_array_type, RARRAY_PTR(arr)[i]);
+        volatile VALUE m = callRuby(rb_check_array_type, RARRAY_AREF(arr, i));
         assert(!NIL_P(m));
         assert(RARRAY_LEN(m) == allowOptional ? 4 : 2);
 
         DataMemberPtr member = new DataMember;
 
-        member->name = getString(RARRAY_PTR(m)[0]);
-        member->type = getType(RARRAY_PTR(m)[1]);
+        member->name = getString(RARRAY_AREF(m, 0));
+        member->type = getType(RARRAY_AREF(m, 1));
         string s = "@" + member->name;
         member->rubyID = rb_intern(s.c_str());
 
         if(allowOptional)
         {
-            member->optional = RTEST(RARRAY_PTR(m)[2]);
-            member->tag = static_cast<int>(getInteger(RARRAY_PTR(m)[3]));
+            member->optional = RTEST(RARRAY_AREF(m, 2));
+            member->tag = static_cast<int>(getInteger(RARRAY_AREF(m, 3)));
         }
         else
         {
@@ -1246,12 +1248,12 @@ IceRuby::SequenceInfo::marshal(VALUE p, const Ice::OutputStreamPtr& os, ObjectMa
         os->writeSize(static_cast<Ice::Int>(sz));
         for(long i = 0; i < sz; ++i)
         {
-            if(!elementType->validate(RARRAY_PTR(arr)[i]))
+            if(!elementType->validate(RARRAY_AREF(arr, i)))
             {
                 throw RubyException(rb_eTypeError, "invalid value for element %ld of `%s'", i,
                                     const_cast<char*>(id.c_str()));
             }
-            elementType->marshal(RARRAY_PTR(arr)[i], os, objectMap, false);
+            elementType->marshal(RARRAY_AREF(arr, i), os, objectMap, false);
         }
     }
 
@@ -1304,7 +1306,7 @@ IceRuby::SequenceInfo::unmarshaled(VALUE val, VALUE target, void* closure)
 #else
     long i = reinterpret_cast<long>(closure);
 #endif
-    RARRAY_PTR(target)[i] = val;
+    RARRAY_ASET(target, i, val);
 }
 
 void
@@ -1344,7 +1346,7 @@ IceRuby::SequenceInfo::print(VALUE value, IceUtilInternal::Output& out, PrintObj
         for(long i = 0; i < sz; ++i)
         {
             out << nl << '[' << i << "] = ";
-            elementType->print(RARRAY_PTR(arr)[i], out, history);
+            elementType->print(RARRAY_AREF(arr, i), out, history);
         }
         out.eb();
     }
@@ -1401,7 +1403,7 @@ IceRuby::SequenceInfo::marshalPrimitiveSequence(const PrimitiveInfoPtr& pi, VALU
         Ice::BoolSeq seq(sz);
         for(long i = 0; i < sz; ++i)
         {
-            seq[i] = RTEST(RARRAY_PTR(arr)[i]);
+            seq[i] = RTEST(RARRAY_AREF(arr, i));
         }
         os->write(seq);
         break;
@@ -1427,7 +1429,7 @@ IceRuby::SequenceInfo::marshalPrimitiveSequence(const PrimitiveInfoPtr& pi, VALU
             Ice::ByteSeq seq(sz);
             for(long i = 0; i < sz; ++i)
             {
-                long val = getInteger(RARRAY_PTR(arr)[i]);
+                long val = getInteger(RARRAY_AREF(arr, i));
                 if(val < 0 || val > 255)
                 {
                     throw RubyException(rb_eTypeError, "invalid value for element %ld of sequence<byte>", i);
@@ -1444,7 +1446,7 @@ IceRuby::SequenceInfo::marshalPrimitiveSequence(const PrimitiveInfoPtr& pi, VALU
         Ice::ShortSeq seq(sz);
         for(long i = 0; i < sz; ++i)
         {
-            long val = getInteger(RARRAY_PTR(arr)[i]);
+            long val = getInteger(RARRAY_AREF(arr, i));
             if(val < SHRT_MIN || val > SHRT_MAX)
             {
                 throw RubyException(rb_eTypeError, "invalid value for element %ld of sequence<short>", i);
@@ -1460,7 +1462,7 @@ IceRuby::SequenceInfo::marshalPrimitiveSequence(const PrimitiveInfoPtr& pi, VALU
         Ice::IntSeq seq(sz);
         for(long i = 0; i < sz; ++i)
         {
-            long val = getInteger(RARRAY_PTR(arr)[i]);
+            long val = getInteger(RARRAY_AREF(arr, i));
             if(val < INT_MIN || val > INT_MAX)
             {
                 throw RubyException(rb_eTypeError, "invalid value for element %ld of sequence<int>", i);
@@ -1476,7 +1478,7 @@ IceRuby::SequenceInfo::marshalPrimitiveSequence(const PrimitiveInfoPtr& pi, VALU
         Ice::LongSeq seq(sz);
         for(long i = 0; i < sz; ++i)
         {
-            seq[i] = getLong(RARRAY_PTR(arr)[i]);
+            seq[i] = getLong(RARRAY_AREF(arr, i));
         }
         os->write(&seq[0], &seq[0] + seq.size());
         break;
@@ -1487,7 +1489,7 @@ IceRuby::SequenceInfo::marshalPrimitiveSequence(const PrimitiveInfoPtr& pi, VALU
         Ice::FloatSeq seq(sz);
         for(long i = 0; i < sz; ++i)
         {
-            volatile VALUE v = callRuby(rb_Float, RARRAY_PTR(arr)[i]);
+            volatile VALUE v = callRuby(rb_Float, RARRAY_AREF(arr, i));
             if(NIL_P(v))
             {
                 throw RubyException(rb_eTypeError, "unable to convert array element %ld to a float", i);
@@ -1504,7 +1506,7 @@ IceRuby::SequenceInfo::marshalPrimitiveSequence(const PrimitiveInfoPtr& pi, VALU
         Ice::DoubleSeq seq(sz);
         for(long i = 0; i < sz; ++i)
         {
-            volatile VALUE v = callRuby(rb_Float, RARRAY_PTR(arr)[i]);
+            volatile VALUE v = callRuby(rb_Float, RARRAY_AREF(arr, i));
             if(NIL_P(v))
             {
                 throw RubyException(rb_eTypeError, "unable to convert array element %ld to a double", i);
@@ -1521,7 +1523,7 @@ IceRuby::SequenceInfo::marshalPrimitiveSequence(const PrimitiveInfoPtr& pi, VALU
         Ice::StringSeq seq(sz);
         for(long i = 0; i < sz; ++i)
         {
-            seq[i] = getString(RARRAY_PTR(arr)[i]);
+            seq[i] = getString(RARRAY_AREF(arr, i));
         }
         os->write(seq, true);
         break;
@@ -1549,7 +1551,7 @@ IceRuby::SequenceInfo::unmarshalPrimitiveSequence(const PrimitiveInfoPtr& pi, co
         {
             for(long i = 0; i < sz; ++i)
             {
-                RARRAY_PTR(result)[i] = p.first[i] ? Qtrue : Qfalse;
+                RARRAY_ASET(result, i, p.first[i] ? Qtrue : Qfalse);
             }
         }
         break;
@@ -1573,7 +1575,7 @@ IceRuby::SequenceInfo::unmarshalPrimitiveSequence(const PrimitiveInfoPtr& pi, co
         {
             for(long i = 0; i < sz; ++i)
             {
-                RARRAY_PTR(result)[i] = INT2FIX(p.first[i]);
+                RARRAY_ASET(result, i, INT2FIX(p.first[i]));
             }
         }
         break;
@@ -1590,7 +1592,7 @@ IceRuby::SequenceInfo::unmarshalPrimitiveSequence(const PrimitiveInfoPtr& pi, co
         {
             for(long i = 0; i < sz; ++i)
             {
-                RARRAY_PTR(result)[i] = INT2FIX(p.first[i]);
+                RARRAY_ASET(result, i, INT2FIX(p.first[i]));
             }
         }
         break;
@@ -1607,7 +1609,7 @@ IceRuby::SequenceInfo::unmarshalPrimitiveSequence(const PrimitiveInfoPtr& pi, co
         {
             for(long i = 0; i < sz; ++i)
             {
-                RARRAY_PTR(result)[i] = callRuby(rb_ll2inum, p.first[i]);
+                RARRAY_ASET(result, i, callRuby(rb_ll2inum, p.first[i]));
             }
         }
         break;
@@ -1624,7 +1626,7 @@ IceRuby::SequenceInfo::unmarshalPrimitiveSequence(const PrimitiveInfoPtr& pi, co
         {
             for(long i = 0; i < sz; ++i)
             {
-                RARRAY_PTR(result)[i] = callRuby(rb_float_new, p.first[i]);
+                RARRAY_ASET(result, i, callRuby(rb_float_new, p.first[i]));
             }
         }
         break;
@@ -1641,7 +1643,7 @@ IceRuby::SequenceInfo::unmarshalPrimitiveSequence(const PrimitiveInfoPtr& pi, co
         {
             for(long i = 0; i < sz; ++i)
             {
-                RARRAY_PTR(result)[i] = callRuby(rb_float_new, p.first[i]);
+                RARRAY_ASET(result, i, callRuby(rb_float_new, p.first[i]));
             }
         }
         break;
@@ -1657,7 +1659,7 @@ IceRuby::SequenceInfo::unmarshalPrimitiveSequence(const PrimitiveInfoPtr& pi, co
         {
             for(long i = 0; i < sz; ++i)
             {
-                RARRAY_PTR(result)[i] = createString(seq[i]);
+                RARRAY_ASET(result, i, createString(seq[i]));
             }
         }
         break;
@@ -1985,7 +1987,7 @@ IceRuby::ClassInfo::define(VALUE t, VALUE compact, VALUE abstr, VALUE pres, VALU
     assert(!NIL_P(arr));
     for(n = 0; n < RARRAY_LEN(arr); ++n)
     {
-        ClassInfoPtr iface = ClassInfoPtr::dynamicCast(getType(RARRAY_PTR(arr)[n]));
+        ClassInfoPtr iface = ClassInfoPtr::dynamicCast(getType(RARRAY_AREF(arr, n)));
         assert(iface);
         const_cast<ClassInfoList&>(interfaces).push_back(iface);
     }
diff --git a/ruby/src/IceRuby/Util.cpp b/ruby/src/IceRuby/Util.cpp
index 6b9ba1314d7..df53f265563 100644
--- a/ruby/src/IceRuby/Util.cpp
+++ b/ruby/src/IceRuby/Util.cpp
@@ -378,8 +378,8 @@ IceRuby::arrayToStringSeq(VALUE val, vector<string>& seq)
     }
     for(long i = 0; i < RARRAY_LEN(arr); ++i)
     {
-        string s = getString(RARRAY_PTR(arr)[i]);
-        seq.push_back(getString(RARRAY_PTR(arr)[i]));
+        string s = getString(RARRAY_AREF(arr, i));
+        seq.push_back(getString(RARRAY_AREF(arr, i)));
     }
     return true;
 }
@@ -393,7 +393,7 @@ IceRuby::stringSeqToArray(const vector<string>& seq)
     {
         for(vector<string>::const_iterator p = seq.begin(); p != seq.end(); ++p, ++i)
         {
-            RARRAY_PTR(result)[i] = createString(*p);
+            RARRAY_ASET(result, i, createString(*p));
         }
     }
     return result;
diff --git a/ruby/src/IceRuby/Util.h b/ruby/src/IceRuby/Util.h
index 40054f909d5..355044bca9b 100644
--- a/ruby/src/IceRuby/Util.h
+++ b/ruby/src/IceRuby/Util.h
@@ -445,7 +445,7 @@ VALUE createArrayHelper(long);
 // VALUE arr = createArray(size);
 // for(long i = 0; i < size; ++i)
 // {
-//     RARRAY_PTR(arr)[i] = ...;
+//     RARRAY_ASET(arr, i, val);
 // }
 //
 template<typename T>