zeroc-ice 3.7.3 → 3.7.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f061772e9d3a2a709e480d9bd0d028110838d15529c793b34367253782d649db
-  data.tar.gz: b451ddd683af4bbc6e948d76dce911204ff6c1b4314143e285b89f656ae8f0e4
+  metadata.gz: cff48e9f22f45608f28bf0b3ba75a93c4dda74bff3b4de7fee4bf135a40cc46c
+  data.tar.gz: 8554d36b0529c6be6828682a00874c85de26145421b62eb6d487df33814a737f
 SHA512:
-  metadata.gz: 943b478cf1ecdfb5e4332271fd025e8153b2c0a595ef7c96ce260d3d0a8caaffff2c1b5827166f687650d6fc6685f3e8c0f1c1fdd4090f7aecbb4ef237d8623a
-  data.tar.gz: 289327d910be75354d258ebc41eb31d2583738cd5b3fc7f43130442d87803000b9dac8787fd0b3ee9874bbf107606ad9c9ae12ac7a7c06f6aa9bd9f942cfdbf4
+  metadata.gz: 82c9091136257ab107583fa77daed2acab9c2ca00d2b94511437169ace8efbb8bc212df48efbd88728dd53568e3f52cec8ec851397b1182e24d0b8e913bac289
+  data.tar.gz: dd022772296e7269f6c58d726b3fcc941d6980f54d818bf648b62246101ca669de2bffd2faa258e62a0498baf0504c72a91922c4894080811a8f74012d73f699

data/ext/Communicator.cpp

@@ -207,6 +207,9 @@ IceRuby_initialize(int argc, VALUE* argv, VALUE /*self*/)
             data.properties = Ice::createProperties(seq, data.properties);
         }
 
+        // Always accept cycles in Ruby
+        data.properties->setProperty("Ice.AcceptClassCycles", "1");
+
         //
         // Remaining command line options are passed to the communicator
         // as an argument vector in case they contain plugin properties.

data/ext/Config.h

@@ -51,15 +51,26 @@
 // BUGFIX: Workaround unused parameter in ruby.h header file
 //
 #if defined(__clang__)
+// BUFIX: Workaround clang 13 warnings during ruby macro expansion, it is important to put this before the push/pop
+// directives to keep the warnings ignored in the source files where macros are expanded.
+#   if __clang_major__ >= 13
+#       pragma clang diagnostic ignored "-Wcompound-token-split-by-macro"
+#   endif
 #   pragma clang diagnostic push
 #   pragma clang diagnostic ignored "-Wunused-parameter"
 //
 // BUGFIX: Workaround clang conversion warnings in ruby headers
 //
 #   pragma clang diagnostic ignored "-Wconversion"
+
+// Silence warnings regarding missing deprecation attributes in ruby headers
+#   pragma clang diagnostic ignored "-Wdocumentation-deprecated-sync"
 #elif defined(__GNUC__)
 #   pragma GCC diagnostic push
 #   pragma GCC diagnostic ignored "-Wunused-parameter"
+// BUGFIX Workaround G++ 10 problem with ruby headers
+// see https://bugs.ruby-lang.org/issues/16930
+#   pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 #endif
 
 #include <ruby.h>

data/ext/Types.cpp

@@ -1853,7 +1853,18 @@ IceRuby::DictionaryInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallback
         //
         keyType->unmarshal(is, keyCB, Qnil, 0, false);
         assert(!NIL_P(keyCB->key));
-
+        if (valueType->usesClasses())
+        {
+            // Temporarily set the entry with a Qnil value to ensure the key is not GC
+            // while unmarshaling a value class
+            if (RB_TYPE_P(keyCB->key, T_STRING))
+            {
+                // For string keys create a frozen string to ensure that the key used
+                // in the map matches the one keep in the closure
+                keyCB->key = rb_str_new_frozen(keyCB->key);
+            }
+            callRuby(rb_hash_aset, hash, keyCB->key, Qnil);
+        }
         //
         // The callback will set the dictionary entry with the unmarshaled value,
         // so we pass it the key.
@@ -2744,7 +2755,10 @@ IceRuby::ReadObjectCallback::invoke(const Ice::ObjectPtr& p)
             ex.expectedType = _info->id;
             throw ex;
         }
