expressir 1.4.3 → 2.1.0

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

@@ -1,242 +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.
- */
-
-#include <cassert>
-#include <cstdint>
-
-#include "support/Utf8.h"
-#include "support/Unicode.h"
-
-// The below implementation is based off of https://github.com/google/cel-cpp/internal/utf8.cc,
-// which is itself based off of https://go.googlesource.com/go/+/refs/heads/master/src/unicode/utf8/utf8.go.
-// If for some reason you feel the need to copy this implementation, please retain a comment
-// referencing the two source files and giving credit, as well as maintaining any and all
-// obligations required by the BSD 3-clause license that governs this file.
-
-namespace antlrcpp {
-
-namespace {
-
-#undef SELF
-  constexpr uint8_t SELF = 0x80;
-
-#undef LOW
-  constexpr uint8_t LOW = 0x80;
-#undef HIGH
-  constexpr uint8_t HIGH = 0xbf;
-
-#undef MASKX
-  constexpr uint8_t MASKX = 0x3f;
-#undef MASK2
-  constexpr uint8_t MASK2 = 0x1f;
-#undef MASK3
-  constexpr uint8_t MASK3 = 0xf;
-#undef MASK4
-  constexpr uint8_t MASK4 = 0x7;
-
-#undef TX
-  constexpr uint8_t TX = 0x80;
-#undef T2
-  constexpr uint8_t T2 = 0xc0;
-#undef T3
-  constexpr uint8_t T3 = 0xe0;
-#undef T4
-  constexpr uint8_t T4 = 0xf0;
-
-#undef XX
-  constexpr uint8_t XX = 0xf1;
-#undef AS
-  constexpr uint8_t AS = 0xf0;
-#undef S1
-  constexpr uint8_t S1 = 0x02;
-#undef S2
-  constexpr uint8_t S2 = 0x13;
-#undef S3
-  constexpr uint8_t S3 = 0x03;
-#undef S4
-  constexpr uint8_t S4 = 0x23;
-#undef S5
-  constexpr uint8_t S5 = 0x34;
-#undef S6
-  constexpr uint8_t S6 = 0x04;
-#undef S7
-  constexpr uint8_t S7 = 0x44;
-
-  // NOLINTBEGIN
-  // clang-format off
-#undef LEADING
-  constexpr uint8_t LEADING[256] = {
-    //   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
-    AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, // 0x00-0x0F
-    AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, // 0x10-0x1F
-    AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, // 0x20-0x2F
-    AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, // 0x30-0x3F
-    AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, // 0x40-0x4F
-    AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, // 0x50-0x5F
-    AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, // 0x60-0x6F
-    AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, AS, // 0x70-0x7F
-    //   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
-    XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, // 0x80-0x8F
-    XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, // 0x90-0x9F
-    XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, // 0xA0-0xAF
-    XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, // 0xB0-0xBF
-    XX, XX, S1, S1, S1, S1, S1, S1, S1, S1, S1, S1, S1, S1, S1, S1, // 0xC0-0xCF
-    S1, S1, S1, S1, S1, S1, S1, S1, S1, S1, S1, S1, S1, S1, S1, S1, // 0xD0-0xDF
-    S2, S3, S3, S3, S3, S3, S3, S3, S3, S3, S3, S3, S3, S4, S3, S3, // 0xE0-0xEF
-    S5, S6, S6, S6, S7, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, // 0xF0-0xFF
-  };
-  // clang-format on
-  // NOLINTEND
-
-#undef ACCEPT
-  constexpr std::pair<uint8_t, uint8_t> ACCEPT[16] = {
-      {LOW, HIGH}, {0xa0, HIGH}, {LOW, 0x9f}, {0x90, HIGH},
-      {LOW, 0x8f}, {0x0, 0x0},   {0x0, 0x0},  {0x0, 0x0},
-      {0x0, 0x0},  {0x0, 0x0},   {0x0, 0x0},  {0x0, 0x0},
-      {0x0, 0x0},  {0x0, 0x0},   {0x0, 0x0},  {0x0, 0x0},
-  };
-
-}  // namespace
-
-  std::pair<char32_t, size_t> Utf8::decode(std::string_view input) {
-    assert(!input.empty());
-    const auto b = static_cast<uint8_t>(input.front());
-    input.remove_prefix(1);
-    if (b < SELF) {
-      return {static_cast<char32_t>(b), 1};
-    }
-    const auto leading = LEADING[b];
-    if (leading == XX) {
-      return {Unicode::REPLACEMENT_CHARACTER, 1};
-    }
-    auto size = static_cast<size_t>(leading & 7) - 1;
-    if (size > input.size()) {
-      return {Unicode::REPLACEMENT_CHARACTER, 1};
-    }
-    const auto& accept = ACCEPT[leading >> 4];
-    const auto b1 = static_cast<uint8_t>(input.front());
-    input.remove_prefix(1);
-    if (b1 < accept.first || b1 > accept.second) {
-      return {Unicode::REPLACEMENT_CHARACTER, 1};
-    }
-    if (size <= 1) {
-      return {(static_cast<char32_t>(b & MASK2) << 6) |
-                  static_cast<char32_t>(b1 & MASKX),
-              2};
-    }
-    const auto b2 = static_cast<uint8_t>(input.front());
-    input.remove_prefix(1);
-    if (b2 < LOW || b2 > HIGH) {
-      return {Unicode::REPLACEMENT_CHARACTER, 1};
-    }
-    if (size <= 2) {
-      return {(static_cast<char32_t>(b & MASK3) << 12) |
-                  (static_cast<char32_t>(b1 & MASKX) << 6) |
-                  static_cast<char32_t>(b2 & MASKX),
-              3};
-    }
-    const auto b3 = static_cast<uint8_t>(input.front());
-    input.remove_prefix(1);
-    if (b3 < LOW || b3 > HIGH) {
-      return {Unicode::REPLACEMENT_CHARACTER, 1};
-    }
-    return {(static_cast<char32_t>(b & MASK4) << 18) |
-                (static_cast<char32_t>(b1 & MASKX) << 12) |
-                (static_cast<char32_t>(b2 & MASKX) << 6) |
-                static_cast<char32_t>(b3 & MASKX),
-            4};
-  }
-
-  std::optional<std::u32string> Utf8::strictDecode(std::string_view input) {
-    std::u32string output;
-    char32_t codePoint;
-    size_t codeUnits;
-    output.reserve(input.size());  // Worst case is each byte is a single Unicode code point.
-    for (size_t index = 0; index < input.size(); index += codeUnits) {
-      std::tie(codePoint, codeUnits) = Utf8::decode(input.substr(index));
-      if (codePoint == Unicode::REPLACEMENT_CHARACTER && codeUnits == 1) {
-        // Condition is only met when an illegal byte sequence is encountered. See Utf8::decode.
-        return std::nullopt;
-      }
-      output.push_back(codePoint);
-    }
-    output.shrink_to_fit();
-    return output;
-  }
-
-  std::u32string Utf8::lenientDecode(std::string_view input) {
-    std::u32string output;
-    char32_t codePoint;
-    size_t codeUnits;
-    output.reserve(input.size());  // Worst case is each byte is a single Unicode code point.
-    for (size_t index = 0; index < input.size(); index += codeUnits) {
-      std::tie(codePoint, codeUnits) = Utf8::decode(input.substr(index));
-      output.push_back(codePoint);
-    }
-    output.shrink_to_fit();
-    return output;
-  }
-
-  std::string& Utf8::encode(std::string* buffer, char32_t codePoint) {
-    assert(buffer != nullptr);
-    if (!Unicode::isValid(codePoint)) {
-      codePoint = Unicode::REPLACEMENT_CHARACTER;
-    }
-    if (codePoint <= 0x7f) {
-      buffer->push_back(static_cast<char>(static_cast<uint8_t>(codePoint)));
-    } else if (codePoint <= 0x7ff) {
-      buffer->push_back(
-          static_cast<char>(T2 | static_cast<uint8_t>(codePoint >> 6)));
-      buffer->push_back(
-          static_cast<char>(TX | (static_cast<uint8_t>(codePoint) & MASKX)));
-    } else if (codePoint <= 0xffff) {
-      buffer->push_back(
-          static_cast<char>(T3 | static_cast<uint8_t>(codePoint >> 12)));
-      buffer->push_back(static_cast<char>(
-          TX | (static_cast<uint8_t>(codePoint >> 6) & MASKX)));
-      buffer->push_back(
-          static_cast<char>(TX | (static_cast<uint8_t>(codePoint) & MASKX)));
-    } else {
-      buffer->push_back(
-          static_cast<char>(T4 | static_cast<uint8_t>(codePoint >> 18)));
-      buffer->push_back(static_cast<char>(
-          TX | (static_cast<uint8_t>(codePoint >> 12) & MASKX)));
-      buffer->push_back(static_cast<char>(
-          TX | (static_cast<uint8_t>(codePoint >> 6) & MASKX)));
-      buffer->push_back(
-          static_cast<char>(TX | (static_cast<uint8_t>(codePoint) & MASKX)));
-    }
-    return *buffer;
-  }
-
-  std::optional<std::string> Utf8::strictEncode(std::u32string_view input) {
-    std::string output;
-    output.reserve(input.size() * 4);  // Worst case is each Unicode code point encodes to 4 bytes.
-    for (size_t index = 0; index < input.size(); index++) {
-      char32_t codePoint = input[index];
-      if (!Unicode::isValid(codePoint)) {
-        return std::nullopt;
-      }
-      Utf8::encode(&output, codePoint);
-    }
-    output.shrink_to_fit();
-    return output;
-  }
-
-  std::string Utf8::lenientEncode(std::u32string_view input) {
-    std::string output;
-    output.reserve(input.size() * 4);  // Worst case is each Unicode code point encodes to 4 bytes.
-    for (size_t index = 0; index < input.size(); index++) {
-      char32_t codePoint = input[index];
-      if (!Unicode::isValid(codePoint)) {
-        codePoint = Unicode::REPLACEMENT_CHARACTER;
-      }
-      Utf8::encode(&output, codePoint);
-    }
-    output.shrink_to_fit();
-    return output;
-  }
-
-}

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

