zeroc-ice 3.8.2 → 3.8.3

data/dist/IceRuby/Types.h

@@ -21,7 +21,6 @@ namespace IceRuby
 
     class ProxyInfo;
     using ProxyInfoPtr = std::shared_ptr<ProxyInfo>;
-    using ProxyInfoList = std::vector<ProxyInfoPtr>;
 
     //
     // This class is raised as an exception when object marshaling needs to be aborted.
@@ -35,20 +34,27 @@ namespace IceRuby
     using ValueMap = std::map<VALUE, std::shared_ptr<Ice::Value>>;
 
     class ValueReader;
+    class StreamUtil;
 
+    // Tracks the class instances already printed during a stringification, to detect shared instances and cycles.
+    // The instances are keyed in a Ruby identity hash (instance => index), whose keys remain valid when GC
+    // compaction runs during the stringification.
     struct PrintObjectHistory
     {
-        int index;
-        std::map<VALUE, int> objects;
+        PrintObjectHistory();
+
+        int index{0};  // the index to assign to the next class instance printed for the first time
+        VALUE objects; // Ruby identity hash
     };
 
     //
-    // The delayed nature of class unmarshaling in the Ice protocol requires us to
-    // handle unmarshaling using a callback strategy. An instance of UnmarshalCallback
-    // is supplied to each type's unmarshal() member function. For all types except
-    // classes, the callback is invoked with the unmarshaled value before unmarshal()
-    // returns. For class instances, however, the callback may not be invoked until
-    // the stream's finished() function is called.
+    // Slice unmarshaling uses a callback strategy: an instance of UnmarshalCallback is
+    // supplied to each type's unmarshal() member function. For all types except classes,
+    // the callback is invoked with the unmarshaled value before unmarshal() returns. For
+    // class instances, the callback may not be invoked until later, because the Slice 1.0
+    // encoding writes instances after the data that references them. The 1.1 encoding is
+    // much more linear, but this extension unmarshals both encodings with the same
+    // callback logic.
     //
     class UnmarshalCallback
     {
@@ -57,28 +63,32 @@ namespace IceRuby
 
         //
         // The unmarshaled() member function receives the unmarshaled value. The
-        // last two arguments are the values passed to unmarshal() for use by
-        // UnmarshalCallback implementations.
+        // next two arguments are the values passed to unmarshal() for use by
+        // UnmarshalCallback implementations, and the last argument is the
+        // StreamUtil attached to the stream.
         //
-        virtual void unmarshaled(VALUE, VALUE, void*) = 0;
+        virtual void unmarshaled(VALUE, VALUE, void*, StreamUtil*) = 0;
     };
     using UnmarshalCallbackPtr = std::shared_ptr<UnmarshalCallback>;
 
     //
     // ReadValueCallback retains all of the information necessary to store an unmarshaled
-    // Slice value as a Ruby object.
+    // Slice value as a Ruby object. Its only owner is the StreamUtil attached to the
+    // stream (the stream's patch entries hold non-owning pointers), so it never outlives
+    // the StreamUtil and _util remains valid for its whole lifetime.
     //
     class ReadValueCallback final
     {
     public:
-        ReadValueCallback(const ClassInfoPtr&, const UnmarshalCallbackPtr&, VALUE, void*);
+        ReadValueCallback(const ClassInfoPtr&, const UnmarshalCallbackPtr&, VALUE, void*, StreamUtil*);
 
         void invoke(const std::shared_ptr<Ice::Value>&);
 
     private:
         ClassInfoPtr _info;
         UnmarshalCallbackPtr _cb;
-        VALUE _target;
+        StreamUtil* _util;
+        long _targetIndex;
         void* _closure;
     };
     using ReadValueCallbackPtr = std::shared_ptr<ReadValueCallback>;
@@ -93,6 +103,12 @@ namespace IceRuby
         StreamUtil();
         ~StreamUtil();
 
