forked from NUDT-compiler/nudt-compiler-cpp
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
295 lines
10 KiB
295 lines
10 KiB
/* 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);
|
|
}
|