zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,50 +1,141 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef SLICE_UTIL_H
 #define SLICE_UTIL_H
 
-#include <Slice/Parser.h>
-#include <IceUtil/OutputUtil.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);
 
-std::string fullPath(const std::string&);
-std::string changeInclude(const std::string&, const std::vector<std::string>&);
-void emitError(const std::string&, int, const std::string&);
-void emitWarning(const std::string&, int, const std::string&);
-void emitError(const std::string&, const std::string&, const std::string&);
-void emitWarning(const std::string&, const std::string&, const std::string&);
-void emitRaw(const char*);
-std::vector<std::string> filterMcppWarnings(const std::string&);
-void printGeneratedHeader(IceUtilInternal::Output& out, const std::string&, const std::string& commentStyle = "//");
+    /// Converts a string to Pascal case. For example, "myClass" becomes "MyClass".
+    std::string toPascalCase(const std::string& s);
+
+    /// Converts a string to camel case. For example, "MyClass" becomes "myClass".
+    std::string toCamelCase(const std::string& s);
+
+    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[]);
+    std::vector<std::string> argvToArgs(int argc, wchar_t* argv[]);
 #else
-std::vector<std::string> argvToArgs(int argc, char* argv[]);
+    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&, const std::string&, const std::string&, EscapeMode, unsigned char);
-
-void
-writeDependencies(const std::string&, const std::string&);
+    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

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

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

