expressir 1.4.3 → 2.1.0

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

@@ -1,628 +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/ATNDeserializationOptions.h"
-
-#include "atn/ATNType.h"
-#include "atn/ATNState.h"
-#include "atn/ATN.h"
-
-#include "atn/LoopEndState.h"
-#include "atn/DecisionState.h"
-#include "atn/RuleStartState.h"
-#include "atn/RuleStopState.h"
-#include "atn/TokensStartState.h"
-#include "atn/RuleTransition.h"
-#include "atn/EpsilonTransition.h"
-#include "atn/PlusLoopbackState.h"
-#include "atn/PlusBlockStartState.h"
-#include "atn/StarLoopbackState.h"
-#include "atn/BasicBlockStartState.h"
-#include "atn/BasicState.h"
-#include "atn/BlockEndState.h"
-#include "atn/StarLoopEntryState.h"
-
-#include "atn/AtomTransition.h"
-#include "atn/StarBlockStartState.h"
-#include "atn/RangeTransition.h"
-#include "atn/PredicateTransition.h"
-#include "atn/PrecedencePredicateTransition.h"
-#include "atn/ActionTransition.h"
-#include "atn/SetTransition.h"
-#include "atn/NotSetTransition.h"
-#include "atn/WildcardTransition.h"
-#include "atn/TransitionType.h"
-#include "Token.h"
-
-#include "misc/IntervalSet.h"
-#include "Exceptions.h"
-#include "support/CPPUtils.h"
-#include "support/Casts.h"
-
-#include "atn/LexerCustomAction.h"
-#include "atn/LexerChannelAction.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/ATNDeserializer.h"
-
-#include <cassert>
-#include <string>
-#include <vector>
-
-using namespace antlr4;
-using namespace antlr4::atn;
-using namespace antlrcpp;
-
-namespace {
-
-  void checkCondition(bool condition, std::string_view message) {
-    if (!condition) {
-      throw IllegalStateException(std::string(message));
-    }
-  }
-
-  void checkCondition(bool condition) {
-    checkCondition(condition, "");
-  }
-
-  /**
-   * Analyze the {@link StarLoopEntryState} states in the specified ATN to set
-   * the {@link StarLoopEntryState#isPrecedenceDecision} field to the
-   * correct value.
-   *
-   * @param atn The ATN.
-   */
-  void markPrecedenceDecisions(const ATN &atn) {
-    for (ATNState *state : atn.states) {
-      if (!StarLoopEntryState::is(state)) {
-        continue;
-      }
-
-      /* We analyze the ATN to determine if this ATN decision state is the
-      * decision for the closure block that determines whether a
-      * precedence rule should continue or complete.
-      */
-      if (atn.ruleToStartState[state->ruleIndex]->isLeftRecursiveRule) {
-        ATNState *maybeLoopEndState = state->transitions[state->transitions.size() - 1]->target;
-        if (LoopEndState::is(maybeLoopEndState)) {
-          if (maybeLoopEndState->epsilonOnlyTransitions && RuleStopState::is(maybeLoopEndState->transitions[0]->target)) {
-            downCast<StarLoopEntryState*>(state)->isPrecedenceDecision = true;
-          }
-        }
-      }
-    }
-  }
-
-  Ref<const LexerAction> lexerActionFactory(LexerActionType type, int data1, int data2) {
-    switch (type) {
-      case LexerActionType::CHANNEL:
-        return std::make_shared<LexerChannelAction>(data1);
-
-      case LexerActionType::CUSTOM:
-        return std::make_shared<LexerCustomAction>(data1, data2);
-
-      case LexerActionType::MODE:
-        return std::make_shared< LexerModeAction>(data1);
-
-      case LexerActionType::MORE:
-        return LexerMoreAction::getInstance();
-
-      case LexerActionType::POP_MODE:
-        return LexerPopModeAction::getInstance();
-
-      case LexerActionType::PUSH_MODE:
-        return std::make_shared<LexerPushModeAction>(data1);
-
-      case LexerActionType::SKIP:
-        return LexerSkipAction::getInstance();
-
-      case LexerActionType::TYPE:
-        return std::make_shared<LexerTypeAction>(data1);
-
-      default:
-        throw IllegalArgumentException("The specified lexer action type " + std::to_string(static_cast<size_t>(type)) +
-                                      " is not valid.");
-    }
-  }
-
-  ConstTransitionPtr edgeFactory(const ATN &atn, TransitionType type, size_t trg, size_t arg1, size_t arg2,
-                                        size_t arg3, const std::vector<misc::IntervalSet> &sets) {
-    ATNState *target = atn.states[trg];
-    switch (type) {
-      case TransitionType::EPSILON:
-        return std::make_unique<EpsilonTransition>(target);
-      case TransitionType::RANGE:
-        if (arg3 != 0) {
-          return std::make_unique<RangeTransition>(target, Token::EOF, arg2);
-        } else {
-          return std::make_unique<RangeTransition>(target, arg1, arg2);
-        }
-      case TransitionType::RULE:
-        return std::make_unique<RuleTransition>(downCast<RuleStartState*>(atn.states[arg1]), arg2, (int)arg3, target);
-      case TransitionType::PREDICATE:
-        return std::make_unique<PredicateTransition>(target, arg1, arg2, arg3 != 0);
-      case TransitionType::PRECEDENCE:
-        return std::make_unique<PrecedencePredicateTransition>(target, (int)arg1);
-      case TransitionType::ATOM:
-        if (arg3 != 0) {
-          return std::make_unique<AtomTransition>(target, Token::EOF);
-        } else {
-          return std::make_unique<AtomTransition>(target, arg1);
-        }
-      case TransitionType::ACTION:
-        return std::make_unique<ActionTransition>(target, arg1, arg2, arg3 != 0);
-      case TransitionType::SET:
-        return std::make_unique<SetTransition>(target, sets[arg1]);
-      case TransitionType::NOT_SET:
-        return std::make_unique<NotSetTransition>(target, sets[arg1]);
-      case TransitionType::WILDCARD:
-        return std::make_unique<WildcardTransition>(target);
-    }
-
-    throw IllegalArgumentException("The specified transition type is not valid.");
-  }
-
-  /* mem check: all created instances are freed in the d-tor of the ATN. */
-  ATNState* stateFactory(ATNStateType type, size_t ruleIndex) {
-    ATNState *s;
-    switch (type) {
-      case ATNStateType::INVALID:
-        return nullptr;
-      case ATNStateType::BASIC :
-        s = new BasicState();
-        break;
-      case ATNStateType::RULE_START :
-        s = new RuleStartState();
-        break;
-      case ATNStateType::BLOCK_START :
-        s = new BasicBlockStartState();
-        break;
-      case ATNStateType::PLUS_BLOCK_START :
-        s = new PlusBlockStartState();
-        break;
-      case ATNStateType::STAR_BLOCK_START :
-        s = new StarBlockStartState();
-        break;
-      case ATNStateType::TOKEN_START :
-        s = new TokensStartState();
-        break;
-      case ATNStateType::RULE_STOP :
-        s = new RuleStopState();
-        break;
-      case ATNStateType::BLOCK_END :
-        s = new BlockEndState();
-        break;
-      case ATNStateType::STAR_LOOP_BACK :
-        s = new StarLoopbackState();
-        break;
-      case ATNStateType::STAR_LOOP_ENTRY :
-        s = new StarLoopEntryState();
-        break;
-      case ATNStateType::PLUS_LOOP_BACK :
-        s = new PlusLoopbackState();
-        break;
-      case ATNStateType::LOOP_END :
-        s = new LoopEndState();
-        break;
-      default :
-        std::string message = "The specified state type " + std::to_string(static_cast<size_t>(type)) + " is not valid.";
-        throw IllegalArgumentException(message);
-    }
-    assert(s->getStateType() == type);
-    s->ruleIndex = ruleIndex;
-    return s;
-  }
-
-  ssize_t readUnicodeInt32(SerializedATNView data, int& p) {
-    return static_cast<ssize_t>(data[p++]);
-  }
-
-  void deserializeSets(
-    SerializedATNView data,
-    int& p,
-    std::vector<misc::IntervalSet>& sets) {
-    size_t nsets = data[p++];
-    sets.reserve(sets.size() + nsets);
-    for (size_t i = 0; i < nsets; i++) {
-      size_t nintervals = data[p++];
-      misc::IntervalSet set;
-
-      bool containsEof = data[p++] != 0;
-      if (containsEof) {
-        set.add(-1);
-      }
-
-      for (size_t j = 0; j < nintervals; j++) {
-        auto a = readUnicodeInt32(data, p);
-        auto b = readUnicodeInt32(data, p);
-        set.add(a, b);
-      }
-      sets.push_back(set);
-    }
-  }
-
-}
-
-ATNDeserializer::ATNDeserializer() : ATNDeserializer(ATNDeserializationOptions::getDefaultOptions()) {}
-
-ATNDeserializer::ATNDeserializer(ATNDeserializationOptions deserializationOptions) : _deserializationOptions(std::move(deserializationOptions)) {}
-
-std::unique_ptr<ATN> ATNDeserializer::deserialize(SerializedATNView data) const {
-  int p = 0;
-  int version = data[p++];
-  if (version != SERIALIZED_VERSION) {
-    std::string reason = "Could not deserialize ATN with version" + std::to_string(version) + "(expected " + std::to_string(SERIALIZED_VERSION) + ").";
-
-    throw UnsupportedOperationException(reason);
-  }
-
-  ATNType grammarType = (ATNType)data[p++];
-  size_t maxTokenType = data[p++];
-  auto atn = std::make_unique<ATN>(grammarType, maxTokenType);
-
-  //
-  // STATES
-  //
-  {
-    std::vector<std::pair<LoopEndState*, size_t>> loopBackStateNumbers;
-    std::vector<std::pair<BlockStartState*, size_t>> endStateNumbers;
-    size_t nstates = data[p++];
-    atn->states.reserve(nstates);
-    loopBackStateNumbers.reserve(nstates);  // Reserve worst case size, its short lived.
-    endStateNumbers.reserve(nstates);  // Reserve worst case size, its short lived.
-    for (size_t i = 0; i < nstates; i++) {
-      ATNStateType stype = static_cast<ATNStateType>(data[p++]);
-      // ignore bad type of states
-      if (stype == ATNStateType::INVALID) {
-        atn->addState(nullptr);
-        continue;
-      }
-
-      size_t ruleIndex = data[p++];
-      ATNState *s = stateFactory(stype, ruleIndex);
-      if (stype == ATNStateType::LOOP_END) { // special case
-        int loopBackStateNumber = data[p++];
-        loopBackStateNumbers.push_back({ downCast<LoopEndState*>(s),  loopBackStateNumber });
-      } else if (BlockStartState::is(s)) {
-        int endStateNumber = data[p++];
-        endStateNumbers.push_back({ downCast<BlockStartState*>(s), endStateNumber });
-      }
-      atn->addState(s);
-    }
-
-    // delay the assignment of loop back and end states until we know all the state instances have been initialized
-    for (auto &pair : loopBackStateNumbers) {
-      pair.first->loopBackState = atn->states[pair.second];
-    }
-
-    for (auto &pair : endStateNumbers) {
-      pair.first->endState = downCast<BlockEndState*>(atn->states[pair.second]);
-    }
-  }
-
-  size_t numNonGreedyStates = data[p++];
-  for (size_t i = 0; i < numNonGreedyStates; i++) {
-    size_t stateNumber = data[p++];
-    // The serialized ATN must be specifying the right states, so that the
-    // cast below is correct.
-    downCast<DecisionState*>(atn->states[stateNumber])->nonGreedy = true;
-  }
-
-  size_t numPrecedenceStates = data[p++];
-  for (size_t i = 0; i < numPrecedenceStates; i++) {
-    size_t stateNumber = data[p++];
-    downCast<RuleStartState*>(atn->states[stateNumber])->isLeftRecursiveRule = true;
-  }
-
-  //
-  // RULES
-  //
-  size_t nrules = data[p++];
-  atn->ruleToStartState.reserve(nrules);
-  for (size_t i = 0; i < nrules; i++) {
-    size_t s = data[p++];
-    // Also here, the serialized atn must ensure to point to the correct class type.
-    RuleStartState *startState = downCast<RuleStartState*>(atn->states[s]);
-    atn->ruleToStartState.push_back(startState);
-    if (atn->grammarType == ATNType::LEXER) {
-      size_t tokenType = data[p++];
-      atn->ruleToTokenType.push_back(tokenType);
-    }
-  }
-
-  atn->ruleToStopState.resize(nrules);
-  for (ATNState *state : atn->states) {
-    if (!RuleStopState::is(state)) {
-      continue;
-    }
-
-    RuleStopState *stopState = downCast<RuleStopState*>(state);
-    atn->ruleToStopState[state->ruleIndex] = stopState;
-    atn->ruleToStartState[state->ruleIndex]->stopState = stopState;
-  }
-
-  //
-  // MODES
-  //
-  size_t nmodes = data[p++];
-  atn->modeToStartState.reserve(nmodes);
-  for (size_t i = 0; i < nmodes; i++) {
-    size_t s = data[p++];
-    atn->modeToStartState.push_back(downCast<TokensStartState*>(atn->states[s]));
-  }
-
-  //
-  // SETS
-  //
-  {
-    std::vector<misc::IntervalSet> sets;
-
-    deserializeSets(data, p, sets);
-    sets.shrink_to_fit();
-
-    //
-    // EDGES
-    //
-    int nedges = data[p++];
-    for (int i = 0; i < nedges; i++) {
-      size_t src = data[p];
-      size_t trg = data[p + 1];
-      TransitionType ttype = static_cast<TransitionType>(data[p + 2]);
-      size_t arg1 = data[p + 3];
-      size_t arg2 = data[p + 4];
-      size_t arg3 = data[p + 5];
-      ConstTransitionPtr trans = edgeFactory(*atn, ttype, trg, arg1, arg2, arg3, sets);
-      ATNState *srcState = atn->states[src];
-      srcState->addTransition(std::move(trans));
-      p += 6;
-    }
-  }
-  // edges for rule stop states can be derived, so they aren't serialized
-  for (ATNState *state : atn->states) {
-    for (size_t i = 0; i < state->transitions.size(); i++) {
-      const Transition *t = state->transitions[i].get();
-      if (!RuleTransition::is(t)) {
-        continue;
-      }
-
-      const RuleTransition *ruleTransition = downCast<const RuleTransition*>(t);
-      size_t outermostPrecedenceReturn = INVALID_INDEX;
-      if (atn->ruleToStartState[ruleTransition->target->ruleIndex]->isLeftRecursiveRule) {
-        if (ruleTransition->precedence == 0) {
-          outermostPrecedenceReturn = ruleTransition->target->ruleIndex;
-        }
-      }
-
-      ConstTransitionPtr returnTransition = std::make_unique<EpsilonTransition>(ruleTransition->followState, outermostPrecedenceReturn);
-      atn->ruleToStopState[ruleTransition->target->ruleIndex]->addTransition(std::move(returnTransition));
-    }
-  }
-
-  for (ATNState *state : atn->states) {
-    if (BlockStartState::is(state)) {
-      BlockStartState *startState = downCast<BlockStartState*>(state);
-
-      // we need to know the end state to set its start state
-      if (startState->endState == nullptr) {
-        throw IllegalStateException();
-      }
-
-      // block end states can only be associated to a single block start state
-      if (startState->endState->startState != nullptr) {
-        throw IllegalStateException();
-      }
-
-      startState->endState->startState = downCast<BlockStartState*>(state);
-    }
-
-    if (PlusLoopbackState::is(state)) {
-      PlusLoopbackState *loopbackState = downCast<PlusLoopbackState*>(state);
-      for (size_t i = 0; i < loopbackState->transitions.size(); i++) {
-        ATNState *target = loopbackState->transitions[i]->target;
-        if (PlusBlockStartState::is(target)) {
-          (downCast<PlusBlockStartState*>(target))->loopBackState = loopbackState;
-        }
-      }
-    } else if (StarLoopbackState::is(state)) {
-      StarLoopbackState *loopbackState = downCast<StarLoopbackState*>(state);
-      for (size_t i = 0; i < loopbackState->transitions.size(); i++) {
-        ATNState *target = loopbackState->transitions[i]->target;
-        if (StarLoopEntryState::is(target)) {
-          downCast<StarLoopEntryState*>(target)->loopBackState = loopbackState;
-        }
-      }
-    }
-  }
-
-  //
-  // DECISIONS
-  //
-  size_t ndecisions = data[p++];
-  atn->decisionToState.reserve(ndecisions);
-  for (size_t i = 0; i < ndecisions; i++) {
-    size_t s = data[p++];
-    DecisionState *decState = downCast<DecisionState*>(atn->states[s]);
-    if (decState == nullptr)
-      throw IllegalStateException();
-
-    atn->decisionToState.push_back(decState);
-    decState->decision = static_cast<int>(i);
-  }
-
-  //
-  // LEXER ACTIONS
-  //
-  if (atn->grammarType == ATNType::LEXER) {
-    atn->lexerActions.resize(data[p++]);
-    for (size_t i = 0; i < atn->lexerActions.size(); i++) {
-      LexerActionType actionType = static_cast<LexerActionType>(data[p++]);
-      int data1 = data[p++];
-      int data2 = data[p++];
-      atn->lexerActions[i] = lexerActionFactory(actionType, data1, data2);
-    }
-  }
-
-  markPrecedenceDecisions(*atn);
-
-  if (_deserializationOptions.isVerifyATN()) {
-    verifyATN(*atn);
-  }
-
-  if (_deserializationOptions.isGenerateRuleBypassTransitions() && atn->grammarType == ATNType::PARSER) {
-    atn->ruleToTokenType.resize(atn->ruleToStartState.size());
-    for (size_t i = 0; i < atn->ruleToStartState.size(); i++) {
-      atn->ruleToTokenType[i] = static_cast<int>(atn->maxTokenType + i + 1);
-    }
-
-    for (std::vector<RuleStartState*>::size_type i = 0; i < atn->ruleToStartState.size(); i++) {
-      BasicBlockStartState *bypassStart = new BasicBlockStartState(); /* mem check: freed in ATN d-tor */
-      bypassStart->ruleIndex = static_cast<int>(i);
-      atn->addState(bypassStart);
-
-      BlockEndState *bypassStop = new BlockEndState(); /* mem check: freed in ATN d-tor */
-      bypassStop->ruleIndex = static_cast<int>(i);
-      atn->addState(bypassStop);
-
-      bypassStart->endState = bypassStop;
-      atn->defineDecisionState(bypassStart);
-
-      bypassStop->startState = bypassStart;
-
-      ATNState *endState;
-      const Transition *excludeTransition = nullptr;
-      if (atn->ruleToStartState[i]->isLeftRecursiveRule) {
-        // wrap from the beginning of the rule to the StarLoopEntryState
-        endState = nullptr;
-        for (ATNState *state : atn->states) {
-          if (state->ruleIndex != i) {
-            continue;
-          }
-
-          if (!StarLoopEntryState::is(state)) {
-            continue;
-          }
-
-          ATNState *maybeLoopEndState = state->transitions[state->transitions.size() - 1]->target;
-          if (!LoopEndState::is(maybeLoopEndState)) {
-            continue;
-          }
-
-          if (maybeLoopEndState->epsilonOnlyTransitions && RuleStopState::is(maybeLoopEndState->transitions[0]->target)) {
-            endState = state;
-            break;
-          }
-        }
-
-        if (endState == nullptr) {
-          throw UnsupportedOperationException("Couldn't identify final state of the precedence rule prefix section.");
-
-        }
-
-        excludeTransition = (static_cast<StarLoopEntryState*>(endState))->loopBackState->transitions[0].get();
-      } else {
-        endState = atn->ruleToStopState[i];
-      }
-
-      // all non-excluded transitions that currently target end state need to target blockEnd instead
-      for (ATNState *state : atn->states) {
-        for (auto &transition : state->transitions) {
-          if (transition.get() == excludeTransition) {
-            continue;
-          }
-
-          if (transition->target == endState) {
-            const_cast<Transition*>(transition.get())->target = bypassStop;
-          }
-        }
-      }
-
-      // all transitions leaving the rule start state need to leave blockStart instead
-      while (atn->ruleToStartState[i]->transitions.size() > 0) {
-        ConstTransitionPtr transition = atn->ruleToStartState[i]->removeTransition(atn->ruleToStartState[i]->transitions.size() - 1);
-        bypassStart->addTransition(std::move(transition));
-      }
-
-      // link the new states
-      atn->ruleToStartState[i]->addTransition(std::make_unique<EpsilonTransition>(bypassStart));
-      bypassStop->addTransition(std::make_unique<EpsilonTransition>(endState));
-
-      ATNState *matchState = new BasicState(); /* mem check: freed in ATN d-tor */
-      atn->addState(matchState);
-      matchState->addTransition(std::make_unique<AtomTransition>(bypassStop, atn->ruleToTokenType[i]));
-      bypassStart->addTransition(std::make_unique<EpsilonTransition>(matchState));
-    }
-
-    if (_deserializationOptions.isVerifyATN()) {
-      // reverify after modification
-      verifyATN(*atn);
-    }
-  }
-
-  return atn;
-}
-
-void ATNDeserializer::verifyATN(const ATN &atn) const {
-  // verify assumptions
-  for (ATNState *state : atn.states) {
-    if (state == nullptr) {
-      continue;
-    }
-
-    checkCondition(state->epsilonOnlyTransitions || state->transitions.size() <= 1);
-
-    if (PlusBlockStartState::is(state)) {
-      checkCondition((downCast<PlusBlockStartState*>(state))->loopBackState != nullptr);
-    }
-
-    if (StarLoopEntryState::is(state)) {
-      StarLoopEntryState *starLoopEntryState = downCast<StarLoopEntryState*>(state);
-      checkCondition(starLoopEntryState->loopBackState != nullptr);
-      checkCondition(starLoopEntryState->transitions.size() == 2);
-
-      if (StarBlockStartState::is(starLoopEntryState->transitions[0]->target)) {
-        checkCondition(downCast<LoopEndState*>(starLoopEntryState->transitions[1]->target) != nullptr);
-        checkCondition(!starLoopEntryState->nonGreedy);
-      } else if (LoopEndState::is(starLoopEntryState->transitions[0]->target)) {
-        checkCondition(StarBlockStartState::is(starLoopEntryState->transitions[1]->target));
-        checkCondition(starLoopEntryState->nonGreedy);
-      } else {
-        throw IllegalStateException();
-      }
-    }
-
-    if (StarLoopbackState::is(state)) {
-      checkCondition(state->transitions.size() == 1);
-      checkCondition(StarLoopEntryState::is(state->transitions[0]->target));
-    }
-
-    if (LoopEndState::is(state)) {
-      checkCondition((downCast<LoopEndState*>(state))->loopBackState != nullptr);
-    }
-
-    if (RuleStartState::is(state)) {
-      checkCondition((downCast<RuleStartState*>(state))->stopState != nullptr);
-    }
-
-    if (BlockStartState::is(state)) {
-      checkCondition((downCast<BlockStartState*>(state))->endState != nullptr);
-    }
-
-    if (BlockEndState::is(state)) {
-      checkCondition((downCast<BlockEndState*>(state))->startState != nullptr);
-    }
-
-    if (DecisionState::is(state)) {
-      DecisionState *decisionState = downCast<DecisionState*>(state);
-      checkCondition(decisionState->transitions.size() <= 1 || decisionState->decision >= 0);
-    } else {
-      checkCondition(state->transitions.size() <= 1 || RuleStopState::is(state));
-    }
-  }
-}

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