@@ -1,54 +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 <optional>
-#include <string>
-#include <string_view>
-#include <tuple>
-
-#include "antlr4-common.h"
-
-namespace antlrcpp {
-
-  class ANTLR4CPP_PUBLIC Utf8 final {
-  public:
-    // Decodes the next code point, returning the decoded code point and the number
-    // of code units (a.k.a. bytes) consumed. In the event that an invalid code unit
-    // sequence is returned the replacement character, U+FFFD, is returned with a
-    // code unit count of 1. As U+FFFD requires 3 code units when encoded, this can
-    // be used to differentiate valid input from malformed input.
-    static std::pair<char32_t, size_t> decode(std::string_view input);
-
-    // Decodes the given UTF-8 encoded input into a string of code points.
-    static std::optional<std::u32string> strictDecode(std::string_view input);
-
-    // Decodes the given UTF-8 encoded input into a string of code points. Unlike strictDecode(),
-    // each byte in an illegal byte sequence is replaced with the Unicode replacement character,
-    // U+FFFD.
-    static std::u32string lenientDecode(std::string_view input);
-
-    // Encodes the given code point and appends it to the buffer. If the code point
-    // is an unpaired surrogate or outside of the valid Unicode range it is replaced
-    // with the replacement character, U+FFFD.
-    static std::string& encode(std::string *buffer, char32_t codePoint);
-
-    // Encodes the given Unicode code point string as UTF-8.
-    static std::optional<std::string> strictEncode(std::u32string_view input);
-
-    // Encodes the given Unicode code point string as UTF-8. Unlike strictEncode(),
-    // each invalid Unicode code point is replaced with the Unicode replacement character, U+FFFD.
-    static std::string lenientEncode(std::u32string_view input);
-
-  private:
-    Utf8() = delete;
-    Utf8(const Utf8&) = delete;
-    Utf8(Utf8&&) = delete;
-    Utf8& operator=(const Utf8&) = delete;
-    Utf8& operator=(Utf8&&) = delete;
-  };
-
-}

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/AbstractParseTreeVisitor.h

