expressir 1.4.3 → 2.1.0

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/LexerATNSimulator.h

@@ -1,199 +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 <atomic>
-
-#include "atn/ATNSimulator.h"
-#include "atn/LexerATNConfig.h"
-#include "atn/ATNConfigSet.h"
-
-namespace antlr4 {
-namespace atn {
-
-  /// "dup" of ParserInterpreter
-  class ANTLR4CPP_PUBLIC LexerATNSimulator : public ATNSimulator {
-  protected:
-    struct ANTLR4CPP_PUBLIC SimState final {
-      size_t index = INVALID_INDEX;
-      size_t line = 0;
-      size_t charPos = INVALID_INDEX;
-      dfa::DFAState *dfaState = nullptr;
-
-      void reset();
-    };
-
-  public:
-    static constexpr size_t MIN_DFA_EDGE = 0;
-    static constexpr size_t MAX_DFA_EDGE = 127; // forces unicode to stay in ATN
-
-  protected:
-    /// <summary>
-    /// When we hit an accept state in either the DFA or the ATN, we
-    ///  have to notify the character stream to start buffering characters
-    ///  via <seealso cref="IntStream#mark"/> and record the current state. The current sim state
-    ///  includes the current index into the input, the current line,
-    ///  and current character position in that line. Note that the Lexer is
-    ///  tracking the starting line and characterization of the token. These
-    ///  variables track the "state" of the simulator when it hits an accept state.
-    /// <p/>
-    ///  We track these variables separately for the DFA and ATN simulation
-    ///  because the DFA simulation often has to fail over to the ATN
-    ///  simulation. If the ATN simulation fails, we need the DFA to fall
-    ///  back to its previously accepted state, if any. If the ATN succeeds,
-    ///  then the ATN does the accept and the DFA simulator that invoked it
-    ///  can simply return the predicted token type.
-    /// </summary>
-    Lexer *const _recog;
-
-    /// The current token's starting index into the character stream.
-    ///  Shared across DFA to ATN simulation in case the ATN fails and the
-    ///  DFA did not have a previous accept state. In this case, we use the
-    ///  ATN-generated exception object.
-    size_t _startIndex;
-
-    /// line number 1..n within the input.
-    size_t _line;
-
-    /// The index of the character relative to the beginning of the line 0..n-1.
-    size_t _charPositionInLine;
-
-  public:
-    std::vector<dfa::DFA> &_decisionToDFA;
-
-  protected:
-    size_t _mode;
-
-    /// Used during DFA/ATN exec to record the most recent accept configuration info.
-    SimState _prevAccept;
-
-  public:
-    LexerATNSimulator(const ATN &atn, std::vector<dfa::DFA> &decisionToDFA, PredictionContextCache &sharedContextCache);
-    LexerATNSimulator(Lexer *recog, const ATN &atn, std::vector<dfa::DFA> &decisionToDFA, PredictionContextCache &sharedContextCache);
-    virtual ~LexerATNSimulator() = default;
-
-    virtual void copyState(LexerATNSimulator *simulator);
-    virtual size_t match(CharStream *input, size_t mode);
-    virtual void reset() override;
-
-    virtual void clearDFA() override;
-
-  protected:
-    virtual size_t matchATN(CharStream *input);
-    virtual size_t execATN(CharStream *input, dfa::DFAState *ds0);
-
-    /// <summary>
-    /// Get an existing target state for an edge in the DFA. If the target state
-    /// for the edge has not yet been computed or is otherwise not available,
-    /// this method returns {@code null}.
-    /// </summary>
-    /// <param name="s"> The current DFA state </param>
-    /// <param name="t"> The next input symbol </param>
-    /// <returns> The existing target DFA state for the given input symbol
-    /// {@code t}, or {@code null} if the target state for this edge is not
-    /// already cached </returns>
-    virtual dfa::DFAState *getExistingTargetState(dfa::DFAState *s, size_t t);
-
-    /// <summary>
-    /// Compute a target state for an edge in the DFA, and attempt to add the
-    /// computed state and corresponding edge to the DFA.
-    /// </summary>
-    /// <param name="input"> The input stream </param>
-    /// <param name="s"> The current DFA state </param>
-    /// <param name="t"> The next input symbol
-    /// </param>
-    /// <returns> The computed target DFA state for the given input symbol
-    /// {@code t}. If {@code t} does not lead to a valid DFA state, this method
-    /// returns <seealso cref="#ERROR"/>. </returns>
-    virtual dfa::DFAState *computeTargetState(CharStream *input, dfa::DFAState *s, size_t t);
-
-    virtual size_t failOrAccept(CharStream *input, ATNConfigSet *reach, size_t t);
-
-    /// <summary>
-    /// Given a starting configuration set, figure out all ATN configurations
-    ///  we can reach upon input {@code t}. Parameter {@code reach} is a return
-    ///  parameter.
-    /// </summary>
-    void getReachableConfigSet(CharStream *input, ATNConfigSet *closure_, // closure_ as we have a closure() already
-                               ATNConfigSet *reach, size_t t);
-
-    virtual void accept(CharStream *input, const Ref<const LexerActionExecutor> &lexerActionExecutor, size_t startIndex, size_t index,
-                        size_t line, size_t charPos);
-
-    virtual ATNState *getReachableTarget(const Transition *trans, size_t t);
-
-    virtual std::unique_ptr<ATNConfigSet> computeStartState(CharStream *input, ATNState *p);
-
-    /// <summary>
-    /// Since the alternatives within any lexer decision are ordered by
-    /// preference, this method stops pursuing the closure as soon as an accept
-    /// state is reached. After the first accept state is reached by depth-first
-    /// search from {@code config}, all other (potentially reachable) states for
-    /// this rule would have a lower priority.
-    /// </summary>
-    /// <returns> {@code true} if an accept state is reached, otherwise
-    /// {@code false}. </returns>
-    virtual bool closure(CharStream *input, const Ref<LexerATNConfig> &config, ATNConfigSet *configs,
-                         bool currentAltReachedAcceptState, bool speculative, bool treatEofAsEpsilon);
-
-    // side-effect: can alter configs.hasSemanticContext
-    virtual Ref<LexerATNConfig> getEpsilonTarget(CharStream *input, const Ref<LexerATNConfig> &config, const Transition *t,
-      ATNConfigSet *configs, bool speculative, bool treatEofAsEpsilon);
-
-    /// <summary>
-    /// Evaluate a predicate specified in the lexer.
-    /// <p/>
-    /// If {@code speculative} is {@code true}, this method was called before
-    /// <seealso cref="#consume"/> for the matched character. This method should call
-    /// <seealso cref="#consume"/> before evaluating the predicate to ensure position
-    /// sensitive values, including <seealso cref="Lexer#getText"/>, <seealso cref="Lexer#getLine"/>,
-    /// and <seealso cref="Lexer#getCharPositionInLine"/>, properly reflect the current
-    /// lexer state. This method should restore {@code input} and the simulator
-    /// to the original state before returning (i.e. undo the actions made by the
-    /// call to <seealso cref="#consume"/>.
-    /// </summary>
-    /// <param name="input"> The input stream. </param>
-    /// <param name="ruleIndex"> The rule containing the predicate. </param>
-    /// <param name="predIndex"> The index of the predicate within the rule. </param>
-    /// <param name="speculative"> {@code true} if the current index in {@code input} is
-    /// one character before the predicate's location.
-    /// </param>
-    /// <returns> {@code true} if the specified predicate evaluates to
-    /// {@code true}. </returns>
-    virtual bool evaluatePredicate(CharStream *input, size_t ruleIndex, size_t predIndex, bool speculative);
-
-    virtual void captureSimState(CharStream *input, dfa::DFAState *dfaState);
-    virtual dfa::DFAState* addDFAEdge(dfa::DFAState *from, size_t t, ATNConfigSet *q);
-    virtual void addDFAEdge(dfa::DFAState *p, size_t t, dfa::DFAState *q);
-
-    /// <summary>
-    /// Add a new DFA state if there isn't one with this set of
-    /// configurations already. This method also detects the first
-    /// configuration containing an ATN rule stop state. Later, when
-    /// traversing the DFA, we will know which rule to accept.
-    /// </summary>
-    virtual dfa::DFAState *addDFAState(ATNConfigSet *configs);
-
-    virtual dfa::DFAState *addDFAState(ATNConfigSet *configs, bool suppressEdge);
-
-  public:
-    dfa::DFA& getDFA(size_t mode);
-
-    /// Get the text matched so far for the current token.
-    virtual std::string getText(CharStream *input);
-    virtual size_t getLine() const;
-    virtual void setLine(size_t line);
-    virtual size_t getCharPositionInLine();
-    virtual void setCharPositionInLine(size_t charPositionInLine);
-    virtual void consume(CharStream *input);
-    virtual std::string getTokenName(size_t t);
-
-  private:
-    void InitializeInstanceFields();
-  };
-
-} // namespace atn
-} // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/LexerAction.cpp

