zeroc-ice 3.6.5 → 3.7.4

data/ext/ice/cpp/src/Ice/InstrumentationI.h

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #ifndef ICE_INSTRUMENTATION_I_H
 #define ICE_INSTRUMENTATION_I_H
@@ -16,14 +11,13 @@
 namespace IceInternal
 {
 
-template<typename T, typename O> class ObserverWithDelegateT : public IceMX::ObserverT<T>, virtual public O
+template<typename T, typename O> class ObserverWithDelegateT : public IceMX::ObserverT<T>, public virtual O
 {
 public:
 
     typedef O ObserverType;
-    typedef typename IceInternal::Handle<O> ObserverPtrType;
-
-    virtual void 
+    typedef typename ICE_INTERNAL_HANDLE<O> ObserverPtrType;
+    virtual void
     attach()
     {
         IceMX::ObserverT<T>::attach();
@@ -33,7 +27,7 @@ public:
         }
     }
 
-    virtual void 
+    virtual void
     detach()
     {
         IceMX::ObserverT<T>::detach();
@@ -65,11 +59,11 @@ public:
         _delegate = delegate;
     }
 
-    template<typename ObserverImpl, typename ObserverMetricsType, typename ObserverPtrType> ObserverPtrType 
-    getObserverWithDelegate(const std::string& mapName, const IceMX::MetricsHelperT<ObserverMetricsType>& helper, 
+    template<typename ObserverImpl, typename ObserverMetricsType, typename ObserverPtrType> ObserverPtrType
+    getObserverWithDelegate(const std::string& mapName, const IceMX::MetricsHelperT<ObserverMetricsType>& helper,
                             const ObserverPtrType& del)
     {
-        IceInternal::Handle<ObserverImpl> obsv = IceMX::ObserverT<T>::template getObserver<ObserverImpl>(mapName, 
+        ICE_INTERNAL_HANDLE<ObserverImpl> obsv = IceMX::ObserverT<T>::template getObserver<ObserverImpl>(mapName,
                                                                                                          helper);
         if(obsv)
         {
@@ -88,15 +82,15 @@ template class ObserverFactoryWithDelegateT : public IceMX::Observer
 {
 public:
 
-    ObserverFactoryWithDelegateT(const IceInternal::MetricsAdminIPtr& metrics, const std::string& name) : 
+    ObserverFactoryWithDelegateT(const IceInternal::MetricsAdminIPtr& metrics, const std::string& name) :
         IceMX::ObserverFactoryT<T>(metrics, name)
     {
     }
 
-    template<typename ObserverMetricsType, typename ObserverPtrType> ObserverPtrType 
+    template<typename ObserverMetricsType, typename ObserverPtrType> ObserverPtrType
     getObserverWithDelegate(const IceMX::MetricsHelperT<ObserverMetricsType>& helper, const ObserverPtrType& del)
     {
-        IceInternal::Handle<T> obsv = IceMX::ObserverFactoryT<T>::getObserver(helper);
+        ICE_INTERNAL_HANDLE<T> obsv = IceMX::ObserverFactoryT<T>::getObserver(helper);
         if(obsv)
         {
             obsv->setDelegate(del);
@@ -105,11 +99,11 @@ public:
         return del;
     }
 
-    template<typename ObserverMetricsType, typename ObserverPtrType> ObserverPtrType 
-    getObserverWithDelegate(const IceMX::MetricsHelperT<ObserverMetricsType>& helper, const ObserverPtrType& del, 
+    template<typename ObserverMetricsType, typename ObserverPtrType> ObserverPtrType
+    getObserverWithDelegate(const IceMX::MetricsHelperT<ObserverMetricsType>& helper, const ObserverPtrType& del,
                             const ObserverPtrType& old)
     {
-        IceInternal::Handle<T> obsv = IceMX::ObserverFactoryT<T>::getObserver(helper, old);
+        ICE_INTERNAL_HANDLE<T> obsv = IceMX::ObserverFactoryT<T>::getObserver(helper, old);
         if(obsv)
         {
             obsv->setDelegate(del);
@@ -129,7 +123,7 @@ void addEndpointAttributes(typename Helper::Attributes& attrs)
     attrs.add("endpointIsSecure", &Helper::getEndpointInfo, &Ice::EndpointInfo::secure);
     attrs.add("endpointTimeout", &Helper::getEndpointInfo, &Ice::EndpointInfo::timeout);
     attrs.add("endpointCompress", &Helper::getEndpointInfo, &Ice::EndpointInfo::compress);
-    
+
     attrs.add("endpointHost", &Helper::getEndpointInfo, &Ice::IPEndpointInfo::host);
     attrs.add("endpointPort", &Helper::getEndpointInfo, &Ice::IPEndpointInfo::port);
 }
@@ -140,19 +134,19 @@ void addConnectionAttributes(typename Helper::Attributes& attrs)
     attrs.add("incoming", &Helper::getConnectionInfo, &Ice::ConnectionInfo::incoming);
     attrs.add("adapterName", &Helper::getConnectionInfo, &Ice::ConnectionInfo::adapterName);
     attrs.add("connectionId", &Helper::getConnectionInfo, &Ice::ConnectionInfo::connectionId);
-    
+
     attrs.add("localHost", &Helper::getConnectionInfo, &Ice::IPConnectionInfo::localAddress);
     attrs.add("localPort", &Helper::getConnectionInfo, &Ice::IPConnectionInfo::localPort);
     attrs.add("remoteHost", &Helper::getConnectionInfo, &Ice::IPConnectionInfo::remoteAddress);
     attrs.add("remotePort", &Helper::getConnectionInfo, &Ice::IPConnectionInfo::remotePort);
-            
+
     attrs.add("mcastHost", &Helper::getConnectionInfo, &Ice::UDPConnectionInfo::mcastAddress);
     attrs.add("mcastPort", &Helper::getConnectionInfo, &Ice::UDPConnectionInfo::mcastPort);
-    
+
     addEndpointAttributes<Helper>(attrs);
 }
 
-class ConnectionObserverI : public ObserverWithDelegateT<IceMX::ConnectionMetrics, 
+class ConnectionObserverI : public ObserverWithDelegateT<IceMX::ConnectionMetrics,
                                                          Ice::Instrumentation::ConnectionObserver>
 {
 public:
@@ -184,7 +178,7 @@ public:
     virtual void reply(Ice::Int);
 };
 
-class CollocatedObserverI : public ObserverWithDelegateT<IceMX::CollocatedMetrics, 
+class CollocatedObserverI : public ObserverWithDelegateT<IceMX::CollocatedMetrics,
                                                          Ice::Instrumentation::CollocatedObserver>
 {
 public:
@@ -192,7 +186,7 @@ public:
     virtual void reply(Ice::Int);
 };
 
-class InvocationObserverI : public ObserverWithDelegateT<IceMX::InvocationMetrics, 
+class InvocationObserverI : public ObserverWithDelegateT<IceMX::InvocationMetrics,
                                                          Ice::Instrumentation::InvocationObserver>
 {
 public:
@@ -201,7 +195,7 @@ public:
 
     virtual void userException();
 
-    virtual Ice::Instrumentation::RemoteObserverPtr 
+    virtual Ice::Instrumentation::RemoteObserverPtr
     getRemoteObserver(const Ice::ConnectionInfoPtr&, const Ice::EndpointPtr&, Ice::Int, Ice::Int);
 
     virtual Ice::Instrumentation::CollocatedObserverPtr
@@ -217,23 +211,23 @@ public:
     CommunicatorObserverI(const Ice::InitializationData&);
 
     virtual void setObserverUpdater(const Ice::Instrumentation::ObserverUpdaterPtr&);
- 
+
     virtual Ice::Instrumentation::ObserverPtr getConnectionEstablishmentObserver(const Ice::EndpointPtr&,
                                                                                  const std::string&);
- 
+
     virtual Ice::Instrumentation::ObserverPtr getEndpointLookupObserver(const Ice::EndpointPtr&);
-    
-    virtual Ice::Instrumentation::ConnectionObserverPtr 
-    getConnectionObserver(const Ice::ConnectionInfoPtr&, 
+
+    virtual Ice::Instrumentation::ConnectionObserverPtr
+    getConnectionObserver(const Ice::ConnectionInfoPtr&,
                           const Ice::EndpointPtr&,
-                          Ice::Instrumentation::ConnectionState, 
+                          Ice::Instrumentation::ConnectionState,
                           const Ice::Instrumentation::ConnectionObserverPtr&);
 
     virtual Ice::Instrumentation::ThreadObserverPtr getThreadObserver(const std::string&, const std::string&,
                                                                       Ice::Instrumentation::ThreadState,
                                                                       const Ice::Instrumentation::ThreadObserverPtr&);
 
-    virtual Ice::Instrumentation::InvocationObserverPtr getInvocationObserver(const Ice::ObjectPrx&, 
+    virtual Ice::Instrumentation::InvocationObserverPtr getInvocationObserver(const Ice::ObjectPrxPtr&,
                                                                               const std::string&,
                                                                               const Ice::Context&);
 
@@ -255,7 +249,7 @@ private:
     ObserverFactoryWithDelegateT<ObserverI> _connects;
     ObserverFactoryWithDelegateT<ObserverI> _endpointLookups;
 };
-typedef IceUtil::Handle<CommunicatorObserverI> CommunicatorObserverIPtr;
+ICE_DEFINE_PTR(CommunicatorObserverIPtr, CommunicatorObserverI);
 
 };
 

data/ext/ice/cpp/src/Ice/LocalException.cpp

@@ -1,13 +1,8 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
 //
-// **********************************************************************
-//
-// Ice version 3.6.5
+// Ice version 3.7.4
 //
 // <auto-generated>
 //
@@ -23,30 +18,768 @@
 #endif
 #include <Ice/LocalException.h>
 #include <IceUtil/PushDisableWarnings.h>
-#include <Ice/BasicStream.h>
-#include <IceUtil/Iterator.h>
+#include <Ice/InputStream.h>
+#include <Ice/OutputStream.h>
 #include <IceUtil/PopDisableWarnings.h>
 
+#if defined(_MSC_VER)
+#   pragma warning(disable:4458) // declaration of ... hides class member
+#elif defined(__clang__)
+#   pragma clang diagnostic ignored "-Wshadow"
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic ignored "-Wshadow"
+#endif
+
 #ifndef ICE_IGNORE_VERSION
-#   if ICE_INT_VERSION / 100 != 306
+#   if ICE_INT_VERSION / 100 != 307
 #       error Ice version mismatch!
 #   endif
-#   if ICE_INT_VERSION % 100 > 50
+#   if ICE_INT_VERSION % 100 >= 50
 #       error Beta header file detected
 #   endif
-#   if ICE_INT_VERSION % 100 < 5
+#   if ICE_INT_VERSION % 100 < 4
 #       error Ice patch level mismatch!
 #   endif
 #endif
 
-Ice::InitializationException::InitializationException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+#ifdef ICE_CPP11_MAPPING // C++11 mapping
+
+Ice::InitializationException::~InitializationException()
+{
+}
+
+const ::std::string&
+Ice::InitializationException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::InitializationException";
+    return typeId;
+}
+
+Ice::PluginInitializationException::~PluginInitializationException()
+{
+}
+
+const ::std::string&
+Ice::PluginInitializationException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::PluginInitializationException";
+    return typeId;
+}
+
+Ice::CollocationOptimizationException::~CollocationOptimizationException()
+{
+}
+
+const ::std::string&
+Ice::CollocationOptimizationException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::CollocationOptimizationException";
+    return typeId;
+}
+
+Ice::AlreadyRegisteredException::~AlreadyRegisteredException()
+{
+}
+
+const ::std::string&
+Ice::AlreadyRegisteredException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::AlreadyRegisteredException";
+    return typeId;
+}
+
+Ice::NotRegisteredException::~NotRegisteredException()
+{
+}
+
+const ::std::string&
+Ice::NotRegisteredException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::NotRegisteredException";
+    return typeId;
+}
+
+Ice::TwowayOnlyException::~TwowayOnlyException()
+{
+}
+
+const ::std::string&
+Ice::TwowayOnlyException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::TwowayOnlyException";
+    return typeId;
+}
+
+Ice::CloneNotImplementedException::~CloneNotImplementedException()
+{
+}
+
+const ::std::string&
+Ice::CloneNotImplementedException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::CloneNotImplementedException";
+    return typeId;
+}
+
+Ice::UnknownException::~UnknownException()
+{
+}
+
+const ::std::string&
+Ice::UnknownException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::UnknownException";
+    return typeId;
+}
+
+Ice::UnknownLocalException::~UnknownLocalException()
+{
+}
+
+const ::std::string&
+Ice::UnknownLocalException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::UnknownLocalException";
+    return typeId;
+}
+
+Ice::UnknownUserException::~UnknownUserException()
+{
+}
+
+const ::std::string&
+Ice::UnknownUserException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::UnknownUserException";
+    return typeId;
+}
+
+Ice::VersionMismatchException::~VersionMismatchException()
+{
+}
+
+const ::std::string&
+Ice::VersionMismatchException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::VersionMismatchException";
+    return typeId;
+}
+
+Ice::CommunicatorDestroyedException::~CommunicatorDestroyedException()
+{
+}
+
+const ::std::string&
+Ice::CommunicatorDestroyedException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::CommunicatorDestroyedException";
+    return typeId;
+}
+
+Ice::ObjectAdapterDeactivatedException::~ObjectAdapterDeactivatedException()
+{
+}
+
+const ::std::string&
+Ice::ObjectAdapterDeactivatedException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::ObjectAdapterDeactivatedException";
+    return typeId;
+}
+
+Ice::ObjectAdapterIdInUseException::~ObjectAdapterIdInUseException()
+{
+}
+
+const ::std::string&
+Ice::ObjectAdapterIdInUseException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::ObjectAdapterIdInUseException";
+    return typeId;
+}
+
+Ice::NoEndpointException::~NoEndpointException()
+{
+}
+
+const ::std::string&
+Ice::NoEndpointException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::NoEndpointException";
+    return typeId;
+}
+
+Ice::EndpointParseException::~EndpointParseException()
+{
+}
+
+const ::std::string&
+Ice::EndpointParseException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::EndpointParseException";
+    return typeId;
+}
+
+Ice::EndpointSelectionTypeParseException::~EndpointSelectionTypeParseException()
+{
+}
+
+const ::std::string&
+Ice::EndpointSelectionTypeParseException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::EndpointSelectionTypeParseException";
+    return typeId;
+}
+
+Ice::VersionParseException::~VersionParseException()
+{
+}
+
+const ::std::string&
+Ice::VersionParseException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::VersionParseException";
+    return typeId;
+}
+
+Ice::IdentityParseException::~IdentityParseException()
+{
+}
+
+const ::std::string&
+Ice::IdentityParseException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::IdentityParseException";
+    return typeId;
+}
+
+Ice::ProxyParseException::~ProxyParseException()
+{
+}
+
+const ::std::string&
+Ice::ProxyParseException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::ProxyParseException";
+    return typeId;
+}
+
+Ice::IllegalIdentityException::~IllegalIdentityException()
+{
+}
+
+const ::std::string&
+Ice::IllegalIdentityException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::IllegalIdentityException";
+    return typeId;
+}
+
+Ice::IllegalServantException::~IllegalServantException()
+{
+}
+
+const ::std::string&
+Ice::IllegalServantException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::IllegalServantException";
+    return typeId;
+}
+
+Ice::RequestFailedException::~RequestFailedException()
+{
+}
+
+const ::std::string&
+Ice::RequestFailedException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::RequestFailedException";
+    return typeId;
+}
+
+Ice::ObjectNotExistException::~ObjectNotExistException()
+{
+}
+
+const ::std::string&
+Ice::ObjectNotExistException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::ObjectNotExistException";
+    return typeId;
+}
+
+Ice::FacetNotExistException::~FacetNotExistException()
+{
+}
+
+const ::std::string&
+Ice::FacetNotExistException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::FacetNotExistException";
+    return typeId;
+}
+
+Ice::OperationNotExistException::~OperationNotExistException()
+{
+}
+
+const ::std::string&
+Ice::OperationNotExistException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::OperationNotExistException";
+    return typeId;
+}
+
+Ice::SyscallException::~SyscallException()
+{
+}
+
+const ::std::string&
+Ice::SyscallException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::SyscallException";
+    return typeId;
+}
+
+Ice::SocketException::~SocketException()
+{
+}
+
+const ::std::string&
+Ice::SocketException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::SocketException";
+    return typeId;
+}
+
+Ice::CFNetworkException::~CFNetworkException()
+{
+}
+
+const ::std::string&
+Ice::CFNetworkException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::CFNetworkException";
+    return typeId;
+}
+
+Ice::FileException::~FileException()
+{
+}
+
+const ::std::string&
+Ice::FileException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::FileException";
+    return typeId;
+}
+
+Ice::ConnectFailedException::~ConnectFailedException()
+{
+}
+
+const ::std::string&
+Ice::ConnectFailedException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::ConnectFailedException";
+    return typeId;
+}
+
+Ice::ConnectionRefusedException::~ConnectionRefusedException()
+{
+}
+
+const ::std::string&
+Ice::ConnectionRefusedException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::ConnectionRefusedException";
+    return typeId;
+}
+
+Ice::ConnectionLostException::~ConnectionLostException()
+{
+}
+
+const ::std::string&
+Ice::ConnectionLostException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::ConnectionLostException";
+    return typeId;
+}
+
+Ice::DNSException::~DNSException()
+{
+}
+
+const ::std::string&
+Ice::DNSException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::DNSException";
+    return typeId;
+}
+
+Ice::OperationInterruptedException::~OperationInterruptedException()
+{
+}
+
+const ::std::string&
+Ice::OperationInterruptedException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::OperationInterruptedException";
+    return typeId;
+}
+
+Ice::TimeoutException::~TimeoutException()
+{
+}
+
+const ::std::string&
+Ice::TimeoutException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::TimeoutException";
+    return typeId;
+}
+
+Ice::ConnectTimeoutException::~ConnectTimeoutException()
+{
+}
+
+const ::std::string&
+Ice::ConnectTimeoutException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::ConnectTimeoutException";
+    return typeId;
+}
+
+Ice::CloseTimeoutException::~CloseTimeoutException()
+{
+}
+
+const ::std::string&
+Ice::CloseTimeoutException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::CloseTimeoutException";
+    return typeId;
+}
+
+Ice::ConnectionTimeoutException::~ConnectionTimeoutException()
+{
+}
+
+const ::std::string&
+Ice::ConnectionTimeoutException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::ConnectionTimeoutException";
+    return typeId;
+}
+
+Ice::InvocationTimeoutException::~InvocationTimeoutException()
+{
+}
+
+const ::std::string&
+Ice::InvocationTimeoutException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::InvocationTimeoutException";
+    return typeId;
+}
+
+Ice::InvocationCanceledException::~InvocationCanceledException()
+{
+}
+
+const ::std::string&
+Ice::InvocationCanceledException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::InvocationCanceledException";
+    return typeId;
+}
+
+Ice::ProtocolException::~ProtocolException()
+{
+}
+
+const ::std::string&
+Ice::ProtocolException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::ProtocolException";
+    return typeId;
+}
+
+Ice::BadMagicException::~BadMagicException()
+{
+}
+
+const ::std::string&
+Ice::BadMagicException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::BadMagicException";
+    return typeId;
+}
+
+Ice::UnsupportedProtocolException::~UnsupportedProtocolException()
+{
+}
+
+const ::std::string&
+Ice::UnsupportedProtocolException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::UnsupportedProtocolException";
+    return typeId;
+}
+
+Ice::UnsupportedEncodingException::~UnsupportedEncodingException()
+{
+}
+
+const ::std::string&
+Ice::UnsupportedEncodingException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::UnsupportedEncodingException";
+    return typeId;
+}
+
+Ice::UnknownMessageException::~UnknownMessageException()
+{
+}
+
+const ::std::string&
+Ice::UnknownMessageException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::UnknownMessageException";
+    return typeId;
+}
+
+Ice::ConnectionNotValidatedException::~ConnectionNotValidatedException()
+{
+}
+
+const ::std::string&
+Ice::ConnectionNotValidatedException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::ConnectionNotValidatedException";
+    return typeId;
+}
+
+Ice::UnknownRequestIdException::~UnknownRequestIdException()
+{
+}
+
+const ::std::string&
+Ice::UnknownRequestIdException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::UnknownRequestIdException";
+    return typeId;
+}
+
+Ice::UnknownReplyStatusException::~UnknownReplyStatusException()
+{
+}
+
+const ::std::string&
+Ice::UnknownReplyStatusException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::UnknownReplyStatusException";
+    return typeId;
+}
+
+Ice::CloseConnectionException::~CloseConnectionException()
+{
+}
+
+const ::std::string&
+Ice::CloseConnectionException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::CloseConnectionException";
+    return typeId;
+}
+
+Ice::ConnectionManuallyClosedException::~ConnectionManuallyClosedException()
+{
+}
+
+const ::std::string&
+Ice::ConnectionManuallyClosedException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::ConnectionManuallyClosedException";
+    return typeId;
+}
+
+Ice::IllegalMessageSizeException::~IllegalMessageSizeException()
+{
+}
+
+const ::std::string&
+Ice::IllegalMessageSizeException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::IllegalMessageSizeException";
+    return typeId;
+}
+
+Ice::CompressionException::~CompressionException()
+{
+}
+
+const ::std::string&
+Ice::CompressionException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::CompressionException";
+    return typeId;
+}
+
+Ice::DatagramLimitException::~DatagramLimitException()
+{
+}
+
+const ::std::string&
+Ice::DatagramLimitException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::DatagramLimitException";
+    return typeId;
+}
+
+Ice::MarshalException::~MarshalException()
+{
+}
+
+const ::std::string&
+Ice::MarshalException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::MarshalException";
+    return typeId;
+}
+
+Ice::ProxyUnmarshalException::~ProxyUnmarshalException()
+{
+}
+
+const ::std::string&
+Ice::ProxyUnmarshalException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::ProxyUnmarshalException";
+    return typeId;
+}
+
+Ice::UnmarshalOutOfBoundsException::~UnmarshalOutOfBoundsException()
+{
+}
+
+const ::std::string&
+Ice::UnmarshalOutOfBoundsException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::UnmarshalOutOfBoundsException";
+    return typeId;
+}
+
+Ice::NoValueFactoryException::~NoValueFactoryException()
+{
+}
+
+const ::std::string&
+Ice::NoValueFactoryException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::NoValueFactoryException";
+    return typeId;
+}
+
+Ice::UnexpectedObjectException::~UnexpectedObjectException()
+{
+}
+
+const ::std::string&
+Ice::UnexpectedObjectException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::UnexpectedObjectException";
+    return typeId;
+}
+
+Ice::MemoryLimitException::~MemoryLimitException()
+{
+}
+
+const ::std::string&
+Ice::MemoryLimitException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::MemoryLimitException";
+    return typeId;
+}
+
+Ice::StringConversionException::~StringConversionException()
+{
+}
+
+const ::std::string&
+Ice::StringConversionException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::StringConversionException";
+    return typeId;
+}
+
+Ice::EncapsulationException::~EncapsulationException()
+{
+}
+
+const ::std::string&
+Ice::EncapsulationException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::EncapsulationException";
+    return typeId;
+}
+
+Ice::FeatureNotSupportedException::~FeatureNotSupportedException()
+{
+}
+
+const ::std::string&
+Ice::FeatureNotSupportedException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::FeatureNotSupportedException";
+    return typeId;
+}
+
+Ice::SecurityException::~SecurityException()
+{
+}
+
+const ::std::string&
+Ice::SecurityException::ice_staticId()
 {
+    static const ::std::string typeId = "::Ice::SecurityException";
+    return typeId;
 }
 