+        // Registers a GC root tied to the address of _held, so it's neither copyable nor movable.
+        StreamUtil(const StreamUtil&) = delete;
+        StreamUtil(StreamUtil&&) = delete;
+        StreamUtil& operator=(const StreamUtil&) = delete;
+        StreamUtil& operator=(StreamUtil&&) = delete;
+
         //
         // Keep a reference to a ReadValueCallback for patching purposes.
         //
@@ -103,6 +119,15 @@ namespace IceRuby
         //
         void add(const std::shared_ptr<ValueReader>&);
 
+        //
+        // Keep a Ruby object reachable for the lifetime of the stream and return an index
+        // that recovers it via getHeldValue. The objects are held in a Ruby array whose
+        // elements the GC updates when compaction moves them, so getHeldValue remains
+        // valid where a raw VALUE copy in native code would go stale.
+        //
+        long hold(VALUE);
+        VALUE getHeldValue(long index) const;
+
         //
         // Updated the sliced data information for all stored object instances.
         //
@@ -114,6 +139,7 @@ namespace IceRuby
     private:
         std::vector<ReadValueCallbackPtr> _callbacks;
         std::set<std::shared_ptr<ValueReader>> _readers;
+        VALUE _held; // Ruby array created on first use by hold()
         static VALUE _slicedDataType;
         static VALUE _sliceInfoType;
     };
@@ -134,7 +160,7 @@ namespace IceRuby
 
         virtual bool usesClasses() const; // Default implementation returns false.
 
-        void unmarshaled(VALUE, VALUE, void*) override; // Default implementation is assert(false).
+        void unmarshaled(VALUE, VALUE, void*, StreamUtil*) override; // Default implementation is assert(false).
 
         virtual void destroy();
 
@@ -167,7 +193,6 @@ namespace IceRuby
             KindString
         };
 
-        PrimitiveInfo();
         PrimitiveInfo(Kind);
 
         std::string getId() const final;
@@ -220,7 +245,7 @@ namespace IceRuby
     class DataMember final : public UnmarshalCallback
     {
     public:
-        void unmarshaled(VALUE, VALUE, void*) final;
+        void unmarshaled(VALUE, VALUE, void*, StreamUtil*) final;
 
         std::string name;
         TypeInfoPtr type;
@@ -282,7 +307,7 @@ namespace IceRuby
 
         void marshal(VALUE, Ice::OutputStream*, ValueMap*, bool) final;
         void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool) final;
-        void unmarshaled(VALUE, VALUE, void*) final;
+        void unmarshaled(VALUE, VALUE, void*, StreamUtil*) final;
 
         void print(VALUE, IceInternal::Output&, PrintObjectHistory*) final;
 
@@ -321,7 +346,7 @@ namespace IceRuby
         void marshal(VALUE, Ice::OutputStream*, ValueMap*, bool) final;
         void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool) final;
         void marshalElement(VALUE, VALUE, Ice::OutputStream*, ValueMap*);
-        void unmarshaled(VALUE, VALUE, void*) final;
+        void unmarshaled(VALUE, VALUE, void*, StreamUtil*) final;
 
         void print(VALUE, IceInternal::Output&, PrintObjectHistory*) final;
         void printElement(VALUE, VALUE, IceInternal::Output&, PrintObjectHistory*);
@@ -331,7 +356,7 @@ namespace IceRuby
         class KeyCallback final : public UnmarshalCallback
         {
         public:
-            void unmarshaled(VALUE, VALUE, void*) final;
+            void unmarshaled(VALUE, VALUE, void*, StreamUtil*) final;
 
             VALUE key;
         };
@@ -397,6 +422,8 @@ namespace IceRuby
     public:
         static ProxyInfoPtr create(VALUE);
 
+        // TODO: the 2nd and 3rd parameters are dead code, and should be removed in 3.9.
+        // They cannot be removed yet because slice2rb generated code which passes them in.
         void define(VALUE, VALUE, VALUE);
 
         std::string getId() const final;
