Revert "Replaced double and triple underscores in C++ by ice-prefixed names"

This reverts commit 91fa99c34d1211d426b24bf68001fc27a87b3f00.

73 files changed, 1213 insertions, 1220 deletions

diff --git a/cpp/include/Ice/AsyncResult.h b/cpp/include/Ice/AsyncResult.h
index 5562448e7eb..e8aea029007 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 iceWait() = 0;
-    virtual Ice::InputStream* iceStartReadParams() = 0;
-    virtual void iceEndReadParams() = 0;
-    virtual void iceReadEmptyParams() = 0;
-    virtual void iceReadParamEncaps(const ::Ice::Byte*&, ::Ice::Int&) = 0;
-    virtual void iceThrowUserException() = 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;
 
-    static void iceCheck(const AsyncResultPtr&, const ::IceProxy::Ice::Object*, const ::std::string&);
-    static void iceCheck(const AsyncResultPtr&, const Connection*, const ::std::string&);
-    static void iceCheck(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 iceCheck(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 ea121dff6c5..549542567dd 100644
--- a/cpp/include/Ice/CommunicatorAsync.h
+++ b/cpp/include/Ice/CommunicatorAsync.h
@@ -33,18 +33,18 @@ public:
     {
     }
 
-    virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const
+    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
     {
-        ::Ice::CommunicatorPtr iceCom = iceResult->getCommunicator();
-        assert(iceCom);
+        ::Ice::CommunicatorPtr __com = __result->getCommunicator();
+        assert(__com);
         try
         {
-            iceCom->end_flushBatchRequests(iceResult);
+            __com->end_flushBatchRequests(__result);
             assert(false);
         }
         catch(const ::Ice::Exception& ex)
         {
-            ::IceInternal::CallbackNC<T>::exception(iceResult, ex);
+            ::IceInternal::CallbackNC<T>::exception(__result, ex);
         }
     }
 };
@@ -81,18 +81,18 @@ public:
     {
     }
 
-    virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const
+    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
     {
-        ::Ice::CommunicatorPtr iceCom = iceResult->getCommunicator();
-        assert(iceCom);
+        ::Ice::CommunicatorPtr __com = __result->getCommunicator();
+        assert(__com);
         try
         {
-            iceCom->end_flushBatchRequests(iceResult);
+            __com->end_flushBatchRequests(__result);
             assert(false);
         }
         catch(const ::Ice::Exception& ex)
         {
-            ::IceInternal::Callback<T, CT>::exception(iceResult, ex);
+            ::IceInternal::Callback<T, CT>::exception(__result, ex);
         }
     }
 };
diff --git a/cpp/include/Ice/ConnectionAsync.h b/cpp/include/Ice/ConnectionAsync.h
index dfba4900e52..ce9fd85e7af 100644
--- a/cpp/include/Ice/ConnectionAsync.h
+++ b/cpp/include/Ice/ConnectionAsync.h
@@ -34,18 +34,18 @@ public:
     {
     }
 
-    virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const
+    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
     {
-        ::Ice::ConnectionPtr iceCon = iceResult->getConnection();
-        assert(iceCon);
+        ::Ice::ConnectionPtr __con = __result->getConnection();
+        assert(__con);
         try
         {
-            iceCon->end_flushBatchRequests(iceResult);
+            __con->end_flushBatchRequests(__result);
             assert(false);
         }
         catch(const ::Ice::Exception& ex)
         {
-            ::IceInternal::CallbackNC<T>::exception(iceResult, ex);
+            ::IceInternal::CallbackNC<T>::exception(__result, ex);
         }
     }
 };
@@ -81,18 +81,18 @@ public:
     {
     }
 
-    virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const
+    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
     {
-        ::Ice::ConnectionPtr iceCon = iceResult->getConnection();
-        assert(iceCon);
+        ::Ice::ConnectionPtr __con = __result->getConnection();
+        assert(__con);
         try
         {
-            iceCon->end_flushBatchRequests(iceResult);
+            __con->end_flushBatchRequests(__result);
             assert(false);
         }
         catch(const ::Ice::Exception& ex)
         {
-            ::IceInternal::Callback<T, CT>::exception(iceResult, ex);
+            ::IceInternal::Callback<T, CT>::exception(__result, ex);
         }
     }
 };
diff --git a/cpp/include/Ice/DispatchInterceptor.h b/cpp/include/Ice/DispatchInterceptor.h
index 12223a61abe..648e21412ca 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 iceDispatch(IceInternal::Incoming&, const Current&);
+    virtual bool __dispatch(IceInternal::Incoming&, const Current&);
 };
 
 ICE_DEFINE_PTR(DispatchInterceptorPtr, DispatchInterceptor);
diff --git a/cpp/include/Ice/Exception.h b/cpp/include/Ice/Exception.h
index b135e34c69b..b2b4720b8ea 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 iceWrite(::Ice::OutputStream*) const;
-    virtual void iceRead(::Ice::InputStream*);
+    virtual void __write(::Ice::OutputStream*) const;
+    virtual void __read(::Ice::InputStream*);
 
-    virtual bool iceUsesClasses() const;
+    virtual bool __usesClasses() const;
 
 #ifdef ICE_CPP11_MAPPING
     std::unique_ptr<UserException> ice_clone() const;
@@ -72,8 +72,8 @@ public:
 
 protected:
 
-    virtual void iceWriteImpl(::Ice::OutputStream*) const {};
-    virtual void iceReadImpl(::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 320f5de9aaa..04c37669f07 100644
--- a/cpp/include/Ice/ExceptionHelpers.h
+++ b/cpp/include/Ice/ExceptionHelpers.h
@@ -45,20 +45,20 @@ public:
 
 protected:
 
-    virtual void iceWriteImpl(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::iceWriteImpl(os);
+        B::__writeImpl(os);
     }
 
-    virtual void iceReadImpl(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::iceReadImpl(is);
+        B::__readImpl(is);
     }
 };
 
diff --git a/cpp/include/Ice/GCObject.h b/cpp/include/Ice/GCObject.h
index ad18de931ca..e115795be20 100644
--- a/cpp/include/Ice/GCObject.h
+++ b/cpp/include/Ice/GCObject.h
@@ -47,24 +47,24 @@ public:
     //
     // Override IceUtil::Shared methods
     //
-    virtual void iceIncRef();
-    virtual void iceDecRef();
-    virtual int iceGetRef() const;
-    virtual void iceSetNoDelete(bool);
+    virtual void __incRef();
+    virtual void __decRef();
+    virtual int __getRef() const;
+    virtual void __setNoDelete(bool);
 
     //
     // Override Object methods
     //
-    virtual bool iceGcVisit(GCVisitor&);
+    virtual bool __gcVisit(GCVisitor&);
     virtual void ice_collectable(bool);
 
     //
     // This method is implemented by Slice classes to visit class
     // members.
     //
-    virtual void iceGcVisitMembers(IceInternal::GCVisitor&) = 0;
+    virtual void __gcVisitMembers(IceInternal::GCVisitor&) = 0;
 
-    int iceGetRefUnsafe()
+    int __getRefUnsafe()
     {
         return _ref;
     }
diff --git a/cpp/include/Ice/Handle.h b/cpp/include/Ice/Handle.h
index 927ad362b13..59283f07702 100644
--- a/cpp/include/Ice/Handle.h
+++ b/cpp/include/Ice/Handle.h
@@ -43,7 +43,7 @@ public:
 
         if(this->_ptr)
         {
-            upCast(this->_ptr)->iceIncRef();
+            upCast(this->_ptr)->__incRef();
         }
     }
     
@@ -54,7 +54,7 @@ public:
 
         if(this->_ptr)
         {
-            upCast(this->_ptr)->iceIncRef();
+            upCast(this->_ptr)->__incRef();
         }
     }
 
@@ -65,7 +65,7 @@ public:
 
         if(this->_ptr)
         {
-            upCast(this->_ptr)->iceIncRef();
+            upCast(this->_ptr)->__incRef();
         }
     }
 
@@ -75,7 +75,7 @@ public:
 
         if(this->_ptr)
         {
-            upCast(this->_ptr)->iceIncRef();
+            upCast(this->_ptr)->__incRef();
         }
     }
     
@@ -83,7 +83,7 @@ public:
     {
         if(this->_ptr)
         {
-            upCast(this->_ptr)->iceDecRef();
+            upCast(this->_ptr)->__decRef();
         }
     }
     
@@ -93,7 +93,7 @@ public:
         {
             if(p)
             {
-                upCast(p)->iceIncRef();
+                upCast(p)->__incRef();
             }
 
             T* ptr = this->_ptr;
@@ -101,7 +101,7 @@ public:
 
             if(ptr)
             {
-                upCast(ptr)->iceDecRef();
+                upCast(ptr)->__decRef();
             }
         }
         return *this;
@@ -114,7 +114,7 @@ public:
         {
             if(r._ptr)
             {
-                upCast(r._ptr)->iceIncRef();
+                upCast(r._ptr)->__incRef();
             }
 
             T* ptr = this->_ptr;
@@ -122,7 +122,7 @@ public:
 
             if(ptr)
             {
-                upCast(ptr)->iceDecRef();
+                upCast(ptr)->__decRef();
             }
         }
         return *this;
@@ -135,7 +135,7 @@ public:
         {
             if(r._ptr)
             {
-                upCast(r._ptr)->iceIncRef();
+                upCast(r._ptr)->__incRef();
             }
 
             T* ptr = this->_ptr;
@@ -143,7 +143,7 @@ public:
 
             if(ptr)
             {
-                upCast(ptr)->iceDecRef();
+                upCast(ptr)->__decRef();
             }
         }
         return *this;
@@ -155,7 +155,7 @@ public:
         {
             if(r._ptr)
             {
-                upCast(r._ptr)->iceIncRef();
+                upCast(r._ptr)->__incRef();
             }
 
             T* ptr = this->_ptr;
@@ -163,7 +163,7 @@ public:
 
             if(ptr)
             {
-                upCast(ptr)->iceDecRef();
+                upCast(ptr)->__decRef();
             }
         }
         return *this;
@@ -181,7 +181,7 @@ public:
         return Handle(dynamic_cast<T*>(p));
     }
 
-    void iceClearHandleUnsafe()
+    void __clearHandleUnsafe()
     {
         this->_ptr = 0;
     }
diff --git a/cpp/include/Ice/Incoming.h b/cpp/include/Ice/Incoming.h
index bdff5b49721..f512d38ac8b 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 __os;
     }
 
 protected:
 
-    std::shared_ptr<OutputStream> _os;
+    std::shared_ptr<OutputStream> __os;
 };
 
 }
diff --git a/cpp/include/Ice/InputStream.h b/cpp/include/Ice/InputStream.h
index c570d7cbe77..81d5be4c950 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);
-    icePatch(*p, v); // Generated icePatch method, necessary for forward declarations.
+    __patch(*p, v); // Generated __patch method, necessary for forward declarations.
 #endif
 }
 
@@ -383,7 +383,7 @@ public:
 #ifdef ICE_CPP11_MAPPING
             v.emplace();
 #else
-            v.iceSetIsSet();
+            v.__setIsSet();
 #endif
             StreamOptionalHelper<T,
                                  StreamableTraits<T>::helper,
@@ -594,14 +594,14 @@ public:
         else
         {
             v = ::IceInternal::createProxy<T>();
-            v->iceCopyFrom(proxy);
+            v->__copyFrom(proxy);
         }
     }
 #else
     void read(ObjectPrx&);
     template<typename T> void read(IceInternal::ProxyHandle<T>& v)
     {
-        iceRead(this, v); // Generated iceRead method, necessary for forward declarations.
+        __read(this, v); // Generated __read method, necessary for forward declarations.
     }
 #endif
 
diff --git a/cpp/include/Ice/LoggerUtil.h b/cpp/include/Ice/LoggerUtil.h
index 0be6d1e4359..ff890e9aedd 100644
--- a/cpp/include/Ice/LoggerUtil.h
+++ b/cpp/include/Ice/LoggerUtil.h
@@ -24,7 +24,7 @@ public:
 
     std::string str() const;
 
-    std::ostringstream& iceStr(); // For internal use only. Don't use in your code.
+    std::ostringstream& __str(); // For internal use only. Don't use in your code.
 
 private:
 
@@ -48,7 +48,7 @@ struct LoggerOutputInserter
     static inline LoggerOutputBase&
     insert(LoggerOutputBase& out, const T& val)
     {
-        out.iceStr() << val;
+        out.__str() << 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.iceStr() << ex.what();
+    out.__str() << ex.what();
     return out;
 }
 
@@ -108,13 +108,13 @@ public:
 
     inline void flush()
     {
-        std::string s = iceStr().str();
+        std::string s = __str().str();
         if(!s.empty())
         {
             L& ref = *_logger;
             (ref.*output)(s);
         }
-        iceStr().str("");
+        __str().str("");
     }
 
 private:
diff --git a/cpp/include/Ice/Object.h b/cpp/include/Ice/Object.h
index 9e2eaf984b7..6e472bd5fee 100644
--- a/cpp/include/Ice/Object.h
+++ b/cpp/include/Ice/Object.h
@@ -70,20 +70,20 @@ public:
     virtual ~Object() = default;
 
     virtual bool ice_isA(std::string, const Current& = Ice::noExplicitCurrent) const;
-    bool iceD_ice_isA(IceInternal::Incoming&, const Current&);
+    bool ___ice_isA(IceInternal::Incoming&, const Current&);
 
     virtual void ice_ping(const Current&  = Ice::noExplicitCurrent) const;
-    bool iceD_ice_ping(IceInternal::Incoming&, const Current&);
+    bool ___ice_ping(IceInternal::Incoming&, const Current&);
 
     virtual std::vector< std::string> ice_ids(const Current& = Ice::noExplicitCurrent) const;
-    bool iceD_ice_ids(IceInternal::Incoming&, const Current&);
+    bool ___ice_ids(IceInternal::Incoming&, const Current&);
 
     virtual std::string ice_id(const Current& = Ice::noExplicitCurrent) const;
-    bool iceD_ice_id(IceInternal::Incoming&, const Current&);
+    bool ___ice_id(IceInternal::Incoming&, const Current&);
 
     static const std::string& ice_staticId();
 
-    static std::string s_iceAll[];
+    static std::string __all[];
 
 #ifndef ICE_CPP11_MAPPING
     virtual bool ice_dispatch(Ice::Request&, const DispatchInterceptorAsyncCallbackPtr& = 0);
@@ -92,7 +92,7 @@ public:
                               std::function<bool()> = nullptr,
                               std::function<bool(std::exception_ptr)> = nullptr);
 #endif
-    virtual bool iceDispatch(IceInternal::Incoming&, const Current&);
+    virtual bool __dispatch(IceInternal::Incoming&, const Current&);
 
     struct Ice_invokeResult
     {
@@ -102,7 +102,7 @@ public:
 
 protected:
 
-    static void iceCheckMode(OperationMode, OperationMode);
+    static void __checkMode(OperationMode, OperationMode);
 };
 #else
 class ICE_API Object  : public virtual IceUtil::Shared
@@ -113,23 +113,23 @@ public:
     virtual bool operator<(const Object&) const;
 
     virtual bool ice_isA(const std::string&, const Current& = Ice::noExplicitCurrent) const;
-    bool iceD_ice_isA(IceInternal::Incoming&, const Current&);
+    bool ___ice_isA(IceInternal::Incoming&, const Current&);
 
     virtual void ice_ping(const Current&  = Ice::noExplicitCurrent) const;
-    bool iceD_ice_ping(IceInternal::Incoming&, const Current&);
+    bool ___ice_ping(IceInternal::Incoming&, const Current&);
 
     virtual std::vector< std::string> ice_ids(const Current& = Ice::noExplicitCurrent) const;
-    bool iceD_ice_ids(IceInternal::Incoming&, const Current&);
+    bool ___ice_ids(IceInternal::Incoming&, const Current&);
 
     virtual const std::string& ice_id(const Current& = Ice::noExplicitCurrent) const;
-    bool iceD_ice_id(IceInternal::Incoming&, const Current&);
+    bool ___ice_id(IceInternal::Incoming&, const Current&);
 
     virtual Int ice_operationAttributes(const std::string&) const;
 
-    virtual void iceWrite(Ice::OutputStream*) const;
-    virtual void iceRead(Ice::InputStream*);
+    virtual void __write(Ice::OutputStream*) const;
+    virtual void __read(Ice::InputStream*);
 
-    virtual bool iceGcVisit(IceInternal::GCVisitor&) { return false; };
+    virtual bool __gcVisit(IceInternal::GCVisitor&) { return false; };
     virtual void ice_collectable(bool) { };
 
     virtual void ice_preMarshal();
@@ -139,10 +139,10 @@ public:
 
     virtual ObjectPtr ice_clone() const;
 
-    static std::string s_iceAll[];
+    static std::string __all[];
 
     virtual bool ice_dispatch(Ice::Request&, const DispatchInterceptorAsyncCallbackPtr& = 0);
-    virtual bool iceDispatch(IceInternal::Incoming&, const Current&);
+    virtual bool __dispatch(IceInternal::Incoming&, const Current&);
 
 protected:
 
@@ -151,10 +151,10 @@ protected:
 
 protected:
 
-    virtual void iceWriteImpl(Ice::OutputStream*) const {}
-    virtual void iceReadImpl(Ice::InputStream*) {}
+    virtual void __writeImpl(Ice::OutputStream*) const {}
+    virtual void __readImpl(Ice::InputStream*) {}
 
-    static void iceCheckMode(OperationMode, OperationMode);
+    static void __checkMode(OperationMode, OperationMode);
 };
 #endif
 
@@ -167,7 +167,7 @@ public:
     //
     virtual bool ice_invoke(const std::vector<Byte>&, std::vector<Byte>&, const Current&) = 0;
 
-    virtual bool iceDispatch(IceInternal::Incoming&, const Current&);
+    virtual bool __dispatch(IceInternal::Incoming&, const Current&);
 };
 
 class ICE_API BlobjectArray : public virtual Object
@@ -179,7 +179,7 @@ public:
     //
     virtual bool ice_invoke(const std::pair<const Byte*, const Byte*>&, std::vector<Byte>&, const Current&) = 0;
 
-    virtual bool iceDispatch(IceInternal::Incoming&, const Current&);
+    virtual bool __dispatch(IceInternal::Incoming&, const Current&);
 };
 
 class ICE_API BlobjectAsync : public virtual Object
@@ -194,7 +194,7 @@ public:
 #else
     virtual void ice_invoke_async(const AMD_Object_ice_invokePtr&, const std::vector<Byte>&, const Current&) = 0;
 #endif
-    virtual bool iceDispatch(IceInternal::Incoming&, const Current&);
+    virtual bool __dispatch(IceInternal::Incoming&, const Current&);
 };
 
 class ICE_API BlobjectArrayAsync : public virtual Object
@@ -210,7 +210,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 iceDispatch(IceInternal::Incoming&, const Current&);
+    virtual bool __dispatch(IceInternal::Incoming&, const Current&);
 };
 
 }
diff --git a/cpp/include/Ice/ObjectF.h b/cpp/include/Ice/ObjectF.h
index 8f6ffd96580..eb157fac899 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 icePatch(ObjectPtr&, const ObjectPtr&);
+ICE_API void __patch(ObjectPtr&, const ObjectPtr&);
 #endif
 
 }
diff --git a/cpp/include/Ice/OutgoingAsync.h b/cpp/include/Ice/OutgoingAsync.h
index 23d2ef8a1e6..8391c6c189d 100644
--- a/cpp/include/Ice/OutgoingAsync.h
+++ b/cpp/include/Ice/OutgoingAsync.h
@@ -101,12 +101,12 @@ public:
 
     virtual void throwLocalException() const;
 
-    virtual bool iceWait();
-    virtual Ice::InputStream* iceStartReadParams();
-    virtual void iceEndReadParams();
-    virtual void iceReadEmptyParams();
-    virtual void iceReadParamEncaps(const ::Ice::Byte*&, ::Ice::Int&);
-    virtual void iceThrowUserException();
+    virtual bool __wait();
+    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 b0ddec97b23..30315e7f33b 100644
--- a/cpp/include/Ice/Proxy.h
+++ b/cpp/include/Ice/Proxy.h
@@ -254,7 +254,7 @@ public:
     bool
     ice_isA(const ::std::string& typeId, const ::Ice::Context& ctx = ::Ice::noExplicitContext)
     {
-        return makePromiseOutgoing<bool>(true, this, &ObjectPrx::iceI_ice_isA, typeId, ctx).get();
+        return makePromiseOutgoing<bool>(true, this, &ObjectPrx::__ice_isA, typeId, ctx).get();
     }
 
     ::std::function<void()>
@@ -264,23 +264,23 @@ public:
                  ::std::function<void(bool)> sent = nullptr,
                  const ::Ice::Context& ctx = ::Ice::noExplicitContext)
     {
-        return makeLambdaOutgoing<bool>(response, ex, sent, this, &ObjectPrx::iceI_ice_isA, typeId, ctx);
+        return makeLambdaOutgoing<bool>(response, ex, sent, this, &ObjectPrx::__ice_isA, typeId, ctx);
     }
 
     template<template<typename> class P = std::promise> auto
     ice_isAAsync(const ::std::string& typeId, const ::Ice::Context& ctx = ::Ice::noExplicitContext)
         -> decltype(std::declval<P<bool>>().get_future())
     {
-        return makePromiseOutgoing<bool, P>(false, this, &ObjectPrx::iceI_ice_isA, typeId, ctx);
+        return makePromiseOutgoing<bool, P>(false, this, &ObjectPrx::__ice_isA, typeId, ctx);
     }
 
     void
-    iceI_ice_isA(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<bool>>&, const ::std::string&, const ::Ice::Context&);
+    __ice_isA(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<bool>>&, const ::std::string&, const ::Ice::Context&);
 
     void
     ice_ping(const ::Ice::Context& ctx = ::Ice::noExplicitContext)
     {
-        makePromiseOutgoing<void>(true, this, &ObjectPrx::iceI_ice_ping, ctx).get();
+        makePromiseOutgoing<void>(true, this, &ObjectPrx::__ice_ping, ctx).get();
     }
 
     ::std::function<void()>
@@ -289,23 +289,23 @@ public:
                   ::std::function<void(bool)> sent = nullptr,
                   const ::Ice::Context& ctx = ::Ice::noExplicitContext)
     {
-        return makeLambdaOutgoing<void>(response, ex, sent, this, &ObjectPrx::iceI_ice_ping, ctx);
+        return makeLambdaOutgoing<void>(response, ex, sent, this, &ObjectPrx::__ice_ping, ctx);
     }
 
     template<template<typename> class P = std::promise>
     auto ice_pingAsync(const ::Ice::Context& ctx = ::Ice::noExplicitContext)
         -> decltype(std::declval<P<void>>().get_future())
     {
-        return makePromiseOutgoing<void, P>(false, this, &ObjectPrx::iceI_ice_ping, ctx);
+        return makePromiseOutgoing<void, P>(false, this, &ObjectPrx::__ice_ping, ctx);
     }
 
     void
-    iceI_ice_ping(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::Ice::Context&);
+    __ice_ping(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::Ice::Context&);
 
     ::std::vector<::std::string>
     ice_ids(const ::Ice::Context& ctx = ::Ice::noExplicitContext)
     {
-        return makePromiseOutgoing<::std::vector<::std::string>>(true, this, &ObjectPrx::iceI_ice_ids, ctx).get();
+        return makePromiseOutgoing<::std::vector<::std::string>>(true, this, &ObjectPrx::__ice_ids, ctx).get();
     }
 
     ::std::function<void()>
@@ -314,23 +314,23 @@ public:
                  ::std::function<void(bool)> sent = nullptr,
                  const ::Ice::Context& ctx = ::Ice::noExplicitContext)
     {
-        return makeLambdaOutgoing<::std::vector<::std::string>>(response, ex, sent, this, &ObjectPrx::iceI_ice_ids, ctx);
+        return makeLambdaOutgoing<::std::vector<::std::string>>(response, ex, sent, this, &ObjectPrx::__ice_ids, ctx);
     }
 
     template<template<typename> class P = std::promise> auto
     ice_idsAsync(const ::Ice::Context& ctx = ::Ice::noExplicitContext)
         -> decltype(std::declval<P<::std::vector<::std::string>>>().get_future())
     {
-        return makePromiseOutgoing<::std::vector<::std::string>, P>(false, this, &ObjectPrx::iceI_ice_ids, ctx);
+        return makePromiseOutgoing<::std::vector<::std::string>, P>(false, this, &ObjectPrx::__ice_ids, ctx);
     }
 
     void
-    iceI_ice_ids(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::vector<::std::string>>>&, const ::Ice::Context&);
+    __ice_ids(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::vector<::std::string>>>&, const ::Ice::Context&);
 
     ::std::string
     ice_id(const ::Ice::Context& ctx = ::Ice::noExplicitContext)
     {
-        return makePromiseOutgoing<::std::string>(true, this, &ObjectPrx::iceI_ice_id, ctx).get();
+        return makePromiseOutgoing<::std::string>(true, this, &ObjectPrx::__ice_id, ctx).get();
     }
 
     ::std::function<void()>
@@ -339,18 +339,18 @@ public:
                 ::std::function<void(bool)> sent = nullptr,
                 const ::Ice::Context& ctx = ::Ice::noExplicitContext)
     {
-        return makeLambdaOutgoing<::std::string>(response, ex, sent, this, &ObjectPrx::iceI_ice_id, ctx);
+        return makeLambdaOutgoing<::std::string>(response, ex, sent, this, &ObjectPrx::__ice_id, ctx);
     }
 
     template<template<typename> class P = std::promise>
     auto ice_idAsync(const ::Ice::Context& ctx = ::Ice::noExplicitContext)
         -> decltype(std::declval<P<::std::string>>().get_future())
     {
-        return makePromiseOutgoing<::std::string, P>(false, this, &ObjectPrx::iceI_ice_id, ctx);
+        return makePromiseOutgoing<::std::string, P>(false, this, &ObjectPrx::__ice_id, ctx);
     }
 
     void
-    iceI_ice_id(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::string>>&, const ::Ice::Context&);
+    __ice_id(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::string>>&, const ::Ice::Context&);
 
     static const ::std::string& ice_staticId()
     {
@@ -541,7 +541,7 @@ public:
     {
         using LambdaOutgoing = ::IceInternal::ProxyGetConnectionLambda;
         auto outAsync = ::std::make_shared<LambdaOutgoing>(shared_from_this(), response, ex, sent);
-        iceGetConnection(outAsync);
+        __ice_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());
-        iceGetConnection(outAsync);
+        __ice_getConnection(outAsync);
         return outAsync->getFuture();
     }
 
-    void iceGetConnection(const ::std::shared_ptr<::IceInternal::ProxyGetConnection>&);
+    void __ice_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);
-        iceI_ice_flushBatchRequests(outAsync);
+        __ice_flushBatchRequests(outAsync);
         return [outAsync]() { outAsync->cancel(); };
     }
 
@@ -578,29 +578,29 @@ public:
     {
         using PromiseOutgoing = ::IceInternal::ProxyFlushBatchPromise<P<bool>>;
         auto outAsync = ::std::make_shared<PromiseOutgoing>(shared_from_this());
-        iceI_ice_flushBatchRequests(outAsync);
+        __ice_flushBatchRequests(outAsync);
         return outAsync->getFuture();
     }
 
-    void iceI_ice_flushBatchRequests(const ::std::shared_ptr<::IceInternal::ProxyFlushBatchAsync>&);
+    void __ice_flushBatchRequests(const ::std::shared_ptr<::IceInternal::ProxyFlushBatchAsync>&);
 
-    const ::IceInternal::ReferencePtr& iceReference() const { return _reference; }
+    const ::IceInternal::ReferencePtr& __reference() const { return _reference; }
 
-    void iceCopyFrom(const std::shared_ptr<::Ice::ObjectPrx>&);
+    void __copyFrom(const std::shared_ptr<::Ice::ObjectPrx>&);
 
-    int iceHandleException(const ::Ice::Exception&, const ::IceInternal::RequestHandlerPtr&, ::Ice::OperationMode,
+    int __handleException(const ::Ice::Exception&, const ::IceInternal::RequestHandlerPtr&, ::Ice::OperationMode,
                           bool, int&);
 
-    void iceCheckTwowayOnly(const ::std::string&) const;
+    void __checkTwowayOnly(const ::std::string&) const;
 
-    ::IceInternal::RequestHandlerPtr iceGetRequestHandler();
-    ::IceInternal::BatchRequestQueuePtr iceGetBatchRequestQueue();
-    ::IceInternal::RequestHandlerPtr iceSetRequestHandler(const ::IceInternal::RequestHandlerPtr&);
-    void iceUpdateRequestHandler(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 iceHash() const;
+    int __hash() const;
 
-    void iceWrite(OutputStream&) const;
+    void __write(OutputStream&) const;
 
 protected:
 
@@ -621,7 +621,7 @@ protected:
         return [outAsync]() { outAsync->cancel(); };
     }
 
-    virtual ::std::shared_ptr<ObjectPrx> iceNewInstance() 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> iceNewInstance() 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->iceCopyFrom(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->iceCopyFrom(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->iceCopyFrom(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->iceCopyFrom(bb);
+                r->__copyFrom(bb);
             }
         }
         catch(const Ice::FacetNotExistException&)
@@ -964,20 +964,20 @@ public:
 
     bool ice_isA(const ::std::string& typeId, const ::Ice::Context& ctx = ::Ice::noExplicitContext)
     {
-        return end_ice_isA(iceI_begin_ice_isA(typeId, ctx, ::IceInternal::dummyCallback, 0, true));
+        return end_ice_isA(__begin_ice_isA(typeId, ctx, ::IceInternal::__dummyCallback, 0, true));
     }
 
     ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string& typeId,
                                         const ::Ice::Context& ctx = ::Ice::noExplicitContext)
     {
-        return iceI_begin_ice_isA(typeId, ctx, ::IceInternal::dummyCallback, 0);
+        return __begin_ice_isA(typeId, ctx, ::IceInternal::__dummyCallback, 0);
     }
 
     ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string& typeId,
                                         const ::Ice::CallbackPtr& del,
                                         const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_isA(typeId, ::Ice::noExplicitContext, del, cookie);
+        return __begin_ice_isA(typeId, ::Ice::noExplicitContext, del, cookie);
     }
 
     ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string& typeId,
@@ -985,14 +985,14 @@ public:
                                         const ::Ice::CallbackPtr& del,
                                         const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_isA(typeId, ctx, del, cookie);
+        return __begin_ice_isA(typeId, ctx, del, cookie);
     }
 
     ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string& typeId,
                                         const ::Ice::Callback_Object_ice_isAPtr& del,
                                         const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_isA(typeId, ::Ice::noExplicitContext, del, cookie);
+        return __begin_ice_isA(typeId, ::Ice::noExplicitContext, del, cookie);
     }
 
     ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string& typeId,
@@ -1000,119 +1000,119 @@ public:
                                         const ::Ice::Callback_Object_ice_isAPtr& del,
                                         const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_isA(typeId, ctx, del, cookie);