-Ice::InitializationException::InitializationException(const char* __file, int __line, const ::std::string& __ice_reason) :
-    ::Ice::LocalException(__file, __line),
-    reason(__ice_reason)
+Ice::FixedProxyException::~FixedProxyException()
+{
+}
+
+const ::std::string&
+Ice::FixedProxyException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::FixedProxyException";
+    return typeId;
+}
+
+Ice::ResponseSentException::~ResponseSentException()
+{
+}
+
+const ::std::string&
+Ice::ResponseSentException::ice_staticId()
+{
+    static const ::std::string typeId = "::Ice::ResponseSentException";
+    return typeId;
+}
+
+#else // C++98 mapping
+
+Ice::InitializationException::InitializationException(const char* file, int line) :
+    LocalException(file, line)
+{
+}
+
+Ice::InitializationException::InitializationException(const char* file, int line, const ::std::string& reason) :
+    LocalException(file, line),
+    reason(reason)
 {
 }
 
@@ -55,9 +788,9 @@ Ice::InitializationException::~InitializationException() throw()
 }
 
 ::std::string
-Ice::InitializationException::ice_name() const
+Ice::InitializationException::ice_id() const
 {
-    return "Ice::InitializationException";
+    return "::Ice::InitializationException";
 }
 
 Ice::InitializationException*