@@ -412,14 +439,7 @@ namespace IceRuby
 
         void print(VALUE, IceInternal::Output&, PrintObjectHistory*) final;
 
-        void destroy() final;
-
-        bool isA(const ProxyInfoPtr&);
-
         const std::string id;
-        const bool isBase; // Is this the ClassInfo for Ice::ObjectPrx?
-        const ProxyInfoPtr base;
-        const ProxyInfoList interfaces;
         const VALUE rubyClass;
         const VALUE typeObj;
 
@@ -451,6 +471,12 @@ namespace IceRuby
         ValueWriter(VALUE, ValueMap*, const ClassInfoPtr&);
         ~ValueWriter();
 
+        // Registers a GC root tied to the address of _object, so it's neither copyable nor movable.
+        ValueWriter(const ValueWriter&) = delete;
+        ValueWriter(ValueWriter&&) = delete;
+        ValueWriter& operator=(const ValueWriter&) = delete;
+        ValueWriter& operator=(ValueWriter&&) = delete;
+
         void ice_preMarshal() final;
 
         void _iceWrite(Ice::OutputStream*) const final;
@@ -474,6 +500,12 @@ namespace IceRuby
         ValueReader(VALUE, const ClassInfoPtr&);
         ~ValueReader();
 
+        // Registers a GC root tied to the address of _object, so it's neither copyable nor movable.
+        ValueReader(const ValueReader&) = delete;
+        ValueReader(ValueReader&&) = delete;
+        ValueReader& operator=(const ValueReader&) = delete;
+        ValueReader& operator=(ValueReader&&) = delete;
+
         void ice_postUnmarshal() final;
 
         void _iceWrite(Ice::OutputStream*) const final;
@@ -495,10 +527,18 @@ namespace IceRuby
     class ExceptionReader final : public Ice::UserException
     {
     public:
+        // Each constructor registers a GC root tied to the address of the new instance's _ex member, and the
+        // destructor unregisters it. The copy constructor must remain available: the exception machinery copies the
+        // reader into the exception storage. The other special members are deleted so that none can transfer or
+        // assign _ex without the matching registration.
         ExceptionReader(const ExceptionInfoPtr&);
         ExceptionReader(const ExceptionReader&);
         ~ExceptionReader();
 
+        ExceptionReader(ExceptionReader&&) = delete;
+        ExceptionReader& operator=(const ExceptionReader&) = delete;
+        ExceptionReader& operator=(ExceptionReader&&) = delete;
+
         const char* ice_id() const noexcept final;
         void ice_throw() const final;
 

data/dist/IceRuby/Util.cpp

@@ -9,28 +9,25 @@ using namespace IceRuby;
 
 namespace
 {
-    template<typename T> bool setVersion(VALUE p, const T& version)
+    template<typename T> void setVersion(VALUE p, const T& version)
     {
         volatile VALUE major = callRuby(rb_int2inum, version.major);
         volatile VALUE minor = callRuby(rb_int2inum, version.minor);
         rb_ivar_set(p, rb_intern("@major"), major);
         rb_ivar_set(p, rb_intern("@minor"), minor);
-
-        return true;
     }
 
-    template<typename T> bool getVersion(VALUE p, T& v)
+    template<typename T> void getVersion(VALUE p, T& v)
     {
         volatile VALUE major = callRuby(rb_ivar_get, p, rb_intern("@major"));
         volatile VALUE minor = callRuby(rb_ivar_get, p, rb_intern("@minor"));
 
-        long m;
+        int32_t m;
 
         m = getInteger(major);
         if (m < 0 || m > 255)
         {
             throw RubyException(rb_eTypeError, "version major must be a value between 0 and 255");
-            return false;
         }
         v.major = m;
 
@@ -38,11 +35,8 @@ namespace
         if (m < 0 || m > 255)
         {
             throw RubyException(rb_eTypeError, "version minor must be a value between 0 and 255");
-            return false;
         }
         v.minor = m;
-
-        return true;
     }
 
     template<typename T> VALUE createVersion(const T& version, const char* type)
@@ -51,11 +45,7 @@ namespace
         assert(!NIL_P(rbType));
 
         volatile VALUE obj = callRuby(rb_class_new_instance, 0, static_cast<VALUE*>(0), rbType);
-
-        if (!setVersion<T>(obj, version))
-        {
-            return Qnil;
-        }
+        setVersion<T>(obj, version);
 
         return obj;
     }
@@ -126,13 +116,7 @@ IceRuby::isString(VALUE val)
 bool
 IceRuby::isArray(VALUE val)
 {
-    return TYPE(val) == T_ARRAY || callRuby(rb_respond_to, val, rb_intern("to_arr")) != 0;
-}
-
-bool
-IceRuby::isHash(VALUE val)
-{
-    return TYPE(val) == T_HASH || callRuby(rb_respond_to, val, rb_intern("to_hash")) != 0;
+    return TYPE(val) == T_ARRAY || callRuby(rb_respond_to, val, rb_intern("to_ary")) != 0;
 }
 
 string
@@ -156,17 +140,6 @@ namespace
         T ret;
     };
 
