public DFA(DecisionState atnStartState, int decision) { this.atnStartState = atnStartState; this.decision = decision; boolean precedenceDfa = false; if (atnStartState instanceof StarLoopEntryState) { if (((StarLoopEntryState)atnStartState).isPrecedenceDecision) { precedenceDfa = true; DFAState precedenceState = new DFAState(new ATNConfigSet()); precedenceState.edges = new DFAState[0]; precedenceState.isAcceptState = false; precedenceState.requiresFullContext = false; this.s0 = precedenceState; } } this.precedenceDfa = precedenceDfa; }
public boolean isEmpty() { if (isPrecedenceDfa()) { return s0.get().getEdgeMap().isEmpty() && s0full.get().getEdgeMap().isEmpty(); } return s0.get() == null && s0full.get() == null; }
String getStateString(DFAState s) { if (s == ATNSimulator.ERROR) { return "ERROR"; } int n = s.stateNumber; String stateStr = "s"+n; if ( s.isAcceptState() ) { if ( s.predicates!=null ) { stateStr = ":s"+n+"=>"+Arrays.toString(s.predicates); } else { stateStr = ":s"+n+"=>"+s.getPrediction(); } } if ( s.isContextSensitive() ) { stateStr += "*"; for (ATNConfig config : s.configs) { if (config.getReachesIntoOuterContext()) { stateStr += "*"; break; } } } return stateStr; } }
@Override public String toString() { StringBuilder buf = new StringBuilder(); buf.append(stateNumber).append(":").append(configs); if ( isAcceptState() ) { buf.append("=>"); if ( predicates!=null ) { buf.append(Arrays.toString(predicates)); } else { buf.append(getPrediction()); } } return buf.toString(); } }
Set<Integer> alts = s.getAltSet(); if ( alts!=null ) { buf.append("\\n");
/** Add a new DFA state if there isn't one with this set of configurations already. This method also detects the first configuration containing an ATN rule stop state. Later, when traversing the DFA, we will know which rule to accept. */ @NotNull protected DFAState addDFAState(@NotNull ATNConfigSet configs) { /* the lexer evaluates predicates on-the-fly; by this point configs * should not contain any configurations with unevaluated predicates. */ assert !configs.hasSemanticContext(); DFAState proposed = new DFAState(atn.modeToDFA[mode], configs); DFAState existing = atn.modeToDFA[mode].states.get(proposed); if ( existing!=null ) return existing; configs.optimizeConfigs(this); DFAState newState = new DFAState(atn.modeToDFA[mode], configs.clone(true)); ATNConfig firstConfigWithRuleStopState = null; for (ATNConfig c : configs) { if ( c.getState() instanceof RuleStopState ) { firstConfigWithRuleStopState = c; break; } } if ( firstConfigWithRuleStopState!=null ) { int prediction = atn.ruleToTokenType[firstConfigWithRuleStopState.getState().ruleIndex]; LexerActionExecutor lexerActionExecutor = firstConfigWithRuleStopState.getLexerActionExecutor(); newState.setAcceptState(new AcceptStateInfo(prediction, lexerActionExecutor)); } return atn.modeToDFA[mode].addState(newState); }
Map<Integer, DFAState> edges = s.getEdgeMap(); Map<Integer, DFAState> contextEdges = s.getContextEdgeMap(); for (Map.Entry<Integer, DFAState> entry : edges.entrySet()) { if ((entry.getValue() == null || entry.getValue() == ATNSimulator.ERROR) && !s.isContextSymbol(entry.getKey())) { continue; if (s.isContextSymbol(entry.getKey())) { buf.append("!"); contextSymbol = true; if (s.isContextSensitive()) { for (Map.Entry<Integer, DFAState> entry : contextEdges.entrySet()) { buf.append(getStateString(s))
if ( !d.isAcceptState() ) continue; ST st = stlib.getInstanceOf("stopstate"); st.add("name", "s"+d.stateNumber); if ( d.isAcceptState() ) continue; if ( d.stateNumber == Integer.MAX_VALUE ) continue; ST st = stlib.getInstanceOf("state"); Map<Integer, DFAState> edges = d.getEdgeMap(); for (Map.Entry<Integer, DFAState> entry : edges.entrySet()) { DFAState target = entry.getValue();
if ( dfa_debug ) System.out.println("DFA state "+s.stateNumber+" LA(1)=="+getLookaheadName(input)); if ( state.useContext ) { while ( s.isContextSymbol(t) ) { DFAState next = null; if (remainingOuterContext != null) { remainingOuterContext = skipTailCalls(remainingOuterContext); next = s.getContextTarget(getReturnState(remainingOuterContext)); " predicts "+s.getPrediction()); return s.getPrediction();
protected int failOrAccept(SimState prevAccept, CharStream input, ATNConfigSet reach, int t) { if (prevAccept.dfaState != null) { LexerActionExecutor lexerActionExecutor = prevAccept.dfaState.getLexerActionExecutor(); accept(input, lexerActionExecutor, startIndex, prevAccept.index, prevAccept.line, prevAccept.charPos); return prevAccept.dfaState.getPrediction(); } else { // if no accept and EOF is first char, return EOF if ( t==IntStream.EOF && input.index()==startIndex ) { return Token.EOF; } throw new LexerNoViableAltException(recog, input, startIndex, reach); } }
int predictedAlt = getUniqueAlt(configs); if ( predictedAlt!=ATN.INVALID_ALT_NUMBER ) { newState.setAcceptState(new AcceptStateInfo(predictedAlt)); } else if (configs.getConflictingAlts() != null) { newState.setAcceptState(new AcceptStateInfo(newState.configs.getConflictingAlts().nextSetBit(0))); if (newState.isAcceptState() && configs.hasSemanticContext()) { predicateDFAState(newState, configs, decisionState.getNumberOfTransitions());
if (!state.isAcceptState()) { return false;
Set<Integer> alts = s.getAltSet(); if ( alts!=null ) { buf.append("\\n");
buf.append('s'); buf.append(s.stateNumber); if ( s.isAcceptState() ) { buf.append("=>").append(s.getPrediction());
if (ds0.isAcceptState()) { if (target.isAcceptState()) { captureSimState(prevAccept, input, target); if (t == IntStream.EOF) {
DFAState proposed = new DFAState(configs); ATNConfig firstConfigWithRuleStopState = null; for (ATNConfig c : configs) {
Set<Integer> alts = s.getAltSet(); if ( alts!=null ) { buf.append("\\n");
assert D.isAcceptState() || D.getPrediction() == ATN.INVALID_ALT_NUMBER; assert D.isAcceptState() || D.configs.getConflictInfo() == null; int predictedAlt = conflictingAlts == null ? D.getPrediction() : ATN.INVALID_ALT_NUMBER; if ( predictedAlt!=ATN.INVALID_ALT_NUMBER ) { if (optimize_ll1 predictedAlt = D.getPrediction();
public boolean isContextSensitive() { if (isPrecedenceDfa()) { return !s0full.get().getEdgeMap().isEmpty(); } return s0full.get() != null; }
DFAState D = new DFAState(reach);