zeroc-ice 3.6b1

data/ext/ice/cpp/src/IceUtil/FileUtil.h

@@ -0,0 +1,159 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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_FILE_UTIL_H
+#define ICE_FILE_UTIL_H
+
+#include <IceUtil/Config.h>
+#include <IceUtil/Shared.h>
+#include <IceUtil/Handle.h>
+
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <fstream>
+
+namespace IceUtilInternal
+{
+
+extern const ICE_UTIL_API std::string pathsep;
+extern const ICE_UTIL_API std::string separator;
+
+//
+// Detemine if path is an absolute path.
+//
+ICE_UTIL_API bool isAbsolutePath(const std::string&);
+
+//
+// Determine if a file exists.
+//
+ICE_UTIL_API bool fileExists(const std::string&);
+
+//
+// Determine if a directory exists.
+//
+ICE_UTIL_API bool directoryExists(const std::string&);
+
+#ifdef _WIN32
+
+#if defined(__MINGW32__)
+typedef struct _stat structstat;
+#else
+typedef struct _stat64i32 structstat;
+#endif
+
+#ifdef _MSC_VER
+#   define O_RDONLY _O_RDONLY
+#   define O_BINARY _O_BINARY
+
+#   define S_ISDIR(mode) ((mode) & _S_IFDIR)
+#   define S_ISREG(mode) ((mode) & _S_IFREG)
+#endif
+
+#else
+
+typedef struct stat structstat;
+#   define O_BINARY 0
+
+#endif
+
+//
+// OS stat
+//
+ICE_UTIL_API int stat(const std::string&, structstat*);
+ICE_UTIL_API int remove(const std::string&);
+ICE_UTIL_API int rename(const std::string&, const std::string&);
+ICE_UTIL_API int rmdir(const std::string&);
+
+ICE_UTIL_API int mkdir(const std::string&, int);
+ICE_UTIL_API FILE* fopen(const std::string&, const std::string&);
+ICE_UTIL_API FILE* freopen(const std::string&, const std::string&, FILE*);
+ICE_UTIL_API int open(const std::string&, int);
+
+#ifndef ICE_OS_WINRT
+ICE_UTIL_API int getcwd(std::string&);
+#endif
+
+ICE_UTIL_API int unlink(const std::string&);
+ICE_UTIL_API int close(int);
+
+//
+// This class is used to implement process file locking. This class
+// is not intended to do file locking within the same process.
+//
+class ICE_UTIL_API FileLock : public IceUtil::Shared, public IceUtil::noncopyable
+{
+public:
+    //
+    // The constructor opens the given file (eventually creating it)
+    // and acquires a lock on the file or throws FileLockException if
+    // the file couldn't be locked.
+    //
+    // If the lock can be acquired, the process pid is written to the
+    // file.
+    //
+    FileLock(const std::string&);
+    
+    //
+    // The destructor releases the lock and removes the file.
+    //
+    virtual ~FileLock();
+    
+private:
+    
+#ifdef _WIN32
+    HANDLE _fd;
+#else
+    int _fd;
+#endif
+    std::string _path;
+};
+
+typedef IceUtil::Handle<FileLock> FileLockPtr;
+
+class ICE_UTIL_API ifstream : public std::ifstream
+{
+public:
+
+    ifstream();
+    ifstream(const std::string&, std::ios_base::openmode mode = std::ios_base::in);
+    void open(const std::string&, std::ios_base::openmode mode = std::ios_base::in);
+
+#ifdef __SUNPRO_CC
+    using std::ifstream::open;
+#endif
+
+private:
+
+    // Hide const char* definitions since they shouldn't be used.
+    ifstream(const char*);
+    void open(const char*, std::ios_base::openmode mode = std::ios_base::in);
+};
+
+class ICE_UTIL_API ofstream : public std::ofstream
+{
+public:
+
+    ofstream();
+    ofstream(const std::string&, std::ios_base::openmode mode = std::ios_base::out);
+    void open(const std::string&, std::ios_base::openmode mode = std::ios_base::out);
+
+#ifdef __SUNPRO_CC
+    using std::ofstream::open;
+#endif
+
+private:
+
+    // Hide const char* definitions since they shouldn't be used.
+    ofstream(const char*);
+    void open(const char*, std::ios_base::openmode mode = std::ios_base::out);
+};
+
+}
+#endif