-    //
-    // Wrapper function to call rb_num2long with rb_protect
-    //
-    VALUE
-    rb_num2long_wrapper(VALUE val)
-    {
-        RubyCallArgs<long>* data = (RubyCallArgs<long>*)val;
-        data->ret = rb_num2long(data->val);
-        return val;
-    }
-
     //
     // Wrapper function to call rb_num2ll with rb_protect
     //
@@ -179,17 +152,15 @@ namespace
     }
 }
 
-long
+int32_t
 IceRuby::getInteger(VALUE val)
 {
-    RubyCallArgs<long> arg = {val, -1};
-    int error = 0;
-    rb_protect(rb_num2long_wrapper, (VALUE)&arg, &error);
-    if (error)
+    int64_t value = getLong(val);
+    if (value < INT32_MIN || value > INT32_MAX)
     {
-        throw RubyException(rb_eTypeError, "unable to convert value to an int");
+        throw RubyException(rb_eRangeError, "value is out of the range of a 32-bit integer");
     }
-    return arg.ret;
+    return static_cast<int32_t>(value);
 }
 
 int64_t
@@ -216,7 +187,7 @@ IceRuby::arrayToStringSeq(VALUE val, vector<string>& seq)
     for (long i = 0; i < RARRAY_LEN(arr); ++i)
     {
         string s = getString(RARRAY_AREF(arr, i));
-        seq.push_back(getString(RARRAY_AREF(arr, i)));
+        seq.push_back(std::move(s));
     }
     return true;
 }
@@ -236,21 +207,6 @@ IceRuby::stringSeqToArray(const vector<string>& seq)
     return result;
 }
 
-VALUE
-IceRuby::createNumSeq(const vector<byte>& v)
-{
-    volatile VALUE result = createArray(v.size());
-    long i = 0;
-    if (v.size() > 0)
-    {
-        for (vector<byte>::const_iterator p = v.begin(); p != v.end(); ++p, ++i)
-        {
-            RARRAY_ASET(result, i, INT2FIX(std::to_integer<int>(*p)));
-        }
-    }
-    return result;
-}
-
 namespace
 {
     struct HashToContextIterator : public IceRuby::HashIterator
@@ -298,11 +254,7 @@ IceRuby::contextToHash(const Ice::Context& ctx)
 }
 
 extern "C" VALUE
-#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);
@@ -319,16 +271,6 @@ IceRuby_Util_hash_foreach_callback(VALUE val, VALUE arg, int, VALUE*)
     return val;
 }
 
-extern "C"
-{
-// 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)
 {
@@ -340,7 +282,7 @@ IceRuby::hashIterate(VALUE h, HashIterator& iter)
         rb_intern("each"),
         0,
         static_cast<VALUE*>(0),
-        reinterpret_cast<ICE_RUBY_HASH_FOREACH_CALLBACK>(IceRuby_Util_hash_foreach_callback),
+        IceRuby_Util_hash_foreach_callback,
         reinterpret_cast<VALUE>(&iter));
 }
 