@@ -72,14 +805,14 @@ Ice::InitializationException::ice_throw() const
     throw *this;
 }
 
-Ice::PluginInitializationException::PluginInitializationException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::PluginInitializationException::PluginInitializationException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
-Ice::PluginInitializationException::PluginInitializationException(const char* __file, int __line, const ::std::string& __ice_reason) :
-    ::Ice::LocalException(__file, __line),
-    reason(__ice_reason)
+Ice::PluginInitializationException::PluginInitializationException(const char* file, int line, const ::std::string& reason) :
+    LocalException(file, line),
+    reason(reason)
 {
 }
 
@@ -88,9 +821,9 @@ Ice::PluginInitializationException::~PluginInitializationException() throw()
 }
 
 ::std::string
-Ice::PluginInitializationException::ice_name() const
+Ice::PluginInitializationException::ice_id() const
 {
-    return "Ice::PluginInitializationException";
+    return "::Ice::PluginInitializationException";
 }
 
 Ice::PluginInitializationException*
@@ -105,8 +838,8 @@ Ice::PluginInitializationException::ice_throw() const
     throw *this;
 }
 
-Ice::CollocationOptimizationException::CollocationOptimizationException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::CollocationOptimizationException::CollocationOptimizationException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
@@ -115,9 +848,9 @@ Ice::CollocationOptimizationException::~CollocationOptimizationException() throw
 }
 
 ::std::string
-Ice::CollocationOptimizationException::ice_name() const
+Ice::CollocationOptimizationException::ice_id() const
 {
-    return "Ice::CollocationOptimizationException";
+    return "::Ice::CollocationOptimizationException";
 }
 
 Ice::CollocationOptimizationException*
@@ -132,15 +865,15 @@ Ice::CollocationOptimizationException::ice_throw() const
     throw *this;
 }
 
-Ice::AlreadyRegisteredException::AlreadyRegisteredException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::AlreadyRegisteredException::AlreadyRegisteredException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
-Ice::AlreadyRegisteredException::AlreadyRegisteredException(const char* __file, int __line, const ::std::string& __ice_kindOfObject, const ::std::string& __ice_id) :
-    ::Ice::LocalException(__file, __line),
-    kindOfObject(__ice_kindOfObject),
-    id(__ice_id)
+Ice::AlreadyRegisteredException::AlreadyRegisteredException(const char* file, int line, const ::std::string& kindOfObject, const ::std::string& id) :
+    LocalException(file, line),
+    kindOfObject(kindOfObject),
+    id(id)
 {
 }
 
@@ -149,9 +882,9 @@ Ice::AlreadyRegisteredException::~AlreadyRegisteredException() throw()
 }
 
 ::std::string
-Ice::AlreadyRegisteredException::ice_name() const
+Ice::AlreadyRegisteredException::ice_id() const
 {
-    return "Ice::AlreadyRegisteredException";
+    return "::Ice::AlreadyRegisteredException";
 }
 
 Ice::AlreadyRegisteredException*
@@ -166,15 +899,15 @@ Ice::AlreadyRegisteredException::ice_throw() const
     throw *this;
 }
 
-Ice::NotRegisteredException::NotRegisteredException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::NotRegisteredException::NotRegisteredException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
-Ice::NotRegisteredException::NotRegisteredException(const char* __file, int __line, const ::std::string& __ice_kindOfObject, const ::std::string& __ice_id) :
-    ::Ice::LocalException(__file, __line),
-    kindOfObject(__ice_kindOfObject),
-    id(__ice_id)
+Ice::NotRegisteredException::NotRegisteredException(const char* file, int line, const ::std::string& kindOfObject, const ::std::string& id) :
+    LocalException(file, line),
+    kindOfObject(kindOfObject),
+    id(id)
 {
 }
 
@@ -183,9 +916,9 @@ Ice::NotRegisteredException::~NotRegisteredException() throw()
 }
 
 ::std::string
-Ice::NotRegisteredException::ice_name() const
+Ice::NotRegisteredException::ice_id() const
 {
-    return "Ice::NotRegisteredException";
+    return "::Ice::NotRegisteredException";
 }
 
 Ice::NotRegisteredException*
@@ -200,14 +933,14 @@ Ice::NotRegisteredException::ice_throw() const
     throw *this;
 }
 
-Ice::TwowayOnlyException::TwowayOnlyException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::TwowayOnlyException::TwowayOnlyException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
-Ice::TwowayOnlyException::TwowayOnlyException(const char* __file, int __line, const ::std::string& __ice_operation) :
-    ::Ice::LocalException(__file, __line),
-    operation(__ice_operation)
+Ice::TwowayOnlyException::TwowayOnlyException(const char* file, int line, const ::std::string& operation) :
+    LocalException(file, line),
+    operation(operation)
 {
 }
 
@@ -216,9 +949,9 @@ Ice::TwowayOnlyException::~TwowayOnlyException() throw()
 }
 
 ::std::string
-Ice::TwowayOnlyException::ice_name() const
+Ice::TwowayOnlyException::ice_id() const
 {
-    return "Ice::TwowayOnlyException";
+    return "::Ice::TwowayOnlyException";
 }
 
 Ice::TwowayOnlyException*
@@ -233,8 +966,8 @@ Ice::TwowayOnlyException::ice_throw() const
     throw *this;
 }
 
-Ice::CloneNotImplementedException::CloneNotImplementedException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::CloneNotImplementedException::CloneNotImplementedException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
@@ -243,9 +976,9 @@ Ice::CloneNotImplementedException::~CloneNotImplementedException() throw()
 }
 
 ::std::string
-Ice::CloneNotImplementedException::ice_name() const
+Ice::CloneNotImplementedException::ice_id() const
 {
-    return "Ice::CloneNotImplementedException";
+    return "::Ice::CloneNotImplementedException";
 }
 
 Ice::CloneNotImplementedException*
@@ -260,14 +993,14 @@ Ice::CloneNotImplementedException::ice_throw() const
     throw *this;
 }
 
-Ice::UnknownException::UnknownException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::UnknownException::UnknownException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
-Ice::UnknownException::UnknownException(const char* __file, int __line, const ::std::string& __ice_unknown) :
-    ::Ice::LocalException(__file, __line),
-    unknown(__ice_unknown)
+Ice::UnknownException::UnknownException(const char* file, int line, const ::std::string& unknown) :
+    LocalException(file, line),
+    unknown(unknown)
 {
 }
 
@@ -276,9 +1009,9 @@ Ice::UnknownException::~UnknownException() throw()
 }
 
 ::std::string
-Ice::UnknownException::ice_name() const
+Ice::UnknownException::ice_id() const
 {
-    return "Ice::UnknownException";
+    return "::Ice::UnknownException";
 }
 
 Ice::UnknownException*
@@ -293,13 +1026,13 @@ Ice::UnknownException::ice_throw() const
     throw *this;
 }
 
-Ice::UnknownLocalException::UnknownLocalException(const char* __file, int __line) :
-    ::Ice::UnknownException(__file, __line)
+Ice::UnknownLocalException::UnknownLocalException(const char* file, int line) :
+    UnknownException(file, line)
 {
 }
 
-Ice::UnknownLocalException::UnknownLocalException(const char* __file, int __line, const ::std::string& __ice_unknown) :
-    ::Ice::UnknownException(__file, __line, __ice_unknown)
+Ice::UnknownLocalException::UnknownLocalException(const char* file, int line, const ::std::string& unknown) :
+    UnknownException(file, line, unknown)
 {
 }
 
@@ -308,9 +1041,9 @@ Ice::UnknownLocalException::~UnknownLocalException() throw()
 }
 
 ::std::string
-Ice::UnknownLocalException::ice_name() const
+Ice::UnknownLocalException::ice_id() const
 {
-    return "Ice::UnknownLocalException";
+    return "::Ice::UnknownLocalException";
 }
 
 Ice::UnknownLocalException*
@@ -325,13 +1058,13 @@ Ice::UnknownLocalException::ice_throw() const
     throw *this;
 }
 
-Ice::UnknownUserException::UnknownUserException(const char* __file, int __line) :
-    ::Ice::UnknownException(__file, __line)
+Ice::UnknownUserException::UnknownUserException(const char* file, int line) :
+    UnknownException(file, line)
 {
 }
 
-Ice::UnknownUserException::UnknownUserException(const char* __file, int __line, const ::std::string& __ice_unknown) :
-    ::Ice::UnknownException(__file, __line, __ice_unknown)
+Ice::UnknownUserException::UnknownUserException(const char* file, int line, const ::std::string& unknown) :
+    UnknownException(file, line, unknown)
 {
 }
 
@@ -340,9 +1073,9 @@ Ice::UnknownUserException::~UnknownUserException() throw()
 }
 
 ::std::string
-Ice::UnknownUserException::ice_name() const
+Ice::UnknownUserException::ice_id() const
 {
-    return "Ice::UnknownUserException";
+    return "::Ice::UnknownUserException";
 }
 
 Ice::UnknownUserException*
@@ -357,8 +1090,8 @@ Ice::UnknownUserException::ice_throw() const
     throw *this;
 }
 
-Ice::VersionMismatchException::VersionMismatchException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::VersionMismatchException::VersionMismatchException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
@@ -367,9 +1100,9 @@ Ice::VersionMismatchException::~VersionMismatchException() throw()
 }
 
 ::std::string
-Ice::VersionMismatchException::ice_name() const
+Ice::VersionMismatchException::ice_id() const
 {
-    return "Ice::VersionMismatchException";
+    return "::Ice::VersionMismatchException";
 }
 
 Ice::VersionMismatchException*
@@ -384,8 +1117,8 @@ Ice::VersionMismatchException::ice_throw() const
     throw *this;
 }
 
-Ice::CommunicatorDestroyedException::CommunicatorDestroyedException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::CommunicatorDestroyedException::CommunicatorDestroyedException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
@@ -394,9 +1127,9 @@ Ice::CommunicatorDestroyedException::~CommunicatorDestroyedException() throw()
 }
 
 ::std::string
-Ice::CommunicatorDestroyedException::ice_name() const
+Ice::CommunicatorDestroyedException::ice_id() const
 {
-    return "Ice::CommunicatorDestroyedException";
+    return "::Ice::CommunicatorDestroyedException";
 }
 
 Ice::CommunicatorDestroyedException*
