Intermediate changes

1 files changed, 0 insertions, 294 deletions

diff --git a/contrib/libs/antlr4_cpp_runtime/src/ParserInterpreter.cpp b/contrib/libs/antlr4_cpp_runtime/src/ParserInterpreter.cpp
deleted file mode 100644
index e1c54a0eb1e..00000000000
--- a/contrib/libs/antlr4_cpp_runtime/src/ParserInterpreter.cpp
+++ /dev/null
@@ -1,294 +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 "dfa/DFA.h"
-#include "atn/RuleStartState.h"
-#include "InterpreterRuleContext.h"
-#include "atn/ParserATNSimulator.h"
-#include "ANTLRErrorStrategy.h"
-#include "atn/LoopEndState.h"
-#include "FailedPredicateException.h"
-#include "atn/StarLoopEntryState.h"
-#include "atn/AtomTransition.h"
-#include "atn/RuleTransition.h"
-#include "atn/PredicateTransition.h"
-#include "atn/PrecedencePredicateTransition.h"
-#include "atn/ActionTransition.h"
-#include "atn/ATN.h"
-#include "atn/RuleStopState.h"
-#include "Lexer.h"
-#include "Token.h"
-#include "Vocabulary.h"
-#include "InputMismatchException.h"
-#include "CommonToken.h"
-#include "tree/ErrorNode.h"
-
-#include "support/CPPUtils.h"
-#include "support/Casts.h"
-
-#include "ParserInterpreter.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-using namespace antlr4::misc;
-
-using namespace antlrcpp;
-
-ParserInterpreter::ParserInterpreter(const std::string &grammarFileName, const dfa::Vocabulary &vocabulary,
-  const std::vector<std::string> &ruleNames, const atn::ATN &atn, TokenStream *input)
-  : Parser(input), _grammarFileName(grammarFileName), _atn(atn), _ruleNames(ruleNames), _vocabulary(vocabulary) {
-
-  // init decision DFA
-  for (size_t i = 0; i < atn.getNumberOfDecisions(); ++i) {
-    atn::DecisionState *decisionState = atn.getDecisionState(i);
-    _decisionToDFA.push_back(dfa::DFA(decisionState, i));
-  }
-
-  // get atn simulator that knows how to do predictions
-  _interpreter = new atn::ParserATNSimulator(this, atn, _decisionToDFA, _sharedContextCache); /* mem-check: deleted in d-tor */
-}
-
-ParserInterpreter::~ParserInterpreter() {
-  delete _interpreter;
-}
-
-void ParserInterpreter::reset() {
-  Parser::reset();
-  _overrideDecisionReached = false;
-  _overrideDecisionRoot = nullptr;
-}
-
-const atn::ATN& ParserInterpreter::getATN() const {
-  return _atn;
-}
-
-const dfa::Vocabulary& ParserInterpreter::getVocabulary() const {
-  return _vocabulary;
-}
-
-const std::vector<std::string>& ParserInterpreter::getRuleNames() const {
-  return _ruleNames;
-}
-
-std::string ParserInterpreter::getGrammarFileName() const {
-  return _grammarFileName;
-}
-
-ParserRuleContext* ParserInterpreter::parse(size_t startRuleIndex) {
-  atn::RuleStartState *startRuleStartState = _atn.ruleToStartState[startRuleIndex];
-
-  _rootContext = createInterpreterRuleContext(nullptr, atn::ATNState::INVALID_STATE_NUMBER, startRuleIndex);
-
-  if (startRuleStartState->isLeftRecursiveRule) {
-    enterRecursionRule(_rootContext, startRuleStartState->stateNumber, startRuleIndex, 0);
-  } else {
-    enterRule(_rootContext, startRuleStartState->stateNumber, startRuleIndex);
-  }
-
-  while (true) {
-    atn::ATNState *p = getATNState();
-    switch (p->getStateType()) {
-      case atn::ATNStateType::RULE_STOP :
-        // pop; return from rule
-        if (_ctx->isEmpty()) {
-          if (startRuleStartState->isLeftRecursiveRule) {
-            ParserRuleContext *result = _ctx;
-            auto parentContext = _parentContextStack.top();
-            _parentContextStack.pop();
-            unrollRecursionContexts(parentContext.first);
-            return result;
-          } else {
-            exitRule();
-            return _rootContext;
-          }
-        }
-
-        visitRuleStopState(p);
-        break;
-
-      default :
-        try {
-          visitState(p);
-        }
-        catch (RecognitionException &e) {
-          setState(_atn.ruleToStopState[p->ruleIndex]->stateNumber);
-          getErrorHandler()->reportError(this, e);
-          getContext()->exception = std::current_exception();
-          recover(e);
-        }
-
-        break;
-    }
-  }
-}
-
-void ParserInterpreter::enterRecursionRule(ParserRuleContext *localctx, size_t state, size_t ruleIndex, int precedence) {
-  _parentContextStack.push({ _ctx, localctx->invokingState });
-  Parser::enterRecursionRule(localctx, state, ruleIndex, precedence);
-}
-
-void ParserInterpreter::addDecisionOverride(int decision, int tokenIndex, int forcedAlt) {
-  _overrideDecision = decision;
-  _overrideDecisionInputIndex = tokenIndex;
-  _overrideDecisionAlt = forcedAlt;
-}
-
-Ref<InterpreterRuleContext> ParserInterpreter::getOverrideDecisionRoot() const {
-  return _overrideDecisionRoot;
-}
-
-InterpreterRuleContext* ParserInterpreter::getRootContext() {
-  return _rootContext;
-}
-
-atn::ATNState* ParserInterpreter::getATNState() {
-  return _atn.states[getState()];
-}
-
-void ParserInterpreter::visitState(atn::ATNState *p) {
-  size_t predictedAlt = 1;
-  if (DecisionState::is(p)) {
-    predictedAlt = visitDecisionState(downCast<DecisionState*>(p));
-  }
-
-  const atn::Transition *transition = p->transitions[predictedAlt - 1].get();
-  switch (transition->getTransitionType()) {
-    case atn::TransitionType::EPSILON:
-      if (p->getStateType() == ATNStateType::STAR_LOOP_ENTRY &&
-        (downCast<StarLoopEntryState *>(p))->isPrecedenceDecision &&
-        !LoopEndState::is(transition->target)) {
-        // We are at the start of a left recursive rule's (...)* loop
-        // and we're not taking the exit branch of loop.
-        InterpreterRuleContext *localctx = createInterpreterRuleContext(_parentContextStack.top().first,
-          _parentContextStack.top().second, static_cast<int>(_ctx->getRuleIndex()));
-        pushNewRecursionContext(localctx, _atn.ruleToStartState[p->ruleIndex]->stateNumber, static_cast<int>(_ctx->getRuleIndex()));
-      }
-      break;
-
-    case atn::TransitionType::ATOM:
-      match(static_cast<int>(static_cast<const atn::AtomTransition*>(transition)->_label));
-      break;
-
-    case atn::TransitionType::RANGE:
-    case atn::TransitionType::SET:
-    case atn::TransitionType::NOT_SET:
-      if (!transition->matches(static_cast<int>(_input->LA(1)), Token::MIN_USER_TOKEN_TYPE, Lexer::MAX_CHAR_VALUE)) {
-        recoverInline();
-      }
-      matchWildcard();
-      break;
-
-    case atn::TransitionType::WILDCARD:
-      matchWildcard();
-      break;
-
-    case atn::TransitionType::RULE:
-    {
-      atn::RuleStartState *ruleStartState = static_cast<atn::RuleStartState*>(transition->target);
-      size_t ruleIndex = ruleStartState->ruleIndex;
-      InterpreterRuleContext *newctx = createInterpreterRuleContext(_ctx, p->stateNumber, ruleIndex);
-      if (ruleStartState->isLeftRecursiveRule) {
-        enterRecursionRule(newctx, ruleStartState->stateNumber, ruleIndex, static_cast<const atn::RuleTransition*>(transition)->precedence);
-      } else {
-        enterRule(newctx, transition->target->stateNumber, ruleIndex);
-      }
-    }
-      break;
-
-    case atn::TransitionType::PREDICATE:
-    {
-      const atn::PredicateTransition *predicateTransition = static_cast<const atn::PredicateTransition*>(transition);
-      if (!sempred(_ctx, predicateTransition->getRuleIndex(), predicateTransition->getPredIndex())) {
-        throw FailedPredicateException(this);
-      }
-    }
-      break;
-
-    case atn::TransitionType::ACTION:
-    {
-      const atn::ActionTransition *actionTransition = static_cast<const atn::ActionTransition*>(transition);
-      action(_ctx, actionTransition->ruleIndex, actionTransition->actionIndex);
-    }
-      break;
-
-    case atn::TransitionType::PRECEDENCE:
-    {
-      if (!precpred(_ctx, static_cast<const atn::PrecedencePredicateTransition*>(transition)->getPrecedence())) {
-        throw FailedPredicateException(this, "precpred(_ctx, " + std::to_string(static_cast<const atn::PrecedencePredicateTransition*>(transition)->getPrecedence()) +  ")");
-      }
-    }
-      break;
-
-    default:
-      throw UnsupportedOperationException("Unrecognized ATN transition type.");
-  }
-
-  setState(transition->target->stateNumber);
-}
-
-size_t ParserInterpreter::visitDecisionState(DecisionState *p) {
-  size_t predictedAlt = 1;
-  if (p->transitions.size() > 1) {
-    getErrorHandler()->sync(this);
-    int decision = p->decision;
-    if (decision == _overrideDecision && _input->index() == _overrideDecisionInputIndex && !_overrideDecisionReached) {
-      predictedAlt = _overrideDecisionAlt;
-      _overrideDecisionReached = true;
-    } else {
-      predictedAlt = getInterpreter<ParserATNSimulator>()->adaptivePredict(_input, decision, _ctx);
-    }
-  }
-  return predictedAlt;
-}
-
-InterpreterRuleContext* ParserInterpreter::createInterpreterRuleContext(ParserRuleContext *parent,
-  size_t invokingStateNumber, size_t ruleIndex) {
-  return _tracker.createInstance<InterpreterRuleContext>(parent, invokingStateNumber, ruleIndex);
-}
-
-void ParserInterpreter::visitRuleStopState(atn::ATNState *p) {
-  atn::RuleStartState *ruleStartState = _atn.ruleToStartState[p->ruleIndex];
-  if (ruleStartState->isLeftRecursiveRule) {
-    std::pair<ParserRuleContext *, size_t> parentContext = _parentContextStack.top();
-    _parentContextStack.pop();
-
-    unrollRecursionContexts(parentContext.first);
-    setState(parentContext.second);
-  } else {
-    exitRule();
-  }
-
-  const atn::RuleTransition *ruleTransition = static_cast<const atn::RuleTransition*>(_atn.states[getState()]->transitions[0].get());
-  setState(ruleTransition->followState->stateNumber);
-}
-
-void ParserInterpreter::recover(RecognitionException &e) {
-  size_t i = _input->index();
-  getErrorHandler()->recover(this, std::make_exception_ptr(e));
-
-  if (_input->index() == i) {
-    // no input consumed, better add an error node
-    if (is<InputMismatchException *>(&e)) {
-      InputMismatchException &ime = static_cast<InputMismatchException&>(e);
-      Token *tok = e.getOffendingToken();
-      size_t expectedTokenType = ime.getExpectedTokens().getMinElement(); // get any element
-      _errorToken = getTokenFactory()->create({ tok->getTokenSource(), tok->getTokenSource()->getInputStream() },
-        expectedTokenType, tok->getText(), Token::DEFAULT_CHANNEL, INVALID_INDEX, INVALID_INDEX, // invalid start/stop
-        tok->getLine(), tok->getCharPositionInLine());
-      _ctx->addChild(createErrorNode(_errorToken.get()));
-    }
-    else { // NoViableAlt
-      Token *tok = e.getOffendingToken();
-      _errorToken = getTokenFactory()->create({ tok->getTokenSource(), tok->getTokenSource()->getInputStream() },
-        Token::INVALID_TYPE, tok->getText(), Token::DEFAULT_CHANNEL, INVALID_INDEX, INVALID_INDEX, // invalid start/stop
-        tok->getLine(), tok->getCharPositionInLine());
-      _ctx->addChild(createErrorNode(_errorToken.get()));
-    }
-  }
-}
-
-Token* ParserInterpreter::recoverInline() {
-  return _errHandler->recoverInline(this);
-}