zeroc-ice 3.8.2 → 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;
 }
@@ -667,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)
 {
@@ -674,30 +760,23 @@ 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())
+    for (const auto& [source, target] : _makefileRules)
     {
-        os << target << ":" << std::endl;
-    }
-    else
-    {
-        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);
 }
@@ -712,11 +791,10 @@ Slice::DependencyGenerator::writeXMLDependencies(const 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>";
     }
@@ -729,14 +807,19 @@ 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);
@@ -92,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);
@@ -118,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);
     }

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

@@ -15,16 +15,19 @@ using namespace IceInternal;
 
 namespace
 {
-    string getEscapedRubyParamName(const OperationPtr& p, const string& name)
+    // Returns the name of the synthesized trailing 'context' parameter for a generated proxy method. It is escaped
+    // to 'context_' when an in-parameter's lower-cased mapped name is already 'context' (e.g. a parameter named
+    // 'Context'), to avoid emitting a duplicate parameter name in the method signature.
+    string getEscapedContextParam(const OperationPtr& p)
     {
-        for (const auto& param : p->parameters())
+        for (const auto& param : p->inParameters())
         {
-            if (Slice::Ruby::getMappedName(param) == name)
+            if (Slice::Ruby::getMappedName(param, Slice::Ruby::IdentToLower) == "context")
             {
-                return name + "_";
+                return "context_";
             }
         }
-        return name;
+        return "context";
     }
 }
 
@@ -319,7 +322,7 @@ Slice::Ruby::CodeVisitor::visitInterfaceDefStart(const InterfaceDefPtr& p)
         {
             _out << inParams << ", ";
         }
-        const string contextParamName = getEscapedRubyParamName(op, "context");
+        const string contextParamName = getEscapedContextParam(op);
         _out << contextParamName << "=nil)";
         _out.inc();
         _out << nl << proxyName << "_mixin::OP_" << op->name() << ".invoke(self, [" << inParams;
@@ -463,8 +466,9 @@ Slice::Ruby::CodeVisitor::visitInterfaceDefStart(const InterfaceDefPtr& p)
         if (op->isDeprecated())
         {
             // Get the deprecation reason if present, or default to an empty string.
-            string reason = op->getDeprecationReason().value_or("");
-            _out << nl << proxyName << "_mixin::OP_" << opName << ".deprecate(\"" << reason << "\")";
+            const string reason = op->getDeprecationReason().value_or("");
+            const string escapedReason = toStringLiteral(reason, "\a\b\f\n\r\t\v\x20\x1b", "#", EC6UCN, 0);
+            _out << nl << proxyName << "_mixin::OP_" << opName << ".deprecate(\"" << escapedReason << "\")";
         }
     }
 
@@ -778,9 +782,7 @@ Slice::Ruby::CodeVisitor::visitEnum(const EnumPtr& p)
     //
     _out << sp << nl << "def <=>(other)";
     _out.inc();
-    _out << nl << "other.is_a?(" << name << ") or raise ArgumentError, \"value must be " << getArticleFor(name) << ' '
-         << name << "\"";
-    _out << nl << "@value <=> other.to_i";
+    _out << nl << "@value <=> other.to_i if other.is_a?(" << name << ")";
     _out.dec();
     _out << nl << "end";
 
