zeroc-ice 3.7.1 → 3.7.6

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

@@ -1,16 +1,13 @@
-// **********************************************************************
 //
-// 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
 
+#include <sstream>
 #include <iomanip>
 
 using namespace std;
@@ -25,11 +22,11 @@ toHexDigit(Byte b)
     assert(b < 16);
     if(b < 10)
     {
-        return '0' + b;
+        return static_cast<char>('0' + b);
     }
     else
     {
-        return 'a' - 10 + b;
+        return static_cast<char>('a' - 10 + b);
     }
 }
 
@@ -292,7 +289,7 @@ checkChar(const string& s, string::size_type pos)
         ostr << " has invalid ordinal value " << static_cast<int>(c);
         throw IllegalArgumentException(__FILE__, __LINE__, ostr.str());
     }
-    return c;
+    return static_cast<char>(c);
 }
 
 //
@@ -1071,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
@@ -1091,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
         {
@@ -1110,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
         {

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #include <IceUtil/ThreadException.h>
 

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #include <IceUtil/DisableWarnings.h>
 #include <IceUtil/Exception.h>
@@ -102,7 +97,7 @@ IceUtil::Time::now(Clock clock)
         struct timeb tb;
         ftime(&tb);
 #  endif
-        return Time(static_cast<Int64>(tb.time) * ICE_INT64(1000000) + tb.millitm * 1000);
+        return Time(static_cast<Int64>(tb.time) * ICE_INT64(1000000) + Int64(tb.millitm) * 1000);
 #else
         struct timeval tv;
         if(gettimeofday(&tv, 0) < 0)
@@ -135,7 +130,7 @@ IceUtil::Time::now(Clock clock)
             struct timeb tb;
             ftime(&tb);
 #  endif
-            return Time(static_cast<Int64>(tb.time) * ICE_INT64(1000000) + tb.millitm * 1000);
+            return Time(static_cast<Int64>(tb.time) * ICE_INT64(1000000) + Int64(tb.millitm) * 1000);
         }
 #elif defined(__hppa)
         //
@@ -149,7 +144,7 @@ IceUtil::Time::now(Clock clock)
         }
         return Time(tv.tv_sec * ICE_INT64(1000000) + tv.tv_usec);
 #elif defined(__APPLE__)
-       return Time(mach_absolute_time() * machMultiplier);
+        return Time(static_cast<IceUtil::Int64>(mach_absolute_time() * machMultiplier));
 #else
         struct timespec ts;
         if(clock_gettime(CLOCK_MONOTONIC, &ts) < 0)
@@ -202,8 +197,8 @@ IceUtil::Time::microSecondsDouble(double t)
 IceUtil::Time::operator timeval() const
 {
     timeval tv;
-    tv.tv_sec = static_cast<long>(_usec / 1000000);
-    tv.tv_usec = static_cast<long>(_usec % 1000000);
+    tv.tv_sec = static_cast<time_t>(_usec / 1000000);
+    tv.tv_usec = static_cast<suseconds_t>(_usec % 1000000);
     return tv;
 }
 #endif
@@ -251,7 +246,7 @@ IceUtil::Time::toDateTime() const
     os << toString("%x %H:%M:%S") << ".";
     os.fill('0');
     os.width(3);
-    os << static_cast<long>(_usec % 1000000 / 1000);
+    os << static_cast<Int64>(_usec % 1000000 / 1000);
     return os.str();
 }
 
@@ -283,19 +278,17 @@ IceUtil::Time::toDuration() const
 std::string
 IceUtil::Time::toString(const std::string& format) const
 {
-    time_t time = static_cast<long>(_usec / 1000000);
+    time_t time = static_cast<time_t>(_usec / 1000000);
 
-    struct tm* t;
-#ifdef _WIN32
-    t = localtime(&time);
-#else
     struct tm tr;
+#ifdef _MSC_VER
+    localtime_s(&tr, &time);
+#else
     localtime_r(&time, &tr);
-    t = &tr;
 #endif
 
     char buf[32];
-    if(strftime(buf, sizeof(buf), format.c_str(), t) == 0)
+    if(strftime(buf, sizeof(buf), format.c_str(), &tr) == 0)
     {
         return std::string();
     }

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #include <IceUtil/UUID.h>
 
@@ -52,7 +47,7 @@ public:
         int p = GetCurrentProcessId();
 #endif
         myPid[0] = (p >> 8) & 0x7F;
-        myPid[1] = p & 0xFF;
+        myPid[1] = static_cast<char>(p & 0xFF);
     }
 };
 
