expressir 1.4.2 → 2.0.0

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

@@ -1,23 +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 "Token.h"
-
-namespace antlr4 {
-
-  class ANTLR4CPP_PUBLIC WritableToken : public Token {
-  public:
-    virtual ~WritableToken();
-    virtual void setText(const std::string &text) = 0;
-    virtual void setType(size_t ttype) = 0;
-    virtual void setLine(size_t line) = 0;
-    virtual void setCharPositionInLine(size_t pos) = 0;
-    virtual void setChannel(size_t channel) = 0;
-    virtual void setTokenIndex(size_t index) = 0;
-  };
-
-} // namespace antlr4

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

@@ -1,101 +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 <algorithm>
-#include <any>
-#include <atomic>
-#include <bitset>
-#include <cassert>
-#include <climits>
-#include <cstddef>
-#include <cstdint>
-#include <cstdlib>
-#include <exception>
-#include <fstream>
-#include <iostream>
-#include <iterator>
-#include <limits>
-#include <map>
-#include <memory>
-#include <set>
-#include <sstream>
-#include <stack>
-#include <string>
-#include <string_view>
-#include <typeinfo>
-#include <type_traits>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-#include <vector>
-
-// Defines for the Guid class and other platform dependent stuff.
-#ifdef _WIN32
-  #ifdef _MSC_VER
-    #pragma warning (disable: 4250) // Class inherits by dominance.
-    #pragma warning (disable: 4512) // assignment operator could not be generated
-
-    #if _MSC_VER < 1900
-      // Before VS 2015 code like "while (true)" will create a (useless) warning in level 4.
-      #pragma warning (disable: 4127) // conditional expression is constant
-    #endif
-  #endif
-
-  #ifdef _WIN64
-    typedef __int64 ssize_t;
-  #else
-    typedef __int32 ssize_t;
-  #endif
-
-  #ifdef ANTLR4CPP_EXPORTS
-    #define ANTLR4CPP_PUBLIC __declspec(dllexport)
-  #else
-    #ifdef ANTLR4CPP_STATIC
-      #define ANTLR4CPP_PUBLIC
-    #else
-      #define ANTLR4CPP_PUBLIC __declspec(dllimport)
-    #endif
-  #endif
-
-#elif defined(__APPLE__)
-  #if __GNUC__ >= 4
-    #define ANTLR4CPP_PUBLIC __attribute__ ((visibility ("default")))
-  #else
-    #define ANTLR4CPP_PUBLIC
-  #endif
-#else
-  #if __GNUC__ >= 6
-    #define ANTLR4CPP_PUBLIC __attribute__ ((visibility ("default")))
-  #else
-    #define ANTLR4CPP_PUBLIC
-  #endif
-#endif
-
-#ifdef __has_builtin
-#define ANTLR4CPP_HAVE_BUILTIN(x) __has_builtin(x)
-#else
-#define ANTLR4CPP_HAVE_BUILTIN(x) 0
-#endif
-
-#define ANTLR4CPP_INTERNAL_STRINGIFY(x) #x
-#define ANTLR4CPP_STRINGIFY(x) ANTLR4CPP_INTERNAL_STRINGIFY(x)
-
-// We use everything from the C++ standard library by default.
-#ifndef ANTLR4CPP_USING_ABSEIL
-#define ANTLR4CPP_USING_ABSEIL 0
-#endif
-
-#include "support/Declarations.h"
-
-// We have to undefine this symbol as ANTLR will use this name for own members and even
-// generated functions. Because EOF is a global macro we cannot use e.g. a namespace scope to disambiguate.
-#ifdef EOF
-#undef EOF
-#endif
-
-#define INVALID_INDEX std::numeric_limits<size_t>::max()
-template<class T> using Ref = std::shared_ptr<T>;

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

