zeroc-ice 3.6.5 → 3.7.4

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

@@ -1,19 +1,14 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #include <IceUtil/StringUtil.h>
 #include <IceUtil/StringConverter.h>
 #include <cstring>
+#include <string.h> // for strerror_r
 
-#ifdef ICE_OS_WINRT
-#  include <IceUtil/ScopedArray.h>
-#endif
+#include <sstream>
+#include <iomanip>
 
 using namespace std;
 using namespace IceUtil;
@@ -21,114 +16,88 @@ using namespace IceUtil;
 namespace
 {
 
-string
-toOctalString(unsigned int n)
+char
+toHexDigit(Byte b)
 {
-    string s;
-    s.resize(32);
-    string::size_type charPos = 32;
-    const int radix = 1 << 3;
-    int mask = radix - 1;
-    do
+    assert(b < 16);
+    if(b < 10)
     {
-        s[--charPos] = '0' + (n & mask);
-        n >>= 3;
+        return static_cast<char>('0' + b);
     }
-    while(n != 0);
+    else
+    {
+        return static_cast<char>('a' - 10 + b);
+    }
+}
 
-    return string(s, charPos, (32 - charPos));
+unsigned int
+addContinuationByte(string::iterator& p, string::iterator end, unsigned int codePoint)
+{
+    if(p == end)
+    {
+        throw IllegalArgumentException(__FILE__, __LINE__, "UTF-8 sequence too short");
+    }
+
+    Byte b = static_cast<Byte>(*p++);
+
+    if((b >> 6) != 2)
+    {
+        throw IllegalArgumentException(__FILE__, __LINE__, "Invalid UTF-8 sequence");
+    }
+    return (codePoint << 6) + (b & 0x3F);
 }
 
 //
-// Write the byte b as an escape sequence if it isn't a printable ASCII
-// character and append the escape sequence to s. Additional characters
-// that should be escaped can be passed in special. If b is any of these
-// characters, b is preceded by a backslash in s.
+// Appends a 2 to 4 bytes UTF-8 sequence as a universal character name
 //
 void
-encodeChar(string::value_type b, string& s, const string& special)
+appendUniversalName(char c, string::iterator& p, string::iterator end, string& result)
 {
-    switch(b)
+    unsigned int codePoint;
+
+    Byte b = static_cast<Byte>(c);
+    if((b >> 5) == 0x06)
     {
-        case '\\': 
-        {
-            s.append("\\\\");
-            break;
-        }
-        
-        case '\'': 
-        {
-            s.append("\\'");
-            break;
-        }
-        
-        case '"': 
-        {
-            s.append("\\\"");
-            break;
-        }
-        
-        case '\b': 
-        {
-            s.append("\\b");
-            break;
-        }
-        
-        case '\f': 
-        {
-            s.append("\\f");
-            break;
-        }
-        
-        case '\n': 
-        {
-            s.append("\\n");
-            break;
-        }
-        
-        case '\r': 
-        {
-            s.append("\\r");
-            break;
-        }
-        
-        case '\t': 
+        // 2 bytes
+        codePoint = (b & 0x1F);
+        codePoint = addContinuationByte(p, end, codePoint);
+    }
+    else if((b >> 4) == 0x0E)
+    {
+        // 3 bytes
+        codePoint = (b & 0x0F);
+        codePoint = addContinuationByte(p, end, codePoint);
+        codePoint = addContinuationByte(p, end, codePoint);
+    }
+    else if((b >> 3) == 0x1E)
+    {
+        // 4 bytes
+        codePoint = (b & 0x07);
+        codePoint = addContinuationByte(p, end, codePoint);
+        codePoint = addContinuationByte(p, end, codePoint);
+        codePoint = addContinuationByte(p, end, codePoint);
+    }
+    else
+    {
+        ostringstream ostr;
+        ostr <<  "Invalid first byte 0x" << hex << static_cast<unsigned short>(b) << " in UTF-8 sequence" << endl;
+        throw IllegalArgumentException(__FILE__, __LINE__,  ostr.str());
+    }
+
+    if(codePoint > 0xFFFF)
+    {
+        result.append("\\U");
+        for(int j = 7; j >= 0; j--)
         {
-            s.append("\\t");
-            break;
+            result.push_back(toHexDigit(static_cast<Byte>((codePoint >> (j * 4)) & 0x0F)));
         }
-        
-        default: 
+    }
+    else
+    {
+        result.append("\\u");
+        for(int j = 3; j >= 0; j--)
         {
-            unsigned char i = static_cast<unsigned char>(b);
-            if(!(i >= 32 && i <= 126))
-            {
-                s.push_back('\\');
-                string octal = toOctalString(i);
-                //
-                // Add leading zeroes so that we avoid problems during
-                // decoding. For example, consider the escaped string
-                // \0013 (i.e., a character with value 1 followed by the
-                // character '3'). If the leading zeroes were omitted, the
-                // result would be incorrectly interpreted as a single
-                // character with value 11.
-                //
-                for(string::size_type j = octal.size(); j < 3; j++)
-                {
-                    s.push_back('0');
-                }
-                s.append(octal);
-            }
-            else if(special.find(b) != string::npos)
-            {
-                s.push_back('\\');
-                s.push_back(b);
-            }
-            else
-            {
-                s.push_back(b);
-            }
-            break;
+            result.push_back(toHexDigit(static_cast<Byte>((codePoint >> (j * 4)) & 0x0F)));
         }
     }
 }
@@ -136,27 +105,166 @@ encodeChar(string::value_type b, string& s, const string& special)
 }
 
 //