@@ -1,129 +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 "tree/ParseTree.h"
-#include "tree/ParseTreeVisitor.h"
-
-namespace antlr4 {
-namespace tree {
-
-  class ANTLR4CPP_PUBLIC AbstractParseTreeVisitor : public ParseTreeVisitor {
-  public:
-    /// The default implementation calls <seealso cref="ParseTree#accept"/> on the
-    /// specified tree.
-    virtual std::any visit(ParseTree *tree) override {
-      return tree->accept(this);
-    }
-
-    /**
-     * <p>The default implementation initializes the aggregate result to
-     * {@link #defaultResult defaultResult()}. Before visiting each child, it
-     * calls {@link #shouldVisitNextChild shouldVisitNextChild}; if the result
-     * is {@code false} no more children are visited and the current aggregate
-     * result is returned. After visiting a child, the aggregate result is
-     * updated by calling {@link #aggregateResult aggregateResult} with the
-     * previous aggregate result and the result of visiting the child.</p>
-     *
-     * <p>The default implementation is not safe for use in visitors that modify
-     * the tree structure. Visitors that modify the tree should override this
-     * method to behave properly in respect to the specific algorithm in use.</p>
-     */
-    virtual std::any visitChildren(ParseTree *node) override {
-      std::any result = defaultResult();
-      size_t n = node->children.size();
-      for (size_t i = 0; i < n; i++) {
-        if (!shouldVisitNextChild(node, result)) {
-          break;
-        }
-
-        std::any childResult = node->children[i]->accept(this);
-        result = aggregateResult(std::move(result), std::move(childResult));
-      }
-
-      return result;
-    }
-
-    /// The default implementation returns the result of
-    /// <seealso cref="#defaultResult defaultResult"/>.
-    virtual std::any visitTerminal(TerminalNode * /*node*/) override {
-      return defaultResult();
-    }
-
-    /// The default implementation returns the result of
-    /// <seealso cref="#defaultResult defaultResult"/>.
-    virtual std::any visitErrorNode(ErrorNode * /*node*/) override {
-      return defaultResult();
-    }
-
-  protected:
-    /// <summary>
-    /// Gets the default value returned by visitor methods. This value is
-    /// returned by the default implementations of
-    /// <seealso cref="#visitTerminal visitTerminal"/>, <seealso cref="#visitErrorNode visitErrorNode"/>.
-    /// The default implementation of <seealso cref="#visitChildren visitChildren"/>
-    /// initializes its aggregate result to this value.
-    /// <p/>
-    /// The base implementation returns {@code std::any()}.
-    /// </summary>
-    /// <returns> The default value returned by visitor methods. </returns>
-    virtual std::any defaultResult() {
-      return std::any();
-    }
-
-    /// <summary>
-    /// Aggregates the results of visiting multiple children of a node. After
-    /// either all children are visited or <seealso cref="#shouldVisitNextChild"/> returns
-    /// {@code false}, the aggregate value is returned as the result of
-    /// <seealso cref="#visitChildren"/>.
-    /// <p/>
-    /// The default implementation returns {@code nextResult}, meaning
-    /// <seealso cref="#visitChildren"/> will return the result of the last child visited
-    /// (or return the initial value if the node has no children).
-    /// </summary>
-    /// <param name="aggregate"> The previous aggregate value. In the default
-    /// implementation, the aggregate value is initialized to
-    /// <seealso cref="#defaultResult"/>, which is passed as the {@code aggregate} argument
-    /// to this method after the first child node is visited. </param>
-    /// <param name="nextResult"> The result of the immediately preceeding call to visit
-    /// a child node.
-    /// </param>
-    /// <returns> The updated aggregate result. </returns>
-    virtual std::any aggregateResult(std::any /*aggregate*/, std::any nextResult) {
-      return nextResult;
-    }
-
-    /// <summary>
-    /// This method is called after visiting each child in
-    /// <seealso cref="#visitChildren"/>. This method is first called before the first
-    /// child is visited; at that point {@code currentResult} will be the initial
-    /// value (in the default implementation, the initial value is returned by a
-    /// call to <seealso cref="#defaultResult"/>. This method is not called after the last
-    /// child is visited.
-    /// <p/>
-    /// The default implementation always returns {@code true}, indicating that
-    /// {@code visitChildren} should only return after all children are visited.
-    /// One reason to override this method is to provide a "short circuit"
-    /// evaluation option for situations where the result of visiting a single
-    /// child has the potential to determine the result of the visit operation as
-    /// a whole.
-    /// </summary>
-    /// <param name="node"> The <seealso cref="ParseTree"/> whose children are currently being
-    /// visited. </param>
-    /// <param name="currentResult"> The current aggregate result of the children visited
-    /// to the current point.
-    /// </param>
-    /// <returns> {@code true} to continue visiting children. Otherwise return
-    /// {@code false} to stop visiting children and immediately return the
-    /// current aggregate result from <seealso cref="#visitChildren"/>. </returns>
-    virtual bool shouldVisitNextChild(ParseTree * /*node*/, const std::any &/*currentResult*/) {
-      return true;
-    }
-
-  };
-
-} // namespace tree
-} // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/ErrorNode.h