@@ -1,15 +0,0 @@
-#include "LexerAction.h"
-
-using namespace antlr4::atn;
-
-size_t LexerAction::hashCode() const {
-  auto hash = cachedHashCode();
-  if (hash == 0) {
-    hash = hashCodeImpl();
-    if (hash == 0) {
-      hash = std::numeric_limits<size_t>::max();
-    }
-    _hashCode.store(hash, std::memory_order_relaxed);
-  }
-  return hash;
-}

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/LexerAction.h

@@ -1,100 +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 "atn/LexerActionType.h"
-#include "antlr4-common.h"
-
-namespace antlr4 {
-namespace atn {
-
-  /// <summary>
-  /// Represents a single action which can be executed following the successful
-  /// match of a lexer rule. Lexer actions are used for both embedded action syntax
-  /// and ANTLR 4's new lexer command syntax.
-  ///
-  /// @author Sam Harwell
-  /// @since 4.2
-  /// </summary>
-  class ANTLR4CPP_PUBLIC LexerAction {
-  public:
-    virtual ~LexerAction() = default;
-
-    /// <summary>
-    /// Gets the serialization type of the lexer action.
-    /// </summary>
-    /// <returns> The serialization type of the lexer action. </returns>
-    ///
-    /// IMPORTANT: Unlike Java, this returns LexerActionType::INDEXED_CUSTOM for instances of
-    /// LexerIndexedCustomAction. If you need the wrapped action type, use
-    /// LexerIndexedCustomAction::getAction()->getActionType().
-    LexerActionType getActionType() const { return _actionType; }
-
-    /// <summary>
-    /// Gets whether the lexer action is position-dependent. Position-dependent
-    /// actions may have different semantics depending on the <seealso cref="CharStream"/>
-    /// index at the time the action is executed.
-    ///
-    /// <para>Many lexer commands, including {@code type}, {@code skip}, and
-    /// {@code more}, do not check the input index during their execution.
-    /// Actions like this are position-independent, and may be stored more
-    /// efficiently as part of the <seealso cref="LexerATNConfig#lexerActionExecutor"/>.</para>
-    /// </summary>
-    /// <returns> {@code true} if the lexer action semantics can be affected by the
-    /// position of the input <seealso cref="CharStream"/> at the time it is executed;
-    /// otherwise, {@code false}. </returns>
-    bool isPositionDependent() const { return _positionDependent; }
-
-    /// <summary>
-    /// Execute the lexer action in the context of the specified <seealso cref="Lexer"/>.
-    ///
-    /// <para>For position-dependent actions, the input stream must already be
-    /// positioned correctly prior to calling this method.</para>
-    /// </summary>
-    /// <param name="lexer"> The lexer instance. </param>
-    virtual void execute(Lexer *lexer) const = 0;
-
-    size_t hashCode() const;
-
-    virtual bool equals(const LexerAction &other) const = 0;
-
-    virtual std::string toString() const = 0;
-
-  protected:
-    LexerAction(LexerActionType actionType, bool positionDependent)
-        : _actionType(actionType), _hashCode(0), _positionDependent(positionDependent) {}
-
-    virtual size_t hashCodeImpl() const = 0;
-
-    size_t cachedHashCode() const { return _hashCode.load(std::memory_order_relaxed); }
-
-  private:
-    const LexerActionType _actionType;
-    mutable std::atomic<size_t> _hashCode;
-    const bool _positionDependent;
-  };
-
-  inline bool operator==(const LexerAction &lhs, const LexerAction &rhs) {
-    return lhs.equals(rhs);
-  }
-
-  inline bool operator!=(const LexerAction &lhs, const LexerAction &rhs) {
-    return !operator==(lhs, rhs);
-  }
-
-}  // namespace atn
-}  // namespace antlr4
-
-namespace std {
-
-  template <>
-  struct hash<::antlr4::atn::LexerAction> {
-    size_t operator()(const ::antlr4::atn::LexerAction &lexerAction) const {
-      return lexerAction.hashCode();
-    }
-  };
-
-}  // namespace std

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/LexerActionExecutor.cpp

