zeroc-ice 3.7.0 → 3.7.5

data/ext/ice/cpp/src/Slice/JavaUtil.h

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2017 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 JAVA_UTIL_H
 #define JAVA_UTIL_H
@@ -98,7 +93,7 @@ protected:
                                   const std::string& = std::string()) const;
 
     //
-    // Returns the package prefix for a give Slice file.
+    // Returns the package prefix of a Contained entity.
     //
     std::string getPackagePrefix(const ContainedPtr&) const;
 
@@ -107,12 +102,13 @@ protected:
     //
     std::string getPackage(const ContainedPtr&) const;
 
+    std::string getUnqualified(const std::string&, const std::string&) const;
     //
     // Returns the Java name for a Contained entity. If the optional
     // package argument matches the entity's package name, then the
     // package is removed from the result.
     //
-    std::string getAbsolute(const ContainedPtr&,
+    std::string getUnqualified(const ContainedPtr&,
                             const std::string& = std::string(),
                             const std::string& = std::string(),
                             const std::string& = std::string()) const;
@@ -222,7 +218,6 @@ private:
 
     std::string _dir;
     ::IceUtilInternal::Output* _out;
-    mutable std::map<std::string, std::string> _filePackagePrefix;
 };
 
 class JavaGenerator : private ::IceUtil::noncopyable
@@ -264,7 +259,7 @@ protected:
                                   const std::string& = std::string()) const;
 
     //
-    // Returns the package prefix for a give Slice file.
+    // Returns the package prefix of a Contained entity.
     //
     std::string getPackagePrefix(const ContainedPtr&) const;
 
@@ -273,12 +268,18 @@ protected:
     //
     std::string getPackage(const ContainedPtr&) const;
 
+    //
+    // Returns the Java type without a package if the package
+    // matches the current package
+    //
+    std::string getUnqualified(const std::string&, const std::string&) const;
+
     //
     // Returns the Java name for a Contained entity. If the optional
     // package argument matches the entity's package name, then the
     // package is removed from the result.
     //
-    std::string getAbsolute(const ContainedPtr&,
+    std::string getUnqualified(const ContainedPtr&,
                             const std::string& = std::string(),
                             const std::string& = std::string(),
                             const std::string& = std::string()) const;
@@ -390,7 +391,6 @@ private:
 
     std::string _dir;
     ::IceUtilInternal::Output* _out;
-    mutable std::map<std::string, std::string> _filePackagePrefix;
 };
 
 }

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2017 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/MD5.h>
 #include <Slice/MD5I.h>

data/ext/ice/cpp/src/Slice/MD5.h

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2017 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 SLICE_MD5_H
 #define SLICE_MD5_H

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

@@ -58,6 +58,14 @@
 #  pragma GCC diagnostic ignored "-Wold-style-cast"
 #endif
 
+//
+// Avoid clang conversion warnings
+//
+#if defined(__clang__)
+#   pragma clang diagnostic ignored "-Wconversion"
+#   pragma clang diagnostic ignored "-Wsign-conversion"
+#endif
+
 #undef BYTE_ORDER       /* 1 = big-endian, -1 = little-endian, 0 = unknown */
 #ifdef ARCH_IS_BIG_ENDIAN
 #  define BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : -1)

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2017 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/PHPUtil.h>
 #include <functional>
@@ -19,7 +14,12 @@ static string
 lowerCase(const string& s)
 {
     string result(s);
+#ifdef ICE_CPP11_COMPILER
+    transform(result.begin(), result.end(), result.begin(),
+              [](char c){ return static_cast<char>(::tolower(static_cast<unsigned char>(c))); });
+#else
     transform(result.begin(), result.end(), result.begin(), ::tolower);
+#endif
     return result;
 }
 

data/ext/ice/cpp/src/Slice/PHPUtil.h

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2017 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 SLICE_PHP_UTIL_H
 #define SLICE_PHP_UTIL_H

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2017 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/Functional.h>
 #include <IceUtil/InputUtil.h>
@@ -16,16 +11,64 @@
 #include <cstring>
 #include <iterator>
 
-#ifdef _WIN32
-#   include <io.h>
+// TODO: fix this warning once we no longer support VS2013 and earlier
+#if defined(_MSC_VER) && (_MSC_VER >= 1900)
+#    pragma warning(disable:4589) // Constructor of abstract class 'Slice::Type' ignores initializer...
 #endif
 
 using namespace std;
 using namespace Slice;
 
+Slice::CompilerException::CompilerException(const char* file, int line, const string& r) :
+    IceUtil::Exception(file, line),
+    _reason(r)
+{
+}
+
+#ifndef ICE_CPP11_COMPILER
+Slice::CompilerException::~CompilerException() throw()
+{
+}
+#endif
+
+string
+Slice::CompilerException::ice_id() const
+{
+    return "::Slice::CompilerException";
+}
+
+void
+Slice::CompilerException::ice_print(ostream& out) const
+{
+    IceUtil::Exception::ice_print(out);
+    out << ": " << _reason;
+}
+
+#ifndef ICE_CPP11_MAPPING
+Slice::CompilerException*
+Slice::CompilerException::ice_clone() const
+{
+    return new CompilerException(*this);
+}
+#endif
+
+void
+Slice::CompilerException::ice_throw() const
+{
+    throw *this;
+}
+
+string
+Slice::CompilerException::reason() const
+{
+    return _reason;
+}
+
 extern FILE* slice_in;
 extern int slice_debug;
 
