zeroc-ice 3.7.9.1 → 3.8.0

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

@@ -0,0 +1,448 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "Ice/StringConverter.h"
+#include "Util.h"
+
+#include <cassert>
+#include <iomanip>
+
+using namespace std;
+using namespace Slice;
+using namespace Ice;
+using namespace IceInternal;
+
+namespace
+{
+    class StringLiteralGenerator final
+    {
+    public:
+        StringLiteralGenerator(string, const string&, EscapeMode, unsigned char);
+
+        string escapeASCIIChar(char);
+        string escapeCodePoint(unsigned int);
+        string flushU8Buffer(vector<unsigned char>&);
+
+        enum Format
+        {
+            NoFormat,
+            OctalFormat,
+            HexFormat
+        };
+        void format(Format);
+
+    private:
+        const string _nonPrintableEscaped;
+        const string _printableEscaped;
+        const EscapeMode _escapeMode;
+        const unsigned char _cutOff;
+        const string _shortUCNPrefix;
+        const string _octalChars;
+        const string _hexChars;
+
+        Format _format{NoFormat}; // The last format used for an escape.
+    };
+
+    StringLiteralGenerator::StringLiteralGenerator(
+        string nonPrintableEscaped,
+        const string& printableEscaped,
+        EscapeMode escapeMode,
+        unsigned char cutOff)
+        : _nonPrintableEscaped(std::move(nonPrintableEscaped)),
+          _printableEscaped(printableEscaped + "\\"),
+          _escapeMode(escapeMode),
+          _cutOff(cutOff),
+          _shortUCNPrefix(escapeMode == Matlab ? "\\x" : "\\u"),
+          _octalChars("01234567"),
+          _hexChars("01234567890ABCDEFabcdef")
+
+    {
+        //
+        // Double quotes don't need to be escaped in Matlab because the string delimiter is a single quote.
+        //
+        if (_escapeMode != Matlab)
+        {
+            const_cast<string&>(_printableEscaped) += '"';
+        }
+    }
+
+    string StringLiteralGenerator::escapeASCIIChar(char c)
+    {
+        assert(static_cast<unsigned char>(c) < 128);
+
+        string result;
+
+        Format lastFormat = _format;
+        _format = NoFormat;
+
+        if (_nonPrintableEscaped.find(c) != string::npos)
+        {
+            switch (c)
+            {
+                case '\a':
+                {
+                    result = "\\a";
+                    break;
+                }
+                case '\b':
+                {
+                    result = "\\b";
+                    break;
+                }
+                case '\f':
+                {
+                    result = "\\f";
+                    break;
+                }
+                case '\n':
+                {
+                    result = "\\n";
+                    break;
+                }
+                case '\r':
+                {
+                    result = "\\r";
+                    break;
+                }
+                case '\t':
+                {
+                    result = "\\t";
+                    break;
+                }
+                case '\v':
+                {
+                    result = "\\v";
+                    break;
+                }
+                case '\0':
+                {
+                    result = "\\0";
+                    break;
+                }
+                case '\x20':
+                {
+                    result = "\\s";
+                    break;
+                }
+                case '\x1b':
+                {
+                    result = "\\e";
+                    break;
+                }
+                default:
+                {
+                    // The caller cannot add additional non-printable ASCII characters!
+                    assert(0);
+                }
+            }
+        }
+        else if (_printableEscaped.find(c) != string::npos)
+        {
+            result = '\\';
+            result += c;
+        }
+        else if (_escapeMode == Matlab && c == '\'')
+        {
+            //
+            // Matlab strings are converted by sprintf(), and sprintf() requires a single quote to be escaped
+            // with another single quote.
+            //
+            result = "''";
+        }
+        else if (_escapeMode == Matlab && c == '%')
+        {
+            //
+            // Matlab strings are converted by sprintf(), and sprintf() requires a percent to be escaped
+            // with another percent.
+            //
+            result = "%%";
+        }
+        else if (c >= 32 && c <= 126)
+        {
+            //
+            // Other printable ASCII.
+            //
+            if (_escapeMode == Matlab)
+            {
+                //
+                // While interpreting an octal or hex escape, the Matlab parser will continue to consume adjacent
+                // legal characters. If the trailing character after an escaped value could be consumed, we escape it
+                // as well to terminate the original escape.
+                //
+                if ((lastFormat == OctalFormat && _octalChars.find(c) != string::npos) ||
+                    (lastFormat == HexFormat && _hexChars.find(c) != string::npos))
+                {
+                    ostringstream os;
+                    os << "\\" << oct << setfill('0') << setw(3) << static_cast<unsigned int>(c & 0xFF);
+                    result = os.str();
+                    _format = OctalFormat;
+                }
+                else
+                {
+                    result = c;
+                }
+            }
+            else
+            {
+                result = c;
+            }
+        }
+        else
+        {
+            // Other non-printable ASCII character
+            ostringstream os;
+            if ((static_cast<unsigned char>(c) < _cutOff) || (_escapeMode == Octal))
+            {
+                os << "\\" << oct << setfill('0') << setw(3) << static_cast<unsigned int>(c & 0xFF);
+                _format = OctalFormat;
+            }
+            else if (_escapeMode == EC6UCN)
+            {
+                os << "\\u{" << hex << setfill('0') << setw(4) << static_cast<unsigned int>(c & 0xFF) << "}";
+                _format = HexFormat;
+            }
+            else
+            {
+                os << _shortUCNPrefix << hex << setfill('0') << setw(4) << static_cast<unsigned int>(c & 0xFF);
+                _format = HexFormat;
+            }
+            result = os.str();
+        }
+        return result;
+    }
+
+    string StringLiteralGenerator::escapeCodePoint(unsigned int codePoint)
+    {
+        if (codePoint < 128)
+        {
+            return escapeASCIIChar(static_cast<char>(codePoint));
+        }
+        else if (_escapeMode == Octal)
+        {
+            vector<unsigned int> u32buffer;
+            u32buffer.push_back(codePoint);
+            vector<unsigned char> u8buffer = fromUTF32(u32buffer);
+
+            ostringstream os;
+            for (unsigned char& q : u8buffer)
+            {
+                os << "\\" << setfill('0') << setw(3) << oct << static_cast<unsigned int>(q);
+            }
+            _format = OctalFormat;
+            return os.str();
+        }
+        else
+        {
+            ostringstream os;
+            if (_escapeMode == EC6UCN)
+            {
+                os << "\\u{" << hex << codePoint << "}";
+            }
+            else if (codePoint < _cutOff)
+            {
+                //
+                // Output octal escape
+                //
+                os << "\\" << setfill('0') << setw(3) << oct << codePoint;
+                _format = OctalFormat;
+            }
+            else if (codePoint <= 0xFFFF)
+            {
+                os << _shortUCNPrefix << setfill('0') << setw(4) << hex << codePoint;
+                _format = HexFormat;
+            }
+            else if (_escapeMode == ShortUCN || _escapeMode == Matlab)
+            {
+                //
+                // Convert to surrogate pair
+                //
+                unsigned int highSurrogate = ((codePoint - 0x10000) / 0x400) + 0xD800;
+                unsigned int lowSurrogate = ((codePoint - 0x10000) % 0x400) + 0xDC00;
+                os << _shortUCNPrefix << setfill('0') << setw(4) << hex << highSurrogate;
+                os << _shortUCNPrefix << setfill('0') << setw(4) << hex << lowSurrogate;
+                _format = HexFormat;
+            }
+            else
+            {
+                os << "\\U" << setfill('0') << setw(8) << hex << codePoint;
+            }
+            return os.str();
+        }
+    }
+
+    string StringLiteralGenerator::flushU8Buffer(vector<unsigned char>& u8buffer)
+    {
+        if (u8buffer.empty())
+        {
+            return "";
+        }
+        else
+        {
+            ostringstream os;
+            vector<unsigned int> u32buffer = toUTF32(u8buffer);
+
+            for (unsigned int& p : u32buffer)
+            {
+                os << escapeCodePoint(p);
+            }
+            u8buffer.clear();
+            return os.str();
+        }
+    }
+
+    void StringLiteralGenerator::format(Format f) { _format = f; }
+}
+
+string
+Slice::toStringLiteral(
+    const string& value,
+    const string& nonPrintableEscaped,
+    const string& printableEscaped,
+    EscapeMode escapeMode,
+    unsigned char cutOff)
+{
+    StringLiteralGenerator generator(nonPrintableEscaped, printableEscaped, escapeMode, cutOff);
+
+    ostringstream os;
+
+    if (escapeMode != Octal)
+    {
+        vector<unsigned char> u8buffer; // Buffer to convert multibyte characters
+
+        for (size_t i = 0; i < value.size(); ++i)
+        {
+            char c = value[i];
+
+            if (static_cast<unsigned char>(c) >= 128)
+            {
+                // New UTF-8 byte
+                u8buffer.push_back(static_cast<unsigned char>(c));
+            }
+            else
+            {
+                //
+                // First write any outstanding UTF-8 -encoded characters
+                //
+                os << generator.flushU8Buffer(u8buffer);
+
+                if (c == '\\')
+                {
+                    if (i + 1 == value.size())
+                    {
+                        // trailing backslash, add a second one
+                        os << "\\\\";
+                    }
+                    else
+                    {
+                        c = value[++i];
+
+                        if (c == '\\')
+                        {
+                            os << "\\\\";
+                            generator.format(StringLiteralGenerator::NoFormat);
+                        }
+                        else if (c == 'u' || c == 'U')
+                        {
+                            size_t sz = c == 'U' ? 8 : 4;
+                            string codePointStr = value.substr(i + 1, sz);
+                            assert(codePointStr.size() == sz);
+
+                            int64_t v = std::stoll(codePointStr, nullptr, 16);
+                            if (v < 128)
+                            {
+                                // ASCII character that may need to escaped in languages such as Java
+                                os << generator.escapeASCIIChar(static_cast<char>(v));
+                            }
+                            else if (escapeMode == UCN)
+                            {
+                                // keep this escape as is
+                                os << "\\" << c << codePointStr;
+                            }
+                            else if (c == 'u' && escapeMode != EC6UCN)
+                            {
+                                os << (escapeMode == Matlab ? "\\x" : "\\u") << codePointStr;
+                                generator.format(StringLiteralGenerator::HexFormat);
+                            }
+                            else
+                            {
+                                os << generator.escapeCodePoint(static_cast<unsigned int>(v));
+                            }
+                            i += sz;
+                        }
+                        else
+                        {
+                            // unescaped backslash: escape it!
+                            generator.format(StringLiteralGenerator::NoFormat);
+                            os << "\\\\";
+                            os << generator.escapeASCIIChar(c);
+                        }
+                    }
+                }
+                else
+                {
+                    os << generator.escapeASCIIChar(c);
+                }
+            }
+        }
+
+        //
+        // Write any outstanding UTF-8 -encoded characters
+        //
+        os << generator.flushU8Buffer(u8buffer);
+    }
+    else
+    {
+        assert(escapeMode == Octal);
+
+        for (size_t i = 0; i < value.size(); ++i)
+        {
+            char c = value[i];
+
+            if (static_cast<unsigned char>(c) >= 128)
+            {
+                // Write octal escape
+                os << "\\" << setfill('0') << setw(3) << oct << static_cast<unsigned int>(c & 0xFF);
+            }
+            else if (c == '\\')
+            {
+                if (i + 1 == value.size())
+                {
+                    // trailing backslash, add a second one
+                    os << "\\\\";
+                }
+                else
+                {
+                    c = value[++i];
+
+                    if (c == '\\')
+                    {
+                        os << "\\\\";
+                    }
+                    else if (c == 'u' || c == 'U')
+                    {
+                        //
+                        // Convert code point to UTF-8 bytes and write the escaped bytes
+                        //
+                        size_t sz = c == 'U' ? 8 : 4;
+                        string codePointStr = value.substr(i + 1, sz);
+                        assert(codePointStr.size() == sz);
+
+                        int64_t v = std::stoll(codePointStr, nullptr, 16);
+                        os << generator.escapeCodePoint(static_cast<unsigned int>(v));
+                        i += sz;
+                    }
+                    else
+                    {
+                        // unescaped backslash
+                        os << "\\\\";
+                        os << generator.escapeASCIIChar(c);
+                    }
+                }
+            }
+            else
+            {
+                os << generator.escapeASCIIChar(c);
+            }
+        }
+    }
+    return os.str();
+}

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