data/ext/ice/cpp/src/IceUtil/InputUtil.cpp

@@ -0,0 +1,41 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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.
+//
+// **********************************************************************
+
+#include <IceUtil/InputUtil.h>
+#include <stdlib.h>
+
+using namespace std;
+using namespace IceUtil;
+
+namespace IceUtilInternal
+{
+
+Int64
+strToInt64(const char* s, char** endptr, int base)
+{
+#if defined(_WIN32) && defined(_MSC_VER)
+    return _strtoi64(s, endptr, base);
+#elif defined(ICE_64) && !defined(_WIN32)
+    return strtol(s, endptr, base);
+#else
+    return strtoll(s, endptr, base);
+#endif
+}
+
+bool
+stringToInt64(const string& s, Int64& result)
+{
+    const char* start = s.c_str();
+    char* end = 0;
+    errno = 0;
+    result = strToInt64(start, &end, 0);
+    return (errno == 0 && start != end);
+}
+
+}

data/ext/ice/cpp/src/IceUtil/Makefile

@@ -0,0 +1,68 @@
+# **********************************************************************
+#
+# Copyright (c) 2003-2014 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.
+#
+# **********************************************************************
+
+top_srcdir	= ../..
+
+LIBFILENAME	= $(call mklibfilename,IceUtil,$(VERSION))
+SONAME		= $(call mksoname,IceUtil,$(SOVERSION))
+LIBNAME		= $(call mklibname,IceUtil)
+TARGETS		= $(call mklibtargets,$(libdir)/$(LIBFILENAME),$(libdir)/$(SONAME),$(libdir)$(cpp11libdirsuffix)/$(LIBNAME))
+
+OBJS		= ArgVector.o \
+		  Cond.o \
+		  ConvertUTF.o \
+		  CountDownLatch.o \
+		  CtrlCHandler.o \
+		  Exception.o \
+		  FileUtil.o \
+		  InputUtil.o \
+		  MutexProtocol.o \
+		  Options.o \
+		  OutputUtil.o \
+		  Random.o \
+		  RecMutex.o \
+		  SHA1.o \
+		  Shared.o \
+		  StringConverter.o \
+		  StringUtil.o \
+		  Thread.o \
+		  ThreadException.o \
+		  Time.o \
+		  Timer.o \
+		  Unicode.o \
+		  UUID.o
+
+include $(top_srcdir)/config/Make.rules
+
+CPPFLAGS        := $(CPPFLAGS) $(ICEUTIL_FLAGS) -DICE_UTIL_API_EXPORTS -I..
+LINKWITH        := $(ICEUTIL_OS_LIBS)
+
+ifeq ($(STATICLIBS),yes)
+$(libdir)/$(LIBNAME): $(OBJS)
+	@mkdir -p $(dir $@)
+	rm -f $@
+	$(call mklib,$@,$(OBJS))
+else
+$(libdir)/$(LIBFILENAME): $(OBJS)
+	@mkdir -p $(dir $@)
+	rm -f $@
+	$(call mkshlib,$@,$(SONAME),$(OBJS),$(LINKWITH))
+
+$(libdir)/$(SONAME): $(libdir)/$(LIBFILENAME)
+	rm -f $@
+	ln -s $(LIBFILENAME) $@
+
+$(libdir)$(cpp11libdirsuffix)/$(LIBNAME): $(libdir)/$(SONAME)
+	@mkdir -p $(libdir)$(cpp11libdirsuffix)
+	rm -f $@
+	ln -s $(cpp11sonamedir)$(SONAME) $@
+endif
+
+install:: all
+	$(call installlib,$(DESTDIR)$(install_libdir),$(libdir),$(LIBFILENAME),$(SONAME),$(LIBNAME))

data/ext/ice/cpp/src/IceUtil/MutexProtocol.cpp