-// Add escape sequences (such as "\n", or "\007") to make a string
-// readable in ASCII. Any characters that appear in special are
-// prefixed with a backslash in the returned string.
+// Add escape sequences. Any characters that appear in special are prefixed with a backslash in the returned string.
 //
 string
-IceUtilInternal::escapeString(const string& s, const string& special)
+IceUtilInternal::escapeString(const string& s, const string& special, ToStringMode toStringMode)
 {
     for(string::size_type i = 0; i < special.size(); ++i)
     {
         if(static_cast<unsigned char>(special[i]) < 32 || static_cast<unsigned char>(special[i]) > 126)
         {
-            throw IllegalArgumentException(__FILE__, __LINE__, "special characters must be in ASCII range 32-126");
+            throw IllegalArgumentException(__FILE__, __LINE__, "Special characters must be in ASCII range 32-126");
         }
     }
-    
+
+    //
+    // First convert to UTF-8
+    //
+    string u8s = nativeToUTF8(s, getProcessStringConverter());
+
+    string::iterator p = u8s.begin();
+
     string result;
-    for(string::size_type i = 0; i < s.size(); ++i)
+
+    while(p != u8s.end())
     {
-        encodeChar(s[i], result, special);
+        char c = *p++;
+
+        switch(c)
+        {
+            case '\\':
+            {
+                result.append("\\\\");
+                break;
+            }
+            case '\'':
+            {
+                result.append("\\'");
+                break;
+            }
+            case '"':
+            {
+                result.append("\\\"");
+                break;
+            }
+            case '\a':
+            {
+                if(toStringMode == ICE_ENUM(ToStringMode, Compat))
+                {
+                    // Octal escape for compatibility with 3.6 and earlier
+                    result.append("\\007");
+                }
+                else
+                {
+                    result.append("\\a");
+                }
+                break;
+            }
+            case '\b':
+            {
+                result.append("\\b");
+                break;
+            }
+            case '\f':
+            {
+                result.append("\\f");
+                break;
+            }
+            case '\n':
+            {
+                result.append("\\n");
+                break;
+            }
+            case '\r':
+            {
+                result.append("\\r");
+                break;
+            }
+            case '\t':
+            {
+                result.append("\\t");
+                break;
+            }
+            case '\v':
+            {
+                if(toStringMode == ICE_ENUM(ToStringMode, Compat))
+                {
+                    // Octal escape for compatibility with 3.6 and earlier
+                    result.append("\\013");
+                }
+                else
+                {
+                    result.append("\\v");
+                }
+                break;
+            }
+            default:
+            {
+                if(special.find(c) != string::npos)
+                {
+                    result.push_back('\\');
+                    result.push_back(c);
+                }
+                else
+                {
+                    unsigned char i = static_cast<unsigned char>(c);
+
+                    if(i < 32 || i > 126)
+                    {
+                        if(toStringMode == ICE_ENUM(ToStringMode, Compat))
+                        {
+                            // append octal string
+
+                            // Add leading zeroes so that we avoid problems during
+                            // decoding. For example, consider the escaped string
+                            // \0013 (i.e., a character with value 1 followed by the
+                            // character '3'). If the leading zeroes were omitted, the
+                            // result would be incorrectly interpreted as a single
+                            // character with value 11.
+                            //
+                            ostringstream os;
+                            os << '\\' << oct << setfill('0') << setw(3) << static_cast<unsigned int>(i);
+                            result.append(os.str());
+                        }
+                        else if(i < 32 || i == 127)
+                        {
+                            // append \u00nn
+                            result.append("\\u00");
+                            result.push_back(toHexDigit(i >> 4));
+                            result.push_back(toHexDigit(i & 0x0F));
+                        }
+                        else if(toStringMode == ICE_ENUM(ToStringMode, ASCII))
+                        {
+                            // append \unnnn or \Unnnnnnnn after reading more UTF-8 bytes
+                            appendUniversalName(c, p, u8s.end(), result);
+                        }
+                        else
+                        {
+                            // keep as is
+                            result.push_back(c);
+                        }
+                    }
+                    else
+                    {
+                        // printable ASCII character
+                        result.push_back(c);
+                    }
+                }
+                break;
+            }
+        }
     }
-    
+
+    if(toStringMode == ICE_ENUM(ToStringMode, Unicode))
+    {
+        //
+        // Convert back to Native
+        //
+        result = UTF8ToNative(result, getProcessStringConverter());
+    }
+    // else it's a pure ASCII string
+
     return result;
 }
 
