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

protected String getStateLabel(ATNState s) {
    if ( s==null ) return "null";
    String stateLabel = "";

    if (s instanceof BlockStartState) {
        stateLabel += "→\\n";
    }
    else if (s instanceof BlockEndState) {
        stateLabel += "←\\n";
    }

    stateLabel += String.valueOf(s.stateNumber);

    if (s instanceof PlusBlockStartState || s instanceof PlusLoopbackState) {
        stateLabel += "+";
    }
    else if (s instanceof StarBlockStartState || s instanceof StarLoopEntryState || s instanceof StarLoopbackState) {
        stateLabel += "*";
    }

    if ( s instanceof DecisionState && ((DecisionState)s).decision>=0 ) {
        stateLabel = stateLabel+"\\nd="+((DecisionState)s).decision;
    }

    return stateLabel;
}

@Override
public Choice getEBNFBlock(GrammarAST ebnfRoot, List<CodeBlockForAlt> alts) {
    if (!g.tool.force_atn) {
        int decision;
        if ( ebnfRoot.getType()==ANTLRParser.POSITIVE_CLOSURE ) {
            decision = ((PlusLoopbackState)ebnfRoot.atnState).decision;
        }
        else if ( ebnfRoot.getType()==ANTLRParser.CLOSURE ) {
            decision = ((StarLoopEntryState)ebnfRoot.atnState).decision;
        }
        else {
            decision = ((DecisionState)ebnfRoot.atnState).decision;
        }

        if ( AnalysisPipeline.disjoint(g.decisionLOOK.get(decision)) ) {
            return getLL1EBNFBlock(ebnfRoot, alts);
        }
    }

    return getComplexEBNFBlock(ebnfRoot, alts);
}

String getStateString(ATNState s) {
    int n = s.stateNumber;
    String stateStr = "s"+n;
    if ( s instanceof StarBlockStartState ) stateStr = "StarBlockStart_"+n;
    else if ( s instanceof PlusBlockStartState ) stateStr = "PlusBlockStart_"+n;
    else if ( s instanceof BlockStartState) stateStr = "BlockStart_"+n;
    else if ( s instanceof BlockEndState ) stateStr = "BlockEnd_"+n;
    else if ( s instanceof RuleStartState) stateStr = "RuleStart_"+g.getRule(s.ruleIndex).name+"_"+n;
    else if ( s instanceof RuleStopState ) stateStr = "RuleStop_"+g.getRule(s.ruleIndex).name+"_"+n;
    else if ( s instanceof PlusLoopbackState) stateStr = "PlusLoopBack_"+n;
    else if ( s instanceof StarLoopbackState) stateStr = "StarLoopBack_"+n;
    else if ( s instanceof StarLoopEntryState) stateStr = "StarLoopEntry_"+n;
    return stateStr;
}

@Override
public void visitState(ATNState p) {
    if (p.getStateType() == ATNState.BASIC && p.getNumberOfTransitions() == 1) {
        ATNState q = p.transition(0).target;
        if (p.transition(0) instanceof RuleTransition) {
            q = ((RuleTransition) p.transition(0)).followState;
        }
        if (q.getStateType() == ATNState.BASIC) {
            // we have p-x->q for x in {rule, action, pred, token, ...}
            // if edge out of q is single epsilon to block end
            // we can strip epsilon p-x->q-eps->r
            Transition trans = q.transition(0);
            if (q.getNumberOfTransitions() == 1 && trans instanceof EpsilonTransition) {
                ATNState r = trans.target;
                if (r instanceof BlockEndState || r instanceof PlusLoopbackState || r instanceof StarLoopbackState) {
                    // skip over q
                    if (p.transition(0) instanceof RuleTransition) {
                        ((RuleTransition) p.transition(0)).followState = r;
                    } else {
                        p.transition(0).target = r;
                    }
                    _atn.removeState(q);
                }
            }
        }
    }
}

/**
 * From {@code (blk)+} build
 *
 * <pre>
 *   |---------|
 *   v         |
 *  [o-blk-o]-&gt;o-&gt;o
 * </pre>
 *
 * We add a decision for loop back node to the existing one at {@code blk}
 * start.
 */

@Override
public Handle plus(GrammarAST plusAST, Handle blk) {
    PlusBlockStartState blkStart = (PlusBlockStartState)blk.left;
    BlockEndState blkEnd = (BlockEndState)blk.right;
    preventEpsilonClosureBlocks.add(new Triple<Rule, ATNState, ATNState>(currentRule, blkStart, blkEnd));

    PlusLoopbackState loop = newState(PlusLoopbackState.class, plusAST);
    loop.nonGreedy = !((QuantifierAST)plusAST).isGreedy();
    atn.defineDecisionState(loop);
    LoopEndState end = newState(LoopEndState.class, plusAST);
    blkStart.loopBackState = loop;
    end.loopBackState = loop;

    plusAST.atnState = loop;
    epsilon(blkEnd, loop);      // blk can see loop back

    BlockAST blkAST = (BlockAST)plusAST.getChild(0);
    if ( ((QuantifierAST)plusAST).isGreedy() ) {
        if (expectNonGreedy(blkAST)) {
            g.tool.errMgr.grammarError(ErrorType.EXPECTED_NON_GREEDY_WILDCARD_BLOCK, g.fileName, plusAST.getToken(), plusAST.getToken().getText());
        }

        epsilon(loop, blkStart);    // loop back to start
        epsilon(loop, end);         // or exit
    }
    else {
        // if not greedy, priority to exit branch; make it first
        epsilon(loop, end);         // exit
        epsilon(loop, blkStart);    // loop back to start
    }

    return new Handle(blkStart, end);
}

public PlusBlock(OutputModelFactory factory,
                 GrammarAST plusRoot,
                 List<CodeBlockForAlt> alts)
{
    super(factory, plusRoot, alts);
    BlockAST blkAST = (BlockAST)plusRoot.getChild(0);
    PlusBlockStartState blkStart = (PlusBlockStartState)blkAST.atnState;
    PlusLoopbackState loop = blkStart.loopBackState;
    stateNumber = blkStart.loopBackState.stateNumber;
    blockStartStateNumber = blkStart.stateNumber;
    loopBackStateNumber = loop.stateNumber;
    this.error = getThrowNoViableAlt(factory, plusRoot, null);
    decision = loop.decision;
}