@@ -0,0 +1,250 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "../Ice/ConsoleUtil.h"
+#include "../Ice/Options.h"
+#include "../Slice/FileTracker.h"
+#include "../Slice/Preprocessor.h"
+#include "../Slice/Util.h"
+#include "Ice/CtrlCHandler.h"
+#include "Ice/StringUtil.h"
+#include "RubyUtil.h"
+
+#include <algorithm>
+#include <cassert>
+#include <mutex>
+
+#include <cstring>
+
+using namespace std;
+using namespace Slice;
+using namespace Slice::Ruby;
+using namespace IceInternal;
+
+namespace
+{
+    mutex globalMutex;
+    bool interrupted = false;
+
+    void interruptedCallback(int /*signal*/)
+    {
+        lock_guard lock(globalMutex);
+        interrupted = true;
+    }
+
+    void usage(const string& n)
+    {
+        consoleErr << "Usage: " << n << " [options] slice-files...\n";
+        consoleErr << "Options:\n"
+                      "-h, --help               Show this message.\n"
+                      "-v, --version            Display the Ice version.\n"
+                      "-DNAME                   Define NAME as 1.\n"
+                      "-DNAME=DEF               Define NAME as DEF.\n"
+                      "-UNAME                   Remove any definition for NAME.\n"
+                      "-IDIR                    Put DIR in the include file search path.\n"
+                      "--output-dir DIR         Create files in the directory DIR.\n"
+                      "-d, --debug              Print debug messages.\n"
+                      "--depend                 Generate Makefile dependencies.\n"
+                      "--depend-xml             Generate dependencies in XML format.\n"
+                      "--depend-file FILE       Write dependencies to FILE instead of standard output.\n"
+                      "--all                    Generate code for Slice definitions in included files.\n";
+    }
+}
+
+int
+Slice::Ruby::compile(const vector<string>& argv)
+{
+    IceInternal::Options opts;
+    opts.addOpt("h", "help");
+    opts.addOpt("v", "version");
+    opts.addOpt("D", "", IceInternal::Options::NeedArg, "", IceInternal::Options::Repeat);
+    opts.addOpt("U", "", IceInternal::Options::NeedArg, "", IceInternal::Options::Repeat);
+    opts.addOpt("I", "", IceInternal::Options::NeedArg, "", IceInternal::Options::Repeat);
+    opts.addOpt("", "output-dir", IceInternal::Options::NeedArg);
+    opts.addOpt("", "depend");
+    opts.addOpt("", "depend-xml");
+    opts.addOpt("", "depend-file", IceInternal::Options::NeedArg, "");
+    opts.addOpt("d", "debug");
+    opts.addOpt("", "all");
+
+    vector<string> sliceFiles;
+    try
+    {
+        sliceFiles = opts.parse(argv);
+    }
+    catch (const IceInternal::BadOptException& e)
+    {
+        consoleErr << argv[0] << ": error: " << e.what() << endl;
+        usage(argv[0]);
+        return EXIT_FAILURE;
+    }
+
+    if (opts.isSet("help"))
+    {
+        usage(argv[0]);
+        return EXIT_SUCCESS;
+    }
+
+    if (opts.isSet("version"))
+    {
+        consoleErr << ICE_STRING_VERSION << endl;
+        return EXIT_SUCCESS;
+    }
+
+    vector<string> preprocessorArgs;
+    vector<string> optargs = opts.argVec("D");
+    preprocessorArgs.reserve(optargs.size()); // not quite sufficient but keeps clang-tidy happy
+    for (const auto& optarg : optargs)
+    {
+        preprocessorArgs.push_back("-D" + optarg);
+    }
+
+    optargs = opts.argVec("U");
+    for (const auto& optarg : optargs)
+    {
+        preprocessorArgs.push_back("-U" + optarg);
+    }
+
+    vector<string> includePaths = opts.argVec("I");
+    for (const auto& includePath : includePaths)
+    {
+        preprocessorArgs.push_back("-I" + Preprocessor::normalizeIncludePath(includePath));
+    }
+
+    string output = opts.optArg("output-dir");
+
+    bool depend = opts.isSet("depend");
+
+    bool dependXML = opts.isSet("depend-xml");
+
+    string dependFile = opts.optArg("depend-file");
+
+    bool debug = opts.isSet("debug");
+
+    bool all = opts.isSet("all");
+
+    if (sliceFiles.empty())
+    {
+        consoleErr << argv[0] << ": error: no input file" << endl;
+        usage(argv[0]);
+        return EXIT_FAILURE;
+    }
+
+    if (depend && dependXML)
+    {
+        consoleErr << argv[0] << ": error: cannot specify both --depend and --depend-xml" << endl;
+        usage(argv[0]);
+        return EXIT_FAILURE;
+    }
+
+    int status = EXIT_SUCCESS;
+
+    Ice::CtrlCHandler ctrlCHandler;
+    ctrlCHandler.setCallback(interruptedCallback);
+
+    DependencyGenerator dependencyGenerator;
+
+    for (const auto& fileName : sliceFiles)
+    {
+        UnitPtr unit;
+        PreprocessorPtr preprocessor;
+        try
+        {
+            preprocessor = Preprocessor::create(argv[0], fileName, preprocessorArgs);
+            FILE* preprocessedHandle = preprocessor->preprocess("-D__SLICE2RB__");
+            if (preprocessedHandle == nullptr)
+            {
+                return EXIT_FAILURE;
+            }
+
+            unit = Unit::createUnit("ruby", {.all = all});
+            int parseStatus = unit->parse(fileName, preprocessedHandle, debug);
+
+            preprocessor->close();
+
+            if (parseStatus == EXIT_FAILURE)
+            {
+                status = EXIT_FAILURE;
+            }
+            else if (depend || dependXML)
+            {
+                dependencyGenerator.addDependenciesFor(unit);
+                if (depend)
+                {
+                    string target = removeExtension(baseName(fileName)) + ".rb";
+                    dependencyGenerator.writeMakefileDependencies(dependFile, unit->topLevelFile(), target);
+                }
+                // Else XML dependencies are written below after all units have been processed.
+            }
+            else
+            {
+                string base = removeExtension(baseName(fileName));
+
+                string file = base + ".rb";
+                if (!output.empty())
+                {
+                    file = output + '/' + file;
+                }
+
+                IceInternal::Output out;
+                out.open(file.c_str());
+                if (!out)
+                {
+                    ostringstream oss;
+                    oss << "cannot open '" << file << "': " << IceInternal::errorToString(errno);
+                    throw FileException(oss.str());
+                }
+                FileTracker::instance()->addFile(file);
+
+                printHeader(out);
+                printGeneratedHeader(out, base + ".ice", "#");
+                out << sp;
+
+                // Generate the Ruby mapping.
+                generate(unit, all, includePaths, out);
+
+                out.close();
+
+                status |= unit->getStatus();
+            }
+            unit->destroy();
+        }
+        catch (...)
+        {
+            FileTracker::instance()->cleanup();
+
+            if (preprocessor)
+            {
+                preprocessor->close();
+            }
+
+            if (unit)
+            {
+                unit->destroy();
+            }
+            throw;
+        }
+
+        {
+            lock_guard lock(globalMutex);
+            if (interrupted)
+            {
+                status = EXIT_FAILURE;
+                break;
+            }
+        }
+    }
+
+    if (status == EXIT_FAILURE)
+    {
+        // If the compilation failed, clean up any created files.
+        FileTracker::instance()->cleanup();
+        return status;
+    }
+
+    if (dependXML)
+    {
+        dependencyGenerator.writeXMLDependencies(dependFile);
+    }
+
+    return status;
+}