@@ -1,168 +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
-
-// This is the umbrella header for all ANTLR4 C++ runtime headers.
-
-#include "antlr4-common.h"
-
-#include "ANTLRErrorListener.h"
-#include "ANTLRErrorStrategy.h"
-#include "ANTLRFileStream.h"
-#include "ANTLRInputStream.h"
-#include "BailErrorStrategy.h"
-#include "BaseErrorListener.h"
-#include "BufferedTokenStream.h"
-#include "CharStream.h"
-#include "CommonToken.h"
-#include "CommonTokenFactory.h"
-#include "CommonTokenStream.h"
-#include "ConsoleErrorListener.h"
-#include "DefaultErrorStrategy.h"
-#include "DiagnosticErrorListener.h"
-#include "Exceptions.h"
-#include "FailedPredicateException.h"
-#include "InputMismatchException.h"
-#include "IntStream.h"
-#include "InterpreterRuleContext.h"
-#include "Lexer.h"
-#include "LexerInterpreter.h"
-#include "LexerNoViableAltException.h"
-#include "ListTokenSource.h"
-#include "NoViableAltException.h"
-#include "Parser.h"
-#include "ParserInterpreter.h"
-#include "ParserRuleContext.h"
-#include "ProxyErrorListener.h"
-#include "RecognitionException.h"
-#include "Recognizer.h"
-#include "RuleContext.h"
-#include "RuleContextWithAltNum.h"
-#include "RuntimeMetaData.h"
-#include "Token.h"
-#include "TokenFactory.h"
-#include "TokenSource.h"
-#include "TokenStream.h"
-#include "TokenStreamRewriter.h"
-#include "UnbufferedCharStream.h"
-#include "UnbufferedTokenStream.h"
-#include "Version.h"
-#include "Vocabulary.h"
-#include "Vocabulary.h"
-#include "WritableToken.h"
-#include "atn/ATN.h"
-#include "atn/ATNConfig.h"
-#include "atn/ATNConfigSet.h"
-#include "atn/ATNDeserializationOptions.h"
-#include "atn/ATNDeserializer.h"
-#include "atn/ATNSimulator.h"
-#include "atn/ATNState.h"
-#include "atn/ATNType.h"
-#include "atn/ActionTransition.h"
-#include "atn/AmbiguityInfo.h"
-#include "atn/ArrayPredictionContext.h"
-#include "atn/AtomTransition.h"
-#include "atn/BasicBlockStartState.h"
-#include "atn/BasicState.h"
-#include "atn/BlockEndState.h"
-#include "atn/BlockStartState.h"
-#include "atn/ContextSensitivityInfo.h"
-#include "atn/DecisionEventInfo.h"
-#include "atn/DecisionInfo.h"
-#include "atn/DecisionState.h"
-#include "atn/EpsilonTransition.h"
-#include "atn/ErrorInfo.h"
-#include "atn/LL1Analyzer.h"
-#include "atn/LexerATNConfig.h"
-#include "atn/LexerATNSimulator.h"
-#include "atn/LexerAction.h"
-#include "atn/LexerActionExecutor.h"
-#include "atn/LexerActionType.h"
-#include "atn/LexerChannelAction.h"
-#include "atn/LexerCustomAction.h"
-#include "atn/LexerIndexedCustomAction.h"
-#include "atn/LexerModeAction.h"
-#include "atn/LexerMoreAction.h"
-#include "atn/LexerPopModeAction.h"
-#include "atn/LexerPushModeAction.h"
-#include "atn/LexerSkipAction.h"
-#include "atn/LexerTypeAction.h"
-#include "atn/LookaheadEventInfo.h"
-#include "atn/LoopEndState.h"
-#include "atn/NotSetTransition.h"
-#include "atn/OrderedATNConfigSet.h"
-#include "atn/ParseInfo.h"
-#include "atn/ParserATNSimulator.h"
-#include "atn/ParserATNSimulatorOptions.h"
-#include "atn/PlusBlockStartState.h"
-#include "atn/PlusLoopbackState.h"
-#include "atn/PrecedencePredicateTransition.h"
-#include "atn/PredicateEvalInfo.h"
-#include "atn/PredicateTransition.h"
-#include "atn/PredictionContext.h"
-#include "atn/PredictionContextCache.h"
-#include "atn/PredictionContextMergeCache.h"
-#include "atn/PredictionContextMergeCacheOptions.h"
-#include "atn/PredictionMode.h"
-#include "atn/ProfilingATNSimulator.h"
-#include "atn/RangeTransition.h"
-#include "atn/RuleStartState.h"
-#include "atn/RuleStopState.h"
-#include "atn/RuleTransition.h"
-#include "atn/SemanticContext.h"
-#include "atn/SerializedATNView.h"
-#include "atn/SetTransition.h"
-#include "atn/SingletonPredictionContext.h"
-#include "atn/StarBlockStartState.h"
-#include "atn/StarLoopEntryState.h"
-#include "atn/StarLoopbackState.h"
-#include "atn/TokensStartState.h"
-#include "atn/Transition.h"
-#include "atn/WildcardTransition.h"
-#include "dfa/DFA.h"
-#include "dfa/DFASerializer.h"
-#include "dfa/DFAState.h"
-#include "dfa/LexerDFASerializer.h"
-#include "misc/InterpreterDataReader.h"
-#include "misc/Interval.h"
-#include "misc/IntervalSet.h"
-#include "misc/MurmurHash.h"
-#include "misc/Predicate.h"
-#include "support/Any.h"
-#include "support/Arrays.h"
-#include "support/BitSet.h"
-#include "support/Casts.h"
-#include "support/CPPUtils.h"
-#include "tree/AbstractParseTreeVisitor.h"
-#include "tree/ErrorNode.h"
-#include "tree/ErrorNodeImpl.h"
-#include "tree/ParseTree.h"
-#include "tree/ParseTreeListener.h"
-#include "tree/ParseTreeProperty.h"
-#include "tree/ParseTreeVisitor.h"
-#include "tree/ParseTreeWalker.h"
-#include "tree/TerminalNode.h"
-#include "tree/TerminalNodeImpl.h"
-#include "tree/Trees.h"
-#include "tree/pattern/Chunk.h"
-#include "tree/pattern/ParseTreeMatch.h"
-#include "tree/pattern/ParseTreePattern.h"
-#include "tree/pattern/ParseTreePatternMatcher.h"
-#include "tree/pattern/RuleTagToken.h"
-#include "tree/pattern/TagChunk.h"
-#include "tree/pattern/TextChunk.h"
-#include "tree/pattern/TokenTagToken.h"
-#include "tree/xpath/XPath.h"
-#include "tree/xpath/XPathElement.h"
-#include "tree/xpath/XPathLexer.h"
-#include "tree/xpath/XPathLexerErrorListener.h"
-#include "tree/xpath/XPathRuleAnywhereElement.h"
-#include "tree/xpath/XPathRuleElement.h"
-#include "tree/xpath/XPathTokenAnywhereElement.h"
-#include "tree/xpath/XPathTokenElement.h"
-#include "tree/xpath/XPathWildcardAnywhereElement.h"
-#include "tree/xpath/XPathWildcardElement.h"
-#include "internal/Synchronization.h"

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