@@ -411,14 +1144,14 @@ Ice::CommunicatorDestroyedException::ice_throw() const
     throw *this;
 }
 
-Ice::ObjectAdapterDeactivatedException::ObjectAdapterDeactivatedException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::ObjectAdapterDeactivatedException::ObjectAdapterDeactivatedException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
-Ice::ObjectAdapterDeactivatedException::ObjectAdapterDeactivatedException(const char* __file, int __line, const ::std::string& __ice_name) :
-    ::Ice::LocalException(__file, __line),
-    name(__ice_name)
+Ice::ObjectAdapterDeactivatedException::ObjectAdapterDeactivatedException(const char* file, int line, const ::std::string& name) :
+    LocalException(file, line),
+    name(name)
 {
 }
 
@@ -427,9 +1160,9 @@ Ice::ObjectAdapterDeactivatedException::~ObjectAdapterDeactivatedException() thr
 }
 
 ::std::string
-Ice::ObjectAdapterDeactivatedException::ice_name() const
+Ice::ObjectAdapterDeactivatedException::ice_id() const
 {
-    return "Ice::ObjectAdapterDeactivatedException";
+    return "::Ice::ObjectAdapterDeactivatedException";
 }
 
 Ice::ObjectAdapterDeactivatedException*
@@ -444,14 +1177,14 @@ Ice::ObjectAdapterDeactivatedException::ice_throw() const
     throw *this;
 }
 
-Ice::ObjectAdapterIdInUseException::ObjectAdapterIdInUseException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::ObjectAdapterIdInUseException::ObjectAdapterIdInUseException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
-Ice::ObjectAdapterIdInUseException::ObjectAdapterIdInUseException(const char* __file, int __line, const ::std::string& __ice_id) :
-    ::Ice::LocalException(__file, __line),
-    id(__ice_id)
+Ice::ObjectAdapterIdInUseException::ObjectAdapterIdInUseException(const char* file, int line, const ::std::string& id) :
+    LocalException(file, line),
+    id(id)
 {
 }
 
@@ -460,9 +1193,9 @@ Ice::ObjectAdapterIdInUseException::~ObjectAdapterIdInUseException() throw()
 }
 
 ::std::string
-Ice::ObjectAdapterIdInUseException::ice_name() const
+Ice::ObjectAdapterIdInUseException::ice_id() const
 {
-    return "Ice::ObjectAdapterIdInUseException";
+    return "::Ice::ObjectAdapterIdInUseException";
 }
 
 Ice::ObjectAdapterIdInUseException*
@@ -477,14 +1210,14 @@ Ice::ObjectAdapterIdInUseException::ice_throw() const
     throw *this;
 }
 
-Ice::NoEndpointException::NoEndpointException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::NoEndpointException::NoEndpointException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
-Ice::NoEndpointException::NoEndpointException(const char* __file, int __line, const ::std::string& __ice_proxy) :
-    ::Ice::LocalException(__file, __line),
-    proxy(__ice_proxy)
+Ice::NoEndpointException::NoEndpointException(const char* file, int line, const ::std::string& proxy) :
+    LocalException(file, line),
+    proxy(proxy)
 {
 }
 
@@ -493,9 +1226,9 @@ Ice::NoEndpointException::~NoEndpointException() throw()
 }
 
 ::std::string
-Ice::NoEndpointException::ice_name() const
+Ice::NoEndpointException::ice_id() const
 {
-    return "Ice::NoEndpointException";
+    return "::Ice::NoEndpointException";
 }
 
 Ice::NoEndpointException*
@@ -510,14 +1243,14 @@ Ice::NoEndpointException::ice_throw() const
     throw *this;
 }
 
-Ice::EndpointParseException::EndpointParseException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::EndpointParseException::EndpointParseException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
-Ice::EndpointParseException::EndpointParseException(const char* __file, int __line, const ::std::string& __ice_str) :
-    ::Ice::LocalException(__file, __line),
-    str(__ice_str)
+Ice::EndpointParseException::EndpointParseException(const char* file, int line, const ::std::string& str) :
+    LocalException(file, line),
+    str(str)
 {
 }
 
@@ -526,9 +1259,9 @@ Ice::EndpointParseException::~EndpointParseException() throw()
 }
 
 ::std::string
-Ice::EndpointParseException::ice_name() const
+Ice::EndpointParseException::ice_id() const
 {
-    return "Ice::EndpointParseException";
+    return "::Ice::EndpointParseException";
 }
 
 Ice::EndpointParseException*
@@ -543,14 +1276,14 @@ Ice::EndpointParseException::ice_throw() const
     throw *this;
 }
 
-Ice::EndpointSelectionTypeParseException::EndpointSelectionTypeParseException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::EndpointSelectionTypeParseException::EndpointSelectionTypeParseException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
-Ice::EndpointSelectionTypeParseException::EndpointSelectionTypeParseException(const char* __file, int __line, const ::std::string& __ice_str) :
-    ::Ice::LocalException(__file, __line),
-    str(__ice_str)
+Ice::EndpointSelectionTypeParseException::EndpointSelectionTypeParseException(const char* file, int line, const ::std::string& str) :
+    LocalException(file, line),
+    str(str)
 {
 }
 
@@ -559,9 +1292,9 @@ Ice::EndpointSelectionTypeParseException::~EndpointSelectionTypeParseException()
 }
 
 ::std::string
-Ice::EndpointSelectionTypeParseException::ice_name() const
+Ice::EndpointSelectionTypeParseException::ice_id() const
 {
-    return "Ice::EndpointSelectionTypeParseException";
+    return "::Ice::EndpointSelectionTypeParseException";
 }
 
 Ice::EndpointSelectionTypeParseException*
@@ -576,14 +1309,14 @@ Ice::EndpointSelectionTypeParseException::ice_throw() const
     throw *this;
 }
 
-Ice::VersionParseException::VersionParseException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::VersionParseException::VersionParseException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
-Ice::VersionParseException::VersionParseException(const char* __file, int __line, const ::std::string& __ice_str) :
-    ::Ice::LocalException(__file, __line),
-    str(__ice_str)
+Ice::VersionParseException::VersionParseException(const char* file, int line, const ::std::string& str) :
+    LocalException(file, line),
+    str(str)
 {
 }
 
@@ -592,9 +1325,9 @@ Ice::VersionParseException::~VersionParseException() throw()
 }
 
 ::std::string
-Ice::VersionParseException::ice_name() const
+Ice::VersionParseException::ice_id() const
 {
-    return "Ice::VersionParseException";
+    return "::Ice::VersionParseException";
 }
 
 Ice::VersionParseException*
@@ -609,14 +1342,14 @@ Ice::VersionParseException::ice_throw() const
     throw *this;
 }
 
-Ice::IdentityParseException::IdentityParseException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::IdentityParseException::IdentityParseException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
-Ice::IdentityParseException::IdentityParseException(const char* __file, int __line, const ::std::string& __ice_str) :
-    ::Ice::LocalException(__file, __line),
-    str(__ice_str)
+Ice::IdentityParseException::IdentityParseException(const char* file, int line, const ::std::string& str) :
+    LocalException(file, line),
+    str(str)
 {
 }
 
@@ -625,9 +1358,9 @@ Ice::IdentityParseException::~IdentityParseException() throw()
 }
 
 ::std::string
-Ice::IdentityParseException::ice_name() const
+Ice::IdentityParseException::ice_id() const
 {
-    return "Ice::IdentityParseException";
+    return "::Ice::IdentityParseException";
 }
 
 Ice::IdentityParseException*
@@ -642,14 +1375,14 @@ Ice::IdentityParseException::ice_throw() const
     throw *this;
 }
 
-Ice::ProxyParseException::ProxyParseException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::ProxyParseException::ProxyParseException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
-Ice::ProxyParseException::ProxyParseException(const char* __file, int __line, const ::std::string& __ice_str) :
-    ::Ice::LocalException(__file, __line),
-    str(__ice_str)
+Ice::ProxyParseException::ProxyParseException(const char* file, int line, const ::std::string& str) :
+    LocalException(file, line),
+    str(str)
 {
 }
 
@@ -658,9 +1391,9 @@ Ice::ProxyParseException::~ProxyParseException() throw()
 }
 
 ::std::string
-Ice::ProxyParseException::ice_name() const
+Ice::ProxyParseException::ice_id() const
 {
-    return "Ice::ProxyParseException";
+    return "::Ice::ProxyParseException";
 }
 
 Ice::ProxyParseException*
@@ -675,14 +1408,14 @@ Ice::ProxyParseException::ice_throw() const
     throw *this;
 }
 
-Ice::IllegalIdentityException::IllegalIdentityException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::IllegalIdentityException::IllegalIdentityException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
-Ice::IllegalIdentityException::IllegalIdentityException(const char* __file, int __line, const ::Ice::Identity& __ice_id) :
-    ::Ice::LocalException(__file, __line),
-    id(__ice_id)
+Ice::IllegalIdentityException::IllegalIdentityException(const char* file, int line, const Identity& id) :
+    LocalException(file, line),
+    id(id)
 {
 }
 
@@ -691,9 +1424,9 @@ Ice::IllegalIdentityException::~IllegalIdentityException() throw()
 }
 
 ::std::string
-Ice::IllegalIdentityException::ice_name() const
+Ice::IllegalIdentityException::ice_id() const
 {
-    return "Ice::IllegalIdentityException";
+    return "::Ice::IllegalIdentityException";
 }
 
 Ice::IllegalIdentityException*
@@ -708,14 +1441,14 @@ Ice::IllegalIdentityException::ice_throw() const
     throw *this;
 }
 
-Ice::IllegalServantException::IllegalServantException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::IllegalServantException::IllegalServantException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
-Ice::IllegalServantException::IllegalServantException(const char* __file, int __line, const ::std::string& __ice_reason) :
-    ::Ice::LocalException(__file, __line),
-    reason(__ice_reason)
+Ice::IllegalServantException::IllegalServantException(const char* file, int line, const ::std::string& reason) :
+    LocalException(file, line),
+    reason(reason)
 {
 }
 
@@ -724,9 +1457,9 @@ Ice::IllegalServantException::~IllegalServantException() throw()
 }
 
 ::std::string
-Ice::IllegalServantException::ice_name() const
+Ice::IllegalServantException::ice_id() const
 {
-    return "Ice::IllegalServantException";
+    return "::Ice::IllegalServantException";
 }
 
 Ice::IllegalServantException*
@@ -741,16 +1474,16 @@ Ice::IllegalServantException::ice_throw() const
     throw *this;
 }
 
-Ice::RequestFailedException::RequestFailedException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::RequestFailedException::RequestFailedException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
-Ice::RequestFailedException::RequestFailedException(const char* __file, int __line, const ::Ice::Identity& __ice_id, const ::std::string& __ice_facet, const ::std::string& __ice_operation) :
-    ::Ice::LocalException(__file, __line),
-    id(__ice_id),
-    facet(__ice_facet),
-    operation(__ice_operation)
+Ice::RequestFailedException::RequestFailedException(const char* file, int line, const Identity& id, const ::std::string& facet, const ::std::string& operation) :
+    LocalException(file, line),
+    id(id),
+    facet(facet),
+    operation(operation)
 {
 }
 
@@ -759,9 +1492,9 @@ Ice::RequestFailedException::~RequestFailedException() throw()
 }
 
 ::std::string
-Ice::RequestFailedException::ice_name() const
+Ice::RequestFailedException::ice_id() const
 {
-    return "Ice::RequestFailedException";
+    return "::Ice::RequestFailedException";
 }
 
 Ice::RequestFailedException*
@@ -776,13 +1509,13 @@ Ice::RequestFailedException::ice_throw() const
     throw *this;
 }
 
