zeroc-ice 3.7.11 → 3.8.1

data/dist/IceRuby/Operation.cpp

@@ -1,123 +1,112 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#if defined(__clang__)
-#   pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-#include <Operation.h>
-#include <Proxy.h>
-#include <Types.h>
-#include <Util.h>
-#include <Ice/Communicator.h>
-#include <Ice/Initialize.h>
-#include <Ice/LocalException.h>
-#include <Ice/Logger.h>
-#include <Ice/Properties.h>
-#include <Ice/Proxy.h>
-#include <Slice/RubyUtil.h>
+// Copyright (c) ZeroC, Inc.
+
+#include "Operation.h"
+#include "Communicator.h"
+#include "Ice/Communicator.h"
+#include "Ice/Initialize.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/Logger.h"
+#include "Ice/Properties.h"
+#include "Ice/Proxy.h"
+#include "Proxy.h"
+#include "Types.h"
+#include "Util.h"
+#include "slice2rb/RubyUtil.h"
+
+#include <memory>
 
 using namespace std;
 using namespace IceRuby;
-using namespace Slice::Ruby;
 
 static VALUE _operationClass;
 
 namespace IceRuby
 {
+    class ParamInfo final : public UnmarshalCallback
+    {
+    public:
+        void unmarshaled(VALUE, VALUE, void*) final;
 
-class ParamInfo : public UnmarshalCallback
-{
-public:
-
-    virtual void unmarshaled(VALUE, VALUE, void*);
-
-    TypeInfoPtr type;
-    bool optional;
-    int tag;
-    int pos;
-};
-typedef IceUtil::Handle<ParamInfo> ParamInfoPtr;
-typedef list<ParamInfoPtr> ParamInfoList;
-
-class OperationI : public Operation
-{
-public:
-
-    OperationI(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE);
-
-    virtual VALUE invoke(const Ice::ObjectPrx&, VALUE, VALUE);
-    virtual void deprecate(const string&);
-
-private:
-
-    string _name;
-    Ice::OperationMode _mode;
-    Ice::OperationMode _sendMode;
-    bool _amd;
-    Ice::FormatType _format;
-    ParamInfoList _inParams;
-    ParamInfoList _optionalInParams;
-    ParamInfoList _outParams;
-    ParamInfoList _optionalOutParams;
-    ParamInfoPtr _returnType;
-    ExceptionInfoList _exceptions;
-    string _dispatchName;
-    bool _sendsClasses;
-    bool _returnsClasses;
-    string _deprecateMessage;
-
-    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&);
-    bool validateException(VALUE) const;
-    void checkTwowayOnly(const Ice::ObjectPrx&) const;
-};
-typedef IceUtil::Handle<OperationI> OperationIPtr;
-
-class UserExceptionFactory : public Ice::UserExceptionFactory
-{
-public:
+        TypeInfoPtr type;
+        bool optional;
+        int tag;
+        int pos;
+    };
+    using ParamInfoPtr = shared_ptr<ParamInfo>;
+    using ParamInfoList = list<ParamInfoPtr>;
 
-    virtual void createAndThrow(const string& id)
+    class OperationI final : public Operation
     {
-        ExceptionInfoPtr info = lookupExceptionInfo(id);
-        if(info)
-        {
-            throw ExceptionReader(info);
-        }
-    }
-};
-
+    public:
+        OperationI(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE);
+
+        VALUE invoke(const Ice::ObjectPrx&, VALUE, VALUE) final;
+        void deprecate(const string&) final;
+
+    private:
+        string _sliceName;
+        string _mappedName;
+        Ice::OperationMode _mode;
+        std::optional<Ice::FormatType> _format;
+        ParamInfoList _inParams;
+        ParamInfoList _optionalInParams;
+        ParamInfoList _outParams;
+        ParamInfoList _optionalOutParams;
+        ParamInfoPtr _returnType;
+        ExceptionInfoList _exceptions;
+        bool _sendsClasses;
+        bool _returnsClasses;
+        string _deprecateMessage;
+
+        void convertParams(VALUE, ParamInfoList&, long, bool&);
+        ParamInfoPtr convertParam(VALUE, long);
+        void prepareRequest(const Ice::ObjectPrx&, VALUE, Ice::OutputStream*, pair<const byte*, const byte*>&);
+        VALUE unmarshalResults(const vector<byte>&, const Ice::CommunicatorPtr&);
+        VALUE unmarshalException(const vector<byte>&, const Ice::CommunicatorPtr&);
+        bool validateException(VALUE) const;
+        void checkTwowayOnly(const Ice::ObjectPrx&) const;
+    };
+    using OperationIPtr = shared_ptr<OperationI>;
 }
 