@@ -1,24 +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 "tree/TerminalNode.h"
-
-namespace antlr4 {
-namespace tree {
-
-  class ANTLR4CPP_PUBLIC ErrorNode : public TerminalNode {
-  public:
-    static bool is(const tree::ParseTree &parseTree) { return parseTree.getTreeType() == tree::ParseTreeType::ERROR; }
-
-    static bool is(const tree::ParseTree *parseTree) { return parseTree != nullptr && is(*parseTree); }
-
-  protected:
-    using TerminalNode::TerminalNode;
-  };
-
-} // namespace tree
-} // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/ErrorNodeImpl.cpp

@@ -1,54 +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 "misc/Interval.h"
-#include "Token.h"
-#include "RuleContext.h"
-#include "tree/ParseTreeVisitor.h"
-
-#include "tree/ErrorNodeImpl.h"
-
-using namespace antlr4;
-using namespace antlr4::tree;
-
-Token* ErrorNodeImpl::getSymbol() const {
-  return symbol;
-}
-
-void ErrorNodeImpl::setParent(RuleContext *parent_) {
-  this->parent = parent_;
-}
-
-misc::Interval ErrorNodeImpl::getSourceInterval() {
-  if (symbol == nullptr) {
-    return misc::Interval::INVALID;
-  }
-
-  size_t tokenIndex = symbol->getTokenIndex();
-  return misc::Interval(tokenIndex, tokenIndex);
-}
-
-std::any ErrorNodeImpl::accept(ParseTreeVisitor *visitor) {
-  return visitor->visitErrorNode(this);
-}
-
-std::string ErrorNodeImpl::getText() {
-  return symbol->getText();
-}
-
-std::string ErrorNodeImpl::toStringTree(Parser * /*parser*/, bool /*pretty*/) {
-  return toString();
-}
-
-std::string ErrorNodeImpl::toString() {
-  if (symbol->getType() == Token::EOF) {
-    return "<EOF>";
-  }
-  return symbol->getText();
-}
-
-std::string ErrorNodeImpl::toStringTree(bool /*pretty*/) {
-  return toString();
-}

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/ErrorNodeImpl.h