-Ice::ObjectNotExistException::ObjectNotExistException(const char* __file, int __line) :
-    ::Ice::RequestFailedException(__file, __line)
+Ice::ObjectNotExistException::ObjectNotExistException(const char* file, int line) :
+    RequestFailedException(file, line)
 {
 }
 
-Ice::ObjectNotExistException::ObjectNotExistException(const char* __file, int __line, const ::Ice::Identity& __ice_id, const ::std::string& __ice_facet, const ::std::string& __ice_operation) :
-    ::Ice::RequestFailedException(__file, __line, __ice_id, __ice_facet, __ice_operation)
+Ice::ObjectNotExistException::ObjectNotExistException(const char* file, int line, const Identity& id, const ::std::string& facet, const ::std::string& operation) :
+    RequestFailedException(file, line, id, facet, operation)
 {
 }
 
@@ -791,9 +1524,9 @@ Ice::ObjectNotExistException::~ObjectNotExistException() throw()
 }
 
 ::std::string
-Ice::ObjectNotExistException::ice_name() const
+Ice::ObjectNotExistException::ice_id() const
 {
-    return "Ice::ObjectNotExistException";
+    return "::Ice::ObjectNotExistException";
 }
 
 Ice::ObjectNotExistException*
@@ -808,13 +1541,13 @@ Ice::ObjectNotExistException::ice_throw() const
     throw *this;
 }
 
-Ice::FacetNotExistException::FacetNotExistException(const char* __file, int __line) :
-    ::Ice::RequestFailedException(__file, __line)
+Ice::FacetNotExistException::FacetNotExistException(const char* file, int line) :
+    RequestFailedException(file, line)
 {
 }
 
-Ice::FacetNotExistException::FacetNotExistException(const char* __file, int __line, const ::Ice::Identity& __ice_id, const ::std::string& __ice_facet, const ::std::string& __ice_operation) :
-    ::Ice::RequestFailedException(__file, __line, __ice_id, __ice_facet, __ice_operation)
+Ice::FacetNotExistException::FacetNotExistException(const char* file, int line, const Identity& id, const ::std::string& facet, const ::std::string& operation) :
+    RequestFailedException(file, line, id, facet, operation)
 {
 }
 
@@ -823,9 +1556,9 @@ Ice::FacetNotExistException::~FacetNotExistException() throw()
 }
 
 ::std::string
-Ice::FacetNotExistException::ice_name() const
+Ice::FacetNotExistException::ice_id() const
 {
-    return "Ice::FacetNotExistException";
+    return "::Ice::FacetNotExistException";
 }
 
 Ice::FacetNotExistException*
@@ -840,13 +1573,13 @@ Ice::FacetNotExistException::ice_throw() const
     throw *this;
 }
 
-Ice::OperationNotExistException::OperationNotExistException(const char* __file, int __line) :
-    ::Ice::RequestFailedException(__file, __line)
+Ice::OperationNotExistException::OperationNotExistException(const char* file, int line) :
+    RequestFailedException(file, line)
 {
 }
 
-Ice::OperationNotExistException::OperationNotExistException(const char* __file, int __line, const ::Ice::Identity& __ice_id, const ::std::string& __ice_facet, const ::std::string& __ice_operation) :
-    ::Ice::RequestFailedException(__file, __line, __ice_id, __ice_facet, __ice_operation)
+Ice::OperationNotExistException::OperationNotExistException(const char* file, int line, const Identity& id, const ::std::string& facet, const ::std::string& operation) :
+    RequestFailedException(file, line, id, facet, operation)
 {
 }
 
@@ -855,9 +1588,9 @@ Ice::OperationNotExistException::~OperationNotExistException() throw()
 }
 
 ::std::string
-Ice::OperationNotExistException::ice_name() const
+Ice::OperationNotExistException::ice_id() const
 {
-    return "Ice::OperationNotExistException";
+    return "::Ice::OperationNotExistException";
 }
 
 Ice::OperationNotExistException*
@@ -872,15 +1605,15 @@ Ice::OperationNotExistException::ice_throw() const
     throw *this;
 }
 
-Ice::SyscallException::SyscallException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line), 
+Ice::SyscallException::SyscallException(const char* file, int line) :
+    LocalException(file, line),
     error(0)
 {
 }
 
-Ice::SyscallException::SyscallException(const char* __file, int __line, ::Ice::Int __ice_error) :
-    ::Ice::LocalException(__file, __line),
-    error(__ice_error)
+Ice::SyscallException::SyscallException(const char* file, int line, Int error) :
+    LocalException(file, line),
+    error(error)
 {
 }
 
@@ -889,9 +1622,9 @@ Ice::SyscallException::~SyscallException() throw()
 }
 
 ::std::string
-Ice::SyscallException::ice_name() const
+Ice::SyscallException::ice_id() const
 {
-    return "Ice::SyscallException";
+    return "::Ice::SyscallException";
 }
 
 Ice::SyscallException*
@@ -906,13 +1639,13 @@ Ice::SyscallException::ice_throw() const
     throw *this;
 }
 
-Ice::SocketException::SocketException(const char* __file, int __line) :
-    ::Ice::SyscallException(__file, __line)
+Ice::SocketException::SocketException(const char* file, int line) :
+    SyscallException(file, line)
 {
 }
 
-Ice::SocketException::SocketException(const char* __file, int __line, ::Ice::Int __ice_error) :
-    ::Ice::SyscallException(__file, __line, __ice_error)
+Ice::SocketException::SocketException(const char* file, int line, Int error) :
+    SyscallException(file, line, error)
 {
 }
 
@@ -921,9 +1654,9 @@ Ice::SocketException::~SocketException() throw()
 }
 
 ::std::string
-Ice::SocketException::ice_name() const
+Ice::SocketException::ice_id() const
 {
-    return "Ice::SocketException";
+    return "::Ice::SocketException";
 }
 
 Ice::SocketException*
@@ -938,14 +1671,47 @@ Ice::SocketException::ice_throw() const
     throw *this;
 }
 
-Ice::FileException::FileException(const char* __file, int __line) :
-    ::Ice::SyscallException(__file, __line)
+Ice::CFNetworkException::CFNetworkException(const char* file, int line) :
+    SocketException(file, line)
+{
+}
+
+Ice::CFNetworkException::CFNetworkException(const char* file, int line, Int error, const ::std::string& domain) :
+    SocketException(file, line, error),
+    domain(domain)
+{
+}
+
+Ice::CFNetworkException::~CFNetworkException() throw()
+{
+}
+
+::std::string
+Ice::CFNetworkException::ice_id() const
+{
+    return "::Ice::CFNetworkException";
+}
+
+Ice::CFNetworkException*
+Ice::CFNetworkException::ice_clone() const
+{
+    return new CFNetworkException(*this);
+}
+
+void
+Ice::CFNetworkException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::FileException::FileException(const char* file, int line) :
+    SyscallException(file, line)
 {
 }
 
-Ice::FileException::FileException(const char* __file, int __line, ::Ice::Int __ice_error, const ::std::string& __ice_path) :
-    ::Ice::SyscallException(__file, __line, __ice_error),
-    path(__ice_path)
+Ice::FileException::FileException(const char* file, int line, Int error, const ::std::string& path) :
+    SyscallException(file, line, error),
+    path(path)
 {
 }
 
@@ -954,9 +1720,9 @@ Ice::FileException::~FileException() throw()
 }
 
 ::std::string
-Ice::FileException::ice_name() const
+Ice::FileException::ice_id() const
 {
-    return "Ice::FileException";
+    return "::Ice::FileException";
 }
 
 Ice::FileException*
@@ -971,13 +1737,13 @@ Ice::FileException::ice_throw() const
     throw *this;
 }
 
-Ice::ConnectFailedException::ConnectFailedException(const char* __file, int __line) :
-    ::Ice::SocketException(__file, __line)
+Ice::ConnectFailedException::ConnectFailedException(const char* file, int line) :
+    SocketException(file, line)
 {
 }
 
-Ice::ConnectFailedException::ConnectFailedException(const char* __file, int __line, ::Ice::Int __ice_error) :
-    ::Ice::SocketException(__file, __line, __ice_error)
+Ice::ConnectFailedException::ConnectFailedException(const char* file, int line, Int error) :
+    SocketException(file, line, error)
 {
 }
 
@@ -986,9 +1752,9 @@ Ice::ConnectFailedException::~ConnectFailedException() throw()
 }
 
 ::std::string
-Ice::ConnectFailedException::ice_name() const
+Ice::ConnectFailedException::ice_id() const
 {
-    return "Ice::ConnectFailedException";
+    return "::Ice::ConnectFailedException";
 }
 
 Ice::ConnectFailedException*
@@ -1003,13 +1769,13 @@ Ice::ConnectFailedException::ice_throw() const
     throw *this;
 }
 
-Ice::ConnectionRefusedException::ConnectionRefusedException(const char* __file, int __line) :
-    ::Ice::ConnectFailedException(__file, __line)
+Ice::ConnectionRefusedException::ConnectionRefusedException(const char* file, int line) :
+    ConnectFailedException(file, line)
 {
 }
 
-Ice::ConnectionRefusedException::ConnectionRefusedException(const char* __file, int __line, ::Ice::Int __ice_error) :
-    ::Ice::ConnectFailedException(__file, __line, __ice_error)
+Ice::ConnectionRefusedException::ConnectionRefusedException(const char* file, int line, Int error) :
+    ConnectFailedException(file, line, error)
 {
 }
 
@@ -1018,9 +1784,9 @@ Ice::ConnectionRefusedException::~ConnectionRefusedException() throw()
 }
 
 ::std::string
-Ice::ConnectionRefusedException::ice_name() const
+Ice::ConnectionRefusedException::ice_id() const
 {
-    return "Ice::ConnectionRefusedException";
+    return "::Ice::ConnectionRefusedException";
 }
 
 Ice::ConnectionRefusedException*
@@ -1035,13 +1801,13 @@ Ice::ConnectionRefusedException::ice_throw() const
     throw *this;
 }
 
-Ice::ConnectionLostException::ConnectionLostException(const char* __file, int __line) :
-    ::Ice::SocketException(__file, __line)
+Ice::ConnectionLostException::ConnectionLostException(const char* file, int line) :
+    SocketException(file, line)
 {
 }
 
-Ice::ConnectionLostException::ConnectionLostException(const char* __file, int __line, ::Ice::Int __ice_error) :
-    ::Ice::SocketException(__file, __line, __ice_error)
+Ice::ConnectionLostException::ConnectionLostException(const char* file, int line, Int error) :
+    SocketException(file, line, error)
 {
 }
 
@@ -1050,9 +1816,9 @@ Ice::ConnectionLostException::~ConnectionLostException() throw()
 }
 
 ::std::string
-Ice::ConnectionLostException::ice_name() const
+Ice::ConnectionLostException::ice_id() const
 {
-    return "Ice::ConnectionLostException";
+    return "::Ice::ConnectionLostException";
 }
 
 Ice::ConnectionLostException*
@@ -1067,16 +1833,16 @@ Ice::ConnectionLostException::ice_throw() const
     throw *this;
 }
 
-Ice::DNSException::DNSException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line), 
+Ice::DNSException::DNSException(const char* file, int line) :
+    LocalException(file, line),
     error(0)
 {
 }
 
-Ice::DNSException::DNSException(const char* __file, int __line, ::Ice::Int __ice_error, const ::std::string& __ice_host) :
-    ::Ice::LocalException(__file, __line),
-    error(__ice_error),
-    host(__ice_host)
+Ice::DNSException::DNSException(const char* file, int line, Int error, const ::std::string& host) :
+    LocalException(file, line),
+    error(error),
+    host(host)
 {
 }
 
@@ -1085,9 +1851,9 @@ Ice::DNSException::~DNSException() throw()
 }
 
 ::std::string
-Ice::DNSException::ice_name() const
+Ice::DNSException::ice_id() const
 {
-    return "Ice::DNSException";
+    return "::Ice::DNSException";
 }
 
 Ice::DNSException*
