expressir 1.4.3 → 2.1.0

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/support/CPPUtils.cpp

@@ -1,207 +0,0 @@
-/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
- * Use of this file is governed by the BSD 3-clause license that
- * can be found in the LICENSE.txt file in the project root.
- */
-
-#include "support/CPPUtils.h"
-
-namespace antlrcpp {
-
-  std::string join(const std::vector<std::string> &strings, const std::string &separator) {
-    std::string str;
-    bool firstItem = true;
-    for (const std::string &s : strings) {
-      if (!firstItem) {
-        str.append(separator);
-      }
-      firstItem = false;
-      str.append(s);
-    }
-    return str;
-  }
-
-  std::map<std::string, size_t> toMap(const std::vector<std::string> &keys) {
-    std::map<std::string, size_t> result;
-    for (size_t i = 0; i < keys.size(); ++i) {
-      result.insert({ keys[i], i });
-    }
-    return result;
-  }
-
-  std::string escapeWhitespace(std::string str, bool escapeSpaces) {
-    std::string result;
-    for (auto c : str) {
-      switch (c) {
-        case '\n':
-          result += "\\n";
-          break;
-
-        case '\r':
-          result += "\\r";
-          break;
-
-        case '\t':
-          result += "\\t";
-          break;
-
-        case ' ':
-          if (escapeSpaces) {
-            result += "\u00B7";
-            break;
-          }
-          result += c;
-          break;
-
-        default:
-          result += c;
-          break;
-      }
-    }
-
-    return result;
-  }
-
-  std::string toHexString(const int t) {
-    std::stringstream stream;
-    stream << std::uppercase << std::hex << t;
-    return stream.str();
-  }
-
-  std::string arrayToString(const std::vector<std::string> &data) {
-    std::string answer;
-    size_t toReserve = 0;
-    for (const auto &sub : data) {
-      toReserve += sub.size();
-    }
-    answer.reserve(toReserve);
-    for (const auto &sub: data) {
-      answer.append(sub);
-    }
-    return answer;
-  }
-
-  std::string replaceString(const std::string &s, const std::string &from, const std::string &to) {
-    std::string::size_type p;
-    std::string ss, res;
-
-    ss = s;
-    p = ss.find(from);
-    while (p != std::string::npos) {
-      if (p > 0)
-        res.append(ss.substr(0, p)).append(to);
-      else
-        res.append(to);
-      ss = ss.substr(p + from.size());
-      p = ss.find(from);
-    }
-    res.append(ss);
-
-    return res;
-  }
-
-  std::vector<std::string> split(const std::string &s, const std::string &sep, int count) {
-    std::vector<std::string> parts;
-    std::string ss = s;
-
-    std::string::size_type p;
-
-    if (s.empty())
-      return parts;
-
-    if (count == 0)
-      count= -1;
-
-    p = ss.find(sep);
-    while (!ss.empty() && p != std::string::npos && (count < 0 || count > 0)) {
-      parts.push_back(ss.substr(0, p));
-      ss = ss.substr(p+sep.size());
-
-      --count;
-      p = ss.find(sep);
-    }
-    parts.push_back(ss);
-
-    return parts;
-  }
-
-  //--------------------------------------------------------------------------------------------------
-
-  // Debugging helper. Adds indentation to all lines in the given string.
-  std::string indent(const std::string &s, const std::string &indentation, bool includingFirst) {
-    std::vector<std::string> parts = split(s, "\n", -1);
-    for (size_t i = 0; i < parts.size(); ++i) {
-      if (i == 0 && !includingFirst)
-        continue;
-      parts[i].insert(0, indentation);
-    }
-
-    return join(parts, "\n");
-  }
-
-  //--------------------------------------------------------------------------------------------------
-
-  // Recursively get the error from a, possibly nested, exception.
-#if defined(_MSC_FULL_VER) && _MSC_FULL_VER < 190023026
-  // No nested exceptions before VS 2015.
-  template <typename T>
-  std::exception_ptr get_nested(const T &/*e*/) {
-    try {
-      return nullptr;
-    }
-    catch (const std::bad_cast &) {
-      return nullptr;
-    }
-  }
-#else
-  template <typename T>
-  std::exception_ptr get_nested(const T &e) {
-    try {
-      auto nested = dynamic_cast<const std::nested_exception&>(e);
-      return nested.nested_ptr();
-    }
-    catch (const std::bad_cast &) {
-      return nullptr;
-    }
-  }
-#endif
-
-  std::string what(std::exception_ptr eptr) {
-    if (!eptr) {
-      throw std::bad_exception();
-    }
-
-    std::string result;
-    std::size_t nestCount = 0;
-
-    next: {
-      try {
-        std::exception_ptr yeptr;
-        std::swap(eptr, yeptr);
-        std::rethrow_exception(yeptr);
-      }
-      catch (const std::exception &e) {
-        result += e.what();
-        eptr = get_nested(e);
-      }
-      catch (const std::string &e) {
-        result += e;
-      }
-      catch (const char *e) {
-        result += e;
-      }
-      catch (...) {
-        result += "cannot be determined";
-      }
-
-      if (eptr) {
-        result += " (";
-        ++nestCount;
-        goto next;
-      }
-    }
-
-    result += std::string(nestCount, ')');
-    return result;
-  }
-
-} // namespace antlrcpp

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/support/CPPUtils.h