-
+#ifndef NDEBUG
+        // With debug builds we force a GC to ensure that all data members are correctly keep alive.
+        rb_gc();
+#endif
         _cb->unmarshaled(obj, _target, _closure);
     }
     else
@@ -2875,6 +2889,7 @@ IceRuby::ExceptionReader::ExceptionReader(const ExceptionInfoPtr& info) :
 IceRuby::ExceptionReader::~ExceptionReader()
     throw()
 {
+    rb_gc_unregister_address(&_ex);
 }
 
 string
@@ -2910,6 +2925,7 @@ IceRuby::ExceptionReader::_read(Ice::InputStream* is)
     is->startException();
 
     const_cast<VALUE&>(_ex) = _info->unmarshal(is);
+    rb_gc_register_address(&_ex);
 
     const_cast<Ice::SlicedDataPtr&>(_slicedData) = is->endException(_info->preserve);
 }

data/ext/Util.cpp

@@ -448,7 +448,11 @@ IceRuby::contextToHash(const Ice::Context& ctx)
 
 extern "C"
 VALUE
-IceRuby_Util_hash_foreach_callback(VALUE val, VALUE arg)
+#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);
@@ -467,14 +471,22 @@ IceRuby_Util_hash_foreach_callback(VALUE val, VALUE arg)
 
 extern "C"
 {
-typedef VALUE (*ICE_RUBY_HASH_FOREACH_CALLBACK)(...);
+
+// 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)
 {
     assert(TYPE(h) == T_HASH);
-    callRuby(rb_iterate, rb_each, h,
+
+    callRuby(::rb_block_call, h, rb_intern("each"), 0, static_cast<VALUE*>(0),
              reinterpret_cast<ICE_RUBY_HASH_FOREACH_CALLBACK>(IceRuby_Util_hash_foreach_callback),
              reinterpret_cast<VALUE>(&iter));
 }

data/ext/Util.h

@@ -175,6 +175,9 @@ VALUE callRuby(Fun fun, T1 t1, T2 t2, T3 t3);
 template<typename Fun, typename T1, typename T2, typename T3, typename T4>
 VALUE callRuby(Fun fun, T1 t1, T2 t2, T3 t3, T4 t4);
 
+template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+VALUE callRuby(Fun fun, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6);
+
 extern "C" typedef VALUE (*RubyFunction)(VALUE);
 
 VALUE callProtected(RubyFunction, VALUE);
@@ -314,6 +317,39 @@ inline VALUE callRuby(Fun fun, T1 t1, T2 t2, T3 t3, T4 t4)
     return callProtected(RF::call, reinterpret_cast<VALUE>(&f));
 }
 
+template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+class RF_6
+{
+public:
+
+    RF_6(Fun f, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) : _f(f), _t1(t1), _t2(t2), _t3(t3), _t4(t4), _t5(t5), _t6(t6)
+    {
+    }
+    inline VALUE operator()() { return _f(_t1, _t2, _t3, _t4, _t5, _t6); }
+    static inline VALUE call(VALUE f)
+    {
+        return (*reinterpret_cast<RF_6*>(f))();
+    }
+
+private:
+
+    Fun _f;
+    T1 _t1;
+    T2 _t2;
+    T3 _t3;
+    T4 _t4;
+    T5 _t5;
+    T6 _t6;
+};
+
+template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+inline VALUE callRuby(Fun fun, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)
+{
+    typedef RF_6<Fun, T1, T2, T3, T4, T5, T6> RF;
+    RF f(fun, t1, t2, t3, t4, t5, t6);
+    return callProtected(RF::call, reinterpret_cast<VALUE>(&f));
+}
+
 //
 // The callRubyVoid functions are used to invoke Ruby C API functions
 // while translating any Ruby exception into RubyException so that

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

@@ -44,7 +44,7 @@ public:
 #endif
 
     /**
-     * Polymporphically clones this exception.
+     * Polymorphically clones this exception.
      * @return A shallow copy of this exception.
      */
 #ifdef ICE_CPP11_MAPPING
@@ -69,7 +69,7 @@ class ICE_API UserException : public IceUtil::Exception
 public:
 
     /**
-     * Polymporphically clones this exception.
+     * Polymorphically clones this exception.
      * @return A shallow copy of this exception.
      */
 #ifdef ICE_CPP11_MAPPING
@@ -126,7 +126,7 @@ public:
 #endif
 
     /**
-     * Polymporphically clones this exception.
+     * Polymorphically clones this exception.
      * @return A shallow copy of this exception.
      */
 #ifdef ICE_CPP11_MAPPING

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

@@ -5,7 +5,9 @@
 #ifndef ICE_FUNCTIONAL_H
 #define ICE_FUNCTIONAL_H
 
-#ifndef ICE_CPP11_MAPPING
+#include <IceUtil/Config.h>
+
+#if !defined(ICE_CPP11_MAPPING) && (ICE_CPLUSPLUS < 201703L)
 
 #include <IceUtil/Functional.h>
 #include <Ice/Handle.h>

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

@@ -65,7 +65,7 @@ public:
 
 #ifndef ICE_CPP11_MAPPING
     /**
-     * Polymporphically clones this exception.
+     * Polymorphically clones this exception.
      * @return A shallow copy of this exception.
      */
     virtual IconvInitializationException* ice_clone() const;

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

@@ -682,7 +682,7 @@ public:
      * it will be destroyed.
      * @param holder The holder from which to adopt a communicator.
      */
-    CommunicatorHolder& operator=(CommunicatorHolder&& holder);
+    CommunicatorHolder& operator=(CommunicatorHolder&& holder) noexcept;
 
     /**
      * Determines whether the holder contains an instance.

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

@@ -329,7 +329,14 @@ public:
 protected:
 
     Object() {} // This class is abstract.
+#if defined(__clang__)
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wdeprecated-copy-dtor"
+#endif
     virtual ~Object() {}
+#if defined(__clang__)
+#   pragma clang diagnostic pop
+#endif
 
 protected:
 

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

@@ -210,7 +210,7 @@ template <class T> inline constexpr typename std::remove_reference<T>::type&& co
 #if defined NDEBUG
 # define TR2_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) (EXPR)
 #else
-# define TR2_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) ((CHECK) ? (EXPR) : ([]{assert(!#CHECK);}(), (EXPR)))
+# define TR2_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) ((CHECK) ? (EXPR) : ([]{assert(false && #CHECK);}(), (EXPR)))
 #endif
 
 namespace detail_

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

@@ -463,7 +463,12 @@ public:
                    std::function<void(bool)> sent) :
         OutgoingAsyncT<R>(proxy, false), LambdaInvoke(std::move(ex), std::move(sent))
     {
+#if ICE_CPLUSPLUS >= 201402L
+        // Move capture with C++14
+        _response = [this, response = std::move(response)](bool ok)
+#else
         _response = [this, response](bool ok)
+#endif
         {
             if(!ok)
             {
@@ -499,7 +504,12 @@ public:
                    std::function<void(bool)> sent) :
         OutgoingAsyncT<void>(proxy, false), LambdaInvoke(std::move(ex), std::move(sent))
     {
+#if ICE_CPLUSPLUS >= 201402L
+        // Move capture with C++14
+        _response = [this, response = std::move(response)](bool ok)
+#else
         _response = [this, response](bool ok)
+#endif
         {
             if(!ok)
             {
@@ -535,7 +545,12 @@ public:
                          std::function<void(bool)> sent) :
         OutgoingAsync(proxy, false), LambdaInvoke(std::move(ex), std::move(sent))
     {
+#if ICE_CPLUSPLUS >= 201402L
+        // Move capture with C++14
+        _response = [this, read = std::move(read)](bool ok)
+#else
         _response = [this, read](bool ok)
+#endif
         {
             if(!ok)
             {

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

@@ -178,7 +178,12 @@ public:
     {
         if(response)
         {
+#if ICE_CPLUSPLUS >= 201402L
+            // Move capture with C++14
+            _response = [this, response = std::move(response)](bool ok)
+#else
             _response = [this, response](bool ok)
+#endif
             {
                 if(this->_is.b.empty())
                 {
@@ -235,7 +240,11 @@ public:
                              ::std::function<void(bool)> sent) :
         ProxyGetConnection(proxy), LambdaInvoke(::std::move(ex), ::std::move(sent))
     {
+#if ICE_CPLUSPLUS >= 201402L
+        _response = [&, response = std::move(response)](bool)
+#else
         _response = [&, response](bool)
+#endif
         {
             response(getConnection());
         };
@@ -354,7 +363,8 @@ public:
                  ::std::function<void(bool)> sent = nullptr,
                  const ::Ice::Context& context = ::Ice::noExplicitContext)
     {
-        return _makeLamdaOutgoing<bool>(response, ex, sent, this, &ObjectPrx::_iceI_isA, typeId, context);
+        return _makeLamdaOutgoing<bool>(std::move(response), std::move(ex), std::move(sent), this,
+                                        &ObjectPrx::_iceI_isA, typeId, context);
     }
 
     /**
@@ -399,7 +409,8 @@ public:
                   ::std::function<void(bool)> sent = nullptr,
                   const ::Ice::Context& context = ::Ice::noExplicitContext)
     {
-        return _makeLamdaOutgoing<void>(response, ex, sent, this, &ObjectPrx::_iceI_ping, context);
+        return _makeLamdaOutgoing<void>(std::move(response), std::move(ex), std::move(sent), this,
+                                        &ObjectPrx::_iceI_ping, context);
     }
 
     /**
@@ -445,7 +456,8 @@ public:
                  ::std::function<void(bool)> sent = nullptr,
                  const ::Ice::Context& context = ::Ice::noExplicitContext)
     {
-        return _makeLamdaOutgoing<::std::vector<::std::string>>(response, ex, sent, this, &ObjectPrx::_iceI_ids, context);
+        return _makeLamdaOutgoing<::std::vector<::std::string>>(std::move(response), std::move(ex), std::move(sent),
+                                                                this, &ObjectPrx::_iceI_ids, context);
     }
 
     /**
@@ -490,7 +502,8 @@ public:
                 ::std::function<void(bool)> sent = nullptr,
                 const ::Ice::Context& context = ::Ice::noExplicitContext)
     {
-        return _makeLamdaOutgoing<::std::string>(response, ex, sent, this, &ObjectPrx::_iceI_id, context);
+        return _makeLamdaOutgoing<::std::string>(std::move(response), std::move(ex), std::move(sent), this,
+                                                 &ObjectPrx::_iceI_id, context);
     }
 
     /**
@@ -583,12 +596,16 @@ public:
         ::std::function<void(::Ice::Object::Ice_invokeResult&&)> r;
         if(response)
         {
+#if ICE_CPLUSPLUS >= 201402L
+            r = [response = std::move(response)](::Ice::Object::Ice_invokeResult&& result)
+#else
             r = [response](::Ice::Object::Ice_invokeResult&& result)
+#endif
             {
                 response(result.returnValue, std::move(result.outParams));
             };
         }
-        auto outAsync = ::std::make_shared<Outgoing>(shared_from_this(), r, ex, sent);
+        auto outAsync = ::std::make_shared<Outgoing>(shared_from_this(), std::move(r), std::move(ex), std::move(sent));
         outAsync->invoke(operation, mode, ::IceInternal::makePair(inParams), context);
         return [outAsync]() { outAsync->cancel(); };
     }
@@ -669,12 +686,16 @@ public:
         ::std::function<void(Result&&)> r;
         if(response)
         {
+#if ICE_CPLUSPLUS >= 201402L
+            r = [response = std::move(response)](Result&& result)
+#else
             r = [response](Result&& result)
+#endif
             {
                 response(::std::get<0>(result), ::std::move(::std::get<1>(result)));
             };
         }
-        auto outAsync = ::std::make_shared<Outgoing>(shared_from_this(), r, ex, sent);
+        auto outAsync = ::std::make_shared<Outgoing>(shared_from_this(), std::move(r), std::move(ex), std::move(sent));
         outAsync->invoke(operation, mode, inParams, context);
         return [outAsync]() { outAsync->cancel(); };
     }
@@ -1023,7 +1044,7 @@ public:
                            ::std::function<void(bool)> sent = nullptr)
     {
         using LambdaOutgoing = ::IceInternal::ProxyGetConnectionLambda;
-        auto outAsync = ::std::make_shared<LambdaOutgoing>(shared_from_this(), response, ex, sent);
+        auto outAsync = ::std::make_shared<LambdaOutgoing>(shared_from_this(), std::move(response), std::move(ex), std::move(sent));
         _iceI_getConnection(outAsync);
         return [outAsync]() { outAsync->cancel(); };
     }
@@ -1073,7 +1094,7 @@ public:
                                 ::std::function<void(bool)> sent = nullptr)
     {
         using LambdaOutgoing = ::IceInternal::ProxyFlushBatchLambda;
-        auto outAsync = ::std::make_shared<LambdaOutgoing>(shared_from_this(), ex, sent);
+        auto outAsync = ::std::make_shared<LambdaOutgoing>(shared_from_this(), std::move(ex), std::move(sent));
         _iceI_flushBatchRequests(outAsync);
         return [outAsync]() { outAsync->cancel(); };
     }
@@ -1128,7 +1149,8 @@ protected:
     template<typename R, typename Re, typename E, typename S, typename Obj, typename Fn, typename... Args>
     ::std::function<void()> _makeLamdaOutgoing(Re r, E e, S s, Obj obj, Fn fn, Args&&... args)
     {
-        auto outAsync = ::std::make_shared<::IceInternal::LambdaOutgoing<R>>(shared_from_this(), r, e, s);
+        auto outAsync = ::std::make_shared<::IceInternal::LambdaOutgoing<R>>(shared_from_this(),
+                                                                             std::move(r), std::move(e), std::move(s));
         (obj->*fn)(outAsync, std::forward<Args>(args)...);
         return [outAsync]() { outAsync->cancel(); };
     }
@@ -1455,10 +1477,10 @@ ICE_API bool proxyIdentityAndFacetEqual(const ::std::shared_ptr<ObjectPrx>& lhs,
  * compares less than the identity in rhs, false otherwise.
  * \headerfile Ice/Ice.h
  */
-#if (ICE_CPLUSPLUS >= 201703L)
+
 struct ProxyIdentityLess
-#else
-struct ProxyIdentityLess : std::binary_function<bool, ::std::shared_ptr<ObjectPrx>&, ::std::shared_ptr<ObjectPrx>&>
+#if (ICE_CPLUSPLUS < 201703L)
+    : std::binary_function<bool, ::std::shared_ptr<ObjectPrx>&, ::std::shared_ptr<ObjectPrx>&>
 #endif
 {
     bool operator()(const ::std::shared_ptr<ObjectPrx>& lhs, const ::std::shared_ptr<ObjectPrx>& rhs) const
@@ -1472,10 +1494,9 @@ struct ProxyIdentityLess : std::binary_function<bool, ::std::shared_ptr<ObjectPr
  * compares equal to the identity in rhs, false otherwise.
  * \headerfile Ice/Ice.h
  */
-#if (ICE_CPLUSPLUS >= 201703L)
 struct ProxyIdentityEqual
-#else
-struct ProxyIdentityEqual : std::binary_function<bool, ::std::shared_ptr<ObjectPrx>&, ::std::shared_ptr<ObjectPrx>&>
+#if (ICE_CPLUSPLUS < 201703L)
+    : std::binary_function<bool, ::std::shared_ptr<ObjectPrx>&, ::std::shared_ptr<ObjectPrx>&>
 #endif
 {
     bool operator()(const ::std::shared_ptr<ObjectPrx>& lhs, const ::std::shared_ptr<ObjectPrx>& rhs) const
@@ -1489,10 +1510,9 @@ struct ProxyIdentityEqual : std::binary_function<bool, ::std::shared_ptr<ObjectP
  * and facet in lhs compare less than the identity and facet in rhs, false otherwise.
  * \headerfile Ice/Ice.h
  */
-#if (ICE_CPLUSPLUS >= 201703L)
 struct ProxyIdentityAndFacetLess
-#else
-struct ProxyIdentityAndFacetLess : std::binary_function<bool, ::std::shared_ptr<ObjectPrx>&, ::std::shared_ptr<ObjectPrx>&>
+#if (ICE_CPLUSPLUS < 201703L)
+    : std::binary_function<bool, ::std::shared_ptr<ObjectPrx>&, ::std::shared_ptr<ObjectPrx>&>
 #endif
 {
     bool operator()(const ::std::shared_ptr<ObjectPrx>& lhs, const ::std::shared_ptr<ObjectPrx>& rhs) const
@@ -1506,10 +1526,9 @@ struct ProxyIdentityAndFacetLess : std::binary_function<bool, ::std::shared_ptr<
  * and facet in lhs compare equal to the identity and facet in rhs, false otherwise.
  * \headerfile Ice/Ice.h
  */
-#if (ICE_CPLUSPLUS >= 201703L)
 struct ProxyIdentityAndFacetEqual
-#else
-struct ProxyIdentityAndFacetEqual : std::binary_function<bool, ::std::shared_ptr<ObjectPrx>&, ::std::shared_ptr<ObjectPrx>&>
+#if (ICE_CPLUSPLUS < 201703L)
+    : std::binary_function<bool, ::std::shared_ptr<ObjectPrx>&, ::std::shared_ptr<ObjectPrx>&>
 #endif
 {
     bool operator()(const ::std::shared_ptr<ObjectPrx>& lhs, const ::std::shared_ptr<ObjectPrx>& rhs) const
@@ -3146,7 +3165,10 @@ ICE_API bool proxyIdentityAndFacetEqual(const ObjectPrx& lhs, const ObjectPrx& r
  * compares less than the identity in rhs, false otherwise.
  * \headerfile Ice/Ice.h
  */
-struct ProxyIdentityLess : std::binary_function<bool, ObjectPrx&, ObjectPrx&>
+struct ProxyIdentityLess
+#if (ICE_CPLUSPLUS < 201703L)
+    : std::binary_function<bool, ObjectPrx&, ObjectPrx&>
+#endif
 {
     bool operator()(const ObjectPrx& lhs, const ObjectPrx& rhs) const
     {
@@ -3159,7 +3181,10 @@ struct ProxyIdentityLess : std::binary_function<bool, ObjectPrx&, ObjectPrx&>
  * compares equal to the identity in rhs, false otherwise.
  * \headerfile Ice/Ice.h
  */
-struct ProxyIdentityEqual : std::binary_function<bool, ObjectPrx&, ObjectPrx&>
+struct ProxyIdentityEqual
+#if (ICE_CPLUSPLUS < 201703L)
+    : std::binary_function<bool, ObjectPrx&, ObjectPrx&>
+#endif
 {
     bool operator()(const ObjectPrx& lhs, const ObjectPrx& rhs) const
     {
@@ -3172,7 +3197,10 @@ struct ProxyIdentityEqual : std::binary_function<bool, ObjectPrx&, ObjectPrx&>
  * and facet in lhs compare less than the identity and facet in rhs, false otherwise.
  * \headerfile Ice/Ice.h
  */
-struct ProxyIdentityAndFacetLess : std::binary_function<bool, ObjectPrx&, ObjectPrx&>
+struct ProxyIdentityAndFacetLess
+#if (ICE_CPLUSPLUS < 201703L)
+    : std::binary_function<bool, ObjectPrx&, ObjectPrx&>
+#endif
 {
     bool operator()(const ObjectPrx& lhs, const ObjectPrx& rhs) const
     {
@@ -3185,7 +3213,10 @@ struct ProxyIdentityAndFacetLess : std::binary_function<bool, ObjectPrx&, Object
  * and facet in lhs compare equal to the identity and facet in rhs, false otherwise.
  * \headerfile Ice/Ice.h
  */
-struct ProxyIdentityAndFacetEqual : std::binary_function<bool, ObjectPrx&, ObjectPrx&>
+struct ProxyIdentityAndFacetEqual
+#if (ICE_CPLUSPLUS < 201703L)
+    : std::binary_function<bool, ObjectPrx&, ObjectPrx&>
+#endif
 {
     bool operator()(const ObjectPrx& lhs, const ObjectPrx& rhs) const
     {

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

@@ -157,6 +157,7 @@ public:
      */
     bool checkSystem() const;
 
+#ifdef _WIN32
     /**
      * Alternative entry point for services that use their own
      * command-line options. Instead of invoking main(), the
@@ -172,7 +173,6 @@ public:
      * specified, the version of the Ice installation is used.
      * @return The application's exit status: EXIT_FAILURE or EXIT_SUCCESS.
      */
-#ifdef _WIN32
     int run(int argc, const wchar_t* const argv[], const InitializationData& initData = InitializationData(),
             int version = ICE_INT_VERSION);
 #endif