@@ -1,43 +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 "tree/ErrorNode.h"
-#include "tree/TerminalNodeImpl.h"
-#include "misc/Interval.h"
-
-#include "support/Any.h"
-
-namespace antlr4 {
-namespace tree {
-
-  /// <summary>
-  /// Represents a token that was consumed during resynchronization
-  ///  rather than during a valid match operation. For example,
-  ///  we will create this kind of a node during single token insertion
-  ///  and deletion as well as during "consume until error recovery set"
-  ///  upon no viable alternative exceptions.
-  /// </summary>
-  class ANTLR4CPP_PUBLIC ErrorNodeImpl : public ErrorNode {
-  public:
-    Token *symbol;
-
-    explicit ErrorNodeImpl(Token *symbol) : ErrorNode(ParseTreeType::ERROR), symbol(symbol) {}
-
-    virtual Token* getSymbol() const override;
-    virtual void setParent(RuleContext *parent) override;
-    virtual misc::Interval getSourceInterval() override;
-
-    virtual std::any accept(ParseTreeVisitor *visitor) override;
-
-    virtual std::string getText() override;
-    virtual std::string toStringTree(Parser *parser, bool pretty = false) override;
-    virtual std::string toString() override;
-    virtual std::string toStringTree(bool pretty = false) override;
-  };
-
-} // namespace tree
-} // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/IterativeParseTreeWalker.cpp

