zeroc-ice 3.6.5 → 3.7.4

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>
@@ -43,19 +38,31 @@ string toTemplateArg(const string& arg)
 }
 
 string
-stringTypeToString(const TypePtr& type, const StringList& metaData, int typeCtx)
+toOptional(const string& s, int typeCtx)
+{
+    bool cpp11 = (typeCtx & TypeContextCpp11) != 0;
+    string result = cpp11 ? "Ice::optional" : "IceUtil::Optional";
+    result += '<';
+    if(cpp11)
+    {
+        result += s;
+    }
+    else
+    {
+        result += toTemplateArg(s);
+    }
+
+    result += '>';
+    return result;
+}
+
+string
+stringTypeToString(const TypePtr&, const StringList& metaData, int typeCtx)
 {
     string strType = findMetaData(metaData, typeCtx);
     if(strType == "wstring" || (typeCtx & TypeContextUseWstring && strType == ""))
     {
-        if(featureProfile == IceE)
-        {
-            return "::Ice::Wstring";
-        }
-        else
-        {
-            return "::std::wstring";
-        }
+        return "::std::wstring";
     }
     else if(strType != "" && strType != "string")
     {
@@ -68,7 +75,7 @@ stringTypeToString(const TypePtr& type, const StringList& metaData, int typeCtx)
 }
 
 string
-sequenceTypeToString(const SequencePtr& seq, const StringList& metaData, int typeCtx)
+sequenceTypeToString(const SequencePtr& seq, const string& scope, const StringList& metaData, int typeCtx)
 {
     string seqType = findMetaData(metaData, typeCtx);
     if(!seqType.empty())
@@ -80,7 +87,7 @@ sequenceTypeToString(const SequencePtr& seq, const StringList& metaData, int typ
             {
                 if(builtin && builtin->kind() == Builtin::KindByte)
                 {
-                    string s = typeToString(seq->type());
+                    string s = typeToString(seq->type(), scope);
                     return "::std::pair<const " + s + "*, const " + s + "*>";
                 }
                 else if(builtin &&
@@ -88,18 +95,19 @@ sequenceTypeToString(const SequencePtr& seq, const StringList& metaData, int typ
                         builtin->kind() != Builtin::KindObject &&
                         builtin->kind() != Builtin::KindObjectProxy)
                 {
-                    string s = toTemplateArg(typeToString(builtin));
+                    string s = toTemplateArg(typeToString(builtin, scope));
                     return "::std::pair< ::IceUtil::ScopedArray<" + s + ">, " +
                         "::std::pair<const " + s + "*, const " + s + "*> >";
                 }
                 else
                 {
-                    string s = toTemplateArg(typeToString(seq->type(), seq->typeMetaData(),
+                    string s = toTemplateArg(typeToString(seq->type(), scope, seq->typeMetaData(),
                                                           inWstringModule(seq) ? TypeContextUseWstring : 0));
                     return "::std::vector<" + s + '>';
                 }
             }
-            string s = typeToString(seq->type(), seq->typeMetaData(), inWstringModule(seq) ? TypeContextUseWstring : 0);
+            string s = typeToString(seq->type(), scope, seq->typeMetaData(),
+                                    typeCtx | (inWstringModule(seq) ? TypeContextUseWstring : 0));
             return "::std::pair<const " + s + "*, const " + s + "*>";
         }
         else if(seqType.find("%range") == 0)
@@ -111,12 +119,14 @@ sequenceTypeToString(const SequencePtr& seq, const StringList& metaData, int typ
             }
             else
             {
-                s = fixKwd(seq->scoped());
+                s = getUnqualified(fixKwd(seq->scoped()), scope);
             }
+
             if(typeCtx & TypeContextAMIPrivateEnd)
             {
                 return s;
             }
+
             if(s[0] == ':')
             {
                 s = " " + s;
@@ -130,37 +140,36 @@ sequenceTypeToString(const SequencePtr& seq, const StringList& metaData, int typ
     }
     else
     {
-        return fixKwd(seq->scoped());
+        return getUnqualified(fixKwd(seq->scoped()), scope);
     }
 }
 
 string
-dictionaryTypeToString(const DictionaryPtr& dict, const StringList& metaData, int typeCtx)
+dictionaryTypeToString(const DictionaryPtr& dict, const string& scope, const StringList& metaData, int typeCtx)
 {
-    string dictType = findMetaData(metaData, typeCtx);
-    if(!dictType.empty())
+    const string dictType = findMetaData(metaData, typeCtx);
+    if(dictType.empty())
     {
-        return dictType;
+        return getUnqualified(fixKwd(dict->scoped()), scope);
     }
     else
     {
-        return fixKwd(dict->scoped());
+        return dictType;
     }
 }
 
-
 void
-writeParamAllocateCode(Output& out, const TypePtr& type, bool optional, const string& fixedName,
+writeParamAllocateCode(Output& out, const TypePtr& type, bool optional, const string& scope, const string& fixedName,
                        const StringList& metaData, int typeCtx, bool endArg)
 {
-    string s = typeToString(type, metaData, typeCtx);
+    string s = typeToString(type, scope, metaData, typeCtx);
     if(optional)
     {
-        s = "IceUtil::Optional<" + toTemplateArg(s) + '>';
+        s = toOptional(s, typeCtx);
     }
     out << nl << s << ' ' << fixedName << ';';
 
-    if(!(typeCtx & TypeContextInParam) || !endArg)
+    if((typeCtx & TypeContextCpp11) || !(typeCtx & TypeContextInParam) || !endArg)
     {
         return; // We're done.
     }
@@ -178,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, metaData, TypeContextAMIPrivateEnd);
+            str = typeToString(seq, scope, metaData, TypeContextAMIPrivateEnd);
         }
         else if(seqType.find("%range") == 0)
         {
@@ -190,23 +199,28 @@ writeParamAllocateCode(Output& out, const TypePtr& type, bool optional, const st
             {
                 md.push_back("cpp:type:" + seqType.substr(strlen("%range:")));
             }
-            s = typeToString(seq, md);
+            str = typeToString(seq, scope, md, 0);
         }
 
-        if(!s.empty())
+        if(!str.empty())
         {
             if(optional)
             {
-                s = "IceUtil::Optional<" + toTemplateArg(s) + '>';
+                str = toOptional(str, typeCtx);
             }
-            out << nl << s << " ___" << fixedName << ";";
+            out << nl << str << ' ' << fixedName << "_tmp_;";
         }
     }
 }
 
 void
-writeParamEndCode(Output& out, const TypePtr& type, bool optional, const string& fixedName, const StringList& metaData)
+writeParamEndCode(Output& out, const TypePtr& type, bool optional, const string& fixedName, const StringList& metaData,
+                  const string& obj = "")
 {
+    string objPrefix = obj.empty() ? obj : obj + ".";
+    string paramName = objPrefix + fixedName;
+    string escapedParamName = objPrefix + fixedName + "_tmp_";
+
     SequencePtr seq = SequencePtr::dynamicCast(type);
     if(seq)
     {
@@ -227,14 +241,14 @@ writeParamEndCode(Output& out, const TypePtr& type, bool optional, const string&
             {
                 if(optional)
                 {
-                    out << nl << "if(___" << fixedName << ")";
+                    out << nl << "if(" << escapedParamName << ")";
                     out << sb;
-                    out << nl << fixedName << " = ___" << fixedName << "->second;";
-                        out << eb;
+                    out << nl << paramName << " = " << escapedParamName << "->second;";
+                    out << eb;
                 }
                 else
                 {
-                    out << nl << fixedName << " = ___" << fixedName << ".second;";
+                    out << nl << paramName << " = " << escapedParamName << ".second;";
                 }
             }
             else if(!builtin ||
@@ -244,32 +258,32 @@ writeParamEndCode(Output& out, const TypePtr& type, bool optional, const string&
             {
                 if(optional)
                 {
-                    out << nl << "if(___" << fixedName << ")";
+                    out << nl << "if(" << escapedParamName << ")";
                     out << sb;
-                    out << nl << fixedName << ".__setIsSet();";
-                    out << nl << "if(!___" << fixedName << "->empty())";
+                    out << nl << paramName << ".__setIsSet();";
+                    out << nl << "if(!" << escapedParamName << "->empty())";
                     out << sb;
-                    out << nl << fixedName << "->first" << " = &(*___" << fixedName << ")[0];";
-                    out << nl << fixedName << "->second" << " = " << fixedName << "->first + " << "___"
-                        << fixedName << "->size();";
+                    out << nl << paramName << "->first" << " = &(*" << escapedParamName << ")[0];";
+                    out << nl << paramName << "->second" << " = " << paramName << "->first + " << escapedParamName
+                        << "->size();";
                     out << eb;
                     out << nl << "else";
                     out << sb;
-                    out << nl << fixedName << "->first" << " = " << fixedName << "->second" << " = 0;";
+                    out << nl << paramName << "->first" << " = " << paramName << "->second" << " = 0;";
                     out << eb;
                     out << eb;
                 }
                 else
                 {
-                    out << nl << "if(!___" << fixedName << ".empty())";
+                    out << nl << "if(!" << escapedParamName << ".empty())";
                     out << sb;
-                    out << nl << fixedName << ".first" << " = &___" << fixedName << "[0];";
-                    out << nl << fixedName << ".second" << " = " << fixedName << ".first + " << "___"
-                        << fixedName << ".size();";
+                    out << nl << paramName << ".first" << " = &" << escapedParamName << "[0];";
+                    out << nl << paramName << ".second" << " = " << paramName << ".first + " << escapedParamName
+                        << ".size();";
                     out << eb;
                     out << nl << "else";
                     out << sb;
-                    out << nl << fixedName << ".first" << " = " << fixedName << ".second" << " = 0;";
+                    out << nl << paramName << ".first" << " = " << paramName << ".second" << " = 0;";
                     out << eb;
                 }
             }
@@ -278,30 +292,43 @@ writeParamEndCode(Output& out, const TypePtr& type, bool optional, const string&
         {
             if(optional)
             {
-                out << nl << "if(___" << fixedName << ")";
+                out << nl << "if(" << escapedParamName << ")";
                 out << sb;
-                out << nl << fixedName << ".__setIsSet();";
-                out << nl << fixedName << "->first = (*___" << fixedName << ").begin();";
-                out << nl << fixedName << "->second = (*___" << fixedName << ").end();";
+                out << nl << paramName << ".__setIsSet();";
+                out << nl << paramName << "->first = (*" << escapedParamName << ").begin();";
+                out << nl << paramName << "->second = (*" << escapedParamName << ").end();";
                 out << eb;
             }
             else
             {
-                out << nl << fixedName << ".first = ___" << fixedName << ".begin();";
-                out << nl << fixedName << ".second = ___" << fixedName << ".end();";
+                out << nl << paramName << ".first = " << escapedParamName << ".begin();";
+                out << nl << paramName << ".second = " << escapedParamName << ".end();";
             }
         }
     }
 }
 
 void
-writeMarshalUnmarshalParams(Output& out, const ParamDeclList& params, const OperationPtr& op, bool marshal, bool prepend, int typeCtx)
+writeMarshalUnmarshalParams(Output& out, const ParamDeclList& params, const OperationPtr& op, bool marshal,
+                            bool prepend, int typeCtx, const string& customStream = "", const string& retP = "",
+                            const string& obj = "")
 {
     string prefix = prepend ? paramPrefix : "";
+    string returnValueS = retP.empty() ? string("ret") : retP;
+    string objPrefix = obj.empty() ? obj : obj + ".";
+
+    string stream = customStream;
+    if(stream.empty())
+    {
+        stream = marshal ? "ostr" : "istr";
+    }
+
+    bool cpp11 = (typeCtx & TypeContextCpp11) != 0;
 
     //
     // Marshal non optional parameters.
     //
+    ParamDeclList requiredParams;
     ParamDeclList optionals;
     for(ParamDeclList::const_iterator p = params.begin(); p != params.end(); ++p)
     {
@@ -311,57 +338,160 @@ writeMarshalUnmarshalParams(Output& out, const ParamDeclList& params, const Oper
         }
         else
         {
-            writeMarshalUnmarshalCode(out, (*p)->type(), false, 0, fixKwd(prefix + (*p)->name()), marshal, (*p)->getMetaData(),
-                                      typeCtx);
+            requiredParams.push_back(*p);
         }
     }
-    if(op && op->returnType())
+
+    if(!requiredParams.empty() || (op && op->returnType() && !op->returnIsOptional()))
     {
-        if(!op->returnIsOptional())
+        if(cpp11)
+        {
+            out << nl;
+            if(marshal)
+            {
+                out << stream << "->writeAll";
+            }
+            else
+            {
+                out << stream << "->readAll";
+            }
+            out << spar;
+            for(ParamDeclList::const_iterator p = requiredParams.begin(); p != requiredParams.end(); ++p)
+            {
+                out << objPrefix + fixKwd(prefix + (*p)->name());
+            }
+            if(op && op->returnType() && !op->returnIsOptional())
+            {
+                out << objPrefix + returnValueS;
+            }
+            out << epar << ";";
+        }
+        else
         {
-            writeMarshalUnmarshalCode(out, op->returnType(), false, 0, "__ret", marshal, op->getMetaData(), typeCtx);
+            for(ParamDeclList::const_iterator p = requiredParams.begin(); p != requiredParams.end(); ++p)
+            {
+                writeMarshalUnmarshalCode(out, (*p)->type(), false, 0, fixKwd(prefix + (*p)->name()), marshal,
+                                          (*p)->getMetaData(), typeCtx, customStream, true, obj);
+            }
+
+            if(op && op->returnType())
+            {
+                if(!op->returnIsOptional())
+                {
+                    writeMarshalUnmarshalCode(out, op->returnType(), false, 0, returnValueS, marshal, op->getMetaData(),
+                                              typeCtx, customStream, true, obj);
+                }
+            }
         }
     }
 
-    //
-    // Sort optional parameters by tag.
-    //
-    class SortFn
+    if(!optionals.empty() || (op && op->returnType() && op->returnIsOptional()))
     {
-    public:
-        static bool compare(const ParamDeclPtr& lhs, const ParamDeclPtr& rhs)
+        //
+        // Sort optional parameters by tag.
+        //
+        class SortFn
         {
-            return lhs->tag() < rhs->tag();
-        }
-    };
-    optionals.sort(SortFn::compare);
+        public:
+            static bool compare(const ParamDeclPtr& lhs, const ParamDeclPtr& rhs)
+            {
+                return lhs->tag() < rhs->tag();
+            }
+        };
+        optionals.sort(SortFn::compare);
 
-    //
-    // Marshal optional parameters.
-    //
-    bool checkReturnType = op && op->returnIsOptional();
-    for(ParamDeclList::const_iterator p = optionals.begin(); p != optionals.end(); ++p)
-    {
-        if(checkReturnType && op->returnTag() < (*p)->tag())
+        if(cpp11)
         {
-            writeMarshalUnmarshalCode(out, op->returnType(), true, op->returnTag(), "__ret", marshal,
-                                      op->getMetaData(), typeCtx);
-            checkReturnType = false;
+            out << nl;
+            if(marshal)
+            {
+                out << stream << "->writeAll";
+            }
+            else
+            {
+                out << stream << "->readAll";
+            }
+            out << spar;
+
+            {
+                //
+                // Tags
+                //
+                ostringstream os;
+                os << '{';
+                bool checkReturnType = op && op->returnIsOptional();
+                bool insertComma = false;
+                for(ParamDeclList::const_iterator p = optionals.begin(); p != optionals.end(); ++p)
+                {
+                    if(checkReturnType && op->returnTag() < (*p)->tag())
+                    {
+                        os << (insertComma ? ", " : "") << op->returnTag();
+                        checkReturnType = false;
+                        insertComma = true;
+                    }
+                    os << (insertComma ? ", " : "") << (*p)->tag();
+                    insertComma = true;
+                }
+                if(checkReturnType)
+                {
+                    os << (insertComma ? ", " : "") << op->returnTag();
+                }
+                os << '}';
+                out << os.str();
+            }
+
+            {
+                //
+                // Parameters
+                //
+                bool checkReturnType = op && op->returnIsOptional();
+                for(ParamDeclList::const_iterator p = optionals.begin(); p != optionals.end(); ++p)
+                {
+                    if(checkReturnType && op->returnTag() < (*p)->tag())
+                    {
+                        out << objPrefix + returnValueS;
+                        checkReturnType = false;
+                    }
+                    out << objPrefix + fixKwd(prefix + (*p)->name());
+                }
+                if(checkReturnType)
+                {
+                    out << objPrefix + returnValueS;
+                }
+            }
+            out << epar << ";";
+        }
+        else
+        {
+
+            //
+            // Marshal optional parameters.
+            //
+
+            bool checkReturnType = op && op->returnIsOptional();
+            for(ParamDeclList::const_iterator p = optionals.begin(); p != optionals.end(); ++p)
+            {
+                if(checkReturnType && op->returnTag() < (*p)->tag())
+                {
+                    writeMarshalUnmarshalCode(out, op->returnType(), true, op->returnTag(), returnValueS, marshal,
+                                              op->getMetaData(), typeCtx, customStream, true, obj);
+
+                    checkReturnType = false;
+                }
+                writeMarshalUnmarshalCode(out, (*p)->type(), true, (*p)->tag(), fixKwd(prefix + (*p)->name()), marshal,
+                                          (*p)->getMetaData(), typeCtx, customStream, true, obj);
+            }
+            if(checkReturnType)
+            {
+                writeMarshalUnmarshalCode(out, op->returnType(), true, op->returnTag(), returnValueS, marshal,
+                                          op->getMetaData(), typeCtx, customStream, true, obj);
+            }
         }
-        writeMarshalUnmarshalCode(out, (*p)->type(), true, (*p)->tag(), fixKwd(prefix + (*p)->name()), marshal,
-                                  (*p)->getMetaData(), typeCtx);
-    }
-    if(checkReturnType)
-    {
-        writeMarshalUnmarshalCode(out, op->returnType(), true, op->returnTag(), "__ret", marshal, op->getMetaData(),
-                                  typeCtx);
     }
 }
-
 }
 
-Slice::FeatureProfile Slice::featureProfile = Slice::Ice;
-string Slice::paramPrefix = "__p_";
+string Slice::paramPrefix = "iceP_";
 
 char
 Slice::ToIfdef::operator()(char c)
@@ -376,19 +506,13 @@ Slice::ToIfdef::operator()(char c)
     }
 }
 
-
 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;
@@ -403,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
@@ -421,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";
 
@@ -439,10 +563,10 @@ Slice::printDllExportStuff(Output& out, const string& dllExport)
     {
         out << sp;
         out << "\n#ifndef " << dllExport;
-        out << "\n#   ifdef " << dllExport << "_EXPORTS";
-        out << "\n#       define " << dllExport << " ICE_DECLSPEC_EXPORT";
-        out << "\n#   elif defined(ICE_STATIC_LIBS)";
+        out << "\n#   if defined(ICE_STATIC_LIBS)";
         out << "\n#       define " << dllExport << " /**/";
+        out << "\n#   elif defined(" << dllExport << "_EXPORTS)";
+        out << "\n#       define " << dllExport << " ICE_DECLSPEC_EXPORT";
         out << "\n#   else";
         out << "\n#       define " << dllExport << " ICE_DECLSPEC_IMPORT";
         out << "\n#   endif";
@@ -450,10 +574,64 @@ Slice::printDllExportStuff(Output& out, const string& dllExport)
     }
 }
 
+bool
+Slice::isMovable(const TypePtr& type)
+{
+    BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
+    if(builtin)
+    {
+        switch(builtin->kind())
+        {
+            case Builtin::KindString:
+            case Builtin::KindObject:
+            case Builtin::KindObjectProxy:
+            case Builtin::KindLocalObject:
+            case Builtin::KindValue:
+            {
+                return true;
+            }
+            default:
+            {
+                return false;
+            }
+        }
+    }
+    return !EnumPtr::dynamicCast(type);
+}
+
+string
+Slice::getUnqualified(const std::string& type, const std::string& scope)
+{
+    if(type.find("::") != string::npos)
+    {
+        string prefix;
+        if(type.find("const ") == 0)
+        {
+            prefix += "const ";
+        }
+
+        if(type.find("::std::shared_ptr<", prefix.size()) == prefix.size())
+        {
+            prefix += "::std::shared_ptr<";
+        }
+
+        if(type.find(scope, prefix.size()) == prefix.size())
+        {
+            string t = type.substr(prefix.size() + scope.size());
+            if(t.find("::") == string::npos)
+            {
+                return prefix + t;
+            }
+        }
+    }
+    return type;
+}
 
 string
-Slice::typeToString(const TypePtr& type, const StringList& metaData, int typeCtx)
+Slice::typeToString(const TypePtr& type, const string& scope, const StringList& metaData, int typeCtx)
 {
+    bool cpp11 = (typeCtx & TypeContextCpp11) != 0;
+
     static const char* builtinTable[] =
     {
         "::Ice::Byte",
@@ -466,9 +644,40 @@ Slice::typeToString(const TypePtr& type, const StringList& metaData, int typeCtx
         "::std::string",
         "::Ice::ObjectPtr",
         "::Ice::ObjectPrx",
-        "::Ice::LocalObjectPtr"
+        "::Ice::LocalObjectPtr",
+        "::Ice::ValuePtr"
     };
 
+    static const char* cpp11BuiltinTable[] =
+    {
+        "::Ice::Byte",
+        "bool",
+        "short",
+        "int",
+        "long long int",
+        "float",
+        "double",
+        "::std::string",
+        "::std::shared_ptr<::Ice::Object>",
+        "::std::shared_ptr<::Ice::ObjectPrx>",
+        "::std::shared_ptr<void>",
+        "::std::shared_ptr<::Ice::Value>"
+    };
+
+    if((typeCtx & TypeContextLocal) != 0)
+    {
+        for(StringList::const_iterator i = metaData.begin(); i != metaData.end(); ++i)
+        {
+            const string cppType = "cpp:type:";
+            const string meta = *i;
+
+            if(meta.find(cppType) == 0)
+            {
+                return meta.substr(cppType.size());
+            }
+        }
+    }
+
     BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
     if(builtin)
     {
@@ -476,76 +685,125 @@ Slice::typeToString(const TypePtr& type, const StringList& metaData, int typeCtx
         {
             return stringTypeToString(type, metaData, typeCtx);
         }
+        else if(cpp11)
+        {
+            if(builtin->kind() == Builtin::KindObject && !(typeCtx & TypeContextLocal))
+            {
+                return getUnqualified(cpp11BuiltinTable[Builtin::KindValue], scope);
+            }
+            else
+            {
+                return getUnqualified(cpp11BuiltinTable[builtin->kind()], scope);
+            }
+        }
         else
         {
-            return builtinTable[builtin->kind()];
+            return getUnqualified(builtinTable[builtin->kind()], scope);
         }
     }
 
     ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
     if(cl)
     {
-        return fixKwd(cl->scoped() + "Ptr");
+        if(cpp11)
+        {
+            if(cl->definition() && cl->definition()->isDelegate())
+            {
+                return getUnqualified(fixKwd(cl->scoped()), scope);
+            }
+            else if(cl->isInterface() && !cl->isLocal())
+            {
+                return getUnqualified(cpp11BuiltinTable[Builtin::KindValue], scope);
+            }
+            else
+            {
+                return "::std::shared_ptr<" + getUnqualified(cl->scoped(), scope) + ">";
+            }
+        }
+        else
+        {
+            return getUnqualified(cl->scoped() + "Ptr", scope);
+        }
     }
 
     StructPtr st = StructPtr::dynamicCast(type);
     if(st)
     {
-        if(findMetaData(st->getMetaData()) == "%class")
+        //
+        // C++11 mapping doesn't accept cpp:class metadata
+        //
+        if(!cpp11 && findMetaData(st->getMetaData()) == "%class")
+        {
+            return getUnqualified(fixKwd(st->scoped() + "Ptr"), scope);
+        }
+        else
         {
-            return fixKwd(st->scoped() + "Ptr");
+            return getUnqualified(fixKwd(st->scoped()), scope);
         }
-        return fixKwd(st->scoped());
     }
 
     ProxyPtr proxy = ProxyPtr::dynamicCast(type);
     if(proxy)
     {
-        return fixKwd(proxy->_class()->scoped() + "Prx");
+        if(cpp11)
+        {
+            ClassDefPtr def = proxy->_class()->definition();
+            //
+            // Non local classes without operations map to the base
+            // proxy class shared_ptr<Ice::ObjectPrx>
+            //
+            if(!def || def->isAbstract())
+            {
+                return "::std::shared_ptr<" + getUnqualified(fixKwd(proxy->_class()->scoped() + "Prx"), scope) + ">";
+            }
+            else
+            {
+                return getUnqualified(cpp11BuiltinTable[Builtin::KindObjectProxy], scope);
+            }
+        }
+        else
+        {
+            return getUnqualified(fixKwd(proxy->_class()->scoped() + "Prx"), scope);
+        }
+    }
+
+    EnumPtr en = EnumPtr::dynamicCast(type);
+    if(en)
+    {
+        return getUnqualified(fixKwd(en->scoped()), scope);
     }
 
     SequencePtr seq = SequencePtr::dynamicCast(type);
     if(seq)
     {
-        return sequenceTypeToString(seq, metaData, typeCtx);
+        return sequenceTypeToString(seq, scope, metaData, typeCtx);
     }
 
     DictionaryPtr dict = DictionaryPtr::dynamicCast(type);
     if(dict)
     {
-        return dictionaryTypeToString(dict, metaData, typeCtx);
-    }
-
-    ContainedPtr contained = ContainedPtr::dynamicCast(type);
-    if(contained)
-    {
-        return fixKwd(contained->scoped());
-    }
-
-    EnumPtr en = EnumPtr::dynamicCast(type);
-    if(en)
-    {
-        return fixKwd(en->scoped());
+        return dictionaryTypeToString(dict, scope, metaData, typeCtx);
     }
 
     return "???";
 }
 
 string
-Slice::typeToString(const TypePtr& type, bool optional, const StringList& metaData, int typeCtx)
+Slice::typeToString(const TypePtr& type, bool optional, const string& scope, const StringList& metaData, int typeCtx)
 {
     if(optional)
     {
-        return "IceUtil::Optional<" + toTemplateArg(typeToString(type, metaData, typeCtx)) + ">";
+        return toOptional(typeToString(type, scope, metaData, typeCtx), typeCtx);
     }
     else
     {
-        return typeToString(type, metaData, typeCtx);
+        return typeToString(type, scope, metaData, typeCtx);
     }
 }
 
 string
-Slice::returnTypeToString(const TypePtr& type, bool optional, const StringList& metaData, int typeCtx)
+Slice::returnTypeToString(const TypePtr& type, bool optional, const string& scope, const StringList& metaData,
+                          int typeCtx)
 {
     if(!type)
     {
@@ -554,16 +812,19 @@ Slice::returnTypeToString(const TypePtr& type, bool optional, const StringList&
 
     if(optional)
     {
-        return "IceUtil::Optional<" + toTemplateArg(typeToString(type, metaData, typeCtx)) + ">";
+        return toOptional(typeToString(type, scope, metaData, typeCtx), typeCtx);
     }
 
-    return typeToString(type, metaData, typeCtx);
+    return typeToString(type, scope, metaData, typeCtx);
 }
 
 string
-Slice::inputTypeToString(const TypePtr& type, bool optional, const StringList& metaData, int typeCtx)
+Slice::inputTypeToString(const TypePtr& type, bool optional, const string& scope, const StringList& metaData,
+                         int typeCtx)
 {
-    static const char* inputBuiltinTable[] =
+    bool cpp11 = (typeCtx & TypeContextCpp11) != 0;
+
+    static const char* cpp98InputBuiltinTable[] =
     {
         "::Ice::Byte",
         "bool",
@@ -575,14 +836,31 @@ Slice::inputTypeToString(const TypePtr& type, bool optional, const StringList& m
         "const ::std::string&",
         "const ::Ice::ObjectPtr&",
         "const ::Ice::ObjectPrx&",
-        "const ::Ice::LocalObjectPtr&"
+        "const ::Ice::LocalObjectPtr&",
+        "const ::Ice::ValuePtr&"
+    };
+
+    static const char* cpp11InputBuiltinTable[] =
+    {
+        "::Ice::Byte",
+        "bool",
+        "short",
+        "int",
+        "long long int",
+        "float",
+        "double",
+        "const ::std::string&",
+        "const ::std::shared_ptr<::Ice::Object>&",
+        "const ::std::shared_ptr<::Ice::ObjectPrx>&",
+        "const ::std::shared_ptr<void>&",
+        "const ::std::shared_ptr<::Ice::Value>&"
     };
 
     typeCtx |= TypeContextInParam;
 
     if(optional)
     {
-        return "const IceUtil::Optional<" + toTemplateArg(typeToString(type, metaData, typeCtx)) +">&";
+        return "const " + toOptional(typeToString(type, scope, metaData, typeCtx), typeCtx) + '&';
     }
 
     BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
@@ -590,66 +868,117 @@ Slice::inputTypeToString(const TypePtr& type, bool optional, const StringList& m
     {
         if(builtin->kind() == Builtin::KindString)
         {
-            return string("const ") + stringTypeToString(type, metaData, typeCtx) + "&";
+            return string("const ") + stringTypeToString(type, metaData, typeCtx) + '&';
+        }
+        else if(cpp11)
+        {
+            if(builtin->kind() == Builtin::KindObject && !(typeCtx & TypeContextLocal))
+            {
+                return getUnqualified(cpp11InputBuiltinTable[Builtin::KindValue], scope);
+            }
+            else
+            {
+                return getUnqualified(cpp11InputBuiltinTable[builtin->kind()], scope);
+            }
         }
         else
         {
-            return inputBuiltinTable[builtin->kind()];
+            return getUnqualified(cpp98InputBuiltinTable[builtin->kind()], scope);
         }
     }
 
     ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
     if(cl)
     {
-        return "const " + fixKwd(cl->scoped() + "Ptr&");
+        if(cpp11)
+        {
+            if(cl->definition() && cl->definition()->isDelegate())
+            {
+                return getUnqualified(fixKwd(cl->scoped()), scope);
+            }
+            else if(cl->isInterface() && !cl->isLocal())
+            {
+                return getUnqualified(cpp11InputBuiltinTable[Builtin::KindValue], scope);
+            }
+            else
+            {
+                return "const ::std::shared_ptr<" + getUnqualified(fixKwd(cl->scoped()), scope) + ">&";
+            }
+        }
+        else
+        {
+            return "const " + getUnqualified(fixKwd(cl->scoped() + "Ptr&"), scope);
+        }
     }
 
     StructPtr st = StructPtr::dynamicCast(type);
     if(st)
     {
-        if(findMetaData(st->getMetaData()) == "%class")
+        if(cpp11)
+        {
+            return "const " + getUnqualified(fixKwd(st->scoped()), scope) + "&";
+        }
+        else
         {
-            return "const " + fixKwd(st->scoped() + "Ptr&");
+            if(findMetaData(st->getMetaData()) == "%class")
+            {
+                return "const " + getUnqualified(fixKwd(st->scoped() + "Ptr"), scope) + "&";
+            }
+            else
+            {
+                return "const " + getUnqualified(fixKwd(st->scoped()), scope) + "&";
+            }
         }
-        return "const " + fixKwd(st->scoped()) + "&";
     }
 
     ProxyPtr proxy = ProxyPtr::dynamicCast(type);
     if(proxy)
     {
-        return "const " + fixKwd(proxy->_class()->scoped() + "Prx&");
+        if(cpp11)
+        {
+            ClassDefPtr def = proxy->_class()->definition();
+            if(def && !def->isInterface() && def->allOperations().empty())
+            {
+                return getUnqualified(cpp11InputBuiltinTable[Builtin::KindObjectProxy], scope);
+            }
+            else
+            {
+                return "const ::std::shared_ptr<" + getUnqualified(fixKwd(proxy->_class()->scoped() + "Prx"), scope) + ">&";
+            }
+        }
+        else
+        {
+            return "const " + getUnqualified(fixKwd(proxy->_class()->scoped() + "Prx"), scope) + "&";
+        }
     }
 
     EnumPtr en = EnumPtr::dynamicCast(type);
     if(en)
     {
-        return fixKwd(en->scoped());
+        return getUnqualified(fixKwd(en->scoped()), scope);
     }
 
     SequencePtr seq = SequencePtr::dynamicCast(type);
     if(seq)
     {
-        return "const " + sequenceTypeToString(seq, metaData, typeCtx) + "&";
+        return "const " + sequenceTypeToString(seq, scope, metaData, typeCtx) + "&";
     }
 
     DictionaryPtr dict = DictionaryPtr::dynamicCast(type);
     if(dict)
     {
-        return "const " + dictionaryTypeToString(dict, metaData, typeCtx) + "&";
-    }
-
-    ContainedPtr contained = ContainedPtr::dynamicCast(type);
-    if(contained)
-    {
-        return "const " + fixKwd(contained->scoped()) + "&";
+        return "const " + dictionaryTypeToString(dict, scope, metaData, typeCtx) + "&";
     }
 
     return "???";
 }
 
 string
-Slice::outputTypeToString(const TypePtr& type, bool optional, const StringList& metaData, int typeCtx)
+Slice::outputTypeToString(const TypePtr& type, bool optional, const string& scope, const StringList& metaData,
+                          int typeCtx)
 {
+    bool cpp11 = (typeCtx & TypeContextCpp11) != 0;
+
     static const char* outputBuiltinTable[] =
     {
         "::Ice::Byte&",
@@ -661,13 +990,30 @@ Slice::outputTypeToString(const TypePtr& type, bool optional, const StringList&
         "::Ice::Double&",
         "::std::string&",
         "::Ice::ObjectPtr&",
-        "::Ice::ObjectPrx&",
-        "::Ice::LocalObjectPtr&"
+        "::Ice::ObjectPrxPtr&",
+        "::Ice::LocalObjectPtr&",
+        "::Ice::ValuePtr&"
+    };
+
+    static const char* cpp11OutputBuiltinTable[] =
+    {
+        "::Ice::Byte&",
+        "bool&",
+        "short&",
+        "int&",
+        "long long int&",
+        "float&",
+        "double&",
+        "::std::string&",
+        "::std::shared_ptr<::Ice::Object>&",
+        "::std::shared_ptr<::Ice::ObjectPrx>&",
+        "::std::shared_ptr<void>&",
+        "::std::shared_ptr<::Ice::Value>&"
     };
 
     if(optional)
     {
-        return "IceUtil::Optional<" + toTemplateArg(typeToString(type, metaData, typeCtx)) +">&";
+        return toOptional(typeToString(type, scope, metaData, typeCtx), typeCtx) + '&';
     }
 
     BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
@@ -677,75 +1023,126 @@ Slice::outputTypeToString(const TypePtr& type, bool optional, const StringList&
         {
             return stringTypeToString(type, metaData, typeCtx) + "&";
         }
+        else if(cpp11)
+        {
+            if(builtin->kind() == Builtin::KindObject && !(typeCtx & TypeContextLocal))
+            {
+                return getUnqualified(cpp11OutputBuiltinTable[Builtin::KindValue], scope);
+            }
+            else
+            {
+                return getUnqualified(cpp11OutputBuiltinTable[builtin->kind()], scope);
+            }
+        }
         else
         {
-            return outputBuiltinTable[builtin->kind()];
+            return getUnqualified(outputBuiltinTable[builtin->kind()], scope);
         }
     }
 
     ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
     if(cl)
     {
-        return fixKwd(cl->scoped() + "Ptr&");
+        if(cpp11)
+        {
+            if(cl->definition() && cl->definition()->isDelegate())
+            {
+                return getUnqualified(fixKwd(cl->scoped()), scope) + "&";
+            }
+            else if(cl->isInterface() && !cl->isLocal())
+            {
+                return getUnqualified(cpp11OutputBuiltinTable[Builtin::KindValue], scope);
+            }
+            else
+            {
+                return "::std::shared_ptr<" + getUnqualified(fixKwd(cl->scoped()), scope) + ">&";
+            }
+        }
+        else
+        {
+            return getUnqualified(fixKwd(cl->scoped() + "Ptr&"), scope);
+        }
     }
 
     StructPtr st = StructPtr::dynamicCast(type);
     if(st)
     {
-        if(findMetaData(st->getMetaData()) == "%class")
+        if(!cpp11 && findMetaData(st->getMetaData()) == "%class")
         {
-            return fixKwd(st->scoped() + "Ptr&");
+            return getUnqualified(fixKwd(st->scoped() + "Ptr&"), scope);
+        }
+        else
+        {
+            return getUnqualified(fixKwd(st->scoped()), scope) + "&";
         }
-        return fixKwd(st->scoped()) + "&";
     }
 
     ProxyPtr proxy = ProxyPtr::dynamicCast(type);
     if(proxy)
     {
-        return fixKwd(proxy->_class()->scoped() + "Prx&");
+        if(cpp11)
+        {
+            ClassDefPtr def = proxy->_class()->definition();
+            //
+            // Non local classes without operations map to the base
+            // proxy class shared_ptr<Ice::ObjectPrx>
+            //
+            if(def && !def->isInterface() && def->allOperations().empty())
+            {
+                return getUnqualified(cpp11OutputBuiltinTable[Builtin::KindObjectProxy], scope);
+            }
+            else
+            {
+                return "::std::shared_ptr<" + getUnqualified(fixKwd(proxy->_class()->scoped() + "Prx"), scope) + ">&";
+            }
+        }
+        else
+        {
+            return getUnqualified(fixKwd(proxy->_class()->scoped() + "Prx&"), scope);
+        }
+    }
+
+    EnumPtr en = EnumPtr::dynamicCast(type);
+    if(en)
+    {
+        return getUnqualified(fixKwd(en->scoped()), scope) + "&";
     }
 
     SequencePtr seq = SequencePtr::dynamicCast(type);
     if(seq)
     {
-        return sequenceTypeToString(seq, metaData, typeCtx) + "&";
+        return sequenceTypeToString(seq, scope, metaData, typeCtx) + "&";
     }
 
     DictionaryPtr dict = DictionaryPtr::dynamicCast(type);
     if(dict)
     {
-        return dictionaryTypeToString(dict, metaData, typeCtx) + "&";
-    }
-
-    ContainedPtr contained = ContainedPtr::dynamicCast(type);
-    if(contained)
-    {
-        return fixKwd(contained->scoped()) + "&";
+        return dictionaryTypeToString(dict, scope, metaData, typeCtx) + "&";
     }
 
     return "???";
 }
 
 string
-Slice::operationModeToString(Operation::Mode mode)
+Slice::operationModeToString(Operation::Mode mode, bool cpp11)
 {
+    string prefix = cpp11 ? "::Ice::OperationMode::" : "::Ice::";
     switch(mode)
     {
         case Operation::Normal:
         {
-            return "::Ice::Normal";
+            return prefix + "Normal";
         }
 
         case Operation::Nonmutating:
         {
-            return "::Ice::Nonmutating";
+            return prefix + "Nonmutating";
         }
 
         case Operation::Idempotent:
         {
-            return "::Ice::Idempotent";
+            return prefix + "Idempotent";
         }
-
         default:
         {
             assert(false);
@@ -756,16 +1153,18 @@ Slice::operationModeToString(Operation::Mode mode)
 }
 
 string
-Slice::opFormatTypeToString(const OperationPtr& op)
+Slice::opFormatTypeToString(const OperationPtr& op, bool cpp11)
 {
+    string prefix = cpp11 ? "::Ice::FormatType::" : "::Ice::";
+
     switch(op->format())
     {
     case DefaultFormat:
-        return "::Ice::DefaultFormat";
+        return prefix + "DefaultFormat";
     case CompactFormat:
-        return "::Ice::CompactFormat";
+        return prefix + "CompactFormat";
     case SlicedFormat:
-        return "::Ice::SlicedFormat";
+        return prefix + "SlicedFormat";
 
     default:
         assert(false);
@@ -775,7 +1174,7 @@ Slice::opFormatTypeToString(const OperationPtr& op)
 }
 
 //
-// If the passed name is a keyword, return the name with a "_cxx_" prefix;
+// If the passed name is a keyword, return the name with a "_cpp_" prefix;
 // otherwise, return the name unchanged.
 //
 
@@ -792,14 +1191,15 @@ lookupKwd(const string& name)
     //
     static const string keywordList[] =
     {
-        "and", "and_eq", "asm", "auto", "bit_and", "bit_or", "bool", "break", "case", "catch", "char",
-        "class", "compl", "const", "const_cast", "continue", "default", "delete", "do", "double",
-        "dynamic_cast", "else", "enum", "explicit", "export", "extern", "false", "float", "for",
-        "friend", "goto", "if", "inline", "int", "long", "mutable", "namespace", "new", "not", "not_eq",
-        "operator", "or", "or_eq", "private", "protected", "public", "register", "reinterpret_cast",
-        "return", "short", "signed", "sizeof", "static", "static_cast", "struct", "switch", "template",
-        "this", "throw", "true", "try", "typedef", "typeid", "typename", "union", "unsigned", "using",
-        "virtual", "void", "volatile", "wchar_t", "while", "xor", "xor_eq"
+        "alignas", "alignof", "and", "and_eq", "asm", "auto", "bit_and", "bit_or", "bool", "break",
+        "case", "catch", "char", "char16_t", "char32_t", "class", "compl", "const", "const_exptr", "const_cast", "continue",
+        "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",
+        "template", "this", "thread_local", "throw", "true", "try", "typedef", "typeid", "typename",
+        "union", "unsigned", "using", "virtual", "void", "volatile", "wchar_t", "while", "xor", "xor_eq"
     };
     bool found =  binary_search(&keywordList[0],
                                 &keywordList[sizeof(keywordList) / sizeof(*keywordList)],
@@ -845,8 +1245,8 @@ splitScopedName(const string& scoped)
 //
 // If the passed name is a scoped name, return the identical scoped name,
 // but with all components that are C++ keywords replaced by
-// their "_cxx_"-prefixed version; otherwise, if the passed name is
-// not scoped, but a C++ keyword, return the "_cxx_"-prefixed name;
+// their "_cpp_"-prefixed version; otherwise, if the passed name is
+// not scoped, but a C++ keyword, return the "_cpp_"-prefixed name;
 // otherwise, return the name unchanged.
 //
 string
@@ -868,16 +1268,19 @@ Slice::fixKwd(const string& name)
 
 void
 Slice::writeMarshalUnmarshalCode(Output& out, const TypePtr& type, bool optional, int tag, const string& param,
-                                 bool marshal, const StringList& metaData, int typeCtx, const string& str, bool pointer)
+                                 bool marshal, const StringList& metaData, int typeCtx, const string& customStream,
+                                 bool pointer, const string& obj)
 {
+    string objPrefix = obj.empty() ? obj : obj + ".";
+
     ostringstream os;
-    if(str.empty())
+    if(customStream.empty())
     {
-        os << (marshal ? "__os" : "__is");
+        os << (marshal ? "ostr" : "istr");
     }
     else
     {
-        os << str;
+        os << customStream;
     }
 
     string deref;
@@ -916,51 +1319,62 @@ Slice::writeMarshalUnmarshalCode(Output& out, const TypePtr& type, bool optional
                 BuiltinPtr builtin = BuiltinPtr::dynamicCast(seq->type());
                 if(builtin && builtin->kind() == Builtin::KindByte)
                 {
-                    out << nl << func << param << ");";
+                    out << nl << func << objPrefix << param << ");";
                     return;
                 }
 
-                out << nl << func << "___" << param << ");";
-                writeParamEndCode(out, seq, optional, param, metaData);
+                out << nl << func << objPrefix << param << "_tmp_);";
+                writeParamEndCode(out, seq, optional, param, metaData, obj);
                 return;
             }
             else if(seqType.find("%range") == 0)
             {
-                out << nl << func << "___" << param << ");";
-                writeParamEndCode(out, seq, optional, param, metaData);
+                out << nl << func << objPrefix << param << "_tmp_);";
+                writeParamEndCode(out, seq, optional, param, metaData, obj);
                 return;
             }
         }
     }
 
-    out << nl << func << param << ");";
+    out << nl << func << objPrefix << param << ");";
 }
 
 void
-Slice::writeMarshalCode(Output& out, const ParamDeclList& params, const OperationPtr& op, bool prepend, int typeCtx)
+Slice::writeMarshalCode(Output& out, const ParamDeclList& params, const OperationPtr& op, bool prepend, int typeCtx,
+                        const string& customStream, const string& retP)
 {
-    writeMarshalUnmarshalParams(out, params, op, true, prepend, typeCtx);
+    writeMarshalUnmarshalParams(out, params, op, true, prepend, typeCtx, customStream, retP);
 }
 
 void
-Slice::writeUnmarshalCode(Output& out, const ParamDeclList& params, const OperationPtr& op, bool prepend, int typeCtx)
+Slice::writeUnmarshalCode(Output& out, const ParamDeclList& params, const OperationPtr& op, bool prepend, int typeCtx,
+                          const string& customStream, const string& retP, const string& obj)
 {
-    writeMarshalUnmarshalParams(out, params, op, false, prepend, typeCtx);
+    writeMarshalUnmarshalParams(out, params, op, false, prepend, typeCtx, customStream, retP, obj);
 }
 
 void
-Slice::writeAllocateCode(Output& out, const ParamDeclList& params, const OperationPtr& op, bool prepend, int typeCtx)
+Slice::writeAllocateCode(Output& out, const ParamDeclList& params, const OperationPtr& op, bool prepend,
+                         const string& clScope, int typeCtx, const string& customRet)
 {
     string prefix = prepend ? paramPrefix : "";
+    string returnValueS = customRet;
+    if(returnValueS.empty())
+    {
+        returnValueS = "ret";
+    }
+
     for(ParamDeclList::const_iterator p = params.begin(); p != params.end(); ++p)
     {
-        writeParamAllocateCode(out, (*p)->type(), (*p)->optional(), fixKwd(prefix + (*p)->name()), (*p)->getMetaData(),
-                               typeCtx, getEndArg((*p)->type(),(*p)->getMetaData(), (*p)->name()) != (*p)->name());
+        writeParamAllocateCode(out, (*p)->type(), (*p)->optional(), clScope, fixKwd(prefix + (*p)->name()),
+                               (*p)->getMetaData(), typeCtx, getEndArg((*p)->type(), (*p)->getMetaData(),
+                                                                       (*p)->name()) != (*p)->name());
     }
+
     if(op && op->returnType())
     {
-        writeParamAllocateCode(out, op->returnType(), op->returnIsOptional(), "__ret", op->getMetaData(), typeCtx,
-                               getEndArg(op->returnType(), op->getMetaData(), "__ret") != "__ret");
+        writeParamAllocateCode(out, op->returnType(), op->returnIsOptional(), clScope, returnValueS, op->getMetaData(),
+                               typeCtx, getEndArg(op->returnType(), op->getMetaData(), returnValueS) != returnValueS);
     }
 }
 
@@ -986,11 +1400,11 @@ Slice::getEndArg(const TypePtr& type, const StringList& metaData, const string&
                builtin->kind() != Builtin::KindObject &&
                builtin->kind() != Builtin::KindObjectProxy)
             {
-                endArg = "___" + endArg;
+                endArg += "_tmp_";
             }
             else if(!builtin || builtin->kind() != Builtin::KindByte)
             {
-                endArg = "___" + endArg;
+                endArg += "_tmp_";
             }
         }
         else if(seqType.find("%range") == 0)
@@ -1000,7 +1414,7 @@ Slice::getEndArg(const TypePtr& type, const StringList& metaData, const string&
             {
                 md.push_back("cpp:type:" + seqType.substr(strlen("%range:")));
             }
-            endArg = "___" + endArg;
+            endArg += "_tmp_";
         }
     }
     return endArg;
@@ -1016,10 +1430,254 @@ Slice::writeEndCode(Output& out, const ParamDeclList& params, const OperationPtr
     }
     if(op && op->returnType())
     {
-        writeParamEndCode(out, op->returnType(), op->returnIsOptional(), "__ret", op->getMetaData());
+        writeParamEndCode(out, op->returnType(), op->returnIsOptional(), "ret", op->getMetaData());
     }
 }
 
+void
+Slice::writeMarshalUnmarshalDataMemberInHolder(IceUtilInternal::Output& C,
+                                               const string& holder,
+                                               const DataMemberPtr& p,
+                                               bool marshal)
+{
+    writeMarshalUnmarshalCode(C, p->type(), p->optional(), p->tag(), holder + fixKwd(p->name()), marshal,
+                              p->getMetaData());
+}
+
+void
+Slice::writeMarshalUnmarshalAllInHolder(IceUtilInternal::Output& out,
+                                          const string& holder,
+                                          const DataMemberList& dataMembers,
+                                          bool optional,
+                                          bool marshal)
+{
+    if(dataMembers.empty())
+    {
+        return;
+    }
+
+    string stream = marshal ? "ostr" : "istr";
+    string streamOp = marshal ? "writeAll" : "readAll";
+
+    out << nl << stream << "->" << streamOp;
+    out << spar;
+
+    if(optional)
+    {
+        ostringstream os;
+        os << "{";
+        for(DataMemberList::const_iterator q = dataMembers.begin(); q != dataMembers.end(); ++q)
+        {
+            if(q != dataMembers.begin())
+            {
+                os << ", ";
+            }
+            os << (*q)->tag();
+        }
+        os << "}";
+        out << os.str();
+    }
+
+    for(DataMemberList::const_iterator q = dataMembers.begin(); q != dataMembers.end(); ++q)
+    {
+        out << holder + fixKwd((*q)->name());
+    }
+
+    out << epar << ";";
+
+}
+
+void
+Slice::writeStreamHelpers(Output& out,
+                          const ContainedPtr& c,
+                          DataMemberList dataMembers,
+                          bool hasBaseDataMembers,
+                          bool checkClassMetaData,
+                          bool cpp11)
+{
+    // If c is a C++11 class/exception whose base class contains data members (recursively), then we need to generate
+    // 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))
+    {
+        return;
+    }
+
+    DataMemberList requiredMembers;
+    DataMemberList optionalMembers;
+
+    for(DataMemberList::const_iterator q = dataMembers.begin(); q != dataMembers.end(); ++q)
+    {
+        if((*q)->optional())
+        {
+            optionalMembers.push_back(*q);
+        }
+        else
+        {
+            requiredMembers.push_back(*q);
+        }
+    }
+
+    // Sort optional data members
+    class SortFn
+    {
+    public:
+        static bool compare(const DataMemberPtr& lhs, const DataMemberPtr& rhs)
+        {
+            return lhs->tag() < rhs->tag();
+        }
+    };
+    optionalMembers.sort(SortFn::compare);
+
+    string scoped = c->scoped();
+    bool classMetaData = checkClassMetaData ? (findMetaData(c->getMetaData(), false) == "%class") : false;
+    string fullName = classMetaData ? fixKwd(scoped + "Ptr") : fixKwd(scoped);
+    string holder = classMetaData ? "v->" : "v.";
+
+    //
+    // Generate StreamWriter
+    //
+    // Only generate StreamWriter specializations if we are generating for C++98 or
+    // we are generating for C++11 with optional data members and no base class data members
+    //
+    if(!cpp11 || !optionalMembers.empty() || hasBaseDataMembers)
+    {
+        out << nl << "template<typename S>";
+        out << nl << "struct StreamWriter" << (cpp11 ? "<" : "< ") << fullName << ", S>";
+        out << sb;
+        if(requiredMembers.empty() && optionalMembers.empty())
+        {
+            out << nl << "static void write(S*, const " << fullName << "&)";
+        }
+        else
+        {
+            out << nl << "static void write(S* ostr, const " << fullName << "& v)";
+        }
+
+        out << sb;
+
+        if(cpp11)
+        {
+            writeMarshalUnmarshalAllInHolder(out, holder, requiredMembers, false, true);
+            writeMarshalUnmarshalAllInHolder(out, holder, optionalMembers, true, true);
+        }
+        else
+        {
+            for(DataMemberList::const_iterator q = requiredMembers.begin(); q != requiredMembers.end(); ++q)
+            {
+                writeMarshalUnmarshalDataMemberInHolder(out, holder, *q, true);
+            }
+
+            for(DataMemberList::const_iterator q = optionalMembers.begin(); q != optionalMembers.end(); ++q)
+            {
+                writeMarshalUnmarshalDataMemberInHolder(out, holder, *q, true);
+            }
+        }
+
+        out << eb;
+        out << eb << ";" << nl;
+    }
+
+    //
+    // Generate StreamReader
+    //
+    out << nl << "template<typename S>";
+    out << nl << "struct StreamReader" << (cpp11 ? "<" : "< ") << fullName << ", S>";
+    out << sb;
+    if (requiredMembers.empty() && optionalMembers.empty())
+    {
+        out << nl << "static void read(S*, " << fullName << "&)";
+    }
+    else
+    {
+        out << nl << "static void read(S* istr, " << fullName << "& v)";
+    }
+
+    out << sb;
+
+    if(cpp11)
+    {
+        writeMarshalUnmarshalAllInHolder(out, holder, requiredMembers, false, false);
+        writeMarshalUnmarshalAllInHolder(out, holder, optionalMembers, true, false);
+    }
+    else
+    {
+        for(DataMemberList::const_iterator q = requiredMembers.begin(); q != requiredMembers.end(); ++q)
+        {
+            writeMarshalUnmarshalDataMemberInHolder(out, holder, *q, false);
+        }
+
+        for(DataMemberList::const_iterator q = optionalMembers.begin(); q != optionalMembers.end(); ++q)
+        {
+            writeMarshalUnmarshalDataMemberInHolder(out, holder, *q, false);
+        }
+    }
+
+    out << eb;
+    out << eb << ";" << nl;
+}
+
+void
+Slice::writeIceTuple(::IceUtilInternal::Output& out, DataMemberList dataMembers, int typeCtx)
+{
+    //
+    // 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())
+        {
+            out << ", ";
+        }
+        out << "const ";
+        out << typeToString((*q)->type(), (*q)->optional(), scope, (*q)->getMetaData(), typeCtx | TypeContextCpp11)
+            << "&";
+    }
+    out << "> ice_tuple() const";
+
+    out << sb;
+    out << nl << "return std::tie(";
+    for(DataMemberList::const_iterator pi = dataMembers.begin(); pi != dataMembers.end(); ++pi)
+    {
+        if(pi != dataMembers.begin())
+        {
+            out << ", ";
+        }
+        out << fixKwd((*pi)->name());
+    }
+    out << ");" << eb;
+}
+
+bool
+Slice::findMetaData(const string& prefix, const ClassDeclPtr& cl, string& value)
+{
+    if(findMetaData(prefix, cl->getMetaData(), value))
+    {
+        return true;
+    }
+
+    ClassDefPtr def = cl->definition();
+    return def ? findMetaData(prefix, def->getMetaData(), value) : false;
+}
+
+bool
+Slice::findMetaData(const string& prefix, const StringList& metaData, string& value)
+{
+    for(StringList::const_iterator i = metaData.begin(); i != metaData.end(); i++)
+    {
+        string s = *i;
+        if(s.find(prefix) == 0)
+        {
+            value = s.substr(prefix.size());
+            return true;
+        }
+    }
+    return false;
+}
+
 string
 Slice::findMetaData(const StringList& metaData, int typeCtx)
 {
@@ -1041,28 +1699,23 @@ Slice::findMetaData(const StringList& metaData, int typeCtx)
             // the return value is % followed by the string after cpp:.
             //
             // The priority of the metadata is as follows:
-            // 1: protobuf
-            // 2: array, range, view-type for "view" parameters
-            // 3: class
+            // 1: array, range (C++98 only), view-type for "view" parameters
+            // 2: class (C++98 only), scoped (C++98 only), unscoped (C++11 only)
+            //
 
             if(pos != string::npos)
             {
                 string ss = str.substr(prefix.size());
 
-                if(ss.find("protobuf:") == 0)
-                {
-                    return str.substr(pos + 1);
-                }
-
                 if(typeCtx & (TypeContextInParam | TypeContextAMIPrivateEnd))
                 {
-                    if(ss.find("range:") == 0)
+                    if(ss.find("view-type:") == 0)
                     {
-                        return string("%") + str.substr(prefix.size());
+                        return str.substr(pos + 1);
                     }
-                    else if(ss.find("view-type:") == 0)
+                    else if(ss.find("range:") == 0 && !(typeCtx & TypeContextCpp11))
                     {
-                        return str.substr(pos + 1);
+                        return string("%") + str.substr(prefix.size());
                     }
                 }
 
@@ -1078,21 +1731,29 @@ Slice::findMetaData(const StringList& metaData, int typeCtx)
                 {
                     return "%array";
                 }
-                else if(ss == "range")
+                else if(ss == "range" && !(typeCtx & TypeContextCpp11))
                 {
                     return "%range";
                 }
             }
             //
-            // Otherwise if the data is "class" it is returned.
+            // Otherwise if the data is "class", "scoped" or "unscoped" it is returned.
             //
             else
             {
                 string ss = str.substr(prefix.size());
-                if(ss == "class")
+                if(ss == "class" && !(typeCtx & TypeContextCpp11))
                 {
                     return "%class";
                 }
+                else if(ss == "scoped" && !(typeCtx & TypeContextCpp11))
+                {
+                    return "%scoped";
+                }
+                else if(ss == "unscoped" && (typeCtx & TypeContextCpp11))
+                {
+                    return "%unscoped";
+                }
             }
         }
     }
@@ -1125,7 +1786,6 @@ Slice::inWstringModule(const SequencePtr& seq)
     return false;
 }
 
-
 string
 Slice::getDataMemberRef(const DataMemberPtr& p)
 {