-extern "C"
-void
-IceRuby_Operation_free(OperationPtr* p)
+extern "C" void
+IceRuby_Operation_free(void* p)
 {
-    delete p;
+    delete static_cast<OperationPtr*>(p);
 }
 
-extern "C"
-VALUE
-IceRuby_defineOperation(VALUE /*self*/, VALUE name, VALUE mode, VALUE sendMode, VALUE amd, VALUE format, VALUE inParams,
-                        VALUE outParams, VALUE returnType, VALUE exceptions)
+static const rb_data_type_t IceRuby_OperationType = {
+    .wrap_struct_name = "Ice::Operation",
+    .function =
+        {
+            .dfree = IceRuby_Operation_free,
+        },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+extern "C" VALUE
+IceRuby_defineOperation(
+    VALUE /*self*/,
+    VALUE sliceName,
+    VALUE mappedName,
+    VALUE mode,
+    VALUE format,
+    VALUE inParams,
+    VALUE outParams,
+    VALUE returnType,
+    VALUE exceptions)
 {
     ICE_RUBY_TRY
     {
-        OperationIPtr op = new OperationI(name, mode, sendMode, amd, format, inParams, outParams, returnType,
-                                          exceptions);
-        return Data_Wrap_Struct(_operationClass, 0, IceRuby_Operation_free, new OperationPtr(op));
+        OperationIPtr op =
+            make_shared<OperationI>(sliceName, mappedName, mode, format, inParams, outParams, returnType, exceptions);
+        return TypedData_Wrap_Struct(_operationClass, &IceRuby_OperationType, new OperationPtr(op));
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Operation_invoke(VALUE self, VALUE proxy, VALUE opArgs, VALUE ctx)
 {
     ICE_RUBY_TRY
@@ -132,8 +121,7 @@ IceRuby_Operation_invoke(VALUE self, VALUE proxy, VALUE opArgs, VALUE ctx)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Operation_deprecate(VALUE self, VALUE msg)
 {
     ICE_RUBY_TRY
@@ -149,9 +137,7 @@ IceRuby_Operation_deprecate(VALUE self, VALUE msg)
 //
 // Operation implementation.
 //
-IceRuby::Operation::~Operation()
-{
-}
+IceRuby::Operation::~Operation() = default;
 
 //
 // ParamInfo implementation.
@@ -160,30 +146,26 @@ void
 IceRuby::ParamInfo::unmarshaled(VALUE val, VALUE target, void* closure)
 {
     assert(TYPE(target) == T_ARRAY);
-#ifdef ICE_64
-    long i = static_cast<long>(reinterpret_cast<long long>(closure));
-#else
+    static_assert(sizeof(long) == sizeof(void*), "long and void* must have the same size");
     long i = reinterpret_cast<long>(closure);
-#endif
     RARRAY_ASET(target, i, val);
 }
 
 //
 // OperationI implementation.
 //
-IceRuby::OperationI::OperationI(VALUE name, VALUE mode, VALUE sendMode, VALUE amd, VALUE format, VALUE inParams,
-                                VALUE outParams, VALUE returnType, VALUE exceptions)
+IceRuby::OperationI::OperationI(
+    VALUE name,
+    VALUE mapped,
+    VALUE mode,
+    VALUE format,
+    VALUE inParams,
+    VALUE outParams,
+    VALUE returnType,
+    VALUE exceptions)
 {
-    _name = getString(name);
-    _amd = amd == Qtrue;
-    if(_amd)
-    {
-        _dispatchName = fixIdent(_name, IdentNormal) + "_async";
-    }
-    else
-    {
-        _dispatchName = fixIdent(_name, IdentNormal);
-    }
+    _sliceName = getString(name);
+    _mappedName = getString(mapped);
 
     //
     // mode
@@ -192,19 +174,12 @@ IceRuby::OperationI::OperationI(VALUE name, VALUE mode, VALUE sendMode, VALUE am
     assert(TYPE(modeValue) == T_FIXNUM);
     _mode = static_cast<Ice::OperationMode>(FIX2LONG(modeValue));
 
-    //
-    // sendMode
-    //
-    volatile VALUE sendModeValue = callRuby(rb_funcall, sendMode, rb_intern("to_i"), 0);
-    assert(TYPE(sendModeValue) == T_FIXNUM);
-    _sendMode = static_cast<Ice::OperationMode>(FIX2LONG(sendModeValue));
-
     //
     // format
     //
-    if(format == Qnil)
+    if (format == Qnil)
     {
-        _format = Ice::DefaultFormat;
+        _format = std::nullopt;
     }
     else
     {
@@ -217,13 +192,10 @@ IceRuby::OperationI::OperationI(VALUE name, VALUE mode, VALUE sendMode, VALUE am
     // returnType
     //
     _returnsClasses = false;
-    if(!NIL_P(returnType))
+    if (!NIL_P(returnType))
     {
         _returnType = convertParam(returnType, 0);
-        if(!_returnType->optional)
-        {
-            _returnsClasses = _returnType->type->usesClasses();
-        }
+        _returnsClasses = _returnType->type->usesClasses();
     }
 
     //
@@ -240,15 +212,9 @@ IceRuby::OperationI::OperationI(VALUE name, VALUE mode, VALUE sendMode, VALUE am
     class SortFn
     {
     public:
-        static bool compare(const ParamInfoPtr& lhs, const ParamInfoPtr& rhs)
-        {
-            return lhs->tag < rhs->tag;
-        }
+        static bool compare(const ParamInfoPtr& lhs, const ParamInfoPtr& rhs) { return lhs->tag < rhs->tag; }
 
-        static bool isRequired(const ParamInfoPtr& i)
-        {
-            return !i->optional;
-        }
+        static bool isRequired(const ParamInfoPtr& i) { return !i->optional; }
     };
 
     //
@@ -266,7 +232,7 @@ IceRuby::OperationI::OperationI(VALUE name, VALUE mode, VALUE sendMode, VALUE am
     //
     l = _outParams;
     copy(l.begin(), remove_if(l.begin(), l.end(), SortFn::isRequired), back_inserter(_optionalOutParams));
-    if(_returnType && _returnType->optional)
+    if (_returnType && _returnType->optional)
     {
         _optionalOutParams.push_back(_returnType);
     }
@@ -275,7 +241,7 @@ IceRuby::OperationI::OperationI(VALUE name, VALUE mode, VALUE sendMode, VALUE am
     //
     // exceptions
     //
-    for(long i = 0; i < RARRAY_LEN(exceptions); ++i)
+    for (long i = 0; i < RARRAY_LEN(exceptions); ++i)
     {
         _exceptions.push_back(getException(RARRAY_AREF(exceptions, i)));
     }
@@ -290,10 +256,10 @@ IceRuby::OperationI::invoke(const Ice::ObjectPrx& proxy, VALUE args, VALUE hctx)
     // Marshal the input parameters to a byte sequence.
     //
     Ice::OutputStream os(communicator);
-    pair<const Ice::Byte*, const Ice::Byte*> params;
+    pair<const byte*, const byte*> params;
     prepareRequest(proxy, args, &os, params);
 
-    if(!_deprecateMessage.empty())
+    if (!_deprecateMessage.empty())
     {
         rb_warning("%s", _deprecateMessage.c_str());
         _deprecateMessage.clear(); // Only show the warning once.
@@ -307,27 +273,27 @@ IceRuby::OperationI::invoke(const Ice::ObjectPrx& proxy, VALUE args, VALUE hctx)
     Ice::ByteSeq result;
     bool status;
 
-    if(!NIL_P(hctx))
+    if (!NIL_P(hctx))
     {
         Ice::Context ctx;
-        if(!hashToContext(hctx, ctx))
+        if (!hashToContext(hctx, ctx))
         {
             throw RubyException(rb_eArgError, "context argument must be nil or a hash");
         }
 
-        status = proxy->ice_invoke(_name, _sendMode, params, result, ctx);
+        status = proxy->ice_invoke(_sliceName, _mode, params, result, ctx);
     }
     else
     {
-        status = proxy->ice_invoke(_name, _sendMode, params, result);
+        status = proxy->ice_invoke(_sliceName, _mode, params, result);
     }
 
     //
     // Process the reply.
     //
-    if(proxy->ice_isTwoway())
+    if (proxy->ice_isTwoway())
     {
-        if(!status)
+        if (!status)
         {
             //
             // Unmarshal a user exception.
@@ -335,7 +301,7 @@ IceRuby::OperationI::invoke(const Ice::ObjectPrx& proxy, VALUE args, VALUE hctx)
             volatile VALUE ex = unmarshalException(result, communicator);
             throw RubyException(ex);
         }
-        else if(_outParams.size() > 0 || _returnType)
+        else if (_outParams.size() > 0 || _returnType)
         {
             //
             // Unmarshal the results. If there is more than one value to be returned, then return them
@@ -343,7 +309,7 @@ IceRuby::OperationI::invoke(const Ice::ObjectPrx& proxy, VALUE args, VALUE hctx)
             //
             volatile VALUE results = unmarshalResults(result, communicator);
 
-            if(RARRAY_LEN(results)> 1)
+            if (RARRAY_LEN(results) > 1)
             {
                 return results;
             }
@@ -360,13 +326,13 @@ IceRuby::OperationI::invoke(const Ice::ObjectPrx& proxy, VALUE args, VALUE hctx)
 void
 IceRuby::OperationI::deprecate(const string& msg)
 {
-    if(!msg.empty())
+    if (!msg.empty())
     {
         _deprecateMessage = msg;
     }
     else
     {
-        _deprecateMessage = "operation " + _name + " is deprecated";
+        _deprecateMessage = "operation " + _mappedName + " is deprecated";
     }
 }
 
@@ -375,11 +341,11 @@ IceRuby::OperationI::convertParams(VALUE v, ParamInfoList& params, long posOffse
 {
     assert(TYPE(v) == T_ARRAY);
 
-    for(long i = 0; i < RARRAY_LEN(v); ++i)
+    for (long i = 0; i < RARRAY_LEN(v); ++i)
     {
         ParamInfoPtr param = convertParam(RARRAY_AREF(v, i), i + posOffset);
         params.push_back(param);
-        if(!param->optional && !usesClasses)
+        if (!param->optional && !usesClasses)
         {
             usesClasses = param->type->usesClasses();
         }
@@ -390,7 +356,7 @@ ParamInfoPtr
 IceRuby::OperationI::convertParam(VALUE v, long pos)
 {
     assert(TYPE(v) == T_ARRAY);
-    ParamInfoPtr param = new ParamInfo;
+    ParamInfoPtr param = make_shared<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)));
@@ -399,74 +365,78 @@ IceRuby::OperationI::convertParam(VALUE v, long pos)
 }
 
 void
-IceRuby::OperationI::prepareRequest(const Ice::ObjectPrx& proxy, VALUE args, Ice::OutputStream* os,
-                                    pair<const Ice::Byte*, const Ice::Byte*>& params)
+IceRuby::OperationI::prepareRequest(
+    const Ice::ObjectPrx& proxy,
+    VALUE args,
+    Ice::OutputStream* os,
+    pair<const byte*, const byte*>& params)
 {
-    params.first = params.second = static_cast<const Ice::Byte*>(0);
+    params.first = params.second = static_cast<const byte*>(0);
 
     //
     // Validate the number of arguments.
     //
     long argc = RARRAY_LEN(args);
     long paramCount = static_cast<long>(_inParams.size());
-    if(argc != paramCount)
+    if (argc != paramCount)
     {
-        string fixedName = fixIdent(_name, IdentNormal);
-        throw RubyException(rb_eArgError, "%s expects %ld in parameters", fixedName.c_str(), paramCount);
+        throw RubyException(rb_eArgError, "%s expects %ld in parameters", _mappedName.c_str(), paramCount);
     }
 
-    if(!_inParams.empty())
+    if (!_inParams.empty())
     {
         //
         // Marshal the in parameters.
         //
         os->startEncapsulation(proxy->ice_getEncodingVersion(), _format);
 
-        ObjectMap objectMap;
+        ValueMap valueMap;
         ParamInfoList::iterator p;
 
         //
         // Validate the supplied arguments.
         //
-        for(p = _inParams.begin(); p != _inParams.end(); ++p)
+        for (p = _inParams.begin(); p != _inParams.end(); ++p)
         {
             ParamInfoPtr info = *p;
             volatile VALUE arg = RARRAY_AREF(args, info->pos);
-            if((!info->optional || arg != Unset) && !info->type->validate(arg))
+            if ((!info->optional || arg != Qnil) && !info->type->validate(arg))
             {
-                string opName = fixIdent(_name, IdentNormal);
-                throw RubyException(rb_eTypeError, "invalid value for argument %ld in operation `%s'", info->pos + 1,
-                                    opName.c_str());
+                throw RubyException(
+                    rb_eTypeError,
+                    "invalid value for argument %ld in operation `%s'",
+                    info->pos + 1,
+                    _mappedName.c_str());
             }
         }
 
         //
         // Marshal the required parameters.
         //
-        for(p = _inParams.begin(); p != _inParams.end(); ++p)
+        for (p = _inParams.begin(); p != _inParams.end(); ++p)
         {
             ParamInfoPtr info = *p;
-            if(!info->optional)
+            if (!info->optional)
             {
                 volatile VALUE arg = RARRAY_AREF(args, info->pos);
-                info->type->marshal(arg, os, &objectMap, false);
+                info->type->marshal(arg, os, &valueMap, false);
             }
         }
 
         //
         // Marshal the optional parameters.
         //
-        for(p = _optionalInParams.begin(); p != _optionalInParams.end(); ++p)
+        for (p = _optionalInParams.begin(); p != _optionalInParams.end(); ++p)
         {
             ParamInfoPtr info = *p;
             volatile VALUE arg = RARRAY_AREF(args, info->pos);
-            if(arg != Unset && os->writeOptional(info->tag, info->type->optionalFormat()))
+            if (arg != Qnil && os->writeOptional(info->tag, info->type->optionalFormat()))
             {
-                info->type->marshal(arg, os, &objectMap, true);
+                info->type->marshal(arg, os, &valueMap, true);
             }
         }
 
-        if(_sendsClasses)
+        if (_sendsClasses)
         {
             os->writePendingValues();
         }
@@ -477,10 +447,10 @@ IceRuby::OperationI::prepareRequest(const Ice::ObjectPrx& proxy, VALUE args, Ice
 }
 
 VALUE
-IceRuby::OperationI::unmarshalResults(const vector<Ice::Byte>& bytes, const Ice::CommunicatorPtr& communicator)
+IceRuby::OperationI::unmarshalResults(const vector<byte>& bytes, const Ice::CommunicatorPtr& communicator)
 {
     int numResults = static_cast<int>(_outParams.size());
-    if(_returnType)
+    if (_returnType)
     {
         numResults++;
     }
@@ -492,11 +462,11 @@ IceRuby::OperationI::unmarshalResults(const vector<Ice::Byte>& bytes, const Ice:
     // Unmarshal the results. If there is more than one value to be returned, then return them
     // in a tuple of the form (result, outParam1, ...). Otherwise just return the value.
     //
-    Ice::InputStream is(communicator, bytes);
+    Ice::InputStream is{communicator, bytes, lookupSliceLoader(communicator)};
 
     //
     // Store a pointer to a local StreamUtil object as the stream's closure.
-    // This is necessary to support object unmarshaling (see ObjectReader).
+    // This is necessary to support object unmarshaling (see ValueReader).
     //
     StreamUtil util;
     assert(!is.getClosure());
@@ -509,10 +479,10 @@ IceRuby::OperationI::unmarshalResults(const vector<Ice::Byte>& bytes, const Ice:
     //
     // Unmarshal the required out parameters.
     //
-    for(p = _outParams.begin(); p != _outParams.end(); ++p)
+    for (p = _outParams.begin(); p != _outParams.end(); ++p)
     {
         ParamInfoPtr info = *p;
-        if(!info->optional)
+        if (!info->optional)
         {
             void* closure = reinterpret_cast<void*>(info->pos);
             info->type->unmarshal(&is, info, results, closure, false);
@@ -522,7 +492,7 @@ IceRuby::OperationI::unmarshalResults(const vector<Ice::Byte>& bytes, const Ice:
     //
     // Unmarshal the required return value, if any.
     //
-    if(_returnType && !_returnType->optional)
+    if (_returnType && !_returnType->optional)
     {
         assert(_returnType->pos == 0);
         void* closure = reinterpret_cast<void*>(_returnType->pos);
@@ -532,21 +502,21 @@ IceRuby::OperationI::unmarshalResults(const vector<Ice::Byte>& bytes, const Ice:
     //
     // Unmarshal the optional results. This includes an optional return value.
     //
-    for(p = _optionalOutParams.begin(); p != _optionalOutParams.end(); ++p)
+    for (p = _optionalOutParams.begin(); p != _optionalOutParams.end(); ++p)
     {
         ParamInfoPtr info = *p;
-        if(is.readOptional(info->tag, info->type->optionalFormat()))
+        if (is.readOptional(info->tag, info->type->optionalFormat()))
         {
             void* closure = reinterpret_cast<void*>(info->pos);
             info->type->unmarshal(&is, info, results, closure, true);
         }
         else
         {
-            RARRAY_ASET(results, info->pos, Unset);
+            RARRAY_ASET(results, info->pos, Qnil);
         }
     }
 
-    if(_returnsClasses)
+    if (_returnsClasses)
     {
         is.readPendingValues();
     }
@@ -559,13 +529,13 @@ IceRuby::OperationI::unmarshalResults(const vector<Ice::Byte>& bytes, const Ice:
 }
 
 VALUE
-IceRuby::OperationI::unmarshalException(const vector<Ice::Byte>& bytes, const Ice::CommunicatorPtr& communicator)
+IceRuby::OperationI::unmarshalException(const vector<byte>& bytes, const Ice::CommunicatorPtr& communicator)
 {
-    Ice::InputStream is(communicator, bytes);
+    Ice::InputStream is{communicator, bytes, lookupSliceLoader(communicator)};
 
     //
     // Store a pointer to a local StreamUtil object as the stream's closure.
-    // This is necessary to support object unmarshaling (see ObjectReader).
+    // This is necessary to support object unmarshaling (see ValueReader).
     //
     StreamUtil util;
     assert(!is.getClosure());
@@ -575,50 +545,40 @@ IceRuby::OperationI::unmarshalException(const vector<Ice::Byte>& bytes, const Ic
 
     try
     {
-        Ice::UserExceptionFactoryPtr factory = new UserExceptionFactory;
-        is.throwException(factory);
+        is.throwException();
+        assert(false); // throwException always throws an exception
     }
-    catch(const ExceptionReader& r)
+    catch (const ExceptionReader& r)
     {
         is.endEncapsulation();
 
         volatile VALUE ex = r.getException();
 
-        if(validateException(ex))
+        if (validateException(ex))
         {
-            util.updateSlicedData();
-
-            Ice::SlicedDataPtr slicedData = r.getSlicedData();
-            if(slicedData)
-            {
-                StreamUtil::setSlicedDataMember(ex, slicedData);
-            }
-
             return ex;
         }
         else
         {
-            volatile VALUE cls = CLASS_OF(ex);
-            volatile VALUE path = callRuby(rb_class_path, cls);
-            assert(TYPE(path) == T_STRING);
-            Ice::UnknownUserException e(__FILE__, __LINE__);
-            e.unknown = RSTRING_PTR(path);
-            throw e;
+            return convertException(
+                make_exception_ptr(Ice::UnknownUserException::fromTypeId(__FILE__, __LINE__, r.ice_id())));
         }
     }
+    catch (...)
+    {
+        return convertException(std::current_exception());
+    }
 
-    throw Ice::UnknownUserException(__FILE__, __LINE__, "unknown exception");
-#ifdef __SUNPRO_CC
-    return 0;
-#endif
+    // Never reached.
+    return Qnil;
 }
 
 bool
 IceRuby::OperationI::validateException(VALUE ex) const
 {
-    for(ExceptionInfoList::const_iterator p = _exceptions.begin(); p != _exceptions.end(); ++p)
+    for (ExceptionInfoList::const_iterator p = _exceptions.begin(); p != _exceptions.end(); ++p)
     {
-        if(callRuby(rb_obj_is_kind_of, ex, (*p)->rubyClass))
+        if (callRuby(rb_obj_is_kind_of, ex, (*p)->rubyClass))
         {
             return true;
         }
@@ -630,18 +590,16 @@ IceRuby::OperationI::validateException(VALUE ex) const
 void
 IceRuby::OperationI::checkTwowayOnly(const Ice::ObjectPrx& proxy) const
 {
-    if((_returnType != 0 || !_outParams.empty()) && !proxy->ice_isTwoway())
+    if ((_returnType != 0 || !_outParams.empty()) && !proxy->ice_isTwoway())
     {
-        Ice::TwowayOnlyException ex(__FILE__, __LINE__);
-        ex.operation = _name;
-        throw ex;
+        throw Ice::TwowayOnlyException{__FILE__, __LINE__, _sliceName};
     }
 }
 
 bool
 IceRuby::initOperation(VALUE iceModule)
 {
-    rb_define_module_function(iceModule, "__defineOperation", CAST_METHOD(IceRuby_defineOperation), 9);
+    rb_define_module_function(iceModule, "__defineOperation", CAST_METHOD(IceRuby_defineOperation), 8);
 
     //
     // Define a class to represent an operation.