@@ -70,11 +65,11 @@ inline void halfByteToHex(unsigned char hb, char*& hexBuffer)
 {
     if(hb < 10)
     {
-        *hexBuffer++ = '0' + hb;
+        *hexBuffer++ = '0' + static_cast<char>(hb);
     }
     else
     {
-        *hexBuffer++ = 'A' + (hb - 10);
+        *hexBuffer++ = 'A' + static_cast<char>(hb - 10);
     }
 }
 
@@ -148,8 +143,8 @@ IceUtil::generateUUID()
     //
     // Replace the end of the node by myPid (15 bits)
     //
-    uuid.node[4] = (uuid.node[4] & 0x80) | myPid[0];
-    uuid.node[5] = myPid[1];
+    uuid.node[4] = (uuid.node[4] & 0x80) | static_cast<unsigned char>(myPid[0]);
+    uuid.node[5] = static_cast<unsigned char>(myPid[1]);
 
     //
     // Convert to a UUID string

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #include <IceUtil/Config.h>
 

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #ifndef ICE_UTIL_UNICODE_H
 #define ICE_UTIL_UNICODE_H

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #if defined(_MSC_VER) && _MSC_VER >= 1700
 //
@@ -48,7 +43,7 @@
 #       endif
 #   endif
 
-#   if !defined(__sun) && !defined(__FreeBSD__) && !defined(__MINGW32__) && !defined(ICE_STATIC_LIBS)
+#   if !defined(_AIX) && !defined(__sun) && !defined(__FreeBSD__) && !defined(__MINGW32__) && !defined(ICE_STATIC_LIBS)
 #       include <execinfo.h>
 #       include <cxxabi.h>
 #       include <stdint.h>
@@ -56,7 +51,10 @@
 #   endif
 #endif
 
-#if defined(_WIN32) && !defined(ICE_OS_UWP) && !defined(__MINGW32__)
+//
+// The Slice compilers don't retrieve the exception stack traces so we don't need the DbgHelp calls.
+//
+#if defined(_WIN32) && !defined(ICE_OS_UWP) && !defined(__MINGW32__) && !defined(ICE_BUILDING_SLICE_COMPILERS)
 #   define ICE_DBGHELP
 #   if defined(_MSC_VER) && (_MSC_VER >= 1700)
 #       define DBGHELP_TRANSLATE_TCHAR
@@ -114,13 +112,13 @@ HANDLE process = 0;
 backtrace_state* bstate = 0;
 
 void
-ignoreErrorCallback(void*, const char* msg, int errnum)
+ignoreErrorCallback(void*, const char* /*msg*/, int /*errnum*/)
 {
     // cerr << "Error callback: " << msg << ", errnum = " << errnum << endl;
 }
 
 int