@@ -1002,7 +1004,9 @@ Slice::Ruby::CodeVisitor::writeConstantValue(
             case Builtin::KindString:
             {
                 // RubyUCN available in Ruby 1.9 or greater
-                _out << "\"" << toStringLiteral(value, "\a\b\f\n\r\t\v\x20\x1b", "", EC6UCN, 0) << "\"";
+                // Escape '#' so that '#{', '#@', and '#$' are not interpreted as interpolation in the
+                // double-quoted Ruby string literal.
+                _out << "\"" << toStringLiteral(value, "\a\b\f\n\r\t\v\x20\x1b", "#", EC6UCN, 0) << "\"";
                 break;
             }
 

data/dist/ice/cpp/src/slice2rb/RubyUtil.h

@@ -31,13 +31,13 @@ namespace Slice::Ruby
     std::string getMappedName(const ContainedPtr& p, IdentStyle style = IdentNormal);
 
     /// Returns the fully-qualified mapped-identifier of the provided Slice element.
-    /// This is equivalent to calling `getMappedName` on @p p and all it's containers.
+    /// This is equivalent to calling `getMappedName` on @p p and all its containers.
     std::string getAbsolute(const ContainedPtr& p);
 
-    /// Equivalent to `getMappedName` but with "T_" preprended to the name.
+    /// Equivalent to `getMappedName` but with "T_" prepended to the name.
     std::string getMetaTypeName(const ContainedPtr& p);
 
-    /// Equivalent to `getAbsolute` but with "T_" preprended to the name.
+    /// Equivalent to `getAbsolute` but with "T_" prepended to the name.
     std::string getMetaTypeReference(const ContainedPtr& p);
 
     /// Emits a comment header for a generated file.

data/dist/ice/slice/Glacier2/Router.ice

@@ -64,14 +64,14 @@ module Glacier2
         /// @throws PermissionDeniedException Thrown when an authentication or authorization failure occurs.
         /// @throws CannotCreateSessionException Thrown when the session cannot be created.
         /// @see Session
-        /// @see SessionManager
-        /// @see PermissionsVerifier
+        /// @see SSLSessionManager
+        /// @see SSLPermissionsVerifier
         Session* createSessionFromSecureConnection()
             throws PermissionDeniedException, CannotCreateSessionException;
 
         /// Keeps the session with this router alive.
         /// @throws SessionNotExistException Thrown when no session exists for the caller (client).
-        ["deprecated:As of Ice 3.8, this operation does nothing."]
+        ["deprecated:As of Ice 3.8, this operation no longer keeps the session alive; it only verifies that the session exists."]
         void refreshSession()
             throws SessionNotExistException;
 

data/dist/ice/slice/Ice/Metrics.ice

@@ -18,7 +18,7 @@ module IceMX
     /// A dictionary of strings to integers.
     dictionary<string, int> StringIntDict;
 
-    /// The base class for metrics. A metrics object represents a collection of measurements associated to a given a
+    /// The base class for metrics. A metrics object represents a collection of measurements associated with a given
     /// system.
     class Metrics
     {
@@ -32,7 +32,7 @@ module IceMX
         /// The number of objects currently observed by this metrics.
         int current = 0;
 
-        /// The sum of the lifetime of each observed objects. This does not include the lifetime of objects which are
+        /// The sum of the lifetimes of each observed object. This does not include the lifetimes of objects which are
         /// currently observed, only the objects observed in the past.
         long totalLifetime = 0;
 
@@ -71,7 +71,7 @@ module IceMX
     /// metrics of an application that enabled the Ice administrative facility and configured one or more metrics views.
     interface MetricsAdmin
     {
-        /// Gets the names of enabled and disabled metrics.
+        /// Gets the names of the enabled and disabled metrics views.
         /// @param disabledViews The names of the disabled views.
         /// @return The names of the enabled views.
         Ice::StringSeq getMetricsViewNames(out Ice::StringSeq disabledViews);
@@ -107,7 +107,7 @@ module IceMX
         MetricsFailuresSeq getMapMetricsFailures(string view, string map)
             throws UnknownMetricsView;
 
-        /// Gets the metrics failure associated for the given metrics.
+        /// Gets the metrics failures associated with the given metrics.
         /// @param view The name of the metrics view.
         /// @param map The name of the metrics map.
         /// @param id The ID of the metrics.
@@ -170,7 +170,8 @@ module IceMX
     {
     }
 
-    /// Provide measurements for proxy invocations. Proxy invocations can either be sent over the wire or be collocated.
+    /// Provides measurements for proxy invocations. Proxy invocations can either be sent over the wire or be
+    /// collocated.
     class InvocationMetrics extends Metrics
     {
         /// The number of retries for the invocations.