ICE-7707 Improved handling of argc/argv arguments

Added configFile overload to Ice::initialize and CommunicatorHolder in C++

20 files changed, 364 insertions, 251 deletions

diff --git a/cpp/include/Glacier2/Application.h b/cpp/include/Glacier2/Application.h
index 96c06e6c07b..7d2f57b8dc5 100644
--- a/cpp/include/Glacier2/Application.h
+++ b/cpp/include/Glacier2/Application.h
@@ -194,11 +194,11 @@ public:
 
 protected:
 
-    virtual int doMain(int, char*[], const Ice::InitializationData& initData);
+    virtual int doMain(int, char*[], const Ice::InitializationData& initData, int);
 
 private:
 
-    bool doMain(Ice::StringSeq&, const Ice::InitializationData&, int&);
+    bool doMain(Ice::StringSeq&, const Ice::InitializationData&, int&, int);
 
     /**
      * Run should not be overridden for Glacier2.Application. Instead
diff --git a/cpp/include/Ice/Application.h b/cpp/include/Ice/Application.h
index 379542896d3..0df20b71a25 100644
--- a/cpp/include/Ice/Application.h
+++ b/cpp/include/Ice/Application.h
@@ -31,30 +31,29 @@ public:
     Application(SignalPolicy = ICE_ENUM(SignalPolicy, HandleSignals));
     virtual ~Application();
 
-    //
     // This main() must be called by the global main(). main()
-    // initializes the Communicator, calls run() as a template method,
-    // and destroys the Communicator upon return from run(). It
-    // thereby handles all exceptions properly, i.e., error messages
-    // are printed if exceptions propagate to main(), and the
-    // Communicator is always destroyed, regardless of exceptions.
+    // initializes the Communicator, calls run() and destroys the
+    // the Communicator upon return from run(). It handles all
+    // exceptions properly, i.e., error message are printed if
+    // exceptions propagate to main(), and the Communicator is always
+    // destroyed, regardless of exceptions.
     //
-    int main(int, char*[], const Ice::InitializationData& = Ice::InitializationData());
-    int main(int, char*[], const char*);
-
-    int main(int, char* const [], const Ice::InitializationData& = Ice::InitializationData());
-    int main(int, char* const [], const char*);
+    int main(int, const char* const[], const InitializationData& = InitializationData(), int = ICE_INT_VERSION);
+    int main(int, const char* const[], ICE_CONFIG_FILE_STRING, int = ICE_INT_VERSION);
 
-#ifdef _WIN32
+#   ifdef _WIN32
+    int main(int, const wchar_t* const[], const InitializationData& = InitializationData(), int = ICE_INT_VERSION);
+    int main(int, const wchar_t* const[], ICE_CONFIG_FILE_STRING, int = ICE_INT_VERSION);
+#   endif
 
-    int main(int, wchar_t*[], const Ice::InitializationData& = Ice::InitializationData());
-    int main(int, wchar_t*[], const char*);
-
-#endif
-
-    int main(const StringSeq&, const Ice::InitializationData& = Ice::InitializationData());
-    int main(const StringSeq&, const char*);
+    int main(const StringSeq&, const InitializationData& = InitializationData(), int = ICE_INT_VERSION);
+    int main(const StringSeq&, ICE_CONFIG_FILE_STRING, int = ICE_INT_VERSION);
 
+    //
+    // run is given a copy of the remaining argc/argv arguments,
+    // after the communicator initialization in the caller (main)
+    // has removed all Ice-related arguments.
+    //
     virtual int run(int, char*[]) = 0;
 
     //
@@ -114,7 +113,7 @@ public:
 
 protected:
 
-    virtual int doMain(int, char*[], const Ice::InitializationData&);
+    virtual int doMain(int, char*[], const InitializationData&, Int);
 
     //
     // _mutex and _condVar are used to synchronize the main thread and
@@ -124,21 +123,23 @@ protected:
     static IceUtil::Cond _condVar;
 
     //
-    // Variables than can change while run() and communicator->destroy() are running!
+    // Variables than can change while run() and communicator->destroy()
+    //  are running!
     //
     static bool _callbackInProgress;
     static bool _destroyed;
     static bool _interrupted;
 
     //
-    // Variables that are immutable during run() and until communicator->destroy() has returned;
-    // before and after run(), and once communicator->destroy() has returned, we assume that
+    // Variables that are immutable during run() and until
+    // communicator->destroy() has returned, before and after run(), and
+    // once communicator->destroy() has returned, we assume that
     // only the main thread and CtrlCHandler threads are running.
     //
     static std::string _appName;
-    static Ice::CommunicatorPtr _communicator;
-    static Ice::SignalPolicy _signalPolicy;
-    static Ice::Application* _application;
+    static CommunicatorPtr _communicator;
+    static SignalPolicy _signalPolicy;
+    static Application* _application;
 
 private:
 
diff --git a/cpp/include/Ice/Initialize.h b/cpp/include/Ice/Initialize.h
index 43eb9d28dd1..6d1ff3b7bed 100644
--- a/cpp/include/Ice/Initialize.h
+++ b/cpp/include/Ice/Initialize.h
@@ -23,15 +23,19 @@
 #include <Ice/Plugin.h>
 #include <Ice/BatchRequestInterceptor.h>
 
+#ifdef ICE_CPP11_MAPPING
+#   define ICE_CONFIG_FILE_STRING const std::string&
+#else
+#   define ICE_CONFIG_FILE_STRING const char*
+#endif
+
 namespace Ice
 {
 
-ICE_API StringSeq argsToStringSeq(int, char*[]);
+ICE_API StringSeq argsToStringSeq(int, const char* const[]);
 
 #ifdef _WIN32
-
-ICE_API StringSeq argsToStringSeq(int, wchar_t*[]);
-
+ICE_API StringSeq argsToStringSeq(int, const wchar_t* const[]);
 #endif
 
 //
@@ -40,22 +44,34 @@ ICE_API StringSeq argsToStringSeq(int, wchar_t*[]);
 // the argument vector elements so that the vector matches the
 // contents of the sequence.
 //
-ICE_API void stringSeqToArgs(const StringSeq&, int&, char*[]);
+ICE_API void stringSeqToArgs(const StringSeq&, int&, const char*[]);
+inline void stringSeqToArgs(const StringSeq& seq, int& argc, char* argv[])
+{
+    return stringSeqToArgs(seq, argc, const_cast<const char**>(argv));
+}
 
 #ifdef _WIN32
-
-ICE_API void stringSeqToArgs(const StringSeq&, int&, wchar_t*[]);
-
+ICE_API void stringSeqToArgs(const StringSeq&, int&, const wchar_t*[]);
+inline void stringSeqToArgs(const StringSeq& seq, int& argc, wchar_t* argv[])
+{
+    return stringSeqToArgs(seq, argc, const_cast<const wchar_t**>(argv));
+}
 #endif
 
 ICE_API PropertiesPtr createProperties();
 ICE_API PropertiesPtr createProperties(StringSeq&, const PropertiesPtr& = 0);
-ICE_API PropertiesPtr createProperties(int&, char*[], const PropertiesPtr& = 0);
+ICE_API PropertiesPtr createProperties(int&, const char*[], const PropertiesPtr& = 0);
+inline PropertiesPtr createProperties(int& argc, char* argv[], const PropertiesPtr& props = 0)
+{
+    return createProperties(argc, const_cast<const char**>(argv), props);
+}
 
 #ifdef _WIN32
-
-ICE_API PropertiesPtr createProperties(int&, wchar_t*[], const PropertiesPtr& = 0);
-
+ICE_API PropertiesPtr createProperties(int&, const wchar_t*[], const PropertiesPtr& = 0);
+inline PropertiesPtr createProperties(int& argc, wchar_t* argv[], const PropertiesPtr& props = 0)
+{
+    return createProperties(argc, const_cast<const wchar_t**>(argv), props);
+}
 #endif
 
 //
@@ -113,19 +129,49 @@ struct InitializationData
     ValueFactoryManagerPtr valueFactoryManager;
 };
 
-ICE_API CommunicatorPtr initialize(int&, char*[], const InitializationData& = InitializationData(),
-                                   Int = ICE_INT_VERSION);
+ICE_API CommunicatorPtr initialize(int&, const char*[], const InitializationData& = InitializationData(),
+                                   int = ICE_INT_VERSION);
+inline CommunicatorPtr initialize(int& argc, char* argv[], const InitializationData& initData = InitializationData(),
+                                   int version = ICE_INT_VERSION)
+{
+    return initialize(argc, const_cast<const char**>(argv), initData, version);
+}
+
+
+ICE_API CommunicatorPtr initialize(int&, const char*[], ICE_CONFIG_FILE_STRING, int = ICE_INT_VERSION);
+inline CommunicatorPtr initialize(int& argc, char* argv[], ICE_CONFIG_FILE_STRING configFile,
+                                  int version = ICE_INT_VERSION)
+{
+    return initialize(argc, const_cast<const char**>(argv), configFile, version);
+}
 
 #ifdef _WIN32
-ICE_API CommunicatorPtr initialize(int&, wchar_t*[], const InitializationData& = InitializationData(),
-                                   Int = ICE_INT_VERSION);
+ICE_API CommunicatorPtr initialize(int&, const wchar_t*[], const InitializationData& = InitializationData(),
+                                   int = ICE_INT_VERSION);
+inline CommunicatorPtr initialize(int& argc, wchar_t* argv[], const InitializationData& initData = InitializationData(),
+                                   int version = ICE_INT_VERSION)
+{
+    return initialize(argc, const_cast<const wchar_t**>(argv), initData, version);
+}
+
+ICE_API CommunicatorPtr initialize(int&, const wchar_t*[], ICE_CONFIG_FILE_STRING, int = ICE_INT_VERSION);
+inline CommunicatorPtr initialize(int& argc, wchar_t* argv[], ICE_CONFIG_FILE_STRING configFile,
+                                  int version = ICE_INT_VERSION)
+{
+    return initialize(argc, const_cast<const wchar_t**>(argv), configFile, version);
+}
 #endif
 
-ICE_API CommunicatorPtr initialize(Ice::StringSeq&, const InitializationData& = InitializationData(),
-                                   Int = ICE_INT_VERSION);
+ICE_API CommunicatorPtr initialize(StringSeq&, const InitializationData& = InitializationData(),
+                                   int = ICE_INT_VERSION);
+
+ICE_API CommunicatorPtr initialize(StringSeq&, ICE_CONFIG_FILE_STRING, int = ICE_INT_VERSION);
 
 ICE_API CommunicatorPtr initialize(const InitializationData& = InitializationData(),
-                                   Int = ICE_INT_VERSION);
+                                   int = ICE_INT_VERSION);
+
+ICE_API CommunicatorPtr initialize(ICE_CONFIG_FILE_STRING, int = ICE_INT_VERSION);
+
 
 ICE_API LoggerPtr getProcessLogger();
 ICE_API void setProcessLogger(const LoggerPtr&);
@@ -161,24 +207,28 @@ public:
     CommunicatorHolder(CommunicatorHolder&&) = default;
     CommunicatorHolder& operator=(CommunicatorHolder&&) = default;
 
-#else
+#else // C++98 mapping
 
     //
     // Call initialize to create communicator with the provided args
     //
-
-    CommunicatorHolder(int&, char*[], const InitializationData& = InitializationData(),
-                       Int = ICE_INT_VERSION);
+    CommunicatorHolder(int&, const char*[], const InitializationData&, int);
+    CommunicatorHolder(int&, char*[], const InitializationData& = InitializationData(), int = ICE_INT_VERSION);
+    CommunicatorHolder(int&, const char*[], const char* configFile, int = ICE_INT_VERSION);
+    CommunicatorHolder(int&, char*[], const char* configFile, int = ICE_INT_VERSION);
 
 #ifdef _WIN32
-    CommunicatorHolder(int&, wchar_t*[], const InitializationData& = InitializationData(),
-                       Int = ICE_INT_VERSION);
+    CommunicatorHolder(int&, const wchar_t*[], const InitializationData& = InitializationData(), int = ICE_INT_VERSION);
+    CommunicatorHolder(int&, wchar_t*[], const InitializationData& = InitializationData(), int = ICE_INT_VERSION);
+    CommunicatorHolder(int&, const wchar_t*[], const char* configFile, int = ICE_INT_VERSION);
+    CommunicatorHolder(int&, wchar_t*[], const char* configFile, int = ICE_INT_VERSION);
 #endif
 
-    CommunicatorHolder(Ice::StringSeq&, const InitializationData& = InitializationData(),
-                       Int = ICE_INT_VERSION);
+    CommunicatorHolder(StringSeq& args, const InitializationData& = InitializationData(),int = ICE_INT_VERSION);
+    CommunicatorHolder(StringSeq& args, const char* configFile, int = ICE_INT_VERSION);
 
-    CommunicatorHolder(const InitializationData& = InitializationData(), Int = ICE_INT_VERSION);
+    CommunicatorHolder(const InitializationData& = InitializationData(), int = ICE_INT_VERSION);
+    CommunicatorHolder(const char* configFile, int = ICE_INT_VERSION);
 
     //
     // Adopt communicator
diff --git a/cpp/include/Ice/Service.h b/cpp/include/Ice/Service.h
index 8c0b786cda9..c1c3cd02b5a 100644
--- a/cpp/include/Ice/Service.h
+++ b/cpp/include/Ice/Service.h
@@ -60,16 +60,13 @@ public:
     // The return value is an exit status code: EXIT_FAILURE or
     // EXIT_SUCCESS.
     //
-    int main(int&, char*[], const InitializationData& = InitializationData());
-    int main(int, char* const [], const Ice::InitializationData& = Ice::InitializationData());
+    int main(int, const char* const[], const InitializationData& = InitializationData(), int = ICE_INT_VERSION);
 
 #ifdef _WIN32
-
-    int main(int&, wchar_t*[], const InitializationData& = InitializationData());
-
+    int main(int, const wchar_t* const[], const InitializationData& = InitializationData(), int = ICE_INT_VERSION);
 #endif
 
-    int main(StringSeq&, const InitializationData& = InitializationData());
+    int main(const StringSeq&, const InitializationData& = InitializationData(), int = ICE_INT_VERSION);
 
     //
     // Returns the communicator created by the service.
@@ -112,12 +109,10 @@ public:
     // EXIT_SUCCESS.
     //
 #ifdef _WIN32
-    
-    int run(int&, wchar_t*[], const InitializationData& = InitializationData());
-    
+    int run(int, const wchar_t* const[], const InitializationData& = InitializationData(), int = ICE_INT_VERSION);
 #endif
 
-    int run(int&, char*[], const InitializationData& = InitializationData());
+    int run(int, const char* const[], const InitializationData& = InitializationData(), int = ICE_INT_VERSION);
 
 #ifdef _WIN32
 
@@ -171,7 +166,7 @@ protected:
     //
     // Initialize a communicator.
     //
-    virtual Ice::CommunicatorPtr initializeCommunicator(int&, char*[], const InitializationData&);
+    virtual Ice::CommunicatorPtr initializeCommunicator(int&, char*[], const InitializationData&, int);
 
     //
     // Log a system error, which includes a description of the
@@ -225,12 +220,12 @@ private:
     bool _nohup;
     bool _service;
     std::string _name;
-  
+
     static Service* _instance;
 
 #ifdef _WIN32
 
-    int runService(int, char*[], const InitializationData&);
+    int runService(int, const char* const[], const InitializationData&);
     void terminateService(DWORD);
     bool waitForServiceState(SC_HANDLE, DWORD, SERVICE_STATUS&);
     void showServiceStatus(const std::string&, SERVICE_STATUS&);
@@ -241,12 +236,12 @@ private:
 
 public:
 
-    void serviceMain(int, wchar_t*[]);
+    void serviceMain(int, const wchar_t* const[]);
     void control(int);
 
 #else
 
-    int runDaemon(int, char*[], const InitializationData&);
+    int runDaemon(int, char*[], const InitializationData&, int);
 
     bool _changeDirectory;
     bool _closeFiles;
diff --git a/cpp/src/Glacier2/Glacier2Router.cpp b/cpp/src/Glacier2/Glacier2Router.cpp
index 0fe52c41d86..ee0d93a91ce 100644
--- a/cpp/src/Glacier2/Glacier2Router.cpp
+++ b/cpp/src/Glacier2/Glacier2Router.cpp
@@ -36,7 +36,7 @@ protected:
 
     virtual bool start(int, char*[], int&);
     virtual bool stop();
-    virtual CommunicatorPtr initializeCommunicator(int&, char*[], const InitializationData&);
+    virtual CommunicatorPtr initializeCommunicator(int&, char*[], const InitializationData&, int);
 
 private:
 
@@ -50,11 +50,11 @@ private:
 class FinderI : public Ice::RouterFinder
 {
 public:
-    
+
     FinderI(const Glacier2::RouterPrx& router) : _router(router)
     {
     }
-    
+
     virtual Ice::RouterPrx
     getRouter(const Ice::Current&)
     {
@@ -154,20 +154,20 @@ RouterService::start(int argc, char* argv[], int& status)
     }
 
     string instanceName = communicator()->getProperties()->getPropertyWithDefault("Glacier2.InstanceName", "Glacier2");
-    
+
     vector<string> verifierProperties;
     verifierProperties.push_back("Glacier2.PermissionsVerifier");
     verifierProperties.push_back("Glacier2.SSLPermissionsVerifier");
-                           
+
     Glacier2Internal::setupNullPermissionsVerifier(communicator(), instanceName, verifierProperties);
-                                                   
+
     string verifierProperty = verifierProperties[0];
     PermissionsVerifierPrx verifier;
     ObjectPrx obj;
     try
     {
         //
-        // We use propertyToProxy instead of stringToProxy because the property 
+        // We use propertyToProxy instead of stringToProxy because the property
         // can provide proxy attributes
         //
         obj = communicator()->propertyToProxy(verifierProperty);
@@ -175,7 +175,7 @@ RouterService::start(int argc, char* argv[], int& status)
     catch(const std::exception& ex)
     {
         ServiceError err(this);
-        err << "permissions verifier `" << communicator()->getProperties()->getProperty(verifierProperty) 
+        err << "permissions verifier `" << communicator()->getProperties()->getProperty(verifierProperty)
             << "' is invalid:\n" << ex;
         return false;
     }
@@ -188,7 +188,7 @@ RouterService::start(int argc, char* argv[], int& status)
             if(!verifier)
             {
                 ServiceError err(this);
-                err << "permissions verifier `" << communicator()->getProperties()->getProperty(verifierProperty) 
+                err << "permissions verifier `" << communicator()->getProperties()->getProperty(verifierProperty)
                     << "' is invalid";
                 return false;
             }
@@ -198,13 +198,13 @@ RouterService::start(int argc, char* argv[], int& status)
             if(!nowarn)
             {
                 ServiceWarning warn(this);
-                warn << "unable to contact permissions verifier `" 
+                warn << "unable to contact permissions verifier `"
                      << communicator()->getProperties()->getProperty(verifierProperty) << "'\n" << ex;
             }
             verifier = PermissionsVerifierPrx::uncheckedCast(obj);
         }
     }
-    
+
     //
     // Get the session manager if specified.
     //
@@ -241,7 +241,7 @@ RouterService::start(int argc, char* argv[], int& status)
             }
             sessionManager = SessionManagerPrx::uncheckedCast(obj);
         }
-        sessionManager = 
+        sessionManager =
             SessionManagerPrx::uncheckedCast(sessionManager->ice_connectionCached(false)->ice_locatorCacheTimeout(
                 properties->getPropertyAsIntWithDefault("Glacier2.SessionManager.LocatorCacheTimeout", 600)));
     }
@@ -251,15 +251,15 @@ RouterService::start(int argc, char* argv[], int& status)
     //
     string sslVerifierProperty = verifierProperties[1];
     SSLPermissionsVerifierPrx sslVerifier;
-  
+
     try
-    {  
+    {
         obj = communicator()->propertyToProxy(sslVerifierProperty);
     }
     catch(const std::exception& ex)
     {
         ServiceError err(this);
-        err << "ssl permissions verifier `" << communicator()->getProperties()->getProperty(sslVerifierProperty) 
+        err << "ssl permissions verifier `" << communicator()->getProperties()->getProperty(sslVerifierProperty)
             << "' is invalid:\n" << ex;
         return false;
     }
@@ -273,7 +273,7 @@ RouterService::start(int argc, char* argv[], int& status)
             {
                 ServiceError err(this);
                 err << "ssl permissions verifier `"
-                    << communicator()->getProperties()->getProperty(sslVerifierProperty) 
+                    << communicator()->getProperties()->getProperty(sslVerifierProperty)
                     << "' is invalid";
             }
         }
@@ -282,7 +282,7 @@ RouterService::start(int argc, char* argv[], int& status)
             if(!nowarn)
             {
                 ServiceWarning warn(this);
-                warn << "unable to contact ssl permissions verifier `" 
+                warn << "unable to contact ssl permissions verifier `"
                      <<  communicator()->getProperties()->getProperty(sslVerifierProperty) << "'\n"
                      << ex;
             }
@@ -322,12 +322,12 @@ RouterService::start(int argc, char* argv[], int& status)
             if(!nowarn)
             {
                 ServiceWarning warn(this);
-                warn << "unable to contact ssl session manager `" << sslSessionManagerPropertyValue 
+                warn << "unable to contact ssl session manager `" << sslSessionManagerPropertyValue
                      << "'\n" << ex;
             }
             sslSessionManager = SSLSessionManagerPrx::uncheckedCast(obj);
         }
-        sslSessionManager = 
+        sslSessionManager =
             SSLSessionManagerPrx::uncheckedCast(sslSessionManager->ice_connectionCached(false)->ice_locatorCacheTimeout(
                 properties->getPropertyAsIntWithDefault("Glacier2.SSLSessionManager.LocatorCacheTimeout", 600)));
     }
@@ -428,8 +428,9 @@ RouterService::stop()
 }
 
 CommunicatorPtr
-RouterService::initializeCommunicator(int& argc, char* argv[], 
-                                      const InitializationData& initializationData)
+RouterService::initializeCommunicator(int& argc, char* argv[],
+                                      const InitializationData& initializationData,
+                                      int version)
 {
     InitializationData initData = initializationData;
     initData.properties = createProperties(argc, argv, initializationData.properties);
@@ -438,21 +439,21 @@ RouterService::initializeCommunicator(int& argc, char* argv[],
     // Make sure that Glacier2 doesn't use a router.
     //
     initData.properties->setProperty("Ice.Default.Router", "");
-    
+
     //
-    // If Glacier2.PermissionsVerifier is not set and Glacier2.CryptPasswords is set, 
+    // If Glacier2.PermissionsVerifier is not set and Glacier2.CryptPasswords is set,
     // load the Glacier2CryptPermissionsVerifier plug-in
     //
     string verifier = "Glacier2.PermissionsVerifier";
     if(initData.properties->getProperty(verifier).empty())
     {
         string cryptPasswords = initData.properties->getProperty("Glacier2.CryptPasswords");
-            
+
         if(!cryptPasswords.empty())
         {
             initData.properties->setProperty("Ice.Plugin.Glacier2CryptPermissionsVerifier",
                                              "Glacier2CryptPermissionsVerifier:createCryptPermissionsVerifier");
-            
+
             initData.properties->setProperty("Glacier2CryptPermissionsVerifier.Glacier2.PermissionsVerifier",
                                              cryptPasswords);
         }
@@ -474,8 +475,8 @@ RouterService::initializeCommunicator(int& argc, char* argv[],
     // for incoming connections from clients must be disabled in
     // the clients.
     //
-   
-    return Service::initializeCommunicator(argc, argv, initData);
+
+    return Service::initializeCommunicator(argc, argv, initData, version);
 }
 
 void
diff --git a/cpp/src/Glacier2Lib/Application.cpp b/cpp/src/Glacier2Lib/Application.cpp
index 7715afc2cab..ec67be9fa63 100644
--- a/cpp/src/Glacier2Lib/Application.cpp
+++ b/cpp/src/Glacier2Lib/Application.cpp
@@ -104,7 +104,7 @@ Glacier2::Application::categoryForClient()
 }
 
 int
-Glacier2::Application::doMain(int argc, char* argv[], const Ice::InitializationData& initData)
+Glacier2::Application::doMain(int argc, char* argv[], const Ice::InitializationData& initData, int version)
 {
     // Set the default properties for all Glacier2 applications.
     initData.properties->setProperty("Ice.RetryIntervals", "-1");
@@ -122,14 +122,14 @@ Glacier2::Application::doMain(int argc, char* argv[], const Ice::InitializationD
         id.properties = id.properties->clone();
         Ice::StringSeq args = Ice::argsToStringSeq(argc, argv);
 
-        restart = doMain(args, id, ret);
+        restart = doMain(args, id, ret, version);
     }
     while(restart);
     return ret;
 }
 
 bool
-Glacier2::Application::doMain(Ice::StringSeq& args, const Ice::InitializationData& initData, int& status)
+Glacier2::Application::doMain(Ice::StringSeq& args, const Ice::InitializationData& initData, int& status, int version)
 {
     //
     // Reset internal state variables from Ice.Application. The
@@ -144,7 +144,7 @@ Glacier2::Application::doMain(Ice::StringSeq& args, const Ice::InitializationDat
 
     try
     {
-        _communicator = Ice::initialize(args, initData);
+        _communicator = Ice::initialize(args, initData, version);
         _router = ICE_UNCHECKED_CAST(Glacier2::RouterPrx, communicator()->getDefaultRouter());
 
         if(!_router)
diff --git a/cpp/src/Ice/Application.cpp b/cpp/src/Ice/Application.cpp
index 1097e6ab91c..ea9b3588d67 100644
--- a/cpp/src/Ice/Application.cpp
+++ b/cpp/src/Ice/Application.cpp
@@ -68,12 +68,8 @@ Ice::Application::~Application()
 }
 
 int
-Ice::Application::main(int argc, char* argv[], const char* configFile)
+Ice::Application::main(int argc, const char* const argv[], ICE_CONFIG_FILE_STRING configFile, int version)
 {
-    //
-    // We don't call the main below to avoid a deprecated warning
-    //
-
     _appName = "";
     if(argc > 0)
     {
@@ -86,7 +82,9 @@ Ice::Application::main(int argc, char* argv[], const char* configFile)
     }
 
     InitializationData initData;
+#ifndef ICE_CPP11_MAPPING
     if(configFile)
+#endif
     {
         try
         {
@@ -106,31 +104,29 @@ Ice::Application::main(int argc, char* argv[], const char* configFile)
             return EXIT_FAILURE;
         }
     }
-    return main(argc, argv, initData);
+    return main(argc, argv, initData, version);
 }
 
 #ifdef _WIN32
-
-int
-Ice::Application::main(int argc, wchar_t* argv[], const char* config)
-{
-    return main(argsToStringSeq(argc, argv), config);
-}
-
 int
-Ice::Application::main(int argc, wchar_t* argv[], const Ice::InitializationData& initData)
+Ice::Application::main(int argc, const wchar_t* const argv[], const Ice::InitializationData& initData, int version)
 {
     //
     // On Windows the given wchar_t* strings are UTF16 and therefore
-    // needs to be converted to native narow string encoding.
+    // needs to be converted to native narrow string encoding.
     //
-    return main(argsToStringSeq(argc, argv), initData);
+    return main(argsToStringSeq(argc, argv), initData, version);
 }
 
+int
+Ice::Application::main(int argc, const wchar_t* const argv[], ICE_CONFIG_FILE_STRING config, int version)
+{
+    return main(argsToStringSeq(argc, argv), config, version);
+}
 #endif
 
 int
-Ice::Application::main(int argc, char* argv[], const InitializationData& initializationData)
+Ice::Application::main(int argc, const char* const argv[], const InitializationData& initializationData, int version)
 {
     if(argc > 0 && argv[0] && ICE_DYNAMIC_CAST(LoggerI, getProcessLogger()))
     {
@@ -148,13 +144,15 @@ Ice::Application::main(int argc, char* argv[], const InitializationData& initial
     }
     int status;
 
+    ArgVector av(argc, argv); // copy args
+
     //
     // We parse the properties here to extract Ice.ProgramName.
     //
     InitializationData initData = initializationData;
     try
     {
-        initData.properties = createProperties(argc, argv, initData.properties);
+        initData.properties = createProperties(av.argc, av.argv, initData.properties);
     }
     catch(const std::exception& ex)
     {
@@ -188,7 +186,7 @@ Ice::Application::main(int argc, char* argv[], const InitializationData& initial
             CtrlCHandler ctrCHandler;
             _ctrlCHandler = &ctrCHandler;
 
-            status = doMain(argc, argv, initData);
+            status = doMain(av.argc, av.argv, initData, version);
 
             //
             // Set _ctrlCHandler to 0 only once communicator->destroy() has completed.
@@ -204,38 +202,24 @@ Ice::Application::main(int argc, char* argv[], const InitializationData& initial
     }
     else
     {
-        status = doMain(argc, argv, initData);
+        status = doMain(av.argc, av.argv, initData, version);
     }
 
     return status;
 }
 
 int
-Ice::Application::main(int argc, char* const argv[], const char* configFile)
-{
-    ArgVector av(argc, argv);
-    return main(av.argc, av.argv, configFile);
-}
-
-int
-Ice::Application::main(int argc, char* const argv[], const Ice::InitializationData& initData)
-{
-    ArgVector av(argc, argv);
-    return main(av.argc, av.argv, initData);
-}
-
-int
-Ice::Application::main(const StringSeq& args, const char* configFile)
+Ice::Application::main(const StringSeq& args, const InitializationData& initData, int version)
 {
     ArgVector av(args);
-    return main(av.argc, av.argv, configFile);
+    return main(av.argc, av.argv, initData, version);
 }
 
 int
-Ice::Application::main(const StringSeq& args, const InitializationData& initData)
+Ice::Application::main(const StringSeq& args, ICE_CONFIG_FILE_STRING configFile, int version)
 {
     ArgVector av(args);
-    return main(av.argc, av.argv, initData);
+    return main(av.argc, av.argv, configFile, version);
 }
 
 void
@@ -410,7 +394,7 @@ Ice::Application::interrupted()
 }
 
 int
-Ice::Application::doMain(int argc, char* argv[], const InitializationData& initData)
+Ice::Application::doMain(int argc, char* argv[], const InitializationData& initData, int version)
 {
     int status;
 
@@ -431,7 +415,17 @@ Ice::Application::doMain(int argc, char* argv[], const InitializationData& initD
             setProcessLogger(ICE_MAKE_SHARED(LoggerI, initData.properties->getProperty("Ice.ProgramName"), "", convert));
         }
 
-        _communicator = initialize(argc, argv, initData);
+        if(argc >= 0)
+        {
+            _communicator = initialize(argc, argv, initData, version);
+        }
+        else
+        {
+            //
+            // argc < 0 means use arg-less version of initialize
+            //
+            _communicator = initialize(initData, version);
+        }
         _destroyed = false;
 
         //
diff --git a/cpp/src/Ice/ArgVector.cpp b/cpp/src/Ice/ArgVector.cpp
index 90bf1761414..11d6bc3a722 100644
--- a/cpp/src/Ice/ArgVector.cpp
+++ b/cpp/src/Ice/ArgVector.cpp
@@ -10,7 +10,7 @@
 #include <IceUtil/ArgVector.h>
 #include <cstring>
 
-IceUtilInternal::ArgVector::ArgVector(int argc, char* const argv[])
+IceUtilInternal::ArgVector::ArgVector(int argc, const char* const argv[])
 {
     assert(argc >= 0);
     _args.resize(argc);
diff --git a/cpp/src/Ice/CommunicatorI.cpp b/cpp/src/Ice/CommunicatorI.cpp
index 656231ba3b0..66be6c81207 100644
--- a/cpp/src/Ice/CommunicatorI.cpp
+++ b/cpp/src/Ice/CommunicatorI.cpp
@@ -543,7 +543,7 @@ Ice::CommunicatorI::~CommunicatorI()
 }
 
 void
-Ice::CommunicatorI::finishSetup(int& argc, char* argv[])
+Ice::CommunicatorI::finishSetup(int& argc, const char* argv[])
 {
     try
     {
diff --git a/cpp/src/Ice/CommunicatorI.h b/cpp/src/Ice/CommunicatorI.h
index a49e3908654..3111c621633 100644
--- a/cpp/src/Ice/CommunicatorI.h
+++ b/cpp/src/Ice/CommunicatorI.h
@@ -141,9 +141,9 @@ private:
     // Certain initialization tasks need to be completed after the
     // constructor.
     //
-    void finishSetup(int&, char*[]);
+    void finishSetup(int&, const char*[]);
 
-    friend ICE_API CommunicatorPtr initialize(int&, char*[], const InitializationData&, Int);
+    friend ICE_API CommunicatorPtr initialize(int&, const char*[], const InitializationData&, Int);
     friend ICE_API CommunicatorPtr initialize(StringSeq&, const InitializationData&, Int);
     friend ICE_API CommunicatorPtr initialize(const InitializationData&, Int);
     friend ICE_API ::IceInternal::InstancePtr IceInternal::getInstance(const ::Ice::CommunicatorPtr&);
diff --git a/cpp/src/Ice/Initialize.cpp b/cpp/src/Ice/Initialize.cpp
index 8d573d680f0..42272b3ca83 100644
--- a/cpp/src/Ice/Initialize.cpp
+++ b/cpp/src/Ice/Initialize.cpp
@@ -52,7 +52,7 @@ Init init;
 }
 
 StringSeq
-Ice::argsToStringSeq(int argc, char* argv[])
+Ice::argsToStringSeq(int argc, const char* const argv[])
 {
     StringSeq result;
     for(int i = 0; i < argc; i++)
@@ -65,7 +65,7 @@ Ice::argsToStringSeq(int argc, char* argv[])
 #ifdef _WIN32
 
 StringSeq
-Ice::argsToStringSeq(int /*argc*/, wchar_t* argv[])
+Ice::argsToStringSeq(int /*argc*/, const wchar_t* const argv[])
 {
     //
     // Don't need to use a wide string converter argv is expected to
@@ -73,7 +73,7 @@ Ice::argsToStringSeq(int /*argc*/, wchar_t* argv[])
     //
     const StringConverterPtr converter = getProcessStringConverter();
     StringSeq args;
-    for(int i=0; argv[i] != 0; i++)
+    for(int i = 0; argv[i] != 0; i++)
     {
         args.push_back(wstringToString(argv[i], converter));
     }
@@ -83,7 +83,7 @@ Ice::argsToStringSeq(int /*argc*/, wchar_t* argv[])
 #endif
 
 void
-Ice::stringSeqToArgs(const StringSeq& args, int& argc, char* argv[])
+Ice::stringSeqToArgs(const StringSeq& args, int& argc, const char* argv[])
 {
     //
     // Shift all elements in argv which are present in args to the
@@ -121,7 +121,7 @@ Ice::stringSeqToArgs(const StringSeq& args, int& argc, char* argv[])
 
 #ifdef _WIN32
 void
-Ice::stringSeqToArgs(const StringSeq& args, int& argc, wchar_t* argv[])
+Ice::stringSeqToArgs(const StringSeq& args, int& argc, const wchar_t* argv[])
 {
     //
     // Don't need to use a wide string converter argv is expected to
@@ -177,7 +177,7 @@ Ice::createProperties(StringSeq& args, const PropertiesPtr& defaults)
 }
 
 PropertiesPtr
-Ice::createProperties(int& argc, char* argv[], const PropertiesPtr& defaults)
+Ice::createProperties(int& argc, const char* argv[], const PropertiesPtr& defaults)
 {
     StringSeq args = argsToStringSeq(argc, argv);
     PropertiesPtr properties = createProperties(args, defaults);
@@ -187,7 +187,7 @@ Ice::createProperties(int& argc, char* argv[], const PropertiesPtr& defaults)
 
 #ifdef _WIN32
 PropertiesPtr
-Ice::createProperties(int& argc, wchar_t* argv[], const PropertiesPtr& defaults)
+Ice::createProperties(int& argc, const wchar_t* argv[], const PropertiesPtr& defaults)
 {
     StringSeq args = argsToStringSeq(argc, argv);
     PropertiesPtr properties = createProperties(args, defaults);
@@ -234,7 +234,7 @@ Ice::ThreadHookPlugin::destroy()
 namespace
 {
 
-inline void checkIceVersion(Int version)
+inline void checkIceVersion(int version)
 {
 #ifndef ICE_IGNORE_VERSION
 
@@ -280,7 +280,7 @@ inline void checkIceVersion(Int version)
 }
 
 Ice::CommunicatorPtr
-Ice::initialize(int& argc, char* argv[], const InitializationData& initializationData, Int version)
+Ice::initialize(int& argc, const char* argv[], const InitializationData& initializationData, int version)
 {
     checkIceVersion(version);
 
@@ -292,19 +292,37 @@ Ice::initialize(int& argc, char* argv[], const InitializationData& initializatio
     return communicator;
 }
 
+Ice::CommunicatorPtr
+Ice::initialize(int& argc, const char* argv[], ICE_CONFIG_FILE_STRING configFile, int version)
+{
+    InitializationData initData;
+    initData.properties = createProperties();
+    initData.properties->load(configFile);
+    return initialize(argc, argv, initData, version);
+}
+
 #ifdef _WIN32
 Ice::CommunicatorPtr
-Ice::initialize(int& argc, wchar_t* argv[], const InitializationData& initializationData, Int version)
+Ice::initialize(int& argc, const wchar_t* argv[], const InitializationData& initializationData, int version)
 {
     Ice::StringSeq args = argsToStringSeq(argc, argv);
     CommunicatorPtr communicator = initialize(args, initializationData, version);
     stringSeqToArgs(args, argc, argv);
     return communicator;
 }
+
+Ice::CommunicatorPtr
+Ice::initialize(int& argc, const wchar_t* argv[], ICE_CONFIG_FILE_STRING configFile, int version)
+{
+    InitializationData initData;
+    initData.properties = createProperties();
+    initData.properties->load(configFile);
+    return initialize(argc, argv, initData, version);
+}
 #endif
 
 Ice::CommunicatorPtr
-Ice::initialize(StringSeq& args, const InitializationData& initializationData, Int version)
+Ice::initialize(StringSeq& args, const InitializationData& initializationData, int version)
 {
     IceUtilInternal::ArgVector av(args);
     CommunicatorPtr communicator = initialize(av.argc, av.argv, initializationData, version);
@@ -313,7 +331,16 @@ Ice::initialize(StringSeq& args, const InitializationData& initializationData, I
 }
 
 Ice::CommunicatorPtr
-Ice::initialize(const InitializationData& initData, Int version)
+Ice::initialize(StringSeq& args, ICE_CONFIG_FILE_STRING configFile, int version)
+{
+    InitializationData initData;
+    initData.properties = createProperties();
+    initData.properties->load(configFile);
+    return initialize(args, initData, version);
+}
+
+Ice::CommunicatorPtr
+Ice::initialize(const InitializationData& initData, int version)
 {
     //
     // We can't simply call the other initialize() because this one does NOT read
@@ -323,11 +350,20 @@ Ice::initialize(const InitializationData& initData, Int version)
 
     CommunicatorIPtr communicator = CommunicatorI::create(initData);
     int argc = 0;
-    char* argv[] = { 0 };
+    const char* argv[] = { 0 };
     communicator->finishSetup(argc, argv);
     return communicator;
 }
 
+Ice::CommunicatorPtr
+Ice::initialize(ICE_CONFIG_FILE_STRING configFile, int version)
+{
+    InitializationData initData;
+    initData.properties = createProperties();
+    initData.properties->load(configFile);
+    return initialize(initData, version);
+}
+
 LoggerPtr
 Ice::getProcessLogger()
 {
@@ -357,41 +393,88 @@ Ice::registerPluginFactory(const std::string& name, PluginFactory factory, bool
     PluginManagerI::registerPluginFactory(name, factory, loadOnInitialize);
 }
 
+
+//
+// CommunicatorHolder
+//
+
 #ifdef ICE_CPP11_MAPPING
 Ice::CommunicatorHolder::CommunicatorHolder(shared_ptr<Communicator> communicator) :
     _communicator(std::move(communicator))
 {
 }
 
-#else
+#else // C++98 mapping
+
+Ice::CommunicatorHolder::CommunicatorHolder(int& argc, const char* argv[], const InitializationData& initData,
+                                            int version) :
+    _communicator(initialize(argc, argv, initData, version))
+{
+}
 
-Ice::CommunicatorHolder::CommunicatorHolder(int& argc, char* argv[], const InitializationData& initData, Int version) :
+Ice::CommunicatorHolder::CommunicatorHolder(int& argc, char* argv[], const InitializationData& initData, int version) :
     _communicator(initialize(argc, argv, initData, version))
 {
 }
 
+Ice::CommunicatorHolder::CommunicatorHolder(int& argc, const char* argv[], const char* configFile, int version) :
+    _communicator(initialize(argc, argv, configFile, version))
+{
+}
+
+Ice::CommunicatorHolder::CommunicatorHolder(int& argc, char* argv[], const char* configFile, int version) :
+    _communicator(initialize(argc, argv, configFile, version))
+{
+}
+
 #ifdef _WIN32
-Ice::CommunicatorHolder::CommunicatorHolder(int& argc, wchar_t* argv[], const InitializationData& initData, Int version) :
+Ice::CommunicatorHolder::CommunicatorHolder(int& argc, const wchar_t* argv[], const InitializationData& initData,
+                                            int version) :
+    _communicator(initialize(argc, argv, initData, version))
+{
+}
+
+Ice::CommunicatorHolder::CommunicatorHolder(int& argc, wchar_t* argv[], const InitializationData& initData,
+                                            int version) :
     _communicator(initialize(argc, argv, initData, version))
 {
 }
+
+Ice::CommunicatorHolder::CommunicatorHolder(int& argc, const wchar_t* argv[], const char* configFile, int version) :
+    _communicator(initialize(argc, argv, configFile, version))
+{
+}
+
+Ice::CommunicatorHolder::CommunicatorHolder(int& argc, wchar_t* argv[], const char* configFile, int version) :
+    _communicator(initialize(argc, argv, configFile, version))
+{
+}
 #endif
 
-Ice::CommunicatorHolder::CommunicatorHolder(StringSeq& args, const InitializationData& initData, Int version) :
+Ice::CommunicatorHolder::CommunicatorHolder(StringSeq& args, const InitializationData& initData, int version) :
     _communicator(initialize(args, initData, version))
 {
 }
 
-Ice::CommunicatorHolder::CommunicatorHolder(const InitializationData& initData, Int version) :
+Ice::CommunicatorHolder::CommunicatorHolder(StringSeq& args, const char* configFile, int version) :
+    _communicator(initialize(args, configFile, version))
+{
+}
+
+Ice::CommunicatorHolder::CommunicatorHolder(const InitializationData& initData, int version) :
     _communicator(initialize(initData, version))
 {
 }
 
+Ice::CommunicatorHolder::CommunicatorHolder(const char* configFile, int version) :
+    _communicator(initialize(configFile, version))
+{
+}
+
 Ice::CommunicatorHolder::CommunicatorHolder(const CommunicatorPtr& communicator) :
     _communicator(communicator)
 {
 }
-
 #endif
 
 Ice::CommunicatorHolder::~CommunicatorHolder()
diff --git a/cpp/src/Ice/Instance.cpp b/cpp/src/Ice/Instance.cpp
index cba9085ba4f..936bf3cca2f 100644
--- a/cpp/src/Ice/Instance.cpp
+++ b/cpp/src/Ice/Instance.cpp
@@ -1336,7 +1336,7 @@ IceInternal::Instance::~Instance()
 }
 
 void
-IceInternal::Instance::finishSetup(int& argc, char* argv[], const Ice::CommunicatorPtr& communicator)
+IceInternal::Instance::finishSetup(int& argc, const char* argv[], const Ice::CommunicatorPtr& communicator)
 {
     //
     // Load plug-ins.
diff --git a/cpp/src/Ice/Instance.h b/cpp/src/Ice/Instance.h
index 9bcc78e0990..bf6c1d9d910 100644
--- a/cpp/src/Ice/Instance.h
+++ b/cpp/src/Ice/Instance.h
@@ -152,7 +152,7 @@ private:
 
     Instance(const Ice::CommunicatorPtr&, const Ice::InitializationData&);
     virtual ~Instance();
-    void finishSetup(int&, char*[], const Ice::CommunicatorPtr&);
+    void finishSetup(int&, const char*[], const Ice::CommunicatorPtr&);
     void destroy();
     friend class Ice::CommunicatorI;
 
diff --git a/cpp/src/Ice/PluginManagerI.cpp b/cpp/src/Ice/PluginManagerI.cpp
index f2e3095e170..1b43e00c1af 100644
--- a/cpp/src/Ice/PluginManagerI.cpp
+++ b/cpp/src/Ice/PluginManagerI.cpp
@@ -249,7 +249,7 @@ Ice::PluginManagerI::PluginManagerI(const CommunicatorPtr& communicator, const D
 }
 
 void
-Ice::PluginManagerI::loadPlugins(int& argc, char* argv[])
+Ice::PluginManagerI::loadPlugins(int& argc, const char* argv[])
 {
     assert(_communicator);
 
diff --git a/cpp/src/Ice/PluginManagerI.h b/cpp/src/Ice/PluginManagerI.h
index e51de65da73..1386f3e653a 100644
--- a/cpp/src/Ice/PluginManagerI.h
+++ b/cpp/src/Ice/PluginManagerI.h
@@ -40,7 +40,7 @@ private:
 
     friend class IceInternal::Instance;
 
-    void loadPlugins(int&, char*[]);
+    void loadPlugins(int&, const char*[]);
     void loadPlugin(const std::string&, const std::string&, StringSeq&);
 
     PluginPtr findPlugin(const std::string&) const;
diff --git a/cpp/src/Ice/Service.cpp b/cpp/src/Ice/Service.cpp
index a92b2afed95..91d0fee585f 100644
--- a/cpp/src/Ice/Service.cpp
+++ b/cpp/src/Ice/Service.cpp
@@ -537,7 +537,7 @@ Ice::Service::interrupt()
 }
 
 int
-Ice::Service::main(int& argc, char* argv[], const InitializationData& initializationData)
+Ice::Service::main(int argc, const char* const argv[], const InitializationData& initializationData, int version)
 {
     _name = "";
     if(argc > 0)
@@ -545,6 +545,8 @@ Ice::Service::main(int& argc, char* argv[], const InitializationData& initializa
         _name = argv[0];
     }
 
+    IceUtilInternal::ArgVector av(argc, argv); // copy args
+
     //
     // We parse the properties here to extract Ice.ProgramName and
     // Ice.EventLog.Source on Windows.
@@ -552,7 +554,7 @@ Ice::Service::main(int& argc, char* argv[], const InitializationData& initializa
     InitializationData initData = initializationData;
     try
     {
-        initData.properties = createProperties(argc, argv, initData.properties);
+        initData.properties = createProperties(av.argc, av.argv, initData.properties);
     }
     catch(const Ice::Exception& ex)
     {
@@ -570,17 +572,17 @@ Ice::Service::main(int& argc, char* argv[], const InitializationData& initializa
     string eventLogSource;
     int idx = 1;
     const StringConverterPtr stringConverter = getProcessStringConverter();
-    while(idx < argc)
+    while(idx < av.argc)
     {
-        if(strcmp(argv[idx], "--service") == 0)
+        if(strcmp(av.argv[idx], "--service") == 0)
         {
-            if(idx + 1 >= argc)
+            if(idx + 1 >= av.argc)
             {
-                error("service name argument expected for `" + string(argv[idx]) + "'");
+                error("service name argument expected for `" + string(av.argv[idx]) + "'");
                 return EXIT_FAILURE;
             }
 
-            name = argv[idx + 1];
+            name = av.argv[idx + 1];
 
             //
             // If the process logger is the default logger then we use
@@ -594,11 +596,11 @@ Ice::Service::main(int& argc, char* argv[], const InitializationData& initializa
                 setProcessLogger(_logger);
             }
 
-            for(int i = idx; i + 2 < argc; ++i)
+            for(int i = idx; i + 2 < av.argc; ++i)
             {
-                argv[i] = argv[i + 2];
+                av.argv[i] = av.argv[i + 2];
             }
-            argc -= 2;
+            av.argc -= 2;
         }
         else
         {
@@ -620,59 +622,59 @@ Ice::Service::main(int& argc, char* argv[], const InitializationData& initializa
     bool changeDirectory = true;
     string pidFile;
     int idx = 1;
-    while(idx < argc)
+    while(idx < av.argc)
     {
-        if(strcmp(argv[idx], "--daemon") == 0)
+        if(strcmp(av.argv[idx], "--daemon") == 0)
         {
-            for(int i = idx; i + 1 < argc; ++i)
+            for(int i = idx; i + 1 < av.argc; ++i)
             {
-                argv[i] = argv[i + 1];
+                av.argv[i] = av.argv[i + 1];
             }
-            argc -= 1;
+            av.argc -= 1;
 
             daemonize = true;
         }
-        else if(strcmp(argv[idx], "--noclose") == 0)
+        else if(strcmp(av.argv[idx], "--noclose") == 0)
         {
-            for(int i = idx; i + 1 < argc; ++i)
+            for(int i = idx; i + 1 < av.argc; ++i)
             {
-                argv[i] = argv[i + 1];
+                av.argv[i] = av.argv[i + 1];
             }
-            argc -= 1;
+            av.argc -= 1;
 
             closeFiles = false;
         }
-        else if(strcmp(argv[idx], "--nochdir") == 0)
+        else if(strcmp(av.argv[idx], "--nochdir") == 0)
         {
-            for(int i = idx; i + 1 < argc; ++i)
+            for(int i = idx; i + 1 < av.argc; ++i)
             {
-                argv[i] = argv[i + 1];
+                av.argv[i] = av.argv[i + 1];
             }
-            argc -= 1;
+            av.argc -= 1;
 
             changeDirectory = false;
         }
-        else if(strcmp(argv[idx], "--pidfile") == 0)
+        else if(strcmp(av.argv[idx], "--pidfile") == 0)
         {
-            if(idx + 1 < argc)
+            if(idx + 1 < av.argc)
             {
-                pidFile = argv[idx + 1];
+                pidFile = av.argv[idx + 1];
             }
             else
             {
-                if(argv[0])
+                if(av.argv[0])
                 {
-                    consoleErr << argv[0] << ": ";
+                    consoleErr << av.argv[0] << ": ";
                 }
                 consoleErr << "--pidfile must be followed by an argument" << endl;
                 return EXIT_FAILURE;
             }
 
-            for(int i = idx; i + 2 < argc; ++i)
+            for(int i = idx; i + 2 < av.argc; ++i)
             {
-                argv[i] = argv[i + 2];
+                av.argv[i] = av.argv[i + 2];
             }
-            argc -= 2;
+            av.argc -= 2;
         }
         else
         {
@@ -682,9 +684,9 @@ Ice::Service::main(int& argc, char* argv[], const InitializationData& initializa
 
     if(!closeFiles && !daemonize)
     {
-        if(argv[0])
+        if(av.argv[0])
         {
-            consoleErr << argv[0] << ": ";
+            consoleErr << av.argv[0] << ": ";
         }
         consoleErr << "--noclose must be used with --daemon" << endl;
         return EXIT_FAILURE;
@@ -692,9 +694,9 @@ Ice::Service::main(int& argc, char* argv[], const InitializationData& initializa
 
     if(pidFile.size() > 0 && !daemonize)
     {
-        if(argv[0])
+        if(av.argv[0])
         {
-            consoleErr << argv[0] << ": ";
+            consoleErr << av.argv[0] << ": ";
         }
         consoleErr << "--pidfile <file> must be used with --daemon" << endl;
         return EXIT_FAILURE;
@@ -725,40 +727,22 @@ Ice::Service::main(int& argc, char* argv[], const InitializationData& initializa
         }
     }
 
-    return run(argc, argv, initData);
-}
-
-int
-Ice::Service::main(int argc, char* const argv[], const InitializationData& initializationData)
-{
-    IceUtilInternal::ArgVector av(argc, argv);
-    return main(av.argc, av.argv, initializationData);
+    return run(av.argc, av.argv, initData, version);
 }
 
 #ifdef _WIN32
-
 int
-Ice::Service::main(int& argc, wchar_t* argv[], const InitializationData& initializationData)
+Ice::Service::main(int argc, const wchar_t* const argv[], const InitializationData& initializationData, int version)
 {
-
-#   ifdef __MINGW32__ // COMPILER FIX
-    //
-    // MinGW doesn't see the main overload if we don't create the temp args object here.
-    //
-    Ice::StringSeq args = Ice::argsToStringSeq(argc, argv);
-    return main(args, initializationData);
-#   else
-    return main(Ice::argsToStringSeq(argc, argv), initializationData);
-#   endif
+    return main(Ice::argsToStringSeq(argc, argv), initializationData, version);
 }
-
 #endif
 
 int
-Ice::Service::main(StringSeq& args, const InitializationData& initData)
+    Ice::Service::main(const StringSeq& args, const InitializationData& initData, int version)
 {
     IceUtilInternal::ArgVector av(args);
-    return main(av.argc, av.argv, initData);
+    return main(av.argc, av.argv, initData, version);
 }
 
 Ice::CommunicatorPtr
@@ -793,23 +777,25 @@ Ice::Service::checkSystem() const
 
 #ifdef _WIN32
 int
-Ice::Service::run(int& argc, wchar_t* argv[], const InitializationData& initData)
+Ice::Service::run(int argc, const wchar_t* const argv[], const InitializationData& initData, int version)
 {
     StringSeq args = Ice::argsToStringSeq(argc, argv);
     IceUtilInternal::ArgVector av(args);
-    return run(av.argc, av.argv, initData);
+    return run(av.argc, av.argv, initData, version);
 }
 #endif
 
 int
-Ice::Service::run(int& argc, char* argv[], const InitializationData& initData)
+Ice::Service::run(int argc, const char* const argv[], const InitializationData& initData, int version)
 {
+    IceUtilInternal::ArgVector av(argc, argv); // copy args
+
     if(_service)
     {
 #ifdef _WIN32
-        return runService(argc, argv, initData);
+        return runService(av.argc, av.argv, initData);
 #else
-        return runDaemon(argc, argv, initData);
+        return runDaemon(av.argc, av.argv, initData, version);
 #endif
     }
 
@@ -830,7 +816,7 @@ Ice::Service::run(int& argc, char* argv[], const InitializationData& initData)
         //
         // Initialize the communicator.
         //
-        _communicator = initializeCommunicator(argc, argv, initData);
+        _communicator = initializeCommunicator(av.argc, av.argv, initData, version);
 
         //
         // Use the configured logger.
@@ -845,7 +831,7 @@ Ice::Service::run(int& argc, char* argv[], const InitializationData& initData)
         //
         // Start the service.
         //
-        if(start(argc, argv, status))
+        if(start(av.argc, av.argv, status))
         {
             //
             // Wait for service shutdown.
@@ -953,9 +939,9 @@ Ice::Service::stop()
 }
 
 Ice::CommunicatorPtr
-Ice::Service::initializeCommunicator(int& argc, char* argv[], const InitializationData& initData)
+Ice::Service::initializeCommunicator(int& argc, char* argv[], const InitializationData& initData, int version)
 {
-    return Ice::initialize(argc, argv, initData);
+    return Ice::initialize(argc, argv, initData, version);
 }
 
 void
@@ -1067,7 +1053,7 @@ Ice::Service::disableInterrupt()
 #ifdef _WIN32
 
 int
-Ice::Service::runService(int argc, char* argv[], const InitializationData& initData)
+Ice::Service::runService(int argc, const char* const argv[], const InitializationData& initData)
 {
     assert(_service);
 
@@ -1256,7 +1242,7 @@ Ice::Service::showServiceStatus(const string& msg, SERVICE_STATUS& status)
 }
 
 void
-Ice::Service::serviceMain(int argc, wchar_t* argv[])
+Ice::Service::serviceMain(int argc, const wchar_t* const argv[])
 {
     _ctrlCHandler = new IceUtil::CtrlCHandler;
 
@@ -1306,7 +1292,7 @@ Ice::Service::serviceMain(int argc, wchar_t* argv[])
     //
     try
     {
-        _communicator = initializeCommunicator(argc, args, _initData);
+        _communicator = initializeCommunicator(argc, args, _initData, ICE_INT_VERSION);
     }
     catch(const Ice::Exception& ex)
     {
@@ -1504,7 +1490,7 @@ ServiceStatusManager::run()
 #else
 
 int
-Ice::Service::runDaemon(int argc, char* argv[], const InitializationData& initData)
+Ice::Service::runDaemon(int argc, char* argv[], const InitializationData& initData, int version)
 {
     assert(_service);
 
@@ -1702,7 +1688,7 @@ Ice::Service::runDaemon(int argc, char* argv[], const InitializationData& initDa
         //
         // Initialize the communicator.
         //
-        _communicator = initializeCommunicator(argc, argv, initData);
+        _communicator = initializeCommunicator(argc, argv, initData, version);
 
         if(_closeFiles)
         {
diff --git a/cpp/src/IceBridge/IceBridge.cpp b/cpp/src/IceBridge/IceBridge.cpp
index 76a3ba0ab5d..326a73a496b 100644
--- a/cpp/src/IceBridge/IceBridge.cpp
+++ b/cpp/src/IceBridge/IceBridge.cpp
@@ -664,7 +664,7 @@ protected:
 
     virtual bool start(int, char*[], int&);
     virtual bool stop();
-    virtual CommunicatorPtr initializeCommunicator(int&, char*[], const InitializationData&);
+    virtual CommunicatorPtr initializeCommunicator(int&, char*[], const InitializationData&, int);
 
 private:
 
@@ -784,7 +784,8 @@ BridgeService::stop()
 }
 
 CommunicatorPtr
-BridgeService::initializeCommunicator(int& argc, char* argv[], const InitializationData& initializationData)
+BridgeService::initializeCommunicator(int& argc, char* argv[], const InitializationData& initializationData,
+                                      int version)
 {
     InitializationData initData = initializationData;
     initData.properties = createProperties(argc, argv, initializationData.properties);
@@ -801,7 +802,7 @@ BridgeService::initializeCommunicator(int& argc, char* argv[], const Initializat
         initData.properties->setProperty("Ice.RetryIntervals", "-1");
     }
 
-    return Service::initializeCommunicator(argc, argv, initData);
+    return Service::initializeCommunicator(argc, argv, initData, version);
 }
 
 void
diff --git a/cpp/src/IceGrid/IceGridNode.cpp b/cpp/src/IceGrid/IceGridNode.cpp
index a701f0bd354..d28f0ec6e4c 100644
--- a/cpp/src/IceGrid/IceGridNode.cpp
+++ b/cpp/src/IceGrid/IceGridNode.cpp
@@ -71,7 +71,7 @@ protected:
     bool startImpl(int, char*[], int&);
     virtual void waitForShutdown();
     virtual bool stop();
-    virtual CommunicatorPtr initializeCommunicator(int&, char*[], const InitializationData&);
+    virtual CommunicatorPtr initializeCommunicator(int&, char*[], const InitializationData&, int);
 
 private:
 
@@ -754,7 +754,8 @@ NodeService::stop()
 
 CommunicatorPtr
 NodeService::initializeCommunicator(int& argc, char* argv[],
-                                    const InitializationData& initializationData)
+                                    const InitializationData& initializationData,
+                                    int version)
 {
     InitializationData initData = initializationData;
     initData.properties = createProperties(argc, argv, initData.properties);
@@ -782,7 +783,7 @@ NodeService::initializeCommunicator(int& argc, char* argv[],
     //
     initData.properties->setProperty("Ice.ACM.Close", "3");
 
-    return Service::initializeCommunicator(argc, argv, initData);
+    return Service::initializeCommunicator(argc, argv, initData, version);
 }
 
 void
diff --git a/cpp/src/IceGrid/IceGridRegistry.cpp b/cpp/src/IceGrid/IceGridRegistry.cpp
index 7af6de14681..1c1060d6563 100644
--- a/cpp/src/IceGrid/IceGridRegistry.cpp
+++ b/cpp/src/IceGrid/IceGridRegistry.cpp
@@ -37,7 +37,7 @@ protected:
     virtual bool start(int, char*[], int&);
     virtual void waitForShutdown();
     virtual bool stop();
-    virtual CommunicatorPtr initializeCommunicator(int&, char*[], const InitializationData&);
+    virtual CommunicatorPtr initializeCommunicator(int&, char*[], const InitializationData&, int);
 
 private:
 
@@ -161,7 +161,8 @@ RegistryService::stop()
 
 CommunicatorPtr
 RegistryService::initializeCommunicator(int& argc, char* argv[],
-                                        const InitializationData& initializationData)
+                                        const InitializationData& initializationData,
+                                        int version)
 {
     InitializationData initData = initializationData;
     initData.properties = createProperties(argc, argv, initData.properties);
@@ -219,7 +220,7 @@ RegistryService::initializeCommunicator(int& argc, char* argv[],
     initData.properties->setProperty("Ice.ACM.Close", "3");
 
 
-    return Service::initializeCommunicator(argc, argv, initData);
+    return Service::initializeCommunicator(argc, argv, initData, version);
 }
 
 void
diff --git a/cpp/src/IceUtil/ArgVector.h b/cpp/src/IceUtil/ArgVector.h
index b25b09f319b..0648112f7ad 100644
--- a/cpp/src/IceUtil/ArgVector.h
+++ b/cpp/src/IceUtil/ArgVector.h
@@ -21,7 +21,7 @@ class ICE_API ArgVector
 {
 public:
 
-    ArgVector(int argc, char* const argv[]);
+    ArgVector(int argc, const char* const argv[]);
     ArgVector(const ::std::vector< ::std::string>&);
     ArgVector(const ArgVector&);
     ArgVector& operator=(const ArgVector&);