forked from jasder/antlr
ATNState::transactions improvements
The transaction field was access with trivial getters and setters which server no real purpose, so I made the vector public and remove all the obsolete accessor functions. This simplifies the API (e.g. use .size() instead of getNumberOfTransitions()). This change required a few other changes in runtime. Additionally, I radically cut down the ATN::toString method to return only what the Java runtime is doing instead of a full dump of the state and it's transitions.
This commit is contained in:
parent
aabf4baf60
commit
9e77edcb34
|
@ -117,8 +117,7 @@ namespace antlr4 {
|
|||
virtual std::string getText(RuleContext *ctx) override;
|
||||
virtual std::string getText(Token *start, Token *stop) override;
|
||||
|
||||
/// <summary>
|
||||
/// Get all tokens from lexer until EOF </summary>
|
||||
/// Get all tokens from lexer until EOF.
|
||||
virtual void fill();
|
||||
|
||||
protected:
|
||||
|
|
|
@ -246,7 +246,7 @@ bool DefaultErrorStrategy::singleTokenInsertion(Parser *recognizer) {
|
|||
// ATN state, then we know we're missing a token; error recovery
|
||||
// is free to conjure up and insert the missing token
|
||||
atn::ATNState *currentState = recognizer->getInterpreter<atn::ATNSimulator>()->atn.states[recognizer->getState()];
|
||||
atn::ATNState *next = currentState->transition(0)->target;
|
||||
atn::ATNState *next = currentState->transitions[0]->target;
|
||||
const atn::ATN &atn = recognizer->getInterpreter<atn::ATNSimulator>()->atn;
|
||||
misc::IntervalSet expectingAtLL2 = atn.nextTokens(next, recognizer->getContext());
|
||||
if (expectingAtLL2.contains(currentSymbolType)) {
|
||||
|
@ -336,7 +336,7 @@ misc::IntervalSet DefaultErrorStrategy::getErrorRecoverySet(Parser *recognizer)
|
|||
while (ctx->invokingState != ATNState::INVALID_STATE_NUMBER) {
|
||||
// compute what follows who invoked us
|
||||
atn::ATNState *invokingState = atn.states[ctx->invokingState];
|
||||
atn::RuleTransition *rt = dynamic_cast<atn::RuleTransition*>(invokingState->transition(0));
|
||||
atn::RuleTransition *rt = dynamic_cast<atn::RuleTransition*>(invokingState->transitions[0]);
|
||||
misc::IntervalSet follow = atn.nextTokens(rt->followState);
|
||||
recoverSet.addAll(follow);
|
||||
|
||||
|
|
|
@ -52,12 +52,11 @@ FailedPredicateException::FailedPredicateException(Parser *recognizer, const std
|
|||
recognizer->getInputStream(), recognizer->getContext(), recognizer->getCurrentToken()) {
|
||||
|
||||
atn::ATNState *s = recognizer->getInterpreter<atn::ATNSimulator>()->atn.states[recognizer->getState()];
|
||||
atn::Transition *transition = s->transition(0);
|
||||
atn::Transition *transition = s->transitions[0];
|
||||
if (is<atn::PredicateTransition*>(transition)) {
|
||||
_ruleIndex = ((atn::PredicateTransition *)transition)->ruleIndex;
|
||||
_predicateIndex = ((atn::PredicateTransition *)transition)->predIndex;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
_ruleIndex = 0;
|
||||
_predicateIndex = 0;
|
||||
}
|
||||
|
|
|
@ -501,7 +501,7 @@ bool Parser::isExpectedToken(size_t symbol) {
|
|||
|
||||
while (ctx && ctx->invokingState != ATNState::INVALID_STATE_NUMBER && following.contains(Token::EPSILON)) {
|
||||
atn::ATNState *invokingState = atn.states[ctx->invokingState];
|
||||
atn::RuleTransition *rt = static_cast<atn::RuleTransition*>(invokingState->transition(0));
|
||||
atn::RuleTransition *rt = static_cast<atn::RuleTransition*>(invokingState->transitions[0]);
|
||||
following = atn.nextTokens(rt->followState);
|
||||
if (following.contains(symbol)) {
|
||||
return true;
|
||||
|
|
|
@ -189,7 +189,7 @@ void ParserInterpreter::visitState(atn::ATNState *p) {
|
|||
predictedAlt = visitDecisionState(dynamic_cast<DecisionState *>(p));
|
||||
}
|
||||
|
||||
atn::Transition *transition = p->transition(predictedAlt - 1);
|
||||
atn::Transition *transition = p->transitions[predictedAlt - 1];
|
||||
switch (transition->getSerializationType()) {
|
||||
case atn::Transition::EPSILON:
|
||||
if (p->getStateType() == ATNState::STAR_LOOP_ENTRY &&
|
||||
|
@ -266,7 +266,7 @@ void ParserInterpreter::visitState(atn::ATNState *p) {
|
|||
|
||||
size_t ParserInterpreter::visitDecisionState(DecisionState *p) {
|
||||
size_t predictedAlt = 1;
|
||||
if (p->getNumberOfTransitions() > 1) {
|
||||
if (p->transitions.size() > 1) {
|
||||
getErrorHandler()->sync(this);
|
||||
int decision = p->decision;
|
||||
if (decision == _overrideDecision && _input->index() == _overrideDecisionInputIndex && !_overrideDecisionReached) {
|
||||
|
@ -296,7 +296,7 @@ void ParserInterpreter::visitRuleStopState(atn::ATNState *p) {
|
|||
exitRule();
|
||||
}
|
||||
|
||||
atn::RuleTransition *ruleTransition = static_cast<atn::RuleTransition*>(_atn.states[getState()]->transition(0));
|
||||
atn::RuleTransition *ruleTransition = static_cast<atn::RuleTransition*>(_atn.states[getState()]->transitions[0]);
|
||||
setState(ruleTransition->followState->stateNumber);
|
||||
}
|
||||
|
||||
|
|
|
@ -63,12 +63,12 @@ void RecognitionException::setOffendingState(size_t offendingState) {
|
|||
|
||||
misc::IntervalSet RecognitionException::getExpectedTokens() const {
|
||||
if (_recognizer) {
|
||||
return _recognizer->getATN().getExpectedTokens(_offendingState, _ctx.get());
|
||||
return _recognizer->getATN().getExpectedTokens(_offendingState, _ctx);
|
||||
}
|
||||
return misc::IntervalSet::EMPTY_SET;
|
||||
}
|
||||
|
||||
Ref<RuleContext> RecognitionException::getCtx() const {
|
||||
RuleContext* RecognitionException::getCtx() const {
|
||||
return _ctx;
|
||||
}
|
||||
|
||||
|
|
|
@ -167,7 +167,7 @@ misc::IntervalSet ATN::getExpectedTokens(size_t stateNumber, RuleContext *contex
|
|||
expected.remove(Token::EPSILON);
|
||||
while (ctx && ctx->invokingState != ATNState::INVALID_STATE_NUMBER && following.contains(Token::EPSILON)) {
|
||||
ATNState *invokingState = states.at(ctx->invokingState);
|
||||
RuleTransition *rt = static_cast<RuleTransition*>(invokingState->transition(0));
|
||||
RuleTransition *rt = static_cast<RuleTransition*>(invokingState->transitions[0]);
|
||||
following = nextTokens(rt->followState);
|
||||
expected.addAll(following);
|
||||
expected.remove(Token::EPSILON);
|
||||
|
|
|
@ -175,7 +175,7 @@ ATN ATNDeserializer::deserialize(const std::vector<uint16_t>& input) {
|
|||
}
|
||||
|
||||
size_t ruleIndex = data[p++];
|
||||
if (ruleIndex == 0xFFFF) { // Max Unicode char limit imposed by ANTLR.
|
||||
if (ruleIndex == 0xFFFF) {
|
||||
ruleIndex = INVALID_INDEX;
|
||||
}
|
||||
|
||||
|
@ -301,8 +301,8 @@ ATN ATNDeserializer::deserialize(const std::vector<uint16_t>& input) {
|
|||
|
||||
// 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->getNumberOfTransitions(); i++) {
|
||||
Transition *t = state->transition(i);
|
||||
for (size_t i = 0; i < state->transitions.size(); i++) {
|
||||
Transition *t = state->transitions[i];
|
||||
if (!is<RuleTransition*>(t)) {
|
||||
continue;
|
||||
}
|
||||
|
@ -339,16 +339,16 @@ ATN ATNDeserializer::deserialize(const std::vector<uint16_t>& input) {
|
|||
|
||||
if (is<PlusLoopbackState*>(state)) {
|
||||
PlusLoopbackState *loopbackState = static_cast<PlusLoopbackState *>(state);
|
||||
for (size_t i = 0; i < loopbackState->getNumberOfTransitions(); i++) {
|
||||
ATNState *target = loopbackState->transition(i)->target;
|
||||
for (size_t i = 0; i < loopbackState->transitions.size(); i++) {
|
||||
ATNState *target = loopbackState->transitions[i]->target;
|
||||
if (is<PlusBlockStartState *>(target)) {
|
||||
(static_cast<PlusBlockStartState *>(target))->loopBackState = loopbackState;
|
||||
}
|
||||
}
|
||||
} else if (is<StarLoopbackState *>(state)) {
|
||||
StarLoopbackState *loopbackState = static_cast<StarLoopbackState *>(state);
|
||||
for (size_t i = 0; i < loopbackState->getNumberOfTransitions(); i++) {
|
||||
ATNState *target = loopbackState->transition(i)->target;
|
||||
for (size_t i = 0; i < loopbackState->transitions.size(); i++) {
|
||||
ATNState *target = loopbackState->transitions[i]->target;
|
||||
if (is<StarLoopEntryState *>(target)) {
|
||||
(static_cast<StarLoopEntryState*>(target))->loopBackState = loopbackState;
|
||||
}
|
||||
|
@ -395,8 +395,8 @@ ATN ATNDeserializer::deserialize(const std::vector<uint16_t>& input) {
|
|||
// serialized action index for action transitions to the new
|
||||
// form, which is the index of a LexerCustomAction
|
||||
for (ATNState *state : atn.states) {
|
||||
for (size_t i = 0; i < state->getNumberOfTransitions(); i++) {
|
||||
Transition *transition = state->transition(i);
|
||||
for (size_t i = 0; i < state->transitions.size(); i++) {
|
||||
Transition *transition = state->transitions[i];
|
||||
if (!is<ActionTransition *>(transition)) {
|
||||
continue;
|
||||
}
|
||||
|
@ -404,7 +404,8 @@ ATN ATNDeserializer::deserialize(const std::vector<uint16_t>& input) {
|
|||
size_t ruleIndex = static_cast<ActionTransition *>(transition)->ruleIndex;
|
||||
size_t actionIndex = static_cast<ActionTransition *>(transition)->actionIndex;
|
||||
Ref<LexerCustomAction> lexerAction = std::make_shared<LexerCustomAction>(ruleIndex, actionIndex);
|
||||
state->setTransition(i, new ActionTransition(transition->target, ruleIndex, atn.lexerActions.size(), false)); /* mem-check freed in ATNState d-tor */
|
||||
state->transitions[i] = new ActionTransition(transition->target, ruleIndex, atn.lexerActions.size(), false); /* mem-check freed in ATNState d-tor */
|
||||
delete transition; // ml: no longer needed since we just replaced it.
|
||||
atn.lexerActions.push_back(lexerAction);
|
||||
}
|
||||
}
|
||||
|
@ -451,12 +452,12 @@ ATN ATNDeserializer::deserialize(const std::vector<uint16_t>& input) {
|
|||
continue;
|
||||
}
|
||||
|
||||
ATNState *maybeLoopEndState = state->transition(state->getNumberOfTransitions() - 1)->target;
|
||||
ATNState *maybeLoopEndState = state->transitions[state->transitions.size() - 1]->target;
|
||||
if (!is<LoopEndState*>(maybeLoopEndState)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (maybeLoopEndState->epsilonOnlyTransitions && is<RuleStopState*>(maybeLoopEndState->transition(0)->target)) {
|
||||
if (maybeLoopEndState->epsilonOnlyTransitions && is<RuleStopState*>(maybeLoopEndState->transitions[0]->target)) {
|
||||
endState = state;
|
||||
break;
|
||||
}
|
||||
|
@ -467,14 +468,14 @@ ATN ATNDeserializer::deserialize(const std::vector<uint16_t>& input) {
|
|||
|
||||
}
|
||||
|
||||
excludeTransition = (static_cast<StarLoopEntryState*>(endState))->loopBackState->transition(0);
|
||||
excludeTransition = (static_cast<StarLoopEntryState*>(endState))->loopBackState->transitions[0];
|
||||
} 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 (Transition *transition : state->getTransitions()) {
|
||||
for (Transition *transition : state->transitions) {
|
||||
if (transition == excludeTransition) {
|
||||
continue;
|
||||
}
|
||||
|
@ -486,8 +487,8 @@ ATN ATNDeserializer::deserialize(const std::vector<uint16_t>& input) {
|
|||
}
|
||||
|
||||
// all transitions leaving the rule start state need to leave blockStart instead
|
||||
while (atn.ruleToStartState[i]->getNumberOfTransitions() > 0) {
|
||||
Transition *transition = atn.ruleToStartState[i]->removeTransition((int)atn.ruleToStartState[i]->getNumberOfTransitions() - 1);
|
||||
while (atn.ruleToStartState[i]->transitions.size() > 0) {
|
||||
Transition *transition = atn.ruleToStartState[i]->removeTransition(atn.ruleToStartState[i]->transitions.size() - 1);
|
||||
bypassStart->addTransition(transition);
|
||||
}
|
||||
|
||||
|
@ -528,9 +529,9 @@ void ATNDeserializer::markPrecedenceDecisions(const ATN &atn) {
|
|||
* precedence rule should continue or complete.
|
||||
*/
|
||||
if (atn.ruleToStartState[state->ruleIndex]->isLeftRecursiveRule) {
|
||||
ATNState *maybeLoopEndState = state->transition(state->getNumberOfTransitions() - 1)->target;
|
||||
ATNState *maybeLoopEndState = state->transitions[state->transitions.size() - 1]->target;
|
||||
if (is<LoopEndState *>(maybeLoopEndState)) {
|
||||
if (maybeLoopEndState->epsilonOnlyTransitions && is<RuleStopState *>(maybeLoopEndState->transition(0)->target)) {
|
||||
if (maybeLoopEndState->epsilonOnlyTransitions && is<RuleStopState *>(maybeLoopEndState->transitions[0]->target)) {
|
||||
static_cast<StarLoopEntryState *>(state)->isPrecedenceDecision = true;
|
||||
}
|
||||
}
|
||||
|
@ -545,7 +546,7 @@ void ATNDeserializer::verifyATN(const ATN &atn) {
|
|||
continue;
|
||||
}
|
||||
|
||||
checkCondition(state->onlyHasEpsilonTransitions() || state->getNumberOfTransitions() <= 1);
|
||||
checkCondition(state->epsilonOnlyTransitions || state->transitions.size() <= 1);
|
||||
|
||||
if (is<PlusBlockStartState *>(state)) {
|
||||
checkCondition((static_cast<PlusBlockStartState *>(state))->loopBackState != nullptr);
|
||||
|
@ -554,13 +555,13 @@ void ATNDeserializer::verifyATN(const ATN &atn) {
|
|||
if (is<StarLoopEntryState *>(state)) {
|
||||
StarLoopEntryState *starLoopEntryState = static_cast<StarLoopEntryState*>(state);
|
||||
checkCondition(starLoopEntryState->loopBackState != nullptr);
|
||||
checkCondition(starLoopEntryState->getNumberOfTransitions() == 2);
|
||||
checkCondition(starLoopEntryState->transitions.size() == 2);
|
||||
|
||||
if (is<StarBlockStartState *>(starLoopEntryState->transition(0)->target)) {
|
||||
checkCondition(static_cast<LoopEndState *>(starLoopEntryState->transition(1)->target) != nullptr);
|
||||
if (is<StarBlockStartState *>(starLoopEntryState->transitions[0]->target)) {
|
||||
checkCondition(static_cast<LoopEndState *>(starLoopEntryState->transitions[1]->target) != nullptr);
|
||||
checkCondition(!starLoopEntryState->nonGreedy);
|
||||
} else if (is<LoopEndState *>(starLoopEntryState->transition(0)->target)) {
|
||||
checkCondition(is<StarBlockStartState *>(starLoopEntryState->transition(1)->target));
|
||||
} else if (is<LoopEndState *>(starLoopEntryState->transitions[0]->target)) {
|
||||
checkCondition(is<StarBlockStartState *>(starLoopEntryState->transitions[1]->target));
|
||||
checkCondition(starLoopEntryState->nonGreedy);
|
||||
} else {
|
||||
throw IllegalStateException();
|
||||
|
@ -569,8 +570,8 @@ void ATNDeserializer::verifyATN(const ATN &atn) {
|
|||
}
|
||||
|
||||
if (is<StarLoopbackState *>(state)) {
|
||||
checkCondition(state->getNumberOfTransitions() == 1);
|
||||
checkCondition(is<StarLoopEntryState *>(state->transition(0)->target));
|
||||
checkCondition(state->transitions.size() == 1);
|
||||
checkCondition(is<StarLoopEntryState *>(state->transitions[0]->target));
|
||||
}
|
||||
|
||||
if (is<LoopEndState *>(state)) {
|
||||
|
@ -591,9 +592,9 @@ void ATNDeserializer::verifyATN(const ATN &atn) {
|
|||
|
||||
if (is<DecisionState *>(state)) {
|
||||
DecisionState *decisionState = static_cast<DecisionState *>(state);
|
||||
checkCondition(decisionState->getNumberOfTransitions() <= 1 || decisionState->decision >= 0);
|
||||
checkCondition(decisionState->transitions.size() <= 1 || decisionState->decision >= 0);
|
||||
} else {
|
||||
checkCondition(state->getNumberOfTransitions() <= 1 || is<RuleStopState *>(state));
|
||||
checkCondition(state->transitions.size() <= 1 || is<RuleStopState *>(state));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -127,11 +127,11 @@ std::vector<size_t> ATNSerializer::serialize() {
|
|||
if (s->getStateType() != ATNState::RULE_STOP) {
|
||||
// the deserializer can trivially derive these edges, so there's no need
|
||||
// to serialize them
|
||||
nedges += s->getNumberOfTransitions();
|
||||
nedges += s->transitions.size();
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < s->getNumberOfTransitions(); i++) {
|
||||
Transition *t = s->transition(i);
|
||||
for (size_t i = 0; i < s->transitions.size(); i++) {
|
||||
Transition *t = s->transitions[i];
|
||||
Transition::SerializationType edgeType = t->getSerializationType();
|
||||
if (edgeType == Transition::SET || edgeType == Transition::NOT_SET) {
|
||||
SetTransition *st = static_cast<SetTransition *>(t);
|
||||
|
@ -217,8 +217,8 @@ std::vector<size_t> ATNSerializer::serialize() {
|
|||
continue;
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < s->getNumberOfTransitions(); i++) {
|
||||
Transition *t = s->transition(i);
|
||||
for (size_t i = 0; i < s->transitions.size(); i++) {
|
||||
Transition *t = s->transitions[i];
|
||||
|
||||
if (atn->states[t->target->stateNumber] == nullptr) {
|
||||
throw IllegalStateException("Cannot serialize a transition to a removed state.");
|
||||
|
|
|
@ -67,34 +67,11 @@ bool ATNState::isNonGreedyExitState() {
|
|||
}
|
||||
|
||||
std::string ATNState::toString() const {
|
||||
std::stringstream ss;
|
||||
ss << "(ATNState " << std::hex << this << std::dec << ") {" << std::endl;
|
||||
if (stateNumber == INVALID_STATE_NUMBER || stateNumber >= serializationNames.size())
|
||||
ss << " state: INVALID ";
|
||||
else
|
||||
ss << " state: " << serializationNames[stateNumber];
|
||||
ss << " (" << stateNumber << ")" << std::endl;
|
||||
ss << " ruleIndex: " << ruleIndex << std::endl << " epsilonOnlyTransitions: " << epsilonOnlyTransitions << std::endl;
|
||||
ss << " transistions (" << transitions.size() << "):" << std::endl;
|
||||
|
||||
for (auto transition : transitions) {
|
||||
ss << indent(transition->toString(), " ") << std::endl;
|
||||
}
|
||||
ss << "}";
|
||||
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
std::vector<Transition*> ATNState::getTransitions() {
|
||||
return transitions;
|
||||
}
|
||||
|
||||
size_t ATNState::getNumberOfTransitions() {
|
||||
return transitions.size();
|
||||
return std::to_string(stateNumber);
|
||||
}
|
||||
|
||||
void ATNState::addTransition(Transition *e) {
|
||||
addTransition((int)transitions.size(), e);
|
||||
addTransition(transitions.size(), e);
|
||||
}
|
||||
|
||||
void ATNState::addTransition(size_t index, Transition *e) {
|
||||
|
@ -108,23 +85,7 @@ void ATNState::addTransition(size_t index, Transition *e) {
|
|||
transitions.insert(transitions.begin() + index, e);
|
||||
}
|
||||
|
||||
Transition *ATNState::transition(size_t i) {
|
||||
return transitions[i];
|
||||
}
|
||||
|
||||
void ATNState::setTransition(size_t i, Transition *e) {
|
||||
transitions[i] = e;
|
||||
}
|
||||
|
||||
Transition *ATNState::removeTransition(size_t index) {
|
||||
transitions.erase(transitions.begin() + index);
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
bool ATNState::onlyHasEpsilonTransitions() {
|
||||
return epsilonOnlyTransitions;
|
||||
}
|
||||
|
||||
void ATNState::setRuleIndex(size_t index) {
|
||||
ruleIndex = index;
|
||||
}
|
||||
|
|
|
@ -128,10 +128,6 @@ namespace atn {
|
|||
size_t ruleIndex = 0; // at runtime, we don't have Rule objects
|
||||
bool epsilonOnlyTransitions = false;
|
||||
|
||||
protected:
|
||||
/// Track the transitions emanating from this ATN state.
|
||||
std::vector<Transition*> transitions;
|
||||
|
||||
public:
|
||||
/// Used to cache lookahead during parsing, not used during construction.
|
||||
misc::IntervalSet nextTokenWithinRule;
|
||||
|
@ -139,19 +135,15 @@ namespace atn {
|
|||
virtual size_t hashCode();
|
||||
bool operator == (const ATNState &other);
|
||||
|
||||
/// Track the transitions emanating from this ATN state.
|
||||
std::vector<Transition*> transitions;
|
||||
|
||||
virtual bool isNonGreedyExitState();
|
||||
virtual std::string toString() const;
|
||||
virtual std::vector<Transition*> getTransitions();
|
||||
virtual size_t getNumberOfTransitions();
|
||||
virtual void addTransition(Transition *e);
|
||||
virtual void addTransition(size_t index, Transition *e);
|
||||
virtual Transition *transition(size_t i);
|
||||
virtual void setTransition(size_t i, Transition *e);
|
||||
virtual Transition* removeTransition(size_t index);
|
||||
virtual int getStateType() = 0;
|
||||
bool onlyHasEpsilonTransitions();
|
||||
virtual void setRuleIndex(size_t index);
|
||||
|
||||
};
|
||||
|
||||
} // namespace atn
|
||||
|
|
|
@ -58,13 +58,13 @@ std::vector<misc::IntervalSet> LL1Analyzer::getDecisionLookahead(ATNState *s) co
|
|||
return look;
|
||||
}
|
||||
|
||||
look.resize(s->getNumberOfTransitions()); // Fills all interval sets with defaults.
|
||||
for (size_t alt = 0; alt < s->getNumberOfTransitions(); alt++) {
|
||||
look.resize(s->transitions.size()); // Fills all interval sets with defaults.
|
||||
for (size_t alt = 0; alt < s->transitions.size(); alt++) {
|
||||
bool seeThruPreds = false; // fail to get lookahead upon pred
|
||||
|
||||
ATNConfig::Set lookBusy;
|
||||
antlrcpp::BitSet callRuleStack;
|
||||
_LOOK(s->transition(alt)->target, nullptr, PredictionContext::EMPTY,
|
||||
_LOOK(s->transitions[alt]->target, nullptr, PredictionContext::EMPTY,
|
||||
look[alt], lookBusy, callRuleStack, seeThruPreds, false);
|
||||
|
||||
// Wipe out lookahead for this alternative if we found nothing
|
||||
|
@ -140,9 +140,9 @@ void LL1Analyzer::_LOOK(ATNState *s, ATNState *stopState, Ref<PredictionContext>
|
|||
}
|
||||
}
|
||||
|
||||
size_t n = s->getNumberOfTransitions();
|
||||
size_t n = s->transitions.size();
|
||||
for (size_t i = 0; i < n; i++) {
|
||||
Transition *t = s->transition(i);
|
||||
Transition *t = s->transitions[i];
|
||||
|
||||
if (is<RuleTransition *>(t)) {
|
||||
if (calledRuleStack[(static_cast<RuleTransition*>(t))->target->ruleIndex]) {
|
||||
|
|
|
@ -272,9 +272,9 @@ void LexerATNSimulator::getReachableConfigSet(CharStream *input, ATNConfigSet *c
|
|||
std::cout << "testing " << getTokenName((int)t) << " at " << c->toString(true) << std::endl;
|
||||
#endif
|
||||
|
||||
size_t n = c->state->getNumberOfTransitions();
|
||||
size_t n = c->state->transitions.size();
|
||||
for (size_t ti = 0; ti < n; ti++) { // for each transition
|
||||
Transition *trans = c->state->transition(ti);
|
||||
Transition *trans = c->state->transitions[ti];
|
||||
ATNState *target = getReachableTarget(trans, (int)t);
|
||||
if (target != nullptr) {
|
||||
Ref<LexerActionExecutor> lexerActionExecutor = std::static_pointer_cast<LexerATNConfig>(c)->getLexerActionExecutor();
|
||||
|
@ -325,8 +325,8 @@ atn::ATNState *LexerATNSimulator::getReachableTarget(Transition *trans, size_t t
|
|||
std::unique_ptr<ATNConfigSet> LexerATNSimulator::computeStartState(CharStream *input, ATNState *p) {
|
||||
Ref<PredictionContext> initialContext = PredictionContext::EMPTY; // ml: the purpose of this assignment is unclear
|
||||
std::unique_ptr<ATNConfigSet> configs(new OrderedATNConfigSet());
|
||||
for (size_t i = 0; i < p->getNumberOfTransitions(); i++) {
|
||||
ATNState *target = p->transition(i)->target;
|
||||
for (size_t i = 0; i < p->transitions.size(); i++) {
|
||||
ATNState *target = p->transitions[i]->target;
|
||||
Ref<LexerATNConfig> c = std::make_shared<LexerATNConfig>(target, (int)(i + 1), initialContext);
|
||||
closure(input, c, configs.get(), false, false, false);
|
||||
}
|
||||
|
@ -374,15 +374,15 @@ bool LexerATNSimulator::closure(CharStream *input, const Ref<LexerATNConfig> &co
|
|||
}
|
||||
|
||||
// optimization
|
||||
if (!config->state->onlyHasEpsilonTransitions()) {
|
||||
if (!config->state->epsilonOnlyTransitions) {
|
||||
if (!currentAltReachedAcceptState || !config->hasPassedThroughNonGreedyDecision()) {
|
||||
configs->add(config);
|
||||
}
|
||||
}
|
||||
|
||||
ATNState *p = config->state;
|
||||
for (size_t i = 0; i < p->getNumberOfTransitions(); i++) {
|
||||
Transition *t = p->transition(i);
|
||||
for (size_t i = 0; i < p->transitions.size(); i++) {
|
||||
Transition *t = p->transitions[i];
|
||||
Ref<LexerATNConfig> c = getEpsilonTarget(input, config, t, configs, speculative, treatEofAsEpsilon);
|
||||
if (c != nullptr) {
|
||||
currentAltReachedAcceptState = closure(input, c, configs, currentAltReachedAcceptState, speculative, treatEofAsEpsilon);
|
||||
|
|
|
@ -323,7 +323,7 @@ dfa::DFAState *ParserATNSimulator::computeTargetState(dfa::DFA &dfa, dfa::DFASta
|
|||
void ParserATNSimulator::predicateDFAState(dfa::DFAState *dfaState, DecisionState *decisionState) {
|
||||
// We need to test all predicates, even in DFA states that
|
||||
// uniquely predict alternative.
|
||||
size_t nalts = decisionState->getNumberOfTransitions();
|
||||
size_t nalts = decisionState->transitions.size();
|
||||
|
||||
// Update DFA so reach becomes accept state with (predicate,alt)
|
||||
// pairs if preds found for conflicting alts
|
||||
|
@ -476,9 +476,9 @@ std::unique_ptr<ATNConfigSet> ParserATNSimulator::computeReachSet(ATNConfigSet *
|
|||
continue;
|
||||
}
|
||||
|
||||
size_t n = c->state->getNumberOfTransitions();
|
||||
size_t n = c->state->transitions.size();
|
||||
for (size_t ti = 0; ti < n; ti++) { // for each transition
|
||||
Transition *trans = c->state->transition(ti);
|
||||
Transition *trans = c->state->transitions[ti];
|
||||
ATNState *target = getReachableTarget(trans, (int)t);
|
||||
if (target != nullptr) {
|
||||
intermediate->add(std::make_shared<ATNConfig>(c, target), &mergeCache);
|
||||
|
@ -584,7 +584,7 @@ ATNConfigSet* ParserATNSimulator::removeAllConfigsNotInRuleStopState(ATNConfigSe
|
|||
continue;
|
||||
}
|
||||
|
||||
if (lookToEndOfRule && config->state->onlyHasEpsilonTransitions()) {
|
||||
if (lookToEndOfRule && config->state->epsilonOnlyTransitions) {
|
||||
misc::IntervalSet nextTokens = atn.nextTokens(config->state);
|
||||
if (nextTokens.contains(Token::EPSILON)) {
|
||||
ATNState *endOfRuleState = atn.ruleToStopState[config->state->ruleIndex];
|
||||
|
@ -601,8 +601,8 @@ std::unique_ptr<ATNConfigSet> ParserATNSimulator::computeStartState(ATNState *p,
|
|||
Ref<PredictionContext> initialContext = PredictionContext::fromRuleContext(atn, ctx);
|
||||
std::unique_ptr<ATNConfigSet> configs(new ATNConfigSet(fullCtx));
|
||||
|
||||
for (size_t i = 0; i < p->getNumberOfTransitions(); i++) {
|
||||
ATNState *target = p->transition(i)->target;
|
||||
for (size_t i = 0; i < p->transitions.size(); i++) {
|
||||
ATNState *target = p->transitions[i]->target;
|
||||
Ref<ATNConfig> c = std::make_shared<ATNConfig>(target, (int)i + 1, initialContext);
|
||||
ATNConfig::Set closureBusy;
|
||||
closure(c, configs.get(), closureBusy, true, fullCtx, false);
|
||||
|
@ -892,14 +892,14 @@ void ParserATNSimulator::closure_(Ref<ATNConfig> const& config, ATNConfigSet *co
|
|||
bool collectPredicates, bool fullCtx, int depth, bool treatEofAsEpsilon) {
|
||||
ATNState *p = config->state;
|
||||
// optimization
|
||||
if (!p->onlyHasEpsilonTransitions()) {
|
||||
if (!p->epsilonOnlyTransitions) {
|
||||
// make sure to not return here, because EOF transitions can act as
|
||||
// both epsilon transitions and non-epsilon transitions.
|
||||
configs->add(config, &mergeCache);
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < p->getNumberOfTransitions(); i++) {
|
||||
Transition *t = p->transition(i);
|
||||
for (size_t i = 0; i < p->transitions.size(); i++) {
|
||||
Transition *t = p->transitions[i];
|
||||
bool continueCollecting = !is<ActionTransition*>(t) && collectPredicates;
|
||||
Ref<ATNConfig> c = getEpsilonTarget(config, t, continueCollecting, depth == 0, fullCtx, treatEofAsEpsilon);
|
||||
if (c != nullptr) {
|
||||
|
@ -1133,8 +1133,8 @@ void ParserATNSimulator::dumpDeadEndConfigs(NoViableAltException &nvae) {
|
|||
std::cerr << "dead end configs: ";
|
||||
for (auto c : nvae.getDeadEndConfigs()->configs) {
|
||||
std::string trans = "no edges";
|
||||
if (c->state->getNumberOfTransitions() > 0) {
|
||||
Transition *t = c->state->transition(0);
|
||||
if (c->state->transitions.size() > 0) {
|
||||
Transition *t = c->state->transitions[0];
|
||||
if (is<AtomTransition*>(t)) {
|
||||
AtomTransition *at = static_cast<AtomTransition*>(t);
|
||||
trans = "Atom " + getTokenName(at->_label);
|
||||
|
|
|
@ -70,7 +70,7 @@ Ref<PredictionContext> PredictionContext::fromRuleContext(const ATN &atn, RuleCo
|
|||
Ref<PredictionContext> parent = PredictionContext::fromRuleContext(atn, dynamic_cast<RuleContext *>(outerContext->parent));
|
||||
|
||||
ATNState *state = atn.states.at(outerContext->invokingState);
|
||||
RuleTransition *transition = (RuleTransition *)state->transition(0);
|
||||
RuleTransition *transition = (RuleTransition *)state->transitions[0];
|
||||
return SingletonPredictionContext::create(parent, transition->followState->stateNumber);
|
||||
}
|
||||
|
||||
|
|
|
@ -37,7 +37,7 @@
|
|||
using namespace antlr4::atn;
|
||||
|
||||
StarLoopEntryState *StarLoopbackState::getLoopEntryState() {
|
||||
return static_cast<StarLoopEntryState*>(transition(0)->target);
|
||||
return static_cast<StarLoopEntryState*>(transitions[0]->target);
|
||||
}
|
||||
|
||||
int StarLoopbackState::getStateType() {
|
||||
|
|
|
@ -131,8 +131,7 @@ namespace misc {
|
|||
/// return true if this set has no members
|
||||
virtual bool isEmpty() const;
|
||||
|
||||
/// <summary>
|
||||
/// If this set is a single integer, return it otherwise Token.INVALID_TYPE </summary>
|
||||
/// If this set is a single integer, return it otherwise Token.INVALID_TYPE.
|
||||
virtual ssize_t getSingleElement() const;
|
||||
|
||||
/**
|
||||
|
|
Loading…
Reference in New Issue