@@ -1102,8 +1868,8 @@ Ice::DNSException::ice_throw() const
     throw *this;
 }
 
-Ice::OperationInterruptedException::OperationInterruptedException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::OperationInterruptedException::OperationInterruptedException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
@@ -1112,9 +1878,9 @@ Ice::OperationInterruptedException::~OperationInterruptedException() throw()
 }
 
 ::std::string
-Ice::OperationInterruptedException::ice_name() const
+Ice::OperationInterruptedException::ice_id() const
 {
-    return "Ice::OperationInterruptedException";
+    return "::Ice::OperationInterruptedException";
 }
 
 Ice::OperationInterruptedException*
@@ -1129,8 +1895,8 @@ Ice::OperationInterruptedException::ice_throw() const
     throw *this;
 }
 
-Ice::TimeoutException::TimeoutException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::TimeoutException::TimeoutException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
@@ -1139,9 +1905,9 @@ Ice::TimeoutException::~TimeoutException() throw()
 }
 
 ::std::string
-Ice::TimeoutException::ice_name() const
+Ice::TimeoutException::ice_id() const
 {
-    return "Ice::TimeoutException";
+    return "::Ice::TimeoutException";
 }
 
 Ice::TimeoutException*
@@ -1156,8 +1922,8 @@ Ice::TimeoutException::ice_throw() const
     throw *this;
 }
 
-Ice::ConnectTimeoutException::ConnectTimeoutException(const char* __file, int __line) :
-    ::Ice::TimeoutException(__file, __line)
+Ice::ConnectTimeoutException::ConnectTimeoutException(const char* file, int line) :
+    TimeoutException(file, line)
 {
 }
 
@@ -1166,9 +1932,9 @@ Ice::ConnectTimeoutException::~ConnectTimeoutException() throw()
 }
 
 ::std::string
-Ice::ConnectTimeoutException::ice_name() const
+Ice::ConnectTimeoutException::ice_id() const
 {
-    return "Ice::ConnectTimeoutException";
+    return "::Ice::ConnectTimeoutException";
 }
 
 Ice::ConnectTimeoutException*
@@ -1183,8 +1949,8 @@ Ice::ConnectTimeoutException::ice_throw() const
     throw *this;
 }
 
-Ice::CloseTimeoutException::CloseTimeoutException(const char* __file, int __line) :
-    ::Ice::TimeoutException(__file, __line)
+Ice::CloseTimeoutException::CloseTimeoutException(const char* file, int line) :
+    TimeoutException(file, line)
 {
 }
 
@@ -1193,9 +1959,9 @@ Ice::CloseTimeoutException::~CloseTimeoutException() throw()
 }
 
 ::std::string
-Ice::CloseTimeoutException::ice_name() const
+Ice::CloseTimeoutException::ice_id() const
 {
-    return "Ice::CloseTimeoutException";
+    return "::Ice::CloseTimeoutException";
 }
 
 Ice::CloseTimeoutException*
@@ -1210,8 +1976,8 @@ Ice::CloseTimeoutException::ice_throw() const
     throw *this;
 }
 
-Ice::ConnectionTimeoutException::ConnectionTimeoutException(const char* __file, int __line) :
-    ::Ice::TimeoutException(__file, __line)
+Ice::ConnectionTimeoutException::ConnectionTimeoutException(const char* file, int line) :
+    TimeoutException(file, line)
 {
 }
 
@@ -1220,9 +1986,9 @@ Ice::ConnectionTimeoutException::~ConnectionTimeoutException() throw()
 }
 
 ::std::string
-Ice::ConnectionTimeoutException::ice_name() const
+Ice::ConnectionTimeoutException::ice_id() const
 {
-    return "Ice::ConnectionTimeoutException";
+    return "::Ice::ConnectionTimeoutException";
 }
 
 Ice::ConnectionTimeoutException*
@@ -1237,8 +2003,8 @@ Ice::ConnectionTimeoutException::ice_throw() const
     throw *this;
 }
 
-Ice::InvocationTimeoutException::InvocationTimeoutException(const char* __file, int __line) :
-    ::Ice::TimeoutException(__file, __line)
+Ice::InvocationTimeoutException::InvocationTimeoutException(const char* file, int line) :
+    TimeoutException(file, line)
 {
 }
 
@@ -1247,9 +2013,9 @@ Ice::InvocationTimeoutException::~InvocationTimeoutException() throw()
 }
 
 ::std::string
-Ice::InvocationTimeoutException::ice_name() const
+Ice::InvocationTimeoutException::ice_id() const
 {
-    return "Ice::InvocationTimeoutException";
+    return "::Ice::InvocationTimeoutException";
 }
 
 Ice::InvocationTimeoutException*
@@ -1264,8 +2030,8 @@ Ice::InvocationTimeoutException::ice_throw() const
     throw *this;
 }
 
-Ice::InvocationCanceledException::InvocationCanceledException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::InvocationCanceledException::InvocationCanceledException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
@@ -1274,9 +2040,9 @@ Ice::InvocationCanceledException::~InvocationCanceledException() throw()
 }
 
 ::std::string
-Ice::InvocationCanceledException::ice_name() const
+Ice::InvocationCanceledException::ice_id() const
 {
-    return "Ice::InvocationCanceledException";
+    return "::Ice::InvocationCanceledException";
 }
 
 Ice::InvocationCanceledException*
@@ -1291,14 +2057,14 @@ Ice::InvocationCanceledException::ice_throw() const
     throw *this;
 }
 
-Ice::ProtocolException::ProtocolException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::ProtocolException::ProtocolException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
-Ice::ProtocolException::ProtocolException(const char* __file, int __line, const ::std::string& __ice_reason) :
-    ::Ice::LocalException(__file, __line),
-    reason(__ice_reason)
+Ice::ProtocolException::ProtocolException(const char* file, int line, const ::std::string& reason) :
+    LocalException(file, line),
+    reason(reason)
 {
 }
 
@@ -1307,9 +2073,9 @@ Ice::ProtocolException::~ProtocolException() throw()
 }
 
 ::std::string
-Ice::ProtocolException::ice_name() const
+Ice::ProtocolException::ice_id() const
 {
-    return "Ice::ProtocolException";
+    return "::Ice::ProtocolException";
 }
 
 Ice::ProtocolException*
@@ -1324,14 +2090,14 @@ Ice::ProtocolException::ice_throw() const
     throw *this;
 }
 
-Ice::BadMagicException::BadMagicException(const char* __file, int __line) :
-    ::Ice::ProtocolException(__file, __line)
+Ice::BadMagicException::BadMagicException(const char* file, int line) :
+    ProtocolException(file, line)
 {
 }
 
-Ice::BadMagicException::BadMagicException(const char* __file, int __line, const ::std::string& __ice_reason, const ::Ice::ByteSeq& __ice_badMagic) :
-    ::Ice::ProtocolException(__file, __line, __ice_reason),
-    badMagic(__ice_badMagic)
+Ice::BadMagicException::BadMagicException(const char* file, int line, const ::std::string& reason, const ByteSeq& badMagic) :
+    ProtocolException(file, line, reason),
+    badMagic(badMagic)
 {
 }
 
@@ -1340,9 +2106,9 @@ Ice::BadMagicException::~BadMagicException() throw()
 }
 
 ::std::string
-Ice::BadMagicException::ice_name() const
+Ice::BadMagicException::ice_id() const
 {
-    return "Ice::BadMagicException";
+    return "::Ice::BadMagicException";
 }
 
 Ice::BadMagicException*
@@ -1357,15 +2123,15 @@ Ice::BadMagicException::ice_throw() const
     throw *this;
 }
 
-Ice::UnsupportedProtocolException::UnsupportedProtocolException(const char* __file, int __line) :
-    ::Ice::ProtocolException(__file, __line)
+Ice::UnsupportedProtocolException::UnsupportedProtocolException(const char* file, int line) :
+    ProtocolException(file, line)
 {
 }
 
-Ice::UnsupportedProtocolException::UnsupportedProtocolException(const char* __file, int __line, const ::std::string& __ice_reason, const ::Ice::ProtocolVersion& __ice_bad, const ::Ice::ProtocolVersion& __ice_supported) :
-    ::Ice::ProtocolException(__file, __line, __ice_reason),
-    bad(__ice_bad),
-    supported(__ice_supported)
+Ice::UnsupportedProtocolException::UnsupportedProtocolException(const char* file, int line, const ::std::string& reason, const ProtocolVersion& bad, const ProtocolVersion& supported) :
+    ProtocolException(file, line, reason),
+    bad(bad),
+    supported(supported)
 {
 }
 
@@ -1374,9 +2140,9 @@ Ice::UnsupportedProtocolException::~UnsupportedProtocolException() throw()
 }
 
 ::std::string
-Ice::UnsupportedProtocolException::ice_name() const
+Ice::UnsupportedProtocolException::ice_id() const
 {
-    return "Ice::UnsupportedProtocolException";
+    return "::Ice::UnsupportedProtocolException";
 }
 
 Ice::UnsupportedProtocolException*
@@ -1391,15 +2157,15 @@ Ice::UnsupportedProtocolException::ice_throw() const
     throw *this;
 }
 
-Ice::UnsupportedEncodingException::UnsupportedEncodingException(const char* __file, int __line) :
-    ::Ice::ProtocolException(__file, __line)
+Ice::UnsupportedEncodingException::UnsupportedEncodingException(const char* file, int line) :
+    ProtocolException(file, line)
 {
 }
 
-Ice::UnsupportedEncodingException::UnsupportedEncodingException(const char* __file, int __line, const ::std::string& __ice_reason, const ::Ice::EncodingVersion& __ice_bad, const ::Ice::EncodingVersion& __ice_supported) :
-    ::Ice::ProtocolException(__file, __line, __ice_reason),
-    bad(__ice_bad),
-    supported(__ice_supported)
+Ice::UnsupportedEncodingException::UnsupportedEncodingException(const char* file, int line, const ::std::string& reason, const EncodingVersion& bad, const EncodingVersion& supported) :
+    ProtocolException(file, line, reason),
+    bad(bad),
+    supported(supported)
 {
 }
 
@@ -1408,9 +2174,9 @@ Ice::UnsupportedEncodingException::~UnsupportedEncodingException() throw()
 }
 
 ::std::string
-Ice::UnsupportedEncodingException::ice_name() const
+Ice::UnsupportedEncodingException::ice_id() const
 {
-    return "Ice::UnsupportedEncodingException";
+    return "::Ice::UnsupportedEncodingException";
 }
 
 Ice::UnsupportedEncodingException*
@@ -1425,13 +2191,13 @@ Ice::UnsupportedEncodingException::ice_throw() const
     throw *this;
 }
 
-Ice::UnknownMessageException::UnknownMessageException(const char* __file, int __line) :
-    ::Ice::ProtocolException(__file, __line)
+Ice::UnknownMessageException::UnknownMessageException(const char* file, int line) :
+    ProtocolException(file, line)
 {
 }
 
-Ice::UnknownMessageException::UnknownMessageException(const char* __file, int __line, const ::std::string& __ice_reason) :
-    ::Ice::ProtocolException(__file, __line, __ice_reason)
+Ice::UnknownMessageException::UnknownMessageException(const char* file, int line, const ::std::string& reason) :
+    ProtocolException(file, line, reason)
 {
 }
 
@@ -1440,9 +2206,9 @@ Ice::UnknownMessageException::~UnknownMessageException() throw()
 }
 
 ::std::string
-Ice::UnknownMessageException::ice_name() const
+Ice::UnknownMessageException::ice_id() const
 {
-    return "Ice::UnknownMessageException";
+    return "::Ice::UnknownMessageException";
 }
 
 Ice::UnknownMessageException*
@@ -1457,13 +2223,13 @@ Ice::UnknownMessageException::ice_throw() const
     throw *this;
 }
 