@@ -1,65 +0,0 @@
-/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
- * Use of this file is governed by the BSD 3-clause license that
- * can be found in the LICENSE.txt file in the project root.
- */
-
-#pragma once
-
-#include "antlr4-common.h"
-
-namespace antlrcpp {
-
-  ANTLR4CPP_PUBLIC std::string join(const std::vector<std::string> &strings, const std::string &separator);
-  ANTLR4CPP_PUBLIC std::map<std::string, size_t> toMap(const std::vector<std::string> &keys);
-  ANTLR4CPP_PUBLIC std::string escapeWhitespace(std::string str, bool escapeSpaces);
-  ANTLR4CPP_PUBLIC std::string toHexString(const int t);
-  ANTLR4CPP_PUBLIC std::string arrayToString(const std::vector<std::string> &data);
-  ANTLR4CPP_PUBLIC std::string replaceString(const std::string &s, const std::string &from, const std::string &to);
-  ANTLR4CPP_PUBLIC std::vector<std::string> split(const std::string &s, const std::string &sep, int count);
-  ANTLR4CPP_PUBLIC std::string indent(const std::string &s, const std::string &indentation, bool includingFirst = true);
-
-  // Using RAII + a lambda to implement a "finally" replacement.
-  template <typename OnEnd>
-  struct FinalAction {
-    FinalAction(OnEnd f) : _cleanUp { std::move(f) } {}
-    FinalAction(FinalAction &&other) :
-	_cleanUp(std::move(other._cleanUp)), _enabled(other._enabled) {
-      other._enabled = false; // Don't trigger the lambda after ownership has moved.
-    }
-    ~FinalAction() { if (_enabled) _cleanUp(); }
-
-    void disable() { _enabled = false; }
-  private:
-    OnEnd _cleanUp;
-    bool _enabled {true};
-  };
-
-  template <typename OnEnd>
-  FinalAction<OnEnd> finally(OnEnd f) {
-    return FinalAction<OnEnd>(std::move(f));
-  }
-
-  // Convenience functions to avoid lengthy dynamic_cast() != nullptr checks in many places.
-  template <typename T1, typename T2>
-  inline bool is(T2 *obj) { // For pointer types.
-    return dynamic_cast<typename std::add_const<T1>::type>(obj) != nullptr;
-  }
-
-  template <typename T1, typename T2>
-  inline bool is(Ref<T2> const& obj) { // For shared pointers.
-    return dynamic_cast<T1 *>(obj.get()) != nullptr;
-  }
-
-  template <typename T>
-  std::string toString(const T &o) {
-    std::stringstream ss;
-    // typeid gives the mangled class name, but that's all what's possible
-    // in a portable way.
-    ss << typeid(o).name() << "@" << std::hex << reinterpret_cast<uintptr_t>(&o);
-    return ss.str();
-  }
-
-  // Get the error text from an exception pointer or the current exception.
-  ANTLR4CPP_PUBLIC std::string what(std::exception_ptr eptr = std::current_exception());
-
-} // namespace antlrcpp

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/support/Casts.h