@@ -1,108 +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/MurmurHash.h"
-#include "atn/LexerIndexedCustomAction.h"
-#include "atn/HashUtils.h"
-#include "support/CPPUtils.h"
-#include "support/Arrays.h"
-#include "support/Casts.h"
-
-#include "atn/LexerActionExecutor.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-using namespace antlr4::misc;
-using namespace antlrcpp;
-
-namespace {
-
-  bool lexerActionEqual(const Ref<const LexerAction> &lhs, const Ref<const LexerAction> &rhs) {
-    return *lhs == *rhs;
-  }
-
-}
-
-LexerActionExecutor::LexerActionExecutor(std::vector<Ref<const LexerAction>> lexerActions)
-    : _lexerActions(std::move(lexerActions)), _hashCode(0) {}
-
-Ref<const LexerActionExecutor> LexerActionExecutor::append(const Ref<const LexerActionExecutor> &lexerActionExecutor,
-                                                           Ref<const LexerAction> lexerAction) {
-  if (lexerActionExecutor == nullptr) {
-    return std::make_shared<LexerActionExecutor>(std::vector<Ref<const LexerAction>>{ std::move(lexerAction) });
-  }
-  std::vector<Ref<const LexerAction>> lexerActions;
-  lexerActions.reserve(lexerActionExecutor->_lexerActions.size() + 1);
-  lexerActions.insert(lexerActions.begin(), lexerActionExecutor->_lexerActions.begin(), lexerActionExecutor->_lexerActions.end());
-  lexerActions.push_back(std::move(lexerAction));
-  return std::make_shared<LexerActionExecutor>(std::move(lexerActions));
-}
-
-Ref<const LexerActionExecutor> LexerActionExecutor::fixOffsetBeforeMatch(int offset) const {
-  std::vector<Ref<const LexerAction>> updatedLexerActions;
-  for (size_t i = 0; i < _lexerActions.size(); i++) {
-    if (_lexerActions[i]->isPositionDependent() && !LexerIndexedCustomAction::is(*_lexerActions[i])) {
-      if (updatedLexerActions.empty()) {
-        updatedLexerActions = _lexerActions; // Make a copy.
-      }
-      updatedLexerActions[i] = std::make_shared<LexerIndexedCustomAction>(offset, _lexerActions[i]);
-    }
-  }
-  if (updatedLexerActions.empty()) {
-    return shared_from_this();
-  }
-  return std::make_shared<LexerActionExecutor>(std::move(updatedLexerActions));
-}
-
-const std::vector<Ref<const LexerAction>>& LexerActionExecutor::getLexerActions() const {
-  return _lexerActions;
-}
-
-void LexerActionExecutor::execute(Lexer *lexer, CharStream *input, size_t startIndex) const {
-  bool requiresSeek = false;
-  size_t stopIndex = input->index();
-
-  auto onExit = finally([requiresSeek, input, stopIndex]() {
-    if (requiresSeek) {
-      input->seek(stopIndex);
-    }
-  });
-  for (const auto &lexerAction : _lexerActions) {
-    if (LexerIndexedCustomAction::is(*lexerAction)) {
-      int offset = downCast<const LexerIndexedCustomAction&>(*lexerAction).getOffset();
-      input->seek(startIndex + offset);
-      requiresSeek = (startIndex + offset) != stopIndex;
-    } else if (lexerAction->isPositionDependent()) {
-      input->seek(stopIndex);
-      requiresSeek = false;
-    }
-    lexerAction->execute(lexer);
-  }
-}
-
-size_t LexerActionExecutor::hashCode() const {
-  auto hash = _hashCode.load(std::memory_order_relaxed);
-  if (hash == 0) {
-    hash = MurmurHash::initialize();
-    for (const auto &lexerAction : _lexerActions) {
-      hash = MurmurHash::update(hash, lexerAction);
-    }
-    hash = MurmurHash::finish(hash, _lexerActions.size());
-    if (hash == 0) {
-      hash = std::numeric_limits<size_t>::max();
-    }
-    _hashCode.store(hash, std::memory_order_relaxed);
-  }
-  return hash;
-}
-
-bool LexerActionExecutor::equals(const LexerActionExecutor &other) const {
-  if (this == std::addressof(other)) {
-    return true;
-  }
-  return cachedHashCodeEqual(_hashCode.load(std::memory_order_relaxed), other._hashCode.load(std::memory_order_relaxed)) &&
-         _lexerActions.size() == other._lexerActions.size() &&
-         std::equal(_lexerActions.begin(), _lexerActions.end(), other._lexerActions.begin(), lexerActionEqual);
-}

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/LexerActionExecutor.h