@@ -1,159 +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 "atn/LL1Analyzer.h"
-#include "Token.h"
-#include "atn/RuleTransition.h"
-#include "misc/IntervalSet.h"
-#include "RuleContext.h"
-#include "atn/DecisionState.h"
-#include "Recognizer.h"
-#include "atn/ATNType.h"
-#include "Exceptions.h"
-#include "support/CPPUtils.h"
-
-#include "atn/ATN.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-using namespace antlr4::internal;
-using namespace antlrcpp;
-
-ATN::ATN() : ATN(ATNType::LEXER, 0) {}
-
-ATN::ATN(ATNType grammarType_, size_t maxTokenType_) : grammarType(grammarType_), maxTokenType(maxTokenType_) {}
-
-ATN::~ATN() {
-  for (ATNState *state : states) {
-    delete state;
-  }
-}
-
-misc::IntervalSet ATN::nextTokens(ATNState *s, RuleContext *ctx) const {
-  LL1Analyzer analyzer(*this);
-  return analyzer.LOOK(s, ctx);
-
-}
-
-misc::IntervalSet const& ATN::nextTokens(ATNState *s) const {
-  if (!s->_nextTokenUpdated) {
-    UniqueLock<Mutex> lock(_mutex);
-    if (!s->_nextTokenUpdated) {
-      s->_nextTokenWithinRule = nextTokens(s, nullptr);
-      s->_nextTokenUpdated = true;
-    }
-  }
-  return s->_nextTokenWithinRule;
-}
-
-void ATN::addState(ATNState *state) {
-  if (state != nullptr) {
-    //state->atn = this;
-    state->stateNumber = static_cast<int>(states.size());
-  }
-
-  states.push_back(state);
-}
-
-void ATN::removeState(ATNState *state) {
-  delete states.at(state->stateNumber);// just free mem, don't shift states in list
-  states.at(state->stateNumber) = nullptr;
-}
-
-int ATN::defineDecisionState(DecisionState *s) {
-  decisionToState.push_back(s);
-  s->decision = static_cast<int>(decisionToState.size() - 1);
-  return s->decision;
-}
-
-DecisionState *ATN::getDecisionState(size_t decision) const {
-  if (!decisionToState.empty()) {
-    return decisionToState[decision];
-  }
-  return nullptr;
-}
-
-size_t ATN::getNumberOfDecisions() const {
-  return decisionToState.size();
-}
-
-misc::IntervalSet ATN::getExpectedTokens(size_t stateNumber, RuleContext *context) const {
-  if (stateNumber == ATNState::INVALID_STATE_NUMBER || stateNumber >= states.size()) {
-    throw IllegalArgumentException("Invalid state number.");
-  }
-
-  RuleContext *ctx = context;
-  ATNState *s = states.at(stateNumber);
-  misc::IntervalSet following = nextTokens(s);
-  if (!following.contains(Token::EPSILON)) {
-    return following;
-  }
-
-  misc::IntervalSet expected;
-  expected.addAll(following);
-  expected.remove(Token::EPSILON);
-  while (ctx && ctx->invokingState != ATNState::INVALID_STATE_NUMBER && following.contains(Token::EPSILON)) {
-    ATNState *invokingState = states.at(ctx->invokingState);
-    const RuleTransition *rt = static_cast<const RuleTransition*>(invokingState->transitions[0].get());
-    following = nextTokens(rt->followState);
-    expected.addAll(following);
-    expected.remove(Token::EPSILON);
-
-    if (ctx->parent == nullptr) {
-      break;
-    }
-    ctx = static_cast<RuleContext *>(ctx->parent);
-  }
-
-  if (following.contains(Token::EPSILON)) {
-    expected.add(Token::EOF);
-  }
-
-  return expected;
-}
-
-std::string ATN::toString() const {
-  std::stringstream ss;
-  std::string type;
-  switch (grammarType) {
-    case ATNType::LEXER:
-      type = "LEXER ";
-      break;
-
-    case ATNType::PARSER:
-      type = "PARSER ";
-      break;
-
-    default:
-      break;
-  }
-  ss << "(" << type << "ATN " << std::hex << this << std::dec << ") maxTokenType: " << maxTokenType << std::endl;
-  ss << "states (" << states.size() << ") {" << std::endl;
-
-  size_t index = 0;
-  for (auto *state : states) {
-    if (state == nullptr) {
-      ss << "  " << index++ << ": nul" << std::endl;
-    } else {
-      std::string text = state->toString();
-      ss << "  " << index++ << ": " << indent(text, "  ", false) << std::endl;
-    }
-  }
-
-  index = 0;
-  for (auto *state : decisionToState) {
-    if (state == nullptr) {
-      ss << "  " << index++ << ": nul" << std::endl;
-    } else {
-      std::string text = state->toString();
-      ss << "  " << index++ << ": " << indent(text, "  ", false) << std::endl;
-    }
-  }
-
-  ss << "}";
-
-  return ss.str();
-}
-

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