+        return __begin_ice_isA(typeId, ctx, del, cookie);
     }
 
     bool end_ice_isA(const ::Ice::AsyncResultPtr&);
 
     void ice_ping(const ::Ice::Context& ctx = ::Ice::noExplicitContext)
     {
-        end_ice_ping(iceI_begin_ice_ping(ctx, ::IceInternal::dummyCallback, 0, true));
+        end_ice_ping(__begin_ice_ping(ctx, ::IceInternal::__dummyCallback, 0, true));
     }
 
     ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::Context& ctx = ::Ice::noExplicitContext)
     {
-        return iceI_begin_ice_ping(ctx, ::IceInternal::dummyCallback, 0);
+        return __begin_ice_ping(ctx, ::IceInternal::__dummyCallback, 0);
     }
 
     ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_ping(::Ice::noExplicitContext, del, cookie);
+        return __begin_ice_ping(::Ice::noExplicitContext, del, cookie);
     }
 
     ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::Context& ctx, const ::Ice::CallbackPtr& del,
                                          const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_ping(ctx, del, cookie);
+        return __begin_ice_ping(ctx, del, cookie);
     }
 
 
     ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::Callback_Object_ice_pingPtr& del,
                                          const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_ping(::Ice::noExplicitContext, del, cookie);
+        return __begin_ice_ping(::Ice::noExplicitContext, del, cookie);
     }
 
     ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::Context& ctx, const ::Ice::Callback_Object_ice_pingPtr& del,
                                          const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_ping(ctx, del, cookie);
+        return __begin_ice_ping(ctx, del, cookie);
     }
 
     void end_ice_ping(const ::Ice::AsyncResultPtr&);
 
     ::std::vector< ::std::string> ice_ids(const ::Ice::Context& ctx = ::Ice::noExplicitContext)
     {
-        return end_ice_ids(iceI_begin_ice_ids(ctx, ::IceInternal::dummyCallback, 0, true));
+        return end_ice_ids(__begin_ice_ids(ctx, ::IceInternal::__dummyCallback, 0, true));
     }
 
     ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::Context& ctx = ::Ice::noExplicitContext)
     {
-        return iceI_begin_ice_ids(ctx, ::IceInternal::dummyCallback, 0);
+        return __begin_ice_ids(ctx, ::IceInternal::__dummyCallback, 0);
     }
 
     ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::CallbackPtr& del,
                                         const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_ids(::Ice::noExplicitContext, del, cookie);
+        return __begin_ice_ids(::Ice::noExplicitContext, del, cookie);
     }
 
     ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::Context& ctx,
                                         const ::Ice::CallbackPtr& del,
                                         const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_ids(ctx, del, cookie);
+        return __begin_ice_ids(ctx, del, cookie);
     }
 
     ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::Callback_Object_ice_idsPtr& del,
                                         const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_ids(::Ice::noExplicitContext, del, cookie);
+        return __begin_ice_ids(::Ice::noExplicitContext, del, cookie);
     }
 
     ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::Context& ctx,
                                         const ::Ice::Callback_Object_ice_idsPtr& del,
                                         const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_ids(ctx, del, cookie);
+        return __begin_ice_ids(ctx, del, cookie);
     }
 
     ::std::vector< ::std::string> end_ice_ids(const ::Ice::AsyncResultPtr&);
 
     ::std::string ice_id(const ::Ice::Context& ctx = ::Ice::noExplicitContext)
     {
-        return end_ice_id(iceI_begin_ice_id(ctx, ::IceInternal::dummyCallback, 0, true));
+        return end_ice_id(__begin_ice_id(ctx, ::IceInternal::__dummyCallback, 0, true));
     }
 
     ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::Context& ctx = ::Ice::noExplicitContext)
     {
-        return iceI_begin_ice_id(ctx, ::IceInternal::dummyCallback, 0);
+        return __begin_ice_id(ctx, ::IceInternal::__dummyCallback, 0);
     }
 
     ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::CallbackPtr& del,
                                        const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_id(::Ice::noExplicitContext, del, cookie);
+        return __begin_ice_id(::Ice::noExplicitContext, del, cookie);
     }
 
     ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::Context& ctx,
                                        const ::Ice::CallbackPtr& del,
                                        const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_id(ctx, del, cookie);
+        return __begin_ice_id(ctx, del, cookie);
     }
 
     ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::Callback_Object_ice_idPtr& del,
                                        const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_id(::Ice::noExplicitContext, del, cookie);
+        return __begin_ice_id(::Ice::noExplicitContext, del, cookie);
     }
 
     ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::Context& ctx,
                                        const ::Ice::Callback_Object_ice_idPtr& del,
                                        const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_id(ctx, del, cookie);
+        return __begin_ice_id(ctx, del, cookie);
     }
 
     ::std::string end_ice_id(const ::Ice::AsyncResultPtr&);
@@ -1134,7 +1134,7 @@ public:
                                            ::Ice::OperationMode mode,
                                            const ::std::vector< ::Ice::Byte>& inParams)
     {
-        return iceI_begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, ::IceInternal::dummyCallback, 0);
+        return __begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, ::IceInternal::__dummyCallback, 0);
     }
 
     ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op,
@@ -1142,7 +1142,7 @@ public:
                                            const ::std::vector< ::Ice::Byte>& inParams,
                                            const ::Ice::Context& ctx)
     {
-        return iceI_begin_ice_invoke(op, mode, inParams, ctx, ::IceInternal::dummyCallback, 0);
+        return __begin_ice_invoke(op, mode, inParams, ctx, ::IceInternal::__dummyCallback, 0);
     }
 
     ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op,
@@ -1151,7 +1151,7 @@ public:
                                            const ::Ice::CallbackPtr& del,
                                            const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie);
+        return __begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie);
     }
 
     ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op,
@@ -1161,7 +1161,7 @@ public:
                                            const ::Ice::CallbackPtr& del,
                                            const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_invoke(op, mode, inParams, ctx, del, cookie);
+        return __begin_ice_invoke(op, mode, inParams, ctx, del, cookie);
     }
 
     ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op,
@@ -1170,7 +1170,7 @@ public:
                                            const ::Ice::Callback_Object_ice_invokePtr& del,
                                            const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie);
+        return __begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie);
     }
 
     ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op,
@@ -1180,7 +1180,7 @@ public:
                                            const ::Ice::Callback_Object_ice_invokePtr& del,
                                            const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_invoke(op, mode, inParams, ctx, del, cookie);
+        return __begin_ice_invoke(op, mode, inParams, ctx, del, cookie);
     }
 
     bool end_ice_invoke(::std::vector< ::Ice::Byte>&, const ::Ice::AsyncResultPtr&);
@@ -1191,14 +1191,14 @@ public:
                     ::std::vector< ::Ice::Byte>& outP,
                     const ::Ice::Context& ctx = ::Ice::noExplicitContext)
     {
-        return end_ice_invoke(outP, iceI_begin_ice_invoke(op, mode, inP, ctx, ::IceInternal::dummyCallback, 0, true));
+        return end_ice_invoke(outP, __begin_ice_invoke(op, mode, inP, ctx, ::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 iceI_begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, ::IceInternal::dummyCallback, 0);
+        return __begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, ::IceInternal::__dummyCallback, 0);
     }
 
     ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op,
@@ -1207,7 +1207,7 @@ public:
                                            const ::Ice::Context& ctx,
                                            const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_invoke(op, mode, inParams, ctx, ::IceInternal::dummyCallback, cookie);
+        return __begin_ice_invoke(op, mode, inParams, ctx, ::IceInternal::__dummyCallback, cookie);
     }
 
     ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op,
@@ -1216,7 +1216,7 @@ public:
                                            const ::Ice::CallbackPtr& del,
                                            const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie);
+        return __begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie);
     }
 
     ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op,
@@ -1226,7 +1226,7 @@ public:
                                            const ::Ice::CallbackPtr& del,
                                            const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_invoke(op, mode, inParams, ctx, del, cookie);
+        return __begin_ice_invoke(op, mode, inParams, ctx, del, cookie);
     }
 
     ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op,
@@ -1235,7 +1235,7 @@ public:
                                            const ::Ice::Callback_Object_ice_invokePtr& del,
                                            const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie);
+        return __begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie);
     }
 
     ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op,
@@ -1245,10 +1245,10 @@ public:
                                            const ::Ice::Callback_Object_ice_invokePtr& del,
                                            const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_invoke(op, mode, inParams, ctx, del, cookie);
+        return __begin_ice_invoke(op, mode, inParams, ctx, del, cookie);
     }
 
-    bool iceI_end_ice_invoke(::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&, const ::Ice::AsyncResultPtr&);
+    bool ___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 iceI_begin_ice_getConnection(::IceInternal::dummyCallback, 0);
+        return __begin_ice_getConnection(::IceInternal::__dummyCallback, 0);
     }
 
     ::Ice::AsyncResultPtr begin_ice_getConnection(const ::Ice::CallbackPtr& del,
                                                   const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_getConnection(del, cookie);
+        return __begin_ice_getConnection(del, cookie);
     }
 
     ::Ice::AsyncResultPtr begin_ice_getConnection(const ::Ice::Callback_Object_ice_getConnectionPtr& del,
                                                   const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_getConnection(del, cookie);
+        return __begin_ice_getConnection(del, cookie);
     }
 
     ::Ice::ConnectionPtr end_ice_getConnection(const ::Ice::AsyncResultPtr&);
@@ -1345,71 +1345,71 @@ public:
 
     ::Ice::AsyncResultPtr begin_ice_flushBatchRequests()
     {
-        return iceI_begin_ice_flushBatchRequests(::IceInternal::dummyCallback, 0);
+        return __begin_ice_flushBatchRequests(::IceInternal::__dummyCallback, 0);
     }
 
     ::Ice::AsyncResultPtr begin_ice_flushBatchRequests(const ::Ice::CallbackPtr& del,
                                                        const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_flushBatchRequests(del, cookie);
+        return __begin_ice_flushBatchRequests(del, cookie);
     }
 
     ::Ice::AsyncResultPtr begin_ice_flushBatchRequests(const ::Ice::Callback_Object_ice_flushBatchRequestsPtr& del,
                                                        const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return iceI_begin_ice_flushBatchRequests(del, cookie);
+        return __begin_ice_flushBatchRequests(del, cookie);
     }
 
     void end_ice_flushBatchRequests(const ::Ice::AsyncResultPtr&);
 
-    const ::IceInternal::ReferencePtr& iceReference() const { return _reference; }
+    const ::IceInternal::ReferencePtr& __reference() const { return _reference; }
 
-    ::Ice::Int iceHash() const;
+    ::Ice::Int __hash() const;
 
-    void iceCopyFrom(const ::Ice::ObjectPrx&);
+    void __copyFrom(const ::Ice::ObjectPrx&);
 