@@ -1,128 +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 "CharStream.h"
-#include "atn/LexerAction.h"
-
-namespace antlr4 {
-namespace atn {
-
-  /// Represents an executor for a sequence of lexer actions which traversed during
-  /// the matching operation of a lexer rule (token).
-  ///
-  /// <para>The executor tracks position information for position-dependent lexer actions
-  /// efficiently, ensuring that actions appearing only at the end of the rule do
-  /// not cause bloating of the <seealso cref="DFA"/> created for the lexer.</para>
-  class ANTLR4CPP_PUBLIC LexerActionExecutor final : public std::enable_shared_from_this<LexerActionExecutor> {
-  public:
-    /// <summary>
-    /// Constructs an executor for a sequence of <seealso cref="LexerAction"/> actions. </summary>
-    /// <param name="lexerActions"> The lexer actions to execute. </param>
-    explicit LexerActionExecutor(std::vector<Ref<const LexerAction>> lexerActions);
-
-    /// <summary>
-    /// Creates a <seealso cref="LexerActionExecutor"/> which executes the actions for
-    /// the input {@code lexerActionExecutor} followed by a specified
-    /// {@code lexerAction}.
-    /// </summary>
-    /// <param name="lexerActionExecutor"> The executor for actions already traversed by
-    /// the lexer while matching a token within a particular
-    /// <seealso cref="LexerATNConfig"/>. If this is {@code null}, the method behaves as
-    /// though it were an empty executor. </param>
-    /// <param name="lexerAction"> The lexer action to execute after the actions
-    /// specified in {@code lexerActionExecutor}.
-    /// </param>
-    /// <returns> A <seealso cref="LexerActionExecutor"/> for executing the combine actions
-    /// of {@code lexerActionExecutor} and {@code lexerAction}. </returns>
-    static Ref<const LexerActionExecutor> append(const Ref<const LexerActionExecutor> &lexerActionExecutor,
-                                                 Ref<const LexerAction> lexerAction);
-
-    /// <summary>
-    /// Creates a <seealso cref="LexerActionExecutor"/> which encodes the current offset
-    /// for position-dependent lexer actions.
-    ///
-    /// <para>Normally, when the executor encounters lexer actions where
-    /// <seealso cref="LexerAction#isPositionDependent"/> returns {@code true}, it calls
-    /// <seealso cref="IntStream#seek"/> on the input <seealso cref="CharStream"/> to set the input
-    /// position to the <em>end</em> of the current token. This behavior provides
-    /// for efficient DFA representation of lexer actions which appear at the end
-    /// of a lexer rule, even when the lexer rule matches a variable number of
-    /// characters.</para>
-    ///
-    /// <para>Prior to traversing a match transition in the ATN, the current offset
-    /// from the token start index is assigned to all position-dependent lexer
-    /// actions which have not already been assigned a fixed offset. By storing
-    /// the offsets relative to the token start index, the DFA representation of
-    /// lexer actions which appear in the middle of tokens remains efficient due
-    /// to sharing among tokens of the same length, regardless of their absolute
-    /// position in the input stream.</para>
-    ///
-    /// <para>If the current executor already has offsets assigned to all
-    /// position-dependent lexer actions, the method returns {@code this}.</para>
-    /// </summary>
-    /// <param name="offset"> The current offset to assign to all position-dependent
-    /// lexer actions which do not already have offsets assigned.
-    /// </param>
-    /// <returns> A <seealso cref="LexerActionExecutor"/> which stores input stream offsets
-    /// for all position-dependent lexer actions. </returns>
-    Ref<const LexerActionExecutor> fixOffsetBeforeMatch(int offset) const;
-
-    /// <summary>
-    /// Gets the lexer actions to be executed by this executor. </summary>
-    /// <returns> The lexer actions to be executed by this executor. </returns>
-    const std::vector<Ref<const LexerAction>>& getLexerActions() const;
-
-    /// <summary>
-    /// Execute the actions encapsulated by this executor within the context of a
-    /// particular <seealso cref="Lexer"/>.
-    ///
-    /// <para>This method calls <seealso cref="IntStream#seek"/> to set the position of the
-    /// {@code input} <seealso cref="CharStream"/> prior to calling
-    /// <seealso cref="LexerAction#execute"/> on a position-dependent action. Before the
-    /// method returns, the input position will be restored to the same position
-    /// it was in when the method was invoked.</para>
-    /// </summary>
-    /// <param name="lexer"> The lexer instance. </param>
-    /// <param name="input"> The input stream which is the source for the current token.
-    /// When this method is called, the current <seealso cref="IntStream#index"/> for
-    /// {@code input} should be the start of the following token, i.e. 1
-    /// character past the end of the current token. </param>
-    /// <param name="startIndex"> The token start index. This value may be passed to
-    /// <seealso cref="IntStream#seek"/> to set the {@code input} position to the beginning
-    /// of the token. </param>
-    void execute(Lexer *lexer, CharStream *input, size_t startIndex) const;
-
-    size_t hashCode() const;
-
-    bool equals(const LexerActionExecutor &other) const;
-
-  private:
-    const std::vector<Ref<const LexerAction>> _lexerActions;
-    mutable std::atomic<size_t> _hashCode;
-  };
-
-  inline bool operator==(const LexerActionExecutor &lhs, const LexerActionExecutor &rhs) {
-    return lhs.equals(rhs);
-  }
-
-  inline bool operator!=(const LexerActionExecutor &lhs, const LexerActionExecutor &rhs) {
-    return !operator==(lhs, rhs);
-  }
-
-}  // namespace atn
-}  // namespace antlr4
-
-namespace std {
-
-  template <>
-  struct hash<::antlr4::atn::LexerActionExecutor> {
-    size_t operator()(const ::antlr4::atn::LexerActionExecutor &lexerActionExecutor) const {
-      return lexerActionExecutor.hashCode();
-    }
-  };
-
-}  // namespace std

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/LexerActionType.h