@@ -0,0 +1,134 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef SLICE_UTIL_H
+#define SLICE_UTIL_H
+
+#include "../Ice/OutputUtil.h"
+#include "Parser.h"
+
+namespace Slice
+{
+    std::string normalizePath(const std::string& path);
+    std::string fullPath(const std::string& path);
+    std::string changeInclude(const std::string& path, const std::vector<std::string>& includePaths);
+    std::string removeExtension(const std::string& path);
+    std::string baseName(const std::string& path);
+    std::string dirName(const std::string& path);
+    void emitError(std::string_view file, int line, std::string_view message);
+    void emitWarning(std::string_view file, int line, std::string_view message);
+    void emitRaw(const char* message);
+    std::vector<std::string> filterMcppWarnings(const std::string& message);
+    void printGeneratedHeader(IceInternal::Output& out, std::string_view path, std::string_view commentStyle = "//");
+#ifdef _WIN32
+    std::vector<std::string> argvToArgs(int argc, wchar_t* argv[]);
+#else
+    std::vector<std::string> argvToArgs(int argc, char* argv[]);
+#endif
+
+    enum EscapeMode
+    {
+        UCN,
+        Octal,
+        ShortUCN,
+        Matlab,
+        EC6UCN
+    };
+
+    // Parameters:
+    // const string& value: input string provided by Slice Parser
+    // const string& nonPrintableEscaped: which of \a, \b, \f, \n, \r, \t, \v, \0 (null), \x20 (\s), \x1b (\e) are
+    //                                    escaped in the target language
+    //                                    Warning: don't include \0 if the target language recognizes octal escapes
+    // const string& printableEscaped: additional printable ASCII characters other than \ and the string delimiter
+    //                                 that need to be escaped
+    // EscapeMode escapeMode: whether we generate both UCNs, octal escape sequences, only short UCNs (\unnnn),
+    //                        Matlab syntax, or ECMAScript 6-style UCNs with \u{...} for astral characters.
+    // unsigned char cutOff: characters < cutOff other than the nonPrintableEscaped are generated as
+    //                       octal escape sequences, regardless of escapeMode.
+    std::string toStringLiteral(
+        const std::string& value,
+        const std::string& nonPrintableEscaped,
+        const std::string& printableEscaped,
+        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);
+
+    /// Returns "an" if @p s starts with a vowel and "a" otherwise.
+    std::string getArticleFor(const std::string& s);
+
+    /// Returns the 'kindOf' string for the provided Slice definition, but correctly pluralized.
+    /// @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?
+    bool isFirstElement(const ContainedPtr& p);
+
+    /// Returns the first sentence in the provided list of lines.
+    std::string getFirstSentence(const StringList& lines);
+
+    /// Checks if @p param collides with any mapped name in @p params. If yes, return param followed by an underscore;
+    /// otherwise, return param as is.
+    /// @param params The parameter list to check against.
+    /// @param param The parameter name to check.
+    /// @return The parameter name, possibly modified to avoid collisions.
+    std::string getEscapedParamName(const ParameterList& params, std::string_view param);
+
+    /// Gets the name of a Slice type, e.g. "int", "string", "::M::MyClass", etc.
+    /// @param type The type.
+    /// @return The fully qualified name of the type.
+    std::string getTypeScopedName(const TypePtr& type);
+
+    [[nodiscard]] std::string relativePath(const std::string& path1, const std::string& path2);
+
+    /// The DependencyGenerator class is used to collect dependencies of Slice units.
+    class DependencyGenerator final
+    {
+    public:
+        void addDependenciesFor(const UnitPtr& unit);
+
+        /// Writes the dependencies in Makefile format to the specified file. If 'dependFile' is empty, it writes the
+        /// dependencies to standard output instead.
+        ///
+        /// @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);
+
+        /// 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.
+        ///
+        /// @param dependFile The file to write the dependencies to or empty to write to standard output.
+        void writeXMLDependencies(const std::string& dependFile);
+
+        /// 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.
+        ///
+        /// @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;
+    };
+
+    /// Helper method to create the directory structure for a package path.
+    /// This method creates all necessary directories for the specified package path,
+    /// relative to the given output path. The output path must be an existing directory.
+    ///
+    /// @param packagePath The package path to create, relative to @p outputPath.
+    /// @param outputPath  The base output directory. Must already exist.
+    void createPackagePath(const std::string& packagePath, const std::string& outputPath);
+}
+#endif

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

@@ -0,0 +1,33 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "../Ice/ConsoleUtil.h"
+#include "../Slice/Util.h"
+#include "RubyUtil.h"
+
+using namespace std;
+using namespace IceInternal;
+
+#ifdef _WIN32
+int
+wmain(int argc, wchar_t* argv[])
+#else
+int
+main(int argc, char* argv[])
+#endif
+{
+    vector<string> args = Slice::argvToArgs(argc, argv);
+    try
+    {
+        return Slice::Ruby::compile(args);
+    }
+    catch (const std::exception& ex)
+    {
+        consoleErr << args[0] << ": error:" << ex.what() << endl;
+        return EXIT_FAILURE;
+    }
+    catch (...)
+    {
+        consoleErr << args[0] << ": error:unknown exception" << endl;
+        return EXIT_FAILURE;
+    }
+}