zeroc-ice 3.8.1 → 3.8.3

data/dist/ice/cpp/src/Slice/SliceUtil.cpp

@@ -10,6 +10,7 @@
 #include <cctype>
 #include <climits>
 #include <cstring>
+#include <iomanip>
 
 #ifndef _MSC_VER
 #    include <unistd.h> // For readlink()
@@ -19,6 +20,112 @@ using namespace std;
 using namespace Slice;
 using namespace IceInternal;
 
+namespace
+{
+    void writeDependencies(const string& dependencies, const string& dependFile)
+    {
+        if (dependFile.empty())
+        {
+            consoleOut << dependencies << flush;
+        }
+        else
+        {
+            ofstream of(IceInternal::streamFilename(dependFile).c_str()); // dependFile is a UTF-8 string
+            if (!of)
+            {
+                ostringstream os;
+                os << "cannot open file '" << dependFile << "': " << IceInternal::errorToString(errno);
+                throw Slice::FileException(os.str());
+            }
+            of << dependencies;
+            of.close();
+        }
+    }
+
+    // Escapes a file name and wraps it in double quotes, to produce a JSON string.
+    string toJSONString(string_view name)
+    {
+        ostringstream os;
+        os << '"';
+        for (char c : name)
+        {
+            switch (c)
+            {
+                case '"':
+                    os << "\\\"";
+                    break;
+                case '\\':
+                    os << "\\\\";
+                    break;
+                case '\b':
+                    os << "\\b";
+                    break;
+                case '\f':
+                    os << "\\f";
+                    break;
+                case '\n':
+                    os << "\\n";
+                    break;
+                case '\r':
+                    os << "\\r";
+                    break;
+                case '\t':
+                    os << "\\t";
+                    break;
+                default:
+                    if (static_cast<unsigned char>(c) < 0x20)
+                    {
+                        // The remaining control characters have no short escape sequence.
+                        os << "\\u" << setfill('0') << setw(4) << hex << static_cast<int>(static_cast<unsigned char>(c))
+                           << dec;
+                    }
+                    else
+                    {
+                        // Any other character is written as is, including the bytes of a multi-byte UTF-8 sequence.
+                        os << c;
+                    }
+                    break;
+            }
+        }
+        os << '"';
+        return os.str();
+    }
+
+    // Escapes a file name for use in a Makefile rule, following the escaping rules GCC uses in the dependency
+    // files it emits: '$' becomes '$$'; '#', space, and tab get a preceding backslash; and backslashes
+    // immediately preceding a space or tab are doubled.
+    string escapeMakefilePath(string_view name)
+    {
+        ostringstream os;
+        size_t backslashes = 0;
+        for (char c : name)
+        {
+            switch (c)
+            {
+                case ' ':
+                case '\t':
+                    for (size_t i = 0; i < backslashes; ++i)
+                    {
+                        os << '\\';
+                    }
+                    os << '\\';
+                    break;
+                case '#':
+                    os << '\\';
+                    break;
+                case '$':
+                    os << '$';
+                    break;
+                default:
+                    break;
+            }
+            backslashes = (c == '\\') ? backslashes + 1 : 0;
+            os << c;
+        }
+        return os.str();
+    }
+}
+
 string
 Slice::normalizePath(const string& path)
 {
@@ -172,7 +279,9 @@ Slice::changeInclude(const string& p, const vector<string>& includePaths)
     {
         for (const auto& includePath : includePaths)
         {
-            if (i.compare(0, includePath.length(), includePath) == 0)
+            // The prefix test needs a path boundary, or "/a/b" would cover a file under "/a/bc".
+            if (i.length() > includePath.length() + 1 && i[includePath.length()] == '/' &&
+                i.compare(0, includePath.length(), includePath) == 0)
             {
                 string s = i.substr(includePath.length() + 1); // + 1 for the '/'
                 if (s.size() < result.size())
@@ -316,8 +425,6 @@ Slice::emitRaw(const char* message)
 vector<string>
 Slice::filterMcppWarnings(const string& message)
 {
-    static const char* messages[] = {"Converted [CR+LF] to [LF]", "no newline, supplemented newline", nullptr};
-
     constexpr string_view warningPrefix = "warning:";
     constexpr string_view fromPrefix = "from";
     constexpr string_view separators = "\n\t ";
@@ -330,60 +437,34 @@ Slice::filterMcppWarnings(const string& message)
         in.push_back(message.substr(start, end - start));
         start = end + 1;
     }
+
     vector<string> out;
-    bool skipped;
-    for (auto i = in.begin(); i != in.end(); i++)
+    for (auto i = in.begin(); i != in.end();)
     {
-        skipped = false;
+        bool hasWarningPrefix = i->find(warningPrefix) != string::npos;
+        bool hasFilterableWarning = i->find("Converted [CR+LF] to [LF]") != string::npos ||
+                                    i->find("no newline, supplemented newline") != string::npos;
 
-        if (i->find(warningPrefix) != string::npos)
+        if (hasWarningPrefix && hasFilterableWarning)
         {
-            for (int j = 0; messages[j] != nullptr; ++j)
+            // MCPP warnings are multi-line. The first line contains the warning message, followed by a single-line text
+            // snippet of the code that produced the warning. After this can follow any number of "from" lines.
+            assert(std::distance(i, in.end()) >= 2); // Assert there's at least 2 lines to skip (message & snippet).
+
+            // Immediately skip 2 lines (the message and the snippet). Then skip any "from" lines that followed them.
+            for (i += 2; i != in.end(); i++)
             {
-                if (i->find(messages[j]) != string::npos)
+                string::size_type index = i->find_first_not_of(separators);
+                if (index == string::npos || i->find(fromPrefix, index) != index)
                 {
-                    // This line should be skipped it contains the unwanted mcpp warning
-                    // next line should also be skipped it contains the slice line that
-                    // produces the skipped warning
-                    i++;
-                    skipped = true;
-                    //
-                    // Check if next lines are still the same warning
-                    //
-                    i++;
-                    while (i != in.end())
-                    {
-                        string token = *i;
-                        string::size_type index = token.find_first_not_of(separators);
-                        if (index != string::npos)
-                        {
-                            token = token.substr(index);
-                        }
-                        if (token.find(fromPrefix) != 0)
-                        {
-                            //
-                            // First line not of this warning
-                            //
-                            i--;
-                            break;
-                        }
-                        else
-                        {
-                            i++;
-                        }
-                    }
-                    break;
+                    break; // This line isn't part of the warning we're skipping. Break, and go back to the outer loop.
                 }
             }
-            if (i == in.end())
-            {
-                break;
-            }
-        }
-        if (!skipped)
-        {
-            out.push_back(*i + "\n");
+            continue; // Continue to the next loop iteration, to check if it's a warning that should be filtered out.
         }
+
+        // Add this line to the output, and move to the next line. We only reach here if the line wasn't filtered out.
+        out.push_back(*i++ + "\n");
     }
     return out;
 }
@@ -401,27 +482,6 @@ Slice::printGeneratedHeader(IceInternal::Output& out, string_view path, string_v
     out << nl << commentStyle << " <auto-generated>Generated from Slice file '" << path << "'.</auto-generated>";
 }
 
-void
-Slice::writeDependencies(const string& dependencies, const string& dependFile)
-{
-    if (dependFile.empty())
-    {
-        consoleOut << dependencies << flush;
-    }
-    else
-    {
-        ofstream of(IceInternal::streamFilename(dependFile).c_str()); // dependFile is a UTF-8 string
-        if (!of)
-        {
-            ostringstream os;
-            os << "cannot open file '" << dependFile << "': " << IceInternal::errorToString(errno);
-            throw Slice::FileException(os.str());
-        }
-        of << dependencies;
-        of.close();
-    }
-}
-
 #ifdef _WIN32
 vector<string>
 Slice::argvToArgs(int argc, wchar_t* argv[])
@@ -451,33 +511,20 @@ Slice::argvToArgs(int argc, char* argv[])
 // Split a scoped name into its components and return the components as a list of (unscoped) identifiers.
 //
 vector<string>
-Slice::splitScopedName(const string& scoped, bool allowEmpty)
+Slice::splitScopedName(const string& scoped)
 {
-    assert(scoped[0] == ':');
+    assert(scoped.compare(0, 2, "::") == 0); // must be a fully-scoped identifier
+    assert(scoped.back() != ':');            // must end with an identifier (not just "::")
+
     vector<string> ids;
-    string::size_type next = 0;
+    string::size_type next = 2; // skip the leading "::"
     string::size_type pos;
     while ((pos = scoped.find("::", next)) != string::npos)
     {
-        pos += 2;
-        if (pos != scoped.size())
-        {
-            string::size_type endpos = scoped.find("::", pos);
-            if (endpos != string::npos)
-            {
-                ids.push_back(scoped.substr(pos, endpos - pos));
-            }
-        }
-        next = pos;
-    }
-    if (next != scoped.size())
-    {
-        ids.push_back(scoped.substr(next));
-    }
-    else if (allowEmpty)
-    {
-        ids.emplace_back("");
+        ids.push_back(scoped.substr(next, pos - next));
+        next = pos + 2;
     }
+    ids.push_back(scoped.substr(next));
 
     return ids;
 }
@@ -489,7 +536,7 @@ Slice::getArticleFor(const string& s)
     return (vowels.find_first_of(s[0]) != string::npos) ? "an" : "a";
 }
 
-std::string
+string
 Slice::pluralKindOf(const ContainedPtr& p)
 {
     string kindOf = p->kindOf();
@@ -507,58 +554,6 @@ Slice::pluralKindOf(const ContainedPtr& p)
     }
 }
 
-bool
-Slice::reportIllegalSuffixOrUnderscore(const string& identifier)
-{
-    // check whether the identifier is scoped
-    size_t scopeIndex = identifier.rfind("::");
-    bool isScoped = scopeIndex != string::npos;
-    string name;
-    if (isScoped)
-    {
-        name = identifier.substr(scopeIndex + 2); // Only check the unscoped identifier for syntax
-    }
-    else
-    {
-        name = identifier;
-    }
-
-    assert(!name.empty());
-    bool isValid = true;
-
-    // check the identifier for reserved suffixes
-    static const string suffixBlacklist[] = {"Helper", "Holder", "Prx", "Ptr"};
-    for (const auto& i : suffixBlacklist)
-    {
-        if (name.find(i, name.size() - i.size()) != string::npos)
-        {
-            currentUnit->error("illegal identifier '" + name + "': '" + i + "' suffix is reserved");
-            isValid = false;
-            break;
-        }
-    }
-
-    // check the identifier for illegal underscores
-    size_t index = name.find('_');
-    if (index == 0)
-    {
-        currentUnit->error("illegal leading underscore in identifier '" + name + "'");
-        isValid = false;
-    }
-    else if (name.rfind('_') == (name.size() - 1))
-    {
-        currentUnit->error("illegal trailing underscore in identifier '" + name + "'");
-        isValid = false;
-    }
-    else if (name.find("__") != string::npos)
-    {
-        currentUnit->error("illegal double underscore in identifier '" + name + "'");
-        isValid = false;
-    }
-
-    return isValid;
-}
-
 bool
 Slice::isProxyType(const TypePtr& type)
 {
@@ -635,7 +630,7 @@ Slice::getFirstSentence(const StringList& lines)
 }
 
 string
-Slice::getEscapedParamName(const ParameterList& params, std::string_view param)
+Slice::getEscapedParamName(const ParameterList& params, string_view param)
 {
     for (const auto& p : params)
     {
@@ -650,14 +645,14 @@ Slice::getEscapedParamName(const ParameterList& params, std::string_view param)
 string
 Slice::getTypeScopedName(const TypePtr& type)
 {
-    if (auto builtin = std::dynamic_pointer_cast<Builtin>(type))
+    if (auto builtin = dynamic_pointer_cast<Builtin>(type))
     {
         return builtin->kindAsString();
     }
     else
     {
         // a type is either built-in or contained
-        auto contained = std::dynamic_pointer_cast<Contained>(type);
+        auto contained = dynamic_pointer_cast<Contained>(type);
         assert(contained);
         return contained->scoped();
     }
@@ -719,6 +714,45 @@ Slice::relativePath(const string& path1, const string& path2)
     return newPath;
 }
 
+string
+Slice::escapeXMLAttribute(string_view name)
+{
+    ostringstream os;
+    for (char c : name)
+    {
+        switch (c)
+        {
+            case '&':
+                os << "&amp;";
+                break;
+            case '<':
+                os << "&lt;";
+                break;
+            case '>':
+                os << "&gt;";
+                break;
+            case '"':
+                os << "&quot;";
+                break;
+            // An XML parser replaces a literal tab, line feed or carriage return in an attribute value by a
+            // space. Character references survive this normalization.
+            case '\t':
+                os << "&#x9;";
+                break;
+            case '\n':
+                os << "&#xA;";
+                break;
+            case '\r':
+                os << "&#xD;";
+                break;
+            default:
+                os << c;
+                break;
+        }
+    }
+    return os.str();
+}
+
 void
 Slice::DependencyGenerator::addDependenciesFor(const UnitPtr& unit)
 {
@@ -726,36 +760,29 @@ Slice::DependencyGenerator::addDependenciesFor(const UnitPtr& unit)
 }
 
 void
-Slice::DependencyGenerator::writeMakefileDependencies(
-    const string& dependFile,
-    const string& source,
-    const string& target)
+Slice::DependencyGenerator::addMakefileRule(const string& source, const string& target)
+{
+    _makefileRules.emplace_back(source, target);
+}
+
+void
+Slice::DependencyGenerator::writeMakefileDependencies(const string& dependFile)
 {
     ostringstream os;
-    StringList dependencies = _dependencyMap[source];
-    // Write the target
-    if (dependencies.empty())
-    {
-        os << target << ":" << std::endl;
-    }
-    else
+    for (const auto& [source, target] : _makefileRules)
     {
-        os << target << ": \\" << std::endl;
-        for (const auto& dependency : dependencies)
+        os << escapeMakefilePath(target) << ":";
+        for (const auto& dependency : _dependencyMap[source])
         {
-            os << " " << dependency;
-            if (dependency != dependencies.back())
-            {
-                os << " \\";
-            }
-            os << std::endl;
+            os << " \\" << endl << " " << escapeMakefilePath(dependency);
         }
+        os << endl;
     }
     writeDependencies(os.str(), dependFile);
 }
 
 void
-Slice::DependencyGenerator::writeXMLDependencies(const std::string& dependFile)
+Slice::DependencyGenerator::writeXMLDependencies(const string& dependFile)
 {
     ostringstream os;
     os << R"(<?xml version="1.0" encoding="UTF-8"?>)";
@@ -764,11 +791,10 @@ Slice::DependencyGenerator::writeXMLDependencies(const std::string& dependFile)
     {
         string source = dependencies.front();
         dependencies.pop_front();
-        string dirName = Slice::dirName(source);
-        os << endl << "  <source name=\"" << source << "\">";
+        os << endl << "  <source name=\"" << escapeXMLAttribute(source) << "\">";
         for (const auto& dependency : dependencies)
         {
-            os << endl << "    <dependsOn name=\"" << dependency << "\" />";
+            os << endl << "    <dependsOn name=\"" << escapeXMLAttribute(dependency) << "\" />";
         }
         os << endl << "  </source>";
     }
@@ -777,18 +803,23 @@ Slice::DependencyGenerator::writeXMLDependencies(const std::string& dependFile)
 }
 
 void
-Slice::DependencyGenerator::writeJSONDependencies(const std::string& dependFile)
+Slice::DependencyGenerator::writeJSONDependencies(const string& dependFile)
 {
     ostringstream os;
     os << "{";
+    bool firstSource = true;
     for (auto [_, dependencies] : _dependencyMap)
     {
         string source = dependencies.front();
         dependencies.pop_front();
-        os << endl << "  \"" << source << "\" : [";
+        os << (firstSource ? "" : ",") << endl << "  " << toJSONString(source) << " : [";
+        firstSource = false;
+
+        bool firstDependency = true;
         for (const auto& dependency : dependencies)
         {
-            os << endl << "    \"" << dependency << "\"";
+            os << (firstDependency ? "" : ",") << endl << "    " << toJSONString(dependency);
+            firstDependency = false;
         }
         os << endl << "  ]";
     }

data/dist/ice/cpp/src/Slice/StringLiteralUtil.cpp

@@ -384,8 +384,6 @@ Slice::toStringLiteral(
     }
     else
     {
-        assert(escapeMode == Octal);
-
         for (size_t i = 0; i < value.size(); ++i)
         {
             char c = value[i];

data/dist/ice/cpp/src/Slice/Util.h

@@ -59,9 +59,7 @@ namespace Slice
         EscapeMode escapeMode,
         unsigned char cutOff);
 
-    void writeDependencies(const std::string& dependencies, const std::string& dependFile);
-
-    std::vector<std::string> splitScopedName(const std::string& scoped, bool allowEmpty = true);
+    std::vector<std::string> splitScopedName(const std::string& scoped);
 
     /// Returns "an" if @p s starts with a vowel and "a" otherwise.
     std::string getArticleFor(const std::string& s);
@@ -70,9 +68,6 @@ namespace Slice
     /// @see Contained::kindOf
     std::string pluralKindOf(const ContainedPtr& p);
 
-    // Checks an identifier for illegal syntax and reports any errors that are present.
-    bool reportIllegalSuffixOrUnderscore(const std::string& identifier);
-
     bool isProxyType(const TypePtr& type);
 
     // Is this the first element defined in its container?
@@ -95,25 +90,36 @@ namespace Slice
 
     [[nodiscard]] std::string relativePath(const std::string& path1, const std::string& path2);
 
+    /// Escapes a file name for use in a double-quoted XML attribute value.
+    /// @param name The file name to escape.
+    /// @return The escaped file name.
+    [[nodiscard]] std::string escapeXMLAttribute(std::string_view name);
+
     /// The DependencyGenerator class is used to collect dependencies of Slice units.
     class DependencyGenerator final
     {
     public:
         void addDependenciesFor(const UnitPtr& unit);
 
+        /// Records a Makefile rule for a file that is generated from the specified source. The rule's prerequisites
+        /// are the dependencies recorded for the source by addDependenciesFor.
+        ///
+        /// @param source The source file that the target is generated from.
+        /// @param target The generated file, used as the Makefile target.
+        void addMakefileRule(const std::string& source, const std::string& target);
+
         /// Writes the dependencies in Makefile format to the specified file. If 'dependFile' is empty, it writes the
         /// dependencies to standard output instead.
         ///
+        /// This method writes one rule for each target recorded with addMakefileRule.
+        ///
         /// @param dependFile The file to write the dependencies to or empty to write to standard output.
-        /// @param source The source file for which dependencies are being written.
-        /// @param target The target file that is generated from the source. This is used as the Makefile target.
-        void
-        writeMakefileDependencies(const std::string& dependFile, const std::string& source, const std::string& target);
+        void writeMakefileDependencies(const std::string& dependFile);
 
         /// Writes the dependencies in XML format to the specified file. If 'dependFile' is empty, it writes the
         /// dependencies to standard output instead.
         ///
-        /// This method write the dependencies for all visited units in a single XML document.
+        /// This method writes the dependencies for all visited units in a single XML document.
         ///
         /// @param dependFile The file to write the dependencies to or empty to write to standard output.
         void writeXMLDependencies(const std::string& dependFile);
@@ -121,13 +127,16 @@ namespace Slice
         /// Writes the dependencies in JSON format to the specified file. If 'dependFile' is empty, it writes the
         /// dependencies to standard output instead.
         ///
-        /// This method write the dependencies for all visited units in a single JSON document.
+        /// This method writes the dependencies for all visited units in a single JSON document.
         ///
         /// @param dependFile The file to write the dependencies to or empty to write to standard output.
         void writeJSONDependencies(const std::string& dependFile);
 
     private:
         std::map<std::string, StringList> _dependencyMap;
+
+        // The rules recorded by addMakefileRule: (source, target) pairs, in recording order.
+        std::vector<std::pair<std::string, std::string>> _makefileRules;
     };
 
     /// Helper method to create the directory structure for a package path.

data/dist/ice/cpp/src/slice2rb/Ruby.cpp

@@ -171,9 +171,9 @@ Slice::Ruby::compile(const vector<string>& argv)
                 if (depend)
                 {
                     string target = removeExtension(baseName(fileName)) + ".rb";
-                    dependencyGenerator.writeMakefileDependencies(dependFile, unit->topLevelFile(), target);
+                    dependencyGenerator.addMakefileRule(unit->topLevelFile(), target);
                 }
-                // Else XML dependencies are written below after all units have been processed.
+                // The dependencies are written below, after all units have been processed.
             }
             else
             {
@@ -241,7 +241,11 @@ Slice::Ruby::compile(const vector<string>& argv)
         return status;
     }
 
-    if (dependXML)
+    if (depend)
+    {
+        dependencyGenerator.writeMakefileDependencies(dependFile);
+    }
+    else if (dependXML)
     {
         dependencyGenerator.writeXMLDependencies(dependFile);
     }