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 55de1f69c0e..d683d5d7f63 100644
--- a/ruby/src/IceRuby/Operation.cpp
+++ b/ruby/src/IceRuby/Operation.cpp
@@ -166,7 +166,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);
 }
 
 //
@@ -278,7 +278,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)));
     }
 }
 
@@ -350,7 +350,7 @@ IceRuby::OperationI::invoke(const Ice::ObjectPrx& proxy, VALUE args, VALUE hctx)
             }
             else
             {
-                return RARRAY_PTR(results)[0];
+                return RARRAY_AREF(results, 0);
             }
         }
     }
@@ -378,7 +378,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)
         {
@@ -392,9 +392,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;
 }
@@ -432,7 +432,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);
@@ -449,7 +449,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);
             }
         }
@@ -460,7 +460,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);
@@ -543,7 +543,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 526e24d59e8..8a04a31f584 100644
--- a/ruby/src/IceRuby/Types.cpp
+++ b/ruby/src/IceRuby/Types.cpp
@@ -258,7 +258,8 @@ IceRuby::StreamUtil::setSlicedDataMember(VALUE obj, const Ice::SlicedDataPtr& sl
     {
         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
@@ -295,7 +296,8 @@ IceRuby::StreamUtil::setSlicedDataMember(VALUE obj, const Ice::SlicedDataPtr& sl
             assert(r);
             VALUE o = r->getObject();
             assert(o != Qnil); // Should be non-nil.
-            RARRAY_PTR(objects)[j++] = o;
+            RARRAY_ASET(objects, j, o);
+            j++;
         }
 
         //
@@ -338,7 +340,7 @@ IceRuby::StreamUtil::getSlicedDataMember(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;
 
@@ -364,7 +366,7 @@ IceRuby::StreamUtil::getSlicedDataMember(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;
 
@@ -876,21 +878,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
         {
@@ -1238,12 +1240,12 @@ IceRuby::SequenceInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap* object
         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);
         }
     }
 
@@ -1296,7 +1298,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
@@ -1336,7 +1338,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();
     }
@@ -1393,7 +1395,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;
@@ -1419,7 +1421,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);
@@ -1436,7 +1438,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);
@@ -1452,7 +1454,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);
@@ -1468,7 +1470,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;
@@ -1479,7 +1481,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);
@@ -1496,7 +1498,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);
@@ -1513,7 +1515,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[0], &seq[0] + seq.size());
         break;
@@ -1541,7 +1543,7 @@ IceRuby::SequenceInfo::unmarshalPrimitiveSequence(const PrimitiveInfoPtr& pi, Ic
         {
             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;
@@ -1565,7 +1567,7 @@ IceRuby::SequenceInfo::unmarshalPrimitiveSequence(const PrimitiveInfoPtr& pi, Ic
         {
             for(long i = 0; i < sz; ++i)
             {
-                RARRAY_PTR(result)[i] = INT2FIX(p.first[i]);
+                RARRAY_ASET(result, i, INT2FIX(p.first[i]));
             }
         }
         break;
@@ -1582,7 +1584,7 @@ IceRuby::SequenceInfo::unmarshalPrimitiveSequence(const PrimitiveInfoPtr& pi, Ic
         {
             for(long i = 0; i < sz; ++i)
             {
-                RARRAY_PTR(result)[i] = INT2FIX(p.first[i]);
+                RARRAY_ASET(result, i, INT2FIX(p.first[i]));
             }
         }
         break;
@@ -1599,7 +1601,7 @@ IceRuby::SequenceInfo::unmarshalPrimitiveSequence(const PrimitiveInfoPtr& pi, Ic
         {
             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;
@@ -1616,7 +1618,7 @@ IceRuby::SequenceInfo::unmarshalPrimitiveSequence(const PrimitiveInfoPtr& pi, Ic
         {
             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;
@@ -1633,7 +1635,7 @@ IceRuby::SequenceInfo::unmarshalPrimitiveSequence(const PrimitiveInfoPtr& pi, Ic
         {
             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;
@@ -1649,7 +1651,7 @@ IceRuby::SequenceInfo::unmarshalPrimitiveSequence(const PrimitiveInfoPtr& pi, Ic
         {
             for(long i = 0; i < sz; ++i)
             {
-                RARRAY_PTR(result)[i] = createString(seq[i]);
+                RARRAY_ASET(result, i, createString(seq[i]));
             }
         }
         break;
@@ -1977,7 +1979,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 e297c258c03..ef076d04bd8 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 1cd6ea08c34..d225a09dfb0 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>