-    int iceHandleException(const ::Ice::Exception&, const ::IceInternal::RequestHandlerPtr&, ::Ice::OperationMode,
+    int __handleException(const ::Ice::Exception&, const ::IceInternal::RequestHandlerPtr&, ::Ice::OperationMode,
                           bool, int&);
 
-    void iceCheckTwowayOnly(const ::std::string&, bool) const;
+    void __checkTwowayOnly(const ::std::string&, bool) const;
 
-    void iceEnd(const ::Ice::AsyncResultPtr&, const std::string&) const;
+    void __end(const ::Ice::AsyncResultPtr&, const std::string&) const;
 
-    ::IceInternal::RequestHandlerPtr iceGetRequestHandler();
-    ::IceInternal::BatchRequestQueuePtr iceGetBatchRequestQueue();
-    ::IceInternal::RequestHandlerPtr iceSetRequestHandler(const ::IceInternal::RequestHandlerPtr&);
-    void iceUpdateRequestHandler(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 iceWrite(::Ice::OutputStream&) const;
+    void __write(::Ice::OutputStream&) const;
 
 protected:
 
-    virtual Object* iceNewInstance() const;
+    virtual Object* __newInstance() const;
 
 private:
 
-    ::Ice::AsyncResultPtr iceI_begin_ice_isA(const ::std::string&,
+    ::Ice::AsyncResultPtr __begin_ice_isA(const ::std::string&,
                                           const ::Ice::Context&,
                                           const ::IceInternal::CallbackBasePtr&,
                                           const ::Ice::LocalObjectPtr&,
                                           bool = false);
 
-    ::Ice::AsyncResultPtr iceI_begin_ice_ping(const ::Ice::Context&,
+    ::Ice::AsyncResultPtr __begin_ice_ping(const ::Ice::Context&,
                                            const ::IceInternal::CallbackBasePtr&,
                                            const ::Ice::LocalObjectPtr&,
                                            bool = false);
 
-    ::Ice::AsyncResultPtr iceI_begin_ice_ids(const ::Ice::Context&,
+    ::Ice::AsyncResultPtr __begin_ice_ids(const ::Ice::Context&,
                                           const ::IceInternal::CallbackBasePtr&,
                                           const ::Ice::LocalObjectPtr&,
                                           bool = false);
 
-    ::Ice::AsyncResultPtr iceI_begin_ice_id(const ::Ice::Context&,
+    ::Ice::AsyncResultPtr __begin_ice_id(const ::Ice::Context&,
                                          const ::IceInternal::CallbackBasePtr&,
                                          const ::Ice::LocalObjectPtr&,
                                          bool = false);
 
-    ::Ice::AsyncResultPtr iceI_begin_ice_invoke(const ::std::string&,
+    ::Ice::AsyncResultPtr __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 iceI_begin_ice_invoke(const ::std::string&,
+    ::Ice::AsyncResultPtr __begin_ice_invoke(const ::std::string&,
                                              ::Ice::OperationMode,
                                              const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&,
                                              const ::Ice::Context&,
@@ -1425,11 +1425,11 @@ private:
                                              const ::Ice::LocalObjectPtr&,
                                              bool = false);
 
-    ::Ice::AsyncResultPtr iceI_begin_ice_getConnection(const ::IceInternal::CallbackBasePtr&,
-                                                       const ::Ice::LocalObjectPtr&);
+    ::Ice::AsyncResultPtr __begin_ice_getConnection(const ::IceInternal::CallbackBasePtr&,
+                                                    const ::Ice::LocalObjectPtr&);
 
-    ::Ice::AsyncResultPtr iceI_begin_ice_flushBatchRequests(const ::IceInternal::CallbackBasePtr&,
-                                                            const ::Ice::LocalObjectPtr&);
+    ::Ice::AsyncResultPtr __begin_ice_flushBatchRequests(const ::IceInternal::CallbackBasePtr&,
+                                                         const ::Ice::LocalObjectPtr&);
 
     void setup(const ::IceInternal::ReferencePtr&);
     friend class ::IceInternal::ProxyFactory;
@@ -1559,7 +1559,7 @@ public:
 
 protected:
 
-    virtual ::IceProxy::Ice::Object* iceNewInstance() 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.iceUpCast();
-    ::IceProxy::Ice::Object* r = rhs.iceUpCast();
+    ::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.iceUpCast();
-    ::IceProxy::Ice::Object* r = rhs.iceUpCast();
+    ::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->iceCopyFrom(b);
+            d->__copyFrom(b);
         }
     }
     return d;
@@ -1695,7 +1695,7 @@ uncheckedCastImpl(const ::Ice::ObjectPrx& b)
         if(!d)
         {
             d = new T;
-            d->iceCopyFrom(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->iceCopyFrom(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->iceCopyFrom(bb);
+        d->__copyFrom(bb);
     }
     return d;
 }
@@ -1977,7 +1977,7 @@ public:
     {
         try
         {
-            result->getProxy()->iceEnd(result, result->getOperation());
+            result->getProxy()->__end(result, result->getOperation());
         }
         catch(const ::Ice::Exception& ex)
         {
@@ -2016,7 +2016,7 @@ public:
     {
         try
         {
-            result->getProxy()->iceEnd(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& iceResult) const
+    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
     {
-        bool iceRet;
+        bool __ret;
         try
         {
-            iceRet = iceResult->getProxy()->end_ice_isA(iceResult);
+            __ret = __result->getProxy()->end_ice_isA(__result);
         }
         catch(const ::Ice::Exception& ex)
         {
-            ::IceInternal::CallbackNC<T>::exception(iceResult, ex);
+            ::IceInternal::CallbackNC<T>::exception(__result, ex);
             return;
         }
         if(_response)
         {
-            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(iceRet);
+            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(__ret);
         }
     }
 
@@ -2094,22 +2094,22 @@ public:
     {
     }
 
-    virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const
+    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
     {
-        bool iceRet;
+        bool __ret;
         try
         {
-            iceRet = iceResult->getProxy()->end_ice_isA(iceResult);
+            __ret = __result->getProxy()->end_ice_isA(__result);
         }
         catch(const ::Ice::Exception& ex)
         {
-            ::IceInternal::Callback<T, CT>::exception(iceResult, ex);
+            ::IceInternal::Callback<T, CT>::exception(__result, ex);
             return;
         }
         if(_response)
         {
-            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(iceRet,
-                                                                          CT::dynamicCast(iceResult->getCookie()));
+            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(__ret,
+                                                                          CT::dynamicCast(__result->getCookie()));
         }
     }
 
@@ -2168,21 +2168,21 @@ public:
     {
     }
 
-    virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const
+    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
     {
-        ::std::vector< ::std::string> iceRet;
+        ::std::vector< ::std::string> __ret;
         try
         {
-            iceRet = iceResult->getProxy()->end_ice_ids(iceResult);
+            __ret = __result->getProxy()->end_ice_ids(__result);
         }
         catch(const ::Ice::Exception& ex)
         {
-            ::IceInternal::CallbackNC<T>::exception(iceResult, ex);
+            ::IceInternal::CallbackNC<T>::exception(__result, ex);
             return;
         }
         if(_response)
         {
-            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(iceRet);
+            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(__ret);
         }
     }
 
@@ -2207,22 +2207,22 @@ public:
     {
     }
 
-    virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const
+    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
     {
-        ::std::vector< ::std::string> iceRet;
+        ::std::vector< ::std::string> __ret;
         try
         {
-            iceRet = iceResult->getProxy()->end_ice_ids(iceResult);
+            __ret = __result->getProxy()->end_ice_ids(__result);
         }
         catch(const ::Ice::Exception& ex)
         {
-            ::IceInternal::Callback<T, CT>::exception(iceResult, ex);
+            ::IceInternal::Callback<T, CT>::exception(__result, ex);
             return;
         }
         if(_response)
         {
-            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(iceRet,
-                                                                          CT::dynamicCast(iceResult->getCookie()));
+            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(__ret,
+                                                                          CT::dynamicCast(__result->getCookie()));
         }
     }
 
@@ -2247,21 +2247,21 @@ public:
     {
     }
 
-    virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const
+    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
     {
-        ::std::string iceRet;
+        ::std::string __ret;
         try
         {
-            iceRet = iceResult->getProxy()->end_ice_id(iceResult);
+            __ret = __result->getProxy()->end_ice_id(__result);
         }
         catch(const ::Ice::Exception& ex)
         {
-            ::IceInternal::CallbackNC<T>::exception(iceResult, ex);
+            ::IceInternal::CallbackNC<T>::exception(__result, ex);
             return;
         }
         if(_response)
         {
-            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(iceRet);
+            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(__ret);
         }
     }
 
@@ -2286,22 +2286,22 @@ public:
     {
     }
 
-    virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const
+    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
     {
-        ::std::string iceRet;
+        ::std::string __ret;
         try
         {
-            iceRet = iceResult->getProxy()->end_ice_id(iceResult);
+            __ret = __result->getProxy()->end_ice_id(__result);
         }
         catch(const ::Ice::Exception& ex)
         {
-            ::IceInternal::Callback<T, CT>::exception(iceResult, ex);
+            ::IceInternal::Callback<T, CT>::exception(__result, ex);
             return;
         }
         if(_response)
         {
-            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(iceRet,
-                                                                          CT::dynamicCast(iceResult->getCookie()));
+            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(__ret,
+                                                                          CT::dynamicCast(__result->getCookie()));
         }
     }
 
@@ -2332,39 +2332,39 @@ public:
     {
     }
 
-    virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const
+    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
     {
         if(_response)
         {
-            bool iceOk;
+            bool __ok;
             std::vector< ::Ice::Byte> outParams;
             try
             {
-                iceOk = iceResult->getProxy()->end_ice_invoke(outParams, iceResult);
+                __ok = __result->getProxy()->end_ice_invoke(outParams, __result);
             }
             catch(const ::Ice::Exception& ex)
             {
-                ::IceInternal::CallbackNC<T>::exception(iceResult, ex);
+                ::IceInternal::CallbackNC<T>::exception(__result, ex);
                 return;
             }
-            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(iceOk, outParams);
+            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(__ok, outParams);
         }
         else
         {
-            bool iceOk;
+            bool __ok;
             std::pair<const ::Ice::Byte*, const::Ice::Byte*> outParams;
             try
             {
-                iceOk = iceResult->getProxy()->iceI_end_ice_invoke(outParams, iceResult);
+                __ok = __result->getProxy()->___end_ice_invoke(outParams, __result);
             }
             catch(const ::Ice::Exception& ex)
             {
-                ::IceInternal::CallbackNC<T>::exception(iceResult, ex);
+                ::IceInternal::CallbackNC<T>::exception(__result, ex);
                 return;
             }
             if(_responseArray)
             {
-                (::IceInternal::CallbackNC<T>::_callback.get()->*_responseArray)(iceOk, outParams);
+                (::IceInternal::CallbackNC<T>::_callback.get()->*_responseArray)(__ok, outParams);
             }
         }
     }
@@ -2397,44 +2397,44 @@ public:
     {
     }
 
-    virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const
+    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
     {
         if(_response)
         {
-            bool iceOk;
+            bool __ok;
             std::vector< ::Ice::Byte> outParams;
             try
             {
-                iceOk = iceResult->getProxy()->end_ice_invoke(outParams, iceResult);
+                __ok = __result->getProxy()->end_ice_invoke(outParams, __result);
             }
             catch(const ::Ice::Exception& ex)
             {
-                ::IceInternal::Callback<T, CT>::exception(iceResult, ex);
+                ::IceInternal::Callback<T, CT>::exception(__result, ex);
                 return;
             }
-            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(iceOk,
+            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(__ok,
                                                                           outParams,
-                                                                          CT::dynamicCast(iceResult->getCookie()));
+                                                                          CT::dynamicCast(__result->getCookie()));
         }
         else
         {
-            bool iceOk;
+            bool __ok;
             std::pair<const ::Ice::Byte*, const::Ice::Byte*> outParams;
             try
             {
-                iceOk = iceResult->getProxy()->iceI_end_ice_invoke(outParams, iceResult);
+                __ok = __result->getProxy()->___end_ice_invoke(outParams, __result);
             }
             catch(const ::Ice::Exception& ex)
             {
-                ::IceInternal::Callback<T, CT>::exception(iceResult, ex);
+                ::IceInternal::Callback<T, CT>::exception(__result, ex);
                 return;
             }
             if(_responseArray)
             {
-                (::IceInternal::Callback<T, CT>::_callback.get()->*_responseArray)(iceOk,
+                (::IceInternal::Callback<T, CT>::_callback.get()->*_responseArray)(__ok,
                                                                                    outParams,
                                                                                    CT::dynamicCast(
-                                                                                       iceResult->getCookie()));
+                                                                                       __result->getCookie()));
             }
         }
     }
@@ -2463,21 +2463,21 @@ public:
     }
 
 
-    virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const
+    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
     {
-        ::Ice::ConnectionPtr iceRet;
+        ::Ice::ConnectionPtr __ret;
         try
         {
-            iceRet = iceResult->getProxy()->end_ice_getConnection(iceResult);
+            __ret = __result->getProxy()->end_ice_getConnection(__result);
         }
         catch(const ::Ice::Exception& ex)
         {
-            ::IceInternal::CallbackNC<T>::exception(iceResult, ex);
+            ::IceInternal::CallbackNC<T>::exception(__result, ex);
             return;
         }
         if(_response)
         {
-            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(iceRet);
+            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(__ret);
         }
     }
 
@@ -2503,22 +2503,22 @@ public:
     {
     }
 
-    virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const
+    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
     {
-        ::Ice::ConnectionPtr iceRet;
+        ::Ice::ConnectionPtr __ret;
         try
         {
-            iceRet = iceResult->getProxy()->end_ice_getConnection(iceResult);
+            __ret = __result->getProxy()->end_ice_getConnection(__result);
         }
         catch(const ::Ice::Exception& ex)
         {
-            ::IceInternal::Callback<T, CT>::exception(iceResult, ex);
+            ::IceInternal::Callback<T, CT>::exception(__result, ex);
             return;
         }
         if(_response)
         {
-            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(iceRet,
-                                                                          CT::dynamicCast(iceResult->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 0e39dfa9ef6..628fb2b460b 100644
--- a/cpp/include/Ice/ProxyHandle.h
+++ b/cpp/include/Ice/ProxyHandle.h
@@ -125,7 +125,7 @@ public:
 
         if(this->_ptr)
         {
-            upCast(this->_ptr)->iceIncRef();
+            upCast(this->_ptr)->__incRef();
         }
     }
 
@@ -136,7 +136,7 @@ public:
 
         if(this->_ptr)
         {
-            upCast(this->_ptr)->iceIncRef();
+            upCast(this->_ptr)->__incRef();
         }
     }
 
@@ -147,7 +147,7 @@ public:
 
         if(this->_ptr)
         {
-            upCast(this->_ptr)->iceIncRef();
+            upCast(this->_ptr)->__incRef();
         }
     }
 
@@ -157,7 +157,7 @@ public:
 
         if(this->_ptr)
         {
-            upCast(this->_ptr)->iceIncRef();
+            upCast(this->_ptr)->__incRef();
         }
     }
 
@@ -165,7 +165,7 @@ public:
     {
         if(this->_ptr)
         {
-            upCast(this->_ptr)->iceDecRef();
+            upCast(this->_ptr)->__decRef();
         }
     }
 
@@ -175,12 +175,12 @@ public:
         {
             if(p)
             {
-                upCast(p)->iceIncRef();
+                upCast(p)->__incRef();
             }
 
             if(this->_ptr)
             {
-                upCast(this->_ptr)->iceDecRef();
+                upCast(this->_ptr)->__decRef();
             }
 
             this->_ptr = p;
@@ -195,12 +195,12 @@ public:
         {
             if(r._ptr)
             {
-                upCast(r._ptr)->iceIncRef();
+                upCast(r._ptr)->__incRef();
             }
 
             if(this->_ptr)
             {
-                upCast(this->_ptr)->iceDecRef();
+                upCast(this->_ptr)->__decRef();
             }
 
             this->_ptr = r._ptr;
@@ -215,12 +215,12 @@ public:
         {
             if(r._ptr)
             {
-                upCast(r._ptr)->iceIncRef();
+                upCast(r._ptr)->__incRef();
             }
 
             if(this->_ptr)
             {
-                upCast(this->_ptr)->iceDecRef();
+                upCast(this->_ptr)->__decRef();
             }
 
             this->_ptr = r._ptr;
@@ -234,12 +234,12 @@ public:
         {
             if(r._ptr)
             {
-                upCast(r._ptr)->iceIncRef();
+                upCast(r._ptr)->__incRef();
             }
 
             if(this->_ptr)
             {
-                upCast(this->_ptr)->iceDecRef();
+                upCast(this->_ptr)->__decRef();
             }
 
             this->_ptr = r._ptr;
@@ -247,7 +247,7 @@ public:
         return *this;
     }
 
-    ::IceProxy::Ice::Object* iceUpCast() 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 beb09947d90..dcd322b661b 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 iceGcVisitMembers(IceInternal::GCVisitor&);
+    void __gcVisitMembers(IceInternal::GCVisitor&);
 #endif
 };
 
@@ -97,8 +97,8 @@ public:
     SlicedDataPtr getSlicedData() const;
 
 #ifdef ICE_CPP11_MAPPING
-    virtual void iceWrite(::Ice::OutputStream*) const override;
-    virtual void iceRead(::Ice::InputStream*) override;
+    virtual void __write(::Ice::OutputStream*) const override;
+    virtual void __read(::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 iceGcVisitMembers(IceInternal::GCVisitor&);
+    virtual void __gcVisitMembers(IceInternal::GCVisitor&);
 
-    virtual void iceWrite(::Ice::OutputStream*) const;
-    virtual void iceRead(::Ice::InputStream*);
+    virtual void __write(::Ice::OutputStream*) const;
+    virtual void __read(::Ice::InputStream*);
 #endif
 
 private:
diff --git a/cpp/include/Ice/Value.h b/cpp/include/Ice/Value.h
index 5801c195913..b2c4b4f2b57 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 iceWrite(Ice::OutputStream*) const;
-    virtual void iceRead(Ice::InputStream*);
+    virtual void __write(Ice::OutputStream*) const;
+    virtual void __read(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 iceWriteImpl(Ice::OutputStream*) const {}
-    virtual void iceReadImpl(Ice::InputStream*) {}
+    virtual void __writeImpl(Ice::OutputStream*) const {}
+    virtual void __readImpl(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 iceWriteImpl(Ice::OutputStream* os) const override
+    virtual void __writeImpl(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::iceWriteImpl(os);
+        Base::__writeImpl(os);
     }
 
-    virtual void iceReadImpl(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();
-        Base::iceReadImpl(is);
+        Base::__readImpl(is);
     }
 };
 
diff --git a/cpp/include/IceUtil/Handle.h b/cpp/include/IceUtil/Handle.h
index 19991681cbc..91a58be60f0 100644
--- a/cpp/include/IceUtil/Handle.h
+++ b/cpp/include/IceUtil/Handle.h
@@ -154,7 +154,7 @@ public:
 
         if(this->_ptr)
         {
-            this->_ptr->iceIncRef();
+            this->_ptr->__incRef();
         }
     }
     
@@ -165,7 +165,7 @@ public:
 
         if(this->_ptr)
         {
-            this->_ptr->iceIncRef();
+            this->_ptr->__incRef();
         }
     }
 
@@ -175,7 +175,7 @@ public:
 
         if(this->_ptr)
         {
-            this->_ptr->iceIncRef();
+            this->_ptr->__incRef();
         }
     }
     
@@ -183,7 +183,7 @@ public:
     {
         if(this->_ptr)
         {
-            this->_ptr->iceDecRef();
+            this->_ptr->__decRef();
         }
     }
     
@@ -193,7 +193,7 @@ public:
         {
             if(p)
             {
-                p->iceIncRef();
+                p->__incRef();
             }
 
             T* ptr = this->_ptr;
@@ -201,7 +201,7 @@ public:
 
             if(ptr)
             {
-                ptr->iceDecRef();
+                ptr->__decRef();
             }
         }
         return *this;
@@ -214,7 +214,7 @@ public:
         {
             if(r._ptr)
             {
-                r._ptr->iceIncRef();
+                r._ptr->__incRef();
             }
 
             T* ptr = this->_ptr;
@@ -222,7 +222,7 @@ public:
 
             if(ptr)
             {
-                ptr->iceDecRef();
+                ptr->__decRef();
             }
         }
         return *this;
@@ -234,7 +234,7 @@ public:
         {
             if(r._ptr)
             {
-                r._ptr->iceIncRef();
+                r._ptr->__incRef();
             }
 
             T* ptr = this->_ptr;
@@ -242,7 +242,7 @@ public:
 
             if(ptr)
             {
-                ptr->iceDecRef();
+                ptr->__decRef();
             }
         }
         return *this;
diff --git a/cpp/include/IceUtil/Optional.h b/cpp/include/IceUtil/Optional.h
index c7edf344ee8..60493e30fe3 100644
--- a/cpp/include/IceUtil/Optional.h
+++ b/cpp/include/IceUtil/Optional.h
@@ -143,7 +143,7 @@ public:
         std::swap(_value, other._value);
     }
 
-    void iceSetIsSet()
+    void __setIsSet()
     {
         _isSet = true;
     }
diff --git a/cpp/include/IceUtil/Shared.h b/cpp/include/IceUtil/Shared.h
index b9971c3d855..756b10e5f22 100644
--- a/cpp/include/IceUtil/Shared.h
+++ b/cpp/include/IceUtil/Shared.h
@@ -45,13 +45,13 @@ public:
         return *this;
     }
 
-    void iceIncRef()
+    void __incRef()
     {
         assert(_ref >= 0);
         ++_ref;
     }
 
-    void iceDecRef()
+    void __decRef()
     {
         assert(_ref > 0);
         if(--_ref == 0)
@@ -63,12 +63,12 @@ public:
         }
     }
 
-    int iceGetRef() const
+    int __getRef() const
     {
         return _ref;
     }
 
-    void iceSetNoDelete(bool b)
+    void __setNoDelete(bool b)
     {
         _noDelete = b;
     }
@@ -101,22 +101,22 @@ public:
         return *this;
     }
 
-    virtual void iceIncRef();
-    virtual void iceDecRef();
-    virtual int iceGetRef() const;
-    virtual void iceSetNoDelete(bool);
+    virtual void __incRef();
+    virtual void __decRef();
+    virtual int __getRef() const;
+    virtual void __setNoDelete(bool);
 
-    void iceSetFlag(unsigned char flag)
+    void __setFlag(unsigned char flag)
     {
         _flags |= flag;
     }
 
-    void iceClearFlag(unsigned char flag)
+    void __clearFlag(unsigned char flag)
     {
         _flags &= ~flag;
     }
 
-    bool iceHasFlag(unsigned char flag)
+    bool __hasFlag(unsigned char flag)
     {
         return (_flags & flag) > 0;
     }
diff --git a/cpp/src/Glacier2/SessionRouterI.cpp b/cpp/src/Glacier2/SessionRouterI.cpp
index e494f88839a..9f774b79a8e 100644
--- a/cpp/src/Glacier2/SessionRouterI.cpp
+++ b/cpp/src/Glacier2/SessionRouterI.cpp
@@ -678,7 +678,7 @@ SessionRouterI::SessionRouterI(const InstancePtr& instance,
 {
     if(_sessionThread)
     {
-        iceSetNoDelete(true);
+        __setNoDelete(true);
         try
         {
             _sessionThread->start();
@@ -687,10 +687,10 @@ SessionRouterI::SessionRouterI(const InstancePtr& instance,
         {
             _sessionThread->destroy();
             _sessionThread = 0;
-            iceSetNoDelete(false);
+            __setNoDelete(false);
             throw;
         }
-        iceSetNoDelete(false);
+        __setNoDelete(false);
     }
 
     try
diff --git a/cpp/src/Ice/AsyncResult.cpp b/cpp/src/Ice/AsyncResult.cpp
index 42e58e945f7..60e5ac65773 100644
--- a/cpp/src/Ice/AsyncResult.cpp
+++ b/cpp/src/Ice/AsyncResult.cpp
@@ -24,9 +24,9 @@ AsyncResult::~AsyncResult()
 }
 
 void
-AsyncResult::iceCheck(const AsyncResultPtr& r, const IceProxy::Ice::Object* prx, const string& operation)
+AsyncResult::__check(const AsyncResultPtr& r, const IceProxy::Ice::Object* prx, const string& operation)
 {
-    iceCheck(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::iceCheck(const AsyncResultPtr& r, const IceProxy::Ice::Object* prx,
 }
 
 void
-AsyncResult::iceCheck(const AsyncResultPtr& r, const Ice::Communicator* com, const string& operation)
+AsyncResult::__check(const AsyncResultPtr& r, const Ice::Communicator* com, const string& operation)
 {
-    iceCheck(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::iceCheck(const AsyncResultPtr& r, const Ice::Communicator* com, con
 }
 
 void
-AsyncResult::iceCheck(const AsyncResultPtr& r, const Ice::Connection* con, const string& operation)
+AsyncResult::__check(const AsyncResultPtr& r, const Ice::Connection* con, const string& operation)
 {
-    iceCheck(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::iceCheck(const AsyncResultPtr& r, const Ice::Connection* con, const
 }
 
 void
-AsyncResult::iceCheck(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 3c69a86bbc2..99c332f629e 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 iceC_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(iceC_flushBatchRequests_name);
+    outAsync->invoke(__flushBatchRequests_name);
     return [outAsync]() { outAsync->cancel(); };
 }
 
@@ -245,24 +245,24 @@ Ice::CommunicatorI::flushBatchRequests()
 AsyncResultPtr
 Ice::CommunicatorI::begin_flushBatchRequests()
 {
-    return iceI_begin_flushBatchRequests(::IceInternal::dummyCallback, 0);
+    return __begin_flushBatchRequests(::IceInternal::__dummyCallback, 0);
 }
 
 AsyncResultPtr
 Ice::CommunicatorI::begin_flushBatchRequests(const CallbackPtr& cb, const LocalObjectPtr& cookie)
 {
-    return iceI_begin_flushBatchRequests(cb, cookie);
+    return __begin_flushBatchRequests(cb, cookie);
 }
 
 AsyncResultPtr
 Ice::CommunicatorI::begin_flushBatchRequests(const Callback_Communicator_flushBatchRequestsPtr& cb,
                                              const LocalObjectPtr& cookie)
 {
-    return iceI_begin_flushBatchRequests(cb, cookie);
+    return __begin_flushBatchRequests(cb, cookie);
 }
 
 AsyncResultPtr
-Ice::CommunicatorI::iceI_begin_flushBatchRequests(const IceInternal::CallbackBasePtr& cb, const LocalObjectPtr& cookie)
+Ice::CommunicatorI::__begin_flushBatchRequests(const IceInternal::CallbackBasePtr& cb, const LocalObjectPtr& cookie)
 {
     class CommunicatorFlushBatchAsyncWithCallback : public CommunicatorFlushBatchAsync, public CallbackCompletion
     {
@@ -285,7 +285,7 @@ Ice::CommunicatorI::iceI_begin_flushBatchRequests(const IceInternal::CallbackBas
         virtual const std::string&
         getOperation() const
         {
-            return iceC_flushBatchRequests_name;
+            return __flushBatchRequests_name;
         }
 
     private:
@@ -294,15 +294,15 @@ Ice::CommunicatorI::iceI_begin_flushBatchRequests(const IceInternal::CallbackBas
     };
 
     CommunicatorFlushBatchAsyncPtr result = new CommunicatorFlushBatchAsyncWithCallback(this, _instance, cb, cookie);
-    result->invoke(iceC_flushBatchRequests_name);
+    result->invoke(__flushBatchRequests_name);
     return result;
 }
 
 void
 Ice::CommunicatorI::end_flushBatchRequests(const AsyncResultPtr& r)
 {
-    AsyncResult::iceCheck(r, this, iceC_flushBatchRequests_name);
-    r->iceWait();
+    AsyncResult::__check(r, this, __flushBatchRequests_name);
+    r->__wait();
 }
 #endif
 
diff --git a/cpp/src/Ice/CommunicatorI.h b/cpp/src/Ice/CommunicatorI.h
index 7ba37267523..e75037bf72b 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 iceI_begin_flushBatchRequests(const IceInternal::CallbackBasePtr&, const LocalObjectPtr&);
+    AsyncResultPtr __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 7bfd9aaf265..f68ec2c0770 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)->iceUpdateRequestHandler(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 75d40c3609b..ce042d87ba5 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 iceC_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(iceC_flushBatchRequests_name);
+    outAsync->invoke(__flushBatchRequests_name);
     return [outAsync]() { outAsync->cancel(); };
 }
 #else
@@ -731,24 +731,24 @@ Ice::ConnectionI::flushBatchRequests()
 AsyncResultPtr
 Ice::ConnectionI::begin_flushBatchRequests()
 {
-    return iceI_begin_flushBatchRequests(dummyCallback, 0);
+    return __begin_flushBatchRequests(__dummyCallback, 0);
 }
 
 AsyncResultPtr
 Ice::ConnectionI::begin_flushBatchRequests(const CallbackPtr& cb, const LocalObjectPtr& cookie)
 {
-    return iceI_begin_flushBatchRequests(cb, cookie);
+    return __begin_flushBatchRequests(cb, cookie);
 }
 
 AsyncResultPtr
 Ice::ConnectionI::begin_flushBatchRequests(const Callback_Connection_flushBatchRequestsPtr& cb,
                                            const LocalObjectPtr& cookie)
 {
-    return iceI_begin_flushBatchRequests(cb, cookie);
+    return __begin_flushBatchRequests(cb, cookie);
 }
 
 AsyncResultPtr
-Ice::ConnectionI::iceI_begin_flushBatchRequests(const CallbackBasePtr& cb, const LocalObjectPtr& cookie)
+Ice::ConnectionI::__begin_flushBatchRequests(const CallbackBasePtr& cb, const LocalObjectPtr& cookie)
 {
     class ConnectionFlushBatchAsyncWithCallback : public ConnectionFlushBatchAsync, public CallbackCompletion
     {
@@ -780,7 +780,7 @@ Ice::ConnectionI::iceI_begin_flushBatchRequests(const CallbackBasePtr& cb, const
         virtual const std::string&
         getOperation() const
         {
-            return iceC_flushBatchRequests_name;
+            return __flushBatchRequests_name;
         }
 
     private:
@@ -790,15 +790,15 @@ Ice::ConnectionI::iceI_begin_flushBatchRequests(const CallbackBasePtr& cb, const
     };
 
     ConnectionFlushBatchAsyncPtr result = new ConnectionFlushBatchAsyncWithCallback(this, _communicator, _instance, cb, cookie);
-    result->invoke(iceC_flushBatchRequests_name);
+    result->invoke(__flushBatchRequests_name);
     return result;
 }
 
 void
 Ice::ConnectionI::end_flushBatchRequests(const AsyncResultPtr& r)
 {
-    AsyncResult::iceCheck(r, this, iceC_flushBatchRequests_name);
-    r->iceWait();
+    AsyncResult::__check(r, this, __flushBatchRequests_name);
+    r->__wait();
 }
 #endif
 
diff --git a/cpp/src/Ice/ConnectionI.h b/cpp/src/Ice/ConnectionI.h
index 32314d57d0b..ef277ee7c9a 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 iceI_begin_flushBatchRequests(const IceInternal::CallbackBasePtr&, const LocalObjectPtr&);
+    AsyncResultPtr __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 e662ee9cdc9..b9d87096848 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::iceDispatch(IceInternal::Incoming& in, const Current& /*current*/)
+Ice::DispatchInterceptor::__dispatch(IceInternal::Incoming& in, const Current& /*current*/)
 {
     try
     {
diff --git a/cpp/src/Ice/Exception.cpp b/cpp/src/Ice/Exception.cpp
index 64fbfeb95bf..95136f5339a 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 iceC_Ice_UserException_ids[] =
+const string __Ice__UserException_ids[] =
 {
     "::Ice::UserException"
 };
@@ -116,7 +116,7 @@ const string iceC_Ice_UserException_ids[] =
 const std::string&
 Ice::UserException::ice_staticId()
 {
-    return iceC_Ice_UserException_ids[0];
+    return __Ice__UserException_ids[0];
 }
 
 #ifdef ICE_CPP11_MAPPING
@@ -128,23 +128,23 @@ Ice::UserException::ice_clone() const
 #endif
 
 void
-Ice::UserException::iceWrite(::Ice::OutputStream* os) const
+Ice::UserException::__write(::Ice::OutputStream* os) const
 {
     os->startException(0);
-    iceWriteImpl(os);
+    __writeImpl(os);
     os->endException();
 }
 
 void
-Ice::UserException::iceRead(::Ice::InputStream* is)
+Ice::UserException::__read(::Ice::InputStream* is)
 {
     is->startException();
-    iceReadImpl(is);
+    __readImpl(is);
     is->endException(false);
 }
 
 bool
-Ice::UserException::iceUsesClasses() const
+Ice::UserException::__usesClasses() const
 {
     return false;
 }
@@ -173,7 +173,7 @@ Ice::LocalException::ice_clone() const
 namespace
 {
 
-const string iceC_Ice_LocalException_ids[] =
+const string __Ice__LocalException_ids[] =
 {
     "::Ice::LocalException"
 };
@@ -183,7 +183,7 @@ const string iceC_Ice_LocalException_ids[] =
 const std::string&
 Ice::LocalException::ice_staticId()
 {
-    return iceC_Ice_LocalException_ids[0];
+    return __Ice__LocalException_ids[0];
 }
 
 Ice::SystemException::SystemException(const char* file, int line) :
@@ -209,7 +209,7 @@ Ice::SystemException::ice_clone() const
 namespace
 {
 
-const string iceC_Ice_SystemException_ids[] =
+const string __Ice__SystemException_ids[] =
 {
     "::Ice::SystemException"
 };
@@ -219,7 +219,7 @@ const string iceC_Ice_SystemException_ids[] =
 const std::string&
 Ice::SystemException::ice_staticId()
 {
-    return iceC_Ice_SystemException_ids[0];
+    return __Ice__SystemException_ids[0];
 }
 
 void
diff --git a/cpp/src/Ice/GCObject.cpp b/cpp/src/Ice/GCObject.cpp
index fb2cb3d3f7b..a78ebbc8f50 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->iceGetRefUnsafe() - 1));
-        if(obj->iceHasFlag(GCObject::Collectable))
+        _counts.insert(make_pair(obj, obj->__getRefUnsafe() - 1));
+        if(obj->__hasFlag(GCObject::Collectable))
         {
-            obj->iceGcVisitMembers(*this);
+            obj->__gcVisitMembers(*this);
         }
     }
     else
@@ -179,7 +179,7 @@ RestoreRefCountsIfReachable::visit(GCObject* obj)
         // reachable children.
         //
         _counts.erase(p);
-        obj->iceGcVisitMembers(*this);
+        obj->__gcVisitMembers(*this);
     }
     else if(p->second == 0)
     {
@@ -189,7 +189,7 @@ RestoreRefCountsIfReachable::visit(GCObject* obj)
         // being visited again.
         //
         p->second = -1;
-        obj->iceGcVisitMembers(*this);
+        obj->__gcVisitMembers(*this);
     }
     else if(p->second > 0)
     {
@@ -201,7 +201,7 @@ RestoreRefCountsIfReachable::visit(GCObject* obj)
         _counts.erase(p); 
             
         _reachable = true;
-        obj->iceGcVisitMembers(*this);
+        obj->__gcVisitMembers(*this);
         _reachable = false;
     }
     return false;
@@ -224,17 +224,17 @@ MarkCollectable::visit(GCObject* obj)
     // strong components of the graph.
     //
 
-    if(obj->iceHasFlag(GCObject::Collectable))
+    if(obj->__hasFlag(GCObject::Collectable))
     {
         return false;
     }
-    obj->iceSetFlag(GCObject::Collectable);
+    obj->__setFlag(GCObject::Collectable);
         
     _numbers[obj] = ++_counter;
     _p.push(obj);
     _s.push(obj);
 
-    obj->iceGcVisitMembers(_neighborsVisitor);
+    obj->__gcVisitMembers(_neighborsVisitor);
 
     if(_p.top() == obj)
     {
@@ -243,7 +243,7 @@ MarkCollectable::visit(GCObject* obj)
         {
             o = _s.top();
             _s.pop();
-            o->iceSetFlag(GCObject::CycleMember);
+            o->__setFlag(GCObject::CycleMember);
         }
         while(o != obj);
         _p.pop();
@@ -259,7 +259,7 @@ MarkCollectable::visitNeighbor(GCObject* obj)
     {
         visit(obj);
     }
-    else if(!obj->iceHasFlag(GCObject::CycleMember))
+    else if(!obj->__hasFlag(GCObject::CycleMember))
     {
         while(_numbers[_p.top()] > p->second)
         {
@@ -287,10 +287,10 @@ ClearCollectable::visit(GCObject* obj)
     //
     // Clear the collectable flag on the object graph.
     //
-    if(obj->iceHasFlag(GCObject::Collectable))
+    if(obj->__hasFlag(GCObject::Collectable))
     {
-        obj->iceClearFlag(GCObject::Collectable | GCObject::CycleMember);
-        obj->iceGcVisitMembers(*this);
+        obj->__clearFlag(GCObject::Collectable | GCObject::CycleMember);
+        obj->__gcVisitMembers(*this);
     }
     return false;
 }
@@ -306,14 +306,14 @@ const unsigned char GCObject::Visiting = 8;
 // GCObject
 //
 void
-IceInternal::GCObject::iceIncRef()
+IceInternal::GCObject::__incRef()
 {
     IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(gcMutex);
     ++_ref;
 }
 
 void
-IceInternal::GCObject::iceDecRef()
+IceInternal::GCObject::__decRef()
 {
     IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(gcMutex);
     bool doDelete = false;
@@ -323,15 +323,15 @@ IceInternal::GCObject::iceDecRef()
     // Try to collect the object each time its reference count is
     // decremented and only if it's part of a cycle.
     //
-    if(_ref > 1 && iceHasFlag(CycleMember) && collect(lock))
+    if(_ref > 1 && __hasFlag(CycleMember) && collect(lock))
     {
         return;
     }
 
     if(--_ref == 0)
     {
-        doDelete = !iceHasFlag(NoDelete);
-        iceSetFlag(NoDelete);
+        doDelete = !__hasFlag(NoDelete);
+        __setFlag(NoDelete);
     }
 
     lock.release();
@@ -342,21 +342,21 @@ IceInternal::GCObject::iceDecRef()
 }
 
 int
-IceInternal::GCObject::iceGetRef() const
+IceInternal::GCObject::__getRef() const
 {
     IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(gcMutex);
     return _ref;
 }
 
 void
-IceInternal::GCObject::iceSetNoDelete(bool b)
+IceInternal::GCObject::__setNoDelete(bool b)
 {
     IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(gcMutex);
-    IceUtil::Shared::iceSetNoDelete(b);
+    IceUtil::Shared::__setNoDelete(b);
 }
 
 bool
-GCObject::iceGcVisit(GCVisitor& v)
+GCObject::__gcVisit(GCVisitor& v)
 {
     return v.visit(this);
 }
@@ -431,12 +431,12 @@ GCObject::collect(IceUtilInternal::MutexPtrLock<IceUtil::Mutex>& lock)
     //
     for(GCCountMap::const_iterator p = counts.begin(); p != counts.end(); ++p)
     {
-        p->first->iceSetFlag(NoDelete);
-        p->first->iceClearFlag(CycleMember); // Disable cycle collection.
+        p->first->__setFlag(NoDelete);
+        p->first->__clearFlag(CycleMember); // Disable cycle collection.
     }
     for(GCCountMap::const_iterator p = counts.begin(); p != counts.end(); ++p)
     {
-        p->first->iceGcVisitMembers(clearMembers);
+        p->first->__gcVisitMembers(clearMembers);
     }
     for(GCCountMap::const_iterator p = counts.begin(); p != counts.end(); ++p)
     {
diff --git a/cpp/src/Ice/IPEndpointI.cpp b/cpp/src/Ice/IPEndpointI.cpp
index b5017cbf596..10983ccc672 100644
--- a/cpp/src/Ice/IPEndpointI.cpp
+++ b/cpp/src/Ice/IPEndpointI.cpp
@@ -495,7 +495,7 @@ IceInternal::EndpointHostResolver::EndpointHostResolver(const InstancePtr& insta
     _preferIPv6(instance->preferIPv6()),
     _destroyed(false)
 {
-    iceSetNoDelete(true);
+    __setNoDelete(true);
     try
     {
         updateObserver();
@@ -518,7 +518,7 @@ IceInternal::EndpointHostResolver::EndpointHostResolver(const InstancePtr& insta
         }
         throw;
     }
-    iceSetNoDelete(false);
+    __setNoDelete(false);
 }
 
 void
diff --git a/cpp/src/Ice/Incoming.cpp b/cpp/src/Ice/Incoming.cpp
index 6db84652796..da4bb25cbc6 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))
+    __os(make_shared<Ice::OutputStream>(current.adapter->getCommunicator(), Ice::currentProtocolEncoding))
 {
-    _os->writeBlob(replyHdr, sizeof(replyHdr));
-    _os->write(current.requestId);
-    _os->write(replyOK);
+    __os->writeBlob(replyHdr, sizeof(replyHdr));
+    __os->write(current.requestId);
+    __os->write(replyOK);
 }
 #endif
 
@@ -732,7 +732,7 @@ IceInternal::Incoming::invoke(const ServantManagerPtr& servantManager, InputStre
         //
         // Dispatch in the incoming call
         //
-        _servant->iceDispatch(*this, _current);
+        _servant->__dispatch(*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 562bde737fd..132012b07b2 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->iceRead(_stream);
+    v->__read(_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.iceRead(_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.iceRead(_stream);
+                ex.__read(_stream);
                 throw;
 
                 // Never reached.
diff --git a/cpp/src/Ice/Instance.cpp b/cpp/src/Ice/Instance.cpp
index 08987b7dace..304036dec90 100644
--- a/cpp/src/Ice/Instance.cpp
+++ b/cpp/src/Ice/Instance.cpp
@@ -956,7 +956,7 @@ IceInternal::Instance::Instance(const CommunicatorPtr& communicator, const Initi
 {
     try
     {
-        iceSetNoDelete(true);
+        __setNoDelete(true);
         {
             IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(staticMutex);
             instanceList->push_back(this);
@@ -1264,7 +1264,7 @@ IceInternal::Instance::Instance(const CommunicatorPtr& communicator, const Initi
 
         _retryQueue = new RetryQueue(this);
 
-        iceSetNoDelete(false);
+        __setNoDelete(false);
     }
     catch(...)
     {
@@ -1273,7 +1273,7 @@ IceInternal::Instance::Instance(const CommunicatorPtr& communicator, const Initi
             instanceList->remove(this);
         }
         destroy();
-        iceSetNoDelete(false);
+        __setNoDelete(false);
         throw;
     }
 }
diff --git a/cpp/src/Ice/LocatorInfo.cpp b/cpp/src/Ice/LocatorInfo.cpp
index c80f773799d..74f65e2d808 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->iceReference();
+        ReferencePtr r = proxy->__reference();
         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->iceReference();
+        ReferencePtr r = _proxy->__reference();
         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->iceReference()->isIndirect())
+    if(!proxy || proxy->__reference()->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->iceReference()->isIndirect()) // Cache the adapter endpoints.
+        if(proxy && !proxy->__reference()->isIndirect()) // Cache the adapter endpoints.
         {
-            _table->addAdapterEndpoints(ref->getAdapterId(), proxy->iceReference()->getEndpoints());
+            _table->addAdapterEndpoints(ref->getAdapterId(), proxy->__reference()->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->iceReference()->isWellKnown()) // Cache the well-known object reference.
+        if(proxy && !proxy->__reference()->isWellKnown()) // Cache the well-known object reference.
         {
-            _table->addObjectReference(ref->getIdentity(), proxy->iceReference());
+            _table->addObjectReference(ref->getIdentity(), proxy->__reference());
         }
         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 f58397d0fc9..13dd1eae363 100644
--- a/cpp/src/Ice/LoggerUtil.cpp
+++ b/cpp/src/Ice/LoggerUtil.cpp
@@ -30,7 +30,7 @@ Ice::LoggerOutputBase::str() const
 }
 
 ostringstream&
-Ice::LoggerOutputBase::iceStr()
+Ice::LoggerOutputBase::__str()
 {
     return _str;
 }
@@ -38,7 +38,7 @@ Ice::LoggerOutputBase::iceStr()
 Ice::LoggerOutputBase&
 Ice::operator<<(Ice::LoggerOutputBase& out, ios_base& (*val)(ios_base&))
 {
-    out.iceStr() << val;
+    out.__str() << val;
     return out;
 }
 
@@ -47,11 +47,11 @@ Ice::loggerInsert(Ice::LoggerOutputBase& out, const IceUtil::Exception& ex)
 {
     if(IceUtilInternal::printStackTraces)
     {
-        out.iceStr() << ex.what() << '\n' << ex.ice_stackTrace();
+        out.__str() << ex.what() << '\n' << ex.ice_stackTrace();
     }
     else
     {
-        out.iceStr() << ex.what();
+        out.__str() << ex.what();
     }
     return out;
 }
@@ -71,12 +71,12 @@ Ice::Trace::~Trace()
 void
 Ice::Trace::flush()
 {
-    string s = iceStr().str();
+    string s = __str().str();
     if(!s.empty())
     {
         _logger->trace(_category, s);
     }
-    iceStr().str("");
+    __str().str("");
 }
 
 
diff --git a/cpp/src/Ice/Object.cpp b/cpp/src/Ice/Object.cpp
index 2ffdc88901d..197c54e1918 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::icePatch(ObjectPtr& obj, const ObjectPtr& v)
+Ice::__patch(ObjectPtr& obj, const ObjectPtr& v)
 {
     obj = v;
 }
@@ -48,7 +48,7 @@ Ice::Object::operator<(const Object& r) const
 namespace
 {
 
-const string iceC_Ice_Object_ids[] =
+const string __Ice__Object_ids[] =
 {
     "::Ice::Object"
 };
@@ -74,7 +74,7 @@ Ice::Object::ice_isA(string s, const Current&) const
 Ice::Object::ice_isA(const string& s, const Current&) const
 #endif
 {
-    return s == iceC_Ice_Object_ids[0];
+    return s == __Ice__Object_ids[0];
 }
 
 void
@@ -86,7 +86,7 @@ Ice::Object::ice_ping(const Current&) const
 vector<string>
 Ice::Object::ice_ids(const Current&) const
 {
-    return vector<string>(&iceC_Ice_Object_ids[0], &iceC_Ice_Object_ids[1]);
+    return vector<string>(&__Ice__Object_ids[0], &__Ice__Object_ids[1]);
 }
 
 #ifdef ICE_CPP11_MAPPING
@@ -96,13 +96,13 @@ const string&
 #endif
 Ice::Object::ice_id(const Current&) const
 {
-    return iceC_Ice_Object_ids[0];
+    return __Ice__Object_ids[0];
 }
 
 const ::std::string&
 Ice::Object::ice_staticId()
 {
-    return iceC_Ice_Object_ids[0];
+    return __Ice__Object_ids[0];
 }
 
 #ifndef ICE_CPP11_MAPPING
@@ -115,56 +115,56 @@ Ice::Object::ice_clone() const
 #endif
 
 bool
-Ice::Object::iceD_ice_isA(Incoming& iceInS, const Current& iceCurrent)
+Ice::Object::___ice_isA(Incoming& __inS, const Current& __current)
 {
-    InputStream* iceIs = iceInS.startReadParams();
-    string iceId;
-    iceIs->read(iceId, false);
-    iceInS.endReadParams();
+    InputStream* __is = __inS.startReadParams();
+    string __id;
+    __is->read(__id, false);
+    __inS.endReadParams();
 #ifdef ICE_CPP11_MAPPING
-    bool iceRet = ice_isA(move(iceId), iceCurrent);
+    bool __ret = ice_isA(move(__id), __current);
 #else
-    bool iceRet = ice_isA(iceId, iceCurrent);
+    bool __ret = ice_isA(__id, __current);
 #endif
-    OutputStream* iceOs = iceInS.startWriteParams();
-    iceOs->write(iceRet);
-    iceInS.endWriteParams();
+    OutputStream* __os = __inS.startWriteParams();
+    __os->write(__ret);
+    __inS.endWriteParams();
     return false;
 }
 
 bool
-Ice::Object::iceD_ice_ping(Incoming& iceInS, const Current& iceCurrent)
+Ice::Object::___ice_ping(Incoming& __inS, const Current& __current)
 {
-    iceInS.readEmptyParams();
-    ice_ping(iceCurrent);
-    iceInS.writeEmptyParams();
+    __inS.readEmptyParams();
+    ice_ping(__current);
+    __inS.writeEmptyParams();
     return false;
 }
 
 bool
-Ice::Object::iceD_ice_ids(Incoming& iceInS, const Current& iceCurrent)
+Ice::Object::___ice_ids(Incoming& __inS, const Current& __current)
 {
-    iceInS.readEmptyParams();
-    vector<string> iceRet = ice_ids(iceCurrent);
-    OutputStream* iceOs = iceInS.startWriteParams();
-    iceOs->write(&iceRet[0], &iceRet[0] + iceRet.size(), false);
-    iceInS.endWriteParams();
+    __inS.readEmptyParams();
+    vector<string> __ret = ice_ids(__current);
+    OutputStream* __os = __inS.startWriteParams();
+    __os->write(&__ret[0], &__ret[0] + __ret.size(), false);
+    __inS.endWriteParams();
     return false;
 }
 
 bool
-Ice::Object::iceD_ice_id(Incoming& iceInS, const Current& iceCurrent)
+Ice::Object::___ice_id(Incoming& __inS, const Current& __current)
 {
-    iceInS.readEmptyParams();
-    string iceRet = ice_id(iceCurrent);
-    OutputStream* iceOs = iceInS.startWriteParams();
-    iceOs->write(iceRet, false);
-    iceInS.endWriteParams();
+    __inS.readEmptyParams();
+    string __ret = ice_id(__current);
+    OutputStream* __os = __inS.startWriteParams();
+    __os->write(__ret, false);
+    __inS.endWriteParams();
     return false;
 }
 
 
-string Ice::Object::s_iceAll[] =
+string Ice::Object::__all[] =
 {
     "ice_id",
     "ice_ids",
@@ -193,7 +193,7 @@ Ice::Object::ice_dispatch(Request& request, const DispatchInterceptorAsyncCallba
 #endif
         try
         {
-            return iceDispatch(in, in.getCurrent());
+            return __dispatch(in, in.getCurrent());
             in.pop();
         }
         catch(...)
@@ -204,37 +204,37 @@ Ice::Object::ice_dispatch(Request& request, const DispatchInterceptorAsyncCallba
     }
     else
     {
-        return iceDispatch(in, in.getCurrent());
+        return __dispatch(in, in.getCurrent());
     }
 }
 
 bool
-Ice::Object::iceDispatch(Incoming& in, const Current& current)
+Ice::Object::__dispatch(Incoming& in, const Current& current)
 {
-    pair<string*, string*> r = equal_range(s_iceAll, s_iceAll + sizeof(s_iceAll) / sizeof(string), current.operation);
+    pair<string*, string*> r = equal_range(__all, __all + sizeof(__all) / sizeof(string), current.operation);
 
     if(r.first == r.second)
     {
         throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
     }
 
-    switch(r.first - s_iceAll)
+    switch(r.first - __all)
     {
         case 0:
         {
-            return iceD_ice_id(in, current);
+            return ___ice_id(in, current);
         }
         case 1:
         {
-            return iceD_ice_ids(in, current);
+            return ___ice_ids(in, current);
         }
         case 2:
         {
-            return iceD_ice_isA(in, current);
+            return ___ice_isA(in, current);
         }
         case 3:
         {
-            return iceD_ice_ping(in, current);
+            return ___ice_ping(in, current);
         }
         default:
         {
@@ -256,18 +256,18 @@ Ice::Object::ice_postUnmarshal()
 }
 
 void
-Ice::Object::iceWrite(Ice::OutputStream* os) const
+Ice::Object::__write(Ice::OutputStream* os) const
 {
     os->startValue(0);
-    iceWriteImpl(os);
+    __writeImpl(os);
     os->endValue();
 }
 
 void
-Ice::Object::iceRead(Ice::InputStream* is)
+Ice::Object::__read(Ice::InputStream* is)
 {
    is->startValue();
-   iceReadImpl(is);
+   __readImpl(is);
    is->endValue(false);
 }
 
@@ -311,7 +311,7 @@ operationModeToString(OperationMode mode)
 }
 
 void
-Ice::Object::iceCheckMode(OperationMode expected, OperationMode received)
+Ice::Object::__checkMode(OperationMode expected, OperationMode received)
 {
     if(expected != received)
     {
@@ -330,19 +330,19 @@ Ice::Object::iceCheckMode(OperationMode expected, OperationMode received)
         else
         {
             Ice::MarshalException ex(__FILE__, __LINE__);
-            std::ostringstream iceReason;
-            iceReason << "unexpected operation mode. expected = "
+            std::ostringstream __reason;
+            __reason << "unexpected operation mode. expected = "
                      << operationModeToString(expected)
                      << " received = "
                      << operationModeToString(received);
-            ex.reason = iceReason.str();
+            ex.reason = __reason.str();
             throw ex;
         }
     }
 }
 
 bool
-Ice::Blobject::iceDispatch(Incoming& in, const Current& current)
+Ice::Blobject::__dispatch(Incoming& in, const Current& current)
 {
     const Byte* inEncaps;
     Int sz;
@@ -361,7 +361,7 @@ Ice::Blobject::iceDispatch(Incoming& in, const Current& current)
 }
 
 bool
-Ice::BlobjectArray::iceDispatch(Incoming& in, const Current& current)
+Ice::BlobjectArray::__dispatch(Incoming& in, const Current& current)
 {
     pair<const Byte*, const Byte*> inEncaps;
     Int sz;
@@ -381,7 +381,7 @@ Ice::BlobjectArray::iceDispatch(Incoming& in, const Current& current)
 }
 
 bool
-Ice::BlobjectAsync::iceDispatch(Incoming& in, const Current& current)
+Ice::BlobjectAsync::__dispatch(Incoming& in, const Current& current)
 {
     const Byte* inEncaps;
     Int sz;
@@ -409,7 +409,7 @@ Ice::BlobjectAsync::iceDispatch(Incoming& in, const Current& current)
 }
 
 bool
-Ice::BlobjectArrayAsync::iceDispatch(Incoming& in, const Current& current)
+Ice::BlobjectArrayAsync::__dispatch(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 810d46cf7fb..0631186769d 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->iceReference();
+    ReferencePtr ref = proxy->__reference();
     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->iceReference();
+    ReferencePtr ref = proxy->__reference();
     if(ref->isWellKnown())
     {
         //
diff --git a/cpp/src/Ice/ObserverHelper.cpp b/cpp/src/Ice/ObserverHelper.cpp
index 3cf5b1e3da5..6b88a0d68de 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->iceReference()->getInstance()->initializationData().observer;
+    const CommunicatorObserverPtr& obsv = proxy->__reference()->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->iceReference()->getInstance()->initializationData().observer;
+    const CommunicatorObserverPtr& obsv = proxy->__reference()->getInstance()->initializationData().observer;
     if(!obsv)
     {
         return;
diff --git a/cpp/src/Ice/OutgoingAsync.cpp b/cpp/src/Ice/OutgoingAsync.cpp
index 9569e9b92a9..d7ffc2f4d6d 100644
--- a/cpp/src/Ice/OutgoingAsync.cpp
+++ b/cpp/src/Ice/OutgoingAsync.cpp
@@ -474,7 +474,7 @@ OutgoingAsyncBase::throwLocalException() const
 }
 
 bool
-OutgoingAsyncBase::iceWait()
+OutgoingAsyncBase::__wait()
 {
     Lock sync(_m);
     if(_state & EndCalled)
@@ -495,32 +495,32 @@ OutgoingAsyncBase::iceWait()
 }
 
 Ice::InputStream*
-OutgoingAsyncBase::iceStartReadParams()
+OutgoingAsyncBase::__startReadParams()
 {
     _is.startEncapsulation();
     return &_is;
 }
 
 void
-OutgoingAsyncBase::iceEndReadParams()
+OutgoingAsyncBase::__endReadParams()
 {
     _is.endEncapsulation();
 }
 
 void
-OutgoingAsyncBase::iceReadEmptyParams()
+OutgoingAsyncBase::__readEmptyParams()
 {
     _is.skipEmptyEncapsulation();
 }
 
 void
-OutgoingAsyncBase::iceReadParamEncaps(const ::Ice::Byte*& encaps, ::Ice::Int& sz)
+OutgoingAsyncBase::__readParamEncaps(const ::Ice::Byte*& encaps, ::Ice::Int& sz)
 {
     _is.readEncapsulation(encaps, sz);
 }
 
 void
-OutgoingAsyncBase::iceThrowUserException()
+OutgoingAsyncBase::__throwUserException()
 {
     try
     {
@@ -574,7 +574,7 @@ ProxyOutgoingAsyncBase::exception(const Exception& exc)
     }
 
     _cachedConnection = 0;
-    if(_proxy->iceReference()->getInvocationTimeout() == -2)
+    if(_proxy->__reference()->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->iceHandleException(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->iceReference()->getInvocationTimeout() == -2 && _cachedConnection)
+    if(_proxy->__reference()->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->iceUpdateRequestHandler(_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->iceReference()->getInstance()),
+    OutgoingAsyncBase(prx->__reference()->getInstance()),
     _proxy(prx),
     _mode(ICE_ENUM(OperationMode, Normal)),
     _cnt(0),
@@ -696,7 +696,7 @@ ProxyOutgoingAsyncBase::invokeImpl(bool userThread)
     {
         if(userThread)
         {
-            int invocationTimeout = _proxy->iceReference()->getInvocationTimeout();
+            int invocationTimeout = _proxy->__reference()->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->iceGetRequestHandler();
+                _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->iceUpdateRequestHandler(_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->iceHandleException(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->iceReference()->getInvocationTimeout() != -1)
+        if(_proxy->__reference()->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->iceReference()->getInvocationTimeout() != -1)
+    if(_proxy->__reference()->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->iceReference()->getInvocationTimeout() != -1)
+    if(_proxy->__reference()->getInvocationTimeout() != -1)
     {
         _instance->timer()->cancel(ICE_SHARED_FROM_THIS);
     }
@@ -812,7 +812,7 @@ ProxyOutgoingAsyncBase::responseImpl(bool ok)
 void
 ProxyOutgoingAsyncBase::runTimerTask()
 {
-    if(_proxy->iceReference()->getInvocationTimeout() == -2)
+    if(_proxy->__reference()->getInvocationTimeout() == -2)
     {
         cancel(ConnectionTimeoutException(__FILE__, __LINE__));
     }
@@ -824,7 +824,7 @@ ProxyOutgoingAsyncBase::runTimerTask()
 
 OutgoingAsync::OutgoingAsync(const ObjectPrxPtr& prx, bool synchronous) :
     ProxyOutgoingAsyncBase(prx),
-    _encoding(getCompatibleEncoding(prx->iceReference()->getEncoding())),
+    _encoding(getCompatibleEncoding(prx->__reference()->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->iceReference()->getProtocol()));
+    checkSupportedProtocol(getCompatibleProtocol(_proxy->__reference()->getProtocol()));
 
     _mode = mode;
     _observer.attach(_proxy, operation, context);
 
-    switch(_proxy->iceReference()->getMode())
+    switch(_proxy->__reference()->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->iceGetBatchRequestQueue()->prepareBatchRequest(&_os);
+            _proxy->__getBatchRequestQueue()->prepareBatchRequest(&_os);
             break;
         }
     }
 
-    Reference* ref = _proxy->iceReference().get();
+    Reference* ref = _proxy->__reference().get();
 
     _os.write(ref->getIdentity());
 
@@ -1068,7 +1068,7 @@ OutgoingAsync::invokeCollocated(CollocatedRequestHandler* handler)
 void
 OutgoingAsync::abort(const Exception& ex)
 {
-    const Reference::Mode mode = _proxy->iceReference()->getMode();
+    const Reference::Mode mode = _proxy->__reference()->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->iceGetBatchRequestQueue()->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->iceReference()->getMode();
+    const Reference::Mode mode = _proxy->__reference()->getMode();
     if(mode == Reference::ModeBatchOneway || mode == Reference::ModeBatchDatagram)
     {
         _sentSynchronously = true;
-        _proxy->iceGetBatchRequestQueue()->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->iceReference()->getProtocol()));
+    checkSupportedProtocol(getCompatibleProtocol(_proxy->__reference()->getProtocol()));
     _observer.attach(_proxy, operation, ::Ice::noExplicitContext);
-    _batchRequestNum = _proxy->iceGetBatchRequestQueue()->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 7c7a2347664..4850b0f5474 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->iceWrite(*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.iceUsesClasses();
+    bool usesClasses = v.__usesClasses();
     _stream->write(usesClasses);
-    v.iceWrite(_stream);
+    v.__write(_stream);
     if(usesClasses)
     {
         writePendingValues();
@@ -1076,7 +1076,7 @@ Ice::OutputStream::EncapsEncoder10::writePendingValues()
                 out << "unknown exception raised by ice_preMarshal";
             }
 
-            p->first->iceWrite(_stream);
+            p->first->__write(_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.iceWrite(_stream);
+    v.__write(_stream);
 }
 
 void
@@ -1395,5 +1395,5 @@ Ice::OutputStream::EncapsEncoder11::writeInstance(const ValuePtr& v)
     }
 
     _stream->writeSize(1); // Object instance marker.
-    v->iceWrite(_stream);
+    v->__write(_stream);
 }
diff --git a/cpp/src/Ice/Proxy.cpp b/cpp/src/Ice/Proxy.cpp
index 70db48fe6c9..5555d4214a1 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::iceI_ice_isA(const shared_ptr<IceInternal::OutgoingAsyncT<bool>>& outAsync,
+Ice::ObjectPrx::__ice_isA(const shared_ptr<IceInternal::OutgoingAsyncT<bool>>& outAsync,
                           const string& typeId,
                           const Context& ctx)
 {
-    iceCheckTwowayOnly(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::iceI_ice_isA(const shared_ptr<IceInternal::OutgoingAsyncT<bool>>
 }
 
 void
-Ice::ObjectPrx::iceI_ice_ping(const shared_ptr<IceInternal::OutgoingAsyncT<void>>& outAsync, const Context& ctx)
+Ice::ObjectPrx::__ice_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::iceI_ice_ids(const shared_ptr<IceInternal::OutgoingAsyncT<vector<string>>>& outAsync, const Context& ctx)
+Ice::ObjectPrx::__ice_ids(const shared_ptr<IceInternal::OutgoingAsyncT<vector<string>>>& outAsync, const Context& ctx)
 {
-    iceCheckTwowayOnly(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::iceI_ice_ids(const shared_ptr<IceInternal::OutgoingAsyncT<vector
 }
 
 void
-Ice::ObjectPrx::iceI_ice_id(const shared_ptr<IceInternal::OutgoingAsyncT<string>>& outAsync, const Context& ctx)
+Ice::ObjectPrx::__ice_id(const shared_ptr<IceInternal::OutgoingAsyncT<string>>& outAsync, const Context& ctx)
 {
-    iceCheckTwowayOnly(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::iceI_ice_id(const shared_ptr<IceInternal::OutgoingAsyncT<string>
 }
 
 void
-Ice::ObjectPrx::iceGetConnection(const shared_ptr<IceInternal::ProxyGetConnection>& outAsync)
+Ice::ObjectPrx::__ice_getConnection(const shared_ptr<IceInternal::ProxyGetConnection>& outAsync)
 {
     outAsync->invoke(ice_getConnection_name);
 }
 
 void
-Ice::ObjectPrx::iceI_ice_flushBatchRequests(const shared_ptr<IceInternal::ProxyFlushBatchAsync>& outAsync)
+Ice::ObjectPrx::__ice_flushBatchRequests(const shared_ptr<IceInternal::ProxyFlushBatchAsync>& outAsync)
 {
     outAsync->invoke(ice_flushBatchRequests_name);
 }
 
 void
-Ice::ObjectPrx::iceCheckTwowayOnly(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::iceCheckTwowayOnly(const string& name) const
 
 
 shared_ptr<ObjectPrx>
-Ice::ObjectPrx::iceNewInstance() 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::iceI_begin_ice_isA(const string& typeId,
+IceProxy::Ice::Object::__begin_ice_isA(const string& typeId,
                                        const Context& ctx,
                                        const ::IceInternal::CallbackBasePtr& del,
                                        const ::Ice::LocalObjectPtr& cookie,
                                        bool sync)
 {
-    iceCheckTwowayOnly(ice_isA_name, sync);
-    OutgoingAsyncPtr iceResult = new CallbackOutgoing(this, ice_isA_name, del, cookie, sync);
+    __checkTwowayOnly(ice_isA_name, sync);
+    OutgoingAsyncPtr __result = new CallbackOutgoing(this, ice_isA_name, del, cookie, sync);
     try
     {
-        iceResult->prepare(ice_isA_name, Nonmutating, ctx);
-        ::Ice::OutputStream* iceOs = iceResult->startWriteParams(DefaultFormat);
-        iceOs->write(typeId, false);
-        iceResult->endWriteParams();
-        iceResult->invoke(ice_isA_name);
+        __result->prepare(ice_isA_name, Nonmutating, ctx);
+        ::Ice::OutputStream* __os = __result->startWriteParams(DefaultFormat);
+        __os->write(typeId, false);
+        __result->endWriteParams();
+        __result->invoke(ice_isA_name);
     }
-    catch(const Exception& iceEx)
+    catch(const Exception& __ex)
     {
-        iceResult->abort(iceEx);
+        __result->abort(__ex);
     }
-    return iceResult;
+    return __result;
 }
 
 bool
-IceProxy::Ice::Object::end_ice_isA(const AsyncResultPtr& iceResult)
+IceProxy::Ice::Object::end_ice_isA(const AsyncResultPtr& __result)
 {
-    AsyncResult::iceCheck(iceResult, this, ice_isA_name);
-    bool iceOk = iceResult->iceWait();
-    if(!iceOk)
+    AsyncResult::__check(__result, this, ice_isA_name);
+    bool __ok = __result->__wait();
+    if(!__ok)
     {
         try
         {
-            iceResult->iceThrowUserException();
+            __result->__throwUserException();
         }
-        catch(const UserException& iceEx)
+        catch(const UserException& __ex)
         {
-            throw UnknownUserException(__FILE__, __LINE__, iceEx.ice_id());
+            throw UnknownUserException(__FILE__, __LINE__, __ex.ice_id());
         }
     }
-    bool iceRet;
-    ::Ice::InputStream* iceIs = iceResult->iceStartReadParams();
-    iceIs->read(iceRet);
-    iceResult->iceEndReadParams();
-    return iceRet;
+    bool __ret;
+    ::Ice::InputStream* __is = __result->__startReadParams();
+    __is->read(__ret);
+    __result->__endReadParams();
+    return __ret;
 }
 
 AsyncResultPtr
-IceProxy::Ice::Object::iceI_begin_ice_ping(const Context& ctx,
+IceProxy::Ice::Object::__begin_ice_ping(const Context& ctx,
                                         const ::IceInternal::CallbackBasePtr& del,
                                         const ::Ice::LocalObjectPtr& cookie,
                                         bool sync)
 {
-    OutgoingAsyncPtr iceResult = new CallbackOutgoing(this, ice_ping_name, del, cookie, sync);
+    OutgoingAsyncPtr __result = new CallbackOutgoing(this, ice_ping_name, del, cookie, sync);
     try
     {
-        iceResult->prepare(ice_ping_name, Nonmutating, ctx);
-        iceResult->writeEmptyParams();
-        iceResult->invoke(ice_ping_name);
+        __result->prepare(ice_ping_name, Nonmutating, ctx);
+        __result->writeEmptyParams();
+        __result->invoke(ice_ping_name);
     }
-    catch(const Exception& iceEx)
+    catch(const Exception& __ex)
     {
-        iceResult->abort(iceEx);
+        __result->abort(__ex);
     }
-    return iceResult;
+    return __result;
 }
 
 void
-IceProxy::Ice::Object::end_ice_ping(const AsyncResultPtr& iceResult)
+IceProxy::Ice::Object::end_ice_ping(const AsyncResultPtr& __result)
 {
-    iceEnd(iceResult, ice_ping_name);
+    __end(__result, ice_ping_name);
 }
 
 AsyncResultPtr
-IceProxy::Ice::Object::iceI_begin_ice_ids(const Context& ctx,
+IceProxy::Ice::Object::__begin_ice_ids(const Context& ctx,
                                        const ::IceInternal::CallbackBasePtr& del,
                                        const ::Ice::LocalObjectPtr& cookie,
                                        bool sync)
 {
-    iceCheckTwowayOnly(ice_ids_name, sync);
-    OutgoingAsyncPtr iceResult = 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
     {
-        iceResult->prepare(ice_ids_name, Nonmutating, ctx);
-        iceResult->writeEmptyParams();
-        iceResult->invoke(ice_ids_name);
+        __result->prepare(ice_ids_name, Nonmutating, ctx);
+        __result->writeEmptyParams();
+        __result->invoke(ice_ids_name);
     }
-    catch(const Exception& iceEx)
+    catch(const Exception& __ex)
     {
-        iceResult->abort(iceEx);
+        __result->abort(__ex);
     }
-    return iceResult;
+    return __result;
 }
 
 vector<string>
-IceProxy::Ice::Object::end_ice_ids(const AsyncResultPtr& iceResult)
+IceProxy::Ice::Object::end_ice_ids(const AsyncResultPtr& __result)
 {
-    AsyncResult::iceCheck(iceResult, this, ice_ids_name);
-    bool iceOk = iceResult->iceWait();
-    if(!iceOk)
+    AsyncResult::__check(__result, this, ice_ids_name);
+    bool __ok = __result->__wait();
+    if(!__ok)
     {
         try
         {
-            iceResult->iceThrowUserException();
+            __result->__throwUserException();
         }
-        catch(const UserException& iceEx)
+        catch(const UserException& __ex)
         {
-            throw UnknownUserException(__FILE__, __LINE__, iceEx.ice_id());
+            throw UnknownUserException(__FILE__, __LINE__, __ex.ice_id());
         }
     }
-    vector<string> iceRet;
-    ::Ice::InputStream* iceIs = iceResult->iceStartReadParams();
-    iceIs->read(iceRet, false);
-    iceResult->iceEndReadParams();
-    return iceRet;
+    vector<string> __ret;
+    ::Ice::InputStream* __is = __result->__startReadParams();
+    __is->read(__ret, false);
+    __result->__endReadParams();
+    return __ret;
 }
 
 AsyncResultPtr
-IceProxy::Ice::Object::iceI_begin_ice_id(const Context& ctx,
+IceProxy::Ice::Object::__begin_ice_id(const Context& ctx,
                                       const ::IceInternal::CallbackBasePtr& del,
                                       const ::Ice::LocalObjectPtr& cookie,
                                       bool sync)
 {
-    iceCheckTwowayOnly(ice_id_name, sync);
-    OutgoingAsyncPtr iceResult = 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
     {
-        iceResult->prepare(ice_id_name, Nonmutating, ctx);
-        iceResult->writeEmptyParams();
-        iceResult->invoke(ice_id_name);
+        __result->prepare(ice_id_name, Nonmutating, ctx);
+        __result->writeEmptyParams();
+        __result->invoke(ice_id_name);
     }
-    catch(const Exception& iceEx)
+    catch(const Exception& __ex)
     {
-        iceResult->abort(iceEx);
+        __result->abort(__ex);
     }
-    return iceResult;
+    return __result;
 }
 
 string
-IceProxy::Ice::Object::end_ice_id(const AsyncResultPtr& iceResult)
+IceProxy::Ice::Object::end_ice_id(const AsyncResultPtr& __result)
 {
-    AsyncResult::iceCheck(iceResult, this, ice_id_name);
-    bool iceOk = iceResult->iceWait();
-    if(!iceOk)
+    AsyncResult::__check(__result, this, ice_id_name);
+    bool __ok = __result->__wait();
+    if(!__ok)
     {
         try
         {
-            iceResult->iceThrowUserException();
+            __result->__throwUserException();
         }
-        catch(const UserException& iceEx)
+        catch(const UserException& __ex)
         {
-            throw UnknownUserException(__FILE__, __LINE__, iceEx.ice_id());
+            throw UnknownUserException(__FILE__, __LINE__, __ex.ice_id());
         }
     }
-    string iceRet;
-    ::Ice::InputStream* iceIs = iceResult->iceStartReadParams();
-    iceIs->read(iceRet, false);
-    iceResult->iceEndReadParams();
-    return iceRet;
+    string __ret;
+    ::Ice::InputStream* __is = __result->__startReadParams();
+    __is->read(__ret, false);
+    __result->__endReadParams();
+    return __ret;
 }
 
 bool
@@ -374,7 +374,7 @@ IceProxy::Ice::Object::ice_invoke(const string& operation,
 }
 
 AsyncResultPtr
-IceProxy::Ice::Object::iceI_begin_ice_invoke(const string& operation,
+IceProxy::Ice::Object::__begin_ice_invoke(const string& operation,
                                           OperationMode mode,
                                           const vector<Byte>& inEncaps,
                                           const Context& ctx,
@@ -392,26 +392,26 @@ IceProxy::Ice::Object::iceI_begin_ice_invoke(const string& operation,
         inPair.first = &inEncaps[0];
         inPair.second = inPair.first + inEncaps.size();
     }
-    return iceI_begin_ice_invoke(operation, mode, inPair, ctx, del, cookie);
+    return __begin_ice_invoke(operation, mode, inPair, ctx, del, cookie);
 }
 
 bool
-IceProxy::Ice::Object::end_ice_invoke(vector<Byte>& outEncaps, const AsyncResultPtr& iceResult)
+IceProxy::Ice::Object::end_ice_invoke(vector<Byte>& outEncaps, const AsyncResultPtr& __result)
 {
-    AsyncResult::iceCheck(iceResult, this, ice_invoke_name);
-    bool ok = iceResult->iceWait();
+    AsyncResult::__check(__result, this, ice_invoke_name);
+    bool ok = __result->__wait();
     if(_reference->getMode() == Reference::ModeTwoway)
     {
         const Byte* v;
         Int sz;
-        iceResult->iceReadParamEncaps(v, sz);
+        __result->__readParamEncaps(v, sz);
         vector<Byte>(v, v + sz).swap(outEncaps);
     }
     return ok;
 }
 
 AsyncResultPtr
-IceProxy::Ice::Object::iceI_begin_ice_invoke(const string& operation,
+IceProxy::Ice::Object::__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::iceI_begin_ice_invoke(const string& operation,
                                           const ::Ice::LocalObjectPtr& cookie,
                                           bool sync)
 {
-    OutgoingAsyncPtr iceResult = new CallbackOutgoing(this, ice_invoke_name, del, cookie, sync);
+    OutgoingAsyncPtr __result = new CallbackOutgoing(this, ice_invoke_name, del, cookie, sync);
     try
     {
-        iceResult->prepare(operation, mode, ctx);
-        iceResult->writeParamEncaps(inEncaps.first, static_cast<Int>(inEncaps.second - inEncaps.first));
-        iceResult->invoke(operation);
+        __result->prepare(operation, mode, ctx);
+        __result->writeParamEncaps(inEncaps.first, static_cast<Int>(inEncaps.second - inEncaps.first));
+        __result->invoke(operation);
     }
-    catch(const Exception& iceEx)
+    catch(const Exception& __ex)
     {
-        iceResult->abort(iceEx);
+        __result->abort(__ex);
     }
-    return iceResult;
+    return __result;
 }
 
 bool
-IceProxy::Ice::Object::iceI_end_ice_invoke(pair<const Byte*, const Byte*>& outEncaps, const AsyncResultPtr& iceResult)
+IceProxy::Ice::Object::___end_ice_invoke(pair<const Byte*, const Byte*>& outEncaps, const AsyncResultPtr& __result)
 {
-    AsyncResult::iceCheck(iceResult, this, ice_invoke_name);
-    bool ok = iceResult->iceWait();
+    AsyncResult::__check(__result, this, ice_invoke_name);
+    bool ok = __result->__wait();
     if(_reference->getMode() == Reference::ModeTwoway)
     {
         Int sz;
-        iceResult->iceReadParamEncaps(outEncaps.first, sz);
+        __result->__readParamEncaps(outEncaps.first, sz);
         outEncaps.second = outEncaps.first + sz;
     }
     return ok;
 }
 
 ::Ice::AsyncResultPtr
-IceProxy::Ice::Object::iceI_begin_ice_flushBatchRequests(const ::IceInternal::CallbackBasePtr& del,
+IceProxy::Ice::Object::__begin_ice_flushBatchRequests(const ::IceInternal::CallbackBasePtr& del,
                                                       const ::Ice::LocalObjectPtr& cookie)
 {
     class ProxyFlushBatchAsyncWithCallback : public ProxyFlushBatchAsync, public CallbackCompletion
@@ -485,29 +485,29 @@ IceProxy::Ice::Object::iceI_begin_ice_flushBatchRequests(const ::IceInternal::Ca
 void
 IceProxy::Ice::Object::end_ice_flushBatchRequests(const AsyncResultPtr& result)
 {
-    AsyncResult::iceCheck(result, this, ice_flushBatchRequests_name);
-    result->iceWait();
+    AsyncResult::__check(result, this, ice_flushBatchRequests_name);
+    result->__wait();
 }
 
 void
-IceProxy::Ice::Object::iceEnd(const ::Ice::AsyncResultPtr& iceResult, const std::string& operation) const
+IceProxy::Ice::Object::__end(const ::Ice::AsyncResultPtr& __result, const std::string& operation) const
 {
-    AsyncResult::iceCheck(iceResult, this, operation);
-    bool iceOk = iceResult->iceWait();
+    AsyncResult::__check(__result, this, operation);
+    bool __ok = __result->__wait();
     if(_reference->getMode() == Reference::ModeTwoway)
     {
-        if(!iceOk)
+        if(!__ok)
         {
             try
             {
-                iceResult->iceThrowUserException();
+                __result->__throwUserException();
             }
-            catch(const UserException& iceEx)
+            catch(const UserException& __ex)
             {
-                throw UnknownUserException(__FILE__, __LINE__, iceEx.ice_id());
+                throw UnknownUserException(__FILE__, __LINE__, __ex.ice_id());
             }
         }
-        iceResult->iceReadEmptyParams();
+        __result->__readEmptyParams();
     }
 }
 
@@ -528,13 +528,13 @@ operator<<(ostream& os, const ::IceProxy::Ice::Object& p)
 }
 
 IceProxy::Ice::Object*
-IceProxy::Ice::Object::iceNewInstance() const
+IceProxy::Ice::Object::__newInstance() const
 {
     return new Object;
 }
 
 AsyncResultPtr
-IceProxy::Ice::Object::iceI_begin_ice_getConnection(const ::IceInternal::CallbackBasePtr& del,
+IceProxy::Ice::Object::__begin_ice_getConnection(const ::IceInternal::CallbackBasePtr& del,
                                                  const ::Ice::LocalObjectPtr& cookie)
 {
     class ProxyGetConnectionWithCallback :  public ProxyGetConnection, public CallbackCompletion
@@ -569,15 +569,15 @@ IceProxy::Ice::Object::iceI_begin_ice_getConnection(const ::IceInternal::Callbac
 }
 
 ConnectionPtr
-IceProxy::Ice::Object::end_ice_getConnection(const AsyncResultPtr& iceResult)
+IceProxy::Ice::Object::end_ice_getConnection(const AsyncResultPtr& __result)
 {
-    AsyncResult::iceCheck(iceResult, this, ice_getConnection_name);
-    iceResult->iceWait();
-    return iceResult->getConnection();
+    AsyncResult::__check(__result, this, ice_getConnection_name);
+    __result->__wait();
+    return __result->getConnection();
 }
 
 void
-IceProxy::Ice::Object::iceCheckTwowayOnly(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 = iceNewInstance();
+    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 = iceNewInstance();
+        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 = iceNewInstance();
+        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 = iceNewInstance();
+        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 = iceNewInstance();
+        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 = iceNewInstance();
+        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 = iceNewInstance();
+        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 = iceNewInstance();
+        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 = iceNewInstance();
+        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 = iceNewInstance();
+        ObjectPrxPtr proxy = __newInstance();
         proxy->setup(ref);
         return proxy;
     }
@@ -913,7 +913,7 @@ ICE_OBJECT_PRX::ice_locator(const LocatorPrxPtr& locator) const
     }
     else
     {
-        ObjectPrxPtr proxy = iceNewInstance();
+        ObjectPrxPtr proxy = __newInstance();
         proxy->setup(ref);
         return proxy;
     }
@@ -934,7 +934,7 @@ ICE_OBJECT_PRX::ice_collocationOptimized(bool b) const
     }
     else
     {
-        ObjectPrxPtr proxy = iceNewInstance();
+        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 = iceNewInstance();
+        ObjectPrxPtr proxy = __newInstance();
         proxy->setup(_reference->changeInvocationTimeout(newTimeout));
         return proxy;
     }
@@ -976,7 +976,7 @@ ICE_OBJECT_PRX::ice_twoway() const
     }
     else
     {
-        ObjectPrxPtr proxy = iceNewInstance();
+        ObjectPrxPtr proxy = __newInstance();
         proxy->setup(_reference->changeMode(Reference::ModeTwoway));
         return proxy;
     }
@@ -997,7 +997,7 @@ ICE_OBJECT_PRX::ice_oneway() const
     }
     else
     {
-        ObjectPrxPtr proxy = iceNewInstance();
+        ObjectPrxPtr proxy = __newInstance();
         proxy->setup(_reference->changeMode(Reference::ModeOneway));
         return proxy;
     }
@@ -1018,7 +1018,7 @@ ICE_OBJECT_PRX::ice_batchOneway() const
     }
     else
     {
-        ObjectPrxPtr proxy = iceNewInstance();
+        ObjectPrxPtr proxy = __newInstance();
         proxy->setup(_reference->changeMode(Reference::ModeBatchOneway));
         return proxy;
     }
@@ -1039,7 +1039,7 @@ ICE_OBJECT_PRX::ice_datagram() const
     }
     else
     {
-        ObjectPrxPtr proxy = iceNewInstance();
+        ObjectPrxPtr proxy = __newInstance();
         proxy->setup(_reference->changeMode(Reference::ModeDatagram));
         return proxy;
     }
@@ -1060,7 +1060,7 @@ ICE_OBJECT_PRX::ice_batchDatagram() const
     }
     else
     {
-        ObjectPrxPtr proxy = iceNewInstance();
+        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 = iceNewInstance();
+        ObjectPrxPtr proxy = __newInstance();
         proxy->setup(ref);
         return proxy;
     }
@@ -1104,7 +1104,7 @@ ICE_OBJECT_PRX::ice_timeout(int t) const
     }
     else
     {
-        ObjectPrxPtr proxy = iceNewInstance();
+        ObjectPrxPtr proxy = __newInstance();
         proxy->setup(ref);
         return proxy;
     }
@@ -1120,7 +1120,7 @@ ICE_OBJECT_PRX::ice_connectionId(const string& id) const
     }
     else
     {
-        ObjectPrxPtr proxy = iceNewInstance();
+        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 iceHandler;
+    RequestHandlerPtr __handler;
     {
         IceUtil::Mutex::Lock sync(_mutex);
-        iceHandler =  _requestHandler;
+        __handler =  _requestHandler;
     }
 
-    if(iceHandler)
+    if(__handler)
     {
         try
         {
-            return iceHandler->getConnection();
+            return __handler->getConnection();
         }
         catch(const LocalException&)
         {
@@ -1169,13 +1169,13 @@ ICE_OBJECT_PRX::setup(const ReferencePtr& ref)
 }
 
 int
-ICE_OBJECT_PRX::iceHandleException(const Exception& ex,
+ICE_OBJECT_PRX::__handleException(const Exception& ex,
                                          const RequestHandlerPtr& handler,
                                          OperationMode mode,
                                          bool sent,
                                          int& cnt)
 {
-    iceUpdateRequestHandler(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::iceHandleException(const Exception& ex,
 }
 
 ::IceInternal::RequestHandlerPtr
-ICE_OBJECT_PRX::iceGetRequestHandler()
+ICE_OBJECT_PRX::__getRequestHandler()
 {
     RequestHandlerPtr handler;
     if(_reference->getCacheConnection())
@@ -1233,7 +1233,7 @@ ICE_OBJECT_PRX::iceGetRequestHandler()
 }
 
 IceInternal::BatchRequestQueuePtr
-ICE_OBJECT_PRX::iceGetBatchRequestQueue()
+ICE_OBJECT_PRX::__getBatchRequestQueue()
 {
     IceUtil::Mutex::Lock sync(_mutex);
     if(!_batchRequestQueue)
@@ -1244,7 +1244,7 @@ ICE_OBJECT_PRX::iceGetBatchRequestQueue()
 }
 
 ::IceInternal::RequestHandlerPtr
-ICE_OBJECT_PRX::iceSetRequestHandler(const ::IceInternal::RequestHandlerPtr& handler)
+ICE_OBJECT_PRX::__setRequestHandler(const ::IceInternal::RequestHandlerPtr& handler)
 {
     if(_reference->getCacheConnection())
     {
@@ -1259,7 +1259,7 @@ ICE_OBJECT_PRX::iceSetRequestHandler(const ::IceInternal::RequestHandlerPtr& han
 }
 
 void
-ICE_OBJECT_PRX::iceUpdateRequestHandler(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::iceUpdateRequestHandler(const ::IceInternal::RequestHandlerPtr&
 }
 
 void
-ICE_OBJECT_PRX::iceCopyFrom(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::iceHash() const
+ICE_OBJECT_PRX::__hash() const
 {
     return _reference->hash();
 }
 
 void
-ICE_OBJECT_PRX::iceWrite(OutputStream& os) const
+ICE_OBJECT_PRX::__write(OutputStream& os) const
 {
-    os.write(iceReference()->getIdentity());
-    iceReference()->streamWrite(&os);
+    os.write(__reference()->getIdentity());
+    __reference()->streamWrite(&os);
 }
 
 bool
diff --git a/cpp/src/Ice/ProxyFactory.cpp b/cpp/src/Ice/ProxyFactory.cpp
index cdda57d6ce1..b0037fa9ce5 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->iceReference()->toString();
+        return proxy->__reference()->toString();
     }
     else
     {
@@ -62,7 +62,7 @@ IceInternal::ProxyFactory::proxyToProperty(const ObjectPrxPtr& proxy, const stri
 {
     if(proxy)
     {
-        return proxy->iceReference()->toProperty(prefix);
+        return proxy->__reference()->toProperty(prefix);
     }
     else
     {
diff --git a/cpp/src/Ice/Reference.cpp b/cpp/src/Ice/Reference.cpp
index 228eb017e39..a82b68507b0 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->iceSetRequestHandler(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()->iceReference()->toProperty(prefix + ".Router");
+        PropertyDict routerProperties = _routerInfo->getRouter()->__reference()->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()->iceReference()->toProperty(prefix + ".Locator");
+        PropertyDict locatorProperties = _locatorInfo->getLocator()->__reference()->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 6d5dc493e7a..414d1001220 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->iceSetRequestHandler(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->iceSetRequestHandler(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 3817b58d919..b205b057d7a 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->iceReference()->getEndpoints();
+            _clientEndpoints = _router->__reference()->getEndpoints();
         }
         else
         {
@@ -351,7 +351,7 @@ IceInternal::RouterInfo::setClientEndpoints(const Ice::ObjectPrxPtr& proxy)
                 clientProxy = clientProxy->ice_timeout(_router->ice_getConnection()->timeout());
             }
 
-            _clientEndpoints = clientProxy->iceReference()->getEndpoints();
+            _clientEndpoints = clientProxy->__reference()->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->iceReference()->getEndpoints();
+        _serverEndpoints = serverProxy->__reference()->getEndpoints();
     }
     return _serverEndpoints;
 }
diff --git a/cpp/src/Ice/SlicedData.cpp b/cpp/src/Ice/SlicedData.cpp
index 320763a1bda..6a433ffbe4d 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::iceGcVisitMembers(IceInternal::GCVisitor& visitor)
+Ice::SlicedData::__gcVisitMembers(IceInternal::GCVisitor& visitor)
 {
     //
     // Iterate over the object references in each preserved slice.
@@ -42,7 +42,7 @@ Ice::SlicedData::iceGcVisitMembers(IceInternal::GCVisitor& visitor)
     {
         for(vector<ObjectPtr>::iterator q = (*p)->instances.begin(); q != (*p)->instances.end(); ++q)
         {
-            if(q->get()->iceGcVisit(visitor))
+            if(q->get()->__gcVisit(visitor))
             {
                 *q = 0;
             }
@@ -51,11 +51,11 @@ Ice::SlicedData::iceGcVisitMembers(IceInternal::GCVisitor& visitor)
 }
 
 void
-Ice::UnknownSlicedValue::iceGcVisitMembers(IceInternal::GCVisitor& _v)
+Ice::UnknownSlicedValue::__gcVisitMembers(IceInternal::GCVisitor& _v)
 {
     if(_slicedData)
     {
-        _slicedData->iceGcVisitMembers(_v);
+        _slicedData->__gcVisitMembers(_v);
     }
 }
 
@@ -78,17 +78,17 @@ Ice::UnknownSlicedValue::getSlicedData() const
 }
 
 void
-Ice::UnknownSlicedValue::iceWrite(Ice::OutputStream* iceOs) const
+Ice::UnknownSlicedValue::__write(Ice::OutputStream* __os) const
 {
-    iceOs->startValue(_slicedData);
-    iceOs->endValue();
+    __os->startValue(_slicedData);
+    __os->endValue();
 }
 
 void
-Ice::UnknownSlicedValue::iceRead(Ice::InputStream* iceIs)
+Ice::UnknownSlicedValue::__read(Ice::InputStream* __is)
 {
-    iceIs->startValue();
-    _slicedData = iceIs->endValue(true);
+    __is->startValue();
+    _slicedData = __is->endValue(true);
 }
 
 #ifdef ICE_CPP11_MAPPING
diff --git a/cpp/src/Ice/Thread.cpp b/cpp/src/Ice/Thread.cpp
index 8c3e03cfd46..7882a0a2948 100644
--- a/cpp/src/Ice/Thread.cpp
+++ b/cpp/src/Ice/Thread.cpp
@@ -162,7 +162,7 @@ WINAPI startHook(void* arg)
         //
         // See the comment in IceUtil::Thread::start() for details.
         //
-        rawThread->iceDecRef();
+        rawThread->__decRef();
         thread->run();
     }
     catch(...)
@@ -209,9 +209,9 @@ IceUtil::Thread::start(size_t, int)
     // object could be deleted before the thread object takes
     // ownership. It's also necessary to increment the reference count
     // prior to calling pthread_create since the thread itself calls
-    // iceDecRef().
+    // __decRef().
     //
-    iceIncRef();
+    __incRef();
     _thread.reset(new thread(startHook, this));
 
     _started = true;
@@ -397,7 +397,7 @@ WINAPI startHook(void* arg)
         //
         // See the comment in IceUtil::Thread::start() for details.
         //
-        rawThread->iceDecRef();
+        rawThread->__decRef();
         thread->run();
     }
     catch(...)
@@ -444,9 +444,9 @@ IceUtil::Thread::start(size_t stackSize, int priority)
     // object could be deleted before the thread object takes
     // ownership. It's also necessary to increment the reference count
     // prior to calling pthread_create since the thread itself calls
-    // iceDecRef().
+    // __decRef().
     //
-    iceIncRef();
+    __incRef();
     
     unsigned int id;
     _handle = 
@@ -460,7 +460,7 @@ IceUtil::Thread::start(size_t stackSize, int priority)
     assert(_handle != (HANDLE)-1L);
     if(_handle == 0)
     {
-        iceDecRef();
+        __decRef();
         throw ThreadSyscallException(__FILE__, __LINE__, GetLastError());
     }
     if(SetThreadPriority(_handle, priority) == 0)
@@ -469,7 +469,7 @@ IceUtil::Thread::start(size_t stackSize, int priority)
     }
     if(static_cast<int>(ResumeThread(_handle)) == -1)
     {
-        iceDecRef();
+        __decRef();
         throw ThreadSyscallException(__FILE__, __LINE__, GetLastError());
     }
 
@@ -643,7 +643,7 @@ startHook(void* arg)
         //
         // See the comment in IceUtil::Thread::start() for details.
         //
-        rawThread->iceDecRef();
+        rawThread->__decRef();
         thread->run();
     }
     catch(...)
@@ -695,15 +695,15 @@ IceUtil::Thread::start(size_t stackSize, bool realtimeScheduling, int priority)
     // object could be deleted before the thread object takes
     // ownership. It's also necessary to increment the reference count
     // prior to calling pthread_create since the thread itself calls
-    // iceDecRef().
+    // __decRef().
     //
-    iceIncRef();
+    __incRef();
 
     pthread_attr_t attr;
     int rc = pthread_attr_init(&attr);
     if(rc != 0)
     {
-        iceDecRef();
+        __decRef();
         pthread_attr_destroy(&attr);
         throw ThreadSyscallException(__FILE__, __LINE__, rc);
     }
@@ -722,7 +722,7 @@ IceUtil::Thread::start(size_t stackSize, bool realtimeScheduling, int priority)
         rc = pthread_attr_setstacksize(&attr, stackSize);
         if(rc != 0)
         {
-            iceDecRef();
+            __decRef();
             pthread_attr_destroy(&attr);
             throw ThreadSyscallException(__FILE__, __LINE__, rc);
         }
@@ -733,7 +733,7 @@ IceUtil::Thread::start(size_t stackSize, bool realtimeScheduling, int priority)
         rc = pthread_attr_setschedpolicy(&attr, SCHED_RR);
         if(rc != 0)
         {
-            iceDecRef();
+            __decRef();
             throw ThreadSyscallException(__FILE__, __LINE__, rc);
         }
         sched_param param;
@@ -741,7 +741,7 @@ IceUtil::Thread::start(size_t stackSize, bool realtimeScheduling, int priority)
         rc = pthread_attr_setschedparam(&attr, &param);
         if(rc != 0)
         {
-            iceDecRef();
+            __decRef();
             pthread_attr_destroy(&attr);
             throw ThreadSyscallException(__FILE__, __LINE__, rc);
         }
@@ -751,7 +751,7 @@ IceUtil::Thread::start(size_t stackSize, bool realtimeScheduling, int priority)
     pthread_attr_destroy(&attr);
     if(rc != 0)
     {
-        iceDecRef();
+        __decRef();
         throw ThreadSyscallException(__FILE__, __LINE__, rc);
     }
 
diff --git a/cpp/src/Ice/ThreadPool.cpp b/cpp/src/Ice/ThreadPool.cpp
index 5412db05acc..3769458371b 100644
--- a/cpp/src/Ice/ThreadPool.cpp
+++ b/cpp/src/Ice/ThreadPool.cpp
@@ -373,7 +373,7 @@ IceInternal::ThreadPool::ThreadPool(const InstancePtr& instance, const string& p
             << _sizeWarn;
     }
 
-    iceSetNoDelete(true);
+    __setNoDelete(true);
     try
     {
         for(int i = 0 ; i < _size ; ++i)
@@ -399,15 +399,15 @@ IceInternal::ThreadPool::ThreadPool(const InstancePtr& instance, const string& p
 
         destroy();
         joinWithAllThreads();
-        iceSetNoDelete(false);
+        __setNoDelete(false);
         throw;
     }
     catch(...)
     {
-        iceSetNoDelete(false);
+        __setNoDelete(false);
         throw;
     }
-    iceSetNoDelete(false);
+    __setNoDelete(false);
 }
 
 IceInternal::ThreadPool::~ThreadPool()
diff --git a/cpp/src/Ice/Timer.cpp b/cpp/src/Ice/Timer.cpp
index f85895456d0..c19ba12a92b 100644
--- a/cpp/src/Ice/Timer.cpp
+++ b/cpp/src/Ice/Timer.cpp
@@ -22,18 +22,18 @@ Timer::Timer() :
     Thread("IceUtil timer thread"),
     _destroyed(false)
 {
-    iceSetNoDelete(true);
+    __setNoDelete(true);
     start();
-    iceSetNoDelete(false);
+    __setNoDelete(false);
 }
 
 Timer::Timer(int priority) :
     Thread("IceUtil timer thread"),
     _destroyed(false)
 {
-    iceSetNoDelete(true);
+    __setNoDelete(true);
     start(0, priority);
-    iceSetNoDelete(false);
+    __setNoDelete(false);
 }
 
 void
diff --git a/cpp/src/Ice/Value.cpp b/cpp/src/Ice/Value.cpp
index 1e596f62f56..f5a7f6b1bbf 100644
--- a/cpp/src/Ice/Value.cpp
+++ b/cpp/src/Ice/Value.cpp
@@ -29,25 +29,25 @@ Ice::Value::ice_postUnmarshal()
 }
 
 void
-Ice::Value::iceWrite(Ice::OutputStream* os) const
+Ice::Value::__write(Ice::OutputStream* os) const
 {
     os->startValue(0);
-    iceWriteImpl(os);
+    __writeImpl(os);
     os->endValue();
 }
 
 void
-Ice::Value::iceRead(Ice::InputStream* is)
+Ice::Value::__read(Ice::InputStream* is)
 {
    is->startValue();
-   iceReadImpl(is);
+   __readImpl(is);
    is->endValue(false);
 }
 
 namespace
 {
 
-const string iceC_Ice_Object_ids[] =
+const string __Ice__Object_ids[] =
 {
     "::Ice::Object"
 };
@@ -57,13 +57,13 @@ const string iceC_Ice_Object_ids[] =
 string
 Ice::Value::ice_id() const
 {
-    return iceC_Ice_Object_ids[0];
+    return __Ice__Object_ids[0];
 }
 
 const string&
 Ice::Value::ice_staticId()
 {
-    return iceC_Ice_Object_ids[0];
+    return __Ice__Object_ids[0];
 }
 
 ValuePtr
diff --git a/cpp/src/IceBT/DBus.cpp b/cpp/src/IceBT/DBus.cpp
index 2b40398b39a..9101e88bb60 100644
--- a/cpp/src/IceBT/DBus.cpp
+++ b/cpp/src/IceBT/DBus.cpp
@@ -826,7 +826,7 @@ public:
         // Bump our refcount to ensure this object lives until the reply is received.
         // The pendingFree function will decrement the refcount.
         //
-        iceIncRef();
+        __incRef();
 
         if(!::dbus_pending_call_set_notify(_call, pendingCallCompletedCallback, this, pendingCallFree))
         {
@@ -971,7 +971,7 @@ pendingCallFree(void* userData)
 {
     AsyncResultI* r = static_cast<AsyncResultI*>(userData);
     assert(r);
-    r->iceDecRef();
+    r->__decRef();
 }
 
 static DBusHandlerResult filterCallback(DBusConnection*, DBusMessage*, void*);
@@ -1117,7 +1117,7 @@ public:
         ::dbus_bus_add_match(_connection, "type='signal'", 0);
         //::dbus_bus_add_match(_connection, "type='method_call'", 0);
 
-        iceIncRef(); // iceDecRef called in freeConnection.
+        __incRef(); // __decRef called in freeConnection.
 
         _thread = new HelperThread(this);
         _thread->start();
@@ -1229,7 +1229,7 @@ static void freeConnection(void* p)
 {
     ConnectionI* c = static_cast<ConnectionI*>(p);
     assert(c);
-    c->iceDecRef();
+    c->__decRef();
 }
 
 }
diff --git a/cpp/src/IceGrid/NodeCache.cpp b/cpp/src/IceGrid/NodeCache.cpp
index abac64ac90c..8757dc0fe2b 100644
--- a/cpp/src/IceGrid/NodeCache.cpp
+++ b/cpp/src/IceGrid/NodeCache.cpp
@@ -722,7 +722,7 @@ NodeEntry::getInternalServerDescriptor(const ServerInfo& server, const SessionIP
 }
 
 void
-NodeEntry::iceIncRef()
+NodeEntry::__incRef()
 {
     Lock sync(*this);
     assert(_ref >= 0);
@@ -730,7 +730,7 @@ NodeEntry::iceIncRef()
 }
 
 void
-NodeEntry::iceDecRef()
+NodeEntry::__decRef()
 {
     //
     // The node entry implements its own reference counting. If the
diff --git a/cpp/src/IceGrid/NodeCache.h b/cpp/src/IceGrid/NodeCache.h
index 88b1bf88fa7..1346cdb3ee2 100644
--- a/cpp/src/IceGrid/NodeCache.h
+++ b/cpp/src/IceGrid/NodeCache.h
@@ -62,8 +62,8 @@ public:
     ServerInfo getServerInfo(const ServerInfo&, const SessionIPtr&);
     InternalServerDescriptorPtr getInternalServerDescriptor(const ServerInfo&, const SessionIPtr&);
     
-    void iceIncRef();
-    void iceDecRef();
+    void __incRef();
+    void __decRef();
 
     void checkSession() const;
     void setProxy(const NodePrx&);
diff --git a/cpp/src/IceGrid/NodeSessionI.cpp b/cpp/src/IceGrid/NodeSessionI.cpp
index 9accf0eb7f3..01bbb7679c0 100644
--- a/cpp/src/IceGrid/NodeSessionI.cpp
+++ b/cpp/src/IceGrid/NodeSessionI.cpp
@@ -145,7 +145,7 @@ NodeSessionI::NodeSessionI(const DatabasePtr& database,
     _load(load),
     _destroy(false)
 {
-    iceSetNoDelete(true);
+    __setNoDelete(true);
     try
     {
         _database->getNode(info->name, true)->setSession(this);
@@ -159,7 +159,7 @@ NodeSessionI::NodeSessionI(const DatabasePtr& database,
     }
     catch(const NodeActiveException&)
     {
-        iceSetNoDelete(false);
+        __setNoDelete(false);
         throw;
     }
     catch(...)
@@ -174,10 +174,10 @@ NodeSessionI::NodeSessionI(const DatabasePtr& database,
 
         _database->getNode(info->name)->setSession(0);
 
-        iceSetNoDelete(false);
+        __setNoDelete(false);
         throw;
     }
-    iceSetNoDelete(false);
+    __setNoDelete(false);
 }
 
 void
diff --git a/cpp/src/IceGrid/ReplicaSessionI.cpp b/cpp/src/IceGrid/ReplicaSessionI.cpp
index 983ebd24430..acb3f2e56d2 100644
--- a/cpp/src/IceGrid/ReplicaSessionI.cpp
+++ b/cpp/src/IceGrid/ReplicaSessionI.cpp
@@ -42,7 +42,7 @@ ReplicaSessionI::ReplicaSessionI(const DatabasePtr& database,
     _timestamp(IceUtil::Time::now(IceUtil::Time::Monotonic)),
     _destroy(false)
 {
-    iceSetNoDelete(true);
+    __setNoDelete(true);
     try
     {
         _database->getReplicaCache().add(info->name, this);
@@ -54,7 +54,7 @@ ReplicaSessionI::ReplicaSessionI(const DatabasePtr& database,
     }
     catch(const ReplicaActiveException&)
     {
-        iceSetNoDelete(false);
+        __setNoDelete(false);
         throw;
     }
     catch(...)
@@ -64,10 +64,10 @@ ReplicaSessionI::ReplicaSessionI(const DatabasePtr& database,
 
         _database->getReplicaCache().remove(_info->name, false);
 
-        iceSetNoDelete(false);
+        __setNoDelete(false);
         throw;
     }
-    iceSetNoDelete(false);
+    __setNoDelete(false);
 }
 
 void
diff --git a/cpp/src/IceGridLib/PluginFacadeI.cpp b/cpp/src/IceGridLib/PluginFacadeI.cpp
index 5747f2e0b1d..f84f33dff0b 100644
--- a/cpp/src/IceGridLib/PluginFacadeI.cpp
+++ b/cpp/src/IceGridLib/PluginFacadeI.cpp
@@ -46,12 +46,12 @@ IceGrid::setRegistryPluginFacade(const RegistryPluginFacadePtr& facade)
 #else
     if(pluginFacade)
     {
-        pluginFacade->iceDecRef();
+        pluginFacade->__decRef();
     }
     pluginFacade = facade.get();
     if(pluginFacade)
     {
-        pluginFacade->iceIncRef();
+        pluginFacade->__incRef();
     }
 #endif
 }
diff --git a/cpp/src/IceSSL/OpenSSLEngine.cpp b/cpp/src/IceSSL/OpenSSLEngine.cpp
index 76b4e562afa..84238614220 100644
--- a/cpp/src/IceSSL/OpenSSLEngine.cpp
+++ b/cpp/src/IceSSL/OpenSSLEngine.cpp
@@ -195,7 +195,7 @@ OpenSSLEngine::OpenSSLEngine(const CommunicatorPtr& communicator) :
     _initialized(false),
     _ctx(0)
 {
-    iceSetNoDelete(true);
+    __setNoDelete(true);
 
     //
     // Initialize OpenSSL if necessary.
@@ -325,7 +325,7 @@ OpenSSLEngine::OpenSSLEngine(const CommunicatorPtr& communicator) :
 #  endif
         }
     }
-    iceSetNoDelete(false);
+    __setNoDelete(false);
 }
 
 OpenSSLEngine::~OpenSSLEngine()
diff --git a/cpp/src/IceStorm/Instance.cpp b/cpp/src/IceStorm/Instance.cpp
index 7f92944c498..6d8334cab4d 100644
--- a/cpp/src/IceStorm/Instance.cpp
+++ b/cpp/src/IceStorm/Instance.cpp
@@ -117,7 +117,7 @@ Instance::Instance(
 {
     try
     {
-        iceSetNoDelete(true);
+        __setNoDelete(true);
 
         Ice::PropertiesPtr properties = communicator->getProperties();
         if(properties->getProperty(name + ".TopicManager.AdapterId").empty())
@@ -167,11 +167,11 @@ Instance::Instance(
     {
         shutdown();
         destroy();
-        iceSetNoDelete(false);
+        __setNoDelete(false);
 
         throw;
     }
-    iceSetNoDelete(false);
+    __setNoDelete(false);
 }
 
 Instance::~Instance()
diff --git a/cpp/src/IceStorm/TopicI.cpp b/cpp/src/IceStorm/TopicI.cpp
index c89e3146211..acea59e5c15 100644
--- a/cpp/src/IceStorm/TopicI.cpp
+++ b/cpp/src/IceStorm/TopicI.cpp
@@ -352,7 +352,7 @@ TopicImpl::TopicImpl(
 {
     try
     {
-        iceSetNoDelete(true);
+        __setNoDelete(true);
 
         // TODO: If we want to improve the performance of the
         // non-replicated case we could allocate a null-topic impl here.
@@ -435,10 +435,10 @@ TopicImpl::TopicImpl(
     catch(...)
     {
         shutdown();
-        iceSetNoDelete(false);
+        __setNoDelete(false);
         throw;
     }
-    iceSetNoDelete(false);
+    __setNoDelete(false);
 }
 
 TopicImpl::~TopicImpl()
diff --git a/cpp/src/IceStorm/TopicManagerI.cpp b/cpp/src/IceStorm/TopicManagerI.cpp
index 57f5b619a4b..5c4ad1c6cbc 100644
--- a/cpp/src/IceStorm/TopicManagerI.cpp
+++ b/cpp/src/IceStorm/TopicManagerI.cpp
@@ -255,7 +255,7 @@ TopicManagerImpl::TopicManagerImpl(const PersistentInstancePtr& instance) :
 {
     try
     {
-        iceSetNoDelete(true);
+        __setNoDelete(true);
 
         if(_instance->observer())
         {
@@ -319,10 +319,10 @@ TopicManagerImpl::TopicManagerImpl(const PersistentInstancePtr& instance) :
     catch(...)
     {
         shutdown();
-        iceSetNoDelete(false);
+        __setNoDelete(false);
         throw;
     }
-    iceSetNoDelete(false);
+    __setNoDelete(false);
 }
 
 TopicManagerImpl::~TopicManagerImpl()
diff --git a/cpp/src/IceUtil/Shared.cpp b/cpp/src/IceUtil/Shared.cpp
index c9c924fef27..75b43462398 100644
--- a/cpp/src/IceUtil/Shared.cpp
+++ b/cpp/src/IceUtil/Shared.cpp
@@ -47,14 +47,14 @@ IceUtil::Shared::Shared(const Shared&) :
 }
 
 void
-IceUtil::Shared::iceIncRef()
+IceUtil::Shared::__incRef()
 {
     assert(_ref >= 0);
     ++_ref;
 }
 
 void
-IceUtil::Shared::iceDecRef()
+IceUtil::Shared::__decRef()
 {
     assert(_ref > 0);
     if(--_ref == 0 && !(_flags & NoDelete))
@@ -64,13 +64,13 @@ IceUtil::Shared::iceDecRef()
 }
 
 int
-IceUtil::Shared::iceGetRef() const
+IceUtil::Shared::__getRef() const
 {
     return _ref;
 }
 
 void
-IceUtil::Shared::iceSetNoDelete(bool b)
+IceUtil::Shared::__setNoDelete(bool b)
 {
     _flags = b ? (_flags | NoDelete) : (_flags & ~NoDelete);
 }
diff --git a/cpp/src/Slice/CPlusPlusUtil.cpp b/cpp/src/Slice/CPlusPlusUtil.cpp
index bbdff8765af..4ae02b9372f 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 << " iceP_" << fixedName << ";";
+            out << nl << s << " ___" << fixedName << ";";
         }
     }
 }
@@ -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 + "iceP_" + fixedName;
+    string escapedParamName = objPrefix + "___" + fixedName;
 
     SequencePtr seq = SequencePtr::dynamicCast(type);
     if(seq)
@@ -269,7 +269,7 @@ writeParamEndCode(Output& out, const TypePtr& type, bool optional, const string&
                 {
                     out << nl << "if(" << escapedParamName << ")";
                     out << sb;
-                    out << nl << paramName << ".iceSetIsSet();";
+                    out << nl << paramName << ".__setIsSet();";
                     out << nl << "if(!" << escapedParamName << "->empty())";
                     out << sb;
                     out << nl << paramName << "->first" << " = &(*" << escapedParamName << ")[0];";
@@ -301,7 +301,7 @@ writeParamEndCode(Output& out, const TypePtr& type, bool optional, const string&
             {
                 out << nl << "if(" << escapedParamName << ")";
                 out << sb;
-                out << nl << paramName << ".iceSetIsSet();";
+                out << nl << paramName << ".__setIsSet();";
                 out << nl << paramName << "->first = (*" << escapedParamName << ").begin();";
                 out << nl << paramName << "->second = (*" << escapedParamName << ").end();";
                 out << eb;
@@ -317,12 +317,10 @@ 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 = "",
-                            const string& stream = "")
+                            bool prepend, int typeCtx, const string& retP = "", const string& obj = "")
 {
     string prefix = prepend ? paramPrefix : "";
-    string returnValueS = retP.empty() ? string("iceRet") : retP;
-    string streamTarget = stream.empty() ? (marshal ? "iceOs" : "iceIs") : stream;
+    string returnValueS = retP.empty() ? string("__ret") : retP;
 
     string objPrefix = obj.empty() ? obj : obj + ".";
 
@@ -353,11 +351,11 @@ writeMarshalUnmarshalParams(Output& out, const ParamDeclList& params, const Oper
             out << nl;
             if(marshal)
             {
-                out << streamTarget << "->writeAll";
+                out << "__os->writeAll";
             }
             else
             {
-                out << streamTarget << "->readAll";
+                out << "__is->readAll";
             }
             out << spar;
             for(ParamDeclList::const_iterator p = requiredParams.begin(); p != requiredParams.end(); ++p)
@@ -409,11 +407,11 @@ writeMarshalUnmarshalParams(Output& out, const ParamDeclList& params, const Oper
             out << nl;
             if(marshal)
             {
-                out << streamTarget << "->writeAll";
+                out << "__os->writeAll";
             }
             else
             {
-                out << streamTarget << "->readAll";
+                out << "__is->readAll";
             }
             out << spar;
 
@@ -496,7 +494,7 @@ writeMarshalUnmarshalParams(Output& out, const ParamDeclList& params, const Oper
 }
 
 Slice::FeatureProfile Slice::featureProfile = Slice::Ice;
-string Slice::paramPrefix = "iceP_";
+string Slice::paramPrefix = "__p_";
 
 char
 Slice::ToIfdef::operator()(char c)
@@ -1257,7 +1255,7 @@ Slice::writeMarshalUnmarshalCode(Output& out, const TypePtr& type, bool optional
     ostringstream os;
     if(str.empty())
     {
-        os << (marshal ? "iceOs" : "iceIs");
+        os << (marshal ? "__os" : "__is");
     }
     else
     {
@@ -1304,13 +1302,13 @@ Slice::writeMarshalUnmarshalCode(Output& out, const TypePtr& type, bool optional
                     return;
                 }
 
-                out << nl << func << objPrefix << "iceP_" << param << ");";
+                out << nl << func << objPrefix << "___" << param << ");";
                 writeParamEndCode(out, seq, optional, param, metaData, obj);
                 return;
             }
             else if(seqType.find("%range") == 0)
             {
-                out << nl << func << objPrefix << "iceP_" << param << ");";
+                out << nl << func << objPrefix << "___" << param << ");";
                 writeParamEndCode(out, seq, optional, param, metaData, obj);
                 return;
             }
@@ -1321,10 +1319,9 @@ Slice::writeMarshalUnmarshalCode(Output& out, const TypePtr& type, bool optional
 }
 
 void
-Slice::writeMarshalCode(Output& out, const ParamDeclList& params, const OperationPtr& op, bool prepend, int typeCtx,
-                        const string& streamTarget)
+Slice::writeMarshalCode(Output& out, const ParamDeclList& params, const OperationPtr& op, bool prepend, int typeCtx)
 {
-    writeMarshalUnmarshalParams(out, params, op, true, prepend, typeCtx, "", "", streamTarget);
+    writeMarshalUnmarshalParams(out, params, op, true, prepend, typeCtx);
 }
 
 void
@@ -1338,7 +1335,7 @@ void
 Slice::writeAllocateCode(Output& out, const ParamDeclList& params, const OperationPtr& op, bool prepend, int typeCtx)
 {
     string prefix = prepend ? paramPrefix : "";
-    string returnValueS = "iceRet";
+    string returnValueS = "__ret";
 
     for(ParamDeclList::const_iterator p = params.begin(); p != params.end(); ++p)
     {
@@ -1376,11 +1373,11 @@ Slice::getEndArg(const TypePtr& type, const StringList& metaData, const string&
                builtin->kind() != Builtin::KindObject &&
                builtin->kind() != Builtin::KindObjectProxy)
             {
-                endArg = "iceP_" + endArg;
+                endArg = "___" + endArg;
             }
             else if(!builtin || builtin->kind() != Builtin::KindByte)
             {
-                endArg = "iceP_" + endArg;
+                endArg = "___" + endArg;
             }
         }
         else if(seqType.find("%range") == 0)
@@ -1390,7 +1387,7 @@ Slice::getEndArg(const TypePtr& type, const StringList& metaData, const string&
             {
                 md.push_back("cpp:type:" + seqType.substr(strlen("%range:")));
             }
-            endArg = "iceP_" + endArg;
+            endArg = "___" + endArg;
         }
     }
     return endArg;
@@ -1406,7 +1403,7 @@ Slice::writeEndCode(Output& out, const ParamDeclList& params, const OperationPtr
     }
     if(op && op->returnType())
     {
-        writeParamEndCode(out, op->returnType(), op->returnIsOptional(), "iceRet", op->getMetaData());
+        writeParamEndCode(out, op->returnType(), op->returnIsOptional(), "__ret", op->getMetaData());
     }
 }
 
@@ -1432,7 +1429,7 @@ Slice::writeMarshalUnmarshalAllInHolder(IceUtilInternal::Output& out,
         return;
     }
 
-    string stream = marshal ? "iceOs" : "iceIs";
+    string stream = marshal ? "__os" : "__is";
     string streamOp = marshal ? "writeAll" : "readAll";
 
     out << nl << stream << "->" << streamOp;
@@ -1522,15 +1519,15 @@ Slice::writeStreamHelpers(Output& out,
         out << nl << "template<typename S>";
         out << nl << "struct StreamWriter" << (cpp11 ? "<" : "< ") << fullName << ", S>";
         out << sb;
-
         if(requiredMembers.empty() && optionalMembers.empty())
         {
             out << nl << "static void write(S*, const " << fullName << "&)";
         }
         else
         {
-            out << nl << "static void write(S* iceOs, const " << fullName << "& v)";
+            out << nl << "static void write(S* __os, const " << fullName << "& v)";
         }
+
         out << sb;
 
         if(cpp11)
@@ -1561,14 +1558,13 @@ Slice::writeStreamHelpers(Output& out,
     out << nl << "template<typename S>";
     out << nl << "struct StreamReader" << (cpp11 ? "<" : "< ") << fullName << ", S>";
     out << sb;
-
     if (requiredMembers.empty() && optionalMembers.empty())
     {
         out << nl << "static void read(S*, " << fullName << "&)";
     }
     else
     {
-        out << nl << "static void read(S* iceIs, " << fullName << "& v)";
+        out << nl << "static void read(S* __is, " << fullName << "& v)";
     }
 
     out << sb;
diff --git a/cpp/src/Slice/CPlusPlusUtil.h b/cpp/src/Slice/CPlusPlusUtil.h
index 3c6dcc652c2..0e359b9a1a7 100644
--- a/cpp/src/Slice/CPlusPlusUtil.h
+++ b/cpp/src/Slice/CPlusPlusUtil.h
@@ -52,8 +52,7 @@ 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,
-                      const std::string& = "");
+void writeMarshalCode(::IceUtilInternal::Output&, const ParamDeclList&, const OperationPtr&, bool, int = 0);
 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);
diff --git a/cpp/src/Slice/Parser.cpp b/cpp/src/Slice/Parser.cpp
index 77038503d92..e6e8fb768a6 100644
--- a/cpp/src/Slice/Parser.cpp
+++ b/cpp/src/Slice/Parser.cpp
@@ -425,14 +425,12 @@ string
 Slice::Contained::flattenedScope() const
 {
     string s = scope();
-    const string doubleColon = "::";
-
-    size_t pos = 0;
-    while((pos = s.find(doubleColon, pos)) != string::npos)
+    string flattenedScope;
+    for(string::const_iterator r = s.begin(); r != s.end(); ++r)
     {
-        s.replace(pos++, doubleColon.length(), "_");
+        flattenedScope += ((*r) == ':') ? '_' : *r;
     }
-    return s;
+    return flattenedScope;
 }
 
 string
@@ -3807,13 +3805,13 @@ Slice::ClassDef::ClassDef(const ContainerPtr& container, const string& name, int
 bool
 Slice::Proxy::isLocal() const
 {
-    return _classDM->isLocal();
+    return __class->isLocal();
 }
 
 string
 Slice::Proxy::typeId() const
 {
-    return _classDM->scoped();
+    return __class->scoped();
 }
 
 bool
@@ -3837,13 +3835,13 @@ Slice::Proxy::isVariableLength() const
 ClassDeclPtr
 Slice::Proxy::_class() const
 {
-    return _classDM;
+    return __class;
 }
 
 Slice::Proxy::Proxy(const ClassDeclPtr& cl) :
      SyntaxTreeBase(cl->unit()),
      Type(cl->unit()),
-    _classDM(cl)
+    __class(cl)
 {
 }
 
diff --git a/cpp/src/Slice/Parser.h b/cpp/src/Slice/Parser.h
index cb009a76837..c26de803f13 100644
--- a/cpp/src/Slice/Parser.h
+++ b/cpp/src/Slice/Parser.h
@@ -707,7 +707,7 @@ public:
 
 protected:
 
-    ClassDeclPtr _classDM;
+    ClassDeclPtr __class;
 };
 
 // ----------------------------------------------------------------------
diff --git a/cpp/src/slice2cpp/Gen.cpp b/cpp/src/slice2cpp/Gen.cpp
index 94a555d0e63..ad125388647 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* iceOs)";
+        C << "[&](::Ice::OutputStream* __os)";
         C << sb;
         writeMarshalCode(C, inParams, 0, true, TypeContextInParam | TypeContextCpp11);
         if(p->sendsClasses(false))
         {
-            C << nl << "iceOs->writePendingValues();";
+            C << nl << "__os->writePendingValues();";
         }
         C << eb;
     }
@@ -267,11 +267,11 @@ throwUserExceptionLambda(IceUtilInternal::Output& C, ExceptionList throws)
         //
         throws.sort(Slice::DerivedToBaseCompare());
 
-        C << "[](const ::Ice::UserException& iceEx)";
+        C << "[](const ::Ice::UserException& __ex)";
         C << sb;
         C << nl << "try";
         C << sb;
-        C << nl << "iceEx.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* iceSliceChecksums[] =";
+            C << sp << nl << "const char* __sliceChecksums[] =";
             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 iceSliceChecksumInit(iceSliceChecksums);";
+            C << nl << "const IceInternal::SliceChecksumInit __sliceChecksumInit(__sliceChecksums);";
             C << sp << nl << "}";
         }
     }
@@ -949,7 +949,7 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p)
     {
         string typeName = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring);
         allTypes.push_back(typeName);
-        allParamDecls.push_back(typeName + " iceP_" + fixKwd((*q)->name()));
+        allParamDecls.push_back(typeName + " __ice_" + fixKwd((*q)->name()));
     }
 
     if(base)
@@ -957,7 +957,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("iceP_" + fixKwd((*q)->name()));
+            baseParams.push_back("__ice_" + fixKwd((*q)->name()));
         }
     }
 
@@ -1012,7 +1012,7 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p)
 
     if(!p->isLocal())
     {
-        string initName = "iceC" + p->flattenedScope() + p->name() + "_init";
+        string initName = p->flattenedScope() + p->name() + "_init";
 
         C << sp << nl << "namespace";
         C << nl << "{";
@@ -1025,10 +1025,10 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p)
 
     if(p->isLocal())
     {
-        C << sp << nl << scoped.substr(2) << "::" << name << spar << "const char* iceFile" << "int iceLine" << epar
+        C << sp << nl << scoped.substr(2) << "::" << name << spar << "const char* __file" << "int __line" << epar
           << " :";
         C.inc();
-        emitUpcall(base, "(iceFile, iceLine)", true);
+        emitUpcall(base, "(__file, __line)", true);
         if(p->hasDefaultValues())
         {
             C << ", ";
@@ -1054,7 +1054,7 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p)
         C << scoped.substr(2) << "::" << name << spar;
         if(p->isLocal())
         {
-            C << "const char* iceFile" << "int iceLine";
+            C << "const char* __file" << "int __line";
         }
         C << allParamDecls << epar;
         if(p->isLocal() || !baseParams.empty() || !params.empty())
@@ -1067,7 +1067,7 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p)
                 upcall = "(";
                 if(p->isLocal())
                 {
-                    upcall += "iceFile, iceLine";
+                    upcall += "__file, __line";
                 }
                 for(vector<string>::const_iterator pi = baseParams.begin(); pi != baseParams.end(); ++pi)
                 {
@@ -1091,7 +1091,7 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p)
             {
                 C << ",";
             }
-            C << nl << *pi << "(iceP_" << *pi << ')';
+            C << nl << *pi << "(__ice_" << *pi << ')';
         }
         if(p->isLocal() || !baseParams.empty() || !params.empty())
         {
@@ -1134,10 +1134,10 @@ Slice::Gen::TypesVisitor::visitExceptionStart(const ExceptionPtr& p)
     {
         if(!base || (base && !base->usesClasses(false)))
         {
-            H << sp << nl << "virtual bool iceUsesClasses() const;";
+            H << sp << nl << "virtual bool __usesClasses() const;";
 
             C << sp << nl << "bool";
-            C << nl << scoped.substr(2) << "::iceUsesClasses() const";
+            C << nl << scoped.substr(2) << "::__usesClasses() const";
             C << sb;
             C << nl << "return true;";
             C << eb;
@@ -1167,62 +1167,62 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
 
         if(preserved && !basePreserved)
         {
-            H << sp << nl << "virtual void iceWrite(::Ice::OutputStream*) const;";
-            H << nl << "virtual void iceRead(::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 << "::iceWrite;";
-            H << nl << "using " << baseName << "::iceRead;";
+            H << nl << "using " << baseName << "::__write;";
+            H << nl << "using " << baseName << "::__read;";
         }
 
         H.dec();
         H << sp << nl << "protected:";
         H.inc();
 
-        H << sp << nl << "virtual void iceWriteImpl(::Ice::OutputStream*) const;";
-        H << nl << "virtual void iceReadImpl(::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) << "::iceWrite(::Ice::OutputStream* iceOs) const";
+            C << sp << nl << "void" << nl << scoped.substr(2) << "::__write(::Ice::OutputStream* __os) const";
             C << sb;
-            C << nl << "iceOs->startException(_slicedData);";
-            C << nl << "iceWriteImpl(iceOs);";
-            C << nl << "iceOs->endException();";
+            C << nl << "__os->startException(__slicedData);";
+            C << nl << "__writeImpl(__os);";
+            C << nl << "__os->endException();";
             C << eb;
 
-            C << sp << nl << "void" << nl << scoped.substr(2) << "::iceRead(::Ice::InputStream* iceIs)";
+            C << sp << nl << "void" << nl << scoped.substr(2) << "::__read(::Ice::InputStream* __is)";
             C << sb;
-            C << nl << "iceIs->startException();";
-            C << nl << "iceReadImpl(iceIs);";
-            C << nl << "_slicedData = iceIs->endException(true);";
+            C << nl << "__is->startException();";
+            C << nl << "__readImpl(__is);";
+            C << nl << "__slicedData = __is->endException(true);";
             C << eb;
         }
 
-        C << sp << nl << "void" << nl << scoped.substr(2) << "::iceWriteImpl(::Ice::OutputStream* iceOs) const";
+        C << sp << nl << "void" << nl << scoped.substr(2) << "::__writeImpl(::Ice::OutputStream* __os) const";
         C << sb;
-        C << nl << "iceOs->startSlice(\"" << p->scoped() << "\", -1, " << (!base ? "true" : "false") << ");";
-        C << nl << "Ice::StreamWriter< ::" << scoped.substr(2) << ", ::Ice::OutputStream>::write(iceOs, *this);";
-        C << nl << "iceOs->endSlice();";
+        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();";
         if(base)
         {
-            emitUpcall(base, "::iceWriteImpl(iceOs);");
+            emitUpcall(base, "::__writeImpl(__os);");
         }
         C << eb;
 
-        C << sp << nl << "void" << nl << scoped.substr(2) << "::iceReadImpl(::Ice::InputStream* iceIs)";
+        C << sp << nl << "void" << nl << scoped.substr(2) << "::__readImpl(::Ice::InputStream* __is)";
         C << sb;
-        C << nl << "iceIs->startSlice();";
-        C << nl << "Ice::StreamReader< ::" << scoped.substr(2) << ", ::Ice::InputStream>::read(iceIs, *this);";
-        C << nl << "iceIs->endSlice();";
+        C << nl << "__is->startSlice();";
+        C << nl << "Ice::StreamReader< ::" << scoped.substr(2) << ", ::Ice::InputStream>::read(__is, *this);";
+        C << nl << "__is->endSlice();";
         if(base)
         {
-            emitUpcall(base, "::iceReadImpl(iceIs);");
+            emitUpcall(base, "::__readImpl(__is);");
         }
         C << eb;
     }
@@ -1238,7 +1238,7 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
         if(!_doneStaticSymbol)
         {
             _doneStaticSymbol = true;
-            H << sp << nl << "static " << name << " iceS_" << p->name() << "_init;";
+            H << sp << nl << "static " << name << " __" << p->name() << "_init;";
         }
     }
 
@@ -1304,7 +1304,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 + " iceP_" + (*q)->name());
+            paramDecls.push_back(typeName + " __ice_" + (*q)->name());
         }
 
         H << nl;
@@ -1322,7 +1322,7 @@ Slice::Gen::TypesVisitor::visitStructStart(const StructPtr& p)
                 H << ',';
             }
             string memberName = fixKwd((*q)->name());
-            H << nl << memberName << '(' << "iceP_" << (*q)->name() << ')';
+            H << nl << memberName << '(' << "__ice_" << (*q)->name() << ')';
         }
 
         H.dec();
@@ -1356,34 +1356,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 << "& iceRhs) const";
+        H << sp << nl << "bool operator==(const " << name << "& __rhs) const";
         H << sb;
-        H << nl << "if(this == &iceRhs)";
+        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 << " != iceRhs." << *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 << "& iceRhs) const";
+        H << sp << nl << "bool operator<(const " << name << "& __rhs) const";
         H << sb;
-        H << nl << "if(this == &iceRhs)";
+        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 << " < iceRhs." << *pi << ')';
+            H << nl << "if(" << *pi << " < __rhs." << *pi << ')';
             H << sb;
             H << nl << "return true;";
             H << eb;
-            H << nl << "else if(iceRhs." << *pi << " < " << *pi << ')';
+            H << nl << "else if(__rhs." << *pi << " < " << *pi << ')';
             H << sb;
             H << nl << "return false;";
             H << eb;
@@ -1391,21 +1391,21 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p)
         H << nl << "return false;";
         H << eb;
 
-        H << sp << nl << "bool operator!=(const " << name << "& iceRhs) const";
+        H << sp << nl << "bool operator!=(const " << name << "& __rhs) const";
         H << sb;
-        H << nl << "return !operator==(iceRhs);";
+        H << nl << "return !operator==(__rhs);";
         H << eb;
-        H << nl << "bool operator<=(const " << name << "& iceRhs) const";
+        H << nl << "bool operator<=(const " << name << "& __rhs) const";
         H << sb;
-        H << nl << "return operator<(iceRhs) || operator==(iceRhs);";
+        H << nl << "return operator<(__rhs) || operator==(__rhs);";
         H << eb;
-        H << nl << "bool operator>(const " << name << "& iceRhs) const";
+        H << nl << "bool operator>(const " << name << "& __rhs) const";
         H << sb;
-        H << nl << "return !operator<(iceRhs) && !operator==(iceRhs);";
+        H << nl << "return !operator<(__rhs) && !operator==(__rhs);";
         H << eb;
-        H << nl << "bool operator>=(const " << name << "& iceRhs) const";
+        H << nl << "bool operator>=(const " << name << "& __rhs) const";
         H << sb;
-        H << nl << "return !operator<(iceRhs);";
+        H << nl << "return !operator<(__rhs);";
         H << eb;
     }
     H << eb << ';';
@@ -1586,7 +1586,7 @@ Slice::Gen::ProxyDeclVisitor::visitClassDecl(const ClassDeclPtr& p)
     string scoped = fixKwd(p->scoped());
 
     H << sp << nl << "class " << name << ';';
-    H << nl << _dllExport << "void iceRead(::Ice::InputStream*, ::IceInternal::ProxyHandle< ::IceProxy"
+    H << nl << _dllExport << "void __read(::Ice::InputStream*, ::IceInternal::ProxyHandle< ::IceProxy"
       << scoped << ">&);";
     H << nl << _dllExport << "::IceProxy::Ice::Object* upCast(::IceProxy" << scoped << "*);";
 }
@@ -1693,7 +1693,7 @@ Slice::Gen::ProxyVisitor::visitClassDefStart(const ClassDefPtr& p)
         H << sp << nl << "protected:";
         H.inc();
 
-        H << sp << nl << "virtual Object* iceNewInstance() const = 0;";
+        H << sp << nl << "virtual Object* __newInstance() const = 0;";
         H << eb << ';';
     }
 
@@ -1723,11 +1723,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 << "iceRead(::Ice::InputStream* iceIs, "
+    C << nl << "void" << nl << "::IceProxy" << scope << "__read(::Ice::InputStream* __is, "
       << "::IceInternal::ProxyHandle< ::IceProxy" << scoped << ">& v)";
     C << sb;
     C << nl << "::Ice::ObjectPrx proxy;";
-    C << nl << "iceIs->read(proxy);";
+    C << nl << "__is->read(proxy);";
     C << nl << "if(!proxy)";
     C << sb;
     C << nl << "v = 0;";
@@ -1735,7 +1735,7 @@ Slice::Gen::ProxyVisitor::visitClassDefStart(const ClassDefPtr& p)
     C << nl << "else";
     C << sb;
     C << nl << "v = new ::IceProxy" << scoped << ';';
-    C << nl << "v->iceCopyFrom(proxy);";
+    C << nl << "v->__copyFrom(proxy);";
     C << eb;
     C << eb;
 
@@ -1754,12 +1754,12 @@ Slice::Gen::ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p)
     H.dec();
     H << sp << nl << "protected: ";
     H.inc();
-    H << sp << nl << _dllMemberExport << "virtual ::IceProxy::Ice::Object* iceNewInstance() const;";
+    H << sp << nl << _dllMemberExport << "virtual ::IceProxy::Ice::Object* __newInstance() const;";
     H << eb << ';';
 
     C << sp;
     C << nl << "::IceProxy::Ice::Object*";
-    C << nl << "IceProxy" << scoped << "::iceNewInstance() const";
+    C << nl << "IceProxy" << scoped << "::__newInstance() const";
     C << sb;
     C << nl << "return new " << name << ";";
     C << eb;
@@ -1809,7 +1809,7 @@ void
 Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p)
 {
     string name = p->name();
-    string flatName = "iceC" + p->flattenedScope() + p->name() + "_name";
+    string flatName = p->flattenedScope() + p->name() + "_name";
     string scoped = fixKwd(p->scoped());
     string scope = fixKwd(p->scope());
 
@@ -1889,12 +1889,12 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p)
     }
 
     //
-    // Check if we need to generate a private iceI_end_ method. This is the case if the
+    // Check if we need to generate a private ___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 iceI_end method which is used by the
+    // For this purpose, we generate a special ___end method which is used by the
     // completed implementation of the generated Callback_Inft_opName operation
     // delegate.
     //
@@ -1903,65 +1903,65 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p)
     {
         string typeStringEndAMI = outputTypeToString(ret, p->returnIsOptional(), p->getMetaData(),
                                                      _useWstring | TypeContextAMIPrivateEnd);
-        outParamsDeclEndAMI.push_back(typeStringEndAMI + ' ' + "iceRet");
+        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& iceCtx = ::Ice::noExplicitContext" << epar;
+      << "const ::Ice::Context& __ctx = ::Ice::noExplicitContext" << epar;
     H << sb << nl;
     if(ret)
     {
         H << "return ";
     }
-    H << "end_" << name << spar << outParamNamesAMI << "iceI_begin_" + name << spar << argsAMI;
-    H << "iceCtx" << "::IceInternal::dummyCallback" << "0" << "true" << epar << epar << ';';
+    H << "end_" << name << spar << outParamNamesAMI << "__begin_" + name << spar << argsAMI;
+    H << "__ctx" << "::IceInternal::__dummyCallback" << "0" << "true" << epar << epar << ';';
     H << eb;
 
     H << sp << nl << "::Ice::AsyncResultPtr begin_" << name << spar << paramsDeclAMI
-      << "const ::Ice::Context& iceCtx = ::Ice::noExplicitContext" << epar;
+      << "const ::Ice::Context& __ctx = ::Ice::noExplicitContext" << epar;
     H << sb;
-    H << nl << "return iceI_begin_" << name << spar << argsAMI << "iceCtx" << "::IceInternal::dummyCallback" << "0"
+    H << nl << "return __begin_" << name << spar << argsAMI << "__ctx" << "::IceInternal::__dummyCallback" << "0"
       << epar << ';';
     H << eb;
 
     H << sp << nl << "::Ice::AsyncResultPtr begin_" << name << spar << paramsDeclAMI
-      << "const ::Ice::CallbackPtr& iceDel"
-      << "const ::Ice::LocalObjectPtr& iceCookie = 0" << epar;
+      << "const ::Ice::CallbackPtr& __del"
+      << "const ::Ice::LocalObjectPtr& __cookie = 0" << epar;
     H << sb;
-    H << nl << "return iceI_begin_" << name << spar << argsAMI << "::Ice::noExplicitContext" << "iceDel" << "iceCookie" << epar << ';';
+    H << nl << "return __begin_" << name << spar << argsAMI << "::Ice::noExplicitContext" << "__del" << "__cookie" << epar << ';';
     H << eb;
 
     H << sp << nl << "::Ice::AsyncResultPtr begin_" << name << spar << paramsDeclAMI
-      << "const ::Ice::Context& iceCtx"
-      << "const ::Ice::CallbackPtr& iceDel"
-      << "const ::Ice::LocalObjectPtr& iceCookie = 0" << epar;
+      << "const ::Ice::Context& __ctx"
+      << "const ::Ice::CallbackPtr& __del"
+      << "const ::Ice::LocalObjectPtr& __cookie = 0" << epar;
     H << sb;
-    H << nl << "return iceI_begin_" << name << spar << argsAMI << "iceCtx" << "iceDel" << "iceCookie" << epar << ';';
+    H << nl << "return __begin_" << name << spar << argsAMI << "__ctx" << "__del" << "__cookie" << epar << ';';
     H << eb;
 
     H << sp << nl << "::Ice::AsyncResultPtr begin_" << name << spar << paramsDeclAMI
-      << "const " + delNameScoped + "Ptr& iceDel"
-      << "const ::Ice::LocalObjectPtr& iceCookie = 0" << epar;
+      << "const " + delNameScoped + "Ptr& __del"
+      << "const ::Ice::LocalObjectPtr& __cookie = 0" << epar;
     H << sb;
-    H << nl << "return iceI_begin_" << name << spar << argsAMI << "::Ice::noExplicitContext" << "iceDel" << "iceCookie" << epar << ';';
+    H << nl << "return __begin_" << name << spar << argsAMI << "::Ice::noExplicitContext" << "__del" << "__cookie" << epar << ';';
     H << eb;
 
     H << sp << nl << "::Ice::AsyncResultPtr begin_" << name << spar << paramsDeclAMI
-      << "const ::Ice::Context& iceCtx"
-      << "const " + delNameScoped + "Ptr& iceDel"
-      << "const ::Ice::LocalObjectPtr& iceCookie = 0" << epar;
+      << "const ::Ice::Context& __ctx"
+      << "const " + delNameScoped + "Ptr& __del"
+      << "const ::Ice::LocalObjectPtr& __cookie = 0" << epar;
     H << sb;
-    H << nl << "return iceI_begin_" << name << spar << argsAMI << "iceCtx" << "iceDel" << "iceCookie" << epar << ';';
+    H << nl << "return __begin_" << name << spar << argsAMI << "__ctx" << "__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 iceI_end_" << name << spar << outParamsDeclEndAMI;
+        H << sp << nl << _dllMemberExport << "void ___end_" << name << spar << outParamsDeclEndAMI;
         H << "const ::Ice::AsyncResultPtr&" << epar << ';';
     }
 
@@ -1969,71 +1969,71 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p)
     H.dec();
     H << nl << "private:";
     H.inc();
-    H << sp << nl << _dllMemberExport << "::Ice::AsyncResultPtr iceI_begin_" << name << spar
+    H << sp << nl << _dllMemberExport << "::Ice::AsyncResultPtr __begin_" << name << spar
       << paramsAMI << "const ::Ice::Context&"
       << "const ::IceInternal::CallbackBasePtr&"
-      << "const ::Ice::LocalObjectPtr& iceCookie = 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 << "iceI_begin_" << name << spar << paramsDeclAMI
-      << "const ::Ice::Context& iceCtx" << "const ::IceInternal::CallbackBasePtr& iceDel"
-      << "const ::Ice::LocalObjectPtr& iceCookie" << "bool sync" << epar;
+    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 << sb;
     if(p->returnsData())
     {
-        C << nl << "iceCheckTwowayOnly(" << flatName <<  ", sync);";
+        C << nl << "__checkTwowayOnly(" << flatName <<  ", sync);";
     }
-    C << nl << "::IceInternal::OutgoingAsyncPtr iceResult = new ::IceInternal::CallbackOutgoing(this, " << flatName
-        << ", iceDel, iceCookie, sync);";
+    C << nl << "::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::CallbackOutgoing(this, " << flatName
+        << ", __del, __cookie, sync);";
     C << nl << "try";
     C << sb;
-    C << nl << "iceResult->prepare(" << flatName << ", " << operationModeToString(p->sendMode()) << ", iceCtx);";
+    C << nl << "__result->prepare(" << flatName << ", " << operationModeToString(p->sendMode()) << ", __ctx);";
     if(inParams.empty())
     {
-        C << nl << "iceResult->writeEmptyParams();";
+        C << nl << "__result->writeEmptyParams();";
     }
     else
     {
-        C << nl << "::Ice::OutputStream* iceOs = iceResult->startWriteParams(" << opFormatTypeToString(p) <<");";
+        C << nl << "::Ice::OutputStream* __os = __result->startWriteParams(" << opFormatTypeToString(p) <<");";
         writeMarshalCode(C, inParams, 0, true, TypeContextInParam);
         if(p->sendsClasses(false))
         {
-            C << nl << "iceOs->writePendingValues();";
+            C << nl << "__os->writePendingValues();";
         }
-        C << nl << "iceResult->endWriteParams();";
+        C << nl << "__result->endWriteParams();";
     }
-    C << nl << "iceResult->invoke(" << flatName << ");";
+    C << nl << "__result->invoke(" << flatName << ");";
     C << eb;
-    C << nl << "catch(const ::Ice::Exception& iceEx)";
+    C << nl << "catch(const ::Ice::Exception& __ex)";
     C << sb;
-    C << nl << "iceResult->abort(iceEx);";
+    C << nl << "__result->abort(__ex);";
     C << eb;
-    C << nl << "return iceResult;";
+    C << nl << "return __result;";
     C << eb;
 
     C << sp << nl << retS << nl << "IceProxy" << scope << "end_" << name << spar << outParamsDeclAMI
-      << "const ::Ice::AsyncResultPtr& iceResult" << epar;
+      << "const ::Ice::AsyncResultPtr& __result" << epar;
     C << sb;
     if(p->returnsData())
     {
-        C << nl << "::Ice::AsyncResult::iceCheck(iceResult, this, " << flatName << ");";
+        C << nl << "::Ice::AsyncResult::__check(__result, this, " << flatName << ");";
 
         //
         // COMPILERFIX: It's necessary to generate the allocate code here before
-        // this if(!iceResult->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(!iceResult->iceWait())";
+        C << nl << "if(!__result->__wait())";
         C << sb;
         C << nl << "try";
         C << sb;
-        C << nl << "iceResult->iceThrowUserException();";
+        C << nl << "__result->__throwUserException();";
         C << eb;
         //
         // Generate a catch block for each legal user exception.
@@ -2054,33 +2054,33 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p)
             C << nl << "throw;";
             C << eb;
         }
-        C << nl << "catch(const ::Ice::UserException& iceEx)";
+        C << nl << "catch(const ::Ice::UserException& __ex)";
         C << sb;
-        C << nl << "throw ::Ice::UnknownUserException(__FILE__, __LINE__, iceEx.ice_id());";
+        C << nl << "throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_id());";
         C << eb;
         C << eb;
         if(ret || !outParams.empty())
         {
-            C << nl << "::Ice::InputStream* iceIs = iceResult->iceStartReadParams();";
+            C << nl << "::Ice::InputStream* __is = __result->__startReadParams();";
             writeUnmarshalCode(C, outParams, p, true, _useWstring | TypeContextAMIEnd);
             if(p->returnsClasses(false))
             {
-                C << nl << "iceIs->readPendingValues();";
+                C << nl << "__is->readPendingValues();";
             }
-            C << nl << "iceResult->iceEndReadParams();";
+            C << nl << "__result->__endReadParams();";
         }
         else
         {
-            C << nl << "iceResult->iceReadEmptyParams();";
+            C << nl << "__result->__readEmptyParams();";
         }
         if(ret)
         {
-            C << nl << "return iceRet;";
+            C << nl << "return __ret;";
         }
     }
     else
     {
-        C << nl << "iceEnd(iceResult, " << flatName << ");";
+        C << nl << "__end(__result, " << flatName << ");";
     }
     C << eb;
 
@@ -2088,15 +2088,15 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p)
     {
         assert(p->returnsData());
 
-        C << sp << nl << "void IceProxy" << scope << "iceI_end_" << name << spar << outParamsDeclEndAMI
-          << "const ::Ice::AsyncResultPtr& iceResult" << epar;
+        C << sp << nl << "void IceProxy" << scope << "___end_" << name << spar << outParamsDeclEndAMI
+          << "const ::Ice::AsyncResultPtr& __result" << epar;
         C << sb;
-        C << nl << "::Ice::AsyncResult::iceCheck(iceResult, this, " << flatName << ");";
-        C << nl << "if(!iceResult->iceWait())";
+        C << nl << "::Ice::AsyncResult::__check(__result, this, " << flatName << ");";
+        C << nl << "if(!__result->__wait())";
         C << sb;
         C << nl << "try";
         C << sb;
-        C << nl << "iceResult->iceThrowUserException();";
+        C << nl << "__result->__throwUserException();";
         C << eb;
         //
         // Generate a catch block for each legal user exception.
@@ -2117,25 +2117,25 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p)
             C << nl << "throw;";
             C << eb;
         }
-        C << nl << "catch(const ::Ice::UserException& iceEx)";
+        C << nl << "catch(const ::Ice::UserException& __ex)";
         C << sb;
-        C << nl << "throw ::Ice::UnknownUserException(__FILE__, __LINE__, iceEx.ice_id());";
+        C << nl << "throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_id());";
         C << eb;
         C << eb;
 
         if(ret || !outParams.empty())
         {
-            C << nl << "::Ice::InputStream* iceIs = iceResult->iceStartReadParams();";
+            C << nl << "::Ice::InputStream* __is = __result->__startReadParams();";
             writeUnmarshalCode(C, outParams, p, true, _useWstring | TypeContextAMIPrivateEnd);
             if(p->returnsClasses(false))
             {
-                C << nl << "iceIs->readPendingValues();";
+                C << nl << "__is->readPendingValues();";
             }
-            C << nl << "iceResult->iceEndReadParams();";
+            C << nl << "__result->__endReadParams();";
         }
         else
         {
-            C << nl << "iceResult->iceReadEmptyParams();";
+            C << nl << "__result->__readEmptyParams();";
         }
         C << eb;
     }
@@ -2181,7 +2181,7 @@ Slice::Gen::ObjectDeclVisitor::visitClassDecl(const ClassDeclPtr& p)
         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 icePatch(" << p->name() << "Ptr&, const ::Ice::ObjectPtr&);";
+        H << nl << _dllExport << "void __patch(" << p->name() << "Ptr&, const ::Ice::ObjectPtr&);";
     }
     else
     {
@@ -2196,7 +2196,7 @@ Slice::Gen::ObjectDeclVisitor::visitOperation(const OperationPtr& p)
     ClassDefPtr cl = ClassDefPtr::dynamicCast(p->container());
     if(cl && !cl->isLocal())
     {
-        string flatName = "iceC" + p->flattenedScope() + p->name() + "_name";
+        string flatName = p->flattenedScope() + p->name() + "_name";
         C << sp << nl << "const ::std::string " << flatName << " = \"" << p->name() << "\";";
     }
 }
@@ -2329,7 +2329,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 + " iceP_" + (*q)->name());
+        allParamDecls.push_back(typeName + " __ice_" + (*q)->name());
     }
 
     if(!p->isInterface())
@@ -2382,8 +2382,8 @@ Slice::Gen::ObjectVisitor::visitClassDefStart(const ClassDefPtr& p)
             C << sb;
             if(!p->isAbstract())
             {
-                C << nl << "::Ice::Object* iceP = new " << name << "(*this);";
-                C << nl << "return iceP;";
+                C << nl << "::Ice::Object* __p = new " << name << "(*this);";
+                C << nl << "return __p;";
             }
             else
             {
@@ -2425,7 +2425,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 = "iceC" + p->flattenedScope() + p->name() + "_ids";
+        string flatName = p->flattenedScope() + p->name() + "_ids";
 
         C << sp << nl << "namespace";
         C << nl << "{";
@@ -2527,9 +2527,9 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p)
             allOpNames.unique();
 
             H << sp;
-            H << nl << "virtual bool iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&);";
+            H << nl << "virtual bool __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);";
 
-            string flatName = "iceC" + p->flattenedScope() + p->name() + "_all";
+            string flatName = p->flattenedScope() + p->name() + "_all";
             C << sp << nl << "namespace";
             C << nl << "{";
             C << nl << "const ::std::string " << flatName << "[] =";
@@ -2547,7 +2547,7 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p)
             C << sp << nl << "}";
             C << sp;
             C << nl << "bool";
-            C << nl << scoped.substr(2) << "::iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)";
+            C << nl << scoped.substr(2) << "::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)";
             C << sb;
 
             C << nl << "::std::pair< const ::std::string*, const ::std::string*> r = "
@@ -2566,7 +2566,7 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p)
             {
                 C << nl << "case " << i++ << ':';
                 C << sb;
-                C << nl << "return iceD_" << *q << "(in, current);";
+                C << nl << "return ___" << *q << "(in, current);";
                 C << eb;
             }
             C << nl << "default:";
@@ -2597,7 +2597,7 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p)
                 H << nl
                   << "virtual ::Ice::Int ice_operationAttributes(const ::std::string&) const;";
 
-                string opAttrFlatName = "iceC" + p->flattenedScope() + p->name() + "_operationAttributes";
+                string opAttrFlatName = p->flattenedScope() + p->name() + "_operationAttributes";
 
                 C << sp << nl << "namespace";
                 C << nl << "{";
@@ -2652,8 +2652,8 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p)
         if(preserved && !basePreserved)
         {
             H << sp;
-            H << nl << "virtual void iceWrite(::Ice::OutputStream*) const;";
-            H << nl << "virtual void iceRead(::Ice::InputStream*);";
+            H << nl << "virtual void __write(::Ice::OutputStream*) const;";
+            H << nl << "virtual void __read(::Ice::InputStream*);";
         }
 
         H.dec();
@@ -2661,49 +2661,49 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p)
         inProtected = true;
         H.inc();
 
-        H << sp << nl << "virtual void iceWriteImpl(::Ice::OutputStream*) const;";
-        H << nl << "virtual void iceReadImpl(::Ice::InputStream*);";
+        H << sp << nl << "virtual void __writeImpl(::Ice::OutputStream*) const;";
+        H << nl << "virtual void __readImpl(::Ice::InputStream*);";
 
         if(preserved && !basePreserved)
         {
             C << sp;
-            C << nl << "void" << nl << scoped.substr(2) << "::iceWrite(::Ice::OutputStream* iceOs) const";
+            C << nl << "void" << nl << scoped.substr(2) << "::__write(::Ice::OutputStream* __os) const";
             C << sb;
-            C << nl << "iceOs->startValue(_slicedData);";
-            C << nl << "iceWriteImpl(iceOs);";
-            C << nl << "iceOs->endValue();";
+            C << nl << "__os->startValue(__slicedData);";
+            C << nl << "__writeImpl(__os);";
+            C << nl << "__os->endValue();";
             C << eb;
 
             C << sp;
-            C << nl << "void" << nl << scoped.substr(2) << "::iceRead(::Ice::InputStream* iceIs)";
+            C << nl << "void" << nl << scoped.substr(2) << "::__read(::Ice::InputStream* __is)";
             C << sb;
-            C << nl << "iceIs->startValue();";
-            C << nl << "iceReadImpl(iceIs);";
-            C << nl << "_slicedData = iceIs->endValue(true);";
+            C << nl << "__is->startValue();";
+            C << nl << "__readImpl(__is);";
+            C << nl << "__slicedData = __is->endValue(true);";
             C << eb;
         }
 
         C << sp;
-        C << nl << "void" << nl << scoped.substr(2) << "::iceWriteImpl(::Ice::OutputStream* iceOs) const";
+        C << nl << "void" << nl << scoped.substr(2) << "::__writeImpl(::Ice::OutputStream* __os) const";
         C << sb;
-        C << nl << "iceOs->startSlice(ice_staticId(), " << p->compactId() << (!base ? ", true" : ", false") << ");";
-        C << nl << "Ice::StreamWriter< ::" << scoped.substr(2) << ", ::Ice::OutputStream>::write(iceOs, *this);";
-        C << nl << "iceOs->endSlice();";
+        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();";
         if(base)
         {
-            emitUpcall(base, "::iceWriteImpl(iceOs);");
+            emitUpcall(base, "::__writeImpl(__os);");
         }
         C << eb;
 
         C << sp;
-        C << nl << "void" << nl << scoped.substr(2) << "::iceReadImpl(::Ice::InputStream* iceIs)";
+        C << nl << "void" << nl << scoped.substr(2) << "::__readImpl(::Ice::InputStream* __is)";
         C << sb;
-        C << nl << "iceIs->startSlice();";
-        C << nl << "Ice::StreamReader< ::" << scoped.substr(2) << ", ::Ice::InputStream>::read(iceIs, *this);";
-        C << nl << "iceIs->endSlice();";
+        C << nl << "__is->startSlice();";
+        C << nl << "Ice::StreamReader< ::" << scoped.substr(2) << ", ::Ice::InputStream>::read(__is, *this);";
+        C << nl << "__is->endSlice();";
         if(base)
         {
-            emitUpcall(base, "::iceReadImpl(iceIs);");
+            emitUpcall(base, "::__readImpl(__is);");
         }
         C << eb;
 
@@ -2714,13 +2714,13 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p)
 
             if(!p->isAbstract())
             {
-                string initName = "iceC" + p->flattenedScope() + p->name() + "_init";
+                string initName = p->flattenedScope() + p->name() + "_init";
                 C << nl << "const ::IceInternal::DefaultValueFactoryInit< " << scoped << "> "
                   << initName << "(\"" << p->scoped() << "\");";
             }
             if(p->compactId() >= 0)
             {
-                string initName = "iceC" + p->flattenedScope() + p->name() + "_compactIdInit";
+                string initName = p->flattenedScope() + p->name() + "_compactIdInit";
                 C << nl << "const ::IceInternal::CompactIdInit "
                   << initName << "(\"" << p->scoped() << "\", " << p->compactId() << ");";
             }
@@ -2787,7 +2787,7 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p)
             H.inc();
             inProtected = true;
         }
-        H << sp << nl << "::Ice::SlicedDataPtr _slicedData;";
+        H << sp << nl << "::Ice::SlicedDataPtr __slicedData;";
     }
 
     if(generateFriend)
@@ -2835,7 +2835,7 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p)
     else
     {
         C << sp << nl << "void " << _dllExport;
-        C << nl << scope.substr(2) << "icePatch(" << p->name() << "Ptr& handle, const ::Ice::ObjectPtr& v)";
+        C << nl << scope.substr(2) << "__patch(" << p->name() << "Ptr& handle, const ::Ice::ObjectPtr& v)";
         C << sb;
         C << nl << "handle = " << scope << p->name() << "Ptr::dynamicCast(v);";
         C << nl << "if(v && !handle)";
@@ -2892,8 +2892,8 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p)
     string classScopedAMD = classScope + classNameAMD;
 
     string paramsAMD = "(const " + classScopedAMD + '_' + name + "Ptr&, ";
-    string paramsDeclAMD = "(const " + classScopedAMD + '_' + name + "Ptr& iceCb, ";
-    string argsAMD = "(new IceAsync" + classScopedAMD + '_' + name + "(iceInS), ";
+    string paramsDeclAMD = "(const " + classScopedAMD + '_' + name + "Ptr& __cb, ";
+    string argsAMD = "(new IceAsync" + classScopedAMD + '_' + name + "(__inS), ";
 
     ParamDeclList inParams;
     ParamDeclList outParams;
@@ -2956,8 +2956,8 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p)
         }
 
         params += "const ::Ice::Current& = ::Ice::noExplicitCurrent)";
-        paramsDecl += "const ::Ice::Current& iceCurrent)";
-        args += "iceCurrent)";
+        paramsDecl += "const ::Ice::Current& __current)";
+        args += "__current)";
     }
     else
     {
@@ -2967,8 +2967,8 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p)
     }
 
     paramsAMD += "const ::Ice::Current& = ::Ice::noExplicitCurrent)";
-    paramsDeclAMD += "const ::Ice::Current& iceCurrent)";
-    argsAMD += "iceCurrent)";
+    paramsDeclAMD += "const ::Ice::Current& __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,32 +2987,32 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p)
 
     if(!cl->isLocal())
     {
-        H << nl << "bool iceD_" << name << "(::IceInternal::Incoming&, const ::Ice::Current&)" << isConst << ';';
+        H << nl << "bool ___" << name << "(::IceInternal::Incoming&, const ::Ice::Current&)" << isConst << ';';
 
         C << sp;
-        C << nl << "bool" << nl << scope.substr(2) << "iceD_" << name << "(::IceInternal::Incoming& iceInS"
-          << ", const ::Ice::Current& iceCurrent)" << isConst;
+        C << nl << "bool" << nl << scope.substr(2) << "___" << name << "(::IceInternal::Incoming& __inS"
+          << ", const ::Ice::Current& __current)" << isConst;
         C << sb;
-        C << nl << "iceCheckMode(" << operationModeToString(p->mode()) << ", iceCurrent.mode);";
+        C << nl << "__checkMode(" << operationModeToString(p->mode()) << ", __current.mode);";
 
         if(!inParams.empty())
         {
-            C << nl << "::Ice::InputStream* iceIs = iceInS.startReadParams();";
+            C << nl << "::Ice::InputStream* __is = __inS.startReadParams();";
             writeAllocateCode(C, inParams, 0, true, _useWstring | TypeContextInParam);
             writeUnmarshalCode(C, inParams, 0, true, TypeContextInParam);
             if(p->sendsClasses(false))
             {
-                C << nl << "iceIs->readPendingValues();";
+                C << nl << "__is->readPendingValues();";
             }
-            C << nl << "iceInS.endReadParams();";
+            C << nl << "__inS.endReadParams();";
         }
         else
         {
-            C << nl << "iceInS.readEmptyParams();";
+            C << nl << "__inS.readEmptyParams();";
         }
         if(p->format() != DefaultFormat)
         {
-            C << nl << "iceInS.setFormat(" << opFormatTypeToString(p) << ");";
+            C << nl << "__inS.setFormat(" << opFormatTypeToString(p) << ");";
         }
 
         if(!amd)
@@ -3020,22 +3020,22 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p)
             writeAllocateCode(C, outParams, 0, true, _useWstring);
             if(ret)
             {
-                C << retS << " iceRet = ";
+                C << retS << " __ret = ";
             }
             C << fixKwd(name) << args << ';';
             if(ret || !outParams.empty())
             {
-                C << nl << "::Ice::OutputStream* iceOs = iceInS.startWriteParams();";
+                C << nl << "::Ice::OutputStream* __os = __inS.startWriteParams();";
                 writeMarshalCode(C, outParams, p, true);
                 if(p->returnsClasses(false))
                 {
-                    C << nl << "iceOs->writePendingValues();";
+                    C << nl << "__os->writePendingValues();";
                 }
-                C << nl << "iceInS.endWriteParams();";
+                C << nl << "__inS.endWriteParams();";
             }
             else
             {
-                C << nl << "iceInS.writeEmptyParams();";
+                C << nl << "__inS.writeEmptyParams();";
             }
             C << nl << "return false;";
         }
@@ -3082,16 +3082,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& iceDel"
-          << "const ::Ice::LocalObjectPtr& iceCookie = 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& iceDel"
-          << "const ::Ice::LocalObjectPtr& iceCookie = 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 +3126,7 @@ Slice::Gen::ObjectVisitor::emitGCFunctions(const ClassDefPtr& p)
     bool preserved = basePreserved || p->hasMetaData("preserve-slice");
 
     //
-    // iceGcVisit() is overridden by the basemost class that can be
+    // __gcVisit() 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 +3134,22 @@ Slice::Gen::ObjectVisitor::emitGCFunctions(const ClassDefPtr& p)
     //
     if(canBeCyclic || (preserved && !basePreserved))
     {
-        H << nl << "virtual void iceGcVisitMembers(::IceInternal::GCVisitor&);";
+        H << nl << "virtual void __gcVisitMembers(::IceInternal::GCVisitor&);";
 
-        C << sp << nl << "void" << nl << scoped.substr(2) << "::iceGcVisitMembers(::IceInternal::GCVisitor& _v)";
+        C << sp << nl << "void" << nl << scoped.substr(2) << "::__gcVisitMembers(::IceInternal::GCVisitor& _v)";
         C << sb;
 
         bool hasCyclicBase = base && base->canBeCyclic();
         if(hasCyclicBase || basePreserved)
         {
-            emitUpcall(bases.front(), "::iceGcVisitMembers(_v);");
+            emitUpcall(bases.front(), "::__gcVisitMembers(_v);");
         }
 
         if(preserved && !basePreserved)
         {
-            C << nl << "if(_slicedData)";
+            C << nl << "if(__slicedData)";
             C << sb;
-            C << nl << "_slicedData->iceGcVisitMembers(_v);";
+            C << nl << "__slicedData->__gcVisitMembers(_v);";
             C << eb;
         }
 
@@ -3188,11 +3188,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())->iceGcVisit(_v)))";
+            C << nl << "if((" << scope << "upCast(" << prefix << name << ".get())->__gcVisit(_v)))";
         }
         else
         {
-            C << nl << "if((" << prefix << name << ".get())->iceGcVisit(_v))";
+            C << nl << "if((" << prefix << name << ".get())->__gcVisit(_v))";
         }
         C << sb;
         C << nl << prefix << name << " = 0;";
@@ -3276,7 +3276,7 @@ Slice::Gen::ObjectVisitor::emitVirtualBaseInitializers(const ClassDefPtr& p, boo
         {
             upcall += ", ";
         }
-        upcall += "iceP_" + (*q)->name();
+        upcall += "__ice_" + (*q)->name();
     }
     upcall += ")";
 
@@ -3304,7 +3304,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) ?
-                                                    (" iceP_" + (*q)->name()) : (" /*iceP_" + (*q)->name() + "*/")));
+                                                    (" __ice_" + (*q)->name()) : (" /*__ice_" + (*q)->name() + "*/")));
         }
 
         H << sp << nl;
@@ -3344,7 +3344,7 @@ Slice::Gen::ObjectVisitor::emitOneShotConstructor(const ClassDefPtr& p)
                 H << ',' << nl;
             }
             string memberName = fixKwd((*q)->name());
-            H << memberName << '(' << "iceP_" << (*q)->name() << ')';
+            H << memberName << '(' << "__ice_" << (*q)->name() << ')';
         }
 
         H.dec();
@@ -3491,7 +3491,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(), "iceRet");
+    string retEndArg = getEndArg(ret, p->getMetaData(), "__ret");
 
     ParamDeclList outParams;
     vector<string> outArgs;
@@ -3592,10 +3592,10 @@ Slice::Gen::AsyncCallbackTemplateVisitor::generateOperation(const OperationPtr&
         //
         // completed.
         //
-        H << sp << nl << "virtual void completed(const ::Ice::AsyncResultPtr& iceResult) const";
+        H << sp << nl << "virtual void completed(const ::Ice::AsyncResultPtr& __result) const";
         H << sb;
-        H << nl << clScope << clName << "Prx iceProxy = " << clScope << clName
-          << "Prx::uncheckedCast(iceResult->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 +3606,23 @@ Slice::Gen::AsyncCallbackTemplateVisitor::generateOperation(const OperationPtr&
             {
                 H << retEndArg << " = ";
             }
-            H << "iceProxy->end_" << p->name() << spar << outEndArgs << "iceResult" << epar << ';';
+            H << "__proxy->end_" << p->name() << spar << outEndArgs << "__result" << epar << ';';
         }
         else
         {
-            H << "iceProxy->iceI_end_" << p->name() << spar << outEndArgs;
+            H << "__proxy->___end_" << p->name() << spar << outEndArgs;
             if(ret)
             {
                 H << retEndArg;
             }
-            H << "iceResult" << epar << ';';
+            H << "__result" << epar << ';';
         }
         writeEndCode(H, outParams, p);
         H << eb;
         H << nl << "catch(const ::Ice::Exception& ex)";
         H << sb;
 
-        H << nl << "" << baseD << "::exception(iceResult, ex);";
+        H << nl << "" << baseD << "::exception(__result, ex);";
         H << nl << "return;";
         H << eb;
         H << nl << "if(_response)";
@@ -3630,12 +3630,12 @@ Slice::Gen::AsyncCallbackTemplateVisitor::generateOperation(const OperationPtr&
         H << nl << "(" << baseD << "::_callback.get()->*_response)" << spar;
         if(ret)
         {
-            H << "iceRet";
+            H << "__ret";
         }
         H << outArgs;
         if(withCookie)
         {
-            H << "CT::dynamicCast(iceResult->getCookie())";
+            H << "CT::dynamicCast(__result->getCookie())";
         }
         H << epar << ';';
         H << eb;
@@ -4085,7 +4085,7 @@ Slice::Gen::AsyncVisitor::visitOperation(const OperationPtr& p)
     vector<string> paramsDeclInvoke;
 
     paramsInvoke.push_back("const " + proxyName + "&");
-    paramsDeclInvoke.push_back("const " + proxyName + "& icePrx");
+    paramsDeclInvoke.push_back("const " + proxyName + "& __prx");
 
     TypePtr ret = p->returnType();
     string retS = inputTypeToString(ret, p->returnIsOptional(), p->getMetaData(), _useWstring);
@@ -4094,8 +4094,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 + " iceRet");
-        args.push_back("iceRet");
+        paramsDecl.push_back(retS + " __ret");
+        args.push_back("__ret");
     }
 
     ParamDeclList inParams;
@@ -4126,7 +4126,7 @@ Slice::Gen::AsyncVisitor::visitOperation(const OperationPtr& p)
     }
 
     paramsInvoke.push_back("const ::Ice::Context&");
-    paramsDeclInvoke.push_back("const ::Ice::Context& iceCtx");
+    paramsDeclInvoke.push_back("const ::Ice::Context& __ctx");
 
     if(cl->hasMetaData("amd") || p->hasMetaData("amd"))
     {
@@ -4245,8 +4245,8 @@ Slice::Gen::AsyncImplVisitor::visitOperation(const OperationPtr& p)
         params += retS;
         paramsDecl += retS;
         paramsDecl += ' ';
-        paramsDecl += "iceRet";
-        args += "iceRet";
+        paramsDecl += "__ret";
+        args += "__ret";
     }
 
     ParamDeclList outParams;
@@ -4303,11 +4303,11 @@ Slice::Gen::AsyncImplVisitor::visitOperation(const OperationPtr& p)
     C << sb;
     if(ret || !outParams.empty())
     {
-        C << nl << "::Ice::OutputStream* iceOs = startWriteParams();";
+        C << nl << "::Ice::OutputStream* __os = startWriteParams();";
         writeMarshalCode(C, outParams, p, false, TypeContextInParam);
         if(p->returnsClasses(false))
         {
-            C << nl << "iceOs->writePendingValues();";
+            C << nl << "__os->writePendingValues();";
         }
         C << nl << "endWriteParams();";
     }
@@ -5134,11 +5134,11 @@ Slice::Gen::Cpp11DeclVisitor::visitClassDefStart(const ClassDefPtr& p)
         C << sp;
 
         C << nl << "const ::IceInternal::DefaultValueFactoryInit<" << fixKwd(p->scoped()) << "> ";
-        C << "iceC" + p->flattenedScope() + p->name() + "_init" << "(\"" << p->scoped() << "\");";
+        C << p->flattenedScope() + p->name() + "_init" << "(\"" << p->scoped() << "\");";
 
         if(p->compactId() >= 0)
         {
-            string n = "iceC" + p->flattenedScope() + p->name() + "_compactIdInit ";
+            string n = p->flattenedScope() + p->name() + "_compactIdInit ";
             C << "const ::IceInternal::CompactIdInit " << n << "(\"" << p->scoped() << "\", " << p->compactId() << ");";
         }
     }
@@ -5158,7 +5158,7 @@ Slice::Gen::Cpp11DeclVisitor::visitClassDefStart(const ClassDefPtr& p)
         ids.merge(other);
         ids.unique();
 
-        C << nl << "const ::std::string iceC" << p->flattenedScope() << p->name() << "_ids[" << ids.size() << "] =";
+        C << nl << "const ::std::string " << p->flattenedScope() << p->name() << "_ids[" << ids.size() << "] =";
         C << sb;
         for(StringList::const_iterator r = ids.begin(); r != ids.end();)
         {
@@ -5179,7 +5179,7 @@ Slice::Gen::Cpp11DeclVisitor::visitClassDefStart(const ClassDefPtr& p)
         allOpNames.sort();
         allOpNames.unique();
 
-        C << nl << "const ::std::string iceC" << p->flattenedScope() << p->name() << "_ops[] =";
+        C << nl << "const ::std::string " << p->flattenedScope() << p->name() << "_ops[] =";
         C << sb;
         for(StringList::const_iterator q = allOpNames.begin(); q != allOpNames.end();)
         {
@@ -5205,7 +5205,7 @@ Slice::Gen::Cpp11DeclVisitor::visitExceptionStart(const ExceptionPtr& p)
 
     C << sp;
     C << nl << "const ::IceInternal::DefaultUserExceptionFactoryInit<" << fixKwd(p->scoped()) << "> ";
-    C << "iceC" + p->flattenedScope() + p->name() + "_init" << "(\"" << p->scoped() << "\");";
+    C << p->flattenedScope() + p->name() + "_init" << "(\"" << p->scoped() << "\");";
     return false;
 }
 
@@ -5215,7 +5215,7 @@ Slice::Gen::Cpp11DeclVisitor::visitOperation(const OperationPtr& p)
     ClassDefPtr cl = ClassDefPtr::dynamicCast(p->container());
     if(cl && !cl->isLocal())
     {
-        string flatName = "iceC" + p->flattenedScope() + p->name() + "_name";
+        string flatName = p->flattenedScope() + p->name() + "_name";
         C << nl << "const ::std::string " << flatName << " = \"" << p->name() << "\";";
     }
 }
@@ -5288,7 +5288,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("iceP_" + (*q)->name()));
+        allParamDecls.push_back(typeName + " " + fixKwd("__ice_" + (*q)->name()));
     }
 
     if(base)
@@ -5296,7 +5296,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("iceP_" + (*q)->name()));
+            baseParams.push_back(fixKwd("__ice_" + (*q)->name()));
         }
     }
 