-Ice::ConnectionNotValidatedException::ConnectionNotValidatedException(const char* __file, int __line) :
-    ::Ice::ProtocolException(__file, __line)
+Ice::ConnectionNotValidatedException::ConnectionNotValidatedException(const char* file, int line) :
+    ProtocolException(file, line)
 {
 }
 
-Ice::ConnectionNotValidatedException::ConnectionNotValidatedException(const char* __file, int __line, const ::std::string& __ice_reason) :
-    ::Ice::ProtocolException(__file, __line, __ice_reason)
+Ice::ConnectionNotValidatedException::ConnectionNotValidatedException(const char* file, int line, const ::std::string& reason) :
+    ProtocolException(file, line, reason)
 {
 }
 
@@ -1472,9 +2238,9 @@ Ice::ConnectionNotValidatedException::~ConnectionNotValidatedException() throw()
 }
 
 ::std::string
-Ice::ConnectionNotValidatedException::ice_name() const
+Ice::ConnectionNotValidatedException::ice_id() const
 {
-    return "Ice::ConnectionNotValidatedException";
+    return "::Ice::ConnectionNotValidatedException";
 }
 
 Ice::ConnectionNotValidatedException*
@@ -1489,13 +2255,13 @@ Ice::ConnectionNotValidatedException::ice_throw() const
     throw *this;
 }
 
-Ice::UnknownRequestIdException::UnknownRequestIdException(const char* __file, int __line) :
-    ::Ice::ProtocolException(__file, __line)
+Ice::UnknownRequestIdException::UnknownRequestIdException(const char* file, int line) :
+    ProtocolException(file, line)
 {
 }
 
-Ice::UnknownRequestIdException::UnknownRequestIdException(const char* __file, int __line, const ::std::string& __ice_reason) :
-    ::Ice::ProtocolException(__file, __line, __ice_reason)
+Ice::UnknownRequestIdException::UnknownRequestIdException(const char* file, int line, const ::std::string& reason) :
+    ProtocolException(file, line, reason)
 {
 }
 
@@ -1504,9 +2270,9 @@ Ice::UnknownRequestIdException::~UnknownRequestIdException() throw()
 }
 
 ::std::string
-Ice::UnknownRequestIdException::ice_name() const
+Ice::UnknownRequestIdException::ice_id() const
 {
-    return "Ice::UnknownRequestIdException";
+    return "::Ice::UnknownRequestIdException";
 }
 
 Ice::UnknownRequestIdException*
@@ -1521,13 +2287,13 @@ Ice::UnknownRequestIdException::ice_throw() const
     throw *this;
 }
 
-Ice::UnknownReplyStatusException::UnknownReplyStatusException(const char* __file, int __line) :
-    ::Ice::ProtocolException(__file, __line)
+Ice::UnknownReplyStatusException::UnknownReplyStatusException(const char* file, int line) :
+    ProtocolException(file, line)
 {
 }
 
-Ice::UnknownReplyStatusException::UnknownReplyStatusException(const char* __file, int __line, const ::std::string& __ice_reason) :
-    ::Ice::ProtocolException(__file, __line, __ice_reason)
+Ice::UnknownReplyStatusException::UnknownReplyStatusException(const char* file, int line, const ::std::string& reason) :
+    ProtocolException(file, line, reason)
 {
 }
 
@@ -1536,9 +2302,9 @@ Ice::UnknownReplyStatusException::~UnknownReplyStatusException() throw()
 }
 
 ::std::string
-Ice::UnknownReplyStatusException::ice_name() const
+Ice::UnknownReplyStatusException::ice_id() const
 {
-    return "Ice::UnknownReplyStatusException";
+    return "::Ice::UnknownReplyStatusException";
 }
 
 Ice::UnknownReplyStatusException*
@@ -1553,13 +2319,13 @@ Ice::UnknownReplyStatusException::ice_throw() const
     throw *this;
 }
 
-Ice::CloseConnectionException::CloseConnectionException(const char* __file, int __line) :
-    ::Ice::ProtocolException(__file, __line)
+Ice::CloseConnectionException::CloseConnectionException(const char* file, int line) :
+    ProtocolException(file, line)
 {
 }
 
-Ice::CloseConnectionException::CloseConnectionException(const char* __file, int __line, const ::std::string& __ice_reason) :
-    ::Ice::ProtocolException(__file, __line, __ice_reason)
+Ice::CloseConnectionException::CloseConnectionException(const char* file, int line, const ::std::string& reason) :
+    ProtocolException(file, line, reason)
 {
 }
 
@@ -1568,9 +2334,9 @@ Ice::CloseConnectionException::~CloseConnectionException() throw()
 }
 
 ::std::string
-Ice::CloseConnectionException::ice_name() const
+Ice::CloseConnectionException::ice_id() const
 {
-    return "Ice::CloseConnectionException";
+    return "::Ice::CloseConnectionException";
 }
 
 Ice::CloseConnectionException*
@@ -1585,45 +2351,46 @@ Ice::CloseConnectionException::ice_throw() const
     throw *this;
 }
 
-Ice::ForcedCloseConnectionException::ForcedCloseConnectionException(const char* __file, int __line) :
-    ::Ice::ProtocolException(__file, __line)
+Ice::ConnectionManuallyClosedException::ConnectionManuallyClosedException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
-Ice::ForcedCloseConnectionException::ForcedCloseConnectionException(const char* __file, int __line, const ::std::string& __ice_reason) :
-    ::Ice::ProtocolException(__file, __line, __ice_reason)
+Ice::ConnectionManuallyClosedException::ConnectionManuallyClosedException(const char* file, int line, bool graceful) :
+    LocalException(file, line),
+    graceful(graceful)
 {
 }
 
-Ice::ForcedCloseConnectionException::~ForcedCloseConnectionException() throw()
+Ice::ConnectionManuallyClosedException::~ConnectionManuallyClosedException() throw()
 {
 }
 
 ::std::string
-Ice::ForcedCloseConnectionException::ice_name() const
+Ice::ConnectionManuallyClosedException::ice_id() const
 {
-    return "Ice::ForcedCloseConnectionException";
+    return "::Ice::ConnectionManuallyClosedException";
 }
 
-Ice::ForcedCloseConnectionException*
-Ice::ForcedCloseConnectionException::ice_clone() const
+Ice::ConnectionManuallyClosedException*
+Ice::ConnectionManuallyClosedException::ice_clone() const
 {
-    return new ForcedCloseConnectionException(*this);
+    return new ConnectionManuallyClosedException(*this);
 }
 
 void
-Ice::ForcedCloseConnectionException::ice_throw() const
+Ice::ConnectionManuallyClosedException::ice_throw() const
 {
     throw *this;
 }
 
-Ice::IllegalMessageSizeException::IllegalMessageSizeException(const char* __file, int __line) :
-    ::Ice::ProtocolException(__file, __line)
+Ice::IllegalMessageSizeException::IllegalMessageSizeException(const char* file, int line) :
+    ProtocolException(file, line)
 {
 }
 
-Ice::IllegalMessageSizeException::IllegalMessageSizeException(const char* __file, int __line, const ::std::string& __ice_reason) :
-    ::Ice::ProtocolException(__file, __line, __ice_reason)
+Ice::IllegalMessageSizeException::IllegalMessageSizeException(const char* file, int line, const ::std::string& reason) :
+    ProtocolException(file, line, reason)
 {
 }
 
@@ -1632,9 +2399,9 @@ Ice::IllegalMessageSizeException::~IllegalMessageSizeException() throw()
 }
 
 ::std::string
-Ice::IllegalMessageSizeException::ice_name() const
+Ice::IllegalMessageSizeException::ice_id() const
 {
-    return "Ice::IllegalMessageSizeException";
+    return "::Ice::IllegalMessageSizeException";
 }
 
 Ice::IllegalMessageSizeException*
@@ -1649,13 +2416,13 @@ Ice::IllegalMessageSizeException::ice_throw() const
     throw *this;
 }
 
-Ice::CompressionException::CompressionException(const char* __file, int __line) :
-    ::Ice::ProtocolException(__file, __line)
+Ice::CompressionException::CompressionException(const char* file, int line) :
+    ProtocolException(file, line)
 {
 }
 
-Ice::CompressionException::CompressionException(const char* __file, int __line, const ::std::string& __ice_reason) :
-    ::Ice::ProtocolException(__file, __line, __ice_reason)
+Ice::CompressionException::CompressionException(const char* file, int line, const ::std::string& reason) :
+    ProtocolException(file, line, reason)
 {
 }
 
@@ -1664,9 +2431,9 @@ Ice::CompressionException::~CompressionException() throw()
 }
 
 ::std::string
-Ice::CompressionException::ice_name() const
+Ice::CompressionException::ice_id() const
 {
-    return "Ice::CompressionException";
+    return "::Ice::CompressionException";
 }
 
 Ice::CompressionException*
@@ -1681,13 +2448,13 @@ Ice::CompressionException::ice_throw() const
     throw *this;
 }
 
-Ice::DatagramLimitException::DatagramLimitException(const char* __file, int __line) :
-    ::Ice::ProtocolException(__file, __line)
+Ice::DatagramLimitException::DatagramLimitException(const char* file, int line) :
+    ProtocolException(file, line)
 {
 }
 
-Ice::DatagramLimitException::DatagramLimitException(const char* __file, int __line, const ::std::string& __ice_reason) :
-    ::Ice::ProtocolException(__file, __line, __ice_reason)
+Ice::DatagramLimitException::DatagramLimitException(const char* file, int line, const ::std::string& reason) :
+    ProtocolException(file, line, reason)
 {
 }
 
@@ -1696,9 +2463,9 @@ Ice::DatagramLimitException::~DatagramLimitException() throw()
 }
 
 ::std::string
-Ice::DatagramLimitException::ice_name() const
+Ice::DatagramLimitException::ice_id() const
 {
-    return "Ice::DatagramLimitException";
+    return "::Ice::DatagramLimitException";
 }
 
 Ice::DatagramLimitException*
@@ -1713,13 +2480,13 @@ Ice::DatagramLimitException::ice_throw() const
     throw *this;
 }
 
-Ice::MarshalException::MarshalException(const char* __file, int __line) :
-    ::Ice::ProtocolException(__file, __line)
+Ice::MarshalException::MarshalException(const char* file, int line) :
+    ProtocolException(file, line)
 {
 }
 
-Ice::MarshalException::MarshalException(const char* __file, int __line, const ::std::string& __ice_reason) :
-    ::Ice::ProtocolException(__file, __line, __ice_reason)
+Ice::MarshalException::MarshalException(const char* file, int line, const ::std::string& reason) :
+    ProtocolException(file, line, reason)
 {
 }
 
@@ -1728,9 +2495,9 @@ Ice::MarshalException::~MarshalException() throw()
 }
 
 ::std::string
-Ice::MarshalException::ice_name() const
+Ice::MarshalException::ice_id() const
 {
-    return "Ice::MarshalException";
+    return "::Ice::MarshalException";
 }
 
 Ice::MarshalException*
@@ -1745,13 +2512,13 @@ Ice::MarshalException::ice_throw() const
     throw *this;
 }
 
-Ice::ProxyUnmarshalException::ProxyUnmarshalException(const char* __file, int __line) :
-    ::Ice::MarshalException(__file, __line)
+Ice::ProxyUnmarshalException::ProxyUnmarshalException(const char* file, int line) :
+    MarshalException(file, line)
 {
 }
 
-Ice::ProxyUnmarshalException::ProxyUnmarshalException(const char* __file, int __line, const ::std::string& __ice_reason) :
-    ::Ice::MarshalException(__file, __line, __ice_reason)
+Ice::ProxyUnmarshalException::ProxyUnmarshalException(const char* file, int line, const ::std::string& reason) :
+    MarshalException(file, line, reason)
 {
 }
 