@@ -1,34 +0,0 @@
-/* Copyright (c) 2012-2021 The ANTLR Project. All rights reserved.
- * Use of this file is governed by the BSD 3-clause license that
- * can be found in the LICENSE.txt file in the project root.
- */
-
-#pragma once
-
-#include <cassert>
-#include <memory>
-#include <type_traits>
-
-namespace antlrcpp {
-
-  template <typename To, typename From>
-  To downCast(From* from) {
-    static_assert(std::is_pointer_v<To>, "Target type not a pointer.");
-    static_assert(std::is_base_of_v<From, std::remove_pointer_t<To>>, "Target type not derived from source type.");
-  #if !defined(__GNUC__) || defined(__GXX_RTTI)
-    assert(from == nullptr || dynamic_cast<To>(from) != nullptr);
-  #endif
-    return static_cast<To>(from);
-  }
-
-  template <typename To, typename From>
-  To downCast(From& from) {
-    static_assert(std::is_lvalue_reference_v<To>, "Target type not a lvalue reference.");
-    static_assert(std::is_base_of_v<From, std::remove_reference_t<To>>, "Target type not derived from source type.");
-  #if !defined(__GNUC__) || defined(__GXX_RTTI)
-    assert(dynamic_cast<std::add_pointer_t<std::remove_reference_t<To>>>(std::addressof(from)) != nullptr);
-  #endif
-    return static_cast<To>(from);
-  }
-
-}

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/support/Declarations.h

@@ -1,161 +0,0 @@
-/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
- * Use of this file is governed by the BSD 3-clause license that
- * can be found in the LICENSE.txt file in the project root.
- */
-
-#pragma once
-
-namespace antlr4 {
-  class ANTLRErrorListener;
-  class ANTLRErrorStrategy;
-  class ANTLRFileStream;
-  class ANTLRInputStream;
-  class BailErrorStrategy;
-  class BaseErrorListener;
-  class BufferedTokenStream;
-  class CharStream;
-  class CommonToken;
-  class CommonTokenFactory;
-  class CommonTokenStream;
-  class ConsoleErrorListener;
-  class DefaultErrorStrategy;
-  class DiagnosticErrorListener;
-  class EmptyStackException;
-  class FailedPredicateException;
-  class IllegalArgumentException;
-  class IllegalStateException;
-  class InputMismatchException;
-  class IntStream;
-  class InterpreterRuleContext;
-  class Lexer;
-  class LexerInterpreter;
-  class LexerNoViableAltException;
-  class ListTokenSource;
-  class NoSuchElementException;
-  class NoViableAltException;
-  class NullPointerException;
-  class ParseCancellationException;
-  class Parser;
-  class ParserInterpreter;
-  class ParserRuleContext;
-  class ProxyErrorListener;
-  class RecognitionException;
-  class Recognizer;
-  class RuleContext;
-  class Token;
-  template<typename Symbol> class TokenFactory;
-  class TokenSource;
-  class TokenStream;
-  class TokenStreamRewriter;
-  class UnbufferedCharStream;
-  class UnbufferedTokenStream;
-  class WritableToken;
-
-  namespace misc {
-    class InterpreterDataReader;
-    class Interval;
-    class IntervalSet;
-    class MurmurHash;
-    class Utils;
-    class Predicate;
-  }
-  namespace atn {
-    class ATN;
-    class ATNConfig;
-    class ATNConfigSet;
-    class ATNDeserializationOptions;
-    class ATNDeserializer;
-    class ATNSerializer;
-    class ATNSimulator;
-    class ATNState;
-    enum class ATNType;
-    class ActionTransition;
-    class ArrayPredictionContext;
-    class AtomTransition;
-    class BasicBlockStartState;
-    class BasicState;
-    class BlockEndState;
-    class BlockStartState;
-    class DecisionState;
-    class EpsilonTransition;
-    class LL1Analyzer;
-    class LexerAction;
-    class LexerActionExecutor;
-    class LexerATNConfig;
-    class LexerATNSimulator;
-    class LexerMoreAction;
-    class LexerPopModeAction;
-    class LexerSkipAction;
-    class LookaheadEventInfo;
-    class LoopEndState;
-    class NotSetTransition;
-    class OrderedATNConfigSet;
-    class ParseInfo;
-    class ParserATNSimulator;
-    class PlusBlockStartState;
-    class PlusLoopbackState;
-    class PrecedencePredicateTransition;
-    class PredicateTransition;
-    class PredictionContext;
-    enum class PredictionMode;
-    class PredictionModeClass;
-    class RangeTransition;
-    class RuleStartState;
-    class RuleStopState;
-    class RuleTransition;
-    class SemanticContext;
-    class SetTransition;
-    class SingletonPredictionContext;
-    class StarBlockStartState;
-    class StarLoopEntryState;
-    class StarLoopbackState;
-    class TokensStartState;
-    class Transition;
-    class WildcardTransition;
-  }
-  namespace dfa {
-    class DFA;
-    class DFASerializer;
-    class DFAState;
-    class LexerDFASerializer;
-    class Vocabulary;
-  }
-  namespace tree {
-    class AbstractParseTreeVisitor;
-    class ErrorNode;
-    class ErrorNodeImpl;
-    class ParseTree;
-    class ParseTreeListener;
-    template<typename T> class ParseTreeProperty;
-    class ParseTreeVisitor;
-    class ParseTreeWalker;
-    class SyntaxTree;
-    class TerminalNode;
-    class TerminalNodeImpl;
-    class Tree;
-    class Trees;
-
-    namespace pattern {
-      class Chunk;
-      class ParseTreeMatch;
-      class ParseTreePattern;
-      class ParseTreePatternMatcher;
-      class RuleTagToken;
-      class TagChunk;
-      class TextChunk;
-      class TokenTagToken;
-    }
-
-    namespace xpath {
-      class XPath;
-      class XPathElement;
-      class XPathLexerErrorListener;
-      class XPathRuleAnywhereElement;
-      class XPathRuleElement;
-      class XPathTokenAnywhereElement;
-      class XPathTokenElement;
-      class XPathWildcardAnywhereElement;
-      class XPathWildcardElement;
-    }
-  }
-}

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/support/StringUtils.cpp