@@ -5321,9 +5321,9 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionStart(const ExceptionPtr& p)
 
     if(p->isLocal())
     {
-        H << sp << nl << name << "(const char* iceFile, int iceLine) : ";
+        H << sp << nl << name << "(const char* __ice_file, int __ice_line) : ";
         H << "::Ice::LocalExceptionHelper" << "<" << templateParameters << ">";
-        H << "(iceFile, iceLine)";
+        H << "(__ice_file, __ice_line)";
         H << sb;
         H << eb;
     }
@@ -5337,7 +5337,7 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionStart(const ExceptionPtr& p)
         H << sp << nl << name << "(";
         if(p->isLocal())
         {
-            H << "const char* iceFile, int iceLine";
+            H << "const char* __ice_file, int __ice_line";
             if(!allParamDecls.empty())
             {
                 H << ", ";
@@ -5359,7 +5359,7 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionStart(const ExceptionPtr& p)
             H << nl << "::" << helperClass << "<" << templateParameters << ">" << "(";
             if(p->isLocal())
             {
-                H << "iceFile, iceLine";
+                H << "__ice_file, __ice_line";
                 if(!baseDataMembers.empty())
                 {
                     H << ", ";
@@ -5374,11 +5374,11 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionStart(const ExceptionPtr& p)
                 }
                 if(isMovable((*q)->type()))
                 {
-                    H << "::std::move(" << fixKwd("iceP_" + (*q)->name()) << ")";
+                    H << "::std::move(" << fixKwd("__ice_" + (*q)->name()) << ")";
                 }
                 else
                 {
-                    H << fixKwd("iceP_" + (*q)->name());
+                    H << fixKwd("__ice_" + (*q)->name());
                 }
             }
 
@@ -5391,7 +5391,7 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionStart(const ExceptionPtr& p)
         else if(p->isLocal())
         {
             H << " ::Ice::LocalExceptionHelper" << "<" << templateParameters << ">";
-            H << "(iceFile, iceLine)";
+            H << "(__ice_file, __ice_line)";
             if(!dataMembers.empty())
             {
                 H << ",";
@@ -5406,11 +5406,11 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionStart(const ExceptionPtr& p)
             }
             if(isMovable((*q)->type()))
             {
-                H << nl << fixKwd((*q)->name()) << "(::std::move(" << fixKwd("iceP_" + (*q)->name()) << "))";
+                H << nl << fixKwd((*q)->name()) << "(::std::move(" << fixKwd("__ice_" + (*q)->name()) << "))";
             }
             else
             {
-                H << nl << fixKwd((*q)->name()) << "(" << fixKwd("iceP_" + (*q)->name()) << ")";
+                H << nl << fixKwd((*q)->name()) << "(" << fixKwd("__ice_" + (*q)->name()) << ")";
             }
         }
 
@@ -5444,10 +5444,10 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionStart(const ExceptionPtr& p)
     {
         if(!base || (base && !base->usesClasses(false)))
         {
-            H << sp << nl << _dllMemberExport << "virtual bool iceUsesClasses() const override;";
+            H << sp << nl << _dllMemberExport << "virtual bool __usesClasses() const override;";
 
             C << sp << nl << "bool";
-            C << nl << scoped.substr(2) << "::iceUsesClasses() const";
+            C << nl << scoped.substr(2) << "::__usesClasses() const";
             C << sb;
             C << nl << "return true;";
             C << eb;
@@ -5477,23 +5477,23 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
 
         if(preserved && !basePreserved)
         {
-            H << sp << nl << _dllMemberExport << "virtual void iceWrite(::Ice::OutputStream*) const override;";
-            H << nl << _dllMemberExport << "virtual void iceRead(::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) << "::iceWrite(::Ice::OutputStream* iceOs) const";
+            C << sp << nl << "void" << nl << scoped.substr(2) << "::__write(::Ice::OutputStream* __os) const";
             C << sb;
-            C << nl << "iceOs->startException(_slicedData);";
-            C << nl << "iceWriteImpl(iceOs);";
-            C << nl << "iceOs->endException();";
+            C << nl << "__os->startException(__slicedData);";
+            C << nl << "__writeImpl(__os);";
+            C << nl << "__os->endException();";
             C << eb;
 
-            C << sp << nl << "void" << nl << scoped.substr(2) << "::iceRead(::Ice::InputStream* iceIs)";
+            C << sp << nl << "void" << nl << scoped.substr(2) << "::__read(::Ice::InputStream* __is)";
             C << sb;
-            C << nl << "iceIs->startException();";
-            C << nl << "iceReadImpl(iceIs);";
-            C << nl << "_slicedData = iceIs->endException(true);";
+            C << nl << "__is->startException();";
+            C << nl << "__readImpl(__is);";
+            C << nl << "__slicedData = __is->endException(true);";
             C << eb;
         }
     }
@@ -5509,7 +5509,7 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
         if(!_doneStaticSymbol)
         {
             _doneStaticSymbol = true;
-            H << sp << nl << "static " << name << " iceS_" << p->name() << "_init;";
+            H << sp << nl << "static " << name << " __" << p->name() << "_init;";
         }
     }
 
@@ -5715,7 +5715,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> iceNewInstance() const override;";
+    H << nl << _dllMemberExport << "virtual ::std::shared_ptr<::Ice::ObjectPrx> __newInstance() const override;";
     H << eb << ';';
 
     string suffix = p->isInterface() ? "" : "Disp";
@@ -5723,7 +5723,7 @@ Slice::Gen::Cpp11ProxyVisitor::visitClassDefEnd(const ClassDefPtr& p)
 
     C << sp;
     C << nl << "::std::shared_ptr<::Ice::ObjectPrx>";
-    C << nl << scoped.substr(2) << "::iceNewInstance() const";
+    C << nl << scoped.substr(2) << "::__newInstance() const";
     C << sb;
     C << nl << "return ::IceInternal::createProxy<" << prx << ">();";
     C << eb;
@@ -5740,7 +5740,7 @@ void
 Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p)
 {
     string name = p->name();
-    string flatName = "iceC" + p->flattenedScope() + p->name() + "_name";
+    string flatName = p->flattenedScope() + p->name() + "_name";
 
     TypePtr ret = p->returnType();
 
@@ -5839,7 +5839,7 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p)
     // Synchronous operation
     //
     H << sp << nl << deprecateSymbol << retS << ' ' << fixKwd(name) << spar << paramsDecl;
-    H << "const ::Ice::Context& iceCtx = Ice::noExplicitContext" << epar;
+    H << "const ::Ice::Context& __ctx = Ice::noExplicitContext" << epar;
     H << sb;
     H << nl;
     if(futureOutParams.size() == 1)
@@ -5855,27 +5855,27 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p)
     }
     else if(futureOutParams.size() > 1)
     {
-        H << "auto iceResult = ";
+        H << "auto __result = ";
     }
 
     H << "makePromiseOutgoing<" << futureT << ">";
 