@@ -1,57 +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 antlr4 {
-namespace atn {
-
-  /// <summary>
-  /// Represents the serialization type of a <seealso cref="LexerAction"/>.
-  ///
-  /// @author Sam Harwell
-  /// @since 4.2
-  /// </summary>
-  enum class LexerActionType : size_t {
-    /// <summary>
-    /// The type of a <seealso cref="LexerChannelAction"/> action.
-    /// </summary>
-    CHANNEL = 0,
-    /// <summary>
-    /// The type of a <seealso cref="LexerCustomAction"/> action.
-    /// </summary>
-    CUSTOM,
-    /// <summary>
-    /// The type of a <seealso cref="LexerModeAction"/> action.
-    /// </summary>
-    MODE,
-    /// <summary>
-    /// The type of a <seealso cref="LexerMoreAction"/> action.
-    /// </summary>
-    MORE,
-    /// <summary>
-    /// The type of a <seealso cref="LexerPopModeAction"/> action.
-    /// </summary>
-    POP_MODE,
-    /// <summary>
-    /// The type of a <seealso cref="LexerPushModeAction"/> action.
-    /// </summary>
-    PUSH_MODE,
-    /// <summary>
-    /// The type of a <seealso cref="LexerSkipAction"/> action.
-    /// </summary>
-    SKIP,
-    /// <summary>
-    /// The type of a <seealso cref="LexerTypeAction"/> action.
-    /// </summary>
-    TYPE,
-
-    INDEXED_CUSTOM,
-  };
-
-} // namespace atn
-} // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/LexerChannelAction.cpp