@@ -167,7 +275,7 @@ char
 checkChar(const string& s, string::size_type pos)
 {
     unsigned char c = static_cast<unsigned char>(s[pos]);
-    if(!(c >= 32 && c <= 126))
+    if(c < 32 || c == 127)
     {
         ostringstream ostr;
         if(pos > 0)
@@ -178,73 +286,179 @@ checkChar(const string& s, string::size_type pos)
         {
             ostr << "first character";
         }
-        ostr << " is not a printable ASCII character (ordinal " << static_cast<int>(c) << ")";
+        ostr << " has invalid ordinal value " << static_cast<int>(c);
         throw IllegalArgumentException(__FILE__, __LINE__, ostr.str());
     }
-    return c;
+    return static_cast<char>(c);
 }
 
 //
-// Decode the character or escape sequence starting at start and return it.
+// Append codePoint as a UTF-8 sequence
+//
+void
+appendUTF8(unsigned int codePoint, string& result)
+{
+    if(codePoint >= 0xD800 && codePoint <= 0xDFFF)
+    {
+        throw IllegalArgumentException(__FILE__, __LINE__,
+                                       "A universal character name cannot designate a surrogate");
+    }
+
+    if(codePoint <= 0x7F)
+    {
+        // ASCII
+        result.push_back(static_cast<char>(codePoint));
+    }
+    else if(codePoint <= 0x7FF)
+    {
+        // 2 bytes
+        result.push_back(static_cast<char>((codePoint >> 6) | 0xC0));
+        result.push_back(static_cast<char>((codePoint & 0x3F) | 0x80));
+    }
+    else if(codePoint <= 0xFFFF)
+    {
+        // 3 bytes
+        result.push_back(static_cast<char>((codePoint >> 12) | 0xE0));
+        result.push_back(static_cast<char>(((codePoint >> 6) & 0x3F) | 0x80));
+        result.push_back(static_cast<char>((codePoint & 0x3F) | 0x80));
+    }
+    else if(codePoint <= 0x10FFFF)
+    {
+        // 4 bytes
+        result.push_back(static_cast<char>((codePoint >> 18) | 0xF0));
+        result.push_back(static_cast<char>(((codePoint >> 12) & 0x3F) | 0x80));
+        result.push_back(static_cast<char>(((codePoint >> 6) & 0x3F) | 0x80));
+        result.push_back(static_cast<char>((codePoint & 0x3F) | 0x80));
+    }
+    else
+    {
+        throw IllegalArgumentException(__FILE__, __LINE__, "Invalid universal character name");
+    }
+}
+
+//
+// Decode the character or escape sequence starting at start and appends it to result;
 // end marks the one-past-the-end position of the substring to be scanned.
 // nextStart is set to the index of the first character following the decoded
 // character or escape sequence.
 //