-    H << spar << "true, this" << string("&" + scoped + "iceI_" + name);
+    H << spar << "true, this" << string("&" + scoped + "__" + name);
     for(ParamDeclList::const_iterator q = inParams.begin(); q != inParams.end(); ++q)
     {
         H << fixKwd(paramPrefix + (*q)->name());
     }
-    H << "iceCtx" << epar << ".get();";
+    H << "__ctx" << 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()), "iceResult." + fixKwd((*q)->name())) + ";";
+            H << condMove(isMovable((*q)->type()), "__result." + fixKwd((*q)->name())) + ";";
         }
         if(ret)
         {
-            H << nl << "return " + condMove(isMovable(ret), "iceResult." + returnValueS) + ";";
+            H << nl << "return " + condMove(isMovable(ret), "__result." + returnValueS) + ";";
         }
     }
     H << eb;
@@ -5886,7 +5886,7 @@ 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& iceCtx = Ice::noExplicitContext" << epar;
+    H << "const ::Ice::Context& __ctx = Ice::noExplicitContext" << epar;
     H.inc();
     H << nl << "-> decltype(::std::declval<P<" << futureT << ">>().get_future())";
     H.dec();
@@ -5894,12 +5894,12 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p)
 
     H << nl << "return makePromiseOutgoing<" << futureT << ", P>" << spar;
 
