zeroc-ice 3.7.1 → 3.7.2

data/ext/ice/cpp/src/IceUtil/MutexProtocol.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/MutexProtocol.h>
 

data/ext/ice/cpp/src/IceUtil/Options.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/Options.h>
 #include <IceUtil/StringUtil.h>
@@ -646,13 +641,20 @@ IceUtilInternal::Options::parse(const StringVector& args)
 
             if(p != string::npos)
             {
-                if(pos->second->arg == NoArg && p != args[i].size() - 1)
+                if(pos->second->arg == NoArg)
                 {
                     string err = "`";
-                    err += args[i];
+                    err += opt;
                     err += "': option does not take an argument";
                     throw BadOptException(__FILE__, __LINE__, err);
                 }
+                else if(pos->second->arg == NeedArg && p == args[i].size() - 1)
+                {
+                    string err = "`";
+                    err += opt;
+                    err += "': option requires an argument";
+                    throw BadOptException(__FILE__, __LINE__, err);
+                }
                 setOpt(opt, "", args[i].substr(p + 1), pos->second->repeat);
                 argDone = true;
             }
@@ -685,12 +687,20 @@ IceUtilInternal::Options::parse(const StringVector& args)
                     }
                 }
 
-                if(pos->second->arg == NeedArg && p != args[i].size() - 1)
+                if(pos->second->arg == NeedArg)
+                {
+                    if(p != args[i].size() - 1)
+                    {
+                        string optArg = args[i].substr(p + 1);
+                        setOpt(opt, "", optArg, pos->second->repeat);
+                        argDone = true;
+                        break;
+                    }
+                }
+                else
                 {
-                    string optArg = args[i].substr(p + 1);
-                    setOpt(opt, "", optArg, pos->second->repeat);
+                    setOpt(opt, "", "1", pos->second->repeat);
                     argDone = true;
-                    break;
                 }
             }
         }

data/ext/ice/cpp/src/IceUtil/OutputUtil.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/OutputUtil.h>
 #include <IceUtil/FileUtil.h>

data/ext/ice/cpp/src/IceUtil/Random.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.
-//
-// **********************************************************************
 
 #ifdef _WIN32
 #  define _CRT_RAND_S

data/ext/ice/cpp/src/IceUtil/RecMutex.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/RecMutex.h>
 #include <IceUtil/Exception.h>
@@ -113,7 +108,7 @@ IceUtil::RecMutex::lock(LockState& state) const
 #else
 
 void
-IceUtil::RecMutex::init(const MutexProtocol protocol)
+IceUtil::RecMutex::init(ICE_MAYBE_UNUSED const MutexProtocol protocol)
 {
     int rc;
     pthread_mutexattr_t attr;

data/ext/ice/cpp/src/IceUtil/Shared.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/Shared.h>
 

data/ext/ice/cpp/src/IceUtil/StringConverter.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/StringConverter.h>
 #include <IceUtil/MutexPtrLock.h>

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;
@@ -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>

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>
 

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
 //
@@ -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);
@@ -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

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;
@@ -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);
         }
     }
 
@@ -760,23 +754,23 @@ Slice::typeToString(const TypePtr& type, const string& scope, const StringList&
             //
             if(def && !def->isInterface() && def->allOperations().empty())
             {
-                return getAbsolute(cpp11BuiltinTable[Builtin::KindObjectProxy], scope);
+                return getUnqualified(cpp11BuiltinTable[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);
@@ -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);