-ignoreFrame(void*, uintptr_t pc, const char*, int, const char*)
+ignoreFrame(void*, ICE_MAYBE_UNUSED uintptr_t pc, const char*, int, const char*)
 {
     assert(pc == 0);
     return 0;
@@ -301,7 +299,7 @@ printFrame(void* data, uintptr_t pc, const char* filename, int lineno, const cha
 #ifdef ICE_LIBBACKTRACE
 
 void
-handlePcInfoError(void* data, const char* msg, int errnum)
+handlePcInfoError(void* data, const char* /*msg*/, int /*errnum*/)
 {
     FrameInfo& frameInfo = *reinterpret_cast<FrameInfo*>(data);
     printFrame(&frameInfo, frameInfo.pc, 0, 0, 0);
@@ -352,8 +350,8 @@ getStackFrames()
 #elif defined(ICE_BACKTRACE)
 
     stackFrames.resize(100);
-    size_t stackDepth = backtrace(&stackFrames.front(), stackFrames.size());
-    stackFrames.resize(stackDepth);
+    int stackDepth = backtrace(&stackFrames.front(), static_cast<int>(stackFrames.size()));
+    stackFrames.resize(static_cast<size_t>(stackDepth));
     if(!stackFrames.empty())
     {
         stackFrames.erase(stackFrames.begin()); // drop the first frame
@@ -379,6 +377,7 @@ getStackTrace(const vector<void*>& stackFrames)
     // Note: the Sym functions are not thread-safe
     //
     IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
+    bool refreshModuleList = process != 0;
     if(process == 0)
     {
         process = GetCurrentProcess();
@@ -412,8 +411,10 @@ getStackTrace(const vector<void*>& stackFrames)
 
     lock.acquire();
 
-    // TODO: call SymRefreshModuleList here? (not available on XP)
-
+    if(refreshModuleList && SymRefreshModuleList(process) == 0)
+    {
+        return "No stack trace: SymRefreshModuleList failed with " + IceUtilInternal::errorToString(GetLastError());
+    }
 #ifdef DBGHELP_TRANSLATE_TCHAR
     const IceUtil::StringConverterPtr converter = IceUtil::getProcessStringConverter();
 #endif
@@ -467,7 +468,7 @@ getStackTrace(const vector<void*>& stackFrames)
     // Initialize backtraceStrings immediately
     if(p != stackFrames.end())
     {
-        backtraceStrings = backtrace_symbols(&*p, stackFrames.size());
+        backtraceStrings = backtrace_symbols(&*p, static_cast<int>(stackFrames.size()));
     }
 #   endif
 

data/ext/ice/cpp/src/Slice/CPlusPlusUtil.cpp

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #include <Slice/CPlusPlusUtil.h>
 #include <Slice/Util.h>
@@ -62,7 +57,7 @@ toOptional(const string& s, int typeCtx)
 }
 
 string
-stringTypeToString(const TypePtr& type, const StringList& metaData, int typeCtx)
+stringTypeToString(const TypePtr&, const StringList& metaData, int typeCtx)
 {
     string strType = findMetaData(metaData, typeCtx);
     if(strType == "wstring" || (typeCtx & TypeContextUseWstring && strType == ""))
@@ -124,7 +119,7 @@ sequenceTypeToString(const SequencePtr& seq, const string& scope, const StringLi
             }
             else
             {
-                s = getAbsolute(fixKwd(seq->scoped()), scope);
+                s = getUnqualified(fixKwd(seq->scoped()), scope);
             }
 
             if(typeCtx & TypeContextAMIPrivateEnd)
@@ -145,7 +140,7 @@ sequenceTypeToString(const SequencePtr& seq, const string& scope, const StringLi
     }
     else
     {
-        return getAbsolute(fixKwd(seq->scoped()), scope);
+        return getUnqualified(fixKwd(seq->scoped()), scope);
     }
 }
 
@@ -155,7 +150,7 @@ dictionaryTypeToString(const DictionaryPtr& dict, const string& scope, const Str
     const string dictType = findMetaData(metaData, typeCtx);
     if(dictType.empty())
     {
-        return getAbsolute(fixKwd(dict->scoped()), scope);
+        return getUnqualified(fixKwd(dict->scoped()), scope);
     }
     else
     {
@@ -192,10 +187,10 @@ writeParamAllocateCode(Output& out, const TypePtr& type, bool optional, const st
             seqType = findMetaData(seq->getMetaData(), typeCtx);
         }
 
-        string s;
+        string str;
         if(seqType == "%array")
         {
-            s = typeToString(seq, scope, metaData, TypeContextAMIPrivateEnd);
+            str = typeToString(seq, scope, metaData, TypeContextAMIPrivateEnd);
         }
         else if(seqType.find("%range") == 0)
         {
@@ -204,16 +199,16 @@ writeParamAllocateCode(Output& out, const TypePtr& type, bool optional, const st
             {
                 md.push_back("cpp:type:" + seqType.substr(strlen("%range:")));
             }
-            s = typeToString(seq, scope, md, 0);
+            str = typeToString(seq, scope, md, 0);
         }
 
-        if(!s.empty())
+        if(!str.empty())
         {
             if(optional)
             {
-                s = toOptional(s, typeCtx);
+                str = toOptional(str, typeCtx);
             }
-            out << nl << s << ' ' << fixedName << "_tmp_;";
+            out << nl << str << ' ' << fixedName << "_tmp_;";
         }
     }
 }
@@ -515,14 +510,9 @@ void
 Slice::printHeader(Output& out)
 {
     static const char* header =
-"// **********************************************************************\n"
-"//\n"
-"// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.\n"
 "//\n"
-"// This copy of Ice is licensed to you under the terms described in the\n"
-"// ICE_LICENSE file included in this distribution.\n"
+"// Copyright (c) ZeroC, Inc. All rights reserved.\n"
 "//\n"
-"// **********************************************************************\n"
         ;
 
     out << header;
@@ -537,7 +527,7 @@ Slice::printVersionCheck(Output& out)
     out << "\n";
     out << "\n#ifndef ICE_IGNORE_VERSION";
     int iceVersion = ICE_INT_VERSION; // Use this to prevent warning with C++Builder
-    if(iceVersion % 100 > 50)
+    if(iceVersion % 100 >= 50)
     {
         //
         // Beta version: exact match required
@@ -555,7 +545,7 @@ Slice::printVersionCheck(Output& out)
         //
         // Generated code is release; reject beta header
         //
-        out << "\n#   if ICE_INT_VERSION % 100 > 50";
+        out << "\n#   if ICE_INT_VERSION % 100 >= 50";
         out << "\n#       error Beta header file detected";
         out << "\n#   endif";
 
@@ -610,7 +600,7 @@ Slice::isMovable(const TypePtr& type)
 }
 
 string
-Slice::getAbsolute(const std::string& type, const std::string& scope)
+Slice::getUnqualified(const std::string& type, const std::string& scope)
 {
     if(type.find("::") != string::npos)
     {
@@ -627,7 +617,11 @@ Slice::getAbsolute(const std::string& type, const std::string& scope)
 
         if(type.find(scope, prefix.size()) == prefix.size())
         {
-            return prefix + type.substr(prefix.size() + scope.size());
+            string t = type.substr(prefix.size() + scope.size());
+            if(t.find("::") == string::npos)
+            {
+                return prefix + t;
+            }
         }
     }
     return type;
@@ -695,16 +689,16 @@ Slice::typeToString(const TypePtr& type, const string& scope, const StringList&
         {
             if(builtin->kind() == Builtin::KindObject && !(typeCtx & TypeContextLocal))
             {
-                return getAbsolute(cpp11BuiltinTable[Builtin::KindValue], scope);
+                return getUnqualified(cpp11BuiltinTable[Builtin::KindValue], scope);
             }
             else
             {
-                return getAbsolute(cpp11BuiltinTable[builtin->kind()], scope);
+                return getUnqualified(cpp11BuiltinTable[builtin->kind()], scope);
             }
         }
         else
         {
-            return getAbsolute(builtinTable[builtin->kind()], scope);
+            return getUnqualified(builtinTable[builtin->kind()], scope);
         }
     }
 
@@ -715,20 +709,20 @@ Slice::typeToString(const TypePtr& type, const string& scope, const StringList&
         {
             if(cl->definition() && cl->definition()->isDelegate())
             {
-                return getAbsolute(fixKwd(cl->scoped()), scope);
+                return getUnqualified(fixKwd(cl->scoped()), scope);
             }
             else if(cl->isInterface() && !cl->isLocal())
             {
-                return getAbsolute(cpp11BuiltinTable[Builtin::KindValue], scope);
+                return getUnqualified(cpp11BuiltinTable[Builtin::KindValue], scope);
             }
             else
             {
-                return "::std::shared_ptr<" + getAbsolute(cl->scoped(), scope) + ">";
+                return "::std::shared_ptr<" + getUnqualified(cl->scoped(), scope) + ">";
             }
         }
         else
         {
-            return getAbsolute(cl->scoped() + "Ptr", scope);
+            return getUnqualified(cl->scoped() + "Ptr", scope);
         }
     }
 
@@ -740,11 +734,11 @@ Slice::typeToString(const TypePtr& type, const string& scope, const StringList&
         //
         if(!cpp11 && findMetaData(st->getMetaData()) == "%class")
         {
-            return getAbsolute(fixKwd(st->scoped() + "Ptr"), scope);
+            return getUnqualified(fixKwd(st->scoped() + "Ptr"), scope);
         }
         else
         {
-            return getAbsolute(fixKwd(st->scoped()), scope);
+            return getUnqualified(fixKwd(st->scoped()), scope);
         }
     }
 
@@ -758,25 +752,25 @@ Slice::typeToString(const TypePtr& type, const string& scope, const StringList&
             // Non local classes without operations map to the base
             // proxy class shared_ptr<Ice::ObjectPrx>
             //
-            if(def && !def->isInterface() && def->allOperations().empty())
+            if(!def || def->isAbstract())
             {
-                return getAbsolute(cpp11BuiltinTable[Builtin::KindObjectProxy], scope);
+                return "::std::shared_ptr<" + getUnqualified(fixKwd(proxy->_class()->scoped() + "Prx"), scope) + ">";
             }
             else
             {
-                return "::std::shared_ptr<" + getAbsolute(fixKwd(proxy->_class()->scoped() + "Prx"), scope) + ">";
+                return getUnqualified(cpp11BuiltinTable[Builtin::KindObjectProxy], scope);
             }
         }
         else
         {
-            return getAbsolute(fixKwd(proxy->_class()->scoped() + "Prx"), scope);
+            return getUnqualified(fixKwd(proxy->_class()->scoped() + "Prx"), scope);
         }
     }
 
     EnumPtr en = EnumPtr::dynamicCast(type);
     if(en)
     {
-        return getAbsolute(fixKwd(en->scoped()), scope);
+        return getUnqualified(fixKwd(en->scoped()), scope);
     }
 
     SequencePtr seq = SequencePtr::dynamicCast(type);
@@ -880,16 +874,16 @@ Slice::inputTypeToString(const TypePtr& type, bool optional, const string& scope
         {
             if(builtin->kind() == Builtin::KindObject && !(typeCtx & TypeContextLocal))
             {
-                return getAbsolute(cpp11InputBuiltinTable[Builtin::KindValue], scope);
+                return getUnqualified(cpp11InputBuiltinTable[Builtin::KindValue], scope);
             }
             else
             {
-                return getAbsolute(cpp11InputBuiltinTable[builtin->kind()], scope);
+                return getUnqualified(cpp11InputBuiltinTable[builtin->kind()], scope);
             }
         }
         else
         {
-            return getAbsolute(cpp98InputBuiltinTable[builtin->kind()], scope);
+            return getUnqualified(cpp98InputBuiltinTable[builtin->kind()], scope);
         }
     }
 
@@ -900,20 +894,20 @@ Slice::inputTypeToString(const TypePtr& type, bool optional, const string& scope
         {
             if(cl->definition() && cl->definition()->isDelegate())
             {
-                return getAbsolute(fixKwd(cl->scoped()), scope);
+                return getUnqualified(fixKwd(cl->scoped()), scope);
             }
             else if(cl->isInterface() && !cl->isLocal())
             {
-                return getAbsolute(cpp11InputBuiltinTable[Builtin::KindValue], scope);
+                return getUnqualified(cpp11InputBuiltinTable[Builtin::KindValue], scope);
             }
             else
             {
-                return "const ::std::shared_ptr<" + getAbsolute(fixKwd(cl->scoped()), scope) + ">&";
+                return "const ::std::shared_ptr<" + getUnqualified(fixKwd(cl->scoped()), scope) + ">&";
             }
         }
         else
         {
-            return "const " + getAbsolute(fixKwd(cl->scoped() + "Ptr&"), scope);
+            return "const " + getUnqualified(fixKwd(cl->scoped() + "Ptr&"), scope);
         }
     }
 
@@ -922,17 +916,17 @@ Slice::inputTypeToString(const TypePtr& type, bool optional, const string& scope
     {
         if(cpp11)
         {
-            return "const " + getAbsolute(fixKwd(st->scoped()), scope) + "&";
+            return "const " + getUnqualified(fixKwd(st->scoped()), scope) + "&";
         }
         else
         {
             if(findMetaData(st->getMetaData()) == "%class")
             {
-                return "const " + getAbsolute(fixKwd(st->scoped() + "Ptr"), scope) + "&";
+                return "const " + getUnqualified(fixKwd(st->scoped() + "Ptr"), scope) + "&";
             }
             else
             {
-                return "const " + getAbsolute(fixKwd(st->scoped()), scope) + "&";
+                return "const " + getUnqualified(fixKwd(st->scoped()), scope) + "&";
             }
         }
     }
@@ -945,23 +939,23 @@ Slice::inputTypeToString(const TypePtr& type, bool optional, const string& scope
             ClassDefPtr def = proxy->_class()->definition();
             if(def && !def->isInterface() && def->allOperations().empty())
             {
-                return getAbsolute(cpp11InputBuiltinTable[Builtin::KindObjectProxy], scope);
+                return getUnqualified(cpp11InputBuiltinTable[Builtin::KindObjectProxy], scope);
             }
             else
             {
-                return "const ::std::shared_ptr<" + getAbsolute(fixKwd(proxy->_class()->scoped() + "Prx"), scope) + ">&";
+                return "const ::std::shared_ptr<" + getUnqualified(fixKwd(proxy->_class()->scoped() + "Prx"), scope) + ">&";
             }
         }
         else
         {
-            return "const " + getAbsolute(fixKwd(proxy->_class()->scoped() + "Prx"), scope) + "&";
+            return "const " + getUnqualified(fixKwd(proxy->_class()->scoped() + "Prx"), scope) + "&";
         }
     }
 
     EnumPtr en = EnumPtr::dynamicCast(type);
     if(en)
     {
-        return getAbsolute(fixKwd(en->scoped()), scope);
+        return getUnqualified(fixKwd(en->scoped()), scope);
     }
 
     SequencePtr seq = SequencePtr::dynamicCast(type);
@@ -1033,16 +1027,16 @@ Slice::outputTypeToString(const TypePtr& type, bool optional, const string& scop
         {
             if(builtin->kind() == Builtin::KindObject && !(typeCtx & TypeContextLocal))
             {
-                return getAbsolute(cpp11OutputBuiltinTable[Builtin::KindValue], scope);
+                return getUnqualified(cpp11OutputBuiltinTable[Builtin::KindValue], scope);
             }
             else
             {
-                return getAbsolute(cpp11OutputBuiltinTable[builtin->kind()], scope);
+                return getUnqualified(cpp11OutputBuiltinTable[builtin->kind()], scope);
             }
         }
         else
         {
-            return getAbsolute(outputBuiltinTable[builtin->kind()], scope);
+            return getUnqualified(outputBuiltinTable[builtin->kind()], scope);
         }
     }
 
@@ -1053,20 +1047,20 @@ Slice::outputTypeToString(const TypePtr& type, bool optional, const string& scop
         {
             if(cl->definition() && cl->definition()->isDelegate())
             {
-                return getAbsolute(fixKwd(cl->scoped()), scope) + "&";
+                return getUnqualified(fixKwd(cl->scoped()), scope) + "&";
             }
             else if(cl->isInterface() && !cl->isLocal())
             {
-                return getAbsolute(cpp11OutputBuiltinTable[Builtin::KindValue], scope);
+                return getUnqualified(cpp11OutputBuiltinTable[Builtin::KindValue], scope);
             }
             else
             {
-                return "::std::shared_ptr<" + getAbsolute(fixKwd(cl->scoped()), scope) + ">&";
+                return "::std::shared_ptr<" + getUnqualified(fixKwd(cl->scoped()), scope) + ">&";
             }
         }
         else
         {
-            return getAbsolute(fixKwd(cl->scoped() + "Ptr&"), scope);
+            return getUnqualified(fixKwd(cl->scoped() + "Ptr&"), scope);
         }
     }
 
@@ -1075,11 +1069,11 @@ Slice::outputTypeToString(const TypePtr& type, bool optional, const string& scop
     {
         if(!cpp11 && findMetaData(st->getMetaData()) == "%class")
         {
-            return getAbsolute(fixKwd(st->scoped() + "Ptr&"), scope);
+            return getUnqualified(fixKwd(st->scoped() + "Ptr&"), scope);
         }
         else
         {
-            return getAbsolute(fixKwd(st->scoped()), scope) + "&";
+            return getUnqualified(fixKwd(st->scoped()), scope) + "&";
         }
     }
 
@@ -1095,23 +1089,23 @@ Slice::outputTypeToString(const TypePtr& type, bool optional, const string& scop
             //
             if(def && !def->isInterface() && def->allOperations().empty())
             {
-                return getAbsolute(cpp11OutputBuiltinTable[Builtin::KindObjectProxy], scope);
+                return getUnqualified(cpp11OutputBuiltinTable[Builtin::KindObjectProxy], scope);
             }
             else
             {
-                return "::std::shared_ptr<" + getAbsolute(fixKwd(proxy->_class()->scoped() + "Prx"), scope) + ">&";
+                return "::std::shared_ptr<" + getUnqualified(fixKwd(proxy->_class()->scoped() + "Prx"), scope) + ">&";
             }
         }
         else
         {
-            return getAbsolute(fixKwd(proxy->_class()->scoped() + "Prx&"), scope);
+            return getUnqualified(fixKwd(proxy->_class()->scoped() + "Prx&"), scope);
         }
     }
 
     EnumPtr en = EnumPtr::dynamicCast(type);
     if(en)
     {
-        return getAbsolute(fixKwd(en->scoped()), scope) + "&";
+        return getUnqualified(fixKwd(en->scoped()), scope) + "&";
     }
 
     SequencePtr seq = SequencePtr::dynamicCast(type);
@@ -1202,8 +1196,8 @@ lookupKwd(const string& name)
         "decltype", "default", "delete", "do", "double", "dynamic_cast",
         "else", "enum", "explicit", "export", "extern", "false", "float", "for", "friend",
         "goto", "if", "inline", "int", "long", "mutable", "namespace", "new", "noexcept", "not", "not_eq",
-        "operator", "or", "or_eq", "private", "protected", "public", "register", "reinterpret_cast", "return",
-        "short", "signed", "sizeof", "static", "static_assert", "static_cast", "struct", "switch",
+        "operator", "or", "or_eq", "private", "protected", "public", "register", "reinterpret_cast", "requires",
+        "return", "short", "signed", "sizeof", "static", "static_assert", "static_cast", "struct", "switch",
         "template", "this", "thread_local", "throw", "true", "try", "typedef", "typeid", "typename",
         "union", "unsigned", "using", "virtual", "void", "volatile", "wchar_t", "while", "xor", "xor_eq"
     };
@@ -1263,7 +1257,11 @@ Slice::fixKwd(const string& name)
         return lookupKwd(name);
     }
     StringList ids = splitScopedName(name);
+#ifdef ICE_CPP11_COMPILER
+    transform(ids.begin(), ids.end(), ids.begin(), [](const string& id) -> string { return lookupKwd(id); });
+#else
     transform(ids.begin(), ids.end(), ids.begin(), ptr_fun(lookupKwd));
+#endif
     stringstream result;
     for(StringList::const_iterator i = ids.begin(); i != ids.end(); ++i)
     {
@@ -1502,7 +1500,7 @@ Slice::writeStreamHelpers(Output& out,
                           bool cpp11)
 {
     // If c is a C++11 class/exception whose base class contains data members (recursively), then we need to generate
-    // an StreamWriter even if its implementation is empty. This is becuase our default marsaling uses ice_tuple() which
+    // a StreamWriter even if its implementation is empty. This is because our default marshaling uses ice_tuple() which
     // contains all of our class/exception's data members as well the base data members, which breaks marshaling. This
     // is not an issue for structs.
     if(dataMembers.empty() && !(cpp11 && hasBaseDataMembers))
@@ -1586,7 +1584,7 @@ Slice::writeStreamHelpers(Output& out,
     }
 
     //
-    // Generate StreamWriter
+    // Generate StreamReader
     //
     out << nl << "template<typename S>";
     out << nl << "struct StreamReader" << (cpp11 ? "<" : "< ") << fullName << ", S>";
@@ -1625,9 +1623,13 @@ Slice::writeStreamHelpers(Output& out,
 }
 
 void
-Slice::writeIceTuple(::IceUtilInternal::Output& out, const string& scope, DataMemberList dataMembers, int typeCtx)
+Slice::writeIceTuple(::IceUtilInternal::Output& out, DataMemberList dataMembers, int typeCtx)
 {
-    out << sp << nl << "std::tuple<";
+    //
+    // Use an empty scope to get full qualified names from calls to typeToString.
+    //
+    const string scope = "";
+    out << nl << "std::tuple<";
     for(DataMemberList::const_iterator q = dataMembers.begin(); q != dataMembers.end(); ++q)
     {
         if(q != dataMembers.begin())