-    H << "false, this" << string("&" + scoped + "iceI_" + name);
+    H << "false, this" << string("&" + scoped + "__" + name);
     for(ParamDeclList::const_iterator q = inParams.begin(); q != inParams.end(); ++q)
     {
         H << fixKwd(paramPrefix + (*q)->name());
     }
-    H << "iceCtx" << epar << ";";
+    H << "__ctx" << epar << ";";
     H << eb;
 
 
@@ -5937,13 +5937,13 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p)
     }
 
     H << "::std::function<void" << spar << lambdaOutParams << epar << ">"
-        + condString(!lambdaCustomOut, " iceResponse") + ",";
+        + condString(!lambdaCustomOut, " __response") + ",";
     H << nl << "::std::function<void(::std::exception_ptr)>"
-        + condString(!lambdaCustomOut, " iceEx") + " = nullptr,";
+        + condString(!lambdaCustomOut, " __ex") + " = nullptr,";
     H << nl << "::std::function<void(bool)>"
-        + condString(!lambdaCustomOut," iceSent") + " = nullptr,";
+        + condString(!lambdaCustomOut," __sent") + " = nullptr,";
     H << nl << "const ::Ice::Context&"
-        + condString(!lambdaCustomOut, "iceCtx") + " = Ice::noExplicitContext)" + condString(lambdaCustomOut, ";");
+        + condString(!lambdaCustomOut, "__ctx") + " = Ice::noExplicitContext)" + condString(lambdaCustomOut, ";");
 
     H.restoreIndent();
     if(lambdaCustomOut)