-char
-decodeChar(const string& s, string::size_type start, string::size_type end, string::size_type& nextStart)
+bool
+decodeChar(const string& s, string::size_type start, string::size_type end, string::size_type& nextStart,
+           const string& special, string& result)
 {
     assert(start < end);
     assert(end <= s.size());
 
-    char c;
+    bool pureASCII = true;
 
     if(s[start] != '\\')
     {
-        c = checkChar(s, start++);
+        result.push_back(checkChar(s, start++));
+    }
+    else if(start + 1 == end)
+    {
+        // Keep trailing backslash
+        ++start;
+        result.push_back('\\');
     }
     else
     {
-        if(start + 1 == end)
-        {
-            throw IllegalArgumentException(__FILE__, __LINE__, "trailing backslash");
-        }
-        switch(s[++start])
+        char c = s[++start];
+
+        switch(c)
         {
-            case '\\': 
-            case '\'': 
-            case '"': 
+            case '\\':
+            case '\'':
+            case '"':
+            case '?':
+            {
+                ++start;
+                result.push_back(c);
+                break;
+            }
+            case 'a':
+            {
+                ++start;
+                result.push_back('\a');
+                break;
+            }
+            case 'b':
             {
-                c = s[start++];
+                ++start;
+                result.push_back('\b');
+                break;
+            }
+            case 'f':
+            {
+                ++start;
+                result.push_back('\f');
                 break;
             }
-            case 'b': 
+            case 'n':
             {
                 ++start;
-                c = '\b';
+                result.push_back('\n');
                 break;
             }
-            case 'f': 
+            case 'r':
             {
                 ++start;
-                c = '\f';
+                result.push_back('\r');
                 break;
             }
-            case 'n': 
+            case 't':
             {
                 ++start;
-                c = '\n';
+                result.push_back('\t');
                 break;
             }
-            case 'r': 
+            case 'v':
             {
                 ++start;
-                c = '\r';
+                result.push_back('\v');
                 break;
             }
-            case 't': 
+            case 'u':
+            case 'U':
             {
+                unsigned int codePoint = 0;
+                bool inBMP = (c == 'u');
+                int size = inBMP ? 4 : 8;
                 ++start;
-                c = '\t';
+                while(size > 0 && start < end)
+                {
+                    c = s[start++];
+                    int charVal = 0;
+                    if(c >= '0' && c <= '9')
+                    {
+                        charVal = c - '0';
+                    }
+                    else if(c >= 'a' && c <= 'f')
+                    {
+                        charVal = 10 + (c - 'a');
+                    }
+                    else if(c >= 'A' && c <= 'F')
+                    {
+                        charVal = 10 + (c - 'A');
+                    }
+                    else
+                    {
+                        break; // while
+                    }
+                    codePoint = codePoint * 16 + static_cast<unsigned int>(charVal);
+                    --size;
+                }
+                if(size > 0)
+                {
+                    throw IllegalArgumentException(__FILE__, __LINE__,
+                                                   "Invalid universal character name: too few hex digits");
+                }
+
+                appendUTF8(codePoint, result);
+                if(codePoint > 127)
+                {
+                    pureASCII = false;
+                }
                 break;
             }
             case '0':
@@ -273,31 +487,71 @@ decodeChar(const string& s, string::size_type start, string::size_type end, stri
                     ostr << "octal value \\" << oct << val << dec << " (" << val << ") is out of range";
                     throw IllegalArgumentException(__FILE__, __LINE__, ostr.str());
                 }
-                c = static_cast<char>(val);
+                result.push_back(static_cast<char>(val));
+                if(val > 127)
+                {
+                    pureASCII = false;
+                }
+                break;
+            }
+            case 'x':
+            {
+                int val = 0;
+                int size = 2;
+                ++start;
+                while(size > 0 && start < end)
+                {
+                    c = s[start++];
+                    int charVal = 0;
+                    if(c >= '0' && c <= '9')
+                    {
+                        charVal = c - '0';
+                    }
+                    else if(c >= 'a' && c <= 'f')
+                    {
+                        charVal = 10 + (c - 'a');
+                    }
+                    else if(c >= 'A' && c <= 'F')
+                    {
+                        charVal = 10 + (c - 'A');
+                    }
+                    else
+                    {
+                        --start; // move back
+                        break; // while
+                    }
+                    val = val * 16 + charVal;
+                    --size;
+                }
+                if(size == 2)
+                {
+                    throw IllegalArgumentException(__FILE__, __LINE__,
+                                                   "Invalid \\x escape sequence: no hex digit");
+                }
+                result.push_back(static_cast<char>(val));
+                if(val > 127)
+                {
+                    pureASCII = false;
+                }
                 break;
             }
             default:
             {
-                c = checkChar(s, start++);
+                if(static_cast<unsigned char>(c) > 127)
+                {
+                    pureASCII = false;
+                }
+                if(special.empty() || special.find(c) == string::npos)
+                {
+                    result.push_back('\\'); // not in special, so we keep the backslash
+                }
+                result.push_back(checkChar(s, start++));
                 break;
             }
         }
     }
     nextStart = start;
