java类org.antlr.v4.runtime.atn.ATNState的实例源码

public static int getQidDecision(@NonNull ATN atn) {
    ATNState decisionState = atn.ruleToStartState[GoParser.RULE_qualifiedIdentifier].transition(0).target;
    if (decisionState instanceof DecisionState) {
        return ((DecisionState)decisionState).decision;
    } else {
        return -1;
    }
}

@Override
public ATNState getReachableTarget(ATNConfig source, Transition trans, int ttype) {
    if (trans instanceof RuleTransition) {
        IntervalSet suppressed = getSuppressedSet(startIndex);
        if (suppressed.contains(((RuleTransition)trans).ruleIndex)) {
            return null;
        }
    }

    return super.getReachableTarget(source, trans, ttype);
}

public ParserInterpreter(String grammarFileName, Collection<String> tokenNames,
                         Collection<String> ruleNames, ATN atn, TokenStream input)
{
    super(input);
    this.grammarFileName = grammarFileName;
    this.atn = atn;
    this.tokenNames = tokenNames.toArray(new String[tokenNames.size()]);
    this.ruleNames = ruleNames.toArray(new String[ruleNames.size()]);
    this.decisionToDFA = new DFA[atn.getNumberOfDecisions()];
    for (int i = 0; i < decisionToDFA.length; i++) {
        decisionToDFA[i] = new DFA(atn.getDecisionState(i), i);
    }

    // identify the ATN states where pushNewRecursionContext must be called
    this.pushRecursionContextStates = new BitSet(atn.states.size());
    for (ATNState state : atn.states) {
        if (!(state instanceof StarLoopEntryState)) {
            continue;
        }

        if (((StarLoopEntryState)state).precedenceRuleDecision) {
            this.pushRecursionContextStates.set(state.stateNumber);
        }
    }

    // get atn simulator that knows how to do predictions
    setInterpreter(new ParserATNSimulator(this, atn,
                                          decisionToDFA,
                                          sharedContextCache));
}

protected void visitRuleStopState(ATNState p) {
    RuleStartState ruleStartState = atn.ruleToStartState[p.ruleIndex];
    if (ruleStartState.isPrecedenceRule) {
        Pair<ParserRuleContext, Integer> parentContext = _parentContextStack.pop();
        unrollRecursionContexts(parentContext.a);
        setState(parentContext.b);
    }
    else {
        exitRule();
    }

    RuleTransition ruleTransition = (RuleTransition)atn.states.get(getState()).transition(0);
    setState(ruleTransition.followState.stateNumber);
}

public void sync(Parser recognizer) throws RecognitionException {
    ATNState s = recognizer.getInterpreter().atn.states.get(recognizer.getState());
    if (!this.inErrorRecoveryMode(recognizer)) {
        TokenStream tokens = recognizer.getInputStream();
        int la = tokens.LA(1);
        if (!recognizer.getATN().nextTokens(s).contains(la) && la != -1) {
            if (!recognizer.isExpectedToken(la)) {
                switch (s.getStateType()) {
                    case 3:
                    case 4:
                    case 5:
                    case 10:
                        throw new RecognitionException(recognizer, tokens, recognizer.getContext());
                    case 9:
                    case 11:
                        //added
                        this.reportUnwantedToken(recognizer);
                        throw new RecognitionException(recognizer, tokens, recognizer.getContext());
                    case 6:
                    case 7:
                    case 8:
                    default:
                }
            }
        }
    }
}

private static Transition createSetTransition(ATNState target, IntervalSet set) {
    if (set.getIntervals().size() == 1) {
        Interval interval = set.getIntervals().get(0);
        if (interval.a == interval.b) {
            return new AtomTransition(target, interval.a);
        } else {
            return new RangeTransition(target, interval.a, interval.b);
        }
    } else {
        return new SetTransition(target, set);
    }
}

private static Transition createSetTransition(ATNState target, IntervalSet set) {
    if (set.getIntervals().size() == 1) {
        Interval interval = set.getIntervals().get(0);
        if (interval.a == interval.b) {
            return new AtomTransition(target, interval.a);
        } else {
            return new RangeTransition(target, interval.a, interval.b);
        }
    } else {
        return new SetTransition(target, set);
    }
}

public String getDOT(ATNState startState) {
    return getDOT(startState, false);
}

public ATNPrinter(Grammar g, ATNState start) {
    this.g = g;
    this.start = start;
}

public void visit(ATNState s) {
    visit_(s, new HashSet<Integer>());
}