@@ -5964,36 +5964,36 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p)
             }
             C << nl;
         }
-        C << "::std::function<void " << spar << lambdaOutParams << epar << "> iceResponse,";
-        C << nl << "::std::function<void(::std::exception_ptr)> iceEx,";
-        C << nl << "::std::function<void(bool)> iceSent,";
-        C << nl << "const ::Ice::Context& iceCtx)";
+        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.restoreIndent();
         C << sb;
         if(p->returnsData())
         {
-            C << nl << "iceCheckTwowayOnly(" << flatName << ");";
+            C << nl << "__checkTwowayOnly(" << flatName << ");";
         }
 
-        C << nl << "::std::function<void(::Ice::InputStream*)> iceRead;";
-        C << nl << "if(iceResponse)";
+        C << nl << "::std::function<void(::Ice::InputStream*)> __read;";
+        C << nl << "if(__response)";
         C << sb;
-        C << nl << "iceRead = [iceResponse](::Ice::InputStream* iceIs)";
+        C << nl << "__read = [__response](::Ice::InputStream* __is)";
         C << sb;
-        C << nl << "iceIs->startEncapsulation();";
+        C << nl << "__is->startEncapsulation();";
         writeAllocateCode(C, outParams, p, true, _useWstring | TypeContextInParam | TypeContextCpp11);
         writeUnmarshalCode(C, outParams, p, true, _useWstring | TypeContextInParam | TypeContextCpp11);
 
         if(p->returnsClasses(false))
         {
-            C << nl << "iceIs->readPendingValues();";
+            C << nl << "__is->readPendingValues();";
         }
