zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/{IceUtil → Ice}/Options.cpp

@@ -1,168 +1,94 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <IceUtil/Options.h>
-#include <IceUtil/StringUtil.h>
-#include <iostream>
+#include "Options.h"
+#include "Ice/StringUtil.h"
+
+#include <cassert>
 #include <set>
+#include <stdexcept>
 
 using namespace std;
-using namespace IceUtil;
 
-IceUtilInternal::APIException::APIException(const char* file, int line, const string& r)
-    : IceUtil::ExceptionHelper<APIException>(file, line), reason(r)
+const char*
+IceInternal::APIException::ice_id() const noexcept
 {
+    return "::IceInternal::APIException";
 }
 
-#ifndef ICE_CPP11_COMPILER
-IceUtilInternal::APIException::~APIException() throw()
+const char*
+IceInternal::BadOptException::ice_id() const noexcept
 {
+    return "::IceInternal::BadOptException";
 }
-#endif
 
-string
-IceUtilInternal::APIException::ice_id() const
-{
-    return "::IceUtilInternal::APIException";
-}
+IceInternal::Options::Options() = default;
 
 void
-IceUtilInternal::APIException::ice_print(ostream& out) const
+IceInternal::Options::checkArgs(const string& shortOpt, const string& longOpt, bool needArg, const string& dflt)
 {
-    Exception::ice_print(out);
-    if(!reason.empty())
+    if (shortOpt.empty() && longOpt.empty())
     {
-        out << ": " << reason;
+        throw invalid_argument("short and long option cannot both be empty");
     }
-}
-
-#ifndef ICE_CPP11_MAPPING
-IceUtilInternal::APIException*
-IceUtilInternal::APIException::ice_clone() const
-{
-    return new APIException(*this);
-}
-#endif
-
-ostream&
-IceUtilInternal::operator<<(ostream& out, const IceUtilInternal::APIException& ex)
-{
-    ex.ice_print(out);
-    return out;
-}
 
-IceUtilInternal::BadOptException::BadOptException(const char* file, int line, const string& r)
-    : IceUtil::ExceptionHelper<BadOptException>(file, line), reason(r)
-{
-}
-
-#ifndef ICE_CPP11_COMPILER
-IceUtilInternal::BadOptException::~BadOptException() throw()
-{
-}
-#endif
-
-string
-IceUtilInternal::BadOptException::ice_id() const
-{
-    return "::IceUtilInternal::BadOptException";
-}
-
-void
-IceUtilInternal::BadOptException::ice_print(ostream& out) const
-{
-    Exception::ice_print(out);
-    if(!reason.empty())
+    if (!shortOpt.empty())
     {
-        out << ": " << reason;
-    }
-}
-
-#ifndef ICE_CPP11_MAPPING
-IceUtilInternal::BadOptException*
-IceUtilInternal::BadOptException::ice_clone() const
-{
-    return new BadOptException(*this);
-}
-#endif
-
-ostream&
-IceUtilInternal::operator<<(ostream& out, const IceUtilInternal::BadOptException& ex)
-{
-    ex.ice_print(out);
-    return out;
-}
-
-IceUtilInternal::Options::Options()
-    : parseCalled(false)
-{
-}
-
-void
-IceUtilInternal::Options::checkArgs(const string& shortOpt, const string& longOpt, bool needArg, const string& dflt)
-{
-    if(shortOpt.empty() && longOpt.empty())
-    {
-        throw IllegalArgumentException(__FILE__, __LINE__, "short and long option cannot both be empty");
-    }
-
-    if(!shortOpt.empty())
-    {
-        if(shortOpt.size() != 1)
+        if (shortOpt.size() != 1)
         {
-            string err = "`";
+            string err = "'";
             err += shortOpt;
             err += "': a short option cannot specify more than one option";
-            throw IllegalArgumentException(__FILE__, __LINE__, err);
+            throw invalid_argument(err);
         }
-        if(shortOpt.find_first_of(" \t\n\r\f\v") != string::npos)
+        if (shortOpt.find_first_of(" \t\n\r\f\v") != string::npos)
         {
-            string err = "`";
+            string err = "'";
             err += shortOpt;
             err += "': a short option cannot be whitespace";
-            throw IllegalArgumentException(__FILE__, __LINE__, err);
+            throw invalid_argument(err);
         }
-        if(shortOpt[0] == '-')
+        if (shortOpt[0] == '-')
         {
-            string err = "`";
+            string err = "'";
             err += shortOpt;
             err += "': a short option cannot be `-'";
-            throw IllegalArgumentException(__FILE__, __LINE__, err);
+            throw invalid_argument(err);
         }
     }
 
-    if(!longOpt.empty())
+    if (!longOpt.empty())
     {
-        if(longOpt.find_first_of(" \t\n\r\f\v") != string::npos)
+        if (longOpt.find_first_of(" \t\n\r\f\v") != string::npos)
         {
-            string err = "`";
+            string err = "'";
             err += longOpt;
             err += "': a long option cannot contain whitespace";
-            throw IllegalArgumentException(__FILE__, __LINE__, err);
+            throw invalid_argument(err);
         }
-        if(longOpt[0] == '-')
+        if (longOpt[0] == '-')
         {
-            string err = "`";
+            string err = "'";
             err += longOpt;
             err += "': a long option must not contain a leading `-'";
-            throw IllegalArgumentException(__FILE__, __LINE__, err);
+            throw invalid_argument(err);
         }
     }
 
-    if(!needArg && !dflt.empty())
+    if (!needArg && !dflt.empty())
     {
-        throw IllegalArgumentException(__FILE__, __LINE__,
-                                       "a default value can be specified only for options requiring an argument");
+        throw invalid_argument("a default value can be specified only for options requiring an argument");
     }
 }
 
 void