@@ -1,133 +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 "RuleContext.h"
-#include "internal/Synchronization.h"
-
-// GCC generates a warning when forward-declaring ATN if ATN has already been
-// declared due to the attributes added by ANTLR4CPP_PUBLIC.
-// See: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=39159
-// Add constant that can be checked so forward-declarations can be omitted.
-#define ANTLR4CPP_ATN_DECLARED
-
-namespace antlr4 {
-namespace atn {
-
-  class LexerATNSimulator;
-  class ParserATNSimulator;
-
-  class ANTLR4CPP_PUBLIC ATN {
-  public:
-    static constexpr size_t INVALID_ALT_NUMBER = 0;
-
-    /// Used for runtime deserialization of ATNs from strings.
-    ATN();
-
-    ATN(ATNType grammarType, size_t maxTokenType);
-
-    ATN(const ATN&) = delete;
-
-    ATN(ATN&&) = delete;
-
-    ~ATN();
-
-    ATN& operator=(const ATN&) = delete;
-
-    ATN& operator=(ATN&&) = delete;
-
-    std::vector<ATNState *> states;
-
-    /// Each subrule/rule is a decision point and we must track them so we
-    /// can go back later and build DFA predictors for them.  This includes
-    /// all the rules, subrules, optional blocks, ()+, ()* etc...
-    std::vector<DecisionState *> decisionToState;
-
-    /// Maps from rule index to starting state number.
-    std::vector<RuleStartState *> ruleToStartState;
-
-    /// Maps from rule index to stop state number.
-    std::vector<RuleStopState *> ruleToStopState;
-
-    /// The type of the ATN.
-    ATNType grammarType;
-
-    /// The maximum value for any symbol recognized by a transition in the ATN.
-    size_t maxTokenType;
-
-    /// <summary>
-    /// For lexer ATNs, this maps the rule index to the resulting token type.
-    /// For parser ATNs, this maps the rule index to the generated bypass token
-    /// type if the
-    /// <seealso cref="ATNDeserializationOptions#isGenerateRuleBypassTransitions"/>
-    /// deserialization option was specified; otherwise, this is {@code null}.
-    /// </summary>
-    std::vector<size_t> ruleToTokenType;
-
-    /// For lexer ATNs, this is an array of {@link LexerAction} objects which may
-    /// be referenced by action transitions in the ATN.
-    std::vector<Ref<const LexerAction>> lexerActions;
-
-    std::vector<TokensStartState *> modeToStartState;
-
-    /// <summary>
-    /// Compute the set of valid tokens that can occur starting in state {@code s}.
-    ///  If {@code ctx} is null, the set of tokens will not include what can follow
-    ///  the rule surrounding {@code s}. In other words, the set will be
-    ///  restricted to tokens reachable staying within {@code s}'s rule.
-    /// </summary>
-    misc::IntervalSet nextTokens(ATNState *s, RuleContext *ctx) const;
-
-    /// <summary>
-    /// Compute the set of valid tokens that can occur starting in {@code s} and
-    /// staying in same rule. <seealso cref="Token#EPSILON"/> is in set if we reach end of
-    /// rule.
-    /// </summary>
-    misc::IntervalSet const& nextTokens(ATNState *s) const;
-
-    void addState(ATNState *state);
-
-    void removeState(ATNState *state);
-
-    int defineDecisionState(DecisionState *s);
-
-    DecisionState *getDecisionState(size_t decision) const;
-
-    size_t getNumberOfDecisions() const;
-
-    /// <summary>
-    /// Computes the set of input symbols which could follow ATN state number
-    /// {@code stateNumber} in the specified full {@code context}. This method
-    /// considers the complete parser context, but does not evaluate semantic
-    /// predicates (i.e. all predicates encountered during the calculation are
-    /// assumed true). If a path in the ATN exists from the starting state to the
-    /// <seealso cref="RuleStopState"/> of the outermost context without matching any
-    /// symbols, <seealso cref="Token#EOF"/> is added to the returned set.
-    /// <p/>
-    /// If {@code context} is {@code null}, it is treated as
-    /// <seealso cref="ParserRuleContext#EMPTY"/>.
-    /// </summary>
-    /// <param name="stateNumber"> the ATN state number </param>
-    /// <param name="context"> the full parse context </param>
-    /// <returns> The set of potentially valid input symbols which could follow the
-    /// specified state in the specified context. </returns>
-    /// <exception cref="IllegalArgumentException"> if the ATN does not contain a state with
-    /// number {@code stateNumber} </exception>
-    misc::IntervalSet getExpectedTokens(size_t stateNumber, RuleContext *context) const;
-
-    std::string toString() const;
-
-  private:
-    friend class LexerATNSimulator;
-    friend class ParserATNSimulator;
-
-    mutable internal::Mutex _mutex;
-    mutable internal::SharedMutex _stateMutex;
-    mutable internal::SharedMutex _edgeMutex;
-  };
-
-} // namespace atn
-} // namespace antlr4

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

