gitweb.ps.run Git - toc/blob - antlr4-cpp-runtime-4.9.2-source/runtime/src/ParserInterpreter.cpp

   1 /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
   2  * Use of this file is governed by the BSD 3-clause license that
   3  * can be found in the LICENSE.txt file in the project root.
   4  */
   5
   6 #include "dfa/DFA.h"
   7 #include "atn/RuleStartState.h"
   8 #include "InterpreterRuleContext.h"
   9 #include "atn/ParserATNSimulator.h"
  10 #include "ANTLRErrorStrategy.h"
  11 #include "atn/LoopEndState.h"
  12 #include "FailedPredicateException.h"
  13 #include "atn/StarLoopEntryState.h"
  14 #include "atn/AtomTransition.h"
  15 #include "atn/RuleTransition.h"
  16 #include "atn/PredicateTransition.h"
  17 #include "atn/PrecedencePredicateTransition.h"
  18 #include "atn/ActionTransition.h"
  19 #include "atn/ATN.h"
  20 #include "atn/RuleStopState.h"
  21 #include "Lexer.h"
  22 #include "Token.h"
  23 #include "Vocabulary.h"
  24 #include "InputMismatchException.h"
  25 #include "CommonToken.h"
  26 #include "tree/ErrorNode.h"
  27
  28 #include "support/CPPUtils.h"
  29
  30 #include "ParserInterpreter.h"
  31
  32 using namespace antlr4;
  33 using namespace antlr4::atn;
  34 using namespace antlr4::misc;
  35
  36 using namespace antlrcpp;
  37
  38 ParserInterpreter::ParserInterpreter(const std::string &grammarFileName, const std::vector<std::string>& tokenNames,
  39   const std::vector<std::string>& ruleNames, const atn::ATN &atn, TokenStream *input)
  40   : ParserInterpreter(grammarFileName, dfa::Vocabulary::fromTokenNames(tokenNames), ruleNames, atn, input) {
  41 }
  42
  43 ParserInterpreter::ParserInterpreter(const std::string &grammarFileName, const dfa::Vocabulary &vocabulary,
  44   const std::vector<std::string> &ruleNames, const atn::ATN &atn, TokenStream *input)
  45   : Parser(input), _grammarFileName(grammarFileName), _atn(atn), _ruleNames(ruleNames), _vocabulary(vocabulary) {
  46
  47   for (size_t i = 0; i < atn.maxTokenType; ++i) {
  48     _tokenNames.push_back(vocabulary.getDisplayName(i));
  49   }
  50
  51   // init decision DFA
  52   for (size_t i = 0; i < atn.getNumberOfDecisions(); ++i) {
  53     atn::DecisionState *decisionState = atn.getDecisionState(i);
  54     _decisionToDFA.push_back(dfa::DFA(decisionState, i));
  55   }
  56
  57   // get atn simulator that knows how to do predictions
  58   _interpreter = new atn::ParserATNSimulator(this, atn, _decisionToDFA, _sharedContextCache); /* mem-check: deleted in d-tor */
  59 }
  60
  61 ParserInterpreter::~ParserInterpreter() {
  62   delete _interpreter;
  63 }
  64
  65 void ParserInterpreter::reset() {
  66   Parser::reset();
  67   _overrideDecisionReached = false;
  68   _overrideDecisionRoot = nullptr;
  69 }
  70
  71 const atn::ATN& ParserInterpreter::getATN() const {
  72   return _atn;
  73 }
  74
  75 const std::vector<std::string>& ParserInterpreter::getTokenNames() const {
  76   return _tokenNames;
  77 }
  78
  79 const dfa::Vocabulary& ParserInterpreter::getVocabulary() const {
  80   return _vocabulary;
  81 }
  82
  83 const std::vector<std::string>& ParserInterpreter::getRuleNames() const {
  84   return _ruleNames;
  85 }
  86
  87 std::string ParserInterpreter::getGrammarFileName() const {
  88   return _grammarFileName;
  89 }
  90
  91 ParserRuleContext* ParserInterpreter::parse(size_t startRuleIndex) {
  92   atn::RuleStartState *startRuleStartState = _atn.ruleToStartState[startRuleIndex];
  93
  94   _rootContext = createInterpreterRuleContext(nullptr, atn::ATNState::INVALID_STATE_NUMBER, startRuleIndex);
  95
  96   if (startRuleStartState->isLeftRecursiveRule) {
  97     enterRecursionRule(_rootContext, startRuleStartState->stateNumber, startRuleIndex, 0);
  98   } else {
  99     enterRule(_rootContext, startRuleStartState->stateNumber, startRuleIndex);
 100   }
 101
 102   while (true) {
 103     atn::ATNState *p = getATNState();
 104     switch (p->getStateType()) {
 105       case atn::ATNState::RULE_STOP :
 106         // pop; return from rule
 107         if (_ctx->isEmpty()) {
 108           if (startRuleStartState->isLeftRecursiveRule) {
 109             ParserRuleContext *result = _ctx;
 110             auto parentContext = _parentContextStack.top();
 111             _parentContextStack.pop();
 112             unrollRecursionContexts(parentContext.first);
 113             return result;
 114           } else {
 115             exitRule();
 116             return _rootContext;
 117           }
 118         }
 119
 120         visitRuleStopState(p);
 121         break;
 122
 123       default :
 124         try {
 125           visitState(p);
 126         }
 127         catch (RecognitionException &e) {
 128           setState(_atn.ruleToStopState[p->ruleIndex]->stateNumber);
 129           getErrorHandler()->reportError(this, e);
 130           getContext()->exception = std::current_exception();
 131           recover(e);
 132         }
 133
 134         break;
 135     }
 136   }
 137 }
 138
 139 void ParserInterpreter::enterRecursionRule(ParserRuleContext *localctx, size_t state, size_t ruleIndex, int precedence) {
 140   _parentContextStack.push({ _ctx, localctx->invokingState });
 141   Parser::enterRecursionRule(localctx, state, ruleIndex, precedence);
 142 }
 143
 144 void ParserInterpreter::addDecisionOverride(int decision, int tokenIndex, int forcedAlt) {
 145   _overrideDecision = decision;
 146   _overrideDecisionInputIndex = tokenIndex;
 147   _overrideDecisionAlt = forcedAlt;
 148 }
 149
 150 Ref<InterpreterRuleContext> ParserInterpreter::getOverrideDecisionRoot() const {
 151   return _overrideDecisionRoot;
 152 }
 153
 154 InterpreterRuleContext* ParserInterpreter::getRootContext() {
 155   return _rootContext;
 156 }
 157
 158 atn::ATNState* ParserInterpreter::getATNState() {
 159   return _atn.states[getState()];
 160 }
 161
 162 void ParserInterpreter::visitState(atn::ATNState *p) {
 163   size_t predictedAlt = 1;
 164   if (is<DecisionState *>(p)) {
 165     predictedAlt = visitDecisionState(dynamic_cast<DecisionState *>(p));
 166   }
 167
 168   atn::Transition *transition = p->transitions[predictedAlt - 1];
 169   switch (transition->getSerializationType()) {
 170     case atn::Transition::EPSILON:
 171       if (p->getStateType() == ATNState::STAR_LOOP_ENTRY &&
 172         (dynamic_cast<StarLoopEntryState *>(p))->isPrecedenceDecision &&
 173         !is<LoopEndState *>(transition->target)) {
 174         // We are at the start of a left recursive rule's (...)* loop
 175         // and we're not taking the exit branch of loop.
 176         InterpreterRuleContext *localctx = createInterpreterRuleContext(_parentContextStack.top().first,
 177           _parentContextStack.top().second, static_cast<int>(_ctx->getRuleIndex()));
 178         pushNewRecursionContext(localctx, _atn.ruleToStartState[p->ruleIndex]->stateNumber, static_cast<int>(_ctx->getRuleIndex()));
 179       }
 180       break;
 181
 182     case atn::Transition::ATOM:
 183       match(static_cast<int>(static_cast<atn::AtomTransition*>(transition)->_label));
 184       break;
 185
 186     case atn::Transition::RANGE:
 187     case atn::Transition::SET:
 188     case atn::Transition::NOT_SET:
 189       if (!transition->matches(static_cast<int>(_input->LA(1)), Token::MIN_USER_TOKEN_TYPE, Lexer::MAX_CHAR_VALUE)) {
 190         recoverInline();
 191       }
 192       matchWildcard();
 193       break;
 194
 195     case atn::Transition::WILDCARD:
 196       matchWildcard();
 197       break;
 198
 199     case atn::Transition::RULE:
 200     {
 201       atn::RuleStartState *ruleStartState = static_cast<atn::RuleStartState*>(transition->target);
 202       size_t ruleIndex = ruleStartState->ruleIndex;
 203       InterpreterRuleContext *newctx = createInterpreterRuleContext(_ctx, p->stateNumber, ruleIndex);
 204       if (ruleStartState->isLeftRecursiveRule) {
 205         enterRecursionRule(newctx, ruleStartState->stateNumber, ruleIndex, static_cast<atn::RuleTransition*>(transition)->precedence);
 206       } else {
 207         enterRule(newctx, transition->target->stateNumber, ruleIndex);
 208       }
 209     }
 210       break;
 211
 212     case atn::Transition::PREDICATE:
 213     {
 214       atn::PredicateTransition *predicateTransition = static_cast<atn::PredicateTransition*>(transition);
 215       if (!sempred(_ctx, predicateTransition->ruleIndex, predicateTransition->predIndex)) {
 216         throw FailedPredicateException(this);
 217       }
 218     }
 219       break;
 220
 221     case atn::Transition::ACTION:
 222     {
 223       atn::ActionTransition *actionTransition = static_cast<atn::ActionTransition*>(transition);
 224       action(_ctx, actionTransition->ruleIndex, actionTransition->actionIndex);
 225     }
 226       break;
 227
 228     case atn::Transition::PRECEDENCE:
 229     {
 230       if (!precpred(_ctx, static_cast<atn::PrecedencePredicateTransition*>(transition)->precedence)) {
 231         throw FailedPredicateException(this, "precpred(_ctx, " + std::to_string(static_cast<atn::PrecedencePredicateTransition*>(transition)->precedence) +  ")");
 232       }
 233     }
 234       break;
 235
 236     default:
 237       throw UnsupportedOperationException("Unrecognized ATN transition type.");
 238   }
 239
 240   setState(transition->target->stateNumber);
 241 }
 242
 243 size_t ParserInterpreter::visitDecisionState(DecisionState *p) {
 244   size_t predictedAlt = 1;
 245   if (p->transitions.size() > 1) {
 246     getErrorHandler()->sync(this);
 247     int decision = p->decision;
 248     if (decision == _overrideDecision && _input->index() == _overrideDecisionInputIndex && !_overrideDecisionReached) {
 249       predictedAlt = _overrideDecisionAlt;
 250       _overrideDecisionReached = true;
 251     } else {
 252       predictedAlt = getInterpreter<ParserATNSimulator>()->adaptivePredict(_input, decision, _ctx);
 253     }
 254   }
 255   return predictedAlt;
 256 }
 257
 258 InterpreterRuleContext* ParserInterpreter::createInterpreterRuleContext(ParserRuleContext *parent,
 259   size_t invokingStateNumber, size_t ruleIndex) {
 260   return _tracker.createInstance<InterpreterRuleContext>(parent, invokingStateNumber, ruleIndex);
 261 }
 262
 263 void ParserInterpreter::visitRuleStopState(atn::ATNState *p) {
 264   atn::RuleStartState *ruleStartState = _atn.ruleToStartState[p->ruleIndex];
 265   if (ruleStartState->isLeftRecursiveRule) {
 266     std::pair<ParserRuleContext *, size_t> parentContext = _parentContextStack.top();
 267     _parentContextStack.pop();
 268
 269     unrollRecursionContexts(parentContext.first);
 270     setState(parentContext.second);
 271   } else {
 272     exitRule();
 273   }
 274
 275   atn::RuleTransition *ruleTransition = static_cast<atn::RuleTransition*>(_atn.states[getState()]->transitions[0]);
 276   setState(ruleTransition->followState->stateNumber);
 277 }
 278
 279 void ParserInterpreter::recover(RecognitionException &e) {
 280   size_t i = _input->index();
 281   getErrorHandler()->recover(this, std::make_exception_ptr(e));
 282
 283   if (_input->index() == i) {
 284     // no input consumed, better add an error node
 285     if (is<InputMismatchException *>(&e)) {
 286       InputMismatchException &ime = static_cast<InputMismatchException&>(e);
 287       Token *tok = e.getOffendingToken();
 288       size_t expectedTokenType = ime.getExpectedTokens().getMinElement(); // get any element
 289       _errorToken = getTokenFactory()->create({ tok->getTokenSource(), tok->getTokenSource()->getInputStream() },
 290         expectedTokenType, tok->getText(), Token::DEFAULT_CHANNEL, INVALID_INDEX, INVALID_INDEX, // invalid start/stop
 291         tok->getLine(), tok->getCharPositionInLine());
 292       _ctx->addChild(createErrorNode(_errorToken.get()));
 293     }
 294     else { // NoViableAlt
 295       Token *tok = e.getOffendingToken();
 296       _errorToken = getTokenFactory()->create({ tok->getTokenSource(), tok->getTokenSource()->getInputStream() },
 297         Token::INVALID_TYPE, tok->getText(), Token::DEFAULT_CHANNEL, INVALID_INDEX, INVALID_INDEX, // invalid start/stop
 298         tok->getLine(), tok->getCharPositionInLine());
 299       _ctx->addChild(createErrorNode(_errorToken.get()));
 300     }
 301   }
 302 }
 303
 304 Token* ParserInterpreter::recoverInline() {
 305   return _errHandler->recoverInline(this);
 306 }