+int slice_parse();
+
 //
 // Operation attributes
 //
@@ -114,18 +157,18 @@ isMutableAfterReturnType(const TypePtr& type)
 }
 
 void
-checkDeprecatedType(const UnitPtr& unit, const TypePtr& type)
+checkDeprecatedType(const UnitPtr& unt, const TypePtr& type)
 {
     ClassDeclPtr decl = ClassDeclPtr::dynamicCast(type);
     if(decl && !decl->isLocal() && decl->isInterface())
     {
-        unit->warning(Deprecated, "interface by value is deprecated");
+        unt->warning(Deprecated, "interface by value is deprecated");
     }
 
     ProxyPtr proxy = ProxyPtr::dynamicCast(type);
     if(proxy && !proxy->_class()->isInterface())
     {
-        unit->warning(Deprecated, "proxy for a class is deprecated");
+        unt->warning(Deprecated, "proxy for a class is deprecated");
     }
 }
 
@@ -229,6 +272,20 @@ Slice::DefinitionContext::warning(WarningCategory category, const string& file,
     }
 }
 
+void
+Slice::DefinitionContext::error(const string& file, int line, const string& msg) const
+{
+    emitError(file, line, msg);
+    throw CompilerException(__FILE__, __LINE__, msg);
+}
+
+void
+Slice::DefinitionContext::error(const string& file, const string& line, const string& msg) const
+{
+    emitError(file, line, msg);
+    throw CompilerException(__FILE__, __LINE__, msg);
+}
+
 bool
 Slice::DefinitionContext::suppressWarning(WarningCategory category) const
 {
@@ -272,13 +329,69 @@ Slice::DefinitionContext::initSuppressedWarnings()
                 else
                 {
                     warning(InvalidMetaData, "", "", string("invalid category `") + s +
-                            "' in global metadata suppress-warning");
+                            "' in file metadata suppress-warning");
                 }
             }
         }
     }
 }
 
+// ----------------------------------------------------------------------
+// Comment
+// ----------------------------------------------------------------------
+
+bool
+Slice::Comment::isDeprecated() const
+{
+    return _isDeprecated;
+}
+
+StringList
+Slice::Comment::deprecated() const
+{
+    return _deprecated;
+}
+
+StringList
+Slice::Comment::overview() const
+{
+    return _overview;
+}
+
+StringList
+Slice::Comment::misc() const
+{
+    return _misc;
+}
+
+StringList
+Slice::Comment::seeAlso() const
+{
+    return _seeAlso;
+}
+
+StringList
+Slice::Comment::returns() const
+{
+    return _returns;
+}
+
+map<string, StringList>
+Slice::Comment::parameters() const
+{
+    return _parameters;
+}
+
+map<string, StringList>
+Slice::Comment::exceptions() const
+{
+    return _exceptions;
+}
+
+Slice::Comment::Comment()
+{
+}
+
 // ----------------------------------------------------------------------
 // SyntaxTreeBase
 // ----------------------------------------------------------------------
@@ -306,12 +419,13 @@ Slice::SyntaxTreeBase::visit(ParserVisitor*, bool)
 {
 }
 
-Slice::SyntaxTreeBase::SyntaxTreeBase(const UnitPtr& unit) :
-    _unit(unit)
+Slice::SyntaxTreeBase::SyntaxTreeBase(const UnitPtr& unt, const DefinitionContextPtr& definitionContext) :
+    _unit(unt),
+    _definitionContext(definitionContext)
 {
-    if(_unit)
+    if(!_definitionContext && _unit)
     {
-        _definitionContext = unit->currentDefinitionContext();
+        _definitionContext = unt->currentDefinitionContext();
     }
 }
 
@@ -319,8 +433,8 @@ Slice::SyntaxTreeBase::SyntaxTreeBase(const UnitPtr& unit) :
 // Type
 // ----------------------------------------------------------------------
 
-Slice::Type::Type(const UnitPtr& unit) :
-    SyntaxTreeBase(unit)
+Slice::Type::Type(const UnitPtr& unt) :
+    SyntaxTreeBase(unt)
 {
 }
 
@@ -425,6 +539,7 @@ Slice::Builtin::minWireSize() const
         1, // KindString: at least one byte for an empty string.
         1, // KindObject: at least one byte (to marshal an index instead of an instance).
         2, // KindObjectProxy: at least an empty identity for a nil proxy, that is, 2 bytes.
+        0, // KindLocalObject: unused
         1  // KindValue: at least one byte (to marshal an index instead of an instance).
     };
 
@@ -466,9 +581,9 @@ const char* Slice::Builtin::builtinTable[] =
         "Value"
     };
 
-Slice::Builtin::Builtin(const UnitPtr& unit, Kind kind) :
-    SyntaxTreeBase(unit),
-    Type(unit),
+Slice::Builtin::Builtin(const UnitPtr& ut, Kind kind) :
+    SyntaxTreeBase(ut),
+    Type(ut),
     _kind(kind)
 {
     //
@@ -538,6 +653,330 @@ Slice::Contained::comment() const
     return _comment;
 }
 