@@ -1,106 +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/PredictionContext.h"
-#include "SemanticContext.h"
-
-#include "atn/ATNConfig.h"
-
-using namespace antlr4::atn;
-
-namespace {
-
-/**
- * This field stores the bit mask for implementing the
- * {@link #isPrecedenceFilterSuppressed} property as a bit within the
- * existing {@link #reachesIntoOuterContext} field.
- */
-inline constexpr size_t SUPPRESS_PRECEDENCE_FILTER = 0x40000000;
-
-}
-
-ATNConfig::ATNConfig(ATNState *state, size_t alt, Ref<const PredictionContext> context)
-    : ATNConfig(state, alt, std::move(context), 0, SemanticContext::Empty::Instance) {}
-
-ATNConfig::ATNConfig(ATNState *state, size_t alt, Ref<const PredictionContext> context, Ref<const SemanticContext> semanticContext)
-    : ATNConfig(state, alt, std::move(context), 0, std::move(semanticContext)) {}
-
-ATNConfig::ATNConfig(ATNConfig const& other, Ref<const SemanticContext> semanticContext)
-    : ATNConfig(other.state, other.alt, other.context, other.reachesIntoOuterContext, std::move(semanticContext)) {}
-
-ATNConfig::ATNConfig(ATNConfig const& other, ATNState *state)
-    : ATNConfig(state, other.alt, other.context, other.reachesIntoOuterContext, other.semanticContext) {}
-
-ATNConfig::ATNConfig(ATNConfig const& other, ATNState *state, Ref<const SemanticContext> semanticContext)
-    : ATNConfig(state, other.alt, other.context, other.reachesIntoOuterContext, std::move(semanticContext)) {}
-
-ATNConfig::ATNConfig(ATNConfig const& other, ATNState *state, Ref<const PredictionContext> context)
-    : ATNConfig(state, other.alt, std::move(context), other.reachesIntoOuterContext, other.semanticContext) {}
-
-ATNConfig::ATNConfig(ATNConfig const& other, ATNState *state, Ref<const PredictionContext> context, Ref<const SemanticContext> semanticContext)
-    : ATNConfig(state, other.alt, std::move(context), other.reachesIntoOuterContext, std::move(semanticContext)) {}
-
-ATNConfig::ATNConfig(ATNState *state, size_t alt, Ref<const PredictionContext> context, size_t reachesIntoOuterContext, Ref<const SemanticContext> semanticContext)
-    : state(state), alt(alt), context(std::move(context)), reachesIntoOuterContext(reachesIntoOuterContext), semanticContext(std::move(semanticContext)) {}
-
-size_t ATNConfig::hashCode() const {
-  size_t hashCode = misc::MurmurHash::initialize(7);
-  hashCode = misc::MurmurHash::update(hashCode, state->stateNumber);
-  hashCode = misc::MurmurHash::update(hashCode, alt);
-  hashCode = misc::MurmurHash::update(hashCode, context);
-  hashCode = misc::MurmurHash::update(hashCode, semanticContext);
-  hashCode = misc::MurmurHash::finish(hashCode, 4);
-  return hashCode;
-}
-
-size_t ATNConfig::getOuterContextDepth() const {
-  return reachesIntoOuterContext & ~SUPPRESS_PRECEDENCE_FILTER;
-}
-
-bool ATNConfig::isPrecedenceFilterSuppressed() const {
-  return (reachesIntoOuterContext & SUPPRESS_PRECEDENCE_FILTER) != 0;
-}
-
-void ATNConfig::setPrecedenceFilterSuppressed(bool value) {
-  if (value) {
-    reachesIntoOuterContext |= SUPPRESS_PRECEDENCE_FILTER;
-  } else {
-    reachesIntoOuterContext &= ~SUPPRESS_PRECEDENCE_FILTER;
-  }
-}
-
-bool ATNConfig::operator==(const ATNConfig &other) const {
-  return state->stateNumber == other.state->stateNumber && alt == other.alt &&
-    ((context == other.context) || (*context == *other.context)) &&
-    *semanticContext == *other.semanticContext &&
-    isPrecedenceFilterSuppressed() == other.isPrecedenceFilterSuppressed();
-}
-
-std::string ATNConfig::toString() const {
-  return toString(true);
-}
-
-std::string ATNConfig::toString(bool showAlt) const {
-  std::stringstream ss;
-  ss << "(";
-
-  ss << state->toString();
-  if (showAlt) {
-    ss << "," << alt;
-  }
-  if (context) {
-    ss << ",[" << context->toString() << "]";
-  }
-  if (semanticContext != nullptr && semanticContext != SemanticContext::Empty::Instance) {
-    ss << "," << semanticContext->toString();
-  }
-  if (getOuterContextDepth() > 0) {
-    ss << ",up=" << getOuterContextDepth();
-  }
-  ss << ")";
-
-  return ss.str();
-}