@@ -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.
- */
-
-#include "misc/MurmurHash.h"
-#include "Lexer.h"
-#include "support/Casts.h"
-
-#include "atn/LexerChannelAction.h"
-
-using namespace antlr4::atn;
-using namespace antlr4::misc;
-using namespace antlrcpp;
-
-LexerChannelAction::LexerChannelAction(int channel)
-    : LexerAction(LexerActionType::CHANNEL, false), _channel(channel) {}
-
-void LexerChannelAction::execute(Lexer *lexer) const {
-  lexer->setChannel(getChannel());
-}
-
-size_t LexerChannelAction::hashCodeImpl() const {
-  size_t hash = MurmurHash::initialize();
-  hash = MurmurHash::update(hash, static_cast<size_t>(getActionType()));
-  hash = MurmurHash::update(hash, getChannel());
-  return MurmurHash::finish(hash, 2);
-}
-
-bool LexerChannelAction::equals(const LexerAction &other) const {
-  if (this == std::addressof(other)) {
-    return true;
-  }
-  if (getActionType() != other.getActionType()) {
-    return false;
-  }
-  const auto &lexerAction = downCast<const LexerChannelAction&>(other);
-  return getChannel() == lexerAction.getChannel();
-}
-
-std::string LexerChannelAction::toString() const {
-  return "channel(" + std::to_string(getChannel()) + ")";
-}