-IceUtilInternal::Options::addOpt(const string& shortOpt, const string& longOpt, ArgType at, string dflt, RepeatType rt)
+IceInternal::Options::addOpt(
+    const string& shortOpt,
+    const string& longOpt,
+    ArgType at,
+    const string& dflt,
+    RepeatType rt)
 {
-    RecMutex::Lock sync(_m);
-
-    if(parseCalled)
+    if (parseCalled)
     {
         throw APIException(__FILE__, __LINE__, "cannot add options after parse() was called");
     }
@@ -179,8 +105,8 @@ IceUtilInternal::Options::addOpt(const string& shortOpt, const string& longOpt,
 // quotes removed.
 //
 
-IceUtilInternal::Options::StringVector
-IceUtilInternal::Options::split(const string& line)
+IceInternal::Options::StringVector
+IceInternal::Options::split(const string& line)
 {
     const string IFS = " \t\n"; // Internal Field Separator.
 
@@ -188,9 +114,9 @@ IceUtilInternal::Options::split(const string& line)
     // Strip leading and trailing whitespace.
     //
     string::size_type start = line.find_first_not_of(IFS);
-    if(start == string::npos)
+    if (start == string::npos)
     {
-        return StringVector();
+        return {};
     }
     string::size_type end = line.find_last_not_of(IFS);
     assert(end != string::npos);
@@ -199,19 +125,25 @@ IceUtilInternal::Options::split(const string& line)
 
     StringVector vec;
 
-    enum ParseState { Normal, DoubleQuote, SingleQuote, ANSIQuote };
+    enum ParseState
+    {
+        Normal,
+        DoubleQuote,
+        SingleQuote,
+        ANSIQuote
+    };
     ParseState state = Normal;
 
     string arg;
 
-    for(string::size_type i = 0; i < l.size(); ++i)
+    for (string::size_type i = 0; i < l.size(); ++i)
     {
         char c = l[i];
-        switch(state)
+        switch (state)
         {
             case Normal:
             {
-                switch(c)
+                switch (c)
                 {
                     case '\\':
                     {
@@ -227,9 +159,9 @@ IceUtilInternal::Options::split(const string& line)
                         // necessary so we don't drop backslashes from Windows
                         // path names.)
                         //
-                        if(i < l.size() - 1 && l[++i] != '\n')
+                        if (i < l.size() - 1 && l[++i] != '\n')
                         {
-                            switch(l[i])
+                            switch (l[i])
                             {
                                 case ' ':
                                 case '$':
@@ -261,7 +193,7 @@ IceUtilInternal::Options::split(const string& line)
                     }
                     case '$':
                     {
-                        if(i < l.size() - 1 && l[i + 1] == '\'')
+                        if (i < l.size() - 1 && l[i + 1] == '\'')
                         {
                             state = ANSIQuote; // Bash uses $'<text>' to allow ANSI escape sequences within <text>.
                             ++i;
@@ -274,7 +206,7 @@ IceUtilInternal::Options::split(const string& line)
                     }
                     default:
                     {
-                        if(IFS.find(l[i]) != string::npos)
+                        if (IFS.find(l[i]) != string::npos)
                         {
                             vec.push_back(arg);
                             arg.clear();
@@ -282,7 +214,7 @@ IceUtilInternal::Options::split(const string& line)
                             //
                             // Move to start of next argument.
                             //
-                            while(++i < l.size() && IFS.find(l[i]) != string::npos)
+                            while (++i < l.size() && IFS.find(l[i]) != string::npos)
                             {
                                 ;
                             }
@@ -305,9 +237,9 @@ IceUtilInternal::Options::split(const string& line)
                 // or newline. If not followed by one of these characters,
                 // both the backslash and the character are preserved.
                 //
-                if(c == '\\' && i < l.size() - 1)
+                if (c == '\\' && i < l.size() - 1)
                 {
-                    switch(c = l[++i])
+                    switch (c = l[++i])
                     {
                         case '"':
                         case '\\':
@@ -324,7 +256,7 @@ IceUtilInternal::Options::split(const string& line)
                         }
                     }
                 }
-                else if(c == '"') // End of double-quote mode.
+                else if (c == '"') // End of double-quote mode.
                 {
                     state = Normal;
                 }
@@ -336,7 +268,7 @@ IceUtilInternal::Options::split(const string& line)
             }
             case SingleQuote:
             {
-                if(c == '\'') // End of single-quote mode.
+                if (c == '\'') // End of single-quote mode.
                 {
                     state = Normal;
                 }
@@ -348,15 +280,15 @@ IceUtilInternal::Options::split(const string& line)
             }
             case ANSIQuote:
             {
-                switch(c)
+                switch (c)
                 {
                     case '\\':
                     {
-                        if(i == l.size() - 1)
+                        if (i == l.size() - 1)
                         {
                             break;
                         }
-                        switch(c = l[++i])
+                        switch (c = l[++i])
                         {
                             //
                             // Single-letter escape sequences.
@@ -427,9 +359,9 @@ IceUtilInternal::Options::split(const string& line)
                                 static const string octalDigits = "01234567";
                                 unsigned short us = 0;
                                 string::size_type j;
-                                for(j = i;
-                                    j < i + 3 && j < l.size() && octalDigits.find_first_of(c = l[j]) != string::npos;
-                                    ++j)
+                                for (j = i;
+                                     j < i + 3 && j < l.size() && octalDigits.find_first_of(c = l[j]) != string::npos;
+                                     ++j)
                                 {
                                     us = us * 8 + static_cast<unsigned short>(c - '0');
                                 }
@@ -443,24 +375,25 @@ IceUtilInternal::Options::split(const string& line)
                             //
                             case 'x':
                             {
-                                if(i < l.size() - 1 && !isxdigit(static_cast<unsigned char>(l[i + 1])))
+                                if (i < l.size() - 1 && !isxdigit(static_cast<unsigned char>(l[i + 1])))
                                 {
                                     arg.push_back('\\');
                                     arg.push_back('x');
                                     break;
                                 }
 
-                                Int64 ull = 0;
+                                int64_t ull = 0;
                                 string::size_type j;
-                                for(j = i + 1; j < i + 3 && j < l.size() &&
-                                    isxdigit(static_cast<unsigned char>(c = l[j])); ++j)
+                                for (j = i + 1;
+                                     j < i + 3 && j < l.size() && isxdigit(static_cast<unsigned char>(c = l[j]));
+                                     ++j)
                                 {
                                     ull *= 16;
-                                    if(isdigit(static_cast<unsigned char>(c)))
+                                    if (isdigit(static_cast<unsigned char>(c)))
                                     {
                                         ull += c - '0';
                                     }
-                                    else if(islower(static_cast<unsigned char>(c)))
+                                    else if (islower(static_cast<unsigned char>(c)))
                                     {
                                         ull += c - 'a' + 10;
                                     }
@@ -480,7 +413,7 @@ IceUtilInternal::Options::split(const string& line)
                             case 'c':
                             {
                                 c = l[++i];
-                                if(IceUtilInternal::isAlpha(c) || c == '@' || (c >= '[' && c <= '_'))
+                                if (IceInternal::isAlpha(c) || c == '@' || (c >= '[' && c <= '_'))
                                 {
                                     arg.push_back(static_cast<char>(toupper(static_cast<unsigned char>(c)) - '@'));
                                 }
@@ -535,7 +468,7 @@ IceUtilInternal::Options::split(const string& line)
         }
     }
 
-    switch(state)
+    switch (state)
     {
         case Normal:
         {
@@ -575,12 +508,10 @@ IceUtilInternal::Options::split(const string& line)
 // of the executable.
 //
 
-IceUtilInternal::Options::StringVector
-IceUtilInternal::Options::parse(const StringVector& args)
+IceInternal::Options::StringVector
+IceInternal::Options::parse(const StringVector& args)
 {
-    RecMutex::Lock sync(_m);
-
-    if(parseCalled)
+    if (parseCalled)
     {
         throw APIException(__FILE__, __LINE__, "cannot call parse() more than once on the same Option instance");
     }
@@ -591,9 +522,9 @@ IceUtilInternal::Options::parse(const StringVector& args)
     StringVector result;
 
     string::size_type i;
-    for(i = 1; i < args.size(); ++i)
+    for (i = 1; i < args.size(); ++i)
     {
-        if(args[i] == "-" || args[i] == "--")
+        if (args[i] == "-" || args[i] == "--")
         {
             ++i;
             break; // "-" and "--" indicate end of options.
@@ -603,7 +534,7 @@ IceUtilInternal::Options::parse(const StringVector& args)
         ValidOpts::iterator pos;
         bool argDone = false;
 
-        if(args[i].compare(0, 2, "--") == 0)
+        if (args[i].compare(0, 2, "--") == 0)
         {
             //
             // Long option. If the option has an argument, it can either be separated by '='
@@ -611,7 +542,7 @@ IceUtilInternal::Options::parse(const StringVector& args)
             // as "--name=value".
             //
             string::size_type p = args[i].find('=', 2);
-            if(p != string::npos)
+            if (p != string::npos)
             {
                 opt = args[i].substr(2, p - 2);
             }
@@ -622,10 +553,10 @@ IceUtilInternal::Options::parse(const StringVector& args)
 
             pos = checkOpt(opt, LongOpt);
 
-            if(pos->second->repeat == NoRepeat)
+            if (pos->second->repeat == NoRepeat)
             {
-                set<string>::iterator seenPos = seenNonRepeatableOpts.find(opt);
-                if(seenPos != seenNonRepeatableOpts.end())
+                auto seenPos = seenNonRepeatableOpts.find(opt);
+                if (seenPos != seenNonRepeatableOpts.end())
                 {
                     string err = "`--";
                     err += opt + ":' option cannot be repeated";
@@ -633,24 +564,24 @@ IceUtilInternal::Options::parse(const StringVector& args)
                 }
                 seenNonRepeatableOpts.insert(seenPos, opt);
                 string synonym = getSynonym(opt);
-                if(!synonym.empty())
+                if (!synonym.empty())
                 {
                     seenNonRepeatableOpts.insert(synonym);
                 }
             }
 
-            if(p != string::npos)
+            if (p != string::npos)
             {
-                if(pos->second->arg == NoArg)
+                if (pos->second->arg == NoArg)
                 {
-                    string err = "`";
+                    string err = "'";
                     err += opt;
                     err += "': option does not take an argument";
                     throw BadOptException(__FILE__, __LINE__, err);
                 }
-                else if(pos->second->arg == NeedArg && p == args[i].size() - 1)
+                else if (pos->second->arg == NeedArg && p == args[i].size() - 1)
                 {
-                    string err = "`";
+                    string err = "'";
                     err += opt;
                     err += "': option requires an argument";
                     throw BadOptException(__FILE__, __LINE__, err);
@@ -659,21 +590,21 @@ IceUtilInternal::Options::parse(const StringVector& args)
                 argDone = true;
             }
         }
-        else if(!args[i].empty() && args[i][0] == '-')
+        else if (!args[i].empty() && args[i][0] == '-')
         {
             //
-            // Short option.
+            // int16_t option.
             //
-            for(string::size_type p = 1; p < args[i].size(); ++p)
+            for (string::size_type p = 1; p < args[i].size(); ++p)
             {
                 opt.clear();
                 opt.push_back(args[i][p]);
                 pos = checkOpt(opt, ShortOpt);
 
-                if(pos->second->repeat == NoRepeat)
+                if (pos->second->repeat == NoRepeat)
                 {
-                    set<string>::iterator seenPos = seenNonRepeatableOpts.find(opt);
-                    if(seenPos != seenNonRepeatableOpts.end())
+                    auto seenPos = seenNonRepeatableOpts.find(opt);
+                    if (seenPos != seenNonRepeatableOpts.end())
                     {
                         string err = "`-";
                         err += opt + ":' option cannot be repeated";
@@ -681,15 +612,15 @@ IceUtilInternal::Options::parse(const StringVector& args)
                     }
                     seenNonRepeatableOpts.insert(seenPos, opt);
                     string synonym = getSynonym(opt);
-                    if(!synonym.empty())
+                    if (!synonym.empty())
                     {
                         seenNonRepeatableOpts.insert(synonym);
                     }
                 }
 
-                if(pos->second->arg == NeedArg)
+                if (pos->second->arg == NeedArg)
                 {
-                    if(p != args[i].size() - 1)
+                    if (p != args[i].size() - 1)
                     {
                         string optArg = args[i].substr(p + 1);
                         setOpt(opt, "", optArg, pos->second->repeat);
@@ -713,14 +644,14 @@ IceUtilInternal::Options::parse(const StringVector& args)
             argDone = true;
         }
 
-        if(!argDone)
+        if (!argDone)
         {
-            if(pos->second->arg == NeedArg) // Need an argument that is separated by whitespace.
+            if (pos->second->arg == NeedArg) // Need an argument that is separated by whitespace.
             {
-                if(i == args.size() - 1)
+                if (i == args.size() - 1)
                 {
                     string err = "`-";
-                    if(opt.size() != 1)
+                    if (opt.size() != 1)
                     {
                         err += "-";
                     }
@@ -739,7 +670,7 @@ IceUtilInternal::Options::parse(const StringVector& args)
 
     _synonyms.clear(); // Don't need the contents anymore.
 
-    while(i < args.size())
+    while (i < args.size())
     {
         result.push_back(args[i++]);
     }
@@ -752,120 +683,118 @@ IceUtilInternal::Options::parse(const StringVector& args)
 // arguments as the return value.
 //
 
-IceUtilInternal::Options::StringVector
-IceUtilInternal::Options::parse(int argc, const char* const argv[])
+IceInternal::Options::StringVector
+IceInternal::Options::parse(int argc, const char* const argv[])
 {
     StringVector vec;
-    for(int i = 0; i < argc; ++i)
+    for (int i = 0; i < argc; ++i)
     {
-        vec.push_back(argv[i]);
+        vec.emplace_back(argv[i]);
     }
     return parse(vec);
 }
 
 bool
-IceUtilInternal::Options::isSet(const string& opt) const
+IceInternal::Options::isSet(const string& opt) const
 {
-    RecMutex::Lock sync(_m);
-
-    if(!parseCalled)
+    if (!parseCalled)
     {
         throw APIException(__FILE__, __LINE__, "cannot lookup options before calling parse()");
     }
 
-    ValidOpts::const_iterator pos = checkOptIsValid(opt);
+    auto pos = checkOptIsValid(opt);
     return pos->second->repeat == NoRepeat ? _opts.find(opt) != _opts.end() : _ropts.find(opt) != _ropts.end();
 }
 
 string
-IceUtilInternal::Options::optArg(const string& opt) const
+IceInternal::Options::optArg(const string& opt) const
 {
-    RecMutex::Lock sync(_m);
-
-    if(!parseCalled)
+    if (!parseCalled)
     {
         throw APIException(__FILE__, __LINE__, "cannot lookup options before calling parse()");
     }
 
-    ValidOpts::const_iterator pos = checkOptHasArg(opt);
+    auto pos = checkOptHasArg(opt);
 
-    if(pos->second->repeat == Repeat)
+    if (pos->second->repeat == Repeat)
     {
         string err = "`-";
-        if(pos->second->length == LongOpt)
+        if (pos->second->length == LongOpt)
         {
             err.push_back('-');
         }
         err += opt;
         err += "': is a repeating option -- use argVec() to get its arguments";
-        throw IllegalArgumentException(__FILE__, __LINE__, err);
+        throw invalid_argument(err);
     }
 
-    Opts::const_iterator p = _opts.find(opt);
-    if(p == _opts.end())
+    auto p = _opts.find(opt);
+    if (p == _opts.end())
     {
         return "";
     }
     return p->second->val;
 }
 
-IceUtilInternal::Options::StringVector
-IceUtilInternal::Options::argVec(const string& opt) const
+IceInternal::Options::StringVector
+IceInternal::Options::argVec(const string& opt) const
 {
-    RecMutex::Lock sync(_m);
-
-    if(!parseCalled)
+    if (!parseCalled)
     {
         throw APIException(__FILE__, __LINE__, "cannot lookup options before calling parse()");
     }
 
-    ValidOpts::const_iterator pos = checkOptHasArg(opt);
+    auto pos = checkOptHasArg(opt);
 
-    if(pos->second->repeat == NoRepeat)
+    if (pos->second->repeat == NoRepeat)
     {
         string err = "`-";
-        if(pos->second->length == LongOpt)
+        if (pos->second->length == LongOpt)
         {
             err.push_back('-');
         }
         err += opt + "': is a non-repeating option -- use optArg() to get its argument";
-        throw IllegalArgumentException(__FILE__, __LINE__, err);
+        throw invalid_argument(err);
     }
 
-    ROpts::const_iterator p = _ropts.find(opt);
+    auto p = _ropts.find(opt);
     return p == _ropts.end() ? StringVector() : p->second->vals;
 }
 
 void
-IceUtilInternal::Options::addValidOpt(const string& shortOpt, const string& longOpt,
-                              ArgType at, const string& dflt, RepeatType rt)
+IceInternal::Options::addValidOpt(
+    const string& shortOpt,
+    const string& longOpt,
+    ArgType at,
+    const string& dflt,
+    RepeatType rt)
 {
-    if(!shortOpt.empty() && _validOpts.find(shortOpt) != _validOpts.end())
+    if (!shortOpt.empty() && _validOpts.find(shortOpt) != _validOpts.end())
     {
-        string err = "`";
+        string err = "'";
         err += shortOpt;
         err += "': duplicate option";
-        throw IllegalArgumentException(__FILE__, __LINE__, err);
+        throw invalid_argument(err);
     }
-    if(!longOpt.empty() && _validOpts.find(longOpt) != _validOpts.end())
+    if (!longOpt.empty() && _validOpts.find(longOpt) != _validOpts.end())
     {
-        string err = "`";
+        string err = "'";
         err += longOpt;
         err += "': duplicate option";
-        throw IllegalArgumentException(__FILE__, __LINE__, err);
+        throw invalid_argument(err);
     }
 
-    ODPtr odp = new OptionDetails;
+    ODPtr odp = make_shared<OptionDetails>();
     odp->arg = at;
     odp->repeat = rt;
     odp->hasDefault = !dflt.empty();
 
-    if(!shortOpt.empty())
+    if (!shortOpt.empty())
     {
         odp->length = ShortOpt;
         _validOpts[shortOpt] = odp;
     }
-    if(!longOpt.empty())
+    if (!longOpt.empty())
     {
         odp->length = LongOpt;
         _validOpts[longOpt] = odp;
@@ -873,20 +802,20 @@ IceUtilInternal::Options::addValidOpt(const string& shortOpt, const string& long
 
     updateSynonyms(shortOpt, longOpt);
 
-    if(at == NeedArg && !dflt.empty())
+    if (at == NeedArg && !dflt.empty())
     {
         setOpt(shortOpt, longOpt, dflt, rt);
     }
 }
 
-IceUtilInternal::Options::ValidOpts::iterator
-IceUtilInternal::Options::checkOpt(const string& opt, LengthType lt)
+IceInternal::Options::ValidOpts::iterator
+IceInternal::Options::checkOpt(const string& opt, LengthType lt)
 {
-    ValidOpts::iterator pos = _validOpts.find(opt);
-    if(pos == _validOpts.end())
+    auto pos = _validOpts.find(opt);
+    if (pos == _validOpts.end())
     {
         string err = "invalid option: `-";
-        if(lt == LongOpt)
+        if (lt == LongOpt)
         {
             err.push_back('-');
         }
@@ -898,14 +827,14 @@ IceUtilInternal::Options::checkOpt(const string& opt, LengthType lt)
 }
 
 void
-IceUtilInternal::Options::setOpt(const string& opt1, const string& opt2, const string& val, RepeatType rt)
+IceInternal::Options::setOpt(const string& opt1, const string& opt2, const string& val, RepeatType rt)
 {
     //
     // opt1 and opt2 (short and long opt) can't both be empty.
     //
     assert(!(opt1.empty() && opt2.empty()));
 
-    if(rt == NoRepeat)
+    if (rt == NoRepeat)
     {
         setNonRepeatingOpt(opt1, val);
         setNonRepeatingOpt(opt2, val);
@@ -918,9 +847,9 @@ IceUtilInternal::Options::setOpt(const string& opt1, const string& opt2, const s
 }
 
 void
-IceUtilInternal::Options::setNonRepeatingOpt(const string& opt, const string& val)
+IceInternal::Options::setNonRepeatingOpt(const string& opt, const string& val)
 {
-    if(opt.empty())
+    if (opt.empty())
     {
         return;
     }
@@ -931,39 +860,39 @@ IceUtilInternal::Options::setNonRepeatingOpt(const string& opt, const string& va
     //
     assert(_opts.find(opt) == _opts.end() || _validOpts.find(opt)->second->hasDefault);
 
-    OValPtr ovp = new OptionValue;
+    OValPtr ovp = make_shared<OptionValue>();
     ovp->val = val;
     _opts[opt] = ovp;
 
     const string synonym = getSynonym(opt);
-    if(!synonym.empty())
+    if (!synonym.empty())
     {
         _opts[synonym] = ovp;
     }
 }
 
 void
-IceUtilInternal::Options::setRepeatingOpt(const string& opt, const string& val)
+IceInternal::Options::setRepeatingOpt(const string& opt, const string& val)
 {
-    if(opt.empty())
+    if (opt.empty())
     {
         return;
     }
 
-    ValidOpts::const_iterator vpos = _validOpts.find(opt);
+    auto vpos = _validOpts.find(opt);
     assert(vpos != _validOpts.end());
 
-    ROpts::iterator pos = _ropts.find(opt);
+    auto pos = _ropts.find(opt);
     const string synonym = getSynonym(opt);
-    ROpts::iterator spos = _ropts.find(synonym);
+    auto spos = _ropts.find(synonym);
 
-    if(pos != _ropts.end())
+    if (pos != _ropts.end())
     {
         assert(_validOpts.find(opt) != _validOpts.end());
         assert(vpos->second->repeat == Repeat);
 
         _ropts[opt] = pos->second;
-        if(vpos->second->hasDefault && pos->second->vals.size() == 1)
+        if (vpos->second->hasDefault && pos->second->vals.size() == 1)
         {
             pos->second->vals[0] = val;
             vpos->second->hasDefault = false;
@@ -973,13 +902,13 @@ IceUtilInternal::Options::setRepeatingOpt(const string& opt, const string& val)
             pos->second->vals.push_back(val);
         }
     }
-    else if(spos != _ropts.end())
+    else if (spos != _ropts.end())
     {
         assert(_validOpts.find(synonym) != _validOpts.end());
         assert(_validOpts.find(synonym)->second->repeat == Repeat);
 
         _ropts[synonym] = spos->second;
-        if(vpos->second->hasDefault && spos->second->vals.size() == 1)
+        if (vpos->second->hasDefault && spos->second->vals.size() == 1)
         {
             spos->second->vals[0] = val;
             vpos->second->hasDefault = false;
@@ -991,52 +920,52 @@ IceUtilInternal::Options::setRepeatingOpt(const string& opt, const string& val)
     }
     else
     {
-        OVecPtr ovp = new OptionValueVector;
+        OVecPtr ovp = make_shared<OptionValueVector>();
         ovp->vals.push_back(val);
         _ropts[opt] = ovp;
-        if(!synonym.empty())
+        if (!synonym.empty())
         {
             _ropts[synonym] = ovp;
         }
     }
 }
 
-IceUtilInternal::Options::ValidOpts::const_iterator
-IceUtilInternal::Options::checkOptIsValid(const string& opt) const
+IceInternal::Options::ValidOpts::const_iterator
+IceInternal::Options::checkOptIsValid(const string& opt) const
 {
-    ValidOpts::const_iterator pos = _validOpts.find(opt);
-    if(pos == _validOpts.end())
+    auto pos = _validOpts.find(opt);
+    if (pos == _validOpts.end())
     {
-        string err = "`";
+        string err = "'";
         err += opt;
         err += "': invalid option";
-        throw IllegalArgumentException(__FILE__, __LINE__, err);
+        throw invalid_argument(err);
     }
     return pos;
 }
 
-IceUtilInternal::Options::ValidOpts::const_iterator
-IceUtilInternal::Options::checkOptHasArg(const string& opt) const
+IceInternal::Options::ValidOpts::const_iterator
+IceInternal::Options::checkOptHasArg(const string& opt) const
 {
-    ValidOpts::const_iterator pos = checkOptIsValid(opt);
-    if(pos->second->arg == NoArg)
+    auto pos = checkOptIsValid(opt);
+    if (pos->second->arg == NoArg)
     {
         string err = "`-";
-        if(pos->second->length == LongOpt)
+        if (pos->second->length == LongOpt)
         {
             err.push_back('-');
         }
         err += opt;
         err += "': option does not take arguments";
-        throw IllegalArgumentException(__FILE__, __LINE__, err);
+        throw invalid_argument(err);
     }
     return pos;
 }
 
 void
-IceUtilInternal::Options::updateSynonyms(const ::std::string& shortOpt, const ::std::string& longOpt)
+IceInternal::Options::updateSynonyms(const std::string& shortOpt, const std::string& longOpt)
 {
-    if(!shortOpt.empty() && !longOpt.empty())
+    if (!shortOpt.empty() && !longOpt.empty())
     {
         _synonyms[shortOpt] = longOpt;
         _synonyms[longOpt] = shortOpt;
@@ -1044,8 +973,8 @@ IceUtilInternal::Options::updateSynonyms(const ::std::string& shortOpt, const ::
 }
 
 string
-IceUtilInternal::Options::getSynonym(const ::std::string& optName) const
+IceInternal::Options::getSynonym(const std::string& optName) const
 {
-    Synonyms::const_iterator pos = _synonyms.find(optName);
+    auto pos = _synonyms.find(optName);
     return pos != _synonyms.end() ? pos->second : string("");
 }