expressir 0.2.5-x64-mingw32 → 0.2.7-x64-mingw32

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

@@ -1,210 +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/ATNSimulator.h"
-#include "atn/LexerATNConfig.h"
-#include "atn/ATNConfigSet.h"
-
-namespace antlr4 {
-namespace atn {
-
-  /// "dup" of ParserInterpreter
-  class ANTLR4CPP_PUBLIC LexerATNSimulator : public ATNSimulator {
-  protected:
-    class SimState {
-    public:
-      virtual ~SimState();
-
-    protected:
-      size_t index;
-      size_t line;
-      size_t charPos;
-      dfa::DFAState *dfaState;
-      virtual void reset();
-      friend class LexerATNSimulator;
-
-    private:
-      void InitializeInstanceFields();
-
-    public:
-      SimState() {
-        InitializeInstanceFields();
-      }
-    };
-
-
-  public:
-    static const size_t MIN_DFA_EDGE = 0;
-    static const 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:
-    static int match_calls;
-
-    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 () {}
-
-    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<LexerActionExecutor> &lexerActionExecutor, size_t startIndex, size_t index,
-                        size_t line, size_t charPos);
-
-    virtual ATNState *getReachableTarget(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, 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);
-
-  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,9 +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 "LexerAction.h"
-
-antlr4::atn::LexerAction::~LexerAction() {
-}

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

@@ -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.
- */
-
-#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();
-
-    /// <summary>
-    /// Gets the serialization type of the lexer action.
-    /// </summary>
-    /// <returns> The serialization type of the lexer action. </returns>
-    virtual LexerActionType getActionType() const = 0;
-
-    /// <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>
-    virtual bool isPositionDependent() const = 0;
-
-    /// <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) = 0;
-
-    virtual size_t hashCode() const = 0;
-    virtual bool operator == (const LexerAction &obj) const = 0;
-    virtual bool operator != (const LexerAction &obj) const {
-      return !(*this == obj);
-    }
-
-    virtual std::string toString() const = 0;
-  };
-
-} // namespace atn
-} // namespace antlr4

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