@@ -1,38 +0,0 @@
-/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
- * Use of this file is governed by the BSD 3-clause license that
- * can be found in the LICENSE.txt file in the project root.
- */
-
-#include "support/StringUtils.h"
-
-namespace antlrcpp {
-
-  std::string escapeWhitespace(std::string_view in) {
-    std::string out;
-    escapeWhitespace(out, in);
-    out.shrink_to_fit();
-    return out;
-  }
-
-  std::string& escapeWhitespace(std::string& out, std::string_view in) {
-    out.reserve(in.size());  // Best case, no escaping.
-    for (const auto &c : in) {
-      switch (c) {
-        case '\t':
-          out.append("\\t");
-          break;
-        case '\r':
-          out.append("\\r");
-          break;
-        case '\n':
-          out.append("\\n");
-          break;
-        default:
-          out.push_back(c);
-          break;
-      }
-    }
-    return out;
-  }
-
-} // namespace antrlcpp

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/support/StringUtils.h

@@ -1,16 +0,0 @@
-/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
- * Use of this file is governed by the BSD 3-clause license that
- * can be found in the LICENSE.txt file in the project root.
- */
-
-#pragma once
-
-#include "antlr4-common.h"
-
-namespace antlrcpp {
-
-  ANTLR4CPP_PUBLIC std::string escapeWhitespace(std::string_view in);
-
-  ANTLR4CPP_PUBLIC std::string& escapeWhitespace(std::string& out, std::string_view in);
-
-}

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/support/Unicode.h

@@ -1,28 +0,0 @@
-/* Copyright (c) 2021 The ANTLR Project. All rights reserved.
- * Use of this file is governed by the BSD 3-clause license that
- * can be found in the LICENSE.txt file in the project root.
- */
-
-#pragma once
-
-#include "antlr4-common.h"
-
-namespace antlrcpp {
-
-  class ANTLR4CPP_PUBLIC Unicode final {
-  public:
-    static constexpr char32_t REPLACEMENT_CHARACTER = 0xfffd;
-
-    static constexpr bool isValid(char32_t codePoint) {
-      return codePoint < 0xd800 || (codePoint > 0xdfff && codePoint <= 0x10ffff);
-    }
-
-  private:
-    Unicode() = delete;
-    Unicode(const Unicode&) = delete;
-    Unicode(Unicode&&) = delete;
-    Unicode& operator=(const Unicode&) = delete;
-    Unicode& operator=(Unicode&&) = delete;
-  };
-
-}