@@ -1,66 +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"
-#include "support/Casts.h"
-
-#include "tree/ParseTreeListener.h"
-#include "tree/ParseTree.h"
-#include "tree/ErrorNode.h"
-
-#include "IterativeParseTreeWalker.h"
-
-using namespace antlr4::tree;
-using namespace antlrcpp;
-
-void IterativeParseTreeWalker::walk(ParseTreeListener *listener, ParseTree *t) const {
-  std::vector<std::pair<ParseTree*, size_t>> stack;
-  ParseTree *currentNode = t;
-  size_t currentIndex = 0;
-
-  while (currentNode != nullptr) {
-    // pre-order visit
-    if (ErrorNode::is(*currentNode)) {
-      listener->visitErrorNode(downCast<ErrorNode*>(currentNode));
-    } else if (TerminalNode::is(*currentNode)) {
-      listener->visitTerminal(downCast<TerminalNode*>(currentNode));
-    } else {
-      enterRule(listener, currentNode);
-    }
-
-    // Move down to first child, if it exists.
-    if (!currentNode->children.empty()) {
-      stack.push_back(std::make_pair(currentNode, currentIndex));
-      currentIndex = 0;
-      currentNode = currentNode->children[0];
-      continue;
-    }
-
-    // No child nodes, so walk tree.
-    do {
-      // post-order visit
-      if (!TerminalNode::is(*currentNode)) {
-        exitRule(listener, currentNode);
-      }
-
-      // No parent, so no siblings.
-      if (stack.empty()) {
-        currentNode = nullptr;
-        currentIndex = 0;
-        break;
-      }
-
-      // Move to next sibling if possible.
-      if (stack.back().first->children.size() > ++currentIndex) {
-        currentNode = stack.back().first->children[currentIndex];
-        break;
-      }
-
-      // No next sibling, so move up.
-      std::tie(currentNode, currentIndex) = stack.back();
-      stack.pop_back();
-    } while (currentNode != nullptr);
-  }
-}

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/IterativeParseTreeWalker.h

@@ -1,53 +0,0 @@
-/*
- * [The "BSD license"]
- *  Copyright (c) 2012 Terence Parr
- *  Copyright (c) 2012 Sam Harwell
- *  All rights reserved.
- *
- *  Redistribution and use in source and binary forms, with or without
- *  modification, are permitted provided that the following conditions
- *  are met:
- *
- *  1. Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- *  2. Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- *  3. The name of the author may not be used to endorse or promote products
- *     derived from this software without specific prior written permission.
- *
- *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- *  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- *  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- *  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#pragma once
-
-#include "antlr4-common.h"
-
-#include "tree/ParseTreeWalker.h"
-
-namespace antlr4 {
-namespace tree {
-
-  class ParseTreeListener;
-  
-  /**
-   * An iterative (read: non-recursive) pre-order and post-order tree walker that
-   * doesn't use the thread stack but heap-based stacks. Makes it possible to
-   * process deeply nested parse trees.
-   */
-  class ANTLR4CPP_PUBLIC IterativeParseTreeWalker : public ParseTreeWalker {
-  public:
-    virtual void walk(ParseTreeListener *listener, ParseTree *t) const override;
-  };
-
-} // namespace tree
-} // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/ParseTree.cpp

@@ -1,12 +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 "tree/ParseTree.h"
-
-using namespace antlr4::tree;
-
-bool ParseTree::operator == (const ParseTree &other) const {
-  return &other == this;
-}