@@ -1760,9 +2527,9 @@ Ice::ProxyUnmarshalException::~ProxyUnmarshalException() throw()
 }
 
 ::std::string
-Ice::ProxyUnmarshalException::ice_name() const
+Ice::ProxyUnmarshalException::ice_id() const
 {
-    return "Ice::ProxyUnmarshalException";
+    return "::Ice::ProxyUnmarshalException";
 }
 
 Ice::ProxyUnmarshalException*
@@ -1777,13 +2544,13 @@ Ice::ProxyUnmarshalException::ice_throw() const
     throw *this;
 }
 
-Ice::UnmarshalOutOfBoundsException::UnmarshalOutOfBoundsException(const char* __file, int __line) :
-    ::Ice::MarshalException(__file, __line)
+Ice::UnmarshalOutOfBoundsException::UnmarshalOutOfBoundsException(const char* file, int line) :
+    MarshalException(file, line)
 {
 }
 
-Ice::UnmarshalOutOfBoundsException::UnmarshalOutOfBoundsException(const char* __file, int __line, const ::std::string& __ice_reason) :
-    ::Ice::MarshalException(__file, __line, __ice_reason)
+Ice::UnmarshalOutOfBoundsException::UnmarshalOutOfBoundsException(const char* file, int line, const ::std::string& reason) :
+    MarshalException(file, line, reason)
 {
 }
 
@@ -1792,9 +2559,9 @@ Ice::UnmarshalOutOfBoundsException::~UnmarshalOutOfBoundsException() throw()
 }
 
 ::std::string
-Ice::UnmarshalOutOfBoundsException::ice_name() const
+Ice::UnmarshalOutOfBoundsException::ice_id() const
 {
-    return "Ice::UnmarshalOutOfBoundsException";
+    return "::Ice::UnmarshalOutOfBoundsException";
 }
 
 Ice::UnmarshalOutOfBoundsException*
@@ -1809,48 +2576,48 @@ Ice::UnmarshalOutOfBoundsException::ice_throw() const
     throw *this;
 }
 
-Ice::NoObjectFactoryException::NoObjectFactoryException(const char* __file, int __line) :
-    ::Ice::MarshalException(__file, __line)
+Ice::NoValueFactoryException::NoValueFactoryException(const char* file, int line) :
+    MarshalException(file, line)
 {
 }
 
-Ice::NoObjectFactoryException::NoObjectFactoryException(const char* __file, int __line, const ::std::string& __ice_reason, const ::std::string& __ice_type) :
-    ::Ice::MarshalException(__file, __line, __ice_reason),
-    type(__ice_type)
+Ice::NoValueFactoryException::NoValueFactoryException(const char* file, int line, const ::std::string& reason, const ::std::string& type) :
+    MarshalException(file, line, reason),
+    type(type)
 {
 }
 
-Ice::NoObjectFactoryException::~NoObjectFactoryException() throw()
+Ice::NoValueFactoryException::~NoValueFactoryException() throw()
 {
 }
 
 ::std::string
-Ice::NoObjectFactoryException::ice_name() const
+Ice::NoValueFactoryException::ice_id() const
 {
-    return "Ice::NoObjectFactoryException";
+    return "::Ice::NoValueFactoryException";
 }
 
-Ice::NoObjectFactoryException*
-Ice::NoObjectFactoryException::ice_clone() const
+Ice::NoValueFactoryException*
+Ice::NoValueFactoryException::ice_clone() const
 {
-    return new NoObjectFactoryException(*this);
+    return new NoValueFactoryException(*this);
 }
 
 void
-Ice::NoObjectFactoryException::ice_throw() const
+Ice::NoValueFactoryException::ice_throw() const
 {
     throw *this;
 }
 
-Ice::UnexpectedObjectException::UnexpectedObjectException(const char* __file, int __line) :
-    ::Ice::MarshalException(__file, __line)
+Ice::UnexpectedObjectException::UnexpectedObjectException(const char* file, int line) :
+    MarshalException(file, line)
 {
 }
 
-Ice::UnexpectedObjectException::UnexpectedObjectException(const char* __file, int __line, const ::std::string& __ice_reason, const ::std::string& __ice_type, const ::std::string& __ice_expectedType) :
-    ::Ice::MarshalException(__file, __line, __ice_reason),
-    type(__ice_type),
-    expectedType(__ice_expectedType)
+Ice::UnexpectedObjectException::UnexpectedObjectException(const char* file, int line, const ::std::string& reason, const ::std::string& type, const ::std::string& expectedType) :
+    MarshalException(file, line, reason),
+    type(type),
+    expectedType(expectedType)
 {
 }
 
@@ -1859,9 +2626,9 @@ Ice::UnexpectedObjectException::~UnexpectedObjectException() throw()
 }
 
 ::std::string
-Ice::UnexpectedObjectException::ice_name() const
+Ice::UnexpectedObjectException::ice_id() const
 {
-    return "Ice::UnexpectedObjectException";
+    return "::Ice::UnexpectedObjectException";
 }
 
 Ice::UnexpectedObjectException*
@@ -1876,13 +2643,13 @@ Ice::UnexpectedObjectException::ice_throw() const
     throw *this;
 }
 
-Ice::MemoryLimitException::MemoryLimitException(const char* __file, int __line) :
-    ::Ice::MarshalException(__file, __line)
+Ice::MemoryLimitException::MemoryLimitException(const char* file, int line) :
+    MarshalException(file, line)
 {
 }
 
-Ice::MemoryLimitException::MemoryLimitException(const char* __file, int __line, const ::std::string& __ice_reason) :
-    ::Ice::MarshalException(__file, __line, __ice_reason)
+Ice::MemoryLimitException::MemoryLimitException(const char* file, int line, const ::std::string& reason) :
+    MarshalException(file, line, reason)
 {
 }
 
@@ -1891,9 +2658,9 @@ Ice::MemoryLimitException::~MemoryLimitException() throw()
 }
 
 ::std::string
-Ice::MemoryLimitException::ice_name() const
+Ice::MemoryLimitException::ice_id() const
 {
-    return "Ice::MemoryLimitException";
+    return "::Ice::MemoryLimitException";
 }
 
 Ice::MemoryLimitException*
@@ -1908,13 +2675,13 @@ Ice::MemoryLimitException::ice_throw() const
     throw *this;
 }
 
-Ice::StringConversionException::StringConversionException(const char* __file, int __line) :
-    ::Ice::MarshalException(__file, __line)
+Ice::StringConversionException::StringConversionException(const char* file, int line) :
+    MarshalException(file, line)
 {
 }
 
-Ice::StringConversionException::StringConversionException(const char* __file, int __line, const ::std::string& __ice_reason) :
-    ::Ice::MarshalException(__file, __line, __ice_reason)
+Ice::StringConversionException::StringConversionException(const char* file, int line, const ::std::string& reason) :
+    MarshalException(file, line, reason)
 {
 }
 
@@ -1923,9 +2690,9 @@ Ice::StringConversionException::~StringConversionException() throw()
 }
 
 ::std::string
-Ice::StringConversionException::ice_name() const
+Ice::StringConversionException::ice_id() const
 {
-    return "Ice::StringConversionException";
+    return "::Ice::StringConversionException";
 }
 
 Ice::StringConversionException*
@@ -1940,13 +2707,13 @@ Ice::StringConversionException::ice_throw() const
     throw *this;
 }
 
-Ice::EncapsulationException::EncapsulationException(const char* __file, int __line) :
-    ::Ice::MarshalException(__file, __line)
+Ice::EncapsulationException::EncapsulationException(const char* file, int line) :
+    MarshalException(file, line)
 {
 }
 
-Ice::EncapsulationException::EncapsulationException(const char* __file, int __line, const ::std::string& __ice_reason) :
-    ::Ice::MarshalException(__file, __line, __ice_reason)
+Ice::EncapsulationException::EncapsulationException(const char* file, int line, const ::std::string& reason) :
+    MarshalException(file, line, reason)
 {
 }
 
@@ -1955,9 +2722,9 @@ Ice::EncapsulationException::~EncapsulationException() throw()
 }
 
 ::std::string
-Ice::EncapsulationException::ice_name() const
+Ice::EncapsulationException::ice_id() const
 {
-    return "Ice::EncapsulationException";
+    return "::Ice::EncapsulationException";
 }
 
 Ice::EncapsulationException*
@@ -1972,14 +2739,14 @@ Ice::EncapsulationException::ice_throw() const
     throw *this;
 }
 
-Ice::FeatureNotSupportedException::FeatureNotSupportedException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::FeatureNotSupportedException::FeatureNotSupportedException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
-Ice::FeatureNotSupportedException::FeatureNotSupportedException(const char* __file, int __line, const ::std::string& __ice_unsupportedFeature) :
-    ::Ice::LocalException(__file, __line),
-    unsupportedFeature(__ice_unsupportedFeature)
+Ice::FeatureNotSupportedException::FeatureNotSupportedException(const char* file, int line, const ::std::string& unsupportedFeature) :
+    LocalException(file, line),
+    unsupportedFeature(unsupportedFeature)
 {
 }
 
@@ -1988,9 +2755,9 @@ Ice::FeatureNotSupportedException::~FeatureNotSupportedException() throw()
 }
 
 ::std::string
-Ice::FeatureNotSupportedException::ice_name() const
+Ice::FeatureNotSupportedException::ice_id() const
 {
-    return "Ice::FeatureNotSupportedException";
+    return "::Ice::FeatureNotSupportedException";
 }
 
 Ice::FeatureNotSupportedException*
@@ -2005,14 +2772,14 @@ Ice::FeatureNotSupportedException::ice_throw() const
     throw *this;
 }
 
-Ice::SecurityException::SecurityException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::SecurityException::SecurityException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
-Ice::SecurityException::SecurityException(const char* __file, int __line, const ::std::string& __ice_reason) :
-    ::Ice::LocalException(__file, __line),
-    reason(__ice_reason)
+Ice::SecurityException::SecurityException(const char* file, int line, const ::std::string& reason) :
+    LocalException(file, line),
+    reason(reason)
 {
 }
 
@@ -2021,9 +2788,9 @@ Ice::SecurityException::~SecurityException() throw()
 }
 
 ::std::string
-Ice::SecurityException::ice_name() const
+Ice::SecurityException::ice_id() const
 {
-    return "Ice::SecurityException";
+    return "::Ice::SecurityException";
 }
 
 Ice::SecurityException*
@@ -2038,8 +2805,8 @@ Ice::SecurityException::ice_throw() const
     throw *this;
 }
 
-Ice::FixedProxyException::FixedProxyException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::FixedProxyException::FixedProxyException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
@@ -2048,9 +2815,9 @@ Ice::FixedProxyException::~FixedProxyException() throw()
 }
 
 ::std::string
-Ice::FixedProxyException::ice_name() const
+Ice::FixedProxyException::ice_id() const
 {
-    return "Ice::FixedProxyException";
+    return "::Ice::FixedProxyException";
 }
 
 Ice::FixedProxyException*
@@ -2065,8 +2832,8 @@ Ice::FixedProxyException::ice_throw() const
     throw *this;
 }
 
-Ice::ResponseSentException::ResponseSentException(const char* __file, int __line) :
-    ::Ice::LocalException(__file, __line)
+Ice::ResponseSentException::ResponseSentException(const char* file, int line) :
+    LocalException(file, line)
 {
 }
 
@@ -2075,9 +2842,9 @@ Ice::ResponseSentException::~ResponseSentException() throw()
 }
 
 ::std::string
-Ice::ResponseSentException::ice_name() const
+Ice::ResponseSentException::ice_id() const
 {
-    return "Ice::ResponseSentException";
+    return "::Ice::ResponseSentException";
 }
 
 Ice::ResponseSentException*
@@ -2095,3 +2862,5 @@ Ice::ResponseSentException::ice_throw() const
 namespace Ice
 {
 }
+
+#endif