-    return c;
-}
-
-//
-// Remove escape sequences from s and append the result to sb.
-// Return true if successful, false otherwise.
-//
-void
-decodeString(const string& s, string::size_type start, string::size_type end, string& sb)
-{
-    while(start < end)
-    {
-        sb.push_back(decodeChar(s, start, end, start));
-    }
+    return pureASCII;
 }
 
 }
@@ -306,15 +560,73 @@ decodeString(const string& s, string::size_type start, string::size_type end, st
 // Remove escape sequences added by escapeString.
 //
 string
-IceUtilInternal::unescapeString(const string& s, string::size_type start, string::size_type end)
+IceUtilInternal::unescapeString(const string& s, string::size_type start, string::size_type end, const string& special)
 {
     assert(start <= end && end <= s.size());
 
-    string result;
-    result.reserve(end - start);
-    result.clear();
-    decodeString(s, start, end, result);
-    return result;
+    for(string::size_type i = 0; i < special.size(); ++i)
+    {
+        if(static_cast<unsigned char>(special[i]) < 32 || static_cast<unsigned char>(special[i]) > 126)
+        {
+            throw IllegalArgumentException(__FILE__, __LINE__, "Special characters must be in ASCII range 32-126");
+        }
+    }
+
+    // Optimization for strings without escapes
+    string::size_type p = s.find('\\', start);
+    if(p == string::npos || p >= end)
+    {
+        p = start;
+        while(p < end)
+        {
+            checkChar(s, p++);
+        }
+        return s.substr(start, end);
+    }
+    else
+    {
+        StringConverterPtr stringConverter = getProcessStringConverter();
+
+        const string* inputStringPtr = &s;
+        string u8s;
+
+        if(stringConverter)
+        {
+            bool inputIsPureASCII = true;
+            string::size_type i = start;
+            while(i < end && inputIsPureASCII)
+            {
+                inputIsPureASCII = static_cast<unsigned char>(s[i++]) <= 127;
+            }
+
+            if(!inputIsPureASCII)
+            {
+                u8s = nativeToUTF8(s.substr(start, end), stringConverter);
+                inputStringPtr = &u8s;
+                start = 0;
+                end = u8s.size();
+            }
+        }
+
+        bool resultIsPureASCII = true;
+        string result;
+        result.reserve(end - start);
+        while(start < end)
+        {
+            if(decodeChar(*inputStringPtr, start, end, start, special, result))
+            {
+                resultIsPureASCII = false;
+            }
+        }
+
+        if(stringConverter && !resultIsPureASCII)
+        {
+            // Need to convert from UTF-8 to Native
+            result = UTF8ToNative(result, stringConverter);
+        }
+
+        return result;
+    }
 }
 
 bool
@@ -332,7 +644,7 @@ IceUtilInternal::splitString(const string& str, const string& delim, vector
             quoteChar = str[pos++];
             continue; // Skip the quote
         }
-        else if(quoteChar == '\0' && str[pos] == '\\' && pos + 1 < length && 
+        else if(quoteChar == '\0' && str[pos] == '\\' && pos + 1 < length &&
                 (str[pos + 1] == '\'' || str[pos + 1] == '"'))
         {
             ++pos;
@@ -360,7 +672,7 @@ IceUtilInternal::splitString(const string& str, const string& delim, vector
                 continue;
             }
         }
-            
+
         if(pos < length)
         {
             elt += str[pos++];
@@ -441,7 +753,7 @@ IceUtilInternal::checkQuote(const string& s, string::size_type start)
 //
 // Match `s' against the pattern `pat'. A * in the pattern acts
 // as a wildcard: it matches any non-empty sequence of characters.
-// We match by hand here because it's portable across platforms 
+// We match by hand here because it's portable across platforms
 // (whereas regex() isn't). Only one * per pattern is supported.
 //
 bool
@@ -500,67 +812,63 @@ IceUtilInternal::errorToString(int error, LPCVOID source)
 {
     if(error < WSABASEERR)
     {
-#ifdef ICE_OS_WINRT
-
-        int size = 256;
-        IceUtil::ScopedArray<wchar_t> lpMsgBuf(new wchar_t[size]);
+#ifdef ICE_OS_UWP
 
+        wstring lpMsgBuf(256, wchar_t());
         DWORD stored = 0;
-        
+
         while(stored == 0)
         {
             stored = FormatMessageW(
                 FORMAT_MESSAGE_FROM_SYSTEM |
                 FORMAT_MESSAGE_IGNORE_INSERTS |
-                (source != NULL ? FORMAT_MESSAGE_FROM_HMODULE : 0),
+                (source != ICE_NULLPTR ? FORMAT_MESSAGE_FROM_HMODULE : 0),
                 source,
                 error,
                 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
-                lpMsgBuf.get(),
-                size,
-                NULL);
+                const_cast<wchar_t*>(lpMsgBuf.data()),
+                static_cast<int>(lpMsgBuf.size()),
+                ICE_NULLPTR);
 
             if(stored == 0)
             {
                 DWORD err = GetLastError();
                 if(err == ERROR_INSUFFICIENT_BUFFER)
                 {
-                    if(size == 65536)
+                    if(lpMsgBuf.size() >= 65536)
                     {
                         break; // already at the max size
                     }
                     else
                     {
-                        size *= 4;
-                        size = max(size, 65536);
-                        lpMsgBuf.reset(new wchar_t[size]);
+                        lpMsgBuf.resize(min<size_t>(lpMsgBuf.size() * 4, 65536));
                     }
                 }
                 else
                 {
                     break;
-                }   
+                }
             }
         }
 
-        LPWSTR msg = lpMsgBuf.get();
+        LPWSTR msg = const_cast<wchar_t*>(lpMsgBuf.data());
 
 #else
         LPWSTR msg = 0;
- 
+
         DWORD stored = FormatMessageW(
             FORMAT_MESSAGE_ALLOCATE_BUFFER |
             FORMAT_MESSAGE_FROM_SYSTEM |
             FORMAT_MESSAGE_IGNORE_INSERTS |
-            (source != NULL ? FORMAT_MESSAGE_FROM_HMODULE : 0),
+            (source != ICE_NULLPTR ? FORMAT_MESSAGE_FROM_HMODULE : 0),
             source,
             error,
             MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
             reinterpret_cast<LPWSTR>(&msg),
             0,
-            NULL);
+            ICE_NULLPTR);
 #endif
-        
+
         if(stored > 0)
         {
             assert(msg && wcslen(msg) > 0);
@@ -569,7 +877,7 @@ IceUtilInternal::errorToString(int error, LPCVOID source)
             {
                 result = result.substr(0, result.length() - 2);
             }
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
             if(msg)
             {
                 LocalFree(msg);
@@ -579,170 +887,164 @@ IceUtilInternal::errorToString(int error, LPCVOID source)
         }
         else
         {
-#ifndef ICE_OS_WINRT
-            if(msg)
-            {
-                LocalFree(msg);
-            }
-#endif
             ostringstream os;
             os << "unknown error: " << error;
             return os.str();
         }
     }
-    
+
     switch(error)
     {
     case WSAEINTR:
         return "WSAEINTR";
-        
+
     case WSAEBADF:
         return "WSAEBADF";
-        
+
     case WSAEACCES:
         return "WSAEACCES";
-        
+
     case WSAEFAULT:
         return "WSAEFAULT";
-        
+
     case WSAEINVAL:
         return "WSAEINVAL";
-        
+
     case WSAEMFILE:
         return "WSAEMFILE";
-        
+
     case WSAEWOULDBLOCK:
         return "WSAEWOULDBLOCK";
-        
+
     case WSAEINPROGRESS:
         return "WSAEINPROGRESS";
-        
+
     case WSAEALREADY:
         return "WSAEALREADY";
-        
+
     case WSAENOTSOCK:
         return "WSAENOTSOCK";
-        
+
     case WSAEDESTADDRREQ:
         return "WSAEDESTADDRREQ";
-        
+
     case WSAEMSGSIZE:
         return "WSAEMSGSIZE";
-        
+
     case WSAEPROTOTYPE:
         return "WSAEPROTOTYPE";
-        
+
     case WSAENOPROTOOPT:
         return "WSAENOPROTOOPT";
-        
+
     case WSAEPROTONOSUPPORT:
         return "WSAEPROTONOSUPPORT";
-        
+
     case WSAESOCKTNOSUPPORT:
         return "WSAESOCKTNOSUPPORT";
-        
+
     case WSAEOPNOTSUPP:
         return "WSAEOPNOTSUPP";
-        
+
     case WSAEPFNOSUPPORT:
         return "WSAEPFNOSUPPORT";
-        
+
     case WSAEAFNOSUPPORT:
         return "WSAEAFNOSUPPORT";
-        
+
     case WSAEADDRINUSE:
         return "WSAEADDRINUSE";
-        
+
     case WSAEADDRNOTAVAIL:
         return "WSAEADDRNOTAVAIL";
-        
+
     case WSAENETDOWN:
         return "WSAENETDOWN";
-        
+
     case WSAENETUNREACH:
         return "WSAENETUNREACH";
-        
+
     case WSAENETRESET:
         return "WSAENETRESET";
-        
+
     case WSAECONNABORTED:
         return "WSAECONNABORTED";
-        
+
     case WSAECONNRESET:
         return "WSAECONNRESET";
-        
+
     case WSAENOBUFS:
         return "WSAENOBUFS";
-        
+
     case WSAEISCONN:
         return "WSAEISCONN";
-        
+
     case WSAENOTCONN:
         return "WSAENOTCONN";
-        
+
     case WSAESHUTDOWN:
         return "WSAESHUTDOWN";
-        
+
     case WSAETOOMANYREFS:
         return "WSAETOOMANYREFS";
-        
+
     case WSAETIMEDOUT:
         return "WSAETIMEDOUT";
-        
+
     case WSAECONNREFUSED:
         return "WSAECONNREFUSED";
-        
+
     case WSAELOOP:
         return "WSAELOOP";
-        
+
     case WSAENAMETOOLONG:
         return "WSAENAMETOOLONG";
-        
+
     case WSAEHOSTDOWN:
         return "WSAEHOSTDOWN";
-        
+
     case WSAEHOSTUNREACH:
         return "WSAEHOSTUNREACH";
-        
+
     case WSAENOTEMPTY:
         return "WSAENOTEMPTY";
-        
+
     case WSAEPROCLIM:
         return "WSAEPROCLIM";
-        
+
     case WSAEUSERS:
         return "WSAEUSERS";
-        
+
     case WSAEDQUOT:
         return "WSAEDQUOT";
-        
+
     case WSAESTALE:
         return "WSAESTALE";
-        
+
     case WSAEREMOTE:
         return "WSAEREMOTE";
-        
+
     case WSAEDISCON:
         return "WSAEDISCON";
-        
+
     case WSASYSNOTREADY:
         return "WSASYSNOTREADY";
-        
+
     case WSAVERNOTSUPPORTED:
         return "WSAVERNOTSUPPORTED";
-        
+
     case WSANOTINITIALISED:
         return "WSANOTINITIALISED";
-        
+
     case WSAHOST_NOT_FOUND:
         return "WSAHOST_NOT_FOUND";
-        
+
     case WSATRY_AGAIN:
         return "WSATRY_AGAIN";
-        
+
     case WSANO_RECOVERY:
         return "WSANO_RECOVERY";
-        
+
     case WSANO_DATA:
         return "WSANO_DATA";
 
@@ -766,7 +1068,43 @@ IceUtilInternal::lastErrorToString()
 string
 IceUtilInternal::errorToString(int error)
 {
-    return strerror(error);
+    vector<char> buffer(500);
+    while(true)
+    {
+#if !defined(__GLIBC__) || ((_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600) && !_GNU_SOURCE)
+        //
+        // Use the XSI-compliant version of strerror_r
+        //
+        int err = strerror_r(error, &buffer[0], buffer.size());
+        if(err == 0)
+        {
+            return string(&buffer[0]);
+        }
+#else
+        //
+        // Use the GNU-specific version of strerror_r
+        //
+        int oerrno = errno;
+        errno = 0;
+        const char* msg = strerror_r(error, &buffer[0], buffer.size());
+        int err = errno;
+        errno = oerrno;
+        if(err == 0)
+        {
+            return msg;
+        }
+#endif
+        if(err == ERANGE && buffer.size() < 1024 * 1024)
+        {
+            buffer.resize(buffer.size() * 2);
+        }
+        else
+        {
+            ostringstream os;
+            os << "Unknown error `" << error << "'";
+            return os.str();
+        }
+    }
 }
 
 string
@@ -786,7 +1124,7 @@ IceUtilInternal::toLower(const std::string& s)
     {
         if(isascii(s[i]))
         {
-            result += tolower(static_cast<unsigned char>(s[i]));
+            result += static_cast<char>(tolower(static_cast<unsigned char>(s[i])));
         }
         else
         {
@@ -805,7 +1143,7 @@ IceUtilInternal::toUpper(const std::string& s)
     {
         if(isascii(s[i]))
         {
-            result += toupper(static_cast<unsigned char>(s[i]));
+            result += static_cast<char>(toupper(static_cast<unsigned char>(s[i])));
         }
         else
         {