+namespace
+{
+
+void
+trimLines(StringList& l)
+{
+    //
+    // Remove empty trailing lines.
+    //
+    while(!l.empty() && l.back().empty())
+    {
+        l.pop_back();
+    }
+}
+
+StringList
+splitComment(const string& c, bool stripMarkup)
+{
+    string comment = c;
+
+    if(stripMarkup)
+    {
+        //
+        // Strip HTML markup and javadoc links.
+        //
+        string::size_type pos = 0;
+        do
+        {
+            pos = comment.find('<', pos);
+            if(pos != string::npos)
+            {
+                string::size_type endpos = comment.find('>', pos);
+                if(endpos == string::npos)
+                {
+                    break;
+                }
+                comment.erase(pos, endpos - pos + 1);
+            }
+        }
+        while(pos != string::npos);
+
+        const string link = "{@link";
+        pos = 0;
+        do
+        {
+            pos = comment.find(link, pos);
+            if(pos != string::npos)
+            {
+                comment.erase(pos, link.size() + 1); // Erase trailing white space too.
+                string::size_type endpos = comment.find('}', pos);
+                if(endpos != string::npos)
+                {
+                    string ident = comment.substr(pos, endpos - pos);
+                    comment.erase(pos, endpos - pos + 1);
+
+                    //
+                    // Replace links of the form {@link Type#member} with "Type.member".
+                    //
+                    string::size_type hash = ident.find('#');
+                    string rest;
+                    if(hash != string::npos)
+                    {
+                        rest = ident.substr(hash + 1);
+                        ident = ident.substr(0, hash);
+                        if(!ident.empty())
+                        {
+                            if(!rest.empty())
+                            {
+                                ident += "." + rest;
+                            }
+                        }
+                        else if(!rest.empty())
+                        {
+                            ident = rest;
+                        }
+                    }
+
+                    comment.insert(pos, ident);
+                }
+            }
+        }
+        while(pos != string::npos);
+    }
+
+    StringList result;
+
+    string::size_type pos = 0;
+    string::size_type nextPos;
+    while((nextPos = comment.find_first_of('\n', pos)) != string::npos)
+    {
+        result.push_back(IceUtilInternal::trim(string(comment, pos, nextPos - pos)));
+        pos = nextPos + 1;
+    }
+    string lastLine = IceUtilInternal::trim(string(comment, pos));
+    if(!lastLine.empty())
+    {
+        result.push_back(lastLine);
+    }
+
+    trimLines(result);
+
+    return result;
+}
+
+bool
+parseCommentLine(const string& l, const string& tag, bool namedTag, string& name, string& doc)
+{
+    doc.clear();
+
+    if(l.find(tag) == 0)
+    {
+        const string ws = " \t";
+
+        if(namedTag)
+        {
+            string::size_type n = l.find_first_not_of(ws, tag.size());
+            if(n == string::npos)
+            {
+                return false; // Malformed line, ignore it.
+            }
+            string::size_type end = l.find_first_of(ws, n);
+            if(end == string::npos)
+            {
+                return false; // Malformed line, ignore it.
+            }
+            name = l.substr(n, end - n);
+            n = l.find_first_not_of(ws, end);
+            if(n != string::npos)
+            {
+                doc = l.substr(n);
+            }
+        }
+        else
+        {
+            name.clear();
+
+            string::size_type n = l.find_first_not_of(ws, tag.size());
+            if(n == string::npos)
+            {
+                return false; // Malformed line, ignore it.
+            }
+            doc = l.substr(n);
+        }
+
+        return true;
+    }
+
+    return false;
+}
+
+}
+
+CommentPtr
+Slice::Contained::parseComment(bool stripMarkup) const
+{
+    CommentPtr comment = new Comment;
+
+    comment->_isDeprecated = false;
+
+    //
+    // First check metadata for a deprecated tag.
+    //
+    string deprecateMetadata;
+    if(findMetaData("deprecate", deprecateMetadata))
+    {
+        comment->_isDeprecated = true;
+        if(deprecateMetadata.find("deprecate:") == 0 && deprecateMetadata.size() > 10)
+        {
+            comment->_deprecated.push_back(IceUtilInternal::trim(deprecateMetadata.substr(10)));
+        }
+    }
+
+    if(!comment->_isDeprecated && _comment.empty())
+    {
+        return 0;
+    }
+
+    //
+    // Split up the comment into lines.
+    //
+    StringList lines = splitComment(_comment, stripMarkup);
+
+    StringList::const_iterator i;
+    for(i = lines.begin(); i != lines.end(); ++i)
+    {
+        const string l = *i;
+        if(l[0] == '@')
+        {
+            break;
+        }
+        comment->_overview.push_back(l);
+    }
+
+    enum State { StateMisc, StateParam, StateThrows, StateReturn, StateDeprecated };
+    State state = StateMisc;
+    string name;
+    const string ws = " \t";
+    const string paramTag = "@param";
+    const string throwsTag = "@throws";
+    const string exceptionTag = "@exception";
+    const string returnTag = "@return";
+    const string deprecatedTag = "@deprecated";
+    const string seeTag = "@see";
+    for(; i != lines.end(); ++i)
+    {
+        const string l = IceUtilInternal::trim(*i);
+        string line;
+        if(parseCommentLine(l, paramTag, true, name, line))
+        {
+            if(!line.empty())
+            {
+                state = StateParam;
+                StringList sl;
+                sl.push_back(line); // The first line of the description.
+                comment->_parameters[name] = sl;
+            }
+        }
+        else if(parseCommentLine(l, throwsTag, true, name, line))
+        {
+            if(!line.empty())
+            {
+                state = StateThrows;
+                StringList sl;
+                sl.push_back(line); // The first line of the description.
+                comment->_exceptions[name] = sl;
+            }
+        }
+        else if(parseCommentLine(l, exceptionTag, true, name, line))
+        {
+            if(!line.empty())
+            {
+                state = StateThrows;
+                StringList sl;
+                sl.push_back(line); // The first line of the description.
+                comment->_exceptions[name] = sl;
+            }
+        }
+        else if(parseCommentLine(l, seeTag, false, name, line))
+        {
+            if(!line.empty())
+            {
+                comment->_seeAlso.push_back(line);
+            }
+        }
+        else if(parseCommentLine(l, returnTag, false, name, line))
+        {
+            if(!line.empty())
+            {
+                state = StateReturn;
+                comment->_returns.push_back(line); // The first line of the description.
+            }
+        }
+        else if(parseCommentLine(l, deprecatedTag, false, name, line))
+        {
+            comment->_isDeprecated = true;
+            if(!line.empty())
+            {
+                state = StateDeprecated;
+                comment->_deprecated.push_back(line); // The first line of the description.
+            }
+        }
+        else if(!l.empty())
+        {
+            if(l[0] == '@')
+            {
+                //
+                // Treat all other tags as miscellaneous comments.
+                //
+                state = StateMisc;
+            }
+
+            switch(state)
+            {
+                case StateMisc:
+                {
+                    comment->_misc.push_back(l);
+                    break;
+                }
+                case StateParam:
+                {
+                    assert(!name.empty());
+                    StringList sl;
+                    if(comment->_parameters.find(name) != comment->_parameters.end())
+                    {
+                        sl = comment->_parameters[name];
+                    }
+                    sl.push_back(l);
+                    comment->_parameters[name] = sl;
+                    break;
+                }
+                case StateThrows:
+                {
+                    assert(!name.empty());
+                    StringList sl;
+                    if(comment->_exceptions.find(name) != comment->_exceptions.end())
+                    {
+                        sl = comment->_exceptions[name];
+                    }
+                    sl.push_back(l);
+                    comment->_exceptions[name] = sl;
+                    break;
+                }
+                case StateReturn:
+                {
+                    comment->_returns.push_back(l);
+                    break;
+                }
+                case StateDeprecated:
+                {
+                    comment->_deprecated.push_back(l);
+                    break;
+                }
+            }
+        }
+    }
+
+    trimLines(comment->_overview);
+    trimLines(comment->_deprecated);
+    trimLines(comment->_misc);
+    trimLines(comment->_returns);
+
+    return comment;
+}
+
 int
 Slice::Contained::includeLevel() const
 {
@@ -677,7 +1116,6 @@ Slice::Container::destroy()
 ModulePtr
 Slice::Container::createModule(const string& name)
 {
-    checkIdentifier(name);
     ContainedList matches = _unit->findContents(thisScope() + name);
     matches.sort(); // Modules can occur many times...
     matches.unique(); // ... but we only want one instance of each.
@@ -730,8 +1168,6 @@ Slice::Container::createModule(const string& name)
 ClassDefPtr
 Slice::Container::createClassDef(const string& name, int id, bool intf, const ClassList& bases, bool local)
 {
-    checkIdentifier(name);
-
     ContainedList matches = _unit->findContents(thisScope() + name);
     for(ContainedList::const_iterator p = matches.begin(); p != matches.end(); ++p)
     {
@@ -812,20 +1248,15 @@ Slice::Container::createClassDef(const string& name, int id, bool intf, const Cl
     // definition. This way the code generator can rely on always
     // having a class declaration available for lookup.
     //
-    ClassDeclPtr decl = createClassDecl(name, intf, local, false);
+    ClassDeclPtr decl = createClassDecl(name, intf, local);
     def->_declaration = decl;
 
     return def;
 }
 
 ClassDeclPtr
-Slice::Container::createClassDecl(const string& name, bool intf, bool local, bool checkName)
+Slice::Container::createClassDecl(const string& name, bool intf, bool local)
 {
-    if (checkName)
-    {
-        checkIdentifier(name);
-    }
-
     ClassDefPtr def;
 
     ContainedList matches = _unit->findContents(thisScope() + name);
@@ -915,8 +1346,6 @@ Slice::Container::createClassDecl(const string& name, bool intf, bool local, boo
 ExceptionPtr
 Slice::Container::createException(const string& name, const ExceptionPtr& base, bool local, NodeType nt)
 {
-    checkIdentifier(name);
-
     ContainedList matches = _unit->findContents(thisScope() + name);
     if(!matches.empty())
     {
@@ -967,8 +1396,6 @@ Slice::Container::createException(const string& name, const ExceptionPtr& base,
 StructPtr
 Slice::Container::createStruct(const string& name, bool local, NodeType nt)
 {
-    checkIdentifier(name);
-
     ContainedList matches = _unit->findContents(thisScope() + name);
     if(!matches.empty())
     {
@@ -1012,8 +1439,6 @@ SequencePtr
 Slice::Container::createSequence(const string& name, const TypePtr& type, const StringList& metaData, bool local,
                                  NodeType nt)
 {
-    checkIdentifier(name);
-
     ContainedList matches = _unit->findContents(thisScope() + name);
     if(!matches.empty())
     {
@@ -1069,8 +1494,6 @@ Slice::Container::createDictionary(const string& name, const TypePtr& keyType, c
                                    const TypePtr& valueType, const StringList& valueMetaData, bool local,
                                    NodeType nt)
 {
-    checkIdentifier(name);
-
     ContainedList matches = _unit->findContents(thisScope() + name);
     if(!matches.empty())
     {
@@ -1143,8 +1566,6 @@ Slice::Container::createDictionary(const string& name, const TypePtr& keyType, c
 EnumPtr
 Slice::Container::createEnum(const string& name, bool local, NodeType nt)
 {
-    checkIdentifier(name);
-
     ContainedList matches = _unit->findContents(thisScope() + name);
     if(!matches.empty())
     {
@@ -1213,8 +1634,6 @@ Slice::Container::createConst(const string name, const TypePtr& constType, const
                               const SyntaxTreeBasePtr& valueType, const string& value, const string& literal,
                               NodeType nt)
 {
-    checkIdentifier(name);
-
     ContainedList matches = _unit->findContents(thisScope() + name);
     if(!matches.empty())
     {
@@ -1710,10 +2129,10 @@ Slice::Container::enumerators(const string& scoped) const
                 string name = scoped.substr(lastColon + 1);
                 for(EnumList::iterator p = enums.begin(); p != enums.end(); ++p)
                 {
-                    ContainedList cl = (*p)->lookupContained(name, false);
-                    if(!cl.empty())
+                    ContainedList cl2 = (*p)->lookupContained(name, false);
+                    if(!cl2.empty())
                     {
-                        result.push_back(EnumeratorPtr::dynamicCast(cl.front()));
+                        result.push_back(EnumeratorPtr::dynamicCast(cl2.front()));
                     }
                 }
             }
@@ -2081,18 +2500,39 @@ Slice::Container::hasOnlyClassDecls() const
 }
 
 bool
-Slice::Container::hasAbstractClassDefs() const
+Slice::Container::hasOperations() const
+{
+    for(ContainedList::const_iterator p = _contents.begin(); p != _contents.end(); ++p)
+    {
+        ClassDefPtr cl = ClassDefPtr::dynamicCast(*p);
+        if(cl && cl->hasOperations())
+        {
+            return true;
+        }
+
+        ContainerPtr container = ContainerPtr::dynamicCast(*p);
+        if(container && container->hasOperations())
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool
+Slice::Container::hasNonLocalAbstractClassDefs() const
 {
     for(ContainedList::const_iterator p = _contents.begin(); p != _contents.end(); ++p)
     {
         ClassDefPtr cl = ClassDefPtr::dynamicCast(*p);
-        if(cl && cl->isAbstract())
+        if(cl && cl->isAbstract() && !cl->isLocal())
         {
             return true;
         }
 
         ContainerPtr container = ContainerPtr::dynamicCast(*p);
-        if(container && container->hasAbstractClassDefs())
+        if(container && container->hasNonLocalAbstractClassDefs())
         {
             return true;
         }
@@ -2276,7 +2716,7 @@ Slice::Container::mergeModules()
             }
 
             //
-            // Compare the global metadata of the two modules being merged.
+            // Compare the file metadata of the two modules being merged.
             //
             DefinitionContextPtr dc2 = mod2->definitionContext();
             assert(dc2);
@@ -2285,7 +2725,7 @@ Slice::Container::mergeModules()
             metaData2.unique();
             if(!checkGlobalMetaData(metaData1, metaData2))
             {
-                unit()->warning(All, "global metadata mismatch for module `" + mod1->name() + "' in files " +
+                unit()->warning(All, "file metadata mismatch for module `" + mod1->name() + "' in files " +
                                 dc1->filename() + " and " + dc2->filename());
             }
 
@@ -2559,74 +2999,6 @@ Slice::Container::Container(const UnitPtr& unit) :
 {
 }
 
-void
-Slice::Container::checkIdentifier(const string& name) const
-{
-    //
-    // Weed out identifiers with reserved suffixes.
-    //
-    static const string suffixBlacklist[] = { "Helper", "Holder", "Prx", "Ptr" };
-    for(size_t i = 0; i < sizeof(suffixBlacklist) / sizeof(*suffixBlacklist); ++i)
-    {
-        if(name.find(suffixBlacklist[i], name.size() - suffixBlacklist[i].size()) != string::npos)
-        {
-            _unit->error("illegal identifier `" + name + "': `" + suffixBlacklist[i] + "' suffix is reserved");
-        }
-    }
-
-    //
-    // Check for illegal underscores.
-    //
-    if(name.find('_') == 0)
-    {
-        _unit->error("illegal leading underscore in identifier `" + name + "'");
-    }
-    else if(name.rfind('_') == name.size() - 1)
-    {
-        _unit->error("illegal trailing underscore in identifier `" + name + "'");
-    }
-    else if(name.find("__") != string::npos)
-    {
-        _unit->error("illegal double underscore in identifier `" + name + "'");
-    }
-    else if(_unit->currentIncludeLevel() == 0 && !_unit->allowUnderscore() && name.find('_') != string::npos)
-    {
-        //
-        // For rules controlled by a translator option, we don't complain about included files.
-        //
-
-        DefinitionContextPtr dc = _unit->currentDefinitionContext();
-        assert(dc);
-        if(dc->findMetaData("underscore") != "underscore") // no "underscore" global metadata
-        {
-            _unit->error("illegal underscore in identifier `" + name + "'");
-        }
-    }
-
-    //
-    // For rules controlled by a translator option, we don't complain about included files.
-    //
-    if(_unit->currentIncludeLevel() == 0 && !_unit->allowIcePrefix())
-    {
-        DefinitionContextPtr dc = _unit->currentDefinitionContext();
-        assert(dc);
-        if(dc->findMetaData("ice-prefix") != "ice-prefix") // no "ice-prefix" global metadata
-        {
-            if(name.size() >= 3)
-            {
-                string prefix3;
-                prefix3 += ::tolower(static_cast<unsigned char>(name[0]));
-                prefix3 += ::tolower(static_cast<unsigned char>(name[1]));
-                prefix3 += ::tolower(static_cast<unsigned char>(name[2]));
-                if(prefix3 == "ice")
-                {
-                    _unit->error("illegal identifier `" + name + "': `" + name.substr(0, 3) + "' prefix is reserved");
-                }
-            }
-        }
-    }
-}
-
 bool
 Slice::Container::checkInterfaceAndLocal(const string& name, bool defined,
                                          bool intf, bool intfOther,
@@ -2693,7 +3065,7 @@ bool
 Slice::Container::checkGlobalMetaData(const StringList& m1, const StringList& m2)
 {
     //
-    // Not all global metadata mismatches represent actual problems. We are only concerned about
+    // Not all file metadata mismatches represent actual problems. We are only concerned about
     // the prefixes listed below (also see bug 2766).
     //
     static const char* prefixes[] =
@@ -3014,8 +3386,6 @@ Slice::Container::validateConstant(const string& name, const TypePtr& type, Synt
 EnumeratorPtr
 Slice::Container::validateEnumerator(const string& name)
 {
-    checkIdentifier(name);
-
     ContainedList matches = _unit->findContents(thisScope() + name);
     if(!matches.empty())
     {
@@ -3214,7 +3584,7 @@ Slice::ClassDecl::recDependencies(set<ConstructedPtr>& dependencies)
 
 void
 Slice::ClassDecl::checkBasesAreLegal(const string& name, bool intf, bool local, const ClassList& bases,
-                                     const UnitPtr& unit)
+                                     const UnitPtr& ut)
 {
     //
     // Local definitions cannot have non-local bases, and vice versa.
@@ -3227,7 +3597,7 @@ Slice::ClassDecl::checkBasesAreLegal(const string& name, bool intf, bool local,
             msg << (local ? "local" : "non-local") << " " << (intf ? "interface" : "class") << " `"
                 << name << "' cannot have " << ((*p)->isLocal() ? "local" : "non-local") << " base "
                 << ((*p)->isInterface() ? "interface" : "class") << " `" << (*p)->name() << "'";
-            unit->error(msg.str());
+            ut->error(msg.str());
         }
     }
 
@@ -3264,7 +3634,7 @@ Slice::ClassDecl::checkBasesAreLegal(const string& name, bool intf, bool local,
         // name (that is, if the union of the intersections of all possible pairs
         // of partitions is empty).
         //
-        checkPairIntersections(spl, name, unit);
+        checkPairIntersections(spl, name, ut);
     }
 }
 
@@ -3366,7 +3736,7 @@ Slice::ClassDecl::toStringPartitionList(const GraphPartitionList& gpl)
 // in the other and, if so, complain.
 //
 void
-Slice::ClassDecl::checkPairIntersections(const StringPartitionList& l, const string& name, const UnitPtr& unit)
+Slice::ClassDecl::checkPairIntersections(const StringPartitionList& l, const string& name, const UnitPtr& ut)
 {
     set<string> reported;
     for(StringPartitionList::const_iterator i = l.begin(); i != l.end(); ++i)
@@ -3383,7 +3753,7 @@ Slice::ClassDecl::checkPairIntersections(const StringPartitionList& l, const str
                     {
                         string msg = "ambiguous multiple inheritance: `" + name;
                         msg += "' inherits operation `" + *s1 + "' from two or more unrelated base interfaces";
-                        unit->error(msg);
+                        ut->error(msg);
                         reported.insert(*s1);
                     }
                     else if(!CICompare()(*s1, *s2) && !CICompare()(*s2, *s1) &&
@@ -3392,7 +3762,7 @@ Slice::ClassDecl::checkPairIntersections(const StringPartitionList& l, const str
                         string msg = "ambiguous multiple inheritance: `" + name;
                         msg += "' inherits operations `" + *s1 + "' and `" + *s2;
                         msg += "', which differ only in capitalization, from unrelated base interfaces";
-                        unit->error(msg);
+                        ut->error(msg);
                         reported.insert(*s1);
                         reported.insert(*s2);
                     }
@@ -3410,7 +3780,7 @@ void
 Slice::ClassDef::destroy()
 {
     _declaration = 0;
-    _bases.empty();
+    _bases.clear();
     Container::destroy();
 }
 
@@ -3421,8 +3791,6 @@ Slice::ClassDef::createOperation(const string& name,
                                  int tag,
                                  Operation::Mode mode)
 {
-    checkIdentifier(name);
-
     ContainedList matches = _unit->findContents(thisScope() + name);
     if(!matches.empty())
     {
@@ -3496,8 +3864,8 @@ Slice::ClassDef::createOperation(const string& name,
             }
 
             string baseName = IceUtilInternal::toLower((*q)->name());
-            string newName = IceUtilInternal::toLower(name);
-            if(baseName == newName)
+            string newName2 = IceUtilInternal::toLower(name);
+            if(baseName == newName2)
             {
                 string msg = "operation `" + name + "' differs only in capitalization from " + (*q)->kindOf();
                 msg += " `" + (*q)->name() + "', which is defined in a base interface or class";
@@ -3533,8 +3901,6 @@ Slice::ClassDef::createDataMember(const string& name, const TypePtr& type, bool
                                   const SyntaxTreeBasePtr& defaultValueType, const string& defaultValue,
                                   const string& defaultLiteral)
 {
-    checkIdentifier(name);
-
     assert(!isInterface());
     ContainedList matches = _unit->findContents(thisScope() + name);
     if(!matches.empty())
@@ -3594,8 +3960,8 @@ Slice::ClassDef::createDataMember(const string& name, const TypePtr& type, bool
             }
 
             string baseName = IceUtilInternal::toLower((*q)->name());
-            string newName = IceUtilInternal::toLower(name);
-            if(baseName == newName)
+            string newName2 = IceUtilInternal::toLower(name);
+            if(baseName == newName2)
             {
                 string msg = "data member `" + name + "' differs only in capitalization from " + (*q)->kindOf();
                 msg += " `" + (*q)->name() + "', which is defined in a base interface or class";
@@ -3703,14 +4069,26 @@ Slice::ClassDef::operations() const
 OperationList
 Slice::ClassDef::allOperations() const
 {
-    OperationList result = operations();
-    result.sort();
-    result.unique();
+    OperationList result;
     for(ClassList::const_iterator p = _bases.begin(); p != _bases.end(); ++p)
     {
         OperationList li = (*p)->allOperations();
-        result.merge(li);
-        result.unique();
+        for(OperationList::const_iterator q = li.begin(); q != li.end(); ++q)
+        {
+            if(find(result.begin(), result.end(), *q) == result.end())
+            {
+                result.push_back(*q);
+            }
+        }
+    }
+
+    OperationList li = operations();
+    for(OperationList::const_iterator q = li.begin(); q != li.end(); ++q)
+    {
+        if(find(result.begin(), result.end(), *q) == result.end())
+        {
+            result.push_back(*q);
+        }
     }
     return result;
 }
@@ -3979,6 +4357,7 @@ Slice::ClassDef::isDelegate() const
 {
     return isLocal() && isInterface() && hasMetaData("delegate") && allOperations().size() == 1;
 }
+
 Slice::ClassDef::ClassDef(const ContainerPtr& container, const string& name, int id, bool intf, const ClassList& bases,
                           bool local) :
     SyntaxTreeBase(container->unit()),
@@ -4060,8 +4439,8 @@ Slice::Proxy::_class() const
 }
 
 Slice::Proxy::Proxy(const ClassDeclPtr& cl) :
-     SyntaxTreeBase(cl->unit()),
-     Type(cl->unit()),
+    SyntaxTreeBase(cl->unit(), cl->definitionContext()),
+    Type(cl->unit()),
     _classDecl(cl)
 {
 }
@@ -4082,8 +4461,6 @@ Slice::Exception::createDataMember(const string& name, const TypePtr& type, bool
                                    const SyntaxTreeBasePtr& defaultValueType, const string& defaultValue,
                                    const string& defaultLiteral)
 {
-    checkIdentifier(name);
-
     ContainedList matches = _unit->findContents(thisScope() + name);
     if(!matches.empty())
     {
@@ -4130,8 +4507,8 @@ Slice::Exception::createDataMember(const string& name, const TypePtr& type, bool
             }
 
             string baseName = IceUtilInternal::toLower((*r)->name());
-            string newName = IceUtilInternal::toLower(name);
-            if(baseName == newName)
+            string newName2 = IceUtilInternal::toLower(name);
+            if(baseName == newName2)
             {
                 string msg = "exception member `" + name + "' differs only in capitalization from exception member `";
                 msg += (*r)->name() + "', which is defined in a base exception";
@@ -5289,8 +5666,6 @@ Slice::Operation::hasMarshaledResult() const
 ParamDeclPtr
 Slice::Operation::createParamDecl(const string& name, const TypePtr& type, bool isOutParam, bool optional, int tag)
 {
-    checkIdentifier(name);
-
     ContainedList matches = _unit->findContents(thisScope() + name);
     if(!matches.empty())
     {
@@ -5685,7 +6060,7 @@ Slice::Operation::attributes() const
             //
             freezeMD = freezeMD.substr(1);
 
-            int i = 0;
+            i = 0;
             while(i < 4)
             {
                 if(freezeMD.find(txAttribute[i]) == 0)
@@ -6171,12 +6546,12 @@ Slice::Unit::addGlobalMetaData(const StringList& metaData)
     assert(dc);
     if(dc->seenDefinition())
     {
-        error("global metadata must appear before any definitions");
+        error("file metadata must appear before any definitions");
     }
     else
     {
         //
-        // Append the global metadata to any existing metadata (e.g., default global metadata).
+        // Append the file metadata to any existing metadata (e.g., default file metadata).
         //
         StringList l = dc->getMetaData();
         copy(metaData.begin(), metaData.end(), back_inserter(l));
@@ -6383,7 +6758,7 @@ Slice::Unit::addTypeId(int compactId, const std::string& typeId)
 }
 
 std::string
-Slice::Unit::getTypeId(int compactId)
+Slice::Unit::getTypeId(int compactId) const
 {
     map<int, string>::const_iterator p = _typeIds.find(compactId);
     if(p != _typeIds.end())
@@ -6393,6 +6768,12 @@ Slice::Unit::getTypeId(int compactId)
     return string();
 }
 
+bool
+Slice::Unit::hasCompactTypeId() const
+{
+    return _typeIds.size() > 0;
+}
+
 bool
 Slice::Unit::usesNonLocals() const
 {
@@ -6514,11 +6895,6 @@ Slice::Unit::parse(const string& filename, FILE* file, bool debug)
         popContainer();
         assert(_definitionContextStack.size() == 1);
         popDefinitionContext();
-
-        if(!checkUndefinedTypes())
-        {
-            status = EXIT_FAILURE;
-        }
     }
 
     Slice::unit = 0;
@@ -6617,113 +6993,6 @@ Slice::Unit::eraseWhiteSpace(string& s)
     }
 }
 
-bool
-Slice::Unit::checkUndefinedTypes()
-{
-    class Visitor : public ParserVisitor
-    {
-    public:
-
-        Visitor(int& errors) :
-            _errors(errors),
-            _local(false)
-        {
-        }
-
-        virtual bool visitClassDefStart(const ClassDefPtr& p)
-        {
-            _local = p->isLocal();
-            return true;
-        }
-
-        virtual bool visitExceptionStart(const ExceptionPtr& p)
-        {
-            _local = p->isLocal();
-            return true;
-        }
-
-        virtual bool visitStructStart(const StructPtr& p)
-        {
-            _local = p->isLocal();
-            return true;
-        }
-
-        virtual void visitOperation(const OperationPtr& p)
-        {
-            if(p->returnType())
-            {
-                checkUndefined(p->returnType(), "return type", p->file(), p->line());
-            }
-            ParamDeclList params = p->parameters();
-            for(ParamDeclList::const_iterator q = params.begin(); q != params.end(); ++q)
-            {
-                checkUndefined((*q)->type(), "parameter " + (*q)->name(), (*q)->file(), (*q)->line());
-            }
-        }
-
-        virtual void visitParamDecl(const ParamDeclPtr& p)
-        {
-            checkUndefined(p->type(), "parameter " + p->name(), p->file(), p->line());
-        }
-
-        virtual void visitDataMember(const DataMemberPtr& p)
-        {
-            checkUndefined(p->type(), "member " + p->name(), p->file(), p->line());
-        }
-
-        virtual void visitSequence(const SequencePtr& p)
-        {
-            _local = p->isLocal();
-            checkUndefined(p->type(), "element type", p->file(), p->line());
-        }
-
-        virtual void visitDictionary(const DictionaryPtr& p)
-        {
-            _local = p->isLocal();
-            checkUndefined(p->keyType(), "key type", p->file(), p->line());
-            checkUndefined(p->valueType(), "value type", p->file(), p->line());
-        }
-
-    private:
-
-        void checkUndefined(const TypePtr& type, const string& desc, const string& file, const string& line)
-        {
-            //
-            // See ICE-6867. Any use of a proxy requires the full type definition, as does any
-            // use of a class in a non-local context.
-            //
-            ProxyPtr p = ProxyPtr::dynamicCast(type);
-            if(p)
-            {
-                const ClassDeclPtr cl = p->_class();
-                if(!cl->definition())
-                {
-                    ostringstream ostr;
-                    ostr << desc << " uses a proxy for undefined type `" << cl->scoped() << "'";
-                    emitError(file, line, ostr.str());
-                    _errors++;
-                }
-            }
-
-            ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
-            if(cl && !cl->definition() && !_local)
-            {
-                ostringstream ostr;
-                ostr << desc << " refers to undefined type `" << cl->scoped() << "'";
-                emitError(file, line, ostr.str());
-                _errors++;
-            }
-        }
-
-        int& _errors;
-        bool _local;
-    };
-
-    Visitor v(_errors);
-    visit(&v, true);
-    return _errors == 0;
-}
-
 // ----------------------------------------------------------------------
 // CICompare
 // ----------------------------------------------------------------------