@@ -1,32 +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/ATNDeserializationOptions.h"
-#include "atn/SerializedATNView.h"
-#include "atn/LexerAction.h"
-#include "atn/Transition.h"
-
-namespace antlr4 {
-namespace atn {
-
-  class ANTLR4CPP_PUBLIC ATNDeserializer final {
-  public:
-    static constexpr size_t SERIALIZED_VERSION = 4;
-
-    ATNDeserializer();
-
-    explicit ATNDeserializer(ATNDeserializationOptions deserializationOptions);
-
-    std::unique_ptr<ATN> deserialize(SerializedATNView input) const;
-    void verifyATN(const ATN &atn) const;
-
-  private:
-    const ATNDeserializationOptions _deserializationOptions;
-  };
-
-} // namespace atn
-} // namespace antlr4

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

@@ -1,33 +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/ATNSimulator.h"
-
-#include "atn/ATNConfigSet.h"
-#include "atn/ATNDeserializer.h"
-#include "atn/ATNType.h"
-#include "dfa/DFAState.h"
-
-using namespace antlr4;
-using namespace antlr4::dfa;
-using namespace antlr4::atn;
-
-const Ref<DFAState> ATNSimulator::ERROR = std::make_shared<DFAState>(std::numeric_limits<int>::max());
-
-ATNSimulator::ATNSimulator(const ATN &atn, PredictionContextCache &sharedContextCache)
-    : atn(atn), _sharedContextCache(sharedContextCache) {}
-
-void ATNSimulator::clearDFA() {
-  throw UnsupportedOperationException("This ATN simulator does not support clearing the DFA.");
-}
-
-PredictionContextCache& ATNSimulator::getSharedContextCache() const {
-  return _sharedContextCache;
-}
-
-Ref<const PredictionContext> ATNSimulator::getCachedContext(const Ref<const PredictionContext> &context) {
-  // This function must only be called with an active state lock, as we are going to change a shared structure.
-  return PredictionContext::getCachedContext(context, getSharedContextCache());
-}