@@ -397,7 +339,7 @@ IceRuby::createEncodingVersion(const Ice::EncodingVersion& v)
     return createVersion<Ice::EncodingVersion>(v, Ice_EncodingVersion);
 }
 
-bool
+void
 IceRuby::getEncodingVersion(VALUE p, Ice::EncodingVersion& v)
 {
     volatile VALUE cls = callRuby(rb_path2class, Ice_EncodingVersion);
@@ -408,12 +350,7 @@ IceRuby::getEncodingVersion(VALUE p, Ice::EncodingVersion& v)
         throw RubyException(rb_eTypeError, "value is not an Ice::EncodingVersion");
     }
 
-    if (!getVersion<Ice::EncodingVersion>(p, v))
-    {
-        return false;
-    }
-
-    return true;
+    getVersion<Ice::EncodingVersion>(p, v);
 }
 
 VALUE
@@ -445,7 +382,6 @@ namespace
     VALUE createRubyException(const char* typeId, std::array<VALUE, N> args, bool fallbackToLocalException = false)
     {
         // Convert the exception's typeId to its mapped Ruby type by removing the leading "::".
-        // This function should only ever be called on Ice local exceptions which don't use 'ruby:identifier'.
         string className = string{typeId}.substr(2);
         assert(className.starts_with("Ice::"));
 

data/dist/IceRuby/Util.h

@@ -51,11 +51,6 @@ namespace IceRuby
     //
     bool isArray(VALUE);
 
-    //
-    // Returns true if the value is a hash or can be converted into a hash.
-    //
-    bool isHash(VALUE);
-
     //
     // Convert a Ruby value into a string. May raise RubyException.
     //
@@ -67,9 +62,10 @@ namespace IceRuby
     VALUE createString(std::string_view);
 
     //
-    // Convert a Ruby value into a long. May raise RubyException.
+    // Convert a Ruby value into an std::int32_t. Raises RangeError if the value is outside the range of a
+    // 32-bit integer. May raise RubyException.
     //
-    long getInteger(VALUE);
+    std::int32_t getInteger(VALUE);
 
     //
     // Convert a Ruby value into an std::int64_t. May raise RubyException.
@@ -89,12 +85,6 @@ namespace IceRuby
     //
     VALUE stringSeqToArray(const std::vector<std::string>&);
 
-    //
-    // Convert a vector of std::byte into a Ruby array of numbers.
-    // May raise RubyException.
-    //
-    VALUE createNumSeq(const std::vector<std::byte>&);
-
     //
     // Convert a Ruby hash to Ice::Context. Returns true on success
     // and false if the value is not a hash. May raise RubyException.
@@ -140,14 +130,14 @@ namespace IceRuby
     VALUE createEncodingVersion(const Ice::EncodingVersion&);
 
     //
-    // Extracts the members of an encoding version.
+    // Extracts the members of an encoding version. May raise RubyException.
     //
-    bool getEncodingVersion(VALUE, Ice::EncodingVersion&);
+    void getEncodingVersion(VALUE, Ice::EncodingVersion&);
 
     //
     // The callRuby functions are used to invoke Ruby C API functions
     // while translating any Ruby exception into RubyException so that
-    // C++ objects are cleaned up properly. Overloadings are provided
+    // C++ objects are cleaned up properly. Overloads are provided
     // to support API functions that accept multiple arguments.
     //
     template<typename Fun> VALUE callRuby(Fun fun);
@@ -306,7 +296,7 @@ namespace IceRuby
     //
     // The callRubyVoid functions are used to invoke Ruby C API functions
     // while translating any Ruby exception into RubyException so that
-    // C++ objects are cleaned up properly. Overloadings are provided
+    // C++ objects are cleaned up properly. Overloads are provided
     // to support API functions that accept multiple arguments.
     //
     template<typename Fun> void callRubyVoid(Fun fun);