@@ -1,107 +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 "support/CPPUtils.h"
-#include "support/Arrays.h"
-
-#include "atn/LexerActionExecutor.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-using namespace antlr4::misc;
-using namespace antlrcpp;
-
-LexerActionExecutor::LexerActionExecutor(const std::vector<Ref<LexerAction>> &lexerActions)
-  : _lexerActions(lexerActions), _hashCode(generateHashCode()) {
-}
-
-LexerActionExecutor::~LexerActionExecutor() {
-}
-
-Ref<LexerActionExecutor> LexerActionExecutor::append(Ref<LexerActionExecutor> const& lexerActionExecutor,
-                                                     Ref<LexerAction> const& lexerAction) {
-  if (lexerActionExecutor == nullptr) {
-    return std::make_shared<LexerActionExecutor>(std::vector<Ref<LexerAction>> { lexerAction });
-  }
-
-  std::vector<Ref<LexerAction>> lexerActions = lexerActionExecutor->_lexerActions; // Make a copy.
-  lexerActions.push_back(lexerAction);
-  return std::make_shared<LexerActionExecutor>(lexerActions);
-}
-
-Ref<LexerActionExecutor> LexerActionExecutor::fixOffsetBeforeMatch(int offset) {
-  std::vector<Ref<LexerAction>> updatedLexerActions;
-  for (size_t i = 0; i < _lexerActions.size(); i++) {
-    if (_lexerActions[i]->isPositionDependent() && !is<LexerIndexedCustomAction>(_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>(updatedLexerActions);
-}
-
-std::vector<Ref<LexerAction>> LexerActionExecutor::getLexerActions() const {
-  return _lexerActions;
-}
-
-void LexerActionExecutor::execute(Lexer *lexer, CharStream *input, size_t startIndex) {
-  bool requiresSeek = false;
-  size_t stopIndex = input->index();
-
-  auto onExit = finally([requiresSeek, input, stopIndex]() {
-    if (requiresSeek) {
-      input->seek(stopIndex);
-    }
-  });
-  for (auto lexerAction : _lexerActions) {
-    if (is<LexerIndexedCustomAction>(lexerAction)) {
-      int offset = (std::static_pointer_cast<LexerIndexedCustomAction>(lexerAction))->getOffset();
-      input->seek(startIndex + offset);
-      lexerAction = std::static_pointer_cast<LexerIndexedCustomAction>(lexerAction)->getAction();
-      requiresSeek = (startIndex + offset) != stopIndex;
-    } else if (lexerAction->isPositionDependent()) {
-      input->seek(stopIndex);
-      requiresSeek = false;
-    }
-
-    lexerAction->execute(lexer);
-  }
-}
-
-size_t LexerActionExecutor::hashCode() const {
-  return _hashCode;
-}
-
-bool LexerActionExecutor::operator == (const LexerActionExecutor &obj) const {
-  if (&obj == this) {
-    return true;
-  }
-
-  return _hashCode == obj._hashCode && Arrays::equals(_lexerActions, obj._lexerActions);
-}
-
-bool LexerActionExecutor::operator != (const LexerActionExecutor &obj) const {
-  return !operator==(obj);
-}
-
-size_t LexerActionExecutor::generateHashCode() const {
-  size_t hash = MurmurHash::initialize();
-  for (auto lexerAction : _lexerActions) {
-    hash = MurmurHash::update(hash, lexerAction);
-  }
-  hash = MurmurHash::finish(hash, _lexerActions.size());
-
-  return hash;
-}

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

@@ -1,115 +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 : 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>
-    LexerActionExecutor(const std::vector<Ref<LexerAction>> &lexerActions);
-    virtual ~LexerActionExecutor();
-
-    /// <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<LexerActionExecutor> append(Ref<LexerActionExecutor> const& lexerActionExecutor,
-                                           Ref<LexerAction> const& 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>
-    virtual Ref<LexerActionExecutor> fixOffsetBeforeMatch(int offset);
-
-    /// <summary>
-    /// Gets the lexer actions to be executed by this executor. </summary>
-    /// <returns> The lexer actions to be executed by this executor. </returns>
-    virtual std::vector<Ref<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>
-    virtual void execute(Lexer *lexer, CharStream *input, size_t startIndex);
-
-    virtual size_t hashCode() const;
-    virtual bool operator == (const LexerActionExecutor &obj) const;
-    virtual bool operator != (const LexerActionExecutor &obj) const;
-
-  private:
-    const std::vector<Ref<LexerAction>> _lexerActions;
-
-    /// Caches the result of <seealso cref="#hashCode"/> since the hash code is an element
-    /// of the performance-critical <seealso cref="LexerATNConfig#hashCode"/> operation.
-    const size_t _hashCode;
-
-    size_t generateHashCode() const;
-  };
-
-} // namespace atn
-} // namespace antlr4

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

@@ -1,55 +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,
-    /// <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,
-  };
-
-} // namespace atn
-} // namespace antlr4

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

@@ -1,55 +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 "atn/LexerChannelAction.h"
-
-using namespace antlr4::atn;
-using namespace antlr4::misc;
-
-LexerChannelAction::LexerChannelAction(int channel) : _channel(channel) {
-}
-
-int LexerChannelAction::getChannel() const {
-  return _channel;
-}
-
-LexerActionType LexerChannelAction::getActionType() const {
-  return LexerActionType::CHANNEL;
-}
-
-bool LexerChannelAction::isPositionDependent() const {
-  return false;
-}
-
-void LexerChannelAction::execute(Lexer *lexer) {
-  lexer->setChannel(_channel);
-}
-
-size_t LexerChannelAction::hashCode() const {
-  size_t hash = MurmurHash::initialize();
-  hash = MurmurHash::update(hash, static_cast<size_t>(getActionType()));
-  hash = MurmurHash::update(hash, _channel);
-  return MurmurHash::finish(hash, 2);
-}
-
-bool LexerChannelAction::operator == (const LexerAction &obj) const {
-  if (&obj == this) {
-    return true;
-  }
-
-  const LexerChannelAction *action = dynamic_cast<const LexerChannelAction *>(&obj);
-  if (action == nullptr) {
-    return false;
-  }
-
-  return _channel == action->_channel;
-}
-
-std::string LexerChannelAction::toString() const {
-  return "channel(" + std::to_string(_channel) + ")";
-}