-        C << nl << "iceIs->endEncapsulation();";
+        C << nl << "__is->endEncapsulation();";
         C << nl << "try" << sb;
-        C << nl << "iceResponse" << spar;
+        C << nl << "__response" << spar;
         if(ret)
         {
-            C << "iceRet";
+            C << "__ret";
         }
         for(ParamDeclList::const_iterator q = outParams.begin(); q != outParams.end(); ++q)
         {
@@ -6007,12 +6007,12 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p)
         C << eb;
         C << eb << ";";
         C << eb;
-        C << nl << "auto iceOutAsync = ::std::make_shared<::IceInternal::CustomLambdaOutgoing>(";
-        C << "shared_from_this(), iceRead, iceEx, iceSent);";
+        C << nl << "auto __outAsync = ::std::make_shared<::IceInternal::CustomLambdaOutgoing>(";
+        C << "shared_from_this(), __read, __ex, __sent);";
         C << sp;
 
-        C << nl << "iceOutAsync->invoke(" << flatName << ", ";
-        C << operationModeToString(p->sendMode(), true) << ", " << opFormatTypeToString(p) << ", iceCtx, ";
+        C << nl << "__outAsync->invoke(" << flatName << ", ";
+        C << operationModeToString(p->sendMode(), true) << ", " << opFormatTypeToString(p) << ", __ctx, ";
         C.inc();
         C << nl;
 
@@ -6022,7 +6022,7 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p)
 
         C.dec();
         C << ");";
-        C << nl << "return [iceOutAsync]() { iceOutAsync->cancel(); };";
+        C << nl << "return [__outAsync]() { __outAsync->cancel(); };";
         C << eb;
     }
     else
@@ -6034,9 +6034,9 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p)
         H << sb;
         if(futureOutParams.size() > 1)
         {
-            H << nl << "auto iceResponseCb = [iceResponse](" << futureT << "&& result)";
+            H << nl << "auto __responseCb = [__response](" << futureT << "&& result)";
             H << sb;
-            H << nl << "iceResponse" << spar;
+            H << nl << "__response" << spar;
 
             if(ret)
             {
@@ -6051,13 +6051,13 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p)
 
         H << nl << "return makeLambdaOutgoing<" << futureT << ">" << spar;
 
-        H << (futureOutParams.size() > 1 ? "iceResponseCb" : "iceResponse") << "iceEx" << "iceSent" << "this";
-        H << string("&" + scoped + "iceI_" + name);
+        H << (futureOutParams.size() > 1 ? "__responseCb" : "__response") << "__ex" << "__sent" << "this";
+        H << string("&" + scoped + "__" + name);
         for(ParamDeclList::const_iterator q = inParams.begin(); q != inParams.end(); ++q)
         {
             H << fixKwd(paramPrefix + (*q)->name());
         }
-        H << "iceCtx" << epar << ";";
+        H << "__ctx" << epar << ";";
         H << eb;
     }
 
@@ -6066,24 +6066,24 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p)
     //
 
     H << sp;
-    H << nl << _dllMemberExport << "void iceI_" << name << spar;
+    H << nl << _dllMemberExport << "void __" << 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 << "iceI_" << name << spar;
-    C << "const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<" + futureT + ">>& iceOutAsync";
-    C << inParamsDecl << "const ::Ice::Context& iceCtx";
+    C << nl << "void" << nl << scoped << "__" << name << spar;
+    C << "const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<" + futureT + ">>& __outAsync";
+    C << inParamsDecl << "const ::Ice::Context& __ctx";
     C << epar;
     C << sb;
     if(p->returnsData())
     {
-        C << nl << "iceCheckTwowayOnly(" << flatName << ");";
+        C << nl << "__checkTwowayOnly(" << flatName << ");";
     }
-    C << nl << "iceOutAsync->invoke(" << flatName << ", ";
-    C << operationModeToString(p->sendMode(), true) << ", " << opFormatTypeToString(p) << ", iceCtx, ";
+    C << nl << "__outAsync->invoke(" << flatName << ", ";
+    C << operationModeToString(p->sendMode(), true) << ", " << opFormatTypeToString(p) << ", __ctx, ";
     C.inc();
     C << nl;
 
@@ -6098,14 +6098,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* iceIs)";
+        C << "," << nl << "[](::Ice::InputStream* __is)";
         C << sb;
         C << nl << futureT << " v;";
         writeUnmarshalCode(C, outParams, p, false, _useWstring | TypeContextCpp11, returnValueS, "v");
 
         if(p->returnsClasses(false))
         {
-            C << nl << "iceIs->readPendingValues();";
+            C << nl << "__is->readPendingValues();";
         }
         C << nl << "return v;";
         C << eb;
@@ -6117,7 +6117,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* iceIs)";
+        C << "," << nl << "[](::Ice::InputStream* __is)";
         C << sb;
 
         writeAllocateCode(C, outParams, p, true, _useWstring | TypeContextCpp11);
@@ -6125,12 +6125,12 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p)
 
         if(p->returnsClasses(false))
         {
-            C << nl << "iceIs->readPendingValues();";
+            C << nl << "__is->readPendingValues();";
         }
 
         if(ret)
         {
-            C << nl << "return iceRet;";
+            C << nl << "return __ret;";
         }
         else
         {
@@ -6356,7 +6356,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 + " iceP_" + (*q)->name());
+        allParamDecls.push_back(typeName + " __ice_" + (*q)->name());
     }
 
     if(!p->isInterface())
@@ -6569,7 +6569,7 @@ Slice::Gen::Cpp11LocalObjectVisitor::visitOperation(const OperationPtr& p)
         H.dec();
         H << sb;
         H << nl << "using Promise = P<bool>;";
-        H << nl << "auto icePromise = ::std::make_shared<Promise>();";
+        H << nl << "auto __promise = ::std::make_shared<Promise>();";
 
         H << nl << name << "Async(";
         H.useCurrentPosAsIndent();
@@ -6581,17 +6581,17 @@ Slice::Gen::Cpp11LocalObjectVisitor::visitOperation(const OperationPtr& p)
         {
             H << nl;
         }
-        H << "[icePromise](::std::exception_ptr iceEx)";
+        H << "[__promise](::std::exception_ptr __ex)";
         H << sb;
-        H << nl << "icePromise->set_exception(::std::move(iceEx));";
+        H << nl << "__promise->set_exception(::std::move(__ex));";
         H << eb << ",";
-        H << nl << "[icePromise](bool iceB)";
+        H << nl << "[__promise](bool __b)";
         H << sb;
-        H << nl << "icePromise->set_value(iceB);";
+        H << nl << "__promise->set_value(__b);";
         H << eb << ");";
         H.restoreIndent();
 
-        H << nl << "return icePromise->get_future();";
+        H << nl << "return __promise->get_future();";
         H << eb;
     }
 }
@@ -6707,7 +6707,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 = "iceC" + p->flattenedScope() + p->name() + "_ids";
+    string flatName = p->flattenedScope() + p->name() + "_ids";
 
     C << sp;
     C << nl << "bool" << nl << scoped.substr(2) << "::ice_isA(::std::string _s, const ::Ice::Current&) const";
@@ -6766,14 +6766,14 @@ Slice::Gen::Cpp11InterfaceVisitor::visitClassDefEnd(const ClassDefPtr& p)
         allOpNames.sort();
         allOpNames.unique();
 
-        string flatName = "iceC" + p->flattenedScope() + p->name() + "_ops";
+        string flatName = p->flattenedScope() + p->name() + "_ops";
 
         H << sp;
-        H << nl << "virtual bool iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&) override;";
+        H << nl << "virtual bool __dispatch(::IceInternal::Incoming&, const ::Ice::Current&) override;";
 
         C << sp;
         C << nl << "bool";
-        C << nl << scoped.substr(2) << "::iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& c)";
+        C << nl << scoped.substr(2) << "::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& c)";
         C << sb;
 
         C << nl << "::std::pair< const ::std::string*, const ::std::string*> r = "
@@ -6790,7 +6790,7 @@ Slice::Gen::Cpp11InterfaceVisitor::visitClassDefEnd(const ClassDefPtr& p)
         {
             C << nl << "case " << i++ << ':';
             C << sb;
-            C << nl << "return iceD_" << *q << "(in, c);";
+            C << nl << "return ___" << *q << "(in, c);";
             C << eb;
         }
         C << nl << "default:";
@@ -6851,7 +6851,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 + " iceRet");
+        responseParamsDecl.push_back(typeS + " __ret");
     }
 
     string retS;
@@ -6909,13 +6909,13 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p)
         else
         {
             params.push_back("::std::function<void(" + joinString(responseParams, ",") + ")>");
-            args.push_back(ret || !outParams.empty() ? "iceResponseCB" : "inS->response()");
+            args.push_back(ret || !outParams.empty() ? "__responseCB" : "inS->response()");
         }
         params.push_back("::std::function<void(::std::exception_ptr)>");
         args.push_back("inS->exception()");
     }
     params.push_back("const ::Ice::Current& = ::Ice::noExplicitCurrent");
-    args.push_back("iceCurrent");
+    args.push_back("__current");
 
     if(cl->isInterface())
     {
@@ -6935,18 +6935,18 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p)
         H << eb << ';';
 
         C << sp << nl << scope.substr(2) << resultName << "::" << resultName;
-        C << spar << responseParamsDecl << "const ::Ice::Current& iceCurrent" << epar << ":";
+        C << spar << responseParamsDecl << "const ::Ice::Current& __current" << epar << ":";
         C.inc();
-        C << nl << "MarshaledResult(iceCurrent)";
+        C << nl << "MarshaledResult(__current)";
         C.dec();
         C << sb;
-        C << nl << "_os->startEncapsulation(iceCurrent.encoding, " << opFormatTypeToString(p) << ");";
-        writeMarshalCode(C, outParams, p, true, TypeContextCpp11, "_os");
+        C << nl << "__os->startEncapsulation(__current.encoding, " << opFormatTypeToString(p) << ");";
+        writeMarshalCode(C, outParams, p, true, TypeContextCpp11);
         if(p->returnsClasses(false))
         {
-            C << nl << "_os->writePendingValues();";
+            C << nl << "__os->writePendingValues();";
         }
-        C << nl << "_os->endEncapsulation();";
+        C << nl << "__os->endEncapsulation();";
         C << eb;
     }
 
@@ -6957,33 +6957,33 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p)
 
     H << sp;
     H << nl << deprecateSymbol << "virtual " << retS << ' ' << opName << spar << params << epar << isConst << " = 0;";
-    H << nl << "bool iceD_" << name << "(::IceInternal::Incoming&, const ::Ice::Current&)" << isConst << ';';
+    H << nl << "bool ___" << name << "(::IceInternal::Incoming&, const ::Ice::Current&)" << isConst << ';';
 
     C << sp;
     C << nl << "bool";
     C << nl << scope.substr(2);
-    C << "iceD_" << name << "(::IceInternal::Incoming& iceInS" << ", const ::Ice::Current& iceCurrent)" << isConst;
+    C << "___" << name << "(::IceInternal::Incoming& __inS" << ", const ::Ice::Current& __current)" << isConst;
     C << sb;
-    C << nl << "iceCheckMode(" << operationModeToString(p->mode(), true) << ", iceCurrent.mode);";
+    C << nl << "__checkMode(" << operationModeToString(p->mode(), true) << ", __current.mode);";
 
     if(!inParams.empty())
     {
-        C << nl << "auto iceIs = iceInS.startReadParams();";
+        C << nl << "auto __is = __inS.startReadParams();";
         writeAllocateCode(C, inParams, 0, true, _useWstring | TypeContextInParam | TypeContextCpp11);
         writeUnmarshalCode(C, inParams, 0, true, _useWstring | TypeContextInParam | TypeContextCpp11);
         if(p->sendsClasses(false))
         {
-            C << nl << "iceIs->readPendingValues();";
+            C << nl << "__is->readPendingValues();";
         }
-        C << nl << "iceInS.endReadParams();";
+        C << nl << "__inS.endReadParams();";
     }
     else
     {
-        C << nl << "iceInS.readEmptyParams();";
+        C << nl << "__inS.readEmptyParams();";
     }
     if(p->format() != DefaultFormat)
     {
-        C << nl << "iceInS.setFormat(" << opFormatTypeToString(p) << ");";
+        C << nl << "__inS.setFormat(" << opFormatTypeToString(p) << ");";
     }
 
     if(!amd)
@@ -6991,11 +6991,11 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p)
         writeAllocateCode(C, outParams, 0, true, _useWstring | TypeContextCpp11);
         if(p->hasMarshaledResult())
         {
-            C << nl << "iceInS.setMarshaledResult(";
+            C << nl << "__inS.setMarshaledResult(";
         }
         else if(ret)
         {
-            C << nl << retS << " iceRet = ";
+            C << nl << retS << " __ret = ";
         }
         else
         {
@@ -7012,33 +7012,33 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p)
             C << ";";
             if(ret || !outParams.empty())
             {
-                C << nl << "auto iceOs = iceInS.startWriteParams();";
+                C << nl << "auto __os = __inS.startWriteParams();";
                 writeMarshalCode(C, outParams, p, true, TypeContextCpp11);
                 if(p->returnsClasses(false))
                 {
-                    C << nl << "iceOs->writePendingValues();";
+                    C << nl << "__os->writePendingValues();";
                 }
-                C << nl << "iceInS.endWriteParams();";
+                C << nl << "__inS.endWriteParams();";
             }
             else
             {
-                C << nl << "iceInS.writeEmptyParams();";
+                C << nl << "__inS.writeEmptyParams();";
             }
         }
         C << nl << "return false;";
     }
     else
     {
-        C << nl << "auto inS = ::IceInternal::IncomingAsync::create(iceInS);";
+        C << nl << "auto inS = ::IceInternal::IncomingAsync::create(__inS);";
         if(!p->hasMarshaledResult() && (ret || !outParams.empty()))
         {
-            C << nl << "auto iceResponseCB = [inS]" << spar << responseParamsDecl << epar;
+            C << nl << "auto __responseCB = [inS]" << spar << responseParamsDecl << epar;
             C << sb;
-            C << nl << "auto iceOs = inS->startWriteParams();";
+            C << nl << "auto __os = inS->startWriteParams();";
             writeMarshalCode(C, outParams, p, true, TypeContextCpp11);
             if(p->returnsClasses(false))
             {
-                C << nl << "iceOs->writePendingValues();";
+                C << nl << "__os->writePendingValues();";
             }
             C << nl << "inS->endWriteParams();";
             C << nl << "inS->completed();";
@@ -7159,23 +7159,23 @@ Slice::Gen::Cpp11ValueVisitor::visitClassDefEnd(const ClassDefPtr& p)
     if(preserved && !basePreserved)
     {
         H << sp;
-        H << nl << "virtual void iceWrite(::Ice::OutputStream*) const override;";
-        H << nl << "virtual void iceRead(::Ice::InputStream*) override;";
+        H << nl << "virtual void __write(::Ice::OutputStream*) const override;";
+        H << nl << "virtual void __read(::Ice::InputStream*) override;";
 
         C << sp;
-        C << nl << "void" << nl << scoped.substr(2) << "::iceWrite(::Ice::OutputStream* iceOs) const";
+        C << nl << "void" << nl << scoped.substr(2) << "::__write(::Ice::OutputStream* __os) const";
         C << sb;
-        C << nl << "iceOs->startValue(_slicedData);";
-        C << nl << "iceWriteImpl(iceOs);";
-        C << nl << "iceOs->endValue();";
+        C << nl << "__os->startValue(__slicedData);";
+        C << nl << "__writeImpl(__os);";
+        C << nl << "__os->endValue();";
         C << eb;
 
         C << sp;
-        C << nl << "void" << nl << scoped.substr(2) << "::iceRead(::Ice::InputStream* iceIs)";
+        C << nl << "void" << nl << scoped.substr(2) << "::__read(::Ice::InputStream* __is)";
         C << sb;
-        C << nl << "iceIs->startValue();";
-        C << nl << "iceReadImpl(iceIs);";
-        C << nl << "_slicedData = iceIs->endValue(true);";
+        C << nl << "__is->startValue();";
+        C << nl << "__readImpl(__is);";
+        C << nl << "__slicedData = __is->endValue(true);";
         C << eb;
     }
 
@@ -7242,7 +7242,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> __slicedData;";
     }
 
     if(generateFriend)
@@ -7314,11 +7314,11 @@ Slice::Gen::Cpp11ObjectVisitor::emitVirtualBaseInitializers(const ClassDefPtr& d
         }
         if(isMovable((*q)->type()))
         {
-            upcall += "::std::move(iceP_" + (*q)->name() + ")";
+            upcall += "::std::move(__ice_" + (*q)->name() + ")";
         }
         else
         {
-            upcall += "iceP_" + (*q)->name();
+            upcall += "__ice_" + (*q)->name();
         }
     }
     upcall += ")";
@@ -7349,7 +7349,7 @@ Slice::Gen::Cpp11ObjectVisitor::emitOneShotConstructor(const ClassDefPtr& p)
         {
             string typeName = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(),
                                                 _useWstring | TypeContextCpp11);
-            allParamDecls.push_back(typeName + " iceP_" + (*q)->name());
+            allParamDecls.push_back(typeName + " __ice_" + (*q)->name());
         }
 
         H << sp << nl;
@@ -7387,11 +7387,11 @@ Slice::Gen::Cpp11ObjectVisitor::emitOneShotConstructor(const ClassDefPtr& p)
             string memberName = fixKwd((*q)->name());
             if(isMovable((*q)->type()))
             {
-                H << memberName << "(::std::move(" << "iceP_" << (*q)->name() << "))";
+                H << memberName << "(::std::move(" << "__ice_" << (*q)->name() << "))";
             }
             else
             {
-                H << memberName << '(' << "iceP_" << (*q)->name() << ')';
+                H << memberName << '(' << "__ice_" << (*q)->name() << ')';
             }
         }
 
@@ -7756,7 +7756,7 @@ Slice::Gen::Cpp11ImplVisitor::visitClassDefStart(const ClassDefPtr& p)
                 string typeS = inputTypeToString(ret, op->returnIsOptional(), op->getMetaData(),
                                                  _useWstring | TypeContextCpp11);
                 responseParams = typeS;
-                responseParamsDecl = typeS + " iceRet";
+                responseParamsDecl = typeS + " __ret";
                 if(!outParams.empty())
                 {
                     responseParams += ", ";
diff --git a/cpp/test/Ice/dispatcher/Dispatcher.cpp b/cpp/test/Ice/dispatcher/Dispatcher.cpp
index 93b72a313c7..c725a9af4a1 100644
--- a/cpp/test/Ice/dispatcher/Dispatcher.cpp
+++ b/cpp/test/Ice/dispatcher/Dispatcher.cpp
@@ -18,9 +18,9 @@ Dispatcher::Dispatcher()
 {
     _instance = this;
     _terminated = false;
-    iceSetNoDelete(true);
+    __setNoDelete(true);
     start();
-    iceSetNoDelete(false);
+    __setNoDelete(false);
 }
 
 void
diff --git a/cpp/test/Ice/gc/Client.cpp b/cpp/test/Ice/gc/Client.cpp
index e6f6c9f188d..4298d102621 100644
--- a/cpp/test/Ice/gc/Client.cpp
+++ b/cpp/test/Ice/gc/Client.cpp
@@ -132,15 +132,15 @@ public:
 
     virtual bool visit(IceInternal::GCObject* obj)
     {
-        if(obj->iceHasFlag(IceInternal::GCObject::Visiting))
+        if(obj->__hasFlag(IceInternal::GCObject::Visiting))
         {
             return false;
         }
-        test(obj->iceHasFlag(IceInternal::GCObject::CycleMember) && obj->iceHasFlag(IceInternal::GCObject::Collectable));
+        test(obj->__hasFlag(IceInternal::GCObject::CycleMember) && obj->__hasFlag(IceInternal::GCObject::Collectable));
 
-        obj->iceSetFlag(IceInternal::GCObject::Visiting);
-        obj->iceGcVisitMembers(*this);
-        obj->iceClearFlag(IceInternal::GCObject::Visiting);
+        obj->__setFlag(IceInternal::GCObject::Visiting);
+        obj->__gcVisitMembers(*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 c6be6fbf8d2..dd1cc6ee4d8 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->iceHash(), obj)).second)
+        if(!seenProxy.insert(make_pair(obj->__hash(), obj)).second)
         {
             ++proxyCollisions;
         }
-        test(obj->iceHash() == obj->iceHash());
+        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->iceHash();
-    proxyMap["prx2"] = prx2->iceHash();
-    proxyMap["prx3"] = prx3->iceHash();
-    proxyMap["prx4"] = prx4->iceHash();
-    proxyMap["prx5"] = prx5->iceHash();
-    proxyMap["prx6"] = prx6->iceHash();
-    proxyMap["prx7"] = prx7->iceHash();
-    proxyMap["prx8"] = prx8->iceHash();
-    proxyMap["prx9"] = prx9->iceHash();
-    proxyMap["prx10"] = prx10->iceHash();
+    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")->iceHash() == proxyMap["prx1"]);
-    test( communicator->stringToProxy("Glacier2/router:ssl -p 10011")->iceHash() == proxyMap["prx2"]);
-    test( communicator->stringToProxy("Glacier2/router:udp -p 10012")->iceHash() == proxyMap["prx3"]);
-    test( communicator->stringToProxy("Glacier2/router:tcp -h zeroc.com -p 10010")->iceHash() == proxyMap["prx4"]);
-    test( communicator->stringToProxy("Glacier2/router:ssl -h zeroc.com -p 10011")->iceHash() == proxyMap["prx5"]);
-    test( communicator->stringToProxy("Glacier2/router:udp -h zeroc.com -p 10012")->iceHash() == proxyMap["prx6"]);
-    test( communicator->stringToProxy("Glacier2/router:tcp -p 10010 -t 10000")->iceHash() == proxyMap["prx7"]);
-    test( communicator->stringToProxy("Glacier2/router:ssl -p 10011 -t 10000")->iceHash() == proxyMap["prx8"]);
-    test( communicator->stringToProxy("Glacier2/router:tcp -h zeroc.com -p 10010 -t 10000")->iceHash() == proxyMap["prx9"]);
-    test( communicator->stringToProxy("Glacier2/router:ssl -h zeroc.com -p 10011 -t 10000")->iceHash() == 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 945337fd385..6aa46b6d691 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 iceWrite(Ice::OutputStream*) const { }
+    virtual void __write(Ice::OutputStream*) const { }
 
-    virtual void iceRead(Ice::InputStream* in)
+    virtual void __read(Ice::InputStream* in)
     {
         in->startValue();
         in->startSlice();
@@ -80,9 +80,9 @@ class BObjectReader : public Ice::Object
 #endif
 {
 public:
-    virtual void iceWrite(Ice::OutputStream*) const { }
+    virtual void __write(Ice::OutputStream*) const { }
 
-    virtual void iceRead(Ice::InputStream* in)
+    virtual void __read(Ice::InputStream* in)
     {
         in->startValue();
         // ::Test::B
@@ -117,9 +117,9 @@ class CObjectReader : public Ice::Object
 #endif
 {
 public:
-    virtual void iceWrite(Ice::OutputStream*) const { }
+    virtual void __write(Ice::OutputStream*) const { }
 
-    virtual void iceRead(Ice::InputStream* in)
+    virtual void __read(Ice::InputStream* in)
     {
         in->startValue();
         // ::Test::C
@@ -158,7 +158,7 @@ class DObjectWriter : public Ice::Object
 {
 public:
 
-    virtual void iceWrite(Ice::OutputStream* out) const
+    virtual void __write(Ice::OutputStream* out) const
     {
         out->startValue(0);
         // ::Test::D
@@ -188,7 +188,7 @@ public:
         out->endValue();
     }
 
-    virtual void iceRead(Ice::InputStream*) { }
+    virtual void __read(Ice::InputStream*) { }
 
 #ifdef ICE_CPP11_MAPPING
 
@@ -211,9 +211,9 @@ class DObjectReader : public Ice::Object
 #endif
 {
 public:
-    virtual void iceWrite(Ice::OutputStream*) const { }
+    virtual void __write(Ice::OutputStream*) const { }
 
-    virtual void iceRead(Ice::InputStream* in)
+    virtual void __read(Ice::InputStream* in)
     {
         in->startValue();
         // ::Test::D
@@ -268,9 +268,9 @@ class FObjectReader : public Ice::Object
 #endif
 {
 public:
-    virtual void iceWrite(Ice::OutputStream*) const { }
+    virtual void __write(Ice::OutputStream*) const { }
 
-    virtual void iceRead(Ice::InputStream* in)
+    virtual void __read(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 bcff7f85e9a..31ab757aa7f 100644
--- a/cpp/test/Ice/stream/Client.cpp
+++ b/cpp/test/Ice/stream/Client.cpp
@@ -32,13 +32,13 @@ public:
         called = false;
     }
 
-    virtual void iceWrite(Ice::OutputStream* out) const
+    virtual void __write(Ice::OutputStream* out) const
     {
-        obj->iceWrite(out);
+        obj->__write(out);
         const_cast<TestObjectWriter*>(this)->called = true;
     }
 
-    virtual void iceRead(Ice::InputStream*)
+    virtual void __read(Ice::InputStream*)
     {
         assert(false);
     }
@@ -61,15 +61,15 @@ public:
         called = false;
     }
 
-    virtual void iceWrite(Ice::OutputStream*) const
+    virtual void __write(Ice::OutputStream*) const
     {
         assert(false);
     }
 
-    virtual void iceRead(Ice::InputStream* in)
+    virtual void __read(Ice::InputStream* in)
     {
         obj = ICE_MAKE_SHARED(MyClass);
-        obj->iceRead(in);
+        obj->__read(in);
         called = true;
     }
 
@@ -78,29 +78,29 @@ public:
 };
 ICE_DEFINE_PTR(TestObjectReaderPtr, TestObjectReader);
 
-// Required for ValueHelper<>'s iceReadImpl and iceWriteIpml
+// Required for ValueHelper<>'s __readImpl and __writeIpml
 #ifdef ICE_CPP11_MAPPING
 namespace Ice
 {
 template<class S>
 struct StreamWriter<TestObjectWriter, S>
 {
-    static void write(S* iceOs, const TestObjectWriter&) { assert(false); }
+    static void write(S* __os, const TestObjectWriter&) { assert(false); }
 };
 template<class S>
 struct StreamReader<TestObjectWriter, S>
 {
-    static void read(S* iceIs, TestObjectWriter&) { assert(false); }
+    static void read(S* __is, TestObjectWriter&) { assert(false); }
 };
 template<class S>
 struct StreamWriter<TestObjectReader, S>
 {
-    static void write(S* iceOs, const TestObjectReader&) { assert(false); }
+    static void write(S* __os, const TestObjectReader&) { assert(false); }
 };
 template<class S>
 struct StreamReader<TestObjectReader, S>
 {
-    static void read(S* iceIs, TestObjectReader&) { assert(false); }
+    static void read(S* __is, TestObjectReader&) { assert(false); }
 };
 }
 #endif