diff options
68 files changed, 1332 insertions, 1337 deletions
diff --git a/cpp/include/Ice/AsyncResult.h b/cpp/include/Ice/AsyncResult.h index e8aea029007..e2c1d53d53b 100644 --- a/cpp/include/Ice/AsyncResult.h +++ b/cpp/include/Ice/AsyncResult.h @@ -51,20 +51,20 @@ public: virtual const std::string& getOperation() const = 0; - virtual bool __wait() = 0; - virtual Ice::InputStream* __startReadParams() = 0; - virtual void __endReadParams() = 0; - virtual void __readEmptyParams() = 0; - virtual void __readParamEncaps(const ::Ice::Byte*&, ::Ice::Int&) = 0; - virtual void __throwUserException() = 0; + virtual bool waitForResponse() = 0; + virtual Ice::InputStream* startReadParams() = 0; + virtual void endReadParams() = 0; + virtual void readEmptyParams() = 0; + virtual void readParamEncaps(const ::Ice::Byte*&, ::Ice::Int&) = 0; + virtual void throwUserException() = 0; - static void __check(const AsyncResultPtr&, const ::IceProxy::Ice::Object*, const ::std::string&); - static void __check(const AsyncResultPtr&, const Connection*, const ::std::string&); - static void __check(const AsyncResultPtr&, const Communicator*, const ::std::string&); + static void check(const AsyncResultPtr&, const ::IceProxy::Ice::Object*, const ::std::string&); + static void check(const AsyncResultPtr&, const Connection*, const ::std::string&); + static void check(const AsyncResultPtr&, const Communicator*, const ::std::string&); protected: - static void __check(const AsyncResultPtr&, const ::std::string&); + static void check(const AsyncResultPtr&, const ::std::string&); }; } diff --git a/cpp/include/Ice/CommunicatorAsync.h b/cpp/include/Ice/CommunicatorAsync.h index 549542567dd..5dfdadd44aa 100644 --- a/cpp/include/Ice/CommunicatorAsync.h +++ b/cpp/include/Ice/CommunicatorAsync.h @@ -33,18 +33,18 @@ public: { } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& result) const { - ::Ice::CommunicatorPtr __com = __result->getCommunicator(); - assert(__com); + ::Ice::CommunicatorPtr communicator = result->getCommunicator(); + assert(communicator); try { - __com->end_flushBatchRequests(__result); + communicator->end_flushBatchRequests(result); assert(false); } catch(const ::Ice::Exception& ex) { - ::IceInternal::CallbackNC<T>::exception(__result, ex); + ::IceInternal::CallbackNC<T>::exception(result, ex); } } }; @@ -81,18 +81,18 @@ public: { } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& result) const { - ::Ice::CommunicatorPtr __com = __result->getCommunicator(); - assert(__com); + ::Ice::CommunicatorPtr communicator = result->getCommunicator(); + assert(communicator); try { - __com->end_flushBatchRequests(__result); + communicator->end_flushBatchRequests(result); assert(false); } catch(const ::Ice::Exception& ex) { - ::IceInternal::Callback<T, CT>::exception(__result, ex); + ::IceInternal::Callback<T, CT>::exception(result, ex); } } }; diff --git a/cpp/include/Ice/ConnectionAsync.h b/cpp/include/Ice/ConnectionAsync.h index ce9fd85e7af..bc3f6064525 100644 --- a/cpp/include/Ice/ConnectionAsync.h +++ b/cpp/include/Ice/ConnectionAsync.h @@ -34,18 +34,18 @@ public: { } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& result) const { - ::Ice::ConnectionPtr __con = __result->getConnection(); - assert(__con); + ::Ice::ConnectionPtr connection = result->getConnection(); + assert(connection); try { - __con->end_flushBatchRequests(__result); + connection->end_flushBatchRequests(result); assert(false); } catch(const ::Ice::Exception& ex) { - ::IceInternal::CallbackNC<T>::exception(__result, ex); + ::IceInternal::CallbackNC<T>::exception(result, ex); } } }; @@ -81,18 +81,18 @@ public: { } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& result) const { - ::Ice::ConnectionPtr __con = __result->getConnection(); - assert(__con); + ::Ice::ConnectionPtr connection = result->getConnection(); + assert(connection); try { - __con->end_flushBatchRequests(__result); + connection->end_flushBatchRequests(result); assert(false); } catch(const ::Ice::Exception& ex) { - ::IceInternal::Callback<T, CT>::exception(__result, ex); + ::IceInternal::Callback<T, CT>::exception(result, ex); } } }; diff --git a/cpp/include/Ice/DispatchInterceptor.h b/cpp/include/Ice/DispatchInterceptor.h index 648e21412ca..aca5b713aaf 100644 --- a/cpp/include/Ice/DispatchInterceptor.h +++ b/cpp/include/Ice/DispatchInterceptor.h @@ -21,7 +21,7 @@ public: virtual bool dispatch(Request&) = 0; - virtual bool __dispatch(IceInternal::Incoming&, const Current&); + virtual bool _iceDispatch(IceInternal::Incoming&, const Current&); }; ICE_DEFINE_PTR(DispatchInterceptorPtr, DispatchInterceptor); diff --git a/cpp/include/Ice/Exception.h b/cpp/include/Ice/Exception.h index b2b4720b8ea..ee38d00688d 100644 --- a/cpp/include/Ice/Exception.h +++ b/cpp/include/Ice/Exception.h @@ -57,10 +57,10 @@ class ICE_API UserException : public IceUtil::Exception { public: - virtual void __write(::Ice::OutputStream*) const; - virtual void __read(::Ice::InputStream*); + virtual void _write(::Ice::OutputStream*) const; + virtual void _read(::Ice::InputStream*); - virtual bool __usesClasses() const; + virtual bool _usesClasses() const; #ifdef ICE_CPP11_MAPPING std::unique_ptr<UserException> ice_clone() const; @@ -72,8 +72,8 @@ public: protected: - virtual void __writeImpl(::Ice::OutputStream*) const {}; - virtual void __readImpl(::Ice::InputStream*) {}; + virtual void _writeImpl(::Ice::OutputStream*) const {}; + virtual void _readImpl(::Ice::InputStream*) {}; }; diff --git a/cpp/include/Ice/ExceptionHelpers.h b/cpp/include/Ice/ExceptionHelpers.h index 04c37669f07..28efc9c9060 100644 --- a/cpp/include/Ice/ExceptionHelpers.h +++ b/cpp/include/Ice/ExceptionHelpers.h @@ -45,20 +45,20 @@ public: protected: - virtual void __writeImpl(Ice::OutputStream* os) const override + virtual void _writeImpl(Ice::OutputStream* os) const override { os->startSlice(T::ice_staticId(), -1, std::is_same<B, Ice::LocalException>::value ? true : false); Ice::StreamWriter<T, Ice::OutputStream>::write(os, static_cast<const T&>(*this)); os->endSlice(); - B::__writeImpl(os); + B::_writeImpl(os); } - virtual void __readImpl(Ice::InputStream* is) override + virtual void _readImpl(Ice::InputStream* is) override { is->startSlice(); Ice::StreamReader<T, ::Ice::InputStream>::read(is, static_cast<T&>(*this)); is->endSlice(); - B::__readImpl(is); + B::_readImpl(is); } }; diff --git a/cpp/include/Ice/GCObject.h b/cpp/include/Ice/GCObject.h index e115795be20..171e12c3cca 100644 --- a/cpp/include/Ice/GCObject.h +++ b/cpp/include/Ice/GCObject.h @@ -55,16 +55,16 @@ public: // // Override Object methods // - virtual bool __gcVisit(GCVisitor&); + virtual bool _iceGcVisit(GCVisitor&); virtual void ice_collectable(bool); // // This method is implemented by Slice classes to visit class // members. // - virtual void __gcVisitMembers(IceInternal::GCVisitor&) = 0; + virtual void _iceGcVisitMembers(IceInternal::GCVisitor&) = 0; - int __getRefUnsafe() + int _iceGetRefUnsafe() { return _ref; } diff --git a/cpp/include/Ice/Handle.h b/cpp/include/Ice/Handle.h index 59283f07702..fc3ad32a833 100644 --- a/cpp/include/Ice/Handle.h +++ b/cpp/include/Ice/Handle.h @@ -180,11 +180,6 @@ public: { return Handle(dynamic_cast<T*>(p)); } - - void __clearHandleUnsafe() - { - this->_ptr = 0; - } }; } diff --git a/cpp/include/Ice/Incoming.h b/cpp/include/Ice/Incoming.h index f512d38ac8b..ba3b1977aaa 100644 --- a/cpp/include/Ice/Incoming.h +++ b/cpp/include/Ice/Incoming.h @@ -37,12 +37,12 @@ public: std::shared_ptr<OutputStream> getOutputStream() const { - return __os; + return ostr; } protected: - std::shared_ptr<OutputStream> __os; + std::shared_ptr<OutputStream> ostr; }; } diff --git a/cpp/include/Ice/InputStream.h b/cpp/include/Ice/InputStream.h index 81d5be4c950..552289a69f4 100644 --- a/cpp/include/Ice/InputStream.h +++ b/cpp/include/Ice/InputStream.h @@ -41,7 +41,7 @@ patchHandle(void* addr, const ValuePtr& v) } #else IceInternal::Handle<T>* p = static_cast<IceInternal::Handle<T>*>(addr); - __patch(*p, v); // Generated __patch method, necessary for forward declarations. + _icePatchObjectPtr(*p, v); // Generated _icePatchObjectPtr function, necessary for forward declarations. #endif } @@ -594,14 +594,14 @@ public: else { v = ::IceInternal::createProxy<T>(); - v->__copyFrom(proxy); + v->_copyFrom(proxy); } } #else void read(ObjectPrx&); template<typename T> void read(IceInternal::ProxyHandle<T>& v) { - __read(this, v); // Generated __read method, necessary for forward declarations. + _readProxy(this, v); // Generated _readProxy method, necessary for forward declarations. } #endif diff --git a/cpp/include/Ice/LoggerUtil.h b/cpp/include/Ice/LoggerUtil.h index ff890e9aedd..8352e72c2e6 100644 --- a/cpp/include/Ice/LoggerUtil.h +++ b/cpp/include/Ice/LoggerUtil.h @@ -24,11 +24,11 @@ public: std::string str() const; - std::ostringstream& __str(); // For internal use only. Don't use in your code. + std::ostringstream& _stream(); // For internal use only. Don't use in your code. private: - std::ostringstream _str; + std::ostringstream _os; }; ICE_API LoggerOutputBase& loggerInsert(LoggerOutputBase& out, const IceUtil::Exception& ex); @@ -48,7 +48,7 @@ struct LoggerOutputInserter static inline LoggerOutputBase& insert(LoggerOutputBase& out, const T& val) { - out.__str() << val; + out._stream() << val; return out; } }; @@ -87,7 +87,7 @@ operator<<(LoggerOutputBase& os, const ::IceInternal::ProxyHandle<T>& p) inline LoggerOutputBase& operator<<(LoggerOutputBase& out, const ::std::exception& ex) { - out.__str() << ex.what(); + out._stream() << ex.what(); return out; } @@ -108,13 +108,13 @@ public: inline void flush() { - std::string s = __str().str(); + std::string s = _stream().str(); if(!s.empty()) { L& ref = *_logger; (ref.*output)(s); } - __str().str(""); + _stream().str(""); } private: diff --git a/cpp/include/Ice/Object.h b/cpp/include/Ice/Object.h index 6e472bd5fee..c468513cd52 100644 --- a/cpp/include/Ice/Object.h +++ b/cpp/include/Ice/Object.h @@ -70,21 +70,19 @@ public: virtual ~Object() = default; virtual bool ice_isA(std::string, const Current& = Ice::noExplicitCurrent) const; - bool ___ice_isA(IceInternal::Incoming&, const Current&); + bool _iceD_ice_isA(IceInternal::Incoming&, const Current&); virtual void ice_ping(const Current& = Ice::noExplicitCurrent) const; - bool ___ice_ping(IceInternal::Incoming&, const Current&); + bool _iceD_ice_ping(IceInternal::Incoming&, const Current&); virtual std::vector< std::string> ice_ids(const Current& = Ice::noExplicitCurrent) const; - bool ___ice_ids(IceInternal::Incoming&, const Current&); + bool _iceD_ice_ids(IceInternal::Incoming&, const Current&); virtual std::string ice_id(const Current& = Ice::noExplicitCurrent) const; - bool ___ice_id(IceInternal::Incoming&, const Current&); + bool _iceD_ice_id(IceInternal::Incoming&, const Current&); static const std::string& ice_staticId(); - static std::string __all[]; - #ifndef ICE_CPP11_MAPPING virtual bool ice_dispatch(Ice::Request&, const DispatchInterceptorAsyncCallbackPtr& = 0); #else @@ -92,7 +90,7 @@ public: std::function<bool()> = nullptr, std::function<bool(std::exception_ptr)> = nullptr); #endif - virtual bool __dispatch(IceInternal::Incoming&, const Current&); + virtual bool _iceDispatch(IceInternal::Incoming&, const Current&); struct Ice_invokeResult { @@ -102,7 +100,7 @@ public: protected: - static void __checkMode(OperationMode, OperationMode); + static void _iceCheckMode(OperationMode, OperationMode); }; #else class ICE_API Object : public virtual IceUtil::Shared @@ -113,23 +111,23 @@ public: virtual bool operator<(const Object&) const; virtual bool ice_isA(const std::string&, const Current& = Ice::noExplicitCurrent) const; - bool ___ice_isA(IceInternal::Incoming&, const Current&); + bool _iceD_ice_isA(IceInternal::Incoming&, const Current&); virtual void ice_ping(const Current& = Ice::noExplicitCurrent) const; - bool ___ice_ping(IceInternal::Incoming&, const Current&); + bool _iceD_ice_ping(IceInternal::Incoming&, const Current&); virtual std::vector< std::string> ice_ids(const Current& = Ice::noExplicitCurrent) const; - bool ___ice_ids(IceInternal::Incoming&, const Current&); + bool _iceD_ice_ids(IceInternal::Incoming&, const Current&); virtual const std::string& ice_id(const Current& = Ice::noExplicitCurrent) const; - bool ___ice_id(IceInternal::Incoming&, const Current&); + bool _iceD_ice_id(IceInternal::Incoming&, const Current&); virtual Int ice_operationAttributes(const std::string&) const; - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); + virtual void _iceWrite(Ice::OutputStream*) const; + virtual void _iceRead(Ice::InputStream*); - virtual bool __gcVisit(IceInternal::GCVisitor&) { return false; }; + virtual bool _iceGcVisit(IceInternal::GCVisitor&) { return false; }; virtual void ice_collectable(bool) { }; virtual void ice_preMarshal(); @@ -139,10 +137,8 @@ public: virtual ObjectPtr ice_clone() const; - static std::string __all[]; - virtual bool ice_dispatch(Ice::Request&, const DispatchInterceptorAsyncCallbackPtr& = 0); - virtual bool __dispatch(IceInternal::Incoming&, const Current&); + virtual bool _iceDispatch(IceInternal::Incoming&, const Current&); protected: @@ -151,10 +147,10 @@ protected: protected: - virtual void __writeImpl(Ice::OutputStream*) const {} - virtual void __readImpl(Ice::InputStream*) {} + virtual void _iceWriteImpl(Ice::OutputStream*) const {} + virtual void _iceReadImpl(Ice::InputStream*) {} - static void __checkMode(OperationMode, OperationMode); + static void _iceCheckMode(OperationMode, OperationMode); }; #endif @@ -167,7 +163,7 @@ public: // virtual bool ice_invoke(const std::vector<Byte>&, std::vector<Byte>&, const Current&) = 0; - virtual bool __dispatch(IceInternal::Incoming&, const Current&); + virtual bool _iceDispatch(IceInternal::Incoming&, const Current&); }; class ICE_API BlobjectArray : public virtual Object @@ -179,7 +175,7 @@ public: // virtual bool ice_invoke(const std::pair<const Byte*, const Byte*>&, std::vector<Byte>&, const Current&) = 0; - virtual bool __dispatch(IceInternal::Incoming&, const Current&); + virtual bool _iceDispatch(IceInternal::Incoming&, const Current&); }; class ICE_API BlobjectAsync : public virtual Object @@ -194,7 +190,7 @@ public: #else virtual void ice_invoke_async(const AMD_Object_ice_invokePtr&, const std::vector<Byte>&, const Current&) = 0; #endif - virtual bool __dispatch(IceInternal::Incoming&, const Current&); + virtual bool _iceDispatch(IceInternal::Incoming&, const Current&); }; class ICE_API BlobjectArrayAsync : public virtual Object @@ -210,7 +206,7 @@ public: virtual void ice_invoke_async(const AMD_Object_ice_invokePtr&, const std::pair<const Byte*, const Byte*>&, const Current&) = 0; #endif - virtual bool __dispatch(IceInternal::Incoming&, const Current&); + virtual bool _iceDispatch(IceInternal::Incoming&, const Current&); }; } diff --git a/cpp/include/Ice/ObjectF.h b/cpp/include/Ice/ObjectF.h index eb157fac899..577e1faaf04 100644 --- a/cpp/include/Ice/ObjectF.h +++ b/cpp/include/Ice/ObjectF.h @@ -23,7 +23,7 @@ using ObjectPtr = ::std::shared_ptr<Object>; ICE_API Object* upCast(Object*); typedef IceInternal::Handle<Object> ObjectPtr; typedef ObjectPtr ValuePtr; -ICE_API void __patch(ObjectPtr&, const ObjectPtr&); +ICE_API void _icePatchObjectPtr(ObjectPtr&, const ObjectPtr&); #endif } diff --git a/cpp/include/Ice/OutgoingAsync.h b/cpp/include/Ice/OutgoingAsync.h index 8391c6c189d..86d017dbfe1 100644 --- a/cpp/include/Ice/OutgoingAsync.h +++ b/cpp/include/Ice/OutgoingAsync.h @@ -101,12 +101,12 @@ public: virtual void throwLocalException() const; - virtual bool __wait(); - virtual Ice::InputStream* __startReadParams(); - virtual void __endReadParams(); - virtual void __readEmptyParams(); - virtual void __readParamEncaps(const ::Ice::Byte*&, ::Ice::Int&); - virtual void __throwUserException(); + virtual bool waitForResponse(); + virtual Ice::InputStream* startReadParams(); + virtual void endReadParams(); + virtual void readEmptyParams(); + virtual void readParamEncaps(const ::Ice::Byte*&, ::Ice::Int&); + virtual void throwUserException(); #endif void attachRemoteObserver(const Ice::ConnectionInfoPtr& c, const Ice::EndpointPtr& endpt, Ice::Int requestId) @@ -753,7 +753,7 @@ public: // // See comments in OutgoingAsync.cpp // -extern ICE_API CallbackBasePtr __dummyCallback; +extern ICE_API CallbackBasePtr dummyCallback; // // Generic callback template that requires the caller to down-cast the diff --git a/cpp/include/Ice/Proxy.h b/cpp/include/Ice/Proxy.h index 30315e7f33b..e996c1324ab 100644 --- a/cpp/include/Ice/Proxy.h +++ b/cpp/include/Ice/Proxy.h @@ -73,7 +73,7 @@ public: invoke(const std::string& operation, Ice::OperationMode mode, const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams, - const Ice::Context& ctx) + const Ice::Context& context) { _read = [](bool ok, Ice::InputStream* stream) { @@ -85,7 +85,7 @@ public: try { - prepare(operation, mode, ctx); + prepare(operation, mode, context); if(inParams.first == inParams.second) { _os.writeEmptyEncapsulation(_encoding); @@ -252,9 +252,9 @@ public: ::std::string ice_toString() const; bool - ice_isA(const ::std::string& typeId, const ::Ice::Context& ctx = ::Ice::noExplicitContext) + ice_isA(const ::std::string& typeId, const ::Ice::Context& context = ::Ice::noExplicitContext) { - return makePromiseOutgoing<bool>(true, this, &ObjectPrx::__ice_isA, typeId, ctx).get(); + return _makePromiseOutgoing<bool>(true, this, &ObjectPrx::_iceI_isA, typeId, context).get(); } ::std::function<void()> @@ -262,95 +262,95 @@ public: ::std::function<void(bool)> response, ::std::function<void(::std::exception_ptr)> ex = nullptr, ::std::function<void(bool)> sent = nullptr, - const ::Ice::Context& ctx = ::Ice::noExplicitContext) + const ::Ice::Context& context = ::Ice::noExplicitContext) { - return makeLambdaOutgoing<bool>(response, ex, sent, this, &ObjectPrx::__ice_isA, typeId, ctx); + return _makeLamdaOutgoing<bool>(response, ex, sent, this, &ObjectPrx::_iceI_isA, typeId, context); } template<template<typename> class P = std::promise> auto - ice_isAAsync(const ::std::string& typeId, const ::Ice::Context& ctx = ::Ice::noExplicitContext) + ice_isAAsync(const ::std::string& typeId, const ::Ice::Context& context = ::Ice::noExplicitContext) -> decltype(std::declval<P<bool>>().get_future()) { - return makePromiseOutgoing<bool, P>(false, this, &ObjectPrx::__ice_isA, typeId, ctx); + return _makePromiseOutgoing<bool, P>(false, this, &ObjectPrx::_iceI_isA, typeId, context); } void - __ice_isA(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<bool>>&, const ::std::string&, const ::Ice::Context&); + _iceI_isA(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<bool>>&, const ::std::string&, const ::Ice::Context&); void - ice_ping(const ::Ice::Context& ctx = ::Ice::noExplicitContext) + ice_ping(const ::Ice::Context& context = ::Ice::noExplicitContext) { - makePromiseOutgoing<void>(true, this, &ObjectPrx::__ice_ping, ctx).get(); + _makePromiseOutgoing<void>(true, this, &ObjectPrx::_iceI_ping, context).get(); } ::std::function<void()> ice_pingAsync(::std::function<void()> response, ::std::function<void(::std::exception_ptr)> ex = nullptr, ::std::function<void(bool)> sent = nullptr, - const ::Ice::Context& ctx = ::Ice::noExplicitContext) + const ::Ice::Context& context = ::Ice::noExplicitContext) { - return makeLambdaOutgoing<void>(response, ex, sent, this, &ObjectPrx::__ice_ping, ctx); + return _makeLamdaOutgoing<void>(response, ex, sent, this, &ObjectPrx::_iceI_ping, context); } template<template<typename> class P = std::promise> - auto ice_pingAsync(const ::Ice::Context& ctx = ::Ice::noExplicitContext) + auto ice_pingAsync(const ::Ice::Context& context = ::Ice::noExplicitContext) -> decltype(std::declval<P<void>>().get_future()) { - return makePromiseOutgoing<void, P>(false, this, &ObjectPrx::__ice_ping, ctx); + return _makePromiseOutgoing<void, P>(false, this, &ObjectPrx::_iceI_ping, context); } void - __ice_ping(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::Ice::Context&); + _iceI_ping(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::Ice::Context&); ::std::vector<::std::string> - ice_ids(const ::Ice::Context& ctx = ::Ice::noExplicitContext) + ice_ids(const ::Ice::Context& context = ::Ice::noExplicitContext) { - return makePromiseOutgoing<::std::vector<::std::string>>(true, this, &ObjectPrx::__ice_ids, ctx).get(); + return _makePromiseOutgoing<::std::vector<::std::string>>(true, this, &ObjectPrx::_iceI_ids, context).get(); } ::std::function<void()> ice_idsAsync(::std::function<void(::std::vector<::std::string>)> response, ::std::function<void(::std::exception_ptr)> ex = nullptr, ::std::function<void(bool)> sent = nullptr, - const ::Ice::Context& ctx = ::Ice::noExplicitContext) + const ::Ice::Context& context = ::Ice::noExplicitContext) { - return makeLambdaOutgoing<::std::vector<::std::string>>(response, ex, sent, this, &ObjectPrx::__ice_ids, ctx); + return _makeLamdaOutgoing<::std::vector<::std::string>>(response, ex, sent, this, &ObjectPrx::_iceI_ids, context); } template<template<typename> class P = std::promise> auto - ice_idsAsync(const ::Ice::Context& ctx = ::Ice::noExplicitContext) + ice_idsAsync(const ::Ice::Context& context = ::Ice::noExplicitContext) -> decltype(std::declval<P<::std::vector<::std::string>>>().get_future()) { - return makePromiseOutgoing<::std::vector<::std::string>, P>(false, this, &ObjectPrx::__ice_ids, ctx); + return _makePromiseOutgoing<::std::vector<::std::string>, P>(false, this, &ObjectPrx::_iceI_ids, context); } void - __ice_ids(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::vector<::std::string>>>&, const ::Ice::Context&); + _iceI_ids(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::vector<::std::string>>>&, const ::Ice::Context&); ::std::string - ice_id(const ::Ice::Context& ctx = ::Ice::noExplicitContext) + ice_id(const ::Ice::Context& context = ::Ice::noExplicitContext) { - return makePromiseOutgoing<::std::string>(true, this, &ObjectPrx::__ice_id, ctx).get(); + return _makePromiseOutgoing<::std::string>(true, this, &ObjectPrx::_iceI_id, context).get(); } ::std::function<void()> ice_idAsync(::std::function<void(::std::string)> response, ::std::function<void(::std::exception_ptr)> ex = nullptr, ::std::function<void(bool)> sent = nullptr, - const ::Ice::Context& ctx = ::Ice::noExplicitContext) + const ::Ice::Context& context = ::Ice::noExplicitContext) { - return makeLambdaOutgoing<::std::string>(response, ex, sent, this, &ObjectPrx::__ice_id, ctx); + return _makeLamdaOutgoing<::std::string>(response, ex, sent, this, &ObjectPrx::_iceI_id, context); } template<template<typename> class P = std::promise> - auto ice_idAsync(const ::Ice::Context& ctx = ::Ice::noExplicitContext) + auto ice_idAsync(const ::Ice::Context& context = ::Ice::noExplicitContext) -> decltype(std::declval<P<::std::string>>().get_future()) { - return makePromiseOutgoing<::std::string, P>(false, this, &ObjectPrx::__ice_id, ctx); + return _makePromiseOutgoing<::std::string, P>(false, this, &ObjectPrx::_iceI_id, context); } void - __ice_id(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::string>>&, const ::Ice::Context&); + _iceI_id(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::string>>&, const ::Ice::Context&); static const ::std::string& ice_staticId() { @@ -367,19 +367,19 @@ public: ::Ice::OperationMode mode, const ::std::vector<Byte>& inP, ::std::vector<::Ice::Byte>& outParams, - const ::Ice::Context& ctx = ::Ice::noExplicitContext) + const ::Ice::Context& context = ::Ice::noExplicitContext) { - return ice_invoke(operation, mode, ::IceInternal::makePair(inP), outParams, ctx); + return ice_invoke(operation, mode, ::IceInternal::makePair(inP), outParams, context); } template<template<typename> class P = std::promise> auto ice_invokeAsync(const ::std::string& operation, ::Ice::OperationMode mode, const ::std::vector<Byte>& inP, - const ::Ice::Context& ctx = ::Ice::noExplicitContext) + const ::Ice::Context& context = ::Ice::noExplicitContext) -> decltype(std::declval<P<::Ice::Object::Ice_invokeResult>>().get_future()) { - return ice_invokeAsync<P>(operation, mode, ::IceInternal::makePair(inP), ctx); + return ice_invokeAsync<P>(operation, mode, ::IceInternal::makePair(inP), context); } ::std::function<void()> @@ -389,7 +389,7 @@ public: ::std::function<void(bool, ::std::vector<::Ice::Byte>)> response, ::std::function<void(::std::exception_ptr)> ex = nullptr, ::std::function<void(bool)> sent = nullptr, - const ::Ice::Context& ctx = ::Ice::noExplicitContext) + const ::Ice::Context& context = ::Ice::noExplicitContext) { using Outgoing = ::IceInternal::InvokeLambdaOutgoing<::Ice::Object::Ice_invokeResult>; ::std::function<void(::Ice::Object::Ice_invokeResult&&)> r; @@ -401,7 +401,7 @@ public: }; } auto outAsync = ::std::make_shared<Outgoing>(shared_from_this(), r, ex, sent); - outAsync->invoke(operation, mode, ::IceInternal::makePair(inP), ctx); + outAsync->invoke(operation, mode, ::IceInternal::makePair(inP), context); return [outAsync]() { outAsync->cancel(); }; } @@ -415,12 +415,12 @@ public: ::Ice::OperationMode mode, const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inP, ::std::vector<::Ice::Byte>& outParams, - const ::Ice::Context& ctx = ::Ice::noExplicitContext) + const ::Ice::Context& context = ::Ice::noExplicitContext) { using Outgoing = ::IceInternal::InvokePromiseOutgoing< ::std::promise<::Ice::Object::Ice_invokeResult>, ::Ice::Object::Ice_invokeResult>; auto outAsync = ::std::make_shared<Outgoing>(shared_from_this(), true); - outAsync->invoke(operation, mode, inP, ctx); + outAsync->invoke(operation, mode, inP, context); auto result = outAsync->getFuture().get(); outParams.swap(result.outParams); return result.returnValue; @@ -430,13 +430,13 @@ public: ice_invokeAsync(const ::std::string& operation, ::Ice::OperationMode mode, const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inP, - const ::Ice::Context& ctx = ::Ice::noExplicitContext) + const ::Ice::Context& context = ::Ice::noExplicitContext) -> decltype(std::declval<P<::Ice::Object::Ice_invokeResult>>().get_future()) { using Outgoing = ::IceInternal::InvokePromiseOutgoing<P<::Ice::Object::Ice_invokeResult>, ::Ice::Object::Ice_invokeResult>; auto outAsync = ::std::make_shared<Outgoing>(shared_from_this(), false); - outAsync->invoke(operation, mode, inP, ctx); + outAsync->invoke(operation, mode, inP, context); return outAsync->getFuture(); } @@ -447,7 +447,7 @@ public: ::std::function<void(bool, ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>)> response, ::std::function<void(::std::exception_ptr)> ex = nullptr, ::std::function<void(bool)> sent = nullptr, - const ::Ice::Context& ctx = ::Ice::noExplicitContext) + const ::Ice::Context& context = ::Ice::noExplicitContext) { using Result = ::std::tuple<bool, ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>>; using Outgoing = ::IceInternal::InvokeLambdaOutgoing<Result>; @@ -461,7 +461,7 @@ public: }; } auto outAsync = ::std::make_shared<Outgoing>(shared_from_this(), r, ex, sent); - outAsync->invoke(operation, mode, inP, ctx); + outAsync->invoke(operation, mode, inP, context); return [outAsync]() { outAsync->cancel(); }; } @@ -541,7 +541,7 @@ public: { using LambdaOutgoing = ::IceInternal::ProxyGetConnectionLambda; auto outAsync = ::std::make_shared<LambdaOutgoing>(shared_from_this(), response, ex, sent); - __ice_getConnection(outAsync); + _iceI_getConnection(outAsync); return [outAsync]() { outAsync->cancel(); }; } @@ -550,11 +550,11 @@ public: { using PromiseOutgoing = ::IceInternal::ProxyGetConnectionPromise<P<::std::shared_ptr<::Ice::Connection>>>; auto outAsync = ::std::make_shared<PromiseOutgoing>(shared_from_this()); - __ice_getConnection(outAsync); + _iceI_getConnection(outAsync); return outAsync->getFuture(); } - void __ice_getConnection(const ::std::shared_ptr<::IceInternal::ProxyGetConnection>&); + void _iceI_getConnection(const ::std::shared_ptr<::IceInternal::ProxyGetConnection>&); ::std::shared_ptr<::Ice::Connection> ice_getCachedConnection() const; @@ -569,7 +569,7 @@ public: { using LambdaOutgoing = ::IceInternal::ProxyFlushBatchLambda; auto outAsync = ::std::make_shared<LambdaOutgoing>(shared_from_this(), ex, sent); - __ice_flushBatchRequests(outAsync); + _iceI_flushBatchRequests(outAsync); return [outAsync]() { outAsync->cancel(); }; } @@ -578,34 +578,34 @@ public: { using PromiseOutgoing = ::IceInternal::ProxyFlushBatchPromise<P<bool>>; auto outAsync = ::std::make_shared<PromiseOutgoing>(shared_from_this()); - __ice_flushBatchRequests(outAsync); + _iceI_flushBatchRequests(outAsync); return outAsync->getFuture(); } - void __ice_flushBatchRequests(const ::std::shared_ptr<::IceInternal::ProxyFlushBatchAsync>&); + void _iceI_flushBatchRequests(const ::std::shared_ptr<::IceInternal::ProxyFlushBatchAsync>&); - const ::IceInternal::ReferencePtr& __reference() const { return _reference; } + const ::IceInternal::ReferencePtr& _getReference() const { return _reference; } - void __copyFrom(const std::shared_ptr<::Ice::ObjectPrx>&); + void _copyFrom(const std::shared_ptr<::Ice::ObjectPrx>&); - int __handleException(const ::Ice::Exception&, const ::IceInternal::RequestHandlerPtr&, ::Ice::OperationMode, + int _handleException(const ::Ice::Exception&, const ::IceInternal::RequestHandlerPtr&, ::Ice::OperationMode, bool, int&); - void __checkTwowayOnly(const ::std::string&) const; + void _checkTwowayOnly(const ::std::string&) const; - ::IceInternal::RequestHandlerPtr __getRequestHandler(); - ::IceInternal::BatchRequestQueuePtr __getBatchRequestQueue(); - ::IceInternal::RequestHandlerPtr __setRequestHandler(const ::IceInternal::RequestHandlerPtr&); - void __updateRequestHandler(const ::IceInternal::RequestHandlerPtr&, const ::IceInternal::RequestHandlerPtr&); + ::IceInternal::RequestHandlerPtr _getRequestHandler(); + ::IceInternal::BatchRequestQueuePtr _getBatchRequestQueue(); + ::IceInternal::RequestHandlerPtr _setRequestHandler(const ::IceInternal::RequestHandlerPtr&); + void _updateRequestHandler(const ::IceInternal::RequestHandlerPtr&, const ::IceInternal::RequestHandlerPtr&); - int __hash() const; + int _hash() const; - void __write(OutputStream&) const; + void _write(OutputStream&) const; protected: template<typename R, template<typename> class P = ::std::promise, typename Obj, typename Fn, typename... Args> - auto makePromiseOutgoing(bool sync, Obj obj, Fn fn, Args&&... args) + auto _makePromiseOutgoing(bool sync, Obj obj, Fn fn, Args&&... args) -> decltype(std::declval<P<R>>().get_future()) { auto outAsync = ::std::make_shared<::IceInternal::PromiseOutgoing<P<R>, R>>(shared_from_this(), sync); @@ -614,14 +614,14 @@ protected: } template<typename R, typename Re, typename E, typename S, typename Obj, typename Fn, typename... Args> - ::std::function<void()> makeLambdaOutgoing(Re r, E e, S s, Obj obj, Fn fn, Args&&... 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); (obj->*fn)(outAsync, std::forward<Args>(args)...); return [outAsync]() { outAsync->cancel(); }; } - virtual ::std::shared_ptr<ObjectPrx> __newInstance() const; + virtual ::std::shared_ptr<ObjectPrx> _newInstance() const; ObjectPrx() = default; friend ::std::shared_ptr<ObjectPrx> IceInternal::createProxy<ObjectPrx>(); @@ -772,7 +772,7 @@ public: protected: - virtual ::std::shared_ptr<ObjectPrx> __newInstance() const = 0; + virtual ::std::shared_ptr<ObjectPrx> _newInstance() const = 0; }; ICE_API ::std::ostream& operator<<(::std::ostream&, const ::Ice::ObjectPrx&); @@ -828,7 +828,7 @@ uncheckedCast(const ::std::shared_ptr<T>& b) if(!r) { r = IceInternal::createProxy<P>(); - r->__copyFrom(b); + r->_copyFrom(b); } } return r; @@ -844,7 +844,7 @@ uncheckedCast(const ::std::shared_ptr<T>& b, const std::string& f) if(b) { r = IceInternal::createProxy<P>(); - r->__copyFrom(b->ice_facet(f)); + r->_copyFrom(b->ice_facet(f)); } return r; } @@ -861,7 +861,7 @@ checkedCast(const ::std::shared_ptr<T>& b, const ::Ice::Context& context = Ice:: if(b->ice_isA(P::ice_staticId(), context)) { r = IceInternal::createProxy<P>(); - r->__copyFrom(b); + r->_copyFrom(b); } } return r; @@ -882,7 +882,7 @@ checkedCast(const ::std::shared_ptr<T>& b, const std::string& f, const ::Ice::Co if(bb->ice_isA(P::ice_staticId(), context)) { r = IceInternal::createProxy<P>(); - r->__copyFrom(bb); + r->_copyFrom(bb); } } catch(const Ice::FacetNotExistException&) @@ -962,157 +962,157 @@ public: ::std::string ice_toString() const; - bool ice_isA(const ::std::string& typeId, const ::Ice::Context& ctx = ::Ice::noExplicitContext) + bool ice_isA(const ::std::string& typeId, const ::Ice::Context& context = ::Ice::noExplicitContext) { - return end_ice_isA(__begin_ice_isA(typeId, ctx, ::IceInternal::__dummyCallback, 0, true)); + return end_ice_isA(_iceI_begin_ice_isA(typeId, context, ::IceInternal::dummyCallback, 0, true)); } ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string& typeId, - const ::Ice::Context& ctx = ::Ice::noExplicitContext) + const ::Ice::Context& context = ::Ice::noExplicitContext) { - return __begin_ice_isA(typeId, ctx, ::IceInternal::__dummyCallback, 0); + return _iceI_begin_ice_isA(typeId, context, ::IceInternal::dummyCallback, 0); } ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string& typeId, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_isA(typeId, ::Ice::noExplicitContext, del, cookie); + return _iceI_begin_ice_isA(typeId, ::Ice::noExplicitContext, del, cookie); } ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string& typeId, - const ::Ice::Context& ctx, + const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_isA(typeId, ctx, del, cookie); + return _iceI_begin_ice_isA(typeId, context, del, cookie); } ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string& typeId, const ::Ice::Callback_Object_ice_isAPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_isA(typeId, ::Ice::noExplicitContext, del, cookie); + return _iceI_begin_ice_isA(typeId, ::Ice::noExplicitContext, del, cookie); } ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string& typeId, - const ::Ice::Context& ctx, + const ::Ice::Context& context, const ::Ice::Callback_Object_ice_isAPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_isA(typeId, ctx, del, cookie); + return _iceI_begin_ice_isA(typeId, context, del, cookie); } bool end_ice_isA(const ::Ice::AsyncResultPtr&); - void ice_ping(const ::Ice::Context& ctx = ::Ice::noExplicitContext) + void ice_ping(const ::Ice::Context& context = ::Ice::noExplicitContext) { - end_ice_ping(__begin_ice_ping(ctx, ::IceInternal::__dummyCallback, 0, true)); + end_ice_ping(_iceI_begin_ice_ping(context, ::IceInternal::dummyCallback, 0, true)); } - ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::Context& ctx = ::Ice::noExplicitContext) + ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::Context& context = ::Ice::noExplicitContext) { - return __begin_ice_ping(ctx, ::IceInternal::__dummyCallback, 0); + return _iceI_begin_ice_ping(context, ::IceInternal::dummyCallback, 0); } ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_ping(::Ice::noExplicitContext, del, cookie); + return _iceI_begin_ice_ping(::Ice::noExplicitContext, del, cookie); } - ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::Context& ctx, const ::Ice::CallbackPtr& del, + ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_ping(ctx, del, cookie); + return _iceI_begin_ice_ping(context, del, cookie); } ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::Callback_Object_ice_pingPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_ping(::Ice::noExplicitContext, del, cookie); + return _iceI_begin_ice_ping(::Ice::noExplicitContext, del, cookie); } - ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::Context& ctx, const ::Ice::Callback_Object_ice_pingPtr& del, + ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::Context& context, const ::Ice::Callback_Object_ice_pingPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_ping(ctx, del, cookie); + return _iceI_begin_ice_ping(context, del, cookie); } void end_ice_ping(const ::Ice::AsyncResultPtr&); - ::std::vector< ::std::string> ice_ids(const ::Ice::Context& ctx = ::Ice::noExplicitContext) + ::std::vector< ::std::string> ice_ids(const ::Ice::Context& context = ::Ice::noExplicitContext) { - return end_ice_ids(__begin_ice_ids(ctx, ::IceInternal::__dummyCallback, 0, true)); + return end_ice_ids(_iceI_begin_ice_ids(context, ::IceInternal::dummyCallback, 0, true)); } - ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::Context& ctx = ::Ice::noExplicitContext) + ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::Context& context = ::Ice::noExplicitContext) { - return __begin_ice_ids(ctx, ::IceInternal::__dummyCallback, 0); + return _iceI_begin_ice_ids(context, ::IceInternal::dummyCallback, 0); } ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_ids(::Ice::noExplicitContext, del, cookie); + return _iceI_begin_ice_ids(::Ice::noExplicitContext, del, cookie); } - ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::Context& ctx, + ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_ids(ctx, del, cookie); + return _iceI_begin_ice_ids(context, del, cookie); } ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::Callback_Object_ice_idsPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_ids(::Ice::noExplicitContext, del, cookie); + return _iceI_begin_ice_ids(::Ice::noExplicitContext, del, cookie); } - ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::Context& ctx, + ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::Context& context, const ::Ice::Callback_Object_ice_idsPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_ids(ctx, del, cookie); + return _iceI_begin_ice_ids(context, del, cookie); } ::std::vector< ::std::string> end_ice_ids(const ::Ice::AsyncResultPtr&); - ::std::string ice_id(const ::Ice::Context& ctx = ::Ice::noExplicitContext) + ::std::string ice_id(const ::Ice::Context& context = ::Ice::noExplicitContext) { - return end_ice_id(__begin_ice_id(ctx, ::IceInternal::__dummyCallback, 0, true)); + return end_ice_id(_iceI_begin_ice_id(context, ::IceInternal::dummyCallback, 0, true)); } - ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::Context& ctx = ::Ice::noExplicitContext) + ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::Context& context = ::Ice::noExplicitContext) { - return __begin_ice_id(ctx, ::IceInternal::__dummyCallback, 0); + return _iceI_begin_ice_id(context, ::IceInternal::dummyCallback, 0); } ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_id(::Ice::noExplicitContext, del, cookie); + return _iceI_begin_ice_id(::Ice::noExplicitContext, del, cookie); } - ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::Context& ctx, + ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_id(ctx, del, cookie); + return _iceI_begin_ice_id(context, del, cookie); } ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::Callback_Object_ice_idPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_id(::Ice::noExplicitContext, del, cookie); + return _iceI_begin_ice_id(::Ice::noExplicitContext, del, cookie); } - ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::Context& ctx, + ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::Context& context, const ::Ice::Callback_Object_ice_idPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_id(ctx, del, cookie); + return _iceI_begin_ice_id(context, del, cookie); } ::std::string end_ice_id(const ::Ice::AsyncResultPtr&); @@ -1134,15 +1134,15 @@ public: ::Ice::OperationMode mode, const ::std::vector< ::Ice::Byte>& inParams) { - return __begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, ::IceInternal::__dummyCallback, 0); + return _iceI_begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, ::IceInternal::dummyCallback, 0); } ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op, ::Ice::OperationMode mode, const ::std::vector< ::Ice::Byte>& inParams, - const ::Ice::Context& ctx) + const ::Ice::Context& context) { - return __begin_ice_invoke(op, mode, inParams, ctx, ::IceInternal::__dummyCallback, 0); + return _iceI_begin_ice_invoke(op, mode, inParams, context, ::IceInternal::dummyCallback, 0); } ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op, @@ -1151,17 +1151,17 @@ public: const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie); + return _iceI_begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie); } ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op, ::Ice::OperationMode mode, const ::std::vector< ::Ice::Byte>& inParams, - const ::Ice::Context& ctx, + const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_invoke(op, mode, inParams, ctx, del, cookie); + return _iceI_begin_ice_invoke(op, mode, inParams, context, del, cookie); } ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op, @@ -1170,17 +1170,17 @@ public: const ::Ice::Callback_Object_ice_invokePtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie); + return _iceI_begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie); } ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op, ::Ice::OperationMode mode, const ::std::vector< ::Ice::Byte>& inParams, - const ::Ice::Context& ctx, + const ::Ice::Context& context, const ::Ice::Callback_Object_ice_invokePtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_invoke(op, mode, inParams, ctx, del, cookie); + return _iceI_begin_ice_invoke(op, mode, inParams, context, del, cookie); } bool end_ice_invoke(::std::vector< ::Ice::Byte>&, const ::Ice::AsyncResultPtr&); @@ -1189,25 +1189,25 @@ public: ::Ice::OperationMode mode, const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inP, ::std::vector< ::Ice::Byte>& outP, - const ::Ice::Context& ctx = ::Ice::noExplicitContext) + const ::Ice::Context& context = ::Ice::noExplicitContext) { - return end_ice_invoke(outP, __begin_ice_invoke(op, mode, inP, ctx, ::IceInternal::__dummyCallback, 0, true)); + return end_ice_invoke(outP, _iceI_begin_ice_invoke(op, mode, inP, context, ::IceInternal::dummyCallback, 0, true)); } ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op, ::Ice::OperationMode mode, const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams) { - return __begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, ::IceInternal::__dummyCallback, 0); + return _iceI_begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, ::IceInternal::dummyCallback, 0); } ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op, ::Ice::OperationMode mode, const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams, - const ::Ice::Context& ctx, + const ::Ice::Context& context, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_invoke(op, mode, inParams, ctx, ::IceInternal::__dummyCallback, cookie); + return _iceI_begin_ice_invoke(op, mode, inParams, context, ::IceInternal::dummyCallback, cookie); } ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op, @@ -1216,17 +1216,17 @@ public: const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie); + return _iceI_begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie); } ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op, ::Ice::OperationMode mode, const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams, - const ::Ice::Context& ctx, + const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_invoke(op, mode, inParams, ctx, del, cookie); + return _iceI_begin_ice_invoke(op, mode, inParams, context, del, cookie); } ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op, @@ -1235,20 +1235,20 @@ public: const ::Ice::Callback_Object_ice_invokePtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie); + return _iceI_begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie); } ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op, ::Ice::OperationMode mode, const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams, - const ::Ice::Context& ctx, + const ::Ice::Context& context, const ::Ice::Callback_Object_ice_invokePtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_invoke(op, mode, inParams, ctx, del, cookie); + return _iceI_begin_ice_invoke(op, mode, inParams, context, del, cookie); } - bool ___end_ice_invoke(::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&, const ::Ice::AsyncResultPtr&); + bool _iceI_end_ice_invoke(::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&, const ::Ice::AsyncResultPtr&); ::Ice::Identity ice_getIdentity() const; ::Ice::ObjectPrx ice_identity(const ::Ice::Identity&) const; @@ -1319,19 +1319,19 @@ public: ::Ice::AsyncResultPtr begin_ice_getConnection() { - return __begin_ice_getConnection(::IceInternal::__dummyCallback, 0); + return _iceI_begin_ice_getConnection(::IceInternal::dummyCallback, 0); } ::Ice::AsyncResultPtr begin_ice_getConnection(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_getConnection(del, cookie); + return _iceI_begin_ice_getConnection(del, cookie); } ::Ice::AsyncResultPtr begin_ice_getConnection(const ::Ice::Callback_Object_ice_getConnectionPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_getConnection(del, cookie); + return _iceI_begin_ice_getConnection(del, cookie); } ::Ice::ConnectionPtr end_ice_getConnection(const ::Ice::AsyncResultPtr&); @@ -1345,71 +1345,71 @@ public: ::Ice::AsyncResultPtr begin_ice_flushBatchRequests() { - return __begin_ice_flushBatchRequests(::IceInternal::__dummyCallback, 0); + return _iceI_begin_ice_flushBatchRequests(::IceInternal::dummyCallback, 0); } ::Ice::AsyncResultPtr begin_ice_flushBatchRequests(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_flushBatchRequests(del, cookie); + return _iceI_begin_ice_flushBatchRequests(del, cookie); } ::Ice::AsyncResultPtr begin_ice_flushBatchRequests(const ::Ice::Callback_Object_ice_flushBatchRequestsPtr& del, const ::Ice::LocalObjectPtr& cookie = 0) { - return __begin_ice_flushBatchRequests(del, cookie); + return _iceI_begin_ice_flushBatchRequests(del, cookie); } void end_ice_flushBatchRequests(const ::Ice::AsyncResultPtr&); - const ::IceInternal::ReferencePtr& __reference() const { return _reference; } + const ::IceInternal::ReferencePtr& _getReference() const { return _reference; } - ::Ice::Int __hash() const; + ::Ice::Int _hash() const; - void __copyFrom(const ::Ice::ObjectPrx&); + void _copyFrom(const ::Ice::ObjectPrx&); - int __handleException(const ::Ice::Exception&, const ::IceInternal::RequestHandlerPtr&, ::Ice::OperationMode, + int _handleException(const ::Ice::Exception&, const ::IceInternal::RequestHandlerPtr&, ::Ice::OperationMode, bool, int&); - void __checkTwowayOnly(const ::std::string&, bool) const; + void _checkTwowayOnly(const ::std::string&, bool) const; - void __end(const ::Ice::AsyncResultPtr&, const std::string&) const; + void _end(const ::Ice::AsyncResultPtr&, const std::string&) const; - ::IceInternal::RequestHandlerPtr __getRequestHandler(); - ::IceInternal::BatchRequestQueuePtr __getBatchRequestQueue(); - ::IceInternal::RequestHandlerPtr __setRequestHandler(const ::IceInternal::RequestHandlerPtr&); - void __updateRequestHandler(const ::IceInternal::RequestHandlerPtr&, const ::IceInternal::RequestHandlerPtr&); + ::IceInternal::RequestHandlerPtr _getRequestHandler(); + ::IceInternal::BatchRequestQueuePtr _getBatchRequestQueue(); + ::IceInternal::RequestHandlerPtr _setRequestHandler(const ::IceInternal::RequestHandlerPtr&); + void _updateRequestHandler(const ::IceInternal::RequestHandlerPtr&, const ::IceInternal::RequestHandlerPtr&); - void __write(::Ice::OutputStream&) const; + void _write(::Ice::OutputStream&) const; protected: - virtual Object* __newInstance() const; + virtual Object* _newInstance() const; private: - ::Ice::AsyncResultPtr __begin_ice_isA(const ::std::string&, + ::Ice::AsyncResultPtr _iceI_begin_ice_isA(const ::std::string&, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr&, bool = false); - ::Ice::AsyncResultPtr __begin_ice_ping(const ::Ice::Context&, + ::Ice::AsyncResultPtr _iceI_begin_ice_ping(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr&, bool = false); - ::Ice::AsyncResultPtr __begin_ice_ids(const ::Ice::Context&, + ::Ice::AsyncResultPtr _iceI_begin_ice_ids(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr&, bool = false); - ::Ice::AsyncResultPtr __begin_ice_id(const ::Ice::Context&, + ::Ice::AsyncResultPtr _iceI_begin_ice_id(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr&, bool = false); - ::Ice::AsyncResultPtr __begin_ice_invoke(const ::std::string&, + ::Ice::AsyncResultPtr _iceI_begin_ice_invoke(const ::std::string&, ::Ice::OperationMode, const ::std::vector< ::Ice::Byte>&, const ::Ice::Context&, @@ -1417,7 +1417,7 @@ private: const ::Ice::LocalObjectPtr&, bool = false); - ::Ice::AsyncResultPtr __begin_ice_invoke(const ::std::string&, + ::Ice::AsyncResultPtr _iceI_begin_ice_invoke(const ::std::string&, ::Ice::OperationMode, const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&, const ::Ice::Context&, @@ -1425,10 +1425,10 @@ private: const ::Ice::LocalObjectPtr&, bool = false); - ::Ice::AsyncResultPtr __begin_ice_getConnection(const ::IceInternal::CallbackBasePtr&, + ::Ice::AsyncResultPtr _iceI_begin_ice_getConnection(const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr&); - ::Ice::AsyncResultPtr __begin_ice_flushBatchRequests(const ::IceInternal::CallbackBasePtr&, + ::Ice::AsyncResultPtr _iceI_begin_ice_flushBatchRequests(const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr&); void setup(const ::IceInternal::ReferencePtr&); @@ -1559,7 +1559,7 @@ public: protected: - virtual ::IceProxy::Ice::Object* __newInstance() const = 0; + virtual ::IceProxy::Ice::Object* _newInstance() const = 0; }; ICE_API bool proxyIdentityLess(const ObjectPrx&, const ObjectPrx&); @@ -1611,8 +1611,8 @@ namespace IceInternal template<typename T, typename U> inline bool operator==(const ProxyHandle<T>& lhs, const ProxyHandle<U>& rhs) { - ::IceProxy::Ice::Object* l = lhs.__upCast(); - ::IceProxy::Ice::Object* r = rhs.__upCast(); + ::IceProxy::Ice::Object* l = lhs._upCast(); + ::IceProxy::Ice::Object* r = rhs._upCast(); if(l && r) { return *l == *r; @@ -1632,8 +1632,8 @@ inline bool operator!=(const ProxyHandle<T>& lhs, const ProxyHandle<U>& rhs) template<typename T, typename U> inline bool operator<(const ProxyHandle<T>& lhs, const ProxyHandle<U>& rhs) { - ::IceProxy::Ice::Object* l = lhs.__upCast(); - ::IceProxy::Ice::Object* r = rhs.__upCast(); + ::IceProxy::Ice::Object* l = lhs._upCast(); + ::IceProxy::Ice::Object* r = rhs._upCast(); if(l && r) { return *l < *r; @@ -1677,7 +1677,7 @@ checkedCastImpl(const ::Ice::ObjectPrx& b, const ::Ice::Context& context) if(b->ice_isA(T::ice_staticId(), context)) { d = new T; - d->__copyFrom(b); + d->_copyFrom(b); } } return d; @@ -1695,7 +1695,7 @@ uncheckedCastImpl(const ::Ice::ObjectPrx& b) if(!d) { d = new T; - d->__copyFrom(b); + d->_copyFrom(b); } } return d; @@ -1744,7 +1744,7 @@ checkedCastImpl(const ::Ice::ObjectPrx& b, const std::string& f, const ::Ice::Co if(bb) { d = new T; - d->__copyFrom(bb); + d->_copyFrom(bb); } return d; } @@ -1759,7 +1759,7 @@ uncheckedCastImpl(const ::Ice::ObjectPrx& b, const std::string& f) ::Ice::ObjectPrx bb = b->ice_facet(f); d = new T; - d->__copyFrom(bb); + d->_copyFrom(bb); } return d; } @@ -1772,10 +1772,10 @@ namespace Ice { template<typename P, typename Y> inline P -checkedCast(const ::IceInternal::ProxyHandle<Y>& b, const ::Ice::Context& ctx = ::Ice::noExplicitContext) +checkedCast(const ::IceInternal::ProxyHandle<Y>& b, const ::Ice::Context& context = ::Ice::noExplicitContext) { Y* tag = 0; - return ::IceInternal::checkedCastHelper<typename P::element_type>(b, tag, ctx); + return ::IceInternal::checkedCastHelper<typename P::element_type>(b, tag, context); } template<typename P, typename Y> inline P @@ -1786,9 +1786,9 @@ uncheckedCast(const ::IceInternal::ProxyHandle<Y>& b) } template<typename P> inline P -checkedCast(const ::Ice::ObjectPrx& b, const std::string& f, const ::Ice::Context& ctx = ::Ice::noExplicitContext) +checkedCast(const ::Ice::ObjectPrx& b, const std::string& f, const ::Ice::Context& context = ::Ice::noExplicitContext) { - return ::IceInternal::checkedCastImpl<P>(b, f, ctx); + return ::IceInternal::checkedCastImpl<P>(b, f, context); } template<typename P> inline P @@ -1977,7 +1977,7 @@ public: { try { - result->getProxy()->__end(result, result->getOperation()); + result->getProxy()->_end(result, result->getOperation()); } catch(const ::Ice::Exception& ex) { @@ -2016,7 +2016,7 @@ public: { try { - result->getProxy()->__end(result, result->getOperation()); + result->getProxy()->_end(result, result->getOperation()); } catch(const ::Ice::Exception& ex) { @@ -2055,21 +2055,21 @@ public: { } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& result) const { - bool __ret; + bool ret; try { - __ret = __result->getProxy()->end_ice_isA(__result); + ret = result->getProxy()->end_ice_isA(result); } catch(const ::Ice::Exception& ex) { - ::IceInternal::CallbackNC<T>::exception(__result, ex); + ::IceInternal::CallbackNC<T>::exception(result, ex); return; } if(_response) { - (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(__ret); + (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret); } } @@ -2094,22 +2094,22 @@ public: { } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& result) const { - bool __ret; + bool ret; try { - __ret = __result->getProxy()->end_ice_isA(__result); + ret = result->getProxy()->end_ice_isA(result); } catch(const ::Ice::Exception& ex) { - ::IceInternal::Callback<T, CT>::exception(__result, ex); + ::IceInternal::Callback<T, CT>::exception(result, ex); return; } if(_response) { - (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(__ret, - CT::dynamicCast(__result->getCookie())); + (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret, + CT::dynamicCast(result->getCookie())); } } @@ -2168,21 +2168,21 @@ public: { } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& result) const { - ::std::vector< ::std::string> __ret; + ::std::vector< ::std::string> ret; try { - __ret = __result->getProxy()->end_ice_ids(__result); + ret = result->getProxy()->end_ice_ids(result); } catch(const ::Ice::Exception& ex) { - ::IceInternal::CallbackNC<T>::exception(__result, ex); + ::IceInternal::CallbackNC<T>::exception(result, ex); return; } if(_response) { - (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(__ret); + (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret); } } @@ -2207,22 +2207,22 @@ public: { } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& result) const { - ::std::vector< ::std::string> __ret; + ::std::vector< ::std::string> ret; try { - __ret = __result->getProxy()->end_ice_ids(__result); + ret = result->getProxy()->end_ice_ids(result); } catch(const ::Ice::Exception& ex) { - ::IceInternal::Callback<T, CT>::exception(__result, ex); + ::IceInternal::Callback<T, CT>::exception(result, ex); return; } if(_response) { - (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(__ret, - CT::dynamicCast(__result->getCookie())); + (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret, + CT::dynamicCast(result->getCookie())); } } @@ -2247,21 +2247,21 @@ public: { } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& result) const { - ::std::string __ret; + ::std::string ret; try { - __ret = __result->getProxy()->end_ice_id(__result); + ret = result->getProxy()->end_ice_id(result); } catch(const ::Ice::Exception& ex) { - ::IceInternal::CallbackNC<T>::exception(__result, ex); + ::IceInternal::CallbackNC<T>::exception(result, ex); return; } if(_response) { - (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(__ret); + (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret); } } @@ -2286,22 +2286,22 @@ public: { } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& result) const { - ::std::string __ret; + ::std::string ret; try { - __ret = __result->getProxy()->end_ice_id(__result); + ret = result->getProxy()->end_ice_id(result); } catch(const ::Ice::Exception& ex) { - ::IceInternal::Callback<T, CT>::exception(__result, ex); + ::IceInternal::Callback<T, CT>::exception(result, ex); return; } if(_response) { - (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(__ret, - CT::dynamicCast(__result->getCookie())); + (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret, + CT::dynamicCast(result->getCookie())); } } @@ -2332,39 +2332,39 @@ public: { } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& result) const { if(_response) { - bool __ok; + bool ok; std::vector< ::Ice::Byte> outParams; try { - __ok = __result->getProxy()->end_ice_invoke(outParams, __result); + ok = result->getProxy()->end_ice_invoke(outParams, result); } catch(const ::Ice::Exception& ex) { - ::IceInternal::CallbackNC<T>::exception(__result, ex); + ::IceInternal::CallbackNC<T>::exception(result, ex); return; } - (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(__ok, outParams); + (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ok, outParams); } else { - bool __ok; + bool ok; std::pair<const ::Ice::Byte*, const::Ice::Byte*> outParams; try { - __ok = __result->getProxy()->___end_ice_invoke(outParams, __result); + ok = result->getProxy()->_iceI_end_ice_invoke(outParams, result); } catch(const ::Ice::Exception& ex) { - ::IceInternal::CallbackNC<T>::exception(__result, ex); + ::IceInternal::CallbackNC<T>::exception(result, ex); return; } if(_responseArray) { - (::IceInternal::CallbackNC<T>::_callback.get()->*_responseArray)(__ok, outParams); + (::IceInternal::CallbackNC<T>::_callback.get()->*_responseArray)(ok, outParams); } } } @@ -2397,44 +2397,44 @@ public: { } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& result) const { if(_response) { - bool __ok; + bool ok; std::vector< ::Ice::Byte> outParams; try { - __ok = __result->getProxy()->end_ice_invoke(outParams, __result); + ok = result->getProxy()->end_ice_invoke(outParams, result); } catch(const ::Ice::Exception& ex) { - ::IceInternal::Callback<T, CT>::exception(__result, ex); + ::IceInternal::Callback<T, CT>::exception(result, ex); return; } - (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(__ok, + (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ok, outParams, - CT::dynamicCast(__result->getCookie())); + CT::dynamicCast(result->getCookie())); } else { - bool __ok; + bool ok; std::pair<const ::Ice::Byte*, const::Ice::Byte*> outParams; try { - __ok = __result->getProxy()->___end_ice_invoke(outParams, __result); + ok = result->getProxy()->_iceI_end_ice_invoke(outParams, result); } catch(const ::Ice::Exception& ex) { - ::IceInternal::Callback<T, CT>::exception(__result, ex); + ::IceInternal::Callback<T, CT>::exception(result, ex); return; } if(_responseArray) { - (::IceInternal::Callback<T, CT>::_callback.get()->*_responseArray)(__ok, + (::IceInternal::Callback<T, CT>::_callback.get()->*_responseArray)(ok, outParams, CT::dynamicCast( - __result->getCookie())); + result->getCookie())); } } } @@ -2463,21 +2463,21 @@ public: } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& result) const { - ::Ice::ConnectionPtr __ret; + ::Ice::ConnectionPtr ret; try { - __ret = __result->getProxy()->end_ice_getConnection(__result); + ret = result->getProxy()->end_ice_getConnection(result); } catch(const ::Ice::Exception& ex) { - ::IceInternal::CallbackNC<T>::exception(__result, ex); + ::IceInternal::CallbackNC<T>::exception(result, ex); return; } if(_response) { - (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(__ret); + (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret); } } @@ -2503,22 +2503,22 @@ public: { } - virtual void completed(const ::Ice::AsyncResultPtr& __result) const + virtual void completed(const ::Ice::AsyncResultPtr& result) const { - ::Ice::ConnectionPtr __ret; + ::Ice::ConnectionPtr ret; try { - __ret = __result->getProxy()->end_ice_getConnection(__result); + ret = result->getProxy()->end_ice_getConnection(result); } catch(const ::Ice::Exception& ex) { - ::IceInternal::Callback<T, CT>::exception(__result, ex); + ::IceInternal::Callback<T, CT>::exception(result, ex); return; } if(_response) { - (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(__ret, - CT::dynamicCast(__result->getCookie())); + (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret, + CT::dynamicCast(result->getCookie())); } } diff --git a/cpp/include/Ice/ProxyHandle.h b/cpp/include/Ice/ProxyHandle.h index 628fb2b460b..d763a146513 100644 --- a/cpp/include/Ice/ProxyHandle.h +++ b/cpp/include/Ice/ProxyHandle.h @@ -247,7 +247,7 @@ public: return *this; } - ::IceProxy::Ice::Object* __upCast() const + ::IceProxy::Ice::Object* _upCast() const { return upCast(this->_ptr); } diff --git a/cpp/include/Ice/SlicedData.h b/cpp/include/Ice/SlicedData.h index dcd322b661b..820bdda2732 100644 --- a/cpp/include/Ice/SlicedData.h +++ b/cpp/include/Ice/SlicedData.h @@ -74,7 +74,7 @@ public: const SliceInfoSeq slices; #ifndef ICE_CPP11_MAPPING - void __gcVisitMembers(IceInternal::GCVisitor&); + void _iceGcVisitMembers(IceInternal::GCVisitor&); #endif }; @@ -97,8 +97,8 @@ public: SlicedDataPtr getSlicedData() const; #ifdef ICE_CPP11_MAPPING - virtual void __write(::Ice::OutputStream*) const override; - virtual void __read(::Ice::InputStream*) override; + virtual void _iceWrite(::Ice::OutputStream*) const override; + virtual void _iceRead(::Ice::InputStream*) override; virtual std::string ice_id() const override; std::shared_ptr<UnknownSlicedValue> ice_clone() const; @@ -107,10 +107,10 @@ protected: virtual std::shared_ptr<Value> cloneImpl() const override; #else - virtual void __gcVisitMembers(IceInternal::GCVisitor&); + virtual void _iceGcVisitMembers(IceInternal::GCVisitor&); - virtual void __write(::Ice::OutputStream*) const; - virtual void __read(::Ice::InputStream*); + virtual void _iceWrite(::Ice::OutputStream*) const; + virtual void _iceRead(::Ice::InputStream*); #endif private: diff --git a/cpp/include/Ice/Value.h b/cpp/include/Ice/Value.h index b2c4b4f2b57..411f5661792 100644 --- a/cpp/include/Ice/Value.h +++ b/cpp/include/Ice/Value.h @@ -29,8 +29,8 @@ public: virtual void ice_preMarshal(); virtual void ice_postUnmarshal(); - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); + virtual void _iceWrite(Ice::OutputStream*) const; + virtual void _iceRead(Ice::InputStream*); virtual std::string ice_id() const; static const std::string& ice_staticId(); @@ -41,8 +41,8 @@ protected: virtual std::shared_ptr<Value> cloneImpl() const = 0; - virtual void __writeImpl(Ice::OutputStream*) const {} - virtual void __readImpl(Ice::InputStream*) {} + virtual void _iceWriteImpl(Ice::OutputStream*) const {} + virtual void _iceReadImpl(Ice::InputStream*) {} }; template<typename T, typename Base> class ValueHelper : public Base @@ -70,20 +70,20 @@ protected: return std::make_shared<T>(static_cast<const T&>(*this)); } - virtual void __writeImpl(Ice::OutputStream* os) const override + virtual void _iceWriteImpl(Ice::OutputStream* os) const override { os->startSlice(T::ice_staticId(), -1, std::is_same<Base, Ice::Value>::value ? true : false); Ice::StreamWriter<T, Ice::OutputStream>::write(os, static_cast<const T&>(*this)); os->endSlice(); - Base::__writeImpl(os); + Base::_iceWriteImpl(os); } - virtual void __readImpl(Ice::InputStream* is) override + virtual void _iceReadImpl(Ice::InputStream* is) override { is->startSlice(); Ice::StreamReader<T, Ice::InputStream>::read(is, static_cast<T&>(*this)); is->endSlice(); - Base::__readImpl(is); + Base::_iceReadImpl(is); } }; diff --git a/cpp/src/Ice/AsyncResult.cpp b/cpp/src/Ice/AsyncResult.cpp index 60e5ac65773..bc19855bdb7 100644 --- a/cpp/src/Ice/AsyncResult.cpp +++ b/cpp/src/Ice/AsyncResult.cpp @@ -24,9 +24,9 @@ AsyncResult::~AsyncResult() } void -AsyncResult::__check(const AsyncResultPtr& r, const IceProxy::Ice::Object* prx, const string& operation) +AsyncResult::check(const AsyncResultPtr& r, const IceProxy::Ice::Object* prx, const string& operation) { - __check(r, operation); + check(r, operation); if(r->getProxy().get() != prx) { throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "Proxy for call to end_" + operation + @@ -36,9 +36,9 @@ AsyncResult::__check(const AsyncResultPtr& r, const IceProxy::Ice::Object* prx, } void -AsyncResult::__check(const AsyncResultPtr& r, const Ice::Communicator* com, const string& operation) +AsyncResult::check(const AsyncResultPtr& r, const Ice::Communicator* com, const string& operation) { - __check(r, operation); + check(r, operation); if(r->getCommunicator().get() != com) { throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "Communicator for call to end_" + operation + @@ -48,9 +48,9 @@ AsyncResult::__check(const AsyncResultPtr& r, const Ice::Communicator* com, cons } void -AsyncResult::__check(const AsyncResultPtr& r, const Ice::Connection* con, const string& operation) +AsyncResult::check(const AsyncResultPtr& r, const Ice::Connection* con, const string& operation) { - __check(r, operation); + check(r, operation); if(r->getConnection().get() != con) { throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "Connection for call to end_" + operation + @@ -60,7 +60,7 @@ AsyncResult::__check(const AsyncResultPtr& r, const Ice::Connection* con, const } void -AsyncResult::__check(const AsyncResultPtr& r, const string& operation) +AsyncResult::check(const AsyncResultPtr& r, const string& operation) { if(!r) { diff --git a/cpp/src/Ice/CommunicatorI.cpp b/cpp/src/Ice/CommunicatorI.cpp index 99c332f629e..a6678b4bd3f 100644 --- a/cpp/src/Ice/CommunicatorI.cpp +++ b/cpp/src/Ice/CommunicatorI.cpp @@ -204,7 +204,7 @@ Ice::CommunicatorI::getValueFactoryManager() const namespace { -const ::std::string __flushBatchRequests_name = "flushBatchRequests"; +const ::std::string flushBatchRequests_name = "flushBatchRequests"; } @@ -230,7 +230,7 @@ Ice::CommunicatorI::flushBatchRequestsAsync(function<void(exception_ptr)> ex, fu } }; auto outAsync = make_shared<CommunicatorFlushBatchLambda>(_instance, ex, sent); - outAsync->invoke(__flushBatchRequests_name); + outAsync->invoke(flushBatchRequests_name); return [outAsync]() { outAsync->cancel(); }; } @@ -245,24 +245,24 @@ Ice::CommunicatorI::flushBatchRequests() AsyncResultPtr Ice::CommunicatorI::begin_flushBatchRequests() { - return __begin_flushBatchRequests(::IceInternal::__dummyCallback, 0); + return _iceI_begin_flushBatchRequests(::IceInternal::dummyCallback, 0); } AsyncResultPtr Ice::CommunicatorI::begin_flushBatchRequests(const CallbackPtr& cb, const LocalObjectPtr& cookie) { - return __begin_flushBatchRequests(cb, cookie); + return _iceI_begin_flushBatchRequests(cb, cookie); } AsyncResultPtr Ice::CommunicatorI::begin_flushBatchRequests(const Callback_Communicator_flushBatchRequestsPtr& cb, const LocalObjectPtr& cookie) { - return __begin_flushBatchRequests(cb, cookie); + return _iceI_begin_flushBatchRequests(cb, cookie); } AsyncResultPtr -Ice::CommunicatorI::__begin_flushBatchRequests(const IceInternal::CallbackBasePtr& cb, const LocalObjectPtr& cookie) +Ice::CommunicatorI::_iceI_begin_flushBatchRequests(const IceInternal::CallbackBasePtr& cb, const LocalObjectPtr& cookie) { class CommunicatorFlushBatchAsyncWithCallback : public CommunicatorFlushBatchAsync, public CallbackCompletion { @@ -285,7 +285,7 @@ Ice::CommunicatorI::__begin_flushBatchRequests(const IceInternal::CallbackBasePt virtual const std::string& getOperation() const { - return __flushBatchRequests_name; + return flushBatchRequests_name; } private: @@ -294,15 +294,15 @@ Ice::CommunicatorI::__begin_flushBatchRequests(const IceInternal::CallbackBasePt }; CommunicatorFlushBatchAsyncPtr result = new CommunicatorFlushBatchAsyncWithCallback(this, _instance, cb, cookie); - result->invoke(__flushBatchRequests_name); + result->invoke(flushBatchRequests_name); return result; } void Ice::CommunicatorI::end_flushBatchRequests(const AsyncResultPtr& r) { - AsyncResult::__check(r, this, __flushBatchRequests_name); - r->__wait(); + AsyncResult::check(r, this, flushBatchRequests_name); + r->waitForResponse(); } #endif diff --git a/cpp/src/Ice/CommunicatorI.h b/cpp/src/Ice/CommunicatorI.h index e75037bf72b..767923b7346 100644 --- a/cpp/src/Ice/CommunicatorI.h +++ b/cpp/src/Ice/CommunicatorI.h @@ -113,7 +113,7 @@ private: friend ICE_API ::IceUtil::TimerPtr IceInternal::getInstanceTimer(const ::Ice::CommunicatorPtr&); #ifndef ICE_CPP11_MAPPING - AsyncResultPtr __begin_flushBatchRequests(const IceInternal::CallbackBasePtr&, const LocalObjectPtr&); + AsyncResultPtr _iceI_begin_flushBatchRequests(const IceInternal::CallbackBasePtr&, const LocalObjectPtr&); #endif const ::IceInternal::InstancePtr _instance; diff --git a/cpp/src/Ice/ConnectRequestHandler.cpp b/cpp/src/Ice/ConnectRequestHandler.cpp index f68ec2c0770..e8b5acbd486 100644 --- a/cpp/src/Ice/ConnectRequestHandler.cpp +++ b/cpp/src/Ice/ConnectRequestHandler.cpp @@ -316,7 +316,7 @@ ConnectRequestHandler::flushRequests() _requestHandler = ICE_MAKE_SHARED(ConnectionRequestHandler, _reference, _connection, _compress); for(set<Ice::ObjectPrxPtr>::const_iterator p = _proxies.begin(); p != _proxies.end(); ++p) { - (*p)->__updateRequestHandler(ICE_SHARED_FROM_THIS, _requestHandler); + (*p)->_updateRequestHandler(ICE_SHARED_FROM_THIS, _requestHandler); } } diff --git a/cpp/src/Ice/ConnectionI.cpp b/cpp/src/Ice/ConnectionI.cpp index ce042d87ba5..9e2c6042043 100644 --- a/cpp/src/Ice/ConnectionI.cpp +++ b/cpp/src/Ice/ConnectionI.cpp @@ -44,7 +44,7 @@ Ice::LocalObject* Ice::upCast(ConnectionI* p) { return p; } namespace { -const ::std::string __flushBatchRequests_name = "flushBatchRequests"; +const ::std::string flushBatchRequests_name = "flushBatchRequests"; class TimeoutCallback : public IceUtil::TimerTask { @@ -718,7 +718,7 @@ Ice::ConnectionI::flushBatchRequestsAsync(::std::function<void(::std::exception_ } }; auto outAsync = make_shared<ConnectionFlushBatchLambda>(ICE_SHARED_FROM_THIS, _instance, ex, sent); - outAsync->invoke(__flushBatchRequests_name); + outAsync->invoke(flushBatchRequests_name); return [outAsync]() { outAsync->cancel(); }; } #else @@ -731,24 +731,24 @@ Ice::ConnectionI::flushBatchRequests() AsyncResultPtr Ice::ConnectionI::begin_flushBatchRequests() { - return __begin_flushBatchRequests(__dummyCallback, 0); + return _iceI_begin_flushBatchRequests(dummyCallback, 0); } AsyncResultPtr Ice::ConnectionI::begin_flushBatchRequests(const CallbackPtr& cb, const LocalObjectPtr& cookie) { - return __begin_flushBatchRequests(cb, cookie); + return _iceI_begin_flushBatchRequests(cb, cookie); } AsyncResultPtr Ice::ConnectionI::begin_flushBatchRequests(const Callback_Connection_flushBatchRequestsPtr& cb, const LocalObjectPtr& cookie) { - return __begin_flushBatchRequests(cb, cookie); + return _iceI_begin_flushBatchRequests(cb, cookie); } AsyncResultPtr -Ice::ConnectionI::__begin_flushBatchRequests(const CallbackBasePtr& cb, const LocalObjectPtr& cookie) +Ice::ConnectionI::_iceI_begin_flushBatchRequests(const CallbackBasePtr& cb, const LocalObjectPtr& cookie) { class ConnectionFlushBatchAsyncWithCallback : public ConnectionFlushBatchAsync, public CallbackCompletion { @@ -780,7 +780,7 @@ Ice::ConnectionI::__begin_flushBatchRequests(const CallbackBasePtr& cb, const Lo virtual const std::string& getOperation() const { - return __flushBatchRequests_name; + return flushBatchRequests_name; } private: @@ -790,15 +790,15 @@ Ice::ConnectionI::__begin_flushBatchRequests(const CallbackBasePtr& cb, const Lo }; ConnectionFlushBatchAsyncPtr result = new ConnectionFlushBatchAsyncWithCallback(this, _communicator, _instance, cb, cookie); - result->invoke(__flushBatchRequests_name); + result->invoke(flushBatchRequests_name); return result; } void Ice::ConnectionI::end_flushBatchRequests(const AsyncResultPtr& r) { - AsyncResult::__check(r, this, __flushBatchRequests_name); - r->__wait(); + AsyncResult::check(r, this, flushBatchRequests_name); + r->waitForResponse(); } #endif diff --git a/cpp/src/Ice/ConnectionI.h b/cpp/src/Ice/ConnectionI.h index ef277ee7c9a..6c0f49f6c08 100644 --- a/cpp/src/Ice/ConnectionI.h +++ b/cpp/src/Ice/ConnectionI.h @@ -307,7 +307,7 @@ private: void reap(); #ifndef ICE_CPP11_MAPPING - AsyncResultPtr __begin_flushBatchRequests(const IceInternal::CallbackBasePtr&, const LocalObjectPtr&); + AsyncResultPtr _iceI_begin_flushBatchRequests(const IceInternal::CallbackBasePtr&, const LocalObjectPtr&); #endif Ice::CommunicatorPtr _communicator; diff --git a/cpp/src/Ice/DispatchInterceptor.cpp b/cpp/src/Ice/DispatchInterceptor.cpp index b9d87096848..c178829aebf 100644 --- a/cpp/src/Ice/DispatchInterceptor.cpp +++ b/cpp/src/Ice/DispatchInterceptor.cpp @@ -15,7 +15,7 @@ using namespace Ice; using namespace IceInternal; bool -Ice::DispatchInterceptor::__dispatch(IceInternal::Incoming& in, const Current& /*current*/) +Ice::DispatchInterceptor::_iceDispatch(IceInternal::Incoming& in, const Current& /*current*/) { try { diff --git a/cpp/src/Ice/Exception.cpp b/cpp/src/Ice/Exception.cpp index 95136f5339a..460ff4dd809 100644 --- a/cpp/src/Ice/Exception.cpp +++ b/cpp/src/Ice/Exception.cpp @@ -106,7 +106,7 @@ throwMarshalException(const char* file, int line, const string& reason) namespace { -const string __Ice__UserException_ids[] = +const string userException_ids[] = { "::Ice::UserException" }; @@ -116,7 +116,7 @@ const string __Ice__UserException_ids[] = const std::string& Ice::UserException::ice_staticId() { - return __Ice__UserException_ids[0]; + return userException_ids[0]; } #ifdef ICE_CPP11_MAPPING @@ -128,23 +128,23 @@ Ice::UserException::ice_clone() const #endif void -Ice::UserException::__write(::Ice::OutputStream* os) const +Ice::UserException::_write(::Ice::OutputStream* os) const { os->startException(0); - __writeImpl(os); + _writeImpl(os); os->endException(); } void -Ice::UserException::__read(::Ice::InputStream* is) +Ice::UserException::_read(::Ice::InputStream* is) { is->startException(); - __readImpl(is); + _readImpl(is); is->endException(false); } bool -Ice::UserException::__usesClasses() const +Ice::UserException::_usesClasses() const { return false; } @@ -173,7 +173,7 @@ Ice::LocalException::ice_clone() const namespace { -const string __Ice__LocalException_ids[] = +const string localException_ids[] = { "::Ice::LocalException" }; @@ -183,7 +183,7 @@ const string __Ice__LocalException_ids[] = const std::string& Ice::LocalException::ice_staticId() { - return __Ice__LocalException_ids[0]; + return localException_ids[0]; } Ice::SystemException::SystemException(const char* file, int line) : @@ -209,7 +209,7 @@ Ice::SystemException::ice_clone() const namespace { -const string __Ice__SystemException_ids[] = +const string systemException_ids[] = { "::Ice::SystemException" }; @@ -219,7 +219,7 @@ const string __Ice__SystemException_ids[] = const std::string& Ice::SystemException::ice_staticId() { - return __Ice__SystemException_ids[0]; + return systemException_ids[0]; } void diff --git a/cpp/src/Ice/GCObject.cpp b/cpp/src/Ice/GCObject.cpp index a78ebbc8f50..6dfcdc76bdd 100644 --- a/cpp/src/Ice/GCObject.cpp +++ b/cpp/src/Ice/GCObject.cpp @@ -142,10 +142,10 @@ DecreaseRefCounts::visit(GCObject* obj) GCCountMap::iterator p = _counts.find(obj); if(p == _counts.end()) { - _counts.insert(make_pair(obj, obj->__getRefUnsafe() - 1)); + _counts.insert(make_pair(obj, obj->_iceGetRefUnsafe() - 1)); if(obj->__hasFlag(GCObject::Collectable)) { - obj->__gcVisitMembers(*this); + obj->_iceGcVisitMembers(*this); } } else @@ -179,7 +179,7 @@ RestoreRefCountsIfReachable::visit(GCObject* obj) // reachable children. // _counts.erase(p); - obj->__gcVisitMembers(*this); + obj->_iceGcVisitMembers(*this); } else if(p->second == 0) { @@ -189,7 +189,7 @@ RestoreRefCountsIfReachable::visit(GCObject* obj) // being visited again. // p->second = -1; - obj->__gcVisitMembers(*this); + obj->_iceGcVisitMembers(*this); } else if(p->second > 0) { @@ -201,7 +201,7 @@ RestoreRefCountsIfReachable::visit(GCObject* obj) _counts.erase(p); _reachable = true; - obj->__gcVisitMembers(*this); + obj->_iceGcVisitMembers(*this); _reachable = false; } return false; @@ -234,7 +234,7 @@ MarkCollectable::visit(GCObject* obj) _p.push(obj); _s.push(obj); - obj->__gcVisitMembers(_neighborsVisitor); + obj->_iceGcVisitMembers(_neighborsVisitor); if(_p.top() == obj) { @@ -290,7 +290,7 @@ ClearCollectable::visit(GCObject* obj) if(obj->__hasFlag(GCObject::Collectable)) { obj->__clearFlag(GCObject::Collectable | GCObject::CycleMember); - obj->__gcVisitMembers(*this); + obj->_iceGcVisitMembers(*this); } return false; } @@ -356,7 +356,7 @@ IceInternal::GCObject::__setNoDelete(bool b) } bool -GCObject::__gcVisit(GCVisitor& v) +GCObject::_iceGcVisit(GCVisitor& v) { return v.visit(this); } @@ -436,7 +436,7 @@ GCObject::collect(IceUtilInternal::MutexPtrLock<IceUtil::Mutex>& lock) } for(GCCountMap::const_iterator p = counts.begin(); p != counts.end(); ++p) { - p->first->__gcVisitMembers(clearMembers); + p->first->_iceGcVisitMembers(clearMembers); } for(GCCountMap::const_iterator p = counts.begin(); p != counts.end(); ++p) { diff --git a/cpp/src/Ice/Incoming.cpp b/cpp/src/Ice/Incoming.cpp index da4bb25cbc6..3db0c3ae2a1 100644 --- a/cpp/src/Ice/Incoming.cpp +++ b/cpp/src/Ice/Incoming.cpp @@ -39,11 +39,11 @@ extern bool printStackTraces; #ifdef ICE_CPP11_MAPPING Ice::MarshaledResult::MarshaledResult(const Ice::Current& current) : - __os(make_shared<Ice::OutputStream>(current.adapter->getCommunicator(), Ice::currentProtocolEncoding)) + ostr(make_shared<Ice::OutputStream>(current.adapter->getCommunicator(), Ice::currentProtocolEncoding)) { - __os->writeBlob(replyHdr, sizeof(replyHdr)); - __os->write(current.requestId); - __os->write(replyOK); + ostr->writeBlob(replyHdr, sizeof(replyHdr)); + ostr->write(current.requestId); + ostr->write(replyOK); } #endif @@ -732,7 +732,7 @@ IceInternal::Incoming::invoke(const ServantManagerPtr& servantManager, InputStre // // Dispatch in the incoming call // - _servant->__dispatch(*this, _current); + _servant->_iceDispatch(*this, _current); // // If the request was not dispatched asynchronously, send the response. diff --git a/cpp/src/Ice/InputStream.cpp b/cpp/src/Ice/InputStream.cpp index 132012b07b2..9389fb247b5 100644 --- a/cpp/src/Ice/InputStream.cpp +++ b/cpp/src/Ice/InputStream.cpp @@ -1899,7 +1899,7 @@ Ice::InputStream::EncapsDecoder::unmarshal(Int index, const Ice::ValuePtr& v) // // Read the object. // - v->__read(_stream); + v->_iceRead(_stream); // // Patch all instances now that the object is unmarshaled. @@ -2034,7 +2034,7 @@ Ice::InputStream::EncapsDecoder10::throwException(ICE_IN(ICE_USER_EXCEPTION_FACT } catch(UserException& ex) { - ex.__read(_stream); + ex._read(_stream); if(usesClasses) { readPendingValues(); @@ -2329,7 +2329,7 @@ Ice::InputStream::EncapsDecoder11::throwException(ICE_IN(ICE_USER_EXCEPTION_FACT } catch(UserException& ex) { - ex.__read(_stream); + ex._read(_stream); throw; // Never reached. diff --git a/cpp/src/Ice/LocatorInfo.cpp b/cpp/src/Ice/LocatorInfo.cpp index 74f65e2d808..181382909f2 100644 --- a/cpp/src/Ice/LocatorInfo.cpp +++ b/cpp/src/Ice/LocatorInfo.cpp @@ -351,7 +351,7 @@ IceInternal::LocatorInfo::RequestCallback::response(const LocatorInfoPtr& locato vector<EndpointIPtr> endpoints; if(proxy) { - ReferencePtr r = proxy->__reference(); + ReferencePtr r = proxy->_getReference(); if(_ref->isWellKnown() && !isSupported(_ref->getEncoding(), r->getEncoding())) { // @@ -482,7 +482,7 @@ IceInternal::LocatorInfo::Request::getEndpoints(const ReferencePtr& ref, vector<EndpointIPtr> endpoints; if(_proxy) { - ReferencePtr r = _proxy->__reference(); + ReferencePtr r = _proxy->_getReference(); if(!r->isIndirect()) { endpoints = r->getEndpoints(); @@ -924,7 +924,7 @@ IceInternal::LocatorInfo::finishRequest(const ReferencePtr& ref, const Ice::ObjectPrxPtr& proxy, bool notRegistered) { - if(!proxy || proxy->__reference()->isIndirect()) + if(!proxy || proxy->_getReference()->isIndirect()) { // // Remove the cached references of well-known objects for which we tried @@ -938,9 +938,9 @@ IceInternal::LocatorInfo::finishRequest(const ReferencePtr& ref, if(!ref->isWellKnown()) { - if(proxy && !proxy->__reference()->isIndirect()) // Cache the adapter endpoints. + if(proxy && !proxy->_getReference()->isIndirect()) // Cache the adapter endpoints. { - _table->addAdapterEndpoints(ref->getAdapterId(), proxy->__reference()->getEndpoints()); + _table->addAdapterEndpoints(ref->getAdapterId(), proxy->_getReference()->getEndpoints()); } else if(notRegistered) // If the adapter isn't registered anymore, remove it from the cache. { @@ -953,9 +953,9 @@ IceInternal::LocatorInfo::finishRequest(const ReferencePtr& ref, } else { - if(proxy && !proxy->__reference()->isWellKnown()) // Cache the well-known object reference. + if(proxy && !proxy->_getReference()->isWellKnown()) // Cache the well-known object reference. { - _table->addObjectReference(ref->getIdentity(), proxy->__reference()); + _table->addObjectReference(ref->getIdentity(), proxy->_getReference()); } else if(notRegistered) // If the well-known object isn't registered anymore, remove it from the cache. { diff --git a/cpp/src/Ice/LoggerUtil.cpp b/cpp/src/Ice/LoggerUtil.cpp index 13dd1eae363..b26bf629837 100644 --- a/cpp/src/Ice/LoggerUtil.cpp +++ b/cpp/src/Ice/LoggerUtil.cpp @@ -26,19 +26,19 @@ extern bool printStackTraces; string Ice::LoggerOutputBase::str() const { - return _str.str(); + return _os.str(); } ostringstream& -Ice::LoggerOutputBase::__str() +Ice::LoggerOutputBase::_stream() { - return _str; + return _os; } Ice::LoggerOutputBase& Ice::operator<<(Ice::LoggerOutputBase& out, ios_base& (*val)(ios_base&)) { - out.__str() << val; + out._stream() << val; return out; } @@ -47,11 +47,11 @@ Ice::loggerInsert(Ice::LoggerOutputBase& out, const IceUtil::Exception& ex) { if(IceUtilInternal::printStackTraces) { - out.__str() << ex.what() << '\n' << ex.ice_stackTrace(); + out._stream() << ex.what() << '\n' << ex.ice_stackTrace(); } else { - out.__str() << ex.what(); + out._stream() << ex.what(); } return out; } @@ -71,12 +71,12 @@ Ice::Trace::~Trace() void Ice::Trace::flush() { - string s = __str().str(); + string s = _stream().str(); if(!s.empty()) { _logger->trace(_category, s); } - __str().str(""); + _stream().str(""); } diff --git a/cpp/src/Ice/Object.cpp b/cpp/src/Ice/Object.cpp index 197c54e1918..0ff14084d0d 100644 --- a/cpp/src/Ice/Object.cpp +++ b/cpp/src/Ice/Object.cpp @@ -27,7 +27,7 @@ const Current noExplicitCurrent = Current(); Object* Ice::upCast(Object* p) { return p; } void -Ice::__patch(ObjectPtr& obj, const ObjectPtr& v) +Ice::_icePatchObjectPtr(ObjectPtr& obj, const ObjectPtr& v) { obj = v; } @@ -48,11 +48,19 @@ Ice::Object::operator<(const Object& r) const namespace { -const string __Ice__Object_ids[] = +const string object_ids[] = { "::Ice::Object" }; +const string object_all[] = +{ + "ice_id", + "ice_ids", + "ice_isA", + "ice_ping" +}; + } #ifndef ICE_CPP11_MAPPING @@ -74,7 +82,7 @@ Ice::Object::ice_isA(string s, const Current&) const Ice::Object::ice_isA(const string& s, const Current&) const #endif { - return s == __Ice__Object_ids[0]; + return s == object_ids[0]; } void @@ -86,7 +94,7 @@ Ice::Object::ice_ping(const Current&) const vector<string> Ice::Object::ice_ids(const Current&) const { - return vector<string>(&__Ice__Object_ids[0], &__Ice__Object_ids[1]); + return vector<string>(&object_ids[0], &object_ids[1]); } #ifdef ICE_CPP11_MAPPING @@ -96,13 +104,13 @@ const string& #endif Ice::Object::ice_id(const Current&) const { - return __Ice__Object_ids[0]; + return object_ids[0]; } const ::std::string& Ice::Object::ice_staticId() { - return __Ice__Object_ids[0]; + return object_ids[0]; } #ifndef ICE_CPP11_MAPPING @@ -115,64 +123,55 @@ Ice::Object::ice_clone() const #endif bool -Ice::Object::___ice_isA(Incoming& __inS, const Current& __current) +Ice::Object::_iceD_ice_isA(Incoming& inS, const Current& current) { - InputStream* __is = __inS.startReadParams(); - string __id; - __is->read(__id, false); - __inS.endReadParams(); + InputStream* istr = inS.startReadParams(); + string iceP_id; + istr->read(iceP_id, false); + inS.endReadParams(); #ifdef ICE_CPP11_MAPPING - bool __ret = ice_isA(move(__id), __current); + bool ret = ice_isA(move(iceP_id), current); #else - bool __ret = ice_isA(__id, __current); + bool ret = ice_isA(iceP_id, current); #endif - OutputStream* __os = __inS.startWriteParams(); - __os->write(__ret); - __inS.endWriteParams(); + OutputStream* ostr = inS.startWriteParams(); + ostr->write(ret); + inS.endWriteParams(); return false; } bool -Ice::Object::___ice_ping(Incoming& __inS, const Current& __current) +Ice::Object::_iceD_ice_ping(Incoming& inS, const Current& current) { - __inS.readEmptyParams(); - ice_ping(__current); - __inS.writeEmptyParams(); + inS.readEmptyParams(); + ice_ping(current); + inS.writeEmptyParams(); return false; } bool -Ice::Object::___ice_ids(Incoming& __inS, const Current& __current) +Ice::Object::_iceD_ice_ids(Incoming& inS, const Current& current) { - __inS.readEmptyParams(); - vector<string> __ret = ice_ids(__current); - OutputStream* __os = __inS.startWriteParams(); - __os->write(&__ret[0], &__ret[0] + __ret.size(), false); - __inS.endWriteParams(); + inS.readEmptyParams(); + vector<string> ret = ice_ids(current); + OutputStream* ostr = inS.startWriteParams(); + ostr->write(&ret[0], &ret[0] + ret.size(), false); + inS.endWriteParams(); return false; } bool -Ice::Object::___ice_id(Incoming& __inS, const Current& __current) +Ice::Object::_iceD_ice_id(Incoming& inS, const Current& current) { - __inS.readEmptyParams(); - string __ret = ice_id(__current); - OutputStream* __os = __inS.startWriteParams(); - __os->write(__ret, false); - __inS.endWriteParams(); + inS.readEmptyParams(); + string ret = ice_id(current); + OutputStream* ostr = inS.startWriteParams(); + ostr->write(ret, false); + inS.endWriteParams(); return false; } -string Ice::Object::__all[] = -{ - "ice_id", - "ice_ids", - "ice_isA", - "ice_ping" -}; - - bool #ifdef ICE_CPP11_MAPPING Ice::Object::ice_dispatch(Request& request, std::function<bool()> r, std::function<bool(std::exception_ptr)> e) @@ -193,7 +192,7 @@ Ice::Object::ice_dispatch(Request& request, const DispatchInterceptorAsyncCallba #endif try { - return __dispatch(in, in.getCurrent()); + return _iceDispatch(in, in.getCurrent()); in.pop(); } catch(...) @@ -204,37 +203,37 @@ Ice::Object::ice_dispatch(Request& request, const DispatchInterceptorAsyncCallba } else { - return __dispatch(in, in.getCurrent()); + return _iceDispatch(in, in.getCurrent()); } } bool -Ice::Object::__dispatch(Incoming& in, const Current& current) +Ice::Object::_iceDispatch(Incoming& in, const Current& current) { - pair<string*, string*> r = equal_range(__all, __all + sizeof(__all) / sizeof(string), current.operation); + pair<const string*, const string*> r = equal_range(object_all, object_all + sizeof(object_all) / sizeof(string), current.operation); if(r.first == r.second) { throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation); } - switch(r.first - __all) + switch(r.first - object_all) { case 0: { - return ___ice_id(in, current); + return _iceD_ice_id(in, current); } case 1: { - return ___ice_ids(in, current); + return _iceD_ice_ids(in, current); } case 2: { - return ___ice_isA(in, current); + return _iceD_ice_isA(in, current); } case 3: { - return ___ice_ping(in, current); + return _iceD_ice_ping(in, current); } default: { @@ -256,18 +255,18 @@ Ice::Object::ice_postUnmarshal() } void -Ice::Object::__write(Ice::OutputStream* os) const +Ice::Object::_iceWrite(Ice::OutputStream* os) const { os->startValue(0); - __writeImpl(os); + _iceWriteImpl(os); os->endValue(); } void -Ice::Object::__read(Ice::InputStream* is) +Ice::Object::_iceRead(Ice::InputStream* is) { is->startValue(); - __readImpl(is); + _iceReadImpl(is); is->endValue(false); } @@ -311,7 +310,7 @@ operationModeToString(OperationMode mode) } void -Ice::Object::__checkMode(OperationMode expected, OperationMode received) +Ice::Object::_iceCheckMode(OperationMode expected, OperationMode received) { if(expected != received) { @@ -330,19 +329,19 @@ Ice::Object::__checkMode(OperationMode expected, OperationMode received) else { Ice::MarshalException ex(__FILE__, __LINE__); - std::ostringstream __reason; - __reason << "unexpected operation mode. expected = " - << operationModeToString(expected) - << " received = " - << operationModeToString(received); - ex.reason = __reason.str(); + std::ostringstream reason; + reason << "unexpected operation mode. expected = " + << operationModeToString(expected) + << " received = " + << operationModeToString(received); + ex.reason = reason.str(); throw ex; } } } bool -Ice::Blobject::__dispatch(Incoming& in, const Current& current) +Ice::Blobject::_iceDispatch(Incoming& in, const Current& current) { const Byte* inEncaps; Int sz; @@ -361,7 +360,7 @@ Ice::Blobject::__dispatch(Incoming& in, const Current& current) } bool -Ice::BlobjectArray::__dispatch(Incoming& in, const Current& current) +Ice::BlobjectArray::_iceDispatch(Incoming& in, const Current& current) { pair<const Byte*, const Byte*> inEncaps; Int sz; @@ -381,7 +380,7 @@ Ice::BlobjectArray::__dispatch(Incoming& in, const Current& current) } bool -Ice::BlobjectAsync::__dispatch(Incoming& in, const Current& current) +Ice::BlobjectAsync::_iceDispatch(Incoming& in, const Current& current) { const Byte* inEncaps; Int sz; @@ -409,7 +408,7 @@ Ice::BlobjectAsync::__dispatch(Incoming& in, const Current& current) } bool -Ice::BlobjectArrayAsync::__dispatch(Incoming& in, const Current& current) +Ice::BlobjectArrayAsync::_iceDispatch(Incoming& in, const Current& current) { pair<const Byte*, const Byte*> inEncaps; Int sz; diff --git a/cpp/src/Ice/ObjectAdapterI.cpp b/cpp/src/Ice/ObjectAdapterI.cpp index 0631186769d..22c8ea8d380 100644 --- a/cpp/src/Ice/ObjectAdapterI.cpp +++ b/cpp/src/Ice/ObjectAdapterI.cpp @@ -537,7 +537,7 @@ Ice::ObjectAdapterI::findByProxy(const ObjectPrxPtr& proxy) const checkForDeactivation(); - ReferencePtr ref = proxy->__reference(); + ReferencePtr ref = proxy->_getReference(); return findFacet(ref->getIdentity(), ref->getFacet()); } @@ -712,7 +712,7 @@ Ice::ObjectAdapterI::isLocal(const ObjectPrxPtr& proxy) const // it can be called for AMI invocations if the proxy has no delegate set yet. // - ReferencePtr ref = proxy->__reference(); + ReferencePtr ref = proxy->_getReference(); if(ref->isWellKnown()) { // diff --git a/cpp/src/Ice/ObserverHelper.cpp b/cpp/src/Ice/ObserverHelper.cpp index 6b88a0d68de..262b5446efc 100644 --- a/cpp/src/Ice/ObserverHelper.cpp +++ b/cpp/src/Ice/ObserverHelper.cpp @@ -18,7 +18,7 @@ using namespace Ice::Instrumentation; IceInternal::InvocationObserver::InvocationObserver(const Ice::ObjectPrxPtr& proxy, const string& op, const Context& ctx) { - const CommunicatorObserverPtr& obsv = proxy->__reference()->getInstance()->initializationData().observer; + const CommunicatorObserverPtr& obsv = proxy->_getReference()->getInstance()->initializationData().observer; if(!obsv) { return; @@ -40,7 +40,7 @@ IceInternal::InvocationObserver::InvocationObserver(IceInternal::Instance* insta void IceInternal::InvocationObserver::attach(const Ice::ObjectPrxPtr& proxy, const string& op, const Context& ctx) { - const CommunicatorObserverPtr& obsv = proxy->__reference()->getInstance()->initializationData().observer; + const CommunicatorObserverPtr& obsv = proxy->_getReference()->getInstance()->initializationData().observer; if(!obsv) { return; diff --git a/cpp/src/Ice/OutgoingAsync.cpp b/cpp/src/Ice/OutgoingAsync.cpp index d7ffc2f4d6d..060f9019e72 100644 --- a/cpp/src/Ice/OutgoingAsync.cpp +++ b/cpp/src/Ice/OutgoingAsync.cpp @@ -474,7 +474,7 @@ OutgoingAsyncBase::throwLocalException() const } bool -OutgoingAsyncBase::__wait() +OutgoingAsyncBase::waitForResponse() { Lock sync(_m); if(_state & EndCalled) @@ -495,32 +495,32 @@ OutgoingAsyncBase::__wait() } Ice::InputStream* -OutgoingAsyncBase::__startReadParams() +OutgoingAsyncBase::startReadParams() { _is.startEncapsulation(); return &_is; } void -OutgoingAsyncBase::__endReadParams() +OutgoingAsyncBase::endReadParams() { _is.endEncapsulation(); } void -OutgoingAsyncBase::__readEmptyParams() +OutgoingAsyncBase::readEmptyParams() { _is.skipEmptyEncapsulation(); } void -OutgoingAsyncBase::__readParamEncaps(const ::Ice::Byte*& encaps, ::Ice::Int& sz) +OutgoingAsyncBase::readParamEncaps(const ::Ice::Byte*& encaps, ::Ice::Int& sz) { _is.readEncapsulation(encaps, sz); } void -OutgoingAsyncBase::__throwUserException() +OutgoingAsyncBase::throwUserException() { try { @@ -574,7 +574,7 @@ ProxyOutgoingAsyncBase::exception(const Exception& exc) } _cachedConnection = 0; - if(_proxy->__reference()->getInvocationTimeout() == -2) + if(_proxy->_getReference()->getInvocationTimeout() == -2) { _instance->timer()->cancel(ICE_SHARED_FROM_THIS); } @@ -590,7 +590,7 @@ ProxyOutgoingAsyncBase::exception(const Exception& exc) // the retry interval is 0. This method can be called with the // connection locked so we can't just retry here. // - _instance->retryQueue()->add(ICE_SHARED_FROM_THIS, _proxy->__handleException(exc, _handler, _mode, _sent, _cnt)); + _instance->retryQueue()->add(ICE_SHARED_FROM_THIS, _proxy->_handleException(exc, _handler, _mode, _sent, _cnt)); return false; } catch(const Exception& ex) @@ -602,7 +602,7 @@ ProxyOutgoingAsyncBase::exception(const Exception& exc) void ProxyOutgoingAsyncBase::cancelable(const CancellationHandlerPtr& handler) { - if(_proxy->__reference()->getInvocationTimeout() == -2 && _cachedConnection) + if(_proxy->_getReference()->getInvocationTimeout() == -2 && _cachedConnection) { const int timeout = _cachedConnection->timeout(); if(timeout > 0) @@ -624,7 +624,7 @@ ProxyOutgoingAsyncBase::retryException(const Exception& ex) // require could end up waiting for the flush of the // connection to be done. // - _proxy->__updateRequestHandler(_handler, 0); // Clear request handler and always retry. + _proxy->_updateRequestHandler(_handler, 0); // Clear request handler and always retry. _instance->retryQueue()->add(ICE_SHARED_FROM_THIS, 0); } catch(const Ice::Exception& exc) @@ -677,7 +677,7 @@ ProxyOutgoingAsyncBase::getCommunicator() const #endif ProxyOutgoingAsyncBase::ProxyOutgoingAsyncBase(const ObjectPrxPtr& prx) : - OutgoingAsyncBase(prx->__reference()->getInstance()), + OutgoingAsyncBase(prx->_getReference()->getInstance()), _proxy(prx), _mode(ICE_ENUM(OperationMode, Normal)), _cnt(0), @@ -696,7 +696,7 @@ ProxyOutgoingAsyncBase::invokeImpl(bool userThread) { if(userThread) { - int invocationTimeout = _proxy->__reference()->getInvocationTimeout(); + int invocationTimeout = _proxy->_getReference()->getInvocationTimeout(); if(invocationTimeout > 0) { _instance->timer()->schedule(ICE_SHARED_FROM_THIS, IceUtil::Time::milliSeconds(invocationTimeout)); @@ -712,7 +712,7 @@ ProxyOutgoingAsyncBase::invokeImpl(bool userThread) try { _sent = false; - _handler = _proxy->__getRequestHandler(); + _handler = _proxy->_getRequestHandler(); AsyncStatus status = _handler->sendAsyncRequest(ICE_SHARED_FROM_THIS); if(status & AsyncStatusSent) { @@ -736,7 +736,7 @@ ProxyOutgoingAsyncBase::invokeImpl(bool userThread) } catch(const RetryException&) { - _proxy->__updateRequestHandler(_handler, 0); // Clear request handler and always retry. + _proxy->_updateRequestHandler(_handler, 0); // Clear request handler and always retry. } catch(const Exception& ex) { @@ -745,7 +745,7 @@ ProxyOutgoingAsyncBase::invokeImpl(bool userThread) _childObserver.failed(ex.ice_id()); _childObserver.detach(); } - int interval = _proxy->__handleException(ex, _handler, _mode, _sent, _cnt); + int interval = _proxy->_handleException(ex, _handler, _mode, _sent, _cnt); if(interval > 0) { _instance->retryQueue()->add(ICE_SHARED_FROM_THIS, interval); @@ -781,7 +781,7 @@ ProxyOutgoingAsyncBase::sentImpl(bool done) _sent = true; if(done) { - if(_proxy->__reference()->getInvocationTimeout() != -1) + if(_proxy->_getReference()->getInvocationTimeout() != -1) { _instance->timer()->cancel(ICE_SHARED_FROM_THIS); } @@ -792,7 +792,7 @@ ProxyOutgoingAsyncBase::sentImpl(bool done) bool ProxyOutgoingAsyncBase::exceptionImpl(const Exception& ex) { - if(_proxy->__reference()->getInvocationTimeout() != -1) + if(_proxy->_getReference()->getInvocationTimeout() != -1) { _instance->timer()->cancel(ICE_SHARED_FROM_THIS); } @@ -802,7 +802,7 @@ ProxyOutgoingAsyncBase::exceptionImpl(const Exception& ex) bool ProxyOutgoingAsyncBase::responseImpl(bool ok) { - if(_proxy->__reference()->getInvocationTimeout() != -1) + if(_proxy->_getReference()->getInvocationTimeout() != -1) { _instance->timer()->cancel(ICE_SHARED_FROM_THIS); } @@ -812,7 +812,7 @@ ProxyOutgoingAsyncBase::responseImpl(bool ok) void ProxyOutgoingAsyncBase::runTimerTask() { - if(_proxy->__reference()->getInvocationTimeout() == -2) + if(_proxy->_getReference()->getInvocationTimeout() == -2) { cancel(ConnectionTimeoutException(__FILE__, __LINE__)); } @@ -824,7 +824,7 @@ ProxyOutgoingAsyncBase::runTimerTask() OutgoingAsync::OutgoingAsync(const ObjectPrxPtr& prx, bool synchronous) : ProxyOutgoingAsyncBase(prx), - _encoding(getCompatibleEncoding(prx->__reference()->getEncoding())), + _encoding(getCompatibleEncoding(prx->_getReference()->getEncoding())), _synchronous(synchronous) { } @@ -832,12 +832,12 @@ OutgoingAsync::OutgoingAsync(const ObjectPrxPtr& prx, bool synchronous) : void OutgoingAsync::prepare(const string& operation, OperationMode mode, const Context& context) { - checkSupportedProtocol(getCompatibleProtocol(_proxy->__reference()->getProtocol())); + checkSupportedProtocol(getCompatibleProtocol(_proxy->_getReference()->getProtocol())); _mode = mode; _observer.attach(_proxy, operation, context); - switch(_proxy->__reference()->getMode()) + switch(_proxy->_getReference()->getMode()) { case Reference::ModeTwoway: case Reference::ModeOneway: @@ -850,12 +850,12 @@ OutgoingAsync::prepare(const string& operation, OperationMode mode, const Contex case Reference::ModeBatchOneway: case Reference::ModeBatchDatagram: { - _proxy->__getBatchRequestQueue()->prepareBatchRequest(&_os); + _proxy->_getBatchRequestQueue()->prepareBatchRequest(&_os); break; } } - Reference* ref = _proxy->__reference().get(); + Reference* ref = _proxy->_getReference().get(); _os.write(ref->getIdentity()); @@ -1068,7 +1068,7 @@ OutgoingAsync::invokeCollocated(CollocatedRequestHandler* handler) void OutgoingAsync::abort(const Exception& ex) { - const Reference::Mode mode = _proxy->__reference()->getMode(); + const Reference::Mode mode = _proxy->_getReference()->getMode(); if(mode == Reference::ModeBatchOneway || mode == Reference::ModeBatchDatagram) { // @@ -1076,7 +1076,7 @@ OutgoingAsync::abort(const Exception& ex) // must notify the connection about that we give up ownership // of the batch stream. // - _proxy->__getBatchRequestQueue()->abortBatchRequest(&_os); + _proxy->_getBatchRequestQueue()->abortBatchRequest(&_os); } ProxyOutgoingAsyncBase::abort(ex); @@ -1085,11 +1085,11 @@ OutgoingAsync::abort(const Exception& ex) void OutgoingAsync::invoke(const string& operation) { - const Reference::Mode mode = _proxy->__reference()->getMode(); + const Reference::Mode mode = _proxy->_getReference()->getMode(); if(mode == Reference::ModeBatchOneway || mode == Reference::ModeBatchDatagram) { _sentSynchronously = true; - _proxy->__getBatchRequestQueue()->finishBatchRequest(&_os, _proxy, operation); + _proxy->_getBatchRequestQueue()->finishBatchRequest(&_os, _proxy, operation); responseImpl(true); return; // Don't call sent/completed callback for batch AMI requests } @@ -1194,9 +1194,9 @@ ProxyFlushBatchAsync::invokeCollocated(CollocatedRequestHandler* handler) void ProxyFlushBatchAsync::invoke(const string& operation) { - checkSupportedProtocol(getCompatibleProtocol(_proxy->__reference()->getProtocol())); + checkSupportedProtocol(getCompatibleProtocol(_proxy->_getReference()->getProtocol())); _observer.attach(_proxy, operation, ::Ice::noExplicitContext); - _batchRequestNum = _proxy->__getBatchRequestQueue()->swap(&_os); + _batchRequestNum = _proxy->_getBatchRequestQueue()->swap(&_os); invokeImpl(true); // userThread = true } @@ -1496,7 +1496,7 @@ namespace // // Dummy class derived from CallbackBase -// We use this class for the __dummyCallback extern pointer in OutgoingAsync. In turn, +// We use this class for the dummyCallback extern pointer in OutgoingAsync. In turn, // this allows us to test whether the user supplied a null delegate instance to the // generated begin_ method without having to generate a separate test to throw IllegalArgumentException // in the inlined versions of the begin_ method. In other words, this reduces the amount of generated @@ -1550,7 +1550,7 @@ public: // versus the generated inline version of the begin_ method having // passed a pointer to the dummy delegate. // -CallbackBasePtr IceInternal::__dummyCallback = new DummyCallback; +CallbackBasePtr IceInternal::dummyCallback = new DummyCallback; CallbackBase::~CallbackBase() { diff --git a/cpp/src/Ice/OutputStream.cpp b/cpp/src/Ice/OutputStream.cpp index 4850b0f5474..4c80fe57604 100644 --- a/cpp/src/Ice/OutputStream.cpp +++ b/cpp/src/Ice/OutputStream.cpp @@ -800,7 +800,7 @@ Ice::OutputStream::write(const ObjectPrx& v) { if(v) { - v->__write(*this); + v->_write(*this); } else { @@ -963,9 +963,9 @@ Ice::OutputStream::EncapsEncoder10::write(const UserException& v) // This allows reading the pending instances even if some part of // the exception was sliced. // - bool usesClasses = v.__usesClasses(); + bool usesClasses = v._usesClasses(); _stream->write(usesClasses); - v.__write(_stream); + v._write(_stream); if(usesClasses) { writePendingValues(); @@ -1076,7 +1076,7 @@ Ice::OutputStream::EncapsEncoder10::writePendingValues() out << "unknown exception raised by ice_preMarshal"; } - p->first->__write(_stream); + p->first->_iceWrite(_stream); } } _stream->writeSize(0); // Zero marker indicates end of sequence of sequences of instances. @@ -1151,7 +1151,7 @@ Ice::OutputStream::EncapsEncoder11::write(const ValuePtr& v) void Ice::OutputStream::EncapsEncoder11::write(const UserException& v) { - v.__write(_stream); + v._write(_stream); } void @@ -1395,5 +1395,5 @@ Ice::OutputStream::EncapsEncoder11::writeInstance(const ValuePtr& v) } _stream->writeSize(1); // Object instance marker. - v->__write(_stream); + v->_iceWrite(_stream); } diff --git a/cpp/src/Ice/Proxy.cpp b/cpp/src/Ice/Proxy.cpp index 5555d4214a1..4c36e74e369 100644 --- a/cpp/src/Ice/Proxy.cpp +++ b/cpp/src/Ice/Proxy.cpp @@ -68,11 +68,11 @@ operator==(const ObjectPrx& lhs, const ObjectPrx& rhs) } void -Ice::ObjectPrx::__ice_isA(const shared_ptr<IceInternal::OutgoingAsyncT<bool>>& outAsync, +Ice::ObjectPrx::_iceI_isA(const shared_ptr<IceInternal::OutgoingAsyncT<bool>>& outAsync, const string& typeId, const Context& ctx) { - __checkTwowayOnly(ice_isA_name); + _checkTwowayOnly(ice_isA_name); outAsync->invoke(ice_isA_name, OperationMode::Nonmutating, DefaultFormat, ctx, [&](Ice::OutputStream* os) { @@ -82,15 +82,15 @@ Ice::ObjectPrx::__ice_isA(const shared_ptr<IceInternal::OutgoingAsyncT<bool>>& o } void -Ice::ObjectPrx::__ice_ping(const shared_ptr<IceInternal::OutgoingAsyncT<void>>& outAsync, const Context& ctx) +Ice::ObjectPrx::_iceI_ping(const shared_ptr<IceInternal::OutgoingAsyncT<void>>& outAsync, const Context& ctx) { outAsync->invoke(ice_ping_name, OperationMode::Nonmutating, DefaultFormat, ctx, nullptr, nullptr); } void -Ice::ObjectPrx::__ice_ids(const shared_ptr<IceInternal::OutgoingAsyncT<vector<string>>>& outAsync, const Context& ctx) +Ice::ObjectPrx::_iceI_ids(const shared_ptr<IceInternal::OutgoingAsyncT<vector<string>>>& outAsync, const Context& ctx) { - __checkTwowayOnly(ice_ids_name); + _checkTwowayOnly(ice_ids_name); outAsync->invoke(ice_ids_name, OperationMode::Nonmutating, DefaultFormat, ctx, nullptr, nullptr, [](Ice::InputStream* stream) { @@ -101,9 +101,9 @@ Ice::ObjectPrx::__ice_ids(const shared_ptr<IceInternal::OutgoingAsyncT<vector<st } void -Ice::ObjectPrx::__ice_id(const shared_ptr<IceInternal::OutgoingAsyncT<string>>& outAsync, const Context& ctx) +Ice::ObjectPrx::_iceI_id(const shared_ptr<IceInternal::OutgoingAsyncT<string>>& outAsync, const Context& ctx) { - __checkTwowayOnly(ice_id_name); + _checkTwowayOnly(ice_id_name); outAsync->invoke(ice_id_name, OperationMode::Nonmutating, DefaultFormat, ctx, nullptr, nullptr, [](Ice::InputStream* stream) { @@ -114,19 +114,19 @@ Ice::ObjectPrx::__ice_id(const shared_ptr<IceInternal::OutgoingAsyncT<string>>& } void -Ice::ObjectPrx::__ice_getConnection(const shared_ptr<IceInternal::ProxyGetConnection>& outAsync) +Ice::ObjectPrx::_iceI_getConnection(const shared_ptr<IceInternal::ProxyGetConnection>& outAsync) { outAsync->invoke(ice_getConnection_name); } void -Ice::ObjectPrx::__ice_flushBatchRequests(const shared_ptr<IceInternal::ProxyFlushBatchAsync>& outAsync) +Ice::ObjectPrx::_iceI_flushBatchRequests(const shared_ptr<IceInternal::ProxyFlushBatchAsync>& outAsync) { outAsync->invoke(ice_flushBatchRequests_name); } void -Ice::ObjectPrx::__checkTwowayOnly(const string& name) const +Ice::ObjectPrx::_checkTwowayOnly(const string& name) const { // // No mutex lock necessary, there is nothing mutable in this operation. @@ -141,7 +141,7 @@ Ice::ObjectPrx::__checkTwowayOnly(const string& name) const shared_ptr<ObjectPrx> -Ice::ObjectPrx::__newInstance() const +Ice::ObjectPrx::_newInstance() const { return createProxy<ObjectPrx>(); } @@ -193,164 +193,164 @@ IceProxy::Ice::Object::operator<(const Object& r) const } Ice::AsyncResultPtr -IceProxy::Ice::Object::__begin_ice_isA(const string& typeId, - const Context& ctx, - const ::IceInternal::CallbackBasePtr& del, - const ::Ice::LocalObjectPtr& cookie, - bool sync) -{ - __checkTwowayOnly(ice_isA_name, sync); - OutgoingAsyncPtr __result = new CallbackOutgoing(this, ice_isA_name, del, cookie, sync); +IceProxy::Ice::Object::_iceI_begin_ice_isA(const string& typeId, + const Context& ctx, + const ::IceInternal::CallbackBasePtr& del, + const ::Ice::LocalObjectPtr& cookie, + bool sync) +{ + _checkTwowayOnly(ice_isA_name, sync); + OutgoingAsyncPtr result = new CallbackOutgoing(this, ice_isA_name, del, cookie, sync); try { - __result->prepare(ice_isA_name, Nonmutating, ctx); - ::Ice::OutputStream* __os = __result->startWriteParams(DefaultFormat); - __os->write(typeId, false); - __result->endWriteParams(); - __result->invoke(ice_isA_name); + result->prepare(ice_isA_name, Nonmutating, ctx); + ::Ice::OutputStream* ostr = result->startWriteParams(DefaultFormat); + ostr->write(typeId, false); + result->endWriteParams(); + result->invoke(ice_isA_name); } - catch(const Exception& __ex) + catch(const Exception& ex) { - __result->abort(__ex); + result->abort(ex); } - return __result; + return result; } bool -IceProxy::Ice::Object::end_ice_isA(const AsyncResultPtr& __result) +IceProxy::Ice::Object::end_ice_isA(const AsyncResultPtr& result) { - AsyncResult::__check(__result, this, ice_isA_name); - bool __ok = __result->__wait(); - if(!__ok) + AsyncResult::check(result, this, ice_isA_name); + bool ok = result->waitForResponse(); + if(!ok) { try { - __result->__throwUserException(); + result->throwUserException(); } - catch(const UserException& __ex) + catch(const UserException& ex) { - throw UnknownUserException(__FILE__, __LINE__, __ex.ice_id()); + throw UnknownUserException(__FILE__, __LINE__, ex.ice_id()); } } - bool __ret; - ::Ice::InputStream* __is = __result->__startReadParams(); - __is->read(__ret); - __result->__endReadParams(); - return __ret; + bool ret; + ::Ice::InputStream* istr = result->startReadParams(); + istr->read(ret); + result->endReadParams(); + return ret; } AsyncResultPtr -IceProxy::Ice::Object::__begin_ice_ping(const Context& ctx, +IceProxy::Ice::Object::_iceI_begin_ice_ping(const Context& ctx, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync) { - OutgoingAsyncPtr __result = new CallbackOutgoing(this, ice_ping_name, del, cookie, sync); + OutgoingAsyncPtr result = new CallbackOutgoing(this, ice_ping_name, del, cookie, sync); try { - __result->prepare(ice_ping_name, Nonmutating, ctx); - __result->writeEmptyParams(); - __result->invoke(ice_ping_name); + result->prepare(ice_ping_name, Nonmutating, ctx); + result->writeEmptyParams(); + result->invoke(ice_ping_name); } - catch(const Exception& __ex) + catch(const Exception& ex) { - __result->abort(__ex); + result->abort(ex); } - return __result; + return result; } void -IceProxy::Ice::Object::end_ice_ping(const AsyncResultPtr& __result) +IceProxy::Ice::Object::end_ice_ping(const AsyncResultPtr& result) { - __end(__result, ice_ping_name); + _end(result, ice_ping_name); } AsyncResultPtr -IceProxy::Ice::Object::__begin_ice_ids(const Context& ctx, +IceProxy::Ice::Object::_iceI_begin_ice_ids(const Context& ctx, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync) { - __checkTwowayOnly(ice_ids_name, sync); - OutgoingAsyncPtr __result = new CallbackOutgoing(this, ice_ids_name, del, cookie, sync); + _checkTwowayOnly(ice_ids_name, sync); + OutgoingAsyncPtr result = new CallbackOutgoing(this, ice_ids_name, del, cookie, sync); try { - __result->prepare(ice_ids_name, Nonmutating, ctx); - __result->writeEmptyParams(); - __result->invoke(ice_ids_name); + result->prepare(ice_ids_name, Nonmutating, ctx); + result->writeEmptyParams(); + result->invoke(ice_ids_name); } - catch(const Exception& __ex) + catch(const Exception& ex) { - __result->abort(__ex); + result->abort(ex); } - return __result; + return result; } vector<string> -IceProxy::Ice::Object::end_ice_ids(const AsyncResultPtr& __result) +IceProxy::Ice::Object::end_ice_ids(const AsyncResultPtr& result) { - AsyncResult::__check(__result, this, ice_ids_name); - bool __ok = __result->__wait(); - if(!__ok) + AsyncResult::check(result, this, ice_ids_name); + bool ok = result->waitForResponse(); + if(!ok) { try { - __result->__throwUserException(); + result->throwUserException(); } - catch(const UserException& __ex) + catch(const UserException& ex) { - throw UnknownUserException(__FILE__, __LINE__, __ex.ice_id()); + throw UnknownUserException(__FILE__, __LINE__, ex.ice_id()); } } - vector<string> __ret; - ::Ice::InputStream* __is = __result->__startReadParams(); - __is->read(__ret, false); - __result->__endReadParams(); - return __ret; + vector<string> ret; + ::Ice::InputStream* istr = result->startReadParams(); + istr->read(ret, false); + result->endReadParams(); + return ret; } AsyncResultPtr -IceProxy::Ice::Object::__begin_ice_id(const Context& ctx, +IceProxy::Ice::Object::_iceI_begin_ice_id(const Context& ctx, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync) { - __checkTwowayOnly(ice_id_name, sync); - OutgoingAsyncPtr __result = new CallbackOutgoing(this, ice_id_name, del, cookie, sync); + _checkTwowayOnly(ice_id_name, sync); + OutgoingAsyncPtr result = new CallbackOutgoing(this, ice_id_name, del, cookie, sync); try { - __result->prepare(ice_id_name, Nonmutating, ctx); - __result->writeEmptyParams(); - __result->invoke(ice_id_name); + result->prepare(ice_id_name, Nonmutating, ctx); + result->writeEmptyParams(); + result->invoke(ice_id_name); } - catch(const Exception& __ex) + catch(const Exception& ex) { - __result->abort(__ex); + result->abort(ex); } - return __result; + return result; } string -IceProxy::Ice::Object::end_ice_id(const AsyncResultPtr& __result) +IceProxy::Ice::Object::end_ice_id(const AsyncResultPtr& result) { - AsyncResult::__check(__result, this, ice_id_name); - bool __ok = __result->__wait(); - if(!__ok) + AsyncResult::check(result, this, ice_id_name); + bool ok = result->waitForResponse(); + if(!ok) { try { - __result->__throwUserException(); + result->throwUserException(); } - catch(const UserException& __ex) + catch(const UserException& ex) { - throw UnknownUserException(__FILE__, __LINE__, __ex.ice_id()); + throw UnknownUserException(__FILE__, __LINE__, ex.ice_id()); } } - string __ret; - ::Ice::InputStream* __is = __result->__startReadParams(); - __is->read(__ret, false); - __result->__endReadParams(); - return __ret; + string ret; + ::Ice::InputStream* istr = result->startReadParams(); + istr->read(ret, false); + result->endReadParams(); + return ret; } bool @@ -374,7 +374,7 @@ IceProxy::Ice::Object::ice_invoke(const string& operation, } AsyncResultPtr -IceProxy::Ice::Object::__begin_ice_invoke(const string& operation, +IceProxy::Ice::Object::_iceI_begin_ice_invoke(const string& operation, OperationMode mode, const vector<Byte>& inEncaps, const Context& ctx, @@ -392,26 +392,26 @@ IceProxy::Ice::Object::__begin_ice_invoke(const string& operation, inPair.first = &inEncaps[0]; inPair.second = inPair.first + inEncaps.size(); } - return __begin_ice_invoke(operation, mode, inPair, ctx, del, cookie); + return _iceI_begin_ice_invoke(operation, mode, inPair, ctx, del, cookie); } bool -IceProxy::Ice::Object::end_ice_invoke(vector<Byte>& outEncaps, const AsyncResultPtr& __result) +IceProxy::Ice::Object::end_ice_invoke(vector<Byte>& outEncaps, const AsyncResultPtr& result) { - AsyncResult::__check(__result, this, ice_invoke_name); - bool ok = __result->__wait(); + AsyncResult::check(result, this, ice_invoke_name); + bool ok = result->waitForResponse(); if(_reference->getMode() == Reference::ModeTwoway) { const Byte* v; Int sz; - __result->__readParamEncaps(v, sz); + result->readParamEncaps(v, sz); vector<Byte>(v, v + sz).swap(outEncaps); } return ok; } AsyncResultPtr -IceProxy::Ice::Object::__begin_ice_invoke(const string& operation, +IceProxy::Ice::Object::_iceI_begin_ice_invoke(const string& operation, OperationMode mode, const pair<const Byte*, const Byte*>& inEncaps, const Context& ctx, @@ -419,36 +419,36 @@ IceProxy::Ice::Object::__begin_ice_invoke(const string& operation, const ::Ice::LocalObjectPtr& cookie, bool sync) { - OutgoingAsyncPtr __result = new CallbackOutgoing(this, ice_invoke_name, del, cookie, sync); + OutgoingAsyncPtr result = new CallbackOutgoing(this, ice_invoke_name, del, cookie, sync); try { - __result->prepare(operation, mode, ctx); - __result->writeParamEncaps(inEncaps.first, static_cast<Int>(inEncaps.second - inEncaps.first)); - __result->invoke(operation); + result->prepare(operation, mode, ctx); + result->writeParamEncaps(inEncaps.first, static_cast<Int>(inEncaps.second - inEncaps.first)); + result->invoke(operation); } - catch(const Exception& __ex) + catch(const Exception& ex) { - __result->abort(__ex); + result->abort(ex); } - return __result; + return result; } bool -IceProxy::Ice::Object::___end_ice_invoke(pair<const Byte*, const Byte*>& outEncaps, const AsyncResultPtr& __result) +IceProxy::Ice::Object::_iceI_end_ice_invoke(pair<const Byte*, const Byte*>& outEncaps, const AsyncResultPtr& result) { - AsyncResult::__check(__result, this, ice_invoke_name); - bool ok = __result->__wait(); + AsyncResult::check(result, this, ice_invoke_name); + bool ok = result->waitForResponse(); if(_reference->getMode() == Reference::ModeTwoway) { Int sz; - __result->__readParamEncaps(outEncaps.first, sz); + result->readParamEncaps(outEncaps.first, sz); outEncaps.second = outEncaps.first + sz; } return ok; } ::Ice::AsyncResultPtr -IceProxy::Ice::Object::__begin_ice_flushBatchRequests(const ::IceInternal::CallbackBasePtr& del, +IceProxy::Ice::Object::_iceI_begin_ice_flushBatchRequests(const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie) { class ProxyFlushBatchAsyncWithCallback : public ProxyFlushBatchAsync, public CallbackCompletion @@ -485,29 +485,29 @@ IceProxy::Ice::Object::__begin_ice_flushBatchRequests(const ::IceInternal::Callb void IceProxy::Ice::Object::end_ice_flushBatchRequests(const AsyncResultPtr& result) { - AsyncResult::__check(result, this, ice_flushBatchRequests_name); - result->__wait(); + AsyncResult::check(result, this, ice_flushBatchRequests_name); + result->waitForResponse(); } void -IceProxy::Ice::Object::__end(const ::Ice::AsyncResultPtr& __result, const std::string& operation) const +IceProxy::Ice::Object::_end(const ::Ice::AsyncResultPtr& result, const std::string& operation) const { - AsyncResult::__check(__result, this, operation); - bool __ok = __result->__wait(); + AsyncResult::check(result, this, operation); + bool ok = result->waitForResponse(); if(_reference->getMode() == Reference::ModeTwoway) { - if(!__ok) + if(!ok) { try { - __result->__throwUserException(); + result->throwUserException(); } - catch(const UserException& __ex) + catch(const UserException& ex) { - throw UnknownUserException(__FILE__, __LINE__, __ex.ice_id()); + throw UnknownUserException(__FILE__, __LINE__, ex.ice_id()); } } - __result->__readEmptyParams(); + result->readEmptyParams(); } } @@ -528,13 +528,13 @@ operator<<(ostream& os, const ::IceProxy::Ice::Object& p) } IceProxy::Ice::Object* -IceProxy::Ice::Object::__newInstance() const +IceProxy::Ice::Object::_newInstance() const { return new Object; } AsyncResultPtr -IceProxy::Ice::Object::__begin_ice_getConnection(const ::IceInternal::CallbackBasePtr& del, +IceProxy::Ice::Object::_iceI_begin_ice_getConnection(const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie) { class ProxyGetConnectionWithCallback : public ProxyGetConnection, public CallbackCompletion @@ -569,15 +569,15 @@ IceProxy::Ice::Object::__begin_ice_getConnection(const ::IceInternal::CallbackBa } ConnectionPtr -IceProxy::Ice::Object::end_ice_getConnection(const AsyncResultPtr& __result) +IceProxy::Ice::Object::end_ice_getConnection(const AsyncResultPtr& result) { - AsyncResult::__check(__result, this, ice_getConnection_name); - __result->__wait(); - return __result->getConnection(); + AsyncResult::check(result, this, ice_getConnection_name); + result->waitForResponse(); + return result->getConnection(); } void -IceProxy::Ice::Object::__checkTwowayOnly(const string& name, bool sync) const +IceProxy::Ice::Object::_checkTwowayOnly(const string& name, bool sync) const { // // No mutex lock necessary, there is nothing mutable in this operation. @@ -649,7 +649,7 @@ ICE_OBJECT_PRX::ice_getContext() const ObjectPrxPtr ICE_OBJECT_PRX::ice_context(const Context& newContext) const { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = _newInstance(); proxy->setup(_reference->changeContext(newContext)); return proxy; } @@ -694,7 +694,7 @@ ICE_OBJECT_PRX::ice_adapterId(const string& newAdapterId) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = _newInstance(); proxy->setup(_reference->changeAdapterId(newAdapterId)); return proxy; } @@ -727,7 +727,7 @@ ICE_OBJECT_PRX::ice_endpoints(const EndpointSeq& newEndpoints) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = _newInstance(); proxy->setup(_reference->changeEndpoints(endpoints)); return proxy; } @@ -754,7 +754,7 @@ ICE_OBJECT_PRX::ice_locatorCacheTimeout(Int newTimeout) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = _newInstance(); proxy->setup(_reference->changeLocatorCacheTimeout(newTimeout)); return proxy; } @@ -775,7 +775,7 @@ ICE_OBJECT_PRX::ice_connectionCached(bool newCache) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = _newInstance(); proxy->setup(_reference->changeCacheConnection(newCache)); return proxy; } @@ -796,7 +796,7 @@ ICE_OBJECT_PRX::ice_endpointSelection(EndpointSelectionType newType) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = _newInstance(); proxy->setup(_reference->changeEndpointSelection(newType)); return proxy; } @@ -817,7 +817,7 @@ ICE_OBJECT_PRX::ice_secure(bool b) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = _newInstance(); proxy->setup(_reference->changeSecure(b)); return proxy; } @@ -838,7 +838,7 @@ ICE_OBJECT_PRX::ice_encodingVersion(const ::Ice::EncodingVersion& encoding) cons } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = _newInstance(); proxy->setup(_reference->changeEncoding(encoding)); return proxy; } @@ -859,7 +859,7 @@ ICE_OBJECT_PRX::ice_preferSecure(bool b) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = _newInstance(); proxy->setup(_reference->changePreferSecure(b)); return proxy; } @@ -886,7 +886,7 @@ ICE_OBJECT_PRX::ice_router(const RouterPrxPtr& router) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = _newInstance(); proxy->setup(ref); return proxy; } @@ -913,7 +913,7 @@ ICE_OBJECT_PRX::ice_locator(const LocatorPrxPtr& locator) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = _newInstance(); proxy->setup(ref); return proxy; } @@ -934,7 +934,7 @@ ICE_OBJECT_PRX::ice_collocationOptimized(bool b) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = _newInstance(); proxy->setup(_reference->changeCollocationOptimized(b)); return proxy; } @@ -961,7 +961,7 @@ ICE_OBJECT_PRX::ice_invocationTimeout(Int newTimeout) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = _newInstance(); proxy->setup(_reference->changeInvocationTimeout(newTimeout)); return proxy; } @@ -976,7 +976,7 @@ ICE_OBJECT_PRX::ice_twoway() const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = _newInstance(); proxy->setup(_reference->changeMode(Reference::ModeTwoway)); return proxy; } @@ -997,7 +997,7 @@ ICE_OBJECT_PRX::ice_oneway() const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = _newInstance(); proxy->setup(_reference->changeMode(Reference::ModeOneway)); return proxy; } @@ -1018,7 +1018,7 @@ ICE_OBJECT_PRX::ice_batchOneway() const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = _newInstance(); proxy->setup(_reference->changeMode(Reference::ModeBatchOneway)); return proxy; } @@ -1039,7 +1039,7 @@ ICE_OBJECT_PRX::ice_datagram() const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = _newInstance(); proxy->setup(_reference->changeMode(Reference::ModeDatagram)); return proxy; } @@ -1060,7 +1060,7 @@ ICE_OBJECT_PRX::ice_batchDatagram() const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = _newInstance(); proxy->setup(_reference->changeMode(Reference::ModeBatchDatagram)); return proxy; } @@ -1082,7 +1082,7 @@ ICE_OBJECT_PRX::ice_compress(bool b) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = _newInstance(); proxy->setup(ref); return proxy; } @@ -1104,7 +1104,7 @@ ICE_OBJECT_PRX::ice_timeout(int t) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = _newInstance(); proxy->setup(ref); return proxy; } @@ -1120,7 +1120,7 @@ ICE_OBJECT_PRX::ice_connectionId(const string& id) const } else { - ObjectPrxPtr proxy = __newInstance(); + ObjectPrxPtr proxy = _newInstance(); proxy->setup(ref); return proxy; } @@ -1135,17 +1135,17 @@ ICE_OBJECT_PRX::ice_getConnectionId() const ConnectionPtr ICE_OBJECT_PRX::ice_getCachedConnection() const { - RequestHandlerPtr __handler; + RequestHandlerPtr handler; { IceUtil::Mutex::Lock sync(_mutex); - __handler = _requestHandler; + handler = _requestHandler; } - if(__handler) + if(handler) { try { - return __handler->getConnection(); + return handler->getConnection(); } catch(const LocalException&) { @@ -1169,13 +1169,13 @@ ICE_OBJECT_PRX::setup(const ReferencePtr& ref) } int -ICE_OBJECT_PRX::__handleException(const Exception& ex, +ICE_OBJECT_PRX::_handleException(const Exception& ex, const RequestHandlerPtr& handler, OperationMode mode, bool sent, int& cnt) { - __updateRequestHandler(handler, 0); // Clear the request handler + _updateRequestHandler(handler, 0); // Clear the request handler // // We only retry local exception, system exceptions aren't retried. @@ -1218,7 +1218,7 @@ ICE_OBJECT_PRX::__handleException(const Exception& ex, } ::IceInternal::RequestHandlerPtr -ICE_OBJECT_PRX::__getRequestHandler() +ICE_OBJECT_PRX::_getRequestHandler() { RequestHandlerPtr handler; if(_reference->getCacheConnection()) @@ -1233,7 +1233,7 @@ ICE_OBJECT_PRX::__getRequestHandler() } IceInternal::BatchRequestQueuePtr -ICE_OBJECT_PRX::__getBatchRequestQueue() +ICE_OBJECT_PRX::_getBatchRequestQueue() { IceUtil::Mutex::Lock sync(_mutex); if(!_batchRequestQueue) @@ -1244,7 +1244,7 @@ ICE_OBJECT_PRX::__getBatchRequestQueue() } ::IceInternal::RequestHandlerPtr -ICE_OBJECT_PRX::__setRequestHandler(const ::IceInternal::RequestHandlerPtr& handler) +ICE_OBJECT_PRX::_setRequestHandler(const ::IceInternal::RequestHandlerPtr& handler) { if(_reference->getCacheConnection()) { @@ -1259,7 +1259,7 @@ ICE_OBJECT_PRX::__setRequestHandler(const ::IceInternal::RequestHandlerPtr& hand } void -ICE_OBJECT_PRX::__updateRequestHandler(const ::IceInternal::RequestHandlerPtr& previous, +ICE_OBJECT_PRX::_updateRequestHandler(const ::IceInternal::RequestHandlerPtr& previous, const ::IceInternal::RequestHandlerPtr& handler) { if(_reference->getCacheConnection() && previous) @@ -1280,7 +1280,7 @@ ICE_OBJECT_PRX::__updateRequestHandler(const ::IceInternal::RequestHandlerPtr& p } void -ICE_OBJECT_PRX::__copyFrom(const ObjectPrxPtr& from) +ICE_OBJECT_PRX::_copyFrom(const ObjectPrxPtr& from) { IceUtil::Mutex::Lock sync(from->_mutex); _reference = from->_reference; @@ -1305,16 +1305,16 @@ ICE_OBJECT_PRX::ice_toString() const } Int -ICE_OBJECT_PRX::__hash() const +ICE_OBJECT_PRX::_hash() const { return _reference->hash(); } void -ICE_OBJECT_PRX::__write(OutputStream& os) const +ICE_OBJECT_PRX::_write(OutputStream& os) const { - os.write(__reference()->getIdentity()); - __reference()->streamWrite(&os); + os.write(_getReference()->getIdentity()); + _getReference()->streamWrite(&os); } bool diff --git a/cpp/src/Ice/ProxyFactory.cpp b/cpp/src/Ice/ProxyFactory.cpp index b0037fa9ce5..eba949508b6 100644 --- a/cpp/src/Ice/ProxyFactory.cpp +++ b/cpp/src/Ice/ProxyFactory.cpp @@ -41,7 +41,7 @@ IceInternal::ProxyFactory::proxyToString(const ObjectPrxPtr& proxy) const { if(proxy) { - return proxy->__reference()->toString(); + return proxy->_getReference()->toString(); } else { @@ -62,7 +62,7 @@ IceInternal::ProxyFactory::proxyToProperty(const ObjectPrxPtr& proxy, const stri { if(proxy) { - return proxy->__reference()->toProperty(prefix); + return proxy->_getReference()->toProperty(prefix); } else { diff --git a/cpp/src/Ice/Reference.cpp b/cpp/src/Ice/Reference.cpp index a82b68507b0..8ec124a1c41 100644 --- a/cpp/src/Ice/Reference.cpp +++ b/cpp/src/Ice/Reference.cpp @@ -815,7 +815,7 @@ IceInternal::FixedReference::getRequestHandler(const Ice::ObjectPrxPtr& proxy) c } ReferencePtr ref = const_cast<FixedReference*>(this); - return proxy->__setRequestHandler(ICE_MAKE_SHARED(ConnectionRequestHandler, ref, _fixedConnection, compress)); + return proxy->_setRequestHandler(ICE_MAKE_SHARED(ConnectionRequestHandler, ref, _fixedConnection, compress)); } BatchRequestQueuePtr @@ -1269,7 +1269,7 @@ IceInternal::RoutableReference::toProperty(const string& prefix) const } if(_routerInfo) { - PropertyDict routerProperties = _routerInfo->getRouter()->__reference()->toProperty(prefix + ".Router"); + PropertyDict routerProperties = _routerInfo->getRouter()->_getReference()->toProperty(prefix + ".Router"); for(PropertyDict::const_iterator p = routerProperties.begin(); p != routerProperties.end(); ++p) { properties[p->first] = p->second; @@ -1278,7 +1278,7 @@ IceInternal::RoutableReference::toProperty(const string& prefix) const if(_locatorInfo) { - PropertyDict locatorProperties = _locatorInfo->getLocator()->__reference()->toProperty(prefix + ".Locator"); + PropertyDict locatorProperties = _locatorInfo->getLocator()->_getReference()->toProperty(prefix + ".Locator"); for(PropertyDict::const_iterator p = locatorProperties.begin(); p != locatorProperties.end(); ++p) { properties[p->first] = p->second; diff --git a/cpp/src/Ice/RequestHandlerFactory.cpp b/cpp/src/Ice/RequestHandlerFactory.cpp index 414d1001220..ff8e0413a90 100644 --- a/cpp/src/Ice/RequestHandlerFactory.cpp +++ b/cpp/src/Ice/RequestHandlerFactory.cpp @@ -30,7 +30,7 @@ IceInternal::RequestHandlerFactory::getRequestHandler(const RoutableReferencePtr Ice::ObjectAdapterPtr adapter = _instance->objectAdapterFactory()->findObjectAdapter(proxy); if(adapter) { - return proxy->__setRequestHandler(ICE_MAKE_SHARED(CollocatedRequestHandler, ref, adapter)); + return proxy->_setRequestHandler(ICE_MAKE_SHARED(CollocatedRequestHandler, ref, adapter)); } } @@ -64,7 +64,7 @@ IceInternal::RequestHandlerFactory::getRequestHandler(const RoutableReferencePtr ref->getConnection(handler.get()); #endif } - return proxy->__setRequestHandler(handler->connect(proxy)); + return proxy->_setRequestHandler(handler->connect(proxy)); } void diff --git a/cpp/src/Ice/RouterInfo.cpp b/cpp/src/Ice/RouterInfo.cpp index b205b057d7a..3367a743077 100644 --- a/cpp/src/Ice/RouterInfo.cpp +++ b/cpp/src/Ice/RouterInfo.cpp @@ -335,7 +335,7 @@ IceInternal::RouterInfo::setClientEndpoints(const Ice::ObjectPrxPtr& proxy) // // If getClientProxy() return nil, use router endpoints. // - _clientEndpoints = _router->__reference()->getEndpoints(); + _clientEndpoints = _router->_getReference()->getEndpoints(); } else { @@ -351,7 +351,7 @@ IceInternal::RouterInfo::setClientEndpoints(const Ice::ObjectPrxPtr& proxy) clientProxy = clientProxy->ice_timeout(_router->ice_getConnection()->timeout()); } - _clientEndpoints = clientProxy->__reference()->getEndpoints(); + _clientEndpoints = clientProxy->_getReference()->getEndpoints(); } } return _clientEndpoints; @@ -372,7 +372,7 @@ IceInternal::RouterInfo::setServerEndpoints(const Ice::ObjectPrxPtr& /*serverPro serverProxy = serverProxy->ice_router(0); // The server proxy cannot be routed. - _serverEndpoints = serverProxy->__reference()->getEndpoints(); + _serverEndpoints = serverProxy->_getReference()->getEndpoints(); } return _serverEndpoints; } diff --git a/cpp/src/Ice/SlicedData.cpp b/cpp/src/Ice/SlicedData.cpp index 6a433ffbe4d..551c18cfdef 100644 --- a/cpp/src/Ice/SlicedData.cpp +++ b/cpp/src/Ice/SlicedData.cpp @@ -33,7 +33,7 @@ Ice::SlicedData::SlicedData(const SliceInfoSeq& seq) : #ifndef ICE_CPP11_MAPPING void -Ice::SlicedData::__gcVisitMembers(IceInternal::GCVisitor& visitor) +Ice::SlicedData::_iceGcVisitMembers(IceInternal::GCVisitor& visitor) { // // Iterate over the object references in each preserved slice. @@ -42,7 +42,7 @@ Ice::SlicedData::__gcVisitMembers(IceInternal::GCVisitor& visitor) { for(vector<ObjectPtr>::iterator q = (*p)->instances.begin(); q != (*p)->instances.end(); ++q) { - if(q->get()->__gcVisit(visitor)) + if(q->get()->_iceGcVisit(visitor)) { *q = 0; } @@ -51,11 +51,11 @@ Ice::SlicedData::__gcVisitMembers(IceInternal::GCVisitor& visitor) } void -Ice::UnknownSlicedValue::__gcVisitMembers(IceInternal::GCVisitor& _v) +Ice::UnknownSlicedValue::_iceGcVisitMembers(IceInternal::GCVisitor& _v) { if(_slicedData) { - _slicedData->__gcVisitMembers(_v); + _slicedData->_iceGcVisitMembers(_v); } } @@ -78,17 +78,17 @@ Ice::UnknownSlicedValue::getSlicedData() const } void -Ice::UnknownSlicedValue::__write(Ice::OutputStream* __os) const +Ice::UnknownSlicedValue::_iceWrite(Ice::OutputStream* ostr) const { - __os->startValue(_slicedData); - __os->endValue(); + ostr->startValue(_slicedData); + ostr->endValue(); } void -Ice::UnknownSlicedValue::__read(Ice::InputStream* __is) +Ice::UnknownSlicedValue::_iceRead(Ice::InputStream* istr) { - __is->startValue(); - _slicedData = __is->endValue(true); + istr->startValue(); + _slicedData = istr->endValue(true); } #ifdef ICE_CPP11_MAPPING diff --git a/cpp/src/Ice/Value.cpp b/cpp/src/Ice/Value.cpp index f5a7f6b1bbf..204895d5e65 100644 --- a/cpp/src/Ice/Value.cpp +++ b/cpp/src/Ice/Value.cpp @@ -29,25 +29,25 @@ Ice::Value::ice_postUnmarshal() } void -Ice::Value::__write(Ice::OutputStream* os) const +Ice::Value::_iceWrite(Ice::OutputStream* os) const { os->startValue(0); - __writeImpl(os); + _iceWriteImpl(os); os->endValue(); } void -Ice::Value::__read(Ice::InputStream* is) +Ice::Value::_iceRead(Ice::InputStream* is) { is->startValue(); - __readImpl(is); + _iceReadImpl(is); is->endValue(false); } namespace { -const string __Ice__Object_ids[] = +const string object_ids[] = { "::Ice::Object" }; @@ -57,13 +57,13 @@ const string __Ice__Object_ids[] = string Ice::Value::ice_id() const { - return __Ice__Object_ids[0]; + return object_ids[0]; } const string& Ice::Value::ice_staticId() { - return __Ice__Object_ids[0]; + return object_ids[0]; } ValuePtr diff --git a/cpp/src/Slice/CPlusPlusUtil.cpp b/cpp/src/Slice/CPlusPlusUtil.cpp index 4ae02b9372f..60bd5257b1f 100644 --- a/cpp/src/Slice/CPlusPlusUtil.cpp +++ b/cpp/src/Slice/CPlusPlusUtil.cpp @@ -217,7 +217,7 @@ writeParamAllocateCode(Output& out, const TypePtr& type, bool optional, const st { s = toOptional(s, typeCtx); } - out << nl << s << " ___" << fixedName << ";"; + out << nl << s << ' ' << fixedName << "_tmp_;"; } } } @@ -228,7 +228,7 @@ writeParamEndCode(Output& out, const TypePtr& type, bool optional, const string& { string objPrefix = obj.empty() ? obj : obj + "."; string paramName = objPrefix + fixedName; - string escapedParamName = objPrefix + "___" + fixedName; + string escapedParamName = objPrefix + fixedName + "_tmp_"; SequencePtr seq = SequencePtr::dynamicCast(type); if(seq) @@ -317,13 +317,18 @@ writeParamEndCode(Output& out, const TypePtr& type, bool optional, const string& void writeMarshalUnmarshalParams(Output& out, const ParamDeclList& params, const OperationPtr& op, bool marshal, - bool prepend, int typeCtx, const string& retP = "", const string& obj = "") + bool prepend, int typeCtx, const string& customStream = "", const string& retP = "", const string& obj = "") { string prefix = prepend ? paramPrefix : ""; - string returnValueS = retP.empty() ? string("__ret") : retP; - + string returnValueS = retP.empty() ? string("ret") : retP; string objPrefix = obj.empty() ? obj : obj + "."; + string stream = customStream; + if(stream.empty()) + { + stream = marshal ? "ostr" : "istr"; + } + bool cpp11 = (typeCtx & TypeContextCpp11) != 0; // @@ -351,11 +356,11 @@ writeMarshalUnmarshalParams(Output& out, const ParamDeclList& params, const Oper out << nl; if(marshal) { - out << "__os->writeAll"; + out << stream << "->writeAll"; } else { - out << "__is->readAll"; + out << stream << "->readAll"; } out << spar; for(ParamDeclList::const_iterator p = requiredParams.begin(); p != requiredParams.end(); ++p) @@ -373,7 +378,7 @@ writeMarshalUnmarshalParams(Output& out, const ParamDeclList& params, const Oper for(ParamDeclList::const_iterator p = requiredParams.begin(); p != requiredParams.end(); ++p) { writeMarshalUnmarshalCode(out, (*p)->type(), false, 0, fixKwd(prefix + (*p)->name()), marshal, (*p)->getMetaData(), - typeCtx, "", true, obj); + typeCtx, customStream, true, obj); } if(op && op->returnType()) @@ -381,7 +386,7 @@ writeMarshalUnmarshalParams(Output& out, const ParamDeclList& params, const Oper if(!op->returnIsOptional()) { writeMarshalUnmarshalCode(out, op->returnType(), false, 0, returnValueS, marshal, op->getMetaData(), typeCtx, - "", true, obj); + customStream, true, obj); } } } @@ -407,11 +412,11 @@ writeMarshalUnmarshalParams(Output& out, const ParamDeclList& params, const Oper out << nl; if(marshal) { - out << "__os->writeAll"; + out << stream << "->writeAll"; } else { - out << "__is->readAll"; + out << stream << "->readAll"; } out << spar; @@ -476,17 +481,17 @@ writeMarshalUnmarshalParams(Output& out, const ParamDeclList& params, const Oper if(checkReturnType && op->returnTag() < (*p)->tag()) { writeMarshalUnmarshalCode(out, op->returnType(), true, op->returnTag(), returnValueS, marshal, - op->getMetaData(), typeCtx, "", true, obj); + op->getMetaData(), typeCtx, customStream, true, obj); checkReturnType = false; } writeMarshalUnmarshalCode(out, (*p)->type(), true, (*p)->tag(), fixKwd(prefix + (*p)->name()), marshal, - (*p)->getMetaData(), typeCtx, "", true, obj); + (*p)->getMetaData(), typeCtx, customStream, true, obj); } if(checkReturnType) { writeMarshalUnmarshalCode(out, op->returnType(), true, op->returnTag(), returnValueS, marshal, op->getMetaData(), - typeCtx, "", true, obj); + typeCtx, customStream, true, obj); } } } @@ -494,7 +499,7 @@ writeMarshalUnmarshalParams(Output& out, const ParamDeclList& params, const Oper } Slice::FeatureProfile Slice::featureProfile = Slice::Ice; -string Slice::paramPrefix = "__p_"; +string Slice::paramPrefix = "iceP_"; char Slice::ToIfdef::operator()(char c) @@ -1154,7 +1159,7 @@ Slice::opFormatTypeToString(const OperationPtr& op) } // -// If the passed name is a keyword, return the name with a "_cxx_" prefix; +// If the passed name is a keyword, return the name with a "_cpp_" prefix; // otherwise, return the name unchanged. // @@ -1171,14 +1176,15 @@ lookupKwd(const string& name) // static const string keywordList[] = { - "and", "and_eq", "asm", "auto", "bit_and", "bit_or", "bool", "break", "case", "catch", "char", - "class", "compl", "const", "const_cast", "continue", "default", "delete", "do", "double", - "dynamic_cast", "else", "enum", "explicit", "export", "extern", "false", "float", "for", - "friend", "goto", "if", "inline", "int", "long", "mutable", "namespace", "new", "not", "not_eq", - "operator", "or", "or_eq", "private", "protected", "public", "register", "reinterpret_cast", - "return", "short", "signed", "sizeof", "static", "static_cast", "struct", "switch", "template", - "this", "throw", "true", "try", "typedef", "typeid", "typename", "union", "unsigned", "using", - "virtual", "void", "volatile", "wchar_t", "while", "xor", "xor_eq" + "alignas", "alignof", "and", "and_eq", "asm", "auto", "bit_and", "bit_or", "bool", "break", + "case", "catch", "char", "char16_t", "char32_t", "class", "compl", "const", "const_exptr", "const_cast", "continue", + "decltype", "default", "delete", "do", "double", "dynamic_cast", + "else", "enum", "explicit", "export", "extern", "false", "float", "for", "friend", + "goto", "if", "inline", "int", "long", "mutable", "namespace", "new", "noexcept", "not", "not_eq", + "operator", "or", "or_eq", "private", "protected", "public", "register", "reinterpret_cast", "return", + "short", "signed", "sizeof", "static", "static_assert", "static_cast", "struct", "switch", + "template", "this", "thread_local", "throw", "true", "try", "typedef", "typeid", "typename", + "union", "unsigned", "using", "virtual", "void", "volatile", "wchar_t", "while", "xor", "xor_eq" }; bool found = binary_search(&keywordList[0], &keywordList[sizeof(keywordList) / sizeof(*keywordList)], @@ -1224,8 +1230,8 @@ splitScopedName(const string& scoped) // // If the passed name is a scoped name, return the identical scoped name, // but with all components that are C++ keywords replaced by -// their "_cxx_"-prefixed version; otherwise, if the passed name is -// not scoped, but a C++ keyword, return the "_cxx_"-prefixed name; +// their "_cpp_"-prefixed version; otherwise, if the passed name is +// not scoped, but a C++ keyword, return the "_cpp_"-prefixed name; // otherwise, return the name unchanged. // string @@ -1247,19 +1253,19 @@ Slice::fixKwd(const string& name) void Slice::writeMarshalUnmarshalCode(Output& out, const TypePtr& type, bool optional, int tag, const string& param, - bool marshal, const StringList& metaData, int typeCtx, const string& str, bool pointer, + bool marshal, const StringList& metaData, int typeCtx, const string& customStream, bool pointer, const string& obj) { string objPrefix = obj.empty() ? obj : obj + "."; ostringstream os; - if(str.empty()) + if(customStream.empty()) { - os << (marshal ? "__os" : "__is"); + os << (marshal ? "ostr" : "istr"); } else { - os << str; + os << customStream; } string deref; @@ -1302,13 +1308,13 @@ Slice::writeMarshalUnmarshalCode(Output& out, const TypePtr& type, bool optional return; } - out << nl << func << objPrefix << "___" << param << ");"; + out << nl << func << objPrefix << param << "_tmp_);"; writeParamEndCode(out, seq, optional, param, metaData, obj); return; } else if(seqType.find("%range") == 0) { - out << nl << func << objPrefix << "___" << param << ");"; + out << nl << func << objPrefix << param << "_tmp_);"; writeParamEndCode(out, seq, optional, param, metaData, obj); return; } @@ -1319,23 +1325,29 @@ Slice::writeMarshalUnmarshalCode(Output& out, const TypePtr& type, bool optional } void -Slice::writeMarshalCode(Output& out, const ParamDeclList& params, const OperationPtr& op, bool prepend, int typeCtx) +Slice::writeMarshalCode(Output& out, const ParamDeclList& params, const OperationPtr& op, bool prepend, int typeCtx, + const string& customStream, const string& retP) { - writeMarshalUnmarshalParams(out, params, op, true, prepend, typeCtx); + writeMarshalUnmarshalParams(out, params, op, true, prepend, typeCtx, customStream, retP); } void Slice::writeUnmarshalCode(Output& out, const ParamDeclList& params, const OperationPtr& op, bool prepend, int typeCtx, - const string& retP, const string& obj) + const string& customStream, const string& retP, const string& obj) { - writeMarshalUnmarshalParams(out, params, op, false, prepend, typeCtx, retP, obj); + writeMarshalUnmarshalParams(out, params, op, false, prepend, typeCtx, customStream, retP, obj); } void -Slice::writeAllocateCode(Output& out, const ParamDeclList& params, const OperationPtr& op, bool prepend, int typeCtx) +Slice::writeAllocateCode(Output& out, const ParamDeclList& params, const OperationPtr& op, bool prepend, int typeCtx, + const string& customRet) { string prefix = prepend ? paramPrefix : ""; - string returnValueS = "__ret"; + string returnValueS = customRet; + if(returnValueS.empty()) + { + returnValueS = "ret"; + } for(ParamDeclList::const_iterator p = params.begin(); p != params.end(); ++p) { @@ -1373,11 +1385,11 @@ Slice::getEndArg(const TypePtr& type, const StringList& metaData, const string& builtin->kind() != Builtin::KindObject && builtin->kind() != Builtin::KindObjectProxy) { - endArg = "___" + endArg; + endArg += "_tmp_"; } else if(!builtin || builtin->kind() != Builtin::KindByte) { - endArg = "___" + endArg; + endArg += "_tmp_"; } } else if(seqType.find("%range") == 0) @@ -1387,7 +1399,7 @@ Slice::getEndArg(const TypePtr& type, const StringList& metaData, const string& { md.push_back("cpp:type:" + seqType.substr(strlen("%range:"))); } - endArg = "___" + endArg; + endArg += "_tmp_"; } } return endArg; @@ -1403,7 +1415,7 @@ Slice::writeEndCode(Output& out, const ParamDeclList& params, const OperationPtr } if(op && op->returnType()) { - writeParamEndCode(out, op->returnType(), op->returnIsOptional(), "__ret", op->getMetaData()); + writeParamEndCode(out, op->returnType(), op->returnIsOptional(), "ret", op->getMetaData()); } } @@ -1429,7 +1441,7 @@ Slice::writeMarshalUnmarshalAllInHolder(IceUtilInternal::Output& out, return; } - string stream = marshal ? "__os" : "__is"; + string stream = marshal ? "ostr" : "istr"; string streamOp = marshal ? "writeAll" : "readAll"; out << nl << stream << "->" << streamOp; @@ -1525,7 +1537,7 @@ Slice::writeStreamHelpers(Output& out, } else { - out << nl << "static void write(S* __os, const " << fullName << "& v)"; + out << nl << "static void write(S* ostr, const " << fullName << "& v)"; } out << sb; @@ -1564,7 +1576,7 @@ Slice::writeStreamHelpers(Output& out, } else { - out << nl << "static void read(S* __is, " << fullName << "& v)"; + out << nl << "static void read(S* istr, " << fullName << "& v)"; } out << sb; diff --git a/cpp/src/Slice/CPlusPlusUtil.h b/cpp/src/Slice/CPlusPlusUtil.h index 0e359b9a1a7..10808d75cff 100644 --- a/cpp/src/Slice/CPlusPlusUtil.h +++ b/cpp/src/Slice/CPlusPlusUtil.h @@ -52,10 +52,12 @@ void writeMarshalUnmarshalCode(::IceUtilInternal::Output&, const TypePtr&, bool, bool, const StringList& = StringList(), int = 0, const std::string& = "", bool = true, const std::string& = ""); -void writeMarshalCode(::IceUtilInternal::Output&, const ParamDeclList&, const OperationPtr&, bool, int = 0); +void writeMarshalCode(::IceUtilInternal::Output&, const ParamDeclList&, const OperationPtr&, bool, + int = 0, const std::string& = "", const std::string& = ""); void writeUnmarshalCode(::IceUtilInternal::Output&, const ParamDeclList&, const OperationPtr&, bool, int = 0, - const std::string& = "", const std::string& = ""); -void writeAllocateCode(::IceUtilInternal::Output&, const ParamDeclList&, const OperationPtr&, bool, int = 0); + const std::string& = "", const std::string& = "", const std::string& = ""); +void writeAllocateCode(::IceUtilInternal::Output&, const ParamDeclList&, const OperationPtr&, bool, + int = 0, const std::string& = ""); std::string getEndArg(const TypePtr&, const StringList&, const std::string&); void writeEndCode(::IceUtilInternal::Output&, const ParamDeclList&, const OperationPtr&, bool = false); diff --git a/cpp/src/Slice/Parser.cpp b/cpp/src/Slice/Parser.cpp index e6e8fb768a6..3bcdd55a197 100644 --- a/cpp/src/Slice/Parser.cpp +++ b/cpp/src/Slice/Parser.cpp @@ -425,12 +425,13 @@ string Slice::Contained::flattenedScope() const { string s = scope(); - string flattenedScope; - for(string::const_iterator r = s.begin(); r != s.end(); ++r) + string::size_type pos = 0; + while((pos = s.find("::", pos)) != string::npos) { - flattenedScope += ((*r) == ':') ? '_' : *r; + s.replace(pos, 2, "_"); + } - return flattenedScope; + return s; } string @@ -3805,13 +3806,13 @@ Slice::ClassDef::ClassDef(const ContainerPtr& container, const string& name, int bool Slice::Proxy::isLocal() const { - return __class->isLocal(); + return _classDecl->isLocal(); } string Slice::Proxy::typeId() const { - return __class->scoped(); + return _classDecl->scoped(); } bool @@ -3835,13 +3836,13 @@ Slice::Proxy::isVariableLength() const ClassDeclPtr Slice::Proxy::_class() const { - return __class; + return _classDecl; } Slice::Proxy::Proxy(const ClassDeclPtr& cl) : SyntaxTreeBase(cl->unit()), Type(cl->unit()), - __class(cl) + _classDecl(cl) { } diff --git a/cpp/src/Slice/Parser.h b/cpp/src/Slice/Parser.h index c26de803f13..5e7a680bc08 100644 --- a/cpp/src/Slice/Parser.h +++ b/cpp/src/Slice/Parser.h @@ -707,7 +707,7 @@ public: protected: - ClassDeclPtr __class; + ClassDeclPtr _classDecl; }; // ---------------------------------------------------------------------- diff --git a/cpp/src/slice2cpp/Gen.cpp b/cpp/src/slice2cpp/Gen.cpp index ad125388647..65af5df2d0d 100644 --- a/cpp/src/slice2cpp/Gen.cpp +++ b/cpp/src/slice2cpp/Gen.cpp @@ -236,12 +236,12 @@ writeInParamsLambda(IceUtilInternal::Output& C, const OperationPtr& p, const Par } else { - C << "[&](::Ice::OutputStream* __os)"; + C << "[&](::Ice::OutputStream* ostr)"; C << sb; writeMarshalCode(C, inParams, 0, true, TypeContextInParam | TypeContextCpp11); if(p->sendsClasses(false)) { - C << nl << "__os->writePendingValues();"; + C << nl << "ostr->writePendingValues();"; } C << eb; } @@ -267,11 +267,11 @@ throwUserExceptionLambda(IceUtilInternal::Output& C, ExceptionList throws) // throws.sort(Slice::DerivedToBaseCompare()); - C << "[](const ::Ice::UserException& __ex)"; + C << "[](const ::Ice::UserException& ex)"; C << sb; C << nl << "try"; C << sb; - C << nl << "__ex.ice_throw();"; + C << nl << "ex.ice_throw();"; C << eb; // // Generate a catch block for each legal user exception. @@ -427,7 +427,7 @@ Slice::Gen::generateChecksumMap(const UnitPtr& p) { C << sp << nl << "namespace"; C << nl << "{"; - C << sp << nl << "const char* __sliceChecksums[] ="; + C << sp << nl << "const char* iceSliceChecksums[] ="; C << sb; for(ChecksumMap::const_iterator q = map.begin(); q != map.end(); ++q) { @@ -443,7 +443,7 @@ Slice::Gen::generateChecksumMap(const UnitPtr& p) } C << nl << "0"; C << eb << ';'; - C << nl << "const IceInternal::SliceChecksumInit __sliceChecksumInit(__sliceChecksums);"; + C << nl << "const IceInternal::SliceChecksumInit iceSliceChecksumInit(iceSliceChecksums);"; C << sp << nl << "}"; } } @@ -935,21 +935,15 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p) DataMemberList allDataMembers = p->allDataMembers(); bool hasDefaultValues = p->hasDefaultValues(); - vector<string> params; vector<string> allTypes; vector<string> allParamDecls; vector<string> baseParams; - for(DataMemberList::const_iterator q = dataMembers.begin(); q != dataMembers.end(); ++q) - { - params.push_back(fixKwd((*q)->name())); - } - for(DataMemberList::const_iterator q = allDataMembers.begin(); q != allDataMembers.end(); ++q) { string typeName = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring); allTypes.push_back(typeName); - allParamDecls.push_back(typeName + " __ice_" + fixKwd((*q)->name())); + allParamDecls.push_back(typeName + " iceP_" + (*q)->name()); } if(base) @@ -957,7 +951,7 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p) DataMemberList baseDataMembers = base->allDataMembers(); for(DataMemberList::const_iterator q = baseDataMembers.begin(); q != baseDataMembers.end(); ++q) { - baseParams.push_back("__ice_" + fixKwd((*q)->name())); + baseParams.push_back("iceP_" + (*q)->name()); } } @@ -1012,7 +1006,7 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p) if(!p->isLocal()) { - string initName = p->flattenedScope() + p->name() + "_init"; + string initName = "iceC" + p->flattenedScope() + p->name() + "_init"; C << sp << nl << "namespace"; C << nl << "{"; @@ -1025,10 +1019,10 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p) if(p->isLocal()) { - C << sp << nl << scoped.substr(2) << "::" << name << spar << "const char* __file" << "int __line" << epar + C << sp << nl << scoped.substr(2) << "::" << name << spar << "const char* file_" << "int line_" << epar << " :"; C.inc(); - emitUpcall(base, "(__file, __line)", true); + emitUpcall(base, "(file_, line_)", true); if(p->hasDefaultValues()) { C << ", "; @@ -1054,10 +1048,10 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p) C << scoped.substr(2) << "::" << name << spar; if(p->isLocal()) { - C << "const char* __file" << "int __line"; + C << "const char* file_" << "int line_"; } C << allParamDecls << epar; - if(p->isLocal() || !baseParams.empty() || !params.empty()) + if(p->isLocal() || !baseParams.empty() || !dataMembers.empty()) { C << " :"; C.inc(); @@ -1067,7 +1061,7 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p) upcall = "("; if(p->isLocal()) { - upcall += "__file, __line"; + upcall += "file_, line_"; } for(vector<string>::const_iterator pi = baseParams.begin(); pi != baseParams.end(); ++pi) { @@ -1079,21 +1073,21 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p) } upcall += ")"; } - if(!params.empty()) + if(!dataMembers.empty()) { upcall += ","; } emitUpcall(base, upcall, p->isLocal()); } - for(vector<string>::const_iterator pi = params.begin(); pi != params.end(); ++pi) + for(DataMemberList::const_iterator d = dataMembers.begin(); d != dataMembers.end(); ++d) { - if(pi != params.begin()) + if(d != dataMembers.begin()) { C << ","; } - C << nl << *pi << "(__ice_" << *pi << ')'; + C << nl << fixKwd((*d)->name()) << "(iceP_" << (*d)->name() << ')'; } - if(p->isLocal() || !baseParams.empty() || !params.empty()) + if(p->isLocal() || !baseParams.empty() || !dataMembers.empty()) { C.dec(); } @@ -1134,10 +1128,10 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p) { if(!base || (base && !base->usesClasses(false))) { - H << sp << nl << "virtual bool __usesClasses() const;"; + H << sp << nl << "virtual bool _usesClasses() const;"; C << sp << nl << "bool"; - C << nl << scoped.substr(2) << "::__usesClasses() const"; + C << nl << scoped.substr(2) << "::_usesClasses() const"; C << sb; C << nl << "return true;"; C << eb; @@ -1167,62 +1161,62 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p) if(preserved && !basePreserved) { - H << sp << nl << "virtual void __write(::Ice::OutputStream*) const;"; - H << nl << "virtual void __read(::Ice::InputStream*);"; + H << sp << nl << "virtual void _write(::Ice::OutputStream*) const;"; + H << nl << "virtual void _read(::Ice::InputStream*);"; string baseName = base ? fixKwd(base->scoped()) : string("::Ice::UserException"); - H << nl << "using " << baseName << "::__write;"; - H << nl << "using " << baseName << "::__read;"; + H << nl << "using " << baseName << "::_write;"; + H << nl << "using " << baseName << "::_read;"; } H.dec(); H << sp << nl << "protected:"; H.inc(); - H << sp << nl << "virtual void __writeImpl(::Ice::OutputStream*) const;"; - H << nl << "virtual void __readImpl(::Ice::InputStream*);"; + H << sp << nl << "virtual void _writeImpl(::Ice::OutputStream*) const;"; + H << nl << "virtual void _readImpl(::Ice::InputStream*);"; string baseName = base ? fixKwd(base->scoped()) : string("::Ice::UserException"); if(preserved && !basePreserved) { - H << sp << nl << "::Ice::SlicedDataPtr __slicedData;"; + H << sp << nl << "::Ice::SlicedDataPtr _slicedData;"; - C << sp << nl << "void" << nl << scoped.substr(2) << "::__write(::Ice::OutputStream* __os) const"; + C << sp << nl << "void" << nl << scoped.substr(2) << "::_write(::Ice::OutputStream* ostr) const"; C << sb; - C << nl << "__os->startException(__slicedData);"; - C << nl << "__writeImpl(__os);"; - C << nl << "__os->endException();"; + C << nl << "ostr->startException(_slicedData);"; + C << nl << "_writeImpl(ostr);"; + C << nl << "ostr->endException();"; C << eb; - C << sp << nl << "void" << nl << scoped.substr(2) << "::__read(::Ice::InputStream* __is)"; + C << sp << nl << "void" << nl << scoped.substr(2) << "::_read(::Ice::InputStream* istr)"; C << sb; - C << nl << "__is->startException();"; - C << nl << "__readImpl(__is);"; - C << nl << "__slicedData = __is->endException(true);"; + C << nl << "istr->startException();"; + C << nl << "_readImpl(istr);"; + C << nl << "_slicedData = istr->endException(true);"; C << eb; } - C << sp << nl << "void" << nl << scoped.substr(2) << "::__writeImpl(::Ice::OutputStream* __os) const"; + C << sp << nl << "void" << nl << scoped.substr(2) << "::_writeImpl(::Ice::OutputStream* ostr) const"; C << sb; - C << nl << "__os->startSlice(\"" << p->scoped() << "\", -1, " << (!base ? "true" : "false") << ");"; - C << nl << "Ice::StreamWriter< ::" << scoped.substr(2) << ", ::Ice::OutputStream>::write(__os, *this);"; - C << nl << "__os->endSlice();"; + C << nl << "ostr->startSlice(\"" << p->scoped() << "\", -1, " << (!base ? "true" : "false") << ");"; + C << nl << "Ice::StreamWriter< ::" << scoped.substr(2) << ", ::Ice::OutputStream>::write(ostr, *this);"; + C << nl << "ostr->endSlice();"; if(base) { - emitUpcall(base, "::__writeImpl(__os);"); + emitUpcall(base, "::_writeImpl(ostr);"); } C << eb; - C << sp << nl << "void" << nl << scoped.substr(2) << "::__readImpl(::Ice::InputStream* __is)"; + C << sp << nl << "void" << nl << scoped.substr(2) << "::_readImpl(::Ice::InputStream* istr)"; C << sb; - C << nl << "__is->startSlice();"; - C << nl << "Ice::StreamReader< ::" << scoped.substr(2) << ", ::Ice::InputStream>::read(__is, *this);"; - C << nl << "__is->endSlice();"; + C << nl << "istr->startSlice();"; + C << nl << "Ice::StreamReader< ::" << scoped.substr(2) << ", ::Ice::InputStream>::read(istr, *this);"; + C << nl << "istr->endSlice();"; if(base) { - emitUpcall(base, "::__readImpl(__is);"); + emitUpcall(base, "::_readImpl(istr);"); } C << eb; } @@ -1238,7 +1232,7 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p) if(!_doneStaticSymbol) { _doneStaticSymbol = true; - H << sp << nl << "static " << name << " __" << p->name() << "_init;"; + H << sp << nl << "static " << name << " _iceS_" << p->name() << "_init;"; } } @@ -1304,7 +1298,7 @@ Slice::Gen::TypesVisitor::visitStructStart(const StructPtr& p) { string typeName = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring); types.push_back(typeName); - paramDecls.push_back(typeName + " __ice_" + (*q)->name()); + paramDecls.push_back(typeName + " iceP_" + (*q)->name()); } H << nl; @@ -1322,7 +1316,7 @@ Slice::Gen::TypesVisitor::visitStructStart(const StructPtr& p) H << ','; } string memberName = fixKwd((*q)->name()); - H << nl << memberName << '(' << "__ice_" << (*q)->name() << ')'; + H << nl << memberName << '(' << "iceP_" << (*q)->name() << ')'; } H.dec(); @@ -1356,34 +1350,34 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p) bool containsSequence = false; if((Dictionary::legalKeyType(p, containsSequence) && !containsSequence) || p->hasMetaData("cpp:comparable")) { - H << sp << nl << "bool operator==(const " << name << "& __rhs) const"; + H << sp << nl << "bool operator==(const " << name << "& rhs_) const"; H << sb; - H << nl << "if(this == &__rhs)"; + H << nl << "if(this == &rhs_)"; H << sb; H << nl << "return true;"; H << eb; for(vector<string>::const_iterator pi = params.begin(); pi != params.end(); ++pi) { - H << nl << "if(" << *pi << " != __rhs." << *pi << ')'; + H << nl << "if(" << *pi << " != rhs_." << *pi << ')'; H << sb; H << nl << "return false;"; H << eb; } H << nl << "return true;"; H << eb; - H << sp << nl << "bool operator<(const " << name << "& __rhs) const"; + H << sp << nl << "bool operator<(const " << name << "& rhs_) const"; H << sb; - H << nl << "if(this == &__rhs)"; + H << nl << "if(this == &rhs_)"; H << sb; H << nl << "return false;"; H << eb; for(vector<string>::const_iterator pi = params.begin(); pi != params.end(); ++pi) { - H << nl << "if(" << *pi << " < __rhs." << *pi << ')'; + H << nl << "if(" << *pi << " < rhs_." << *pi << ')'; H << sb; H << nl << "return true;"; H << eb; - H << nl << "else if(__rhs." << *pi << " < " << *pi << ')'; + H << nl << "else if(rhs_." << *pi << " < " << *pi << ')'; H << sb; H << nl << "return false;"; H << eb; @@ -1391,21 +1385,21 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p) H << nl << "return false;"; H << eb; - H << sp << nl << "bool operator!=(const " << name << "& __rhs) const"; + H << sp << nl << "bool operator!=(const " << name << "& rhs) const"; H << sb; - H << nl << "return !operator==(__rhs);"; + H << nl << "return !operator==(rhs);"; H << eb; - H << nl << "bool operator<=(const " << name << "& __rhs) const"; + H << nl << "bool operator<=(const " << name << "& rhs) const"; H << sb; - H << nl << "return operator<(__rhs) || operator==(__rhs);"; + H << nl << "return operator<(rhs) || operator==(rhs);"; H << eb; - H << nl << "bool operator>(const " << name << "& __rhs) const"; + H << nl << "bool operator>(const " << name << "& rhs) const"; H << sb; - H << nl << "return !operator<(__rhs) && !operator==(__rhs);"; + H << nl << "return !operator<(rhs) && !operator==(rhs);"; H << eb; - H << nl << "bool operator>=(const " << name << "& __rhs) const"; + H << nl << "bool operator>=(const " << name << "& rhs) const"; H << sb; - H << nl << "return !operator<(__rhs);"; + H << nl << "return !operator<(rhs);"; H << eb; } H << eb << ';'; @@ -1586,7 +1580,12 @@ Slice::Gen::ProxyDeclVisitor::visitClassDecl(const ClassDeclPtr& p) string scoped = fixKwd(p->scoped()); H << sp << nl << "class " << name << ';'; - H << nl << _dllExport << "void __read(::Ice::InputStream*, ::IceInternal::ProxyHandle< ::IceProxy" + // + // Underscore prefix because it's a private function that should not clash with + // an interface named 'readProxy' + // Note that _readProxy is always in the IceProxy::... namespace + // + H << nl << _dllExport << "void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< ::IceProxy" << scoped << ">&);"; H << nl << _dllExport << "::IceProxy::Ice::Object* upCast(::IceProxy" << scoped << "*);"; } @@ -1693,7 +1692,7 @@ Slice::Gen::ProxyVisitor::visitClassDefStart(const ClassDefPtr& p) H << sp << nl << "protected:"; H.inc(); - H << sp << nl << "virtual Object* __newInstance() const = 0;"; + H << sp << nl << "virtual Object* _newInstance() const = 0;"; H << eb << ';'; } @@ -1723,11 +1722,11 @@ Slice::Gen::ProxyVisitor::visitClassDefStart(const ClassDefPtr& p) << "::IceProxy::Ice::Object* ::IceProxy" << scope << "upCast(::IceProxy" << scoped << "* p) { return p; }"; C << sp; - C << nl << "void" << nl << "::IceProxy" << scope << "__read(::Ice::InputStream* __is, " + C << nl << "void" << nl << "::IceProxy" << scope << "_readProxy(::Ice::InputStream* istr, " << "::IceInternal::ProxyHandle< ::IceProxy" << scoped << ">& v)"; C << sb; C << nl << "::Ice::ObjectPrx proxy;"; - C << nl << "__is->read(proxy);"; + C << nl << "istr->read(proxy);"; C << nl << "if(!proxy)"; C << sb; C << nl << "v = 0;"; @@ -1735,7 +1734,7 @@ Slice::Gen::ProxyVisitor::visitClassDefStart(const ClassDefPtr& p) C << nl << "else"; C << sb; C << nl << "v = new ::IceProxy" << scoped << ';'; - C << nl << "v->__copyFrom(proxy);"; + C << nl << "v->_copyFrom(proxy);"; C << eb; C << eb; @@ -1754,12 +1753,12 @@ Slice::Gen::ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p) H.dec(); H << sp << nl << "protected: "; H.inc(); - H << sp << nl << _dllMemberExport << "virtual ::IceProxy::Ice::Object* __newInstance() const;"; + H << sp << nl << _dllMemberExport << "virtual ::IceProxy::Ice::Object* _newInstance() const;"; H << eb << ';'; C << sp; C << nl << "::IceProxy::Ice::Object*"; - C << nl << "IceProxy" << scoped << "::__newInstance() const"; + C << nl << "IceProxy" << scoped << "::_newInstance() const"; C << sb; C << nl << "return new " << name << ";"; C << eb; @@ -1809,7 +1808,7 @@ void Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p) { string name = p->name(); - string flatName = p->flattenedScope() + p->name() + "_name"; + string flatName = "iceC" + p->flattenedScope() + p->name() + "_name"; string scoped = fixKwd(p->scoped()); string scope = fixKwd(p->scope()); @@ -1889,12 +1888,12 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p) } // - // Check if we need to generate a private ___end_ method. This is the case if the + // Check if we need to generate a private _iceI_end_ method. This is the case if the // when using certain mapping features such as cpp:array. While // the regular end_ method can't return pair<const TYPE*, const TYPE*> because the // pointers would be invalid once end_ returns, we still want to allow using this // alternate mapping with AMI response callbacks (to allow zero-copy for instance). - // For this purpose, we generate a special ___end method which is used by the + // For this purpose, we generate a special _iceI_end method which is used by the // completed implementation of the generated Callback_Inft_opName operation // delegate. // @@ -1903,65 +1902,65 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p) { string typeStringEndAMI = outputTypeToString(ret, p->returnIsOptional(), p->getMetaData(), _useWstring | TypeContextAMIPrivateEnd); - outParamsDeclEndAMI.push_back(typeStringEndAMI + ' ' + "__ret"); + outParamsDeclEndAMI.push_back(typeStringEndAMI + ' ' + "ret"); } string thisPointer = fixKwd(scope.substr(0, scope.size() - 2)) + "*"; string deprecateSymbol = getDeprecateSymbol(p, cl); H << sp << nl << deprecateSymbol << _dllMemberExport << retS << ' ' << fixKwd(name) << spar << paramsDecl - << "const ::Ice::Context& __ctx = ::Ice::noExplicitContext" << epar; + << "const ::Ice::Context& context = ::Ice::noExplicitContext" << epar; H << sb << nl; if(ret) { H << "return "; } - H << "end_" << name << spar << outParamNamesAMI << "__begin_" + name << spar << argsAMI; - H << "__ctx" << "::IceInternal::__dummyCallback" << "0" << "true" << epar << epar << ';'; + H << "end_" << name << spar << outParamNamesAMI << "_iceI_begin_" + name << spar << argsAMI; + H << "context" << "::IceInternal::dummyCallback" << "0" << "true" << epar << epar << ';'; H << eb; H << sp << nl << "::Ice::AsyncResultPtr begin_" << name << spar << paramsDeclAMI - << "const ::Ice::Context& __ctx = ::Ice::noExplicitContext" << epar; + << "const ::Ice::Context& context = ::Ice::noExplicitContext" << epar; H << sb; - H << nl << "return __begin_" << name << spar << argsAMI << "__ctx" << "::IceInternal::__dummyCallback" << "0" + H << nl << "return _iceI_begin_" << name << spar << argsAMI << "context" << "::IceInternal::dummyCallback" << "0" << epar << ';'; H << eb; H << sp << nl << "::Ice::AsyncResultPtr begin_" << name << spar << paramsDeclAMI - << "const ::Ice::CallbackPtr& __del" - << "const ::Ice::LocalObjectPtr& __cookie = 0" << epar; + << "const ::Ice::CallbackPtr& del" + << "const ::Ice::LocalObjectPtr& cookie = 0" << epar; H << sb; - H << nl << "return __begin_" << name << spar << argsAMI << "::Ice::noExplicitContext" << "__del" << "__cookie" << epar << ';'; + H << nl << "return _iceI_begin_" << name << spar << argsAMI << "::Ice::noExplicitContext" << "del" << "cookie" << epar << ';'; H << eb; H << sp << nl << "::Ice::AsyncResultPtr begin_" << name << spar << paramsDeclAMI - << "const ::Ice::Context& __ctx" - << "const ::Ice::CallbackPtr& __del" - << "const ::Ice::LocalObjectPtr& __cookie = 0" << epar; + << "const ::Ice::Context& context" + << "const ::Ice::CallbackPtr& del" + << "const ::Ice::LocalObjectPtr& cookie = 0" << epar; H << sb; - H << nl << "return __begin_" << name << spar << argsAMI << "__ctx" << "__del" << "__cookie" << epar << ';'; + H << nl << "return _iceI_begin_" << name << spar << argsAMI << "context" << "del" << "cookie" << epar << ';'; H << eb; H << sp << nl << "::Ice::AsyncResultPtr begin_" << name << spar << paramsDeclAMI - << "const " + delNameScoped + "Ptr& __del" - << "const ::Ice::LocalObjectPtr& __cookie = 0" << epar; + << "const " + delNameScoped + "Ptr& del" + << "const ::Ice::LocalObjectPtr& cookie = 0" << epar; H << sb; - H << nl << "return __begin_" << name << spar << argsAMI << "::Ice::noExplicitContext" << "__del" << "__cookie" << epar << ';'; + H << nl << "return _iceI_begin_" << name << spar << argsAMI << "::Ice::noExplicitContext" << "del" << "cookie" << epar << ';'; H << eb; H << sp << nl << "::Ice::AsyncResultPtr begin_" << name << spar << paramsDeclAMI - << "const ::Ice::Context& __ctx" - << "const " + delNameScoped + "Ptr& __del" - << "const ::Ice::LocalObjectPtr& __cookie = 0" << epar; + << "const ::Ice::Context& context" + << "const " + delNameScoped + "Ptr& del" + << "const ::Ice::LocalObjectPtr& cookie = 0" << epar; H << sb; - H << nl << "return __begin_" << name << spar << argsAMI << "__ctx" << "__del" << "__cookie" << epar << ';'; + H << nl << "return _iceI_begin_" << name << spar << argsAMI << "context" << "del" << "cookie" << epar << ';'; H << eb; H << sp << nl << _dllMemberExport << retS << " end_" << name << spar << outParamsDeclAMI << "const ::Ice::AsyncResultPtr&" << epar << ';'; if(generatePrivateEnd) { - H << sp << nl << _dllMemberExport << "void ___end_" << name << spar << outParamsDeclEndAMI; + H << sp << nl << _dllMemberExport << "void _iceI_end_" << name << spar << outParamsDeclEndAMI; H << "const ::Ice::AsyncResultPtr&" << epar << ';'; } @@ -1969,71 +1968,71 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p) H.dec(); H << nl << "private:"; H.inc(); - H << sp << nl << _dllMemberExport << "::Ice::AsyncResultPtr __begin_" << name << spar + H << sp << nl << _dllMemberExport << "::Ice::AsyncResultPtr _iceI_begin_" << name << spar << paramsAMI << "const ::Ice::Context&" << "const ::IceInternal::CallbackBasePtr&" - << "const ::Ice::LocalObjectPtr& __cookie = 0" + << "const ::Ice::LocalObjectPtr& cookie = 0" << "bool sync = false" << epar << ';'; H << nl; H.dec(); H << nl << "public:"; H.inc(); - C << sp << nl << "::Ice::AsyncResultPtr" << nl << "IceProxy" << scope << "__begin_" << name << spar << paramsDeclAMI - << "const ::Ice::Context& __ctx" << "const ::IceInternal::CallbackBasePtr& __del" - << "const ::Ice::LocalObjectPtr& __cookie" << "bool sync" << epar; + C << sp << nl << "::Ice::AsyncResultPtr" << nl << "IceProxy" << scope << "_iceI_begin_" << name << spar << paramsDeclAMI + << "const ::Ice::Context& context" << "const ::IceInternal::CallbackBasePtr& del" + << "const ::Ice::LocalObjectPtr& cookie" << "bool sync" << epar; C << sb; if(p->returnsData()) { - C << nl << "__checkTwowayOnly(" << flatName << ", sync);"; + C << nl << "_checkTwowayOnly(" << flatName << ", sync);"; } - C << nl << "::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::CallbackOutgoing(this, " << flatName - << ", __del, __cookie, sync);"; + C << nl << "::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, " << flatName + << ", del, cookie, sync);"; C << nl << "try"; C << sb; - C << nl << "__result->prepare(" << flatName << ", " << operationModeToString(p->sendMode()) << ", __ctx);"; + C << nl << "result->prepare(" << flatName << ", " << operationModeToString(p->sendMode()) << ", context);"; if(inParams.empty()) { - C << nl << "__result->writeEmptyParams();"; + C << nl << "result->writeEmptyParams();"; } else { - C << nl << "::Ice::OutputStream* __os = __result->startWriteParams(" << opFormatTypeToString(p) <<");"; + C << nl << "::Ice::OutputStream* ostr = result->startWriteParams(" << opFormatTypeToString(p) <<");"; writeMarshalCode(C, inParams, 0, true, TypeContextInParam); if(p->sendsClasses(false)) { - C << nl << "__os->writePendingValues();"; + C << nl << "ostr->writePendingValues();"; } - C << nl << "__result->endWriteParams();"; + C << nl << "result->endWriteParams();"; } - C << nl << "__result->invoke(" << flatName << ");"; + C << nl << "result->invoke(" << flatName << ");"; C << eb; - C << nl << "catch(const ::Ice::Exception& __ex)"; + C << nl << "catch(const ::Ice::Exception& ex)"; C << sb; - C << nl << "__result->abort(__ex);"; + C << nl << "result->abort(ex);"; C << eb; - C << nl << "return __result;"; + C << nl << "return result;"; C << eb; C << sp << nl << retS << nl << "IceProxy" << scope << "end_" << name << spar << outParamsDeclAMI - << "const ::Ice::AsyncResultPtr& __result" << epar; + << "const ::Ice::AsyncResultPtr& result" << epar; C << sb; if(p->returnsData()) { - C << nl << "::Ice::AsyncResult::__check(__result, this, " << flatName << ");"; + C << nl << "::Ice::AsyncResult::check(result, this, " << flatName << ");"; // // COMPILERFIX: It's necessary to generate the allocate code here before - // this if(!__result->wait()). If generated after this if block, we get + // this if(!result->wait()). If generated after this if block, we get // access violations errors with the test/Ice/slicing/objects test on VC9 // and Windows 64 bits when compiled with optimization (see bug 4400). // writeAllocateCode(C, ParamDeclList(), p, true, _useWstring | TypeContextAMIEnd); - C << nl << "if(!__result->__wait())"; + C << nl << "if(!result->waitForResponse())"; C << sb; C << nl << "try"; C << sb; - C << nl << "__result->__throwUserException();"; + C << nl << "result->throwUserException();"; C << eb; // // Generate a catch block for each legal user exception. @@ -2054,33 +2053,33 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p) C << nl << "throw;"; C << eb; } - C << nl << "catch(const ::Ice::UserException& __ex)"; + C << nl << "catch(const ::Ice::UserException& ex)"; C << sb; - C << nl << "throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_id());"; + C << nl << "throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());"; C << eb; C << eb; if(ret || !outParams.empty()) { - C << nl << "::Ice::InputStream* __is = __result->__startReadParams();"; + C << nl << "::Ice::InputStream* istr = result->startReadParams();"; writeUnmarshalCode(C, outParams, p, true, _useWstring | TypeContextAMIEnd); if(p->returnsClasses(false)) { - C << nl << "__is->readPendingValues();"; + C << nl << "istr->readPendingValues();"; } - C << nl << "__result->__endReadParams();"; + C << nl << "result->endReadParams();"; } else { - C << nl << "__result->__readEmptyParams();"; + C << nl << "result->readEmptyParams();"; } if(ret) { - C << nl << "return __ret;"; + C << nl << "return ret;"; } } else { - C << nl << "__end(__result, " << flatName << ");"; + C << nl << "_end(result, " << flatName << ");"; } C << eb; @@ -2088,15 +2087,15 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p) { assert(p->returnsData()); - C << sp << nl << "void IceProxy" << scope << "___end_" << name << spar << outParamsDeclEndAMI - << "const ::Ice::AsyncResultPtr& __result" << epar; + C << sp << nl << "void IceProxy" << scope << "_iceI_end_" << name << spar << outParamsDeclEndAMI + << "const ::Ice::AsyncResultPtr& result" << epar; C << sb; - C << nl << "::Ice::AsyncResult::__check(__result, this, " << flatName << ");"; - C << nl << "if(!__result->__wait())"; + C << nl << "::Ice::AsyncResult::check(result, this, " << flatName << ");"; + C << nl << "if(!result->waitForResponse())"; C << sb; C << nl << "try"; C << sb; - C << nl << "__result->__throwUserException();"; + C << nl << "result->throwUserException();"; C << eb; // // Generate a catch block for each legal user exception. @@ -2117,25 +2116,25 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p) C << nl << "throw;"; C << eb; } - C << nl << "catch(const ::Ice::UserException& __ex)"; + C << nl << "catch(const ::Ice::UserException& ex)"; C << sb; - C << nl << "throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_id());"; + C << nl << "throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());"; C << eb; C << eb; if(ret || !outParams.empty()) { - C << nl << "::Ice::InputStream* __is = __result->__startReadParams();"; + C << nl << "::Ice::InputStream* istr = result->startReadParams();"; writeUnmarshalCode(C, outParams, p, true, _useWstring | TypeContextAMIPrivateEnd); if(p->returnsClasses(false)) { - C << nl << "__is->readPendingValues();"; + C << nl << "istr->readPendingValues();"; } - C << nl << "__result->__endReadParams();"; + C << nl << "result->endReadParams();"; } else { - C << nl << "__result->__readEmptyParams();"; + C << nl << "result->readEmptyParams();"; } C << eb; } @@ -2177,11 +2176,20 @@ Slice::Gen::ObjectDeclVisitor::visitClassDecl(const ClassDeclPtr& p) H << sp << nl << "class " << name << ';'; if(!p->isLocal()) { + // + // upCast is not _upCast nor _iceUpCast for historical reasons. IceInternal::Handle + // depends on this name + // H << nl << _dllExport << "::Ice::Object* upCast(" << scoped << "*);"; H << nl << "typedef ::IceInternal::Handle< " << scoped << "> " << p->name() << "Ptr;"; H << nl << "typedef ::IceInternal::ProxyHandle< ::IceProxy" << scoped << "> " << p->name() << "Prx;"; H << nl << "typedef " << p->name() << "Prx " << p->name() << "PrxPtr;"; - H << nl << _dllExport << "void __patch(" << p->name() << "Ptr&, const ::Ice::ObjectPtr&);"; + + // + // _ice prefix because this function is in the Slice module namespace, where the user + // is allowed to define classes, functions etc. that start with _. + // + H << nl << _dllExport << "void _icePatchObjectPtr(" << p->name() << "Ptr&, const ::Ice::ObjectPtr&);"; } else { @@ -2196,7 +2204,7 @@ Slice::Gen::ObjectDeclVisitor::visitOperation(const OperationPtr& p) ClassDefPtr cl = ClassDefPtr::dynamicCast(p->container()); if(cl && !cl->isLocal()) { - string flatName = p->flattenedScope() + p->name() + "_name"; + string flatName = "iceC" + p->flattenedScope() + p->name() + "_name"; C << sp << nl << "const ::std::string " << flatName << " = \"" << p->name() << "\";"; } } @@ -2329,7 +2337,7 @@ Slice::Gen::ObjectVisitor::visitClassDefStart(const ClassDefPtr& p) { string typeName = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring); allTypes.push_back(typeName); - allParamDecls.push_back(typeName + " __ice_" + (*q)->name()); + allParamDecls.push_back(typeName + " iceP_" + (*q)->name()); } if(!p->isInterface()) @@ -2356,7 +2364,8 @@ Slice::Gen::ObjectVisitor::visitClassDefStart(const ClassDefPtr& p) { C << sp << nl << _dllExport - << "::Ice::Object* " << scope.substr(2) << "upCast(" << scoped << "* p) { return p; }"; + << "::Ice::Object* " << scope.substr(2) << "upCast(" << scoped << "* p) { return p; }" + << nl; // // It would make sense to provide a covariant ice_clone(); unfortunately many compilers @@ -2382,8 +2391,8 @@ Slice::Gen::ObjectVisitor::visitClassDefStart(const ClassDefPtr& p) C << sb; if(!p->isAbstract()) { - C << nl << "::Ice::Object* __p = new " << name << "(*this);"; - C << nl << "return __p;"; + C << nl << "::Ice::Object* p = new " << name << "(*this);"; + C << nl << "return p;"; } else { @@ -2425,7 +2434,7 @@ Slice::Gen::ObjectVisitor::visitClassDefStart(const ClassDefPtr& p) H << nl << "virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::noExplicitCurrent) const;"; H << sp << nl << "static const ::std::string& ice_staticId();"; - string flatName = p->flattenedScope() + p->name() + "_ids"; + string flatName = "iceC" + p->flattenedScope() + p->name() + "_ids"; C << sp << nl << "namespace"; C << nl << "{"; @@ -2445,9 +2454,9 @@ Slice::Gen::ObjectVisitor::visitClassDefStart(const ClassDefPtr& p) C << sp; C << nl << "bool" << nl << scoped.substr(2) - << "::ice_isA(const ::std::string& _s, const ::Ice::Current&) const"; + << "::ice_isA(const ::std::string& s, const ::Ice::Current&) const"; C << sb; - C << nl << "return ::std::binary_search(" << flatName << ", " << flatName << " + " << ids.size() << ", _s);"; + C << nl << "return ::std::binary_search(" << flatName << ", " << flatName << " + " << ids.size() << ", s);"; C << eb; C << sp; @@ -2527,9 +2536,9 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p) allOpNames.unique(); H << sp; - H << nl << "virtual bool __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);"; + H << nl << "virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&);"; - string flatName = p->flattenedScope() + p->name() + "_all"; + string flatName = "iceC" + p->flattenedScope() + p->name() + "_all"; C << sp << nl << "namespace"; C << nl << "{"; C << nl << "const ::std::string " << flatName << "[] ="; @@ -2547,10 +2556,10 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p) C << sp << nl << "}"; C << sp; C << nl << "bool"; - C << nl << scoped.substr(2) << "::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)"; + C << nl << scoped.substr(2) << "::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)"; C << sb; - C << nl << "::std::pair< const ::std::string*, const ::std::string*> r = " + C << nl << "::std::pair<const ::std::string*, const ::std::string*> r = " << "::std::equal_range(" << flatName << ", " << flatName << " + " << allOpNames.size() << ", current.operation);"; C << nl << "if(r.first == r.second)"; @@ -2566,7 +2575,7 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p) { C << nl << "case " << i++ << ':'; C << sb; - C << nl << "return ___" << *q << "(in, current);"; + C << nl << "return _iceD_" << *q << "(in, current);"; C << eb; } C << nl << "default:"; @@ -2597,7 +2606,7 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p) H << nl << "virtual ::Ice::Int ice_operationAttributes(const ::std::string&) const;"; - string opAttrFlatName = p->flattenedScope() + p->name() + "_operationAttributes"; + string opAttrFlatName = "iceC" + p->flattenedScope() + p->name() + "_operationAttributes"; C << sp << nl << "namespace"; C << nl << "{"; @@ -2631,7 +2640,7 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p) << "::ice_operationAttributes(const ::std::string& opName) const"; C << sb; - C << nl << "::std::pair< const ::std::string*, const ::std::string*> r = " + C << nl << "::std::pair<const ::std::string*, const ::std::string*> r = " << "::std::equal_range(" << flatName << ", " << flatName << " + " << allOpNames.size() << ", opName);"; C << nl << "if(r.first == r.second)"; @@ -2652,8 +2661,8 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p) if(preserved && !basePreserved) { H << sp; - H << nl << "virtual void __write(::Ice::OutputStream*) const;"; - H << nl << "virtual void __read(::Ice::InputStream*);"; + H << nl << "virtual void _iceWrite(::Ice::OutputStream*) const;"; + H << nl << "virtual void _iceRead(::Ice::InputStream*);"; } H.dec(); @@ -2661,49 +2670,49 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p) inProtected = true; H.inc(); - H << sp << nl << "virtual void __writeImpl(::Ice::OutputStream*) const;"; - H << nl << "virtual void __readImpl(::Ice::InputStream*);"; + H << sp << nl << "virtual void _iceWriteImpl(::Ice::OutputStream*) const;"; + H << nl << "virtual void _iceReadImpl(::Ice::InputStream*);"; if(preserved && !basePreserved) { C << sp; - C << nl << "void" << nl << scoped.substr(2) << "::__write(::Ice::OutputStream* __os) const"; + C << nl << "void" << nl << scoped.substr(2) << "::_iceWrite(::Ice::OutputStream* ostr) const"; C << sb; - C << nl << "__os->startValue(__slicedData);"; - C << nl << "__writeImpl(__os);"; - C << nl << "__os->endValue();"; + C << nl << "ostr->startValue(_iceSlicedData);"; + C << nl << "_iceWriteImpl(ostr);"; + C << nl << "ostr->endValue();"; C << eb; C << sp; - C << nl << "void" << nl << scoped.substr(2) << "::__read(::Ice::InputStream* __is)"; + C << nl << "void" << nl << scoped.substr(2) << "::_iceRead(::Ice::InputStream* istr)"; C << sb; - C << nl << "__is->startValue();"; - C << nl << "__readImpl(__is);"; - C << nl << "__slicedData = __is->endValue(true);"; + C << nl << "istr->startValue();"; + C << nl << "_iceReadImpl(istr);"; + C << nl << "_iceSlicedData = istr->endValue(true);"; C << eb; } C << sp; - C << nl << "void" << nl << scoped.substr(2) << "::__writeImpl(::Ice::OutputStream* __os) const"; + C << nl << "void" << nl << scoped.substr(2) << "::_iceWriteImpl(::Ice::OutputStream* ostr) const"; C << sb; - C << nl << "__os->startSlice(ice_staticId(), " << p->compactId() << (!base ? ", true" : ", false") << ");"; - C << nl << "Ice::StreamWriter< ::" << scoped.substr(2) << ", ::Ice::OutputStream>::write(__os, *this);"; - C << nl << "__os->endSlice();"; + C << nl << "ostr->startSlice(ice_staticId(), " << p->compactId() << (!base ? ", true" : ", false") << ");"; + C << nl << "Ice::StreamWriter< ::" << scoped.substr(2) << ", ::Ice::OutputStream>::write(ostr, *this);"; + C << nl << "ostr->endSlice();"; if(base) { - emitUpcall(base, "::__writeImpl(__os);"); + emitUpcall(base, "::_iceWriteImpl(ostr);"); } C << eb; C << sp; - C << nl << "void" << nl << scoped.substr(2) << "::__readImpl(::Ice::InputStream* __is)"; + C << nl << "void" << nl << scoped.substr(2) << "::_iceReadImpl(::Ice::InputStream* istr)"; C << sb; - C << nl << "__is->startSlice();"; - C << nl << "Ice::StreamReader< ::" << scoped.substr(2) << ", ::Ice::InputStream>::read(__is, *this);"; - C << nl << "__is->endSlice();"; + C << nl << "istr->startSlice();"; + C << nl << "Ice::StreamReader< ::" << scoped.substr(2) << ", ::Ice::InputStream>::read(istr, *this);"; + C << nl << "istr->endSlice();"; if(base) { - emitUpcall(base, "::__readImpl(__is);"); + emitUpcall(base, "::_iceReadImpl(istr);"); } C << eb; @@ -2714,13 +2723,13 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p) if(!p->isAbstract()) { - string initName = p->flattenedScope() + p->name() + "_init"; + string initName = "iceC" + p->flattenedScope() + p->name() + "_init"; C << nl << "const ::IceInternal::DefaultValueFactoryInit< " << scoped << "> " << initName << "(\"" << p->scoped() << "\");"; } if(p->compactId() >= 0) { - string initName = p->flattenedScope() + p->name() + "_compactIdInit"; + string initName = "iceC" + p->flattenedScope() + p->name() + "_compactIdInit"; C << nl << "const ::IceInternal::CompactIdInit " << initName << "(\"" << p->scoped() << "\", " << p->compactId() << ");"; } @@ -2787,7 +2796,7 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p) H.inc(); inProtected = true; } - H << sp << nl << "::Ice::SlicedDataPtr __slicedData;"; + H << sp << nl << "::Ice::SlicedDataPtr _iceSlicedData;"; } if(generateFriend) @@ -2816,26 +2825,26 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p) // But we do this only once per source file, because a single instance is sufficient to initialize // all of the globals in a compilation unit. // - H << nl << "static ::Ice::ValueFactoryPtr _" << p->name() << "_init = " << p->scoped() << "::ice_factory();"; + H << nl << "static ::Ice::ValueFactoryPtr _iceS_" << p->name() << "_init = " << p->scoped() << "::ice_factory();"; } if(p->isLocal()) { H << sp; - H << nl << "inline bool operator==(const " << fixKwd(p->name()) << "& l, const " << fixKwd(p->name()) << "& r)"; + H << nl << "inline bool operator==(const " << fixKwd(p->name()) << "& lhs, const " << fixKwd(p->name()) << "& rhs)"; H << sb; - H << nl << "return static_cast<const ::Ice::LocalObject&>(l) == static_cast<const ::Ice::LocalObject&>(r);"; + H << nl << "return static_cast<const ::Ice::LocalObject&>(lhs) == static_cast<const ::Ice::LocalObject&>(rhs);"; H << eb; H << sp; - H << nl << "inline bool operator<(const " << fixKwd(p->name()) << "& l, const " << fixKwd(p->name()) << "& r)"; + H << nl << "inline bool operator<(const " << fixKwd(p->name()) << "& lhs, const " << fixKwd(p->name()) << "& rhs)"; H << sb; - H << nl << "return static_cast<const ::Ice::LocalObject&>(l) < static_cast<const ::Ice::LocalObject&>(r);"; + H << nl << "return static_cast<const ::Ice::LocalObject&>(lhs) < static_cast<const ::Ice::LocalObject&>(rhs);"; H << eb; } else { C << sp << nl << "void " << _dllExport; - C << nl << scope.substr(2) << "__patch(" << p->name() << "Ptr& handle, const ::Ice::ObjectPtr& v)"; + C << nl << scope.substr(2) << "_icePatchObjectPtr(" << p->name() << "Ptr& handle, const ::Ice::ObjectPtr& v)"; C << sb; C << nl << "handle = " << scope << p->name() << "Ptr::dynamicCast(v);"; C << nl << "if(v && !handle)"; @@ -2845,14 +2854,14 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p) C << eb; H << sp; - H << nl << "inline bool operator==(const " << fixKwd(p->name()) << "& l, const " << fixKwd(p->name()) << "& r)"; + H << nl << "inline bool operator==(const " << fixKwd(p->name()) << "& lhs, const " << fixKwd(p->name()) << "& rhs)"; H << sb; - H << nl << "return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);"; + H << nl << "return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);"; H << eb; H << sp; - H << nl << "inline bool operator<(const " << fixKwd(p->name()) << "& l, const " << fixKwd(p->name()) << "& r)"; + H << nl << "inline bool operator<(const " << fixKwd(p->name()) << "& lhs, const " << fixKwd(p->name()) << "& rhs)"; H << sb; - H << nl << "return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);"; + H << nl << "return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);"; H << eb; } @@ -2892,8 +2901,7 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p) string classScopedAMD = classScope + classNameAMD; string paramsAMD = "(const " + classScopedAMD + '_' + name + "Ptr&, "; - string paramsDeclAMD = "(const " + classScopedAMD + '_' + name + "Ptr& __cb, "; - string argsAMD = "(new IceAsync" + classScopedAMD + '_' + name + "(__inS), "; + string argsAMD = "(new IceAsync" + classScopedAMD + '_' + name + "(inS), "; ParamDeclList inParams; ParamDeclList outParams; @@ -2933,10 +2941,6 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p) { paramsAMD += typeString; paramsAMD += ", "; - paramsDeclAMD += typeString; - paramsDeclAMD += ' '; - paramsDeclAMD += paramName; - paramsDeclAMD += ", "; argsAMD += paramName; argsAMD += ", "; } @@ -2956,8 +2960,8 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p) } params += "const ::Ice::Current& = ::Ice::noExplicitCurrent)"; - paramsDecl += "const ::Ice::Current& __current)"; - args += "__current)"; + paramsDecl += "const ::Ice::Current& current)"; + args += "current)"; } else { @@ -2967,8 +2971,7 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p) } paramsAMD += "const ::Ice::Current& = ::Ice::noExplicitCurrent)"; - paramsDeclAMD += "const ::Ice::Current& __current)"; - argsAMD += "__current)"; + argsAMD += "current)"; string isConst = ((p->mode() == Operation::Nonmutating) || p->hasMetaData("cpp:const")) ? " const" : ""; bool amd = !cl->isLocal() && (cl->hasMetaData("amd") || p->hasMetaData("amd")); @@ -2987,55 +2990,59 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p) if(!cl->isLocal()) { - H << nl << "bool ___" << name << "(::IceInternal::Incoming&, const ::Ice::Current&)" << isConst << ';'; + H << nl << "bool _iceD_" << name << "(::IceInternal::Incoming&, const ::Ice::Current&)" << isConst << ';'; C << sp; - C << nl << "bool" << nl << scope.substr(2) << "___" << name << "(::IceInternal::Incoming& __inS" - << ", const ::Ice::Current& __current)" << isConst; + // + // inS, ret, current etc. may shadow class-with-operations data members in C++98 + // + C << nl << "bool" << nl << scope.substr(2) << "_iceD_" << name << "(::IceInternal::Incoming& inS" + << ", const ::Ice::Current& current)" << isConst; C << sb; - C << nl << "__checkMode(" << operationModeToString(p->mode()) << ", __current.mode);"; + C << nl << "_iceCheckMode(" << operationModeToString(p->mode()) << ", current.mode);"; if(!inParams.empty()) { - C << nl << "::Ice::InputStream* __is = __inS.startReadParams();"; + C << nl << "::Ice::InputStream* istr = inS.startReadParams();"; writeAllocateCode(C, inParams, 0, true, _useWstring | TypeContextInParam); writeUnmarshalCode(C, inParams, 0, true, TypeContextInParam); if(p->sendsClasses(false)) { - C << nl << "__is->readPendingValues();"; + C << nl << "istr->readPendingValues();"; } - C << nl << "__inS.endReadParams();"; + C << nl << "inS.endReadParams();"; } else { - C << nl << "__inS.readEmptyParams();"; + C << nl << "inS.readEmptyParams();"; } if(p->format() != DefaultFormat) { - C << nl << "__inS.setFormat(" << opFormatTypeToString(p) << ");"; + C << nl << "inS.setFormat(" << opFormatTypeToString(p) << ");"; } if(!amd) { - writeAllocateCode(C, outParams, 0, true, _useWstring); + writeAllocateCode(C, outParams, 0, true, _useWstring, "ret"); + C << nl; if(ret) { - C << retS << " __ret = "; + C << retS << " ret = "; } C << fixKwd(name) << args << ';'; if(ret || !outParams.empty()) { - C << nl << "::Ice::OutputStream* __os = __inS.startWriteParams();"; - writeMarshalCode(C, outParams, p, true); + C << nl << "::Ice::OutputStream* ostr = inS.startWriteParams();"; + writeMarshalCode(C, outParams, p, true, 0); if(p->returnsClasses(false)) { - C << nl << "__os->writePendingValues();"; + C << nl << "ostr->writePendingValues();"; } - C << nl << "__inS.endWriteParams();"; + C << nl << "inS.endWriteParams();"; } else { - C << nl << "__inS.writeEmptyParams();"; + C << nl << "inS.writeEmptyParams();"; } C << nl << "return false;"; } @@ -3082,16 +3089,16 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p) H << sp << nl << "virtual ::Ice::AsyncResultPtr begin_" << name << spar << paramsDeclAMI << epar << " = 0;"; H << sp << nl << "virtual ::Ice::AsyncResultPtr begin_" << name << spar << paramsDeclAMI - << "const ::Ice::CallbackPtr& __del" - << "const ::Ice::LocalObjectPtr& __cookie = 0" << epar << " = 0;"; + << "const ::Ice::CallbackPtr& del" + << "const ::Ice::LocalObjectPtr& cookie = 0" << epar << " = 0;"; string clScope = fixKwd(cl->scope()); string delName = "Callback_" + cl->name() + "_" + name; string delNameScoped = clScope + delName; H << sp << nl << "virtual ::Ice::AsyncResultPtr begin_" << name << spar << paramsDeclAMI - << "const " + delNameScoped + "Ptr& __del" - << "const ::Ice::LocalObjectPtr& __cookie = 0" << epar << " = 0;"; + << "const " + delNameScoped + "Ptr& del" + << "const ::Ice::LocalObjectPtr& cookie = 0" << epar << " = 0;"; H << sp << nl << "virtual " << retS << " end_" << name << spar << outParamsDeclAMI << "const ::Ice::AsyncResultPtr&" << epar << " = 0;"; @@ -3126,7 +3133,7 @@ Slice::Gen::ObjectVisitor::emitGCFunctions(const ClassDefPtr& p) bool preserved = basePreserved || p->hasMetaData("preserve-slice"); // - // __gcVisit() is overridden by the basemost class that can be + // _iceGcVisit() is overridden by the basemost class that can be // cyclic, plus all classes derived from that class. // // We also override these methods for the initial preserved class in a @@ -3134,22 +3141,22 @@ Slice::Gen::ObjectVisitor::emitGCFunctions(const ClassDefPtr& p) // if(canBeCyclic || (preserved && !basePreserved)) { - H << nl << "virtual void __gcVisitMembers(::IceInternal::GCVisitor&);"; + H << nl << "virtual void _iceGcVisitMembers(::IceInternal::GCVisitor&);"; - C << sp << nl << "void" << nl << scoped.substr(2) << "::__gcVisitMembers(::IceInternal::GCVisitor& _v)"; + C << sp << nl << "void" << nl << scoped.substr(2) << "::_iceGcVisitMembers(::IceInternal::GCVisitor& v_)"; C << sb; bool hasCyclicBase = base && base->canBeCyclic(); if(hasCyclicBase || basePreserved) { - emitUpcall(bases.front(), "::__gcVisitMembers(_v);"); + emitUpcall(bases.front(), "::_iceGcVisitMembers(v_);"); } if(preserved && !basePreserved) { - C << nl << "if(__slicedData)"; + C << nl << "if(_iceSlicedData)"; C << sb; - C << nl << "__slicedData->__gcVisitMembers(_v);"; + C << nl << "_iceSlicedData->_iceGcVisitMembers(v_);"; C << eb; } @@ -3188,11 +3195,11 @@ Slice::Gen::ObjectVisitor::emitGCVisitCode(const TypePtr& p, const string& prefi if(decl) { string scope = fixKwd(decl->scope()); - C << nl << "if((" << scope << "upCast(" << prefix << name << ".get())->__gcVisit(_v)))"; + C << nl << "if((" << scope << "upCast(" << prefix << name << ".get())->_iceGcVisit(v_)))"; } else { - C << nl << "if((" << prefix << name << ".get())->__gcVisit(_v))"; + C << nl << "if((" << prefix << name << ".get())->_iceGcVisit(v_))"; } C << sb; C << nl << prefix << name << " = 0;"; @@ -3276,7 +3283,7 @@ Slice::Gen::ObjectVisitor::emitVirtualBaseInitializers(const ClassDefPtr& p, boo { upcall += ", "; } - upcall += "__ice_" + (*q)->name(); + upcall += "iceP_" + (*q)->name(); } upcall += ")"; @@ -3304,7 +3311,7 @@ Slice::Gen::ObjectVisitor::emitOneShotConstructor(const ClassDefPtr& p) string typeName = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring); bool dataMember = std::find(dataMembers.begin(), dataMembers.end(), (*q)) != dataMembers.end(); allParamDecls.push_back(typeName + ((dataMember || callBaseConstuctors) ? - (" __ice_" + (*q)->name()) : (" /*__ice_" + (*q)->name() + "*/"))); + (" iceP_" + (*q)->name()) : (" /*iceP_" + (*q)->name() + "*/"))); } H << sp << nl; @@ -3344,7 +3351,7 @@ Slice::Gen::ObjectVisitor::emitOneShotConstructor(const ClassDefPtr& p) H << ',' << nl; } string memberName = fixKwd((*q)->name()); - H << memberName << '(' << "__ice_" << (*q)->name() << ')'; + H << memberName << '(' << "iceP_" << (*q)->name() << ')'; } H.dec(); @@ -3491,7 +3498,7 @@ Slice::Gen::AsyncCallbackTemplateVisitor::generateOperation(const OperationPtr& TypePtr ret = p->returnType(); string retS = inputTypeToString(ret, p->returnIsOptional(), p->getMetaData(), _useWstring); - string retEndArg = getEndArg(ret, p->getMetaData(), "__ret"); + string retEndArg = getEndArg(ret, p->getMetaData(), "ret"); ParamDeclList outParams; vector<string> outArgs; @@ -3592,10 +3599,10 @@ Slice::Gen::AsyncCallbackTemplateVisitor::generateOperation(const OperationPtr& // // completed. // - H << sp << nl << "virtual void completed(const ::Ice::AsyncResultPtr& __result) const"; + H << sp << nl << "virtual void completed(const ::Ice::AsyncResultPtr& result) const"; H << sb; - H << nl << clScope << clName << "Prx __proxy = " << clScope << clName - << "Prx::uncheckedCast(__result->getProxy());"; + H << nl << clScope << clName << "Prx proxy = " << clScope << clName + << "Prx::uncheckedCast(result->getProxy());"; writeAllocateCode(H, outParams, p, false, _useWstring | TypeContextInParam | TypeContextAMICallPrivateEnd); H << nl << "try"; H << sb; @@ -3606,23 +3613,23 @@ Slice::Gen::AsyncCallbackTemplateVisitor::generateOperation(const OperationPtr& { H << retEndArg << " = "; } - H << "__proxy->end_" << p->name() << spar << outEndArgs << "__result" << epar << ';'; + H << "proxy->end_" << p->name() << spar << outEndArgs << "result" << epar << ';'; } else { - H << "__proxy->___end_" << p->name() << spar << outEndArgs; + H << "proxy->_iceI_end_" << p->name() << spar << outEndArgs; if(ret) { H << retEndArg; } - H << "__result" << epar << ';'; + H << "result" << epar << ';'; } writeEndCode(H, outParams, p); H << eb; H << nl << "catch(const ::Ice::Exception& ex)"; H << sb; - H << nl << "" << baseD << "::exception(__result, ex);"; + H << nl << "" << baseD << "::exception(result, ex);"; H << nl << "return;"; H << eb; H << nl << "if(_response)"; @@ -3630,12 +3637,12 @@ Slice::Gen::AsyncCallbackTemplateVisitor::generateOperation(const OperationPtr& H << nl << "(" << baseD << "::_callback.get()->*_response)" << spar; if(ret) { - H << "__ret"; + H << "ret"; } H << outArgs; if(withCookie) { - H << "CT::dynamicCast(__result->getCookie())"; + H << "CT::dynamicCast(result->getCookie())"; } H << epar << ';'; H << eb; @@ -4082,10 +4089,8 @@ Slice::Gen::AsyncVisitor::visitOperation(const OperationPtr& p) vector<string> args; vector<string> paramsInvoke; - vector<string> paramsDeclInvoke; paramsInvoke.push_back("const " + proxyName + "&"); - paramsDeclInvoke.push_back("const " + proxyName + "& __prx"); TypePtr ret = p->returnType(); string retS = inputTypeToString(ret, p->returnIsOptional(), p->getMetaData(), _useWstring); @@ -4094,8 +4099,8 @@ Slice::Gen::AsyncVisitor::visitOperation(const OperationPtr& p) { params.push_back(retS); paramsAMD.push_back(inputTypeToString(ret, p->returnIsOptional(), p->getMetaData(), _useWstring)); - paramsDecl.push_back(retS + " __ret"); - args.push_back("__ret"); + paramsDecl.push_back(retS + " ret"); + args.push_back("ret"); } ParamDeclList inParams; @@ -4119,14 +4124,11 @@ Slice::Gen::AsyncVisitor::visitOperation(const OperationPtr& p) else { paramsInvoke.push_back(typeString); - paramsDeclInvoke.push_back(typeString + ' ' + paramName); - inParams.push_back(*q); } } paramsInvoke.push_back("const ::Ice::Context&"); - paramsDeclInvoke.push_back("const ::Ice::Context& __ctx"); if(cl->hasMetaData("amd") || p->hasMetaData("amd")) { @@ -4245,8 +4247,8 @@ Slice::Gen::AsyncImplVisitor::visitOperation(const OperationPtr& p) params += retS; paramsDecl += retS; paramsDecl += ' '; - paramsDecl += "__ret"; - args += "__ret"; + paramsDecl += "ret"; + args += "ret"; } ParamDeclList outParams; @@ -4303,11 +4305,11 @@ Slice::Gen::AsyncImplVisitor::visitOperation(const OperationPtr& p) C << sb; if(ret || !outParams.empty()) { - C << nl << "::Ice::OutputStream* __os = startWriteParams();"; + C << nl << "::Ice::OutputStream* ostr = startWriteParams();"; writeMarshalCode(C, outParams, p, false, TypeContextInParam); if(p->returnsClasses(false)) { - C << nl << "__os->writePendingValues();"; + C << nl << "ostr->writePendingValues();"; } C << nl << "endWriteParams();"; } @@ -5134,11 +5136,11 @@ Slice::Gen::Cpp11DeclVisitor::visitClassDefStart(const ClassDefPtr& p) C << sp; C << nl << "const ::IceInternal::DefaultValueFactoryInit<" << fixKwd(p->scoped()) << "> "; - C << p->flattenedScope() + p->name() + "_init" << "(\"" << p->scoped() << "\");"; + C << "iceC" + p->flattenedScope() + p->name() + "_init" << "(\"" << p->scoped() << "\");"; if(p->compactId() >= 0) { - string n = p->flattenedScope() + p->name() + "_compactIdInit "; + string n = "iceC" + p->flattenedScope() + p->name() + "_compactIdInit "; C << "const ::IceInternal::CompactIdInit " << n << "(\"" << p->scoped() << "\", " << p->compactId() << ");"; } } @@ -5158,7 +5160,7 @@ Slice::Gen::Cpp11DeclVisitor::visitClassDefStart(const ClassDefPtr& p) ids.merge(other); ids.unique(); - C << nl << "const ::std::string " << p->flattenedScope() << p->name() << "_ids[" << ids.size() << "] ="; + C << nl << "const ::std::string iceC" << p->flattenedScope() << p->name() << "_ids[" << ids.size() << "] ="; C << sb; for(StringList::const_iterator r = ids.begin(); r != ids.end();) { @@ -5179,7 +5181,7 @@ Slice::Gen::Cpp11DeclVisitor::visitClassDefStart(const ClassDefPtr& p) allOpNames.sort(); allOpNames.unique(); - C << nl << "const ::std::string " << p->flattenedScope() << p->name() << "_ops[] ="; + C << nl << "const ::std::string iceC" << p->flattenedScope() << p->name() << "_ops[] ="; C << sb; for(StringList::const_iterator q = allOpNames.begin(); q != allOpNames.end();) { @@ -5205,7 +5207,7 @@ Slice::Gen::Cpp11DeclVisitor::visitExceptionStart(const ExceptionPtr& p) C << sp; C << nl << "const ::IceInternal::DefaultUserExceptionFactoryInit<" << fixKwd(p->scoped()) << "> "; - C << p->flattenedScope() + p->name() + "_init" << "(\"" << p->scoped() << "\");"; + C << "iceC" + p->flattenedScope() + p->name() + "_init" << "(\"" << p->scoped() << "\");"; return false; } @@ -5215,7 +5217,7 @@ Slice::Gen::Cpp11DeclVisitor::visitOperation(const OperationPtr& p) ClassDefPtr cl = ClassDefPtr::dynamicCast(p->container()); if(cl && !cl->isLocal()) { - string flatName = p->flattenedScope() + p->name() + "_name"; + string flatName = "iceC" + p->flattenedScope() + p->name() + "_name"; C << nl << "const ::std::string " << flatName << " = \"" << p->name() << "\";"; } } @@ -5288,7 +5290,7 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionStart(const ExceptionPtr& p) string typeName = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring | TypeContextCpp11); allTypes.push_back(typeName); - allParamDecls.push_back(typeName + " " + fixKwd("__ice_" + (*q)->name())); + allParamDecls.push_back(typeName + " iceP_" + (*q)->name()); } if(base) @@ -5296,7 +5298,7 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionStart(const ExceptionPtr& p) baseDataMembers = base->allDataMembers(); for(DataMemberList::const_iterator q = baseDataMembers.begin(); q != baseDataMembers.end(); ++q) { - baseParams.push_back(fixKwd("__ice_" + (*q)->name())); + baseParams.push_back("iceP_" + (*q)->name()); } } @@ -5321,9 +5323,9 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionStart(const ExceptionPtr& p) if(p->isLocal()) { - H << sp << nl << name << "(const char* __ice_file, int __ice_line) : "; + H << sp << nl << name << "(const char* file_, int line_) : "; H << "::Ice::LocalExceptionHelper" << "<" << templateParameters << ">"; - H << "(__ice_file, __ice_line)"; + H << "(file_, line_)"; H << sb; H << eb; } @@ -5337,7 +5339,7 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionStart(const ExceptionPtr& p) H << sp << nl << name << "("; if(p->isLocal()) { - H << "const char* __ice_file, int __ice_line"; + H << "const char* file_, int line_"; if(!allParamDecls.empty()) { H << ", "; @@ -5359,7 +5361,7 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionStart(const ExceptionPtr& p) H << nl << "::" << helperClass << "<" << templateParameters << ">" << "("; if(p->isLocal()) { - H << "__ice_file, __ice_line"; + H << "file_, line_"; if(!baseDataMembers.empty()) { H << ", "; @@ -5374,11 +5376,11 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionStart(const ExceptionPtr& p) } if(isMovable((*q)->type())) { - H << "::std::move(" << fixKwd("__ice_" + (*q)->name()) << ")"; + H << "::std::move(iceP_" << (*q)->name() << ")"; } else { - H << fixKwd("__ice_" + (*q)->name()); + H << "iceP_" << (*q)->name(); } } @@ -5391,7 +5393,7 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionStart(const ExceptionPtr& p) else if(p->isLocal()) { H << " ::Ice::LocalExceptionHelper" << "<" << templateParameters << ">"; - H << "(__ice_file, __ice_line)"; + H << "(file_, line_)"; if(!dataMembers.empty()) { H << ","; @@ -5406,11 +5408,11 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionStart(const ExceptionPtr& p) } if(isMovable((*q)->type())) { - H << nl << fixKwd((*q)->name()) << "(::std::move(" << fixKwd("__ice_" + (*q)->name()) << "))"; + H << nl << fixKwd((*q)->name()) << "(::std::move(iceP_" << (*q)->name() << "))"; } else { - H << nl << fixKwd((*q)->name()) << "(" << fixKwd("__ice_" + (*q)->name()) << ")"; + H << nl << fixKwd((*q)->name()) << "(iceP_" << (*q)->name() << ")"; } } @@ -5444,10 +5446,10 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionStart(const ExceptionPtr& p) { if(!base || (base && !base->usesClasses(false))) { - H << sp << nl << _dllMemberExport << "virtual bool __usesClasses() const override;"; + H << sp << nl << _dllMemberExport << "virtual bool _usesClasses() const override;"; C << sp << nl << "bool"; - C << nl << scoped.substr(2) << "::__usesClasses() const"; + C << nl << scoped.substr(2) << "::_usesClasses() const"; C << sb; C << nl << "return true;"; C << eb; @@ -5477,23 +5479,23 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionEnd(const ExceptionPtr& p) if(preserved && !basePreserved) { - H << sp << nl << _dllMemberExport << "virtual void __write(::Ice::OutputStream*) const override;"; - H << nl << _dllMemberExport << "virtual void __read(::Ice::InputStream*) override;"; + H << sp << nl << _dllMemberExport << "virtual void _write(::Ice::OutputStream*) const override;"; + H << nl << _dllMemberExport << "virtual void _read(::Ice::InputStream*) override;"; - H << sp << nl << "::std::shared_ptr<::Ice::SlicedData> __slicedData;"; + H << sp << nl << "::std::shared_ptr<::Ice::SlicedData> _slicedData;"; - C << sp << nl << "void" << nl << scoped.substr(2) << "::__write(::Ice::OutputStream* __os) const"; + C << sp << nl << "void" << nl << scoped.substr(2) << "::_write(::Ice::OutputStream* ostr) const"; C << sb; - C << nl << "__os->startException(__slicedData);"; - C << nl << "__writeImpl(__os);"; - C << nl << "__os->endException();"; + C << nl << "ostr->startException(_slicedData);"; + C << nl << "_writeImpl(ostr);"; + C << nl << "ostr->endException();"; C << eb; - C << sp << nl << "void" << nl << scoped.substr(2) << "::__read(::Ice::InputStream* __is)"; + C << sp << nl << "void" << nl << scoped.substr(2) << "::_read(::Ice::InputStream* istr)"; C << sb; - C << nl << "__is->startException();"; - C << nl << "__readImpl(__is);"; - C << nl << "__slicedData = __is->endException(true);"; + C << nl << "istr->startException();"; + C << nl << "_readImpl(istr);"; + C << nl << "_slicedData = istr->endException(true);"; C << eb; } } @@ -5509,7 +5511,7 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionEnd(const ExceptionPtr& p) if(!_doneStaticSymbol) { _doneStaticSymbol = true; - H << sp << nl << "static " << name << " __" << p->name() << "_init;"; + H << sp << nl << "static " << name << " _iceS_" << p->name() << "_init;"; } } @@ -5715,7 +5717,7 @@ Slice::Gen::Cpp11ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p) H << sp << nl << prx << "() = default;"; H << nl << "friend ::std::shared_ptr<" << prx << "> IceInternal::createProxy<" << prx << ">();"; H << sp; - H << nl << _dllMemberExport << "virtual ::std::shared_ptr<::Ice::ObjectPrx> __newInstance() const override;"; + H << nl << _dllMemberExport << "virtual ::std::shared_ptr<::Ice::ObjectPrx> _newInstance() const override;"; H << eb << ';'; string suffix = p->isInterface() ? "" : "Disp"; @@ -5723,7 +5725,7 @@ Slice::Gen::Cpp11ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p) C << sp; C << nl << "::std::shared_ptr<::Ice::ObjectPrx>"; - C << nl << scoped.substr(2) << "::__newInstance() const"; + C << nl << scoped.substr(2) << "::_newInstance() const"; C << sb; C << nl << "return ::IceInternal::createProxy<" << prx << ">();"; C << eb; @@ -5740,7 +5742,7 @@ void Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) { string name = p->name(); - string flatName = p->flattenedScope() + p->name() + "_name"; + string flatName = "iceC" + p->flattenedScope() + p->name() + "_name"; TypePtr ret = p->returnType(); @@ -5839,7 +5841,7 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) // Synchronous operation // H << sp << nl << deprecateSymbol << retS << ' ' << fixKwd(name) << spar << paramsDecl; - H << "const ::Ice::Context& __ctx = Ice::noExplicitContext" << epar; + H << "const ::Ice::Context& context = Ice::noExplicitContext" << epar; H << sb; H << nl; if(futureOutParams.size() == 1) @@ -5855,27 +5857,27 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) } else if(futureOutParams.size() > 1) { - H << "auto __result = "; + H << "auto result = "; } - H << "makePromiseOutgoing<" << futureT << ">"; + H << "_makePromiseOutgoing<" << futureT << ">"; - H << spar << "true, this" << string("&" + scoped + "__" + name); + H << spar << "true, this" << string("&" + scoped + "_iceI_" + name); for(ParamDeclList::const_iterator q = inParams.begin(); q != inParams.end(); ++q) { H << fixKwd(paramPrefix + (*q)->name()); } - H << "__ctx" << epar << ".get();"; + H << "context" << epar << ".get();"; if(futureOutParams.size() > 1) { for(ParamDeclList::const_iterator q = outParams.begin(); q != outParams.end(); ++q) { H << nl << paramPrefix << (*q)->name() << " = "; - H << condMove(isMovable((*q)->type()), "__result." + fixKwd((*q)->name())) + ";"; + H << condMove(isMovable((*q)->type()), "result." + fixKwd((*q)->name())) + ";"; } if(ret) { - H << nl << "return " + condMove(isMovable(ret), "__result." + returnValueS) + ";"; + H << nl << "return " + condMove(isMovable(ret), "result." + returnValueS) + ";"; } } H << eb; @@ -5886,20 +5888,20 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) H << sp; H << nl << "template<template<typename> class P = ::std::promise>"; H << nl << deprecateSymbol << "auto " << name << "Async" << spar << inParamsDecl; - H << "const ::Ice::Context& __ctx = Ice::noExplicitContext" << epar; + H << "const ::Ice::Context& context = Ice::noExplicitContext" << epar; H.inc(); H << nl << "-> decltype(::std::declval<P<" << futureT << ">>().get_future())"; H.dec(); H << sb; - H << nl << "return makePromiseOutgoing<" << futureT << ", P>" << spar; + H << nl << "return _makePromiseOutgoing<" << futureT << ", P>" << spar; - H << "false, this" << string("&" + scoped + "__" + name); + H << "false, this" << string("&" + scoped + "_iceI_" + name); for(ParamDeclList::const_iterator q = inParams.begin(); q != inParams.end(); ++q) { H << fixKwd(paramPrefix + (*q)->name()); } - H << "__ctx" << epar << ";"; + H << "context" << epar << ";"; H << eb; @@ -5937,13 +5939,13 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) } H << "::std::function<void" << spar << lambdaOutParams << epar << ">" - + condString(!lambdaCustomOut, " __response") + ","; + + condString(!lambdaCustomOut, " response") + ","; H << nl << "::std::function<void(::std::exception_ptr)>" - + condString(!lambdaCustomOut, " __ex") + " = nullptr,"; + + condString(!lambdaCustomOut, " ex") + " = nullptr,"; H << nl << "::std::function<void(bool)>" - + condString(!lambdaCustomOut," __sent") + " = nullptr,"; + + condString(!lambdaCustomOut," sent") + " = nullptr,"; H << nl << "const ::Ice::Context&" - + condString(!lambdaCustomOut, "__ctx") + " = Ice::noExplicitContext)" + condString(lambdaCustomOut, ";"); + + condString(!lambdaCustomOut, " context") + " = Ice::noExplicitContext)" + condString(lambdaCustomOut, ";"); H.restoreIndent(); if(lambdaCustomOut) @@ -5964,36 +5966,36 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) } C << nl; } - C << "::std::function<void " << spar << lambdaOutParams << epar << "> __response,"; - C << nl << "::std::function<void(::std::exception_ptr)> __ex,"; - C << nl << "::std::function<void(bool)> __sent,"; - C << nl << "const ::Ice::Context& __ctx)"; + C << "::std::function<void " << spar << lambdaOutParams << epar << "> response,"; + C << nl << "::std::function<void(::std::exception_ptr)> ex,"; + C << nl << "::std::function<void(bool)> sent,"; + C << nl << "const ::Ice::Context& context)"; C.restoreIndent(); C << sb; if(p->returnsData()) { - C << nl << "__checkTwowayOnly(" << flatName << ");"; + C << nl << "_checkTwowayOnly(" << flatName << ");"; } - C << nl << "::std::function<void(::Ice::InputStream*)> __read;"; - C << nl << "if(__response)"; + C << nl << "::std::function<void(::Ice::InputStream*)> read;"; + C << nl << "if(response)"; C << sb; - C << nl << "__read = [__response](::Ice::InputStream* __is)"; + C << nl << "read = [response](::Ice::InputStream* istr)"; C << sb; - C << nl << "__is->startEncapsulation();"; + C << nl << "istr->startEncapsulation();"; writeAllocateCode(C, outParams, p, true, _useWstring | TypeContextInParam | TypeContextCpp11); writeUnmarshalCode(C, outParams, p, true, _useWstring | TypeContextInParam | TypeContextCpp11); if(p->returnsClasses(false)) { - C << nl << "__is->readPendingValues();"; + C << nl << "istr->readPendingValues();"; } - C << nl << "__is->endEncapsulation();"; + C << nl << "istr->endEncapsulation();"; C << nl << "try" << sb; - C << nl << "__response" << spar; + C << nl << "response" << spar; if(ret) { - C << "__ret"; + C << "ret"; } for(ParamDeclList::const_iterator q = outParams.begin(); q != outParams.end(); ++q) { @@ -6007,12 +6009,12 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) C << eb; C << eb << ";"; C << eb; - C << nl << "auto __outAsync = ::std::make_shared<::IceInternal::CustomLambdaOutgoing>("; - C << "shared_from_this(), __read, __ex, __sent);"; + C << nl << "auto outAsync = ::std::make_shared<::IceInternal::CustomLambdaOutgoing>("; + C << "shared_from_this(), read, ex, sent);"; C << sp; - C << nl << "__outAsync->invoke(" << flatName << ", "; - C << operationModeToString(p->sendMode(), true) << ", " << opFormatTypeToString(p) << ", __ctx, "; + C << nl << "outAsync->invoke(" << flatName << ", "; + C << operationModeToString(p->sendMode(), true) << ", " << opFormatTypeToString(p) << ", context, "; C.inc(); C << nl; @@ -6022,7 +6024,7 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) C.dec(); C << ");"; - C << nl << "return [__outAsync]() { __outAsync->cancel(); };"; + C << nl << "return [outAsync]() { outAsync->cancel(); };"; C << eb; } else @@ -6034,9 +6036,9 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) H << sb; if(futureOutParams.size() > 1) { - H << nl << "auto __responseCb = [__response](" << futureT << "&& result)"; + H << nl << "auto responseCb = [response](" << futureT << "&& result)"; H << sb; - H << nl << "__response" << spar; + H << nl << "response" << spar; if(ret) { @@ -6049,15 +6051,15 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) H << epar << ";" << eb << ";"; } - H << nl << "return makeLambdaOutgoing<" << futureT << ">" << spar; + H << nl << "return _makeLamdaOutgoing<" << futureT << ">" << spar; - H << (futureOutParams.size() > 1 ? "__responseCb" : "__response") << "__ex" << "__sent" << "this"; - H << string("&" + scoped + "__" + name); + H << (futureOutParams.size() > 1 ? "responseCb" : "response") << "ex" << "sent" << "this"; + H << string("&" + scoped + "_iceI_" + name); for(ParamDeclList::const_iterator q = inParams.begin(); q != inParams.end(); ++q) { H << fixKwd(paramPrefix + (*q)->name()); } - H << "__ctx" << epar << ";"; + H << "context" << epar << ";"; H << eb; } @@ -6066,24 +6068,24 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) // H << sp; - H << nl << _dllMemberExport << "void __" << name << spar; + H << nl << _dllMemberExport << "void _iceI_" << name << spar; H << "const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<" + futureT + ">>&"; H << inParamsS; H << "const ::Ice::Context&"; H << epar << ";"; C << sp; - C << nl << "void" << nl << scoped << "__" << name << spar; - C << "const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<" + futureT + ">>& __outAsync"; - C << inParamsDecl << "const ::Ice::Context& __ctx"; + C << nl << "void" << nl << scoped << "_iceI_" << name << spar; + C << "const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<" + futureT + ">>& outAsync"; + C << inParamsDecl << "const ::Ice::Context& context"; C << epar; C << sb; if(p->returnsData()) { - C << nl << "__checkTwowayOnly(" << flatName << ");"; + C << nl << "_checkTwowayOnly(" << flatName << ");"; } - C << nl << "__outAsync->invoke(" << flatName << ", "; - C << operationModeToString(p->sendMode(), true) << ", " << opFormatTypeToString(p) << ", __ctx, "; + C << nl << "outAsync->invoke(" << flatName << ", "; + C << operationModeToString(p->sendMode(), true) << ", " << opFormatTypeToString(p) << ", context, "; C.inc(); C << nl; @@ -6098,14 +6100,14 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) // only one, we rely on the default read method from LambdaOutgoing // except if the unique ret/out is optional or is an array/range. // - C << "," << nl << "[](::Ice::InputStream* __is)"; + C << "," << nl << "[](::Ice::InputStream* istr)"; C << sb; C << nl << futureT << " v;"; - writeUnmarshalCode(C, outParams, p, false, _useWstring | TypeContextCpp11, returnValueS, "v"); + writeUnmarshalCode(C, outParams, p, false, _useWstring | TypeContextCpp11, "", returnValueS, "v"); if(p->returnsClasses(false)) { - C << nl << "__is->readPendingValues();"; + C << nl << "istr->readPendingValues();"; } C << nl << "return v;"; C << eb; @@ -6117,7 +6119,7 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) // a read method, we can't rely on the default read method which wouldn't // known which tag to use. // - C << "," << nl << "[](::Ice::InputStream* __is)"; + C << "," << nl << "[](::Ice::InputStream* istr)"; C << sb; writeAllocateCode(C, outParams, p, true, _useWstring | TypeContextCpp11); @@ -6125,12 +6127,12 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p) if(p->returnsClasses(false)) { - C << nl << "__is->readPendingValues();"; + C << nl << "istr->readPendingValues();"; } if(ret) { - C << nl << "return __ret;"; + C << nl << "return ret;"; } else { @@ -6356,7 +6358,7 @@ Slice::Gen::Cpp11LocalObjectVisitor::visitClassDefStart(const ClassDefPtr& p) { string typeName = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring); allTypes.push_back(typeName); - allParamDecls.push_back(typeName + " __ice_" + (*q)->name()); + allParamDecls.push_back(typeName + " iceP_" + (*q)->name()); } if(!p->isInterface()) @@ -6569,7 +6571,7 @@ Slice::Gen::Cpp11LocalObjectVisitor::visitOperation(const OperationPtr& p) H.dec(); H << sb; H << nl << "using Promise = P<bool>;"; - H << nl << "auto __promise = ::std::make_shared<Promise>();"; + H << nl << "auto promise = ::std::make_shared<Promise>();"; H << nl << name << "Async("; H.useCurrentPosAsIndent(); @@ -6581,17 +6583,17 @@ Slice::Gen::Cpp11LocalObjectVisitor::visitOperation(const OperationPtr& p) { H << nl; } - H << "[__promise](::std::exception_ptr __ex)"; + H << "[promise](::std::exception_ptr ex)"; H << sb; - H << nl << "__promise->set_exception(::std::move(__ex));"; + H << nl << "promise->set_exception(::std::move(ex));"; H << eb << ","; - H << nl << "[__promise](bool __b)"; + H << nl << "[promise](bool b)"; H << sb; - H << nl << "__promise->set_value(__b);"; + H << nl << "promise->set_value(b);"; H << eb << ");"; H.restoreIndent(); - H << nl << "return __promise->get_future();"; + H << nl << "return promise->get_future();"; H << eb; } } @@ -6707,7 +6709,7 @@ Slice::Gen::Cpp11InterfaceVisitor::visitClassDefStart(const ClassDefPtr& p) H << nl << "virtual ::std::string ice_id(const ::Ice::Current& = ::Ice::noExplicitCurrent) const override;"; H << sp << nl << "static const ::std::string& ice_staticId();"; - string flatName = p->flattenedScope() + p->name() + "_ids"; + string flatName = "iceC" + p->flattenedScope() + p->name() + "_ids"; C << sp; C << nl << "bool" << nl << scoped.substr(2) << "::ice_isA(::std::string _s, const ::Ice::Current&) const"; @@ -6766,21 +6768,21 @@ Slice::Gen::Cpp11InterfaceVisitor::visitClassDefEnd(const ClassDefPtr& p) allOpNames.sort(); allOpNames.unique(); - string flatName = p->flattenedScope() + p->name() + "_ops"; + string flatName = "iceC" + p->flattenedScope() + p->name() + "_ops"; H << sp; - H << nl << "virtual bool __dispatch(::IceInternal::Incoming&, const ::Ice::Current&) override;"; + H << nl << "virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&) override;"; C << sp; C << nl << "bool"; - C << nl << scoped.substr(2) << "::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& c)"; + C << nl << scoped.substr(2) << "::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)"; C << sb; - C << nl << "::std::pair< const ::std::string*, const ::std::string*> r = " - << "::std::equal_range(" << flatName << ", " << flatName << " + " << allOpNames.size() << ", c.operation);"; + C << nl << "::std::pair<const ::std::string*, const ::std::string*> r = " + << "::std::equal_range(" << flatName << ", " << flatName << " + " << allOpNames.size() << ", current.operation);"; C << nl << "if(r.first == r.second)"; C << sb; - C << nl << "throw ::Ice::OperationNotExistException(__FILE__, __LINE__, c.id, c.facet, c.operation);"; + C << nl << "throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);"; C << eb; C << sp; C << nl << "switch(r.first - " << flatName << ')'; @@ -6790,13 +6792,13 @@ Slice::Gen::Cpp11InterfaceVisitor::visitClassDefEnd(const ClassDefPtr& p) { C << nl << "case " << i++ << ':'; C << sb; - C << nl << "return ___" << *q << "(in, c);"; + C << nl << "return _iceD_" << *q << "(in, current);"; C << eb; } C << nl << "default:"; C << sb; C << nl << "assert(false);"; - C << nl << "throw ::Ice::OperationNotExistException(__FILE__, __LINE__, c.id, c.facet, c.operation);"; + C << nl << "throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);"; C << eb; C << eb; C << eb; @@ -6851,7 +6853,7 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p) { string typeS = inputTypeToString(ret, p->returnIsOptional(), p->getMetaData(), _useWstring | TypeContextCpp11); responseParams.push_back(typeS); - responseParamsDecl.push_back(typeS + " __ret"); + responseParamsDecl.push_back(typeS + " ret"); } string retS; @@ -6904,18 +6906,18 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p) { string resultName = resultStructName(name, "", true); params.push_back("::std::function<void(const " + resultName + "&)>"); - args.push_back("inS->response<" + resultName + ">()"); + args.push_back("inA->response<" + resultName + ">()"); } else { params.push_back("::std::function<void(" + joinString(responseParams, ",") + ")>"); - args.push_back(ret || !outParams.empty() ? "__responseCB" : "inS->response()"); + args.push_back(ret || !outParams.empty() ? "responseCB" : "inA->response()"); } params.push_back("::std::function<void(::std::exception_ptr)>"); - args.push_back("inS->exception()"); + args.push_back("inA->exception()"); } params.push_back("const ::Ice::Current& = ::Ice::noExplicitCurrent"); - args.push_back("__current"); + args.push_back("current"); if(cl->isInterface()) { @@ -6935,18 +6937,18 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p) H << eb << ';'; C << sp << nl << scope.substr(2) << resultName << "::" << resultName; - C << spar << responseParamsDecl << "const ::Ice::Current& __current" << epar << ":"; + C << spar << responseParamsDecl << "const ::Ice::Current& current" << epar << ":"; C.inc(); - C << nl << "MarshaledResult(__current)"; + C << nl << "MarshaledResult(current)"; C.dec(); C << sb; - C << nl << "__os->startEncapsulation(__current.encoding, " << opFormatTypeToString(p) << ");"; - writeMarshalCode(C, outParams, p, true, TypeContextCpp11); + C << nl << "ostr->startEncapsulation(current.encoding, " << opFormatTypeToString(p) << ");"; + writeMarshalCode(C, outParams, p, true, TypeContextCpp11, "ostr"); if(p->returnsClasses(false)) { - C << nl << "__os->writePendingValues();"; + C << nl << "ostr->writePendingValues();"; } - C << nl << "__os->endEncapsulation();"; + C << nl << "ostr->endEncapsulation();"; C << eb; } @@ -6957,33 +6959,33 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p) H << sp; H << nl << deprecateSymbol << "virtual " << retS << ' ' << opName << spar << params << epar << isConst << " = 0;"; - H << nl << "bool ___" << name << "(::IceInternal::Incoming&, const ::Ice::Current&)" << isConst << ';'; + H << nl << "bool _iceD_" << name << "(::IceInternal::Incoming&, const ::Ice::Current&)" << isConst << ';'; C << sp; C << nl << "bool"; C << nl << scope.substr(2); - C << "___" << name << "(::IceInternal::Incoming& __inS" << ", const ::Ice::Current& __current)" << isConst; + C << "_iceD_" << name << "(::IceInternal::Incoming& inS" << ", const ::Ice::Current& current)" << isConst; C << sb; - C << nl << "__checkMode(" << operationModeToString(p->mode(), true) << ", __current.mode);"; + C << nl << "_iceCheckMode(" << operationModeToString(p->mode(), true) << ", current.mode);"; if(!inParams.empty()) { - C << nl << "auto __is = __inS.startReadParams();"; + C << nl << "auto istr = inS.startReadParams();"; writeAllocateCode(C, inParams, 0, true, _useWstring | TypeContextInParam | TypeContextCpp11); writeUnmarshalCode(C, inParams, 0, true, _useWstring | TypeContextInParam | TypeContextCpp11); if(p->sendsClasses(false)) { - C << nl << "__is->readPendingValues();"; + C << nl << "istr->readPendingValues();"; } - C << nl << "__inS.endReadParams();"; + C << nl << "inS.endReadParams();"; } else { - C << nl << "__inS.readEmptyParams();"; + C << nl << "inS.readEmptyParams();"; } if(p->format() != DefaultFormat) { - C << nl << "__inS.setFormat(" << opFormatTypeToString(p) << ");"; + C << nl << "inS.setFormat(" << opFormatTypeToString(p) << ");"; } if(!amd) @@ -6991,11 +6993,11 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p) writeAllocateCode(C, outParams, 0, true, _useWstring | TypeContextCpp11); if(p->hasMarshaledResult()) { - C << nl << "__inS.setMarshaledResult("; + C << nl << "inS.setMarshaledResult("; } else if(ret) { - C << nl << retS << " __ret = "; + C << nl << retS << " ret = "; } else { @@ -7012,36 +7014,36 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p) C << ";"; if(ret || !outParams.empty()) { - C << nl << "auto __os = __inS.startWriteParams();"; + C << nl << "auto ostr = inS.startWriteParams();"; writeMarshalCode(C, outParams, p, true, TypeContextCpp11); if(p->returnsClasses(false)) { - C << nl << "__os->writePendingValues();"; + C << nl << "ostr->writePendingValues();"; } - C << nl << "__inS.endWriteParams();"; + C << nl << "inS.endWriteParams();"; } else { - C << nl << "__inS.writeEmptyParams();"; + C << nl << "inS.writeEmptyParams();"; } } C << nl << "return false;"; } else { - C << nl << "auto inS = ::IceInternal::IncomingAsync::create(__inS);"; + C << nl << "auto inA = ::IceInternal::IncomingAsync::create(inS);"; if(!p->hasMarshaledResult() && (ret || !outParams.empty())) { - C << nl << "auto __responseCB = [inS]" << spar << responseParamsDecl << epar; + C << nl << "auto responseCB = [inA]" << spar << responseParamsDecl << epar; C << sb; - C << nl << "auto __os = inS->startWriteParams();"; + C << nl << "auto ostr = inA->startWriteParams();"; writeMarshalCode(C, outParams, p, true, TypeContextCpp11); if(p->returnsClasses(false)) { - C << nl << "__os->writePendingValues();"; + C << nl << "ostr->writePendingValues();"; } - C << nl << "inS->endWriteParams();"; - C << nl << "inS->completed();"; + C << nl << "inA->endWriteParams();"; + C << nl << "inA->completed();"; C << eb << ';'; } C << nl << opName << spar << args << epar << ';'; @@ -7159,23 +7161,23 @@ Slice::Gen::Cpp11ValueVisitor::visitClassDefEnd(const ClassDefPtr& p) if(preserved && !basePreserved) { H << sp; - H << nl << "virtual void __write(::Ice::OutputStream*) const override;"; - H << nl << "virtual void __read(::Ice::InputStream*) override;"; + H << nl << "virtual void _iceWrite(::Ice::OutputStream*) const override;"; + H << nl << "virtual void _iceRead(::Ice::InputStream*) override;"; C << sp; - C << nl << "void" << nl << scoped.substr(2) << "::__write(::Ice::OutputStream* __os) const"; + C << nl << "void" << nl << scoped.substr(2) << "::_iceWrite(::Ice::OutputStream* ostr) const"; C << sb; - C << nl << "__os->startValue(__slicedData);"; - C << nl << "__writeImpl(__os);"; - C << nl << "__os->endValue();"; + C << nl << "ostr->startValue(_iceSlicedData);"; + C << nl << "_iceWriteImpl(ostr);"; + C << nl << "ostr->endValue();"; C << eb; C << sp; - C << nl << "void" << nl << scoped.substr(2) << "::__read(::Ice::InputStream* __is)"; + C << nl << "void" << nl << scoped.substr(2) << "::_iceRead(::Ice::InputStream* istr)"; C << sb; - C << nl << "__is->startValue();"; - C << nl << "__readImpl(__is);"; - C << nl << "__slicedData = __is->endValue(true);"; + C << nl << "istr->startValue();"; + C << nl << "_iceReadImpl(istr);"; + C << nl << "_iceSlicedData = istr->endValue(true);"; C << eb; } @@ -7242,7 +7244,7 @@ Slice::Gen::Cpp11ValueVisitor::visitClassDefEnd(const ClassDefPtr& p) H.inc(); inProtected = true; } - H << sp << nl << "::std::shared_ptr<::Ice::SlicedData> __slicedData;"; + H << sp << nl << "::std::shared_ptr<::Ice::SlicedData> _iceSlicedData;"; } if(generateFriend) @@ -7272,7 +7274,7 @@ Slice::Gen::Cpp11ValueVisitor::visitClassDefEnd(const ClassDefPtr& p) // all of the globals in a compilation unit. // _doneStaticSymbol = true; - H << sp << nl << "static " << fixKwd(p->name()) << " _" << p->name() << "_init;"; + H << sp << nl << "static " << fixKwd(p->name()) << " _iceS_" << p->name() << "_init;"; } _useWstring = resetUseWstring(_useWstringHist); @@ -7314,11 +7316,11 @@ Slice::Gen::Cpp11ObjectVisitor::emitVirtualBaseInitializers(const ClassDefPtr& d } if(isMovable((*q)->type())) { - upcall += "::std::move(__ice_" + (*q)->name() + ")"; + upcall += "::std::move(iceP_" + (*q)->name() + ")"; } else { - upcall += "__ice_" + (*q)->name(); + upcall += "iceP_" + (*q)->name(); } } upcall += ")"; @@ -7349,7 +7351,7 @@ Slice::Gen::Cpp11ObjectVisitor::emitOneShotConstructor(const ClassDefPtr& p) { string typeName = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring | TypeContextCpp11); - allParamDecls.push_back(typeName + " __ice_" + (*q)->name()); + allParamDecls.push_back(typeName + " iceP_" + (*q)->name()); } H << sp << nl; @@ -7387,11 +7389,11 @@ Slice::Gen::Cpp11ObjectVisitor::emitOneShotConstructor(const ClassDefPtr& p) string memberName = fixKwd((*q)->name()); if(isMovable((*q)->type())) { - H << memberName << "(::std::move(" << "__ice_" << (*q)->name() << "))"; + H << memberName << "(::std::move(iceP_" << (*q)->name() << "))"; } else { - H << memberName << '(' << "__ice_" << (*q)->name() << ')'; + H << memberName << "(iceP_" << (*q)->name() << ')'; } } @@ -7463,7 +7465,7 @@ Slice::Gen::Cpp11StreamVisitor::visitStructStart(const StructPtr& p) string scoped = fixKwd(p->scoped()); H << nl << "template<>"; - H << nl << "struct StreamableTraits< " << scoped << ">"; + H << nl << "struct StreamableTraits<" << scoped << ">"; H << sb; H << nl << "static const StreamHelperCategory helper = StreamHelperCategoryStruct;"; H << nl << "static const int minWireSize = " << p->minWireSize() << ";"; @@ -7756,7 +7758,7 @@ Slice::Gen::Cpp11ImplVisitor::visitClassDefStart(const ClassDefPtr& p) string typeS = inputTypeToString(ret, op->returnIsOptional(), op->getMetaData(), _useWstring | TypeContextCpp11); responseParams = typeS; - responseParamsDecl = typeS + " __ret"; + responseParamsDecl = typeS + " ret"; if(!outParams.empty()) { responseParams += ", "; diff --git a/cpp/test/Ice/gc/Client.cpp b/cpp/test/Ice/gc/Client.cpp index 4298d102621..d433146ecec 100644 --- a/cpp/test/Ice/gc/Client.cpp +++ b/cpp/test/Ice/gc/Client.cpp @@ -139,7 +139,7 @@ public: test(obj->__hasFlag(IceInternal::GCObject::CycleMember) && obj->__hasFlag(IceInternal::GCObject::Collectable)); obj->__setFlag(IceInternal::GCObject::Visiting); - obj->__gcVisitMembers(*this); + obj->_iceGcVisitMembers(*this); obj->__clearFlag(IceInternal::GCObject::Visiting); return false; } diff --git a/cpp/test/Ice/hash/Client.cpp b/cpp/test/Ice/hash/Client.cpp index dd1cc6ee4d8..fad164cee81 100644 --- a/cpp/test/Ice/hash/Client.cpp +++ b/cpp/test/Ice/hash/Client.cpp @@ -53,11 +53,11 @@ int main(int argc, char** argv) Ice::ObjectPrxPtr obj = communicator->stringToProxy(os.str()); Ice::EndpointSeq endpoints = obj->ice_getEndpoints(); - if(!seenProxy.insert(make_pair(obj->__hash(), obj)).second) + if(!seenProxy.insert(make_pair(obj->_hash(), obj)).second) { ++proxyCollisions; } - test(obj->__hash() == obj->__hash()); + test(obj->_hash() == obj->_hash()); } test(proxyCollisions < maxCollisions); @@ -76,27 +76,27 @@ int main(int argc, char** argv) Ice::ObjectPrxPtr prx10 = communicator->stringToProxy("Glacier2/router:ssl -h zeroc.com -p 10011 -t 10000"); map<string, int> proxyMap; - proxyMap["prx1"] = prx1->__hash(); - proxyMap["prx2"] = prx2->__hash(); - proxyMap["prx3"] = prx3->__hash(); - proxyMap["prx4"] = prx4->__hash(); - proxyMap["prx5"] = prx5->__hash(); - proxyMap["prx6"] = prx6->__hash(); - proxyMap["prx7"] = prx7->__hash(); - proxyMap["prx8"] = prx8->__hash(); - proxyMap["prx9"] = prx9->__hash(); - proxyMap["prx10"] = prx10->__hash(); + proxyMap["prx1"] = prx1->_hash(); + proxyMap["prx2"] = prx2->_hash(); + proxyMap["prx3"] = prx3->_hash(); + proxyMap["prx4"] = prx4->_hash(); + proxyMap["prx5"] = prx5->_hash(); + proxyMap["prx6"] = prx6->_hash(); + proxyMap["prx7"] = prx7->_hash(); + proxyMap["prx8"] = prx8->_hash(); + proxyMap["prx9"] = prx9->_hash(); + proxyMap["prx10"] = prx10->_hash(); - test( communicator->stringToProxy("Glacier2/router:tcp -p 10010")->__hash() == proxyMap["prx1"]); - test( communicator->stringToProxy("Glacier2/router:ssl -p 10011")->__hash() == proxyMap["prx2"]); - test( communicator->stringToProxy("Glacier2/router:udp -p 10012")->__hash() == proxyMap["prx3"]); - test( communicator->stringToProxy("Glacier2/router:tcp -h zeroc.com -p 10010")->__hash() == proxyMap["prx4"]); - test( communicator->stringToProxy("Glacier2/router:ssl -h zeroc.com -p 10011")->__hash() == proxyMap["prx5"]); - test( communicator->stringToProxy("Glacier2/router:udp -h zeroc.com -p 10012")->__hash() == proxyMap["prx6"]); - test( communicator->stringToProxy("Glacier2/router:tcp -p 10010 -t 10000")->__hash() == proxyMap["prx7"]); - test( communicator->stringToProxy("Glacier2/router:ssl -p 10011 -t 10000")->__hash() == proxyMap["prx8"]); - test( communicator->stringToProxy("Glacier2/router:tcp -h zeroc.com -p 10010 -t 10000")->__hash() == proxyMap["prx9"]); - test( communicator->stringToProxy("Glacier2/router:ssl -h zeroc.com -p 10011 -t 10000")->__hash() == proxyMap["prx10"]); + test( communicator->stringToProxy("Glacier2/router:tcp -p 10010")->_hash() == proxyMap["prx1"]); + test( communicator->stringToProxy("Glacier2/router:ssl -p 10011")->_hash() == proxyMap["prx2"]); + test( communicator->stringToProxy("Glacier2/router:udp -p 10012")->_hash() == proxyMap["prx3"]); + test( communicator->stringToProxy("Glacier2/router:tcp -h zeroc.com -p 10010")->_hash() == proxyMap["prx4"]); + test( communicator->stringToProxy("Glacier2/router:ssl -h zeroc.com -p 10011")->_hash() == proxyMap["prx5"]); + test( communicator->stringToProxy("Glacier2/router:udp -h zeroc.com -p 10012")->_hash() == proxyMap["prx6"]); + test( communicator->stringToProxy("Glacier2/router:tcp -p 10010 -t 10000")->_hash() == proxyMap["prx7"]); + test( communicator->stringToProxy("Glacier2/router:ssl -p 10011 -t 10000")->_hash() == proxyMap["prx8"]); + test( communicator->stringToProxy("Glacier2/router:tcp -h zeroc.com -p 10010 -t 10000")->_hash() == proxyMap["prx9"]); + test( communicator->stringToProxy("Glacier2/router:ssl -h zeroc.com -p 10011 -t 10000")->_hash() == proxyMap["prx10"]); cerr << "ok" << endl; diff --git a/cpp/test/Ice/optional/AllTests.cpp b/cpp/test/Ice/optional/AllTests.cpp index 6aa46b6d691..996138a116e 100644 --- a/cpp/test/Ice/optional/AllTests.cpp +++ b/cpp/test/Ice/optional/AllTests.cpp @@ -50,9 +50,9 @@ class TestObjectReader : public Ice::Object #endif { public: - virtual void __write(Ice::OutputStream*) const { } + virtual void _iceWrite(Ice::OutputStream*) const { } - virtual void __read(Ice::InputStream* in) + virtual void _iceRead(Ice::InputStream* in) { in->startValue(); in->startSlice(); @@ -80,9 +80,9 @@ class BObjectReader : public Ice::Object #endif { public: - virtual void __write(Ice::OutputStream*) const { } + virtual void _iceWrite(Ice::OutputStream*) const { } - virtual void __read(Ice::InputStream* in) + virtual void _iceRead(Ice::InputStream* in) { in->startValue(); // ::Test::B @@ -117,9 +117,9 @@ class CObjectReader : public Ice::Object #endif { public: - virtual void __write(Ice::OutputStream*) const { } + virtual void _iceWrite(Ice::OutputStream*) const { } - virtual void __read(Ice::InputStream* in) + virtual void _iceRead(Ice::InputStream* in) { in->startValue(); // ::Test::C @@ -158,7 +158,7 @@ class DObjectWriter : public Ice::Object { public: - virtual void __write(Ice::OutputStream* out) const + virtual void _iceWrite(Ice::OutputStream* out) const { out->startValue(0); // ::Test::D @@ -188,7 +188,7 @@ public: out->endValue(); } - virtual void __read(Ice::InputStream*) { } + virtual void _iceRead(Ice::InputStream*) { } #ifdef ICE_CPP11_MAPPING @@ -211,9 +211,9 @@ class DObjectReader : public Ice::Object #endif { public: - virtual void __write(Ice::OutputStream*) const { } + virtual void _iceWrite(Ice::OutputStream*) const { } - virtual void __read(Ice::InputStream* in) + virtual void _iceRead(Ice::InputStream* in) { in->startValue(); // ::Test::D @@ -268,9 +268,9 @@ class FObjectReader : public Ice::Object #endif { public: - virtual void __write(Ice::OutputStream*) const { } + virtual void _iceWrite(Ice::OutputStream*) const { } - virtual void __read(Ice::InputStream* in) + virtual void _iceRead(Ice::InputStream* in) { _f = ICE_MAKE_SHARED(F); in->startValue(); diff --git a/cpp/test/Ice/stream/Client.cpp b/cpp/test/Ice/stream/Client.cpp index 31ab757aa7f..eb3fb613280 100644 --- a/cpp/test/Ice/stream/Client.cpp +++ b/cpp/test/Ice/stream/Client.cpp @@ -32,13 +32,13 @@ public: called = false; } - virtual void __write(Ice::OutputStream* out) const + virtual void _iceWrite(Ice::OutputStream* out) const { - obj->__write(out); + obj->_iceWrite(out); const_cast<TestObjectWriter*>(this)->called = true; } - virtual void __read(Ice::InputStream*) + virtual void _iceRead(Ice::InputStream*) { assert(false); } @@ -61,15 +61,15 @@ public: called = false; } - virtual void __write(Ice::OutputStream*) const + virtual void _iceWrite(Ice::OutputStream*) const { assert(false); } - virtual void __read(Ice::InputStream* in) + virtual void _iceRead(Ice::InputStream* in) { obj = ICE_MAKE_SHARED(MyClass); - obj->__read(in); + obj->_iceRead(in); called = true; } @@ -78,29 +78,29 @@ public: }; ICE_DEFINE_PTR(TestObjectReaderPtr, TestObjectReader); -// Required for ValueHelper<>'s __readImpl and __writeIpml +// Required for ValueHelper<>'s _iceReadImpl and _iceWriteIpml #ifdef ICE_CPP11_MAPPING namespace Ice { template<class S> struct StreamWriter<TestObjectWriter, S> { - static void write(S* __os, const TestObjectWriter&) { assert(false); } + static void write(S* ostr, const TestObjectWriter&) { assert(false); } }; template<class S> struct StreamReader<TestObjectWriter, S> { - static void read(S* __is, TestObjectWriter&) { assert(false); } + static void read(S* istr, TestObjectWriter&) { assert(false); } }; template<class S> struct StreamWriter<TestObjectReader, S> { - static void write(S* __os, const TestObjectReader&) { assert(false); } + static void write(S* ostr, const TestObjectReader&) { assert(false); } }; template<class S> struct StreamReader<TestObjectReader, S> { - static void read(S* __is, TestObjectReader&) { assert(false); } + static void read(S* istr, TestObjectReader&) { assert(false); } }; } #endif diff --git a/objective-c/src/Ice/Object.mm b/objective-c/src/Ice/Object.mm index 48f4788a516..3344fd709b2 100644 --- a/objective-c/src/Ice/Object.mm +++ b/objective-c/src/Ice/Object.mm @@ -709,7 +709,7 @@ static NSString* ICEObject_all__[4] = NSException* nsex = nil; try { - object__->__write([(ICEOutputStream*)os os]); + object__->_iceWrite([(ICEOutputStream*)os os]); } catch(const std::exception& ex) { @@ -722,7 +722,7 @@ static NSString* ICEObject_all__[4] = NSException* nsex = nil; try { - object__->__read([(ICEInputStream*)is is]); + object__->_iceRead([(ICEInputStream*)is is]); } catch(const std::exception& ex) { diff --git a/objective-c/src/Ice/ObjectAdapterI.mm b/objective-c/src/Ice/ObjectAdapterI.mm index 53c0f8ebad4..af28d9d24f1 100644 --- a/objective-c/src/Ice/ObjectAdapterI.mm +++ b/objective-c/src/Ice/ObjectAdapterI.mm @@ -102,7 +102,7 @@ public: } void - __write(Ice::OutputStream* s) const + _write(Ice::OutputStream* s) const { ICEOutputStream* os = [[ICEOutputStream alloc] initWithCxxStream:s]; [_ex write__:os]; @@ -110,13 +110,13 @@ public: } void - __read(Ice::InputStream*) + _read(Ice::InputStream*) { assert(false); } bool - __usesClasses() const + _usesClasses() const { return [_ex usesClasses__]; } @@ -141,8 +141,8 @@ public: protected: - virtual void __writeImpl(Ice::OutputStream*) const {} - virtual void __readImpl(Ice::InputStream*) {} + virtual void _writeImpl(Ice::OutputStream*) const {} + virtual void _readImpl(Ice::InputStream*) {} private: diff --git a/objective-c/src/Ice/Proxy.mm b/objective-c/src/Ice/Proxy.mm index 4c44532c3d8..9e78224b7eb 100644 --- a/objective-c/src/Ice/Proxy.mm +++ b/objective-c/src/Ice/Proxy.mm @@ -828,7 +828,7 @@ BOOL _returnsData; try { std::pair<const Ice::Byte*, const Ice::Byte*> outParams; - BOOL ok = OBJECTPRX->___end_ice_invoke(outParams, [result asyncResult__]); + BOOL ok = OBJECTPRX->_iceI_end_ice_invoke(outParams, [result asyncResult__]); ICEInputStream* is; is = [[ICEInputStream alloc] initWithCxxCommunicator:OBJECTPRX->ice_getCommunicator().get() data:outParams]; @@ -883,7 +883,7 @@ BOOL _returnsData; -(NSUInteger) hash { - return (NSUInteger)OBJECTPRX->__hash(); + return (NSUInteger)OBJECTPRX->_hash(); } -(NSString*) description { @@ -1342,7 +1342,7 @@ BOOL _returnsData; }, ^(const Ice::AsyncResultPtr& result) { std::pair<const ::Ice::Byte*, const ::Ice::Byte*> outP; - BOOL ret__ = OBJECTPRX->___end_ice_invoke(outP, result); + BOOL ret__ = OBJECTPRX->_iceI_end_ice_invoke(outP, result); if(response) { NSMutableData* outEncaps = @@ -1373,7 +1373,7 @@ BOOL _returnsData; context, ^(const Ice::AsyncResultPtr& result) { std::pair<const ::Ice::Byte*, const ::Ice::Byte*> outP; - BOOL ret__ = OBJECTPRX->___end_ice_invoke(outP, result); + BOOL ret__ = OBJECTPRX->_iceI_end_ice_invoke(outP, result); if(response) { NSMutableData* outEncaps = @@ -1390,7 +1390,7 @@ BOOL _returnsData; endCppCall(^(const Ice::AsyncResultPtr& r) { std::pair<const ::Ice::Byte*, const ::Ice::Byte*> outP; - ret__ = OBJECTPRX->___end_ice_invoke(outP, r); + ret__ = OBJECTPRX->_iceI_end_ice_invoke(outP, r); *outEncaps = [NSMutableData dataWithBytes:outP.first length:(outP.second - outP.first)]; }, result); return ret__; diff --git a/objective-c/src/Ice/Stream.mm b/objective-c/src/Ice/Stream.mm index 179ec095031..85b518ec903 100644 --- a/objective-c/src/Ice/Stream.mm +++ b/objective-c/src/Ice/Stream.mm @@ -46,7 +46,7 @@ public: } virtual void - __write(Ice::OutputStream* stream) const + _iceWrite(Ice::OutputStream* stream) const { @try { @@ -59,7 +59,7 @@ public: } virtual void - __read(Ice::InputStream* stream) + _iceRead(Ice::InputStream* stream) { @try { @@ -268,7 +268,7 @@ public: } virtual bool - __usesClasses() const + _usesClasses() const { return [_ex usesClasses__]; } @@ -292,13 +292,13 @@ public: } virtual void - __write(Ice::OutputStream* s) const + _write(Ice::OutputStream* s) const { [_ex write__:static_cast<ICEOutputStream*>(s->getClosure())]; } virtual void - __read(Ice::InputStream* s) + _read(Ice::InputStream* s) { [_ex read__:static_cast<ICEInputStream*>(s->getClosure())]; } @@ -311,8 +311,8 @@ public: protected: - virtual void __writeImpl(Ice::OutputStream*) const {} - virtual void __readImpl(Ice::InputStream*) {} + virtual void _writeImpl(Ice::OutputStream*) const {} + virtual void _readImpl(Ice::InputStream*) {} private: diff --git a/php/src/php5/Types.cpp b/php/src/php5/Types.cpp index 1ba373c0dac..188c512552f 100644 --- a/php/src/php5/Types.cpp +++ b/php/src/php5/Types.cpp @@ -3009,7 +3009,7 @@ IcePHP::ObjectWriter::ice_preMarshal() } void -IcePHP::ObjectWriter::__write(Ice::OutputStream* os) const +IcePHP::ObjectWriter::_iceWrite(Ice::OutputStream* os) const { Ice::SlicedDataPtr slicedData; @@ -3045,7 +3045,7 @@ IcePHP::ObjectWriter::__write(Ice::OutputStream* os) const } void -IcePHP::ObjectWriter::__read(Ice::InputStream*) +IcePHP::ObjectWriter::_iceRead(Ice::InputStream*) { assert(false); } @@ -3116,13 +3116,13 @@ IcePHP::ObjectReader::ice_postUnmarshal() } void -IcePHP::ObjectReader::__write(Ice::OutputStream*) const +IcePHP::ObjectReader::_iceWrite(Ice::OutputStream*) const { assert(false); } void -IcePHP::ObjectReader::__read(Ice::InputStream* is) +IcePHP::ObjectReader::_iceRead(Ice::InputStream* is) { is->startValue(); @@ -3478,13 +3478,13 @@ IcePHP::ExceptionReader::ice_throw() const } void -IcePHP::ExceptionReader::__write(Ice::OutputStream*) const +IcePHP::ExceptionReader::_write(Ice::OutputStream*) const { assert(false); } void -IcePHP::ExceptionReader::__read(Ice::InputStream* is) +IcePHP::ExceptionReader::_read(Ice::InputStream* is) { is->startException(); @@ -3494,7 +3494,7 @@ IcePHP::ExceptionReader::__read(Ice::InputStream* is) } bool -IcePHP::ExceptionReader::__usesClasses() const +IcePHP::ExceptionReader::_usesClasses() const { return _info->usesClasses; } diff --git a/php/src/php5/Types.h b/php/src/php5/Types.h index 3805f44c00d..6777990217c 100644 --- a/php/src/php5/Types.h +++ b/php/src/php5/Types.h @@ -540,8 +540,8 @@ public: virtual void ice_preMarshal(); - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); + virtual void _iceWrite(Ice::OutputStream*) const; + virtual void _iceRead(Ice::InputStream*); private: @@ -567,8 +567,8 @@ public: virtual void ice_postUnmarshal(); - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); + virtual void _iceWrite(Ice::OutputStream*) const; + virtual void _iceRead(Ice::InputStream*); virtual ClassInfoPtr getInfo() const; @@ -601,9 +601,9 @@ public: virtual ExceptionReader* ice_clone() const; virtual void ice_throw() const; - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); - virtual bool __usesClasses() const; + virtual void _write(Ice::OutputStream*) const; + virtual void _read(Ice::InputStream*); + virtual bool _usesClasses() const; ExceptionInfoPtr getInfo() const; @@ -611,13 +611,10 @@ public: Ice::SlicedDataPtr getSlicedData() const; - using Ice::UserException::__read; - using Ice::UserException::__write; - protected: - virtual void __writeImpl(Ice::OutputStream*) const {} - virtual void __readImpl(Ice::InputStream*) {} + virtual void _writeImpl(Ice::OutputStream*) const {} + virtual void _readImpl(Ice::InputStream*) {} private: diff --git a/php/src/php7/Types.cpp b/php/src/php7/Types.cpp index f42c754cbb1..d99b04344d4 100644 --- a/php/src/php7/Types.cpp +++ b/php/src/php7/Types.cpp @@ -2923,7 +2923,7 @@ IcePHP::ObjectWriter::ice_preMarshal() } void -IcePHP::ObjectWriter::__write(Ice::OutputStream* os) const +IcePHP::ObjectWriter::_iceWrite(Ice::OutputStream* os) const { Ice::SlicedDataPtr slicedData; @@ -2959,7 +2959,7 @@ IcePHP::ObjectWriter::__write(Ice::OutputStream* os) const } void -IcePHP::ObjectWriter::__read(Ice::InputStream*) +IcePHP::ObjectWriter::_iceRead(Ice::InputStream*) { assert(false); } @@ -3032,13 +3032,13 @@ IcePHP::ObjectReader::ice_postUnmarshal() } void -IcePHP::ObjectReader::__write(Ice::OutputStream*) const +IcePHP::ObjectReader::_iceWrite(Ice::OutputStream*) const { assert(false); } void -IcePHP::ObjectReader::__read(Ice::InputStream* is) +IcePHP::ObjectReader::_iceRead(Ice::InputStream* is) { is->startValue(); @@ -3383,13 +3383,13 @@ IcePHP::ExceptionReader::ice_throw() const } void -IcePHP::ExceptionReader::__write(Ice::OutputStream*) const +IcePHP::ExceptionReader::_write(Ice::OutputStream*) const { assert(false); } void -IcePHP::ExceptionReader::__read(Ice::InputStream* is) +IcePHP::ExceptionReader::_read(Ice::InputStream* is) { is->startException(); @@ -3399,7 +3399,7 @@ IcePHP::ExceptionReader::__read(Ice::InputStream* is) } bool -IcePHP::ExceptionReader::__usesClasses() const +IcePHP::ExceptionReader::_usesClasses() const { return _info->usesClasses; } diff --git a/php/src/php7/Types.h b/php/src/php7/Types.h index 27556c48df7..111c5f77c76 100644 --- a/php/src/php7/Types.h +++ b/php/src/php7/Types.h @@ -537,8 +537,8 @@ public: virtual void ice_preMarshal(); - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); + virtual void _iceWrite(Ice::OutputStream*) const; + virtual void _iceRead(Ice::InputStream*); private: @@ -561,8 +561,8 @@ public: virtual void ice_postUnmarshal(); - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); + virtual void _iceWrite(Ice::OutputStream*) const; + virtual void _iceRead(Ice::InputStream*); virtual ClassInfoPtr getInfo() const; @@ -592,9 +592,9 @@ public: virtual ExceptionReader* ice_clone() const; virtual void ice_throw() const; - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); - virtual bool __usesClasses() const; + virtual void _write(Ice::OutputStream*) const; + virtual void _read(Ice::InputStream*); + virtual bool _usesClasses() const; ExceptionInfoPtr getInfo() const; @@ -602,13 +602,10 @@ public: Ice::SlicedDataPtr getSlicedData() const; - using Ice::UserException::__read; - using Ice::UserException::__write; - protected: - virtual void __writeImpl(Ice::OutputStream*) const {} - virtual void __readImpl(Ice::InputStream*) {} + virtual void _writeImpl(Ice::OutputStream*) const {} + virtual void _readImpl(Ice::InputStream*) {} private: diff --git a/python/modules/IcePy/Operation.cpp b/python/modules/IcePy/Operation.cpp index c8dad9a0c96..3b62b8aef59 100644 --- a/python/modules/IcePy/Operation.cpp +++ b/python/modules/IcePy/Operation.cpp @@ -2114,7 +2114,7 @@ IcePy::AsyncTypedInvocation::end(const Ice::ObjectPrx& proxy, const OperationPtr { AllowThreads allowThreads; // Release Python's global interpreter lock during blocking operations. - ok = proxy->___end_ice_invoke(results, r); + ok = proxy->_iceI_end_ice_invoke(results, r); } if(ok) @@ -2803,7 +2803,7 @@ IcePy::AsyncBlobjectInvocation::end(const Ice::ObjectPrx& proxy, const Ice::Asyn { AllowThreads allowThreads; // Release Python's global interpreter lock during blocking operations. - ok = proxy->___end_ice_invoke(results, r); + ok = proxy->_iceI_end_ice_invoke(results, r); } // @@ -4142,7 +4142,7 @@ IcePy::TypedServantWrapper::ice_invoke_async(const Ice::AMD_Object_ice_invokePtr // if(!op->pseudoOp) { - __checkMode(op->mode, current.mode); + _iceCheckMode(op->mode, current.mode); } UpcallPtr up = new TypedUpcall(op, cb, current.adapter->getCommunicator()); diff --git a/python/modules/IcePy/Proxy.cpp b/python/modules/IcePy/Proxy.cpp index d9b2704b2a8..0d1c11bb082 100644 --- a/python/modules/IcePy/Proxy.cpp +++ b/python/modules/IcePy/Proxy.cpp @@ -164,7 +164,7 @@ extern "C" static long proxyHash(ProxyObject* self) { - return static_cast<long>((*self->proxy)->__hash()); + return static_cast<long>((*self->proxy)->_hash()); } #ifdef WIN32 diff --git a/python/modules/IcePy/Types.cpp b/python/modules/IcePy/Types.cpp index 59be1eb8ab5..2f81d25443c 100644 --- a/python/modules/IcePy/Types.cpp +++ b/python/modules/IcePy/Types.cpp @@ -3232,7 +3232,7 @@ IcePy::ObjectWriter::ice_preMarshal() } void -IcePy::ObjectWriter::__write(Ice::OutputStream* os) const +IcePy::ObjectWriter::_iceWrite(Ice::OutputStream* os) const { Ice::SlicedDataPtr slicedData; @@ -3266,7 +3266,7 @@ IcePy::ObjectWriter::__write(Ice::OutputStream* os) const } void -IcePy::ObjectWriter::__read(Ice::InputStream*) +IcePy::ObjectWriter::_iceRead(Ice::InputStream*) { assert(false); } @@ -3341,13 +3341,13 @@ IcePy::ObjectReader::ice_postUnmarshal() } void -IcePy::ObjectReader::__write(Ice::OutputStream*) const +IcePy::ObjectReader::_iceWrite(Ice::OutputStream*) const { assert(false); } void -IcePy::ObjectReader::__read(Ice::InputStream* is) +IcePy::ObjectReader::_iceRead(Ice::InputStream* is) { is->startValue(); @@ -3735,7 +3735,7 @@ IcePy::ExceptionWriter::ice_throw() const } void -IcePy::ExceptionWriter::__write(Ice::OutputStream* os) const +IcePy::ExceptionWriter::_write(Ice::OutputStream* os) const { AdoptThread adoptThread; // Ensure the current thread is able to call into Python. @@ -3743,12 +3743,12 @@ IcePy::ExceptionWriter::__write(Ice::OutputStream* os) const } void -IcePy::ExceptionWriter::__read(Ice::InputStream*) +IcePy::ExceptionWriter::_read(Ice::InputStream*) { } bool -IcePy::ExceptionWriter::__usesClasses() const +IcePy::ExceptionWriter::_usesClasses() const { return _info->usesClasses; } @@ -3790,13 +3790,13 @@ IcePy::ExceptionReader::ice_throw() const } void -IcePy::ExceptionReader::__write(Ice::OutputStream*) const +IcePy::ExceptionReader::_write(Ice::OutputStream*) const { assert(false); } void -IcePy::ExceptionReader::__read(Ice::InputStream* is) +IcePy::ExceptionReader::_read(Ice::InputStream* is) { AdoptThread adoptThread; // Ensure the current thread is able to call into Python. @@ -3808,7 +3808,7 @@ IcePy::ExceptionReader::__read(Ice::InputStream* is) } bool -IcePy::ExceptionReader::__usesClasses() const +IcePy::ExceptionReader::_usesClasses() const { return _info->usesClasses; } diff --git a/python/modules/IcePy/Types.h b/python/modules/IcePy/Types.h index 921047496b9..5933c6dd234 100644 --- a/python/modules/IcePy/Types.h +++ b/python/modules/IcePy/Types.h @@ -554,8 +554,8 @@ public: virtual void ice_preMarshal(); - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); + virtual void _iceWrite(Ice::OutputStream*) const; + virtual void _iceRead(Ice::InputStream*); private: @@ -578,8 +578,8 @@ public: virtual void ice_postUnmarshal(); - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); + virtual void _iceWrite(Ice::OutputStream*) const; + virtual void _iceRead(Ice::InputStream*); virtual ClassInfoPtr getInfo() const; @@ -610,15 +610,15 @@ public: #endif virtual void ice_throw() const; - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); + virtual void _write(Ice::OutputStream*) const; + virtual void _read(Ice::InputStream*); - virtual bool __usesClasses() const; + virtual bool _usesClasses() const; protected: - virtual void __writeImpl(Ice::OutputStream*) const {} - virtual void __readImpl(Ice::InputStream*) {} + virtual void _writeImpl(Ice::OutputStream*) const {} + virtual void _readImpl(Ice::InputStream*) {} private: @@ -643,22 +643,19 @@ public: #endif virtual void ice_throw() const; - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); + virtual void _write(Ice::OutputStream*) const; + virtual void _read(Ice::InputStream*); - virtual bool __usesClasses() const; + virtual bool _usesClasses() const; PyObject* getException() const; // Borrowed reference. Ice::SlicedDataPtr getSlicedData() const; - using Ice::UserException::__read; - using Ice::UserException::__write; - protected: - virtual void __writeImpl(Ice::OutputStream*) const {} - virtual void __readImpl(Ice::InputStream*) {} + virtual void _writeImpl(Ice::OutputStream*) const {} + virtual void _readImpl(Ice::InputStream*) {} private: diff --git a/ruby/src/IceRuby/Proxy.cpp b/ruby/src/IceRuby/Proxy.cpp index 0029cad3378..fd7c201f6b8 100644 --- a/ruby/src/IceRuby/Proxy.cpp +++ b/ruby/src/IceRuby/Proxy.cpp @@ -77,7 +77,7 @@ IceRuby_ObjectPrx_hash(VALUE self) ICE_RUBY_TRY { Ice::ObjectPrx p = getProxy(self); - return INT2FIX(p->__hash()); + return INT2FIX(p->_hash()); } ICE_RUBY_CATCH return Qnil; diff --git a/ruby/src/IceRuby/Types.cpp b/ruby/src/IceRuby/Types.cpp index d0577ddcf09..3561d1f3952 100644 --- a/ruby/src/IceRuby/Types.cpp +++ b/ruby/src/IceRuby/Types.cpp @@ -2468,7 +2468,7 @@ IceRuby::ObjectWriter::ice_preMarshal() } void -IceRuby::ObjectWriter::__write(Ice::OutputStream* os) const +IceRuby::ObjectWriter::_iceWrite(Ice::OutputStream* os) const { Ice::SlicedDataPtr slicedData; @@ -2502,7 +2502,7 @@ IceRuby::ObjectWriter::__write(Ice::OutputStream* os) const } void -IceRuby::ObjectWriter::__read(Ice::InputStream*) +IceRuby::ObjectWriter::_iceRead(Ice::InputStream*) { assert(false); } @@ -2559,13 +2559,13 @@ IceRuby::ObjectReader::ice_postUnmarshal() } void -IceRuby::ObjectReader::__write(Ice::OutputStream*) const +IceRuby::ObjectReader::_iceWrite(Ice::OutputStream*) const { assert(false); } void -IceRuby::ObjectReader::__read(Ice::InputStream* is) +IceRuby::ObjectReader::_iceRead(Ice::InputStream* is) { is->startValue(); @@ -2855,13 +2855,13 @@ IceRuby::ExceptionReader::ice_throw() const } void -IceRuby::ExceptionReader::__write(Ice::OutputStream*) const +IceRuby::ExceptionReader::_write(Ice::OutputStream*) const { assert(false); } void -IceRuby::ExceptionReader::__read(Ice::InputStream* is) +IceRuby::ExceptionReader::_read(Ice::InputStream* is) { is->startException(); @@ -2871,7 +2871,7 @@ IceRuby::ExceptionReader::__read(Ice::InputStream* is) } bool -IceRuby::ExceptionReader::__usesClasses() const +IceRuby::ExceptionReader::_usesClasses() const { return _info->usesClasses; } diff --git a/ruby/src/IceRuby/Types.h b/ruby/src/IceRuby/Types.h index 809b34aed0c..8e59edc056f 100644 --- a/ruby/src/IceRuby/Types.h +++ b/ruby/src/IceRuby/Types.h @@ -492,8 +492,8 @@ public: virtual void ice_preMarshal(); - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); + virtual void _iceWrite(Ice::OutputStream*) const; + virtual void _iceRead(Ice::InputStream*); private: @@ -516,8 +516,8 @@ public: virtual void ice_postUnmarshal(); - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); + virtual void _iceWrite(Ice::OutputStream*) const; + virtual void _iceRead(Ice::InputStream*); virtual ClassInfoPtr getInfo() const; @@ -548,22 +548,19 @@ public: #endif virtual void ice_throw() const; - virtual void __write(Ice::OutputStream*) const; - virtual void __read(Ice::InputStream*); + virtual void _write(Ice::OutputStream*) const; + virtual void _read(Ice::InputStream*); - virtual bool __usesClasses() const; + virtual bool _usesClasses() const; VALUE getException() const; Ice::SlicedDataPtr getSlicedData() const; - using Ice::UserException::__read; - using Ice::UserException::__write; - protected: - virtual void __writeImpl(Ice::OutputStream*) const {} - virtual void __readImpl(Ice::InputStream*) {} + virtual void _writeImpl(Ice::OutputStream*) const {} + virtual void _readImpl(Ice::InputStream*) {} private: diff --git a/ruby/src/IceRuby/Util.h b/ruby/src/IceRuby/Util.h index d225a09dfb0..2487d0a7570 100644 --- a/ruby/src/IceRuby/Util.h +++ b/ruby/src/IceRuby/Util.h @@ -467,19 +467,19 @@ VALUE convertLocalException(const Ice::LocalException&); // exceptions into Ruby exceptions and ensure that C++ objects are cleaned up properly. // #define ICE_RUBY_TRY \ - volatile VALUE __ice_ex = Qnil; \ + volatile VALUE ex_ = Qnil; \ \ - goto __ice_start; \ + goto ice_start; \ \ - __ice_handle_exception: \ - rb_exc_raise(__ice_ex); \ + ice_handle_exception: \ + rb_exc_raise(ex_); \ \ - __ice_start: \ + ice_start: \ try #define ICE_RUBY_RETHROW(ex) \ - __ice_ex = ex; \ - goto __ice_handle_exception; + ex_ = ex; \ + goto ice_handle_exception; #define ICE_RUBY_CATCH \ catch(const ::IceRuby::RubyException& ex) \ @@ -492,8 +492,8 @@ VALUE convertLocalException(const Ice::LocalException&); } \ catch(const ::Ice::Exception& ex) \ { \ - string __ice_msg = "unknown Ice exception: " + ex.ice_id(); \ - ICE_RUBY_RETHROW(rb_exc_new2(rb_eRuntimeError, __ice_msg.c_str())); \ + string msg_ = "unknown Ice exception: " + ex.ice_id(); \ + ICE_RUBY_RETHROW(rb_exc_new2(rb_eRuntimeError, msg_.c_str())); \ } \ catch(const std::bad_alloc& ex) \ { \ |