did_parser 1.0.0

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

@@ -0,0 +1,199 @@
+/* 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/did_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/LexerAction.cpp

@@ -0,0 +1,15 @@
+#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/did_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/LexerAction.h

@@ -0,0 +1,100 @@
+/* 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/did_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/LexerActionExecutor.cpp

@@ -0,0 +1,111 @@
+/* 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 "support/Casts.h"
+
+#include "atn/LexerActionExecutor.h"
+
+using namespace antlr4;
+using namespace antlr4::atn;
+using namespace antlr4::misc;
+using namespace antlrcpp;
+
+namespace {
+
+  bool cachedHashCodeEqual(size_t lhs, size_t rhs) {
+    return lhs == rhs || lhs == 0 || rhs == 0;
+  }
+
+  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/did_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/LexerActionExecutor.h

@@ -0,0 +1,128 @@
+/* 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/did_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/LexerActionType.h

@@ -0,0 +1,57 @@
+/* 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/did_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/LexerChannelAction.cpp

@@ -0,0 +1,43 @@
+/* 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()) + ")";
+}