@@ -0,0 +1,24 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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.
+//
+// **********************************************************************
+
+#include <IceUtil/MutexProtocol.h>
+
+IceUtil::MutexProtocol
+IceUtil::getDefaultMutexProtocol()
+{
+#ifdef _WIN32
+   return PrioNone;
+#else
+#  if defined(ICE_PRIO_INHERIT) && defined(_POSIX_THREAD_PRIO_INHERIT) && _POSIX_THREAD_PRIO_INHERIT > 0
+    return PrioInherit;
+#  else
+    return PrioNone;
+#  endif
+#endif
+}

data/ext/ice/cpp/src/IceUtil/Options.cpp

@@ -0,0 +1,1049 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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.
+//
+// **********************************************************************
+
+#include <IceUtil/Options.h>
+#include <IceUtil/StringUtil.h>
+#include <iostream>
+#include <set>
+
+using namespace std;
+using namespace IceUtil;
+
+IceUtilInternal::APIException::APIException(const char* file, int line, const string& r)
+    : IceUtil::Exception(file, line), reason(r)
+{
+}
+
+IceUtilInternal::APIException::~APIException() throw()
+{
+}
+
+const char* IceUtilInternal::APIException::_name = "IceUtilInternal::APIException";
+
+string
+IceUtilInternal::APIException::ice_name() const
+{
+    return _name;
+}
+
+void
+IceUtilInternal::APIException::ice_print(ostream& out) const
+{
+    Exception::ice_print(out);
+    if(!reason.empty())
+    {
+        out << ": " << reason;
+    }
+}
+
+IceUtilInternal::APIException*
+IceUtilInternal::APIException::ice_clone() const
+{
+    return new APIException(*this);
+}
+
+void
+IceUtilInternal::APIException::ice_throw() const
+{
+    throw *this;
+}
+
+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::Exception(file, line), reason(r)
+{
+}
+
+IceUtilInternal::BadOptException::~BadOptException() throw()
+{
+}
+
+const char* IceUtilInternal::BadOptException::_name = "IceUtilInternal::BadOptException";
+
+string
+IceUtilInternal::BadOptException::ice_name() const
+{
+    return _name;
+}
+
+void
+IceUtilInternal::BadOptException::ice_print(ostream& out) const
+{
+    Exception::ice_print(out);
+    if(!reason.empty())
+    {
+        out << ": " << reason;
+    }
+}
+
+IceUtilInternal::BadOptException*
+IceUtilInternal::BadOptException::ice_clone() const
+{
+    return new BadOptException(*this);
+}
+
+void
+IceUtilInternal::BadOptException::ice_throw() const
+{
+    throw *this;
+}
+
+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)
+        {
+            string err = "`";
+            err += shortOpt;
+            err += "': a short option cannot specify more than one option";
+            throw IllegalArgumentException(__FILE__, __LINE__, err);
+        }
+        if(shortOpt.find_first_of(" \t\n\r\f\v") != string::npos)
+        {
+            string err = "`";
+            err += shortOpt;
+            err += "': a short option cannot be whitespace";
+            throw IllegalArgumentException(__FILE__, __LINE__, err);
+        }
+        if(shortOpt[0] == '-')
+        {
+            string err = "`";
+            err += shortOpt;
+            err += "': a short option cannot be `-'";
+            throw IllegalArgumentException(__FILE__, __LINE__, err);
+        }
+    }
+
+    if(!longOpt.empty())
+    {
+        if(longOpt.find_first_of(" \t\n\r\f\v") != string::npos)
+        {
+            string err = "`";
+            err += longOpt;
+            err += "': a long option cannot contain whitespace";
+            throw IllegalArgumentException(__FILE__, __LINE__, err);
+        }
+        if(longOpt[0] == '-')
+        {
+            string err = "`";
+            err += longOpt;
+            err += "': a long option must not contain a leading `-'";
+            throw IllegalArgumentException(__FILE__, __LINE__, err);
+        }
+    }
+
+    if(!needArg && !dflt.empty())
+    {
+        throw IllegalArgumentException(__FILE__, __LINE__,
+                                       "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)
+{
+    RecMutex::Lock sync(_m);
+    
+    if(parseCalled)
+    {
+        throw APIException(__FILE__, __LINE__, "cannot add options after parse() was called");
+    }
+
+    checkArgs(shortOpt, longOpt, at == NeedArg, dflt);
+
+    addValidOpt(shortOpt, longOpt, at, dflt, rt);
+}
+
+//
+// Split a command line into argv-style arguments, applying
+// bash quoting rules. The return value is the arguments
+// in the command line, with all shell escapes applied, and
+// quotes removed.
+//
+
+IceUtilInternal::Options::StringVector
+IceUtilInternal::Options::split(const string& line)
+{
+    const string IFS = " \t\n"; // Internal Field Separator.
+
+    //
+    // Strip leading and trailing whitespace.
+    //
+    string::size_type start = line.find_first_not_of(IFS);
+    if(start == string::npos)
+    {
+        return StringVector();
+    }
+    string::size_type end = line.find_last_not_of(IFS);
+    assert(end != string::npos);
+
+    string l(line, start, end - start + 1);
+
+    StringVector vec;
+
+    enum ParseState { Normal, DoubleQuote, SingleQuote, ANSIQuote };
+    ParseState state = Normal;
+
+    string arg;
+
+    for(string::size_type i = 0; i < l.size(); ++i)
+    {
+        char c = l[i];
+        switch(state)
+        {
+            case Normal:
+            {
+                switch(c)
+                {
+                    case '\\':
+                    {
+                        //
+                        // Ignore a backslash at the end of the string,
+                        // and strip backslash-newline pairs. If a
+                        // backslash is followed by a space, single quote,
+                        // double quote, or dollar sign, we drop the backslash
+                        // and write the space, single quote, double quote,
+                        // or dollar sign. This is necessary to allow quotes
+                        // to be escaped. Dropping the backslash preceding a
+                        // space deviates from bash quoting rules, but is
+                        // necessary so we don't drop backslashes from Windows
+                        // path names.)
+                        //
+                        if(i < l.size() - 1 && l[++i] != '\n')
+                        {
+                            switch(l[i])
+                            {
+                                case ' ':
+                                case '$':
+                                case '\'':
+                                case '"':
+                                {
+                                    arg.push_back(l[i]);
+                                    break;
+                                }
+                                default:
+                                {
+                                    arg.push_back('\\');
+                                    arg.push_back(l[i]);
+                                    break;
+                                }
+                            }
+                        }
+                        break;
+                    }
+                    case '\'':
+                    {
+                        state = SingleQuote;
+                        break;
+                    }
+                    case '"':
+                    {
+                        state = DoubleQuote;
+                        break;
+                    }
+                    case '$':
+                    {
+                        if(i < l.size() - 1 && l[i + 1] == '\'')
+                        {
+                            state = ANSIQuote; // Bash uses $'<text>' to allow ANSI escape sequences within <text>.
+                            ++i;
+                        }
+                        else
+                        {
+                            arg.push_back('$');
+                        }
+                        break;
+                    }
+                    default:
+                    {
+                        if(IFS.find(l[i]) != string::npos)
+                        {
+                            vec.push_back(arg);
+                            arg.clear();
+
+                            //
+                            // Move to start of next argument.
+                            //
+                            while(++i < l.size() && IFS.find(l[i]) != string::npos)
+                            {
+                                ;
+                            }
+                            --i;
+                        }
+                        else
+                        {
+                            arg.push_back(l[i]);
+                        }
+                        break;
+                    }
+                }
+                break;
+            }
+            case DoubleQuote:
+            {
+                //
+                // Within double quotes, only backslash retains its special
+                // meaning, and only if followed by double quote, backslash,
+                // or newline. If not followed by one of these characters,
+                // both the backslash and the character are preserved.
+                //
+                if(c == '\\' && i < l.size() - 1)
+                {
+                    switch(c = l[++i])
+                    {
+                        case '"':
+                        case '\\':
+                        case '\n':
+                        {
+                            arg.push_back(c);
+                            break;
+                        }
+                        default:
+                        {
+                            arg.push_back('\\');
+                            arg.push_back(c);
+                            break;
+                        }
+                    }
+                }
+                else if(c == '"') // End of double-quote mode.
+                {
+                    state = Normal;
+                }
+                else
+                {
+                    arg.push_back(c); // Everything else is taken literally.
+                }
+                break;
+            }
+            case SingleQuote:
+            {
+                if(c == '\'') // End of single-quote mode.
+                {
+                    state = Normal;
+                }
+                else
+                {
+                    arg.push_back(c); // Everything else is taken literally.
+                }
+                break;
+            }
+            case ANSIQuote:
+            {
+                switch(c)
+                {
+                    case '\\':
+                    {
+                        if(i == l.size() - 1)
+                        {
+                            break;
+                        }
+                        switch(c = l[++i])
+                        {
+                            //
+                            // Single-letter escape sequences.
+                            //
+                            case 'a':
+                            {
+                                arg.push_back('\a');
+                                break;
+                            }
+                            case 'b':
+                            {
+                                arg.push_back('\b');
+                                break;
+                            }
+                            case 'f':
+                            {
+                                arg.push_back('\f');
+                                break;
+                            }
+                            case 'n':
+                            {
+                                arg.push_back('\n');
+                                break;
+                            }
+                            case 'r':
+                            {
+                                arg.push_back('\r');
+                                break;
+                            }
+                            case 't':
+                            {
+                                arg.push_back('\t');
+                                break;
+                            }
+                            case 'v':
+                            {
+                                arg.push_back('\v');
+                                break;
+                            }
+                            case '\\':
+                            {
+                                arg.push_back('\\');
+                                break;
+                            }
+                            case '\'':
+                            {
+                                arg.push_back('\'');
+                                break;
+                            }
+                            case 'e': // Not ANSI-C, but used by bash.
+                            {
+                                arg.push_back('\033');
+                                break;
+                            }
+
+                            //
+                            // Process up to three octal digits.
+                            //
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            {
+                                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)
+                                {
+                                    us = us * 8 + c - '0';
+                                }
+                                i = j - 1;
+                                arg.push_back(static_cast<char>(us));
+                                break;
+                            }
+
+                            //
+                            // Process up to two hex digits.
+                            //
+                            case 'x':
+                            {
+                                if(i < l.size() - 1 && !isxdigit(static_cast<unsigned char>(l[i + 1])))
+                                {
+                                    arg.push_back('\\');
+                                    arg.push_back('x');
+                                    break;
+                                }
+
+                                Int64 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)
+                                {
+                                    ull *= 16;
+                                    if(isdigit(static_cast<unsigned char>(c)))
+                                    {
+                                        ull += c - '0';
+                                    }
+                                    else if(islower(static_cast<unsigned char>(c)))
+                                    {
+                                        ull += c - 'a' + 10;
+                                    }
+                                    else
+                                    {
+                                        ull += c - 'A' + 10;
+                                    }
+                                }
+                                i = j - 1;
+                                arg.push_back(static_cast<char>(ull));
+                                break;
+                            }
+
+                            //
+                            // Process control-chars.
+                            //
+                            case 'c':
+                            {
+                                c = l[++i];
+                                if(IceUtilInternal::isAlpha(c) || c == '@' || (c >= '[' && c <= '_'))
+                                {
+                                    arg.push_back(static_cast<char>(toupper(static_cast<unsigned char>(c)) - '@'));
+                                }
+                                else
+                                {
+                                    //
+                                    // Bash does not define what should happen if a \c
+                                    // is not followed by a recognized control character.
+                                    // We simply treat this case like other unrecognized
+                                    // escape sequences, that is, we preserve the escape
+                                    // sequence unchanged.
+                                    //
+                                    arg.push_back('\\');
+                                    arg.push_back('c');
+                                    arg.push_back(c);
+                                }
+                                break;
+                            }
+
+                            //
+                            // If inside an ANSI-quoted string, a backslash isn't followed by
+                            // one of the recognized characters, both the backslash and the
+                            // character are preserved.
+                            //
+                            default:
+                            {
+                                arg.push_back('\\');
+                                arg.push_back(c);
+                                break;
+                            }
+                        }
+                        break;
+                    }
+                    case '\'': // End of ANSI-quote mode.
+                    {
+                        state = Normal;
+                        break;
+                    }
+                    default:
+                    {
+                        arg.push_back(c); // Everything else is taken literally.
+                        break;
+                    }
+                }
+                break;
+            }
+            default:
+            {
+                assert(!"Impossible parse state");
+                break;
+            }
+        }
+    }
+
+    switch(state)
+    {
+        case Normal:
+        {
+            vec.push_back(arg);
+            break;
+        }
+        case SingleQuote:
+        {
+            throw BadOptException(__FILE__, __LINE__, "missing closing single quote");
+            break;
+        }
+        case DoubleQuote:
+        {
+            throw BadOptException(__FILE__, __LINE__, "missing closing double quote");
+            break;
+        }
+        case ANSIQuote:
+        {
+            throw BadOptException(__FILE__, __LINE__, "unterminated $' quote");
+            break;
+        }
+        default:
+        {
+            assert(!"Impossible parse state");
+            break;
+        }
+    }
+
+    return vec;
+}
+
+//
+// Parse a vector of arguments and return the non-option
+// arguments as the return value. Throw BadOptException if any of the
+// options are invalid.
+// Note that args[0] is ignored because that is the name
+// of the executable.
+//
+
+IceUtilInternal::Options::StringVector
+IceUtilInternal::Options::parse(const StringVector& args)
+{
+    RecMutex::Lock sync(_m);
+
+    if(parseCalled)
+    {
+        throw APIException(__FILE__, __LINE__, "cannot call parse() more than once on the same Option instance");
+    }
+    parseCalled = true;
+
+    set<string> seenNonRepeatableOpts; // To catch repeated non-repeatable options.
+
+    StringVector result;
+
+    string::size_type i;
+    for(i = 1; i < args.size(); ++i)
+    {
+        if(args[i] == "-" || args[i] == "--")
+        {
+            ++i;
+            break; // "-" and "--" indicate end of options.
+        }
+
+        string opt;
+        ValidOpts::iterator pos;
+        bool argDone = false;
+
+        if(args[i].compare(0, 2, "--") == 0)
+        {
+            //
+            // Long option. If the option has an argument, it can either be separated by '='
+            // or appear as a separate argument. For example, "--name value" is the same
+            // as "--name=value".
+            //
+            string::size_type p = args[i].find('=', 2);
+            if(p != string::npos)
+            {
+                opt = args[i].substr(2, p - 2);
+            }
+            else
+            {
+                opt = args[i].substr(2);
+            }
+
+            pos = checkOpt(opt, LongOpt);
+
+            if(pos->second->repeat == NoRepeat)
+            {
+                set<string>::iterator seenPos = seenNonRepeatableOpts.find(opt);
+                if(seenPos != seenNonRepeatableOpts.end())
+                {
+                    string err = "`--";
+                    err += opt + ":' option cannot be repeated";
+                    throw BadOptException(__FILE__, __LINE__, err);
+                }
+                seenNonRepeatableOpts.insert(seenPos, opt);
+                string synonym = getSynonym(opt);
+                if(!synonym.empty())
+                {
+                    seenNonRepeatableOpts.insert(synonym);
+                }
+            }
+
+            if(p != string::npos)
+            {
+                if(pos->second->arg == NoArg && p != args[i].size() - 1)
+                {
+                    string err = "`";
+                    err += args[i];
+                    err += "': option does not take an argument";
+                    throw BadOptException(__FILE__, __LINE__, err);
+                }
+                setOpt(opt, "", args[i].substr(p + 1), pos->second->repeat);
+                argDone = true;
+            }
+        }
+        else if(!args[i].empty() && args[i][0] == '-')
+        {
+            //
+            // Short option.
+            //
+            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)
+                {
+                    set<string>::iterator seenPos = seenNonRepeatableOpts.find(opt);
+                    if(seenPos != seenNonRepeatableOpts.end())
+                    {
+                        string err = "`-";
+                        err += opt + ":' option cannot be repeated";
+                        throw BadOptException(__FILE__, __LINE__, err);
+                    }
+                    seenNonRepeatableOpts.insert(seenPos, opt);
+                    string synonym = getSynonym(opt);
+                    if(!synonym.empty())
+                    {
+                        seenNonRepeatableOpts.insert(synonym);
+                    }
+                }
+
+                if(pos->second->arg == NeedArg && p != args[i].size() - 1)
+                {
+                    string optArg = args[i].substr(p + 1);
+                    setOpt(opt, "", optArg, pos->second->repeat);
+                    argDone = true;
+                    break;
+                }
+            }
+        }
+        else
+        {
+            //
+            // Not an option or option argument.
+            //
+            result.push_back(args[i]);
+            argDone = true;
+        }
+
+        if(!argDone)
+        {
+            if(pos->second->arg == NeedArg) // Need an argument that is separated by whitespace.
+            {
+                if(i == args.size() - 1)
+                {
+                    string err = "`-";
+                    if(opt.size() != 1)
+                    {
+                        err += "-";
+                    }
+                    err += opt;
+                    err += "' option requires an argument";
+                    throw BadOptException(__FILE__, __LINE__, err);
+                }
+                setOpt(opt, "", args[++i], pos->second->repeat);
+            }
+            else
+            {
+                setOpt(opt, "", "1", pos->second->repeat);
+            }
+        }
+    }
+
+    _synonyms.clear(); // Don't need the contents anymore.
+
+    while(i < args.size())
+    {
+        result.push_back(args[i++]);
+    }
+
+    return result;
+}
+
+//
+// Parse a normal argc/argv pair and return the non-option
+// arguments as the return value.
+//
+
+IceUtilInternal::Options::StringVector
+IceUtilInternal::Options::parse(int argc, const char* const argv[])
+{
+    StringVector vec;
+    for(int i = 0; i < argc; ++i)
+    {
+        vec.push_back(argv[i]);
+    }
+    return parse(vec);
+}
+
+bool
+IceUtilInternal::Options::isSet(const string& opt) const
+{
+    RecMutex::Lock sync(_m);
+
+    if(!parseCalled)
+    {
+        throw APIException(__FILE__, __LINE__, "cannot lookup options before calling parse()");
+    }
+
+    ValidOpts::const_iterator 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
+{
+    RecMutex::Lock sync(_m);
+
+    if(!parseCalled)
+    {
+        throw APIException(__FILE__, __LINE__, "cannot lookup options before calling parse()");
+    }
+
+    ValidOpts::const_iterator pos = checkOptHasArg(opt);
+
+    if(pos->second->repeat == Repeat)
+    {
+        string err = "`-";
+        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);
+    }
+
+    Opts::const_iterator p = _opts.find(opt);
+    if(p == _opts.end())
+    {
+        return "";
+    }
+    return p->second->val;
+}
+
+IceUtilInternal::Options::StringVector
+IceUtilInternal::Options::argVec(const string& opt) const
+{
+    RecMutex::Lock sync(_m);
+
+    if(!parseCalled)
+    {
+        throw APIException(__FILE__, __LINE__, "cannot lookup options before calling parse()");
+    }
+
+    ValidOpts::const_iterator pos = checkOptHasArg(opt);
+
+    if(pos->second->repeat == NoRepeat)
+    {
+        string err = "`-";
+        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);
+    }
+
+    ROpts::const_iterator 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)
+{
+    if(!shortOpt.empty() && _validOpts.find(shortOpt) != _validOpts.end())
+    {
+        string err = "`";
+        err += shortOpt;
+        err += "': duplicate option";
+        throw IllegalArgumentException(__FILE__, __LINE__, err);
+    }
+    if(!longOpt.empty() && _validOpts.find(longOpt) != _validOpts.end())
+    {
+        string err = "`";
+        err += longOpt;
+        err += "': duplicate option";
+        throw IllegalArgumentException(__FILE__, __LINE__, err);
+    }
+
+    ODPtr odp = new OptionDetails;
+    odp->arg = at;
+    odp->repeat = rt;
+    odp->hasDefault = !dflt.empty();
+
+    if(!shortOpt.empty())
+    {
+        odp->length = ShortOpt;
+        _validOpts[shortOpt] = odp;
+    }
+    if(!longOpt.empty())
+    {
+        odp->length = LongOpt;
+        _validOpts[longOpt] = odp;
+    }
+
+    updateSynonyms(shortOpt, longOpt);
+
+    if(at == NeedArg && !dflt.empty())
+    {
+        setOpt(shortOpt, longOpt, dflt, rt);
+    }
+}
+
+IceUtilInternal::Options::ValidOpts::iterator
+IceUtilInternal::Options::checkOpt(const string& opt, LengthType lt)
+{
+    ValidOpts::iterator pos = _validOpts.find(opt);
+    if(pos == _validOpts.end())
+    {
+        string err = "invalid option: `-";
+        if(lt == LongOpt)
+        {
+            err.push_back('-');
+        }
+        err += opt;
+        err.push_back('\'');
+        throw BadOptException(__FILE__, __LINE__, err);
+    }
+    return pos;
+}
+
+void
+IceUtilInternal::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)
+    {
+        setNonRepeatingOpt(opt1, val);
+        setNonRepeatingOpt(opt2, val);
+    }
+    else
+    {
+        setRepeatingOpt(opt1, val);
+        setRepeatingOpt(opt2, val);
+    }
+}
+
+void
+IceUtilInternal::Options::setNonRepeatingOpt(const string& opt, const string& val)
+{
+    if(opt.empty())
+    {
+        return;
+    }
+
+    //
+    // The option must not have been set before or, if it was set, it must have
+    // been because of a default value.
+    //
+    assert(_opts.find(opt) == _opts.end() || _validOpts.find(opt)->second->hasDefault);
+
+    OValPtr ovp = new OptionValue;
+    ovp->val = val;
+    _opts[opt] = ovp;
+
+    const string synonym = getSynonym(opt);
+    if(!synonym.empty())
+    {
+        _opts[synonym] = ovp;
+    }
+}
+
+void
+IceUtilInternal::Options::setRepeatingOpt(const string& opt, const string& val)
+{
+    if(opt.empty())
+    {
+        return;
+    }
+
+    ValidOpts::const_iterator vpos = _validOpts.find(opt);
+    assert(vpos != _validOpts.end());
+
+    ROpts::iterator pos = _ropts.find(opt);
+    const string synonym = getSynonym(opt);
+    ROpts::iterator spos = _ropts.find(synonym);
+
+    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)
+        {
+            pos->second->vals[0] = val;
+            vpos->second->hasDefault = false;
+        }
+        else
+        {
+            pos->second->vals.push_back(val);
+        }
+    }
+    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)
+        {
+            spos->second->vals[0] = val;
+            vpos->second->hasDefault = false;
+        }
+        else
+        {
+            spos->second->vals.push_back(val);
+        }
+    }
+    else
+    {
+        OVecPtr ovp = new OptionValueVector;
+        ovp->vals.push_back(val);
+        _ropts[opt] = ovp;
+        if(!synonym.empty())
+        {
+            _ropts[synonym] = ovp;
+        }
+    }
+}
+
+IceUtilInternal::Options::ValidOpts::const_iterator
+IceUtilInternal::Options::checkOptIsValid(const string& opt) const
+{
+    ValidOpts::const_iterator pos = _validOpts.find(opt);
+    if(pos == _validOpts.end())
+    {
+        string err = "`";
+        err += opt;
+        err += "': invalid option";
+        throw IllegalArgumentException(__FILE__, __LINE__, err);
+    }
+    return pos;
+}
+
+IceUtilInternal::Options::ValidOpts::const_iterator
+IceUtilInternal::Options::checkOptHasArg(const string& opt) const
+{
+    ValidOpts::const_iterator pos = checkOptIsValid(opt);
+    if(pos->second->arg == NoArg)
+    {
+        string err = "`-";
+        if(pos->second->length == LongOpt)
+        {
+            err.push_back('-');
+        }
+        err += opt;
+        err += "': option does not take arguments";
+        throw IllegalArgumentException(__FILE__, __LINE__, err);
+    }
+    return pos;
+}
+
+void
+IceUtilInternal::Options::updateSynonyms(const ::std::string& shortOpt, const ::std::string& longOpt)
+{
+    if(!shortOpt.empty() && !longOpt.empty())
+    {
+        _synonyms[shortOpt] = longOpt;
+        _synonyms[longOpt] = shortOpt;
+    }
+}
+
+string
+IceUtilInternal::Options::getSynonym(const ::std::string& optName) const
+{
+    Synonyms::const_iterator pos = _synonyms.find(optName);
+    return pos != _synonyms.end() ? pos->second : string("");
+}