Java DFA类代码示例

import org.antlr.v4.runtime.dfa.DFA; //导入依赖的package包/类
@Override
protected void reportAttemptingFullContext(DFA dfa, BitSet conflictingAlts, SimulatorState conflictState, int startIndex, int stopIndex) {
    super.reportAttemptingFullContext(dfa, conflictingAlts, conflictState, startIndex, stopIndex);
        int k;
        if (startIndex == stopIndex) {
            k = 1;
        } else if (startIndex == stopIndex - 1) {
            k = 2;
        } else {
            k = 0;
            for (int i = startIndex; i <= stopIndex; i++) {
                parser.getInputStream().seek(i);
                if (parser.getInputStream().LT(1).getChannel() == Token.DEFAULT_CHANNEL) {
                    k++;
                }
            }
        }

    fullContextFallback[dfa.decision]++;
    totalLookaheadSll[dfa.decision] += k;
    minLookaheadSll[dfa.decision] = Math.min(minLookaheadSll[dfa.decision], k);
    maxLookaheadSll[dfa.decision] = Math.max(maxLookaheadSll[dfa.decision], k);
}
 

import org.antlr.v4.runtime.dfa.DFA; //导入依赖的package包/类
public LexerInterpreter(String grammarFileName, Collection<String> tokenNames, Collection<String> ruleNames, Collection<String> modeNames, ATN atn, CharStream input) {
	super(input);

	if (atn.grammarType != ATNType.LEXER) {
		throw new IllegalArgumentException("The ATN must be a lexer ATN.");
	}

	this.grammarFileName = grammarFileName;
	this.atn = atn;
	this.tokenNames = tokenNames.toArray(new String[tokenNames.size()]);
	this.ruleNames = ruleNames.toArray(new String[ruleNames.size()]);
	this.modeNames = modeNames.toArray(new String[modeNames.size()]);

	this._decisionToDFA = new DFA[atn.getNumberOfDecisions()];
	for (int i = 0; i < _decisionToDFA.length; i++) {
		_decisionToDFA[i] = new DFA(atn.getDecisionState(i), i);
	}
	this._interp = new LexerATNSimulator(this,atn,_decisionToDFA,_sharedContextCache);
}
 

import org.antlr.v4.runtime.dfa.DFA; //导入依赖的package包/类
@Override
public void reportAmbiguity(@NotNull Parser recognizer,
							@NotNull DFA dfa,
							int startIndex,
							int stopIndex,
							boolean exact,
							@Nullable BitSet ambigAlts,
							@NotNull ATNConfigSet configs)
{
	if (exactOnly && !exact) {
		return;
	}

	String format = "reportAmbiguity d=%s: ambigAlts=%s, input='%s'";
	String decision = getDecisionDescription(recognizer, dfa);
	BitSet conflictingAlts = getConflictingAlts(ambigAlts, configs);
	String text = recognizer.getTokenStream().getText(Interval.of(startIndex, stopIndex));
	String message = String.format(format, decision, conflictingAlts, text);
	recognizer.notifyErrorListeners(message);
}
 

import org.antlr.v4.runtime.dfa.DFA; //导入依赖的package包/类
protected String getDecisionDescription(@NotNull Parser recognizer, @NotNull DFA dfa) {
	int decision = dfa.decision;
	int ruleIndex = dfa.atnStartState.ruleIndex;

	String[] ruleNames = recognizer.getRuleNames();
	if (ruleIndex < 0 || ruleIndex >= ruleNames.length) {
		return String.valueOf(decision);
	}

	String ruleName = ruleNames[ruleIndex];
	if (ruleName == null || ruleName.isEmpty()) {
		return String.valueOf(decision);
	}

	return String.format("%d (%s)", decision, ruleName);
}
 

import org.antlr.v4.runtime.dfa.DFA; //导入依赖的package包/类
/**
 * Add state {@code D} to the DFA if it is not already present, and return
 * the actual instance stored in the DFA. If a state equivalent to {@code D}
 * is already in the DFA, the existing state is returned. Otherwise this
 * method returns {@code D} after adding it to the DFA.
 *
 * <p>If {@code D} is {@link #ERROR}, this method returns {@link #ERROR} and
 * does not change the DFA.</p>
 *
 * @param dfa The dfa
 * @param D The DFA state to add
 * @return The state stored in the DFA. This will be either the existing
 * state if {@code D} is already in the DFA, or {@code D} itself if the
 * state was not already present.
 */
@NotNull
protected DFAState addDFAState(@NotNull DFA dfa, @NotNull DFAState D) {
	if (D == ERROR) {
		return D;
	}

	synchronized (dfa.states) {
		DFAState existing = dfa.states.get(D);
		if ( existing!=null ) return existing;

		D.stateNumber = dfa.states.size();
		if (!D.configs.isReadonly()) {
			D.configs.optimizeConfigs(this);
			D.configs.setReadonly(true);
		}
		dfa.states.put(D, D);
		if ( debug ) System.out.println("adding new DFA state: "+D);
		return D;
	}
}
 

import org.antlr.v4.runtime.dfa.DFA; //导入依赖的package包/类
@Override
protected void reportAmbiguity(@NotNull DFA dfa, DFAState D, int startIndex, int stopIndex, boolean exact,
							   @Nullable BitSet ambigAlts, @NotNull ATNConfigSet configs)
{
	int prediction;
	if ( ambigAlts!=null ) {
		prediction = ambigAlts.nextSetBit(0);
	}
	else {
		prediction = configs.getAlts().nextSetBit(0);
	}
	if ( configs.fullCtx && prediction != conflictingAltResolvedBySLL ) {
		// Even though this is an ambiguity we are reporting, we can
		// still detect some context sensitivities.  Both SLL and LL
		// are showing a conflict, hence an ambiguity, but if they resolve
		// to different minimum alternatives we have also identified a
		// context sensitivity.
		decisions[currentDecision].contextSensitivities.add(
				new ContextSensitivityInfo(currentDecision, configs, _input, startIndex, stopIndex)
		);
	}
	decisions[currentDecision].ambiguities.add(
		new AmbiguityInfo(currentDecision, configs, _input, startIndex, stopIndex, configs.fullCtx)
	);
	super.reportAmbiguity(dfa, D, startIndex, stopIndex, exact, ambigAlts, configs);
}
 

import org.antlr.v4.runtime.dfa.DFA; //导入依赖的package包/类
public int match(@NotNull CharStream input, int mode) {
	match_calls++;
	this.mode = mode;
	int mark = input.mark();
	try {
		this.startIndex = input.index();
		this.prevAccept.reset();
		DFA dfa = decisionToDFA[mode];
		if ( dfa.s0==null ) {
			return matchATN(input);
		}
		else {
			return execATN(input, dfa.s0);
		}
	}
	finally {
		input.release(mark);
	}
}
 

import org.antlr.v4.runtime.dfa.DFA; //导入依赖的package包/类
@Override
public void reportAmbiguity(@NotNull Parser recognizer,
							@NotNull DFA dfa,
							int startIndex,
							int stopIndex,
							boolean exact,
							@Nullable BitSet ambigAlts,
							@NotNull ATNConfigSet configs)
{
}
 

import org.antlr.v4.runtime.dfa.DFA; //导入依赖的package包/类
@Override
public void reportAttemptingFullContext(@NotNull Parser recognizer,
										@NotNull DFA dfa,
										int startIndex,
										int stopIndex,
										@Nullable BitSet conflictingAlts,
										@NotNull ATNConfigSet configs)
{
}
 

import org.antlr.v4.runtime.dfa.DFA; //导入依赖的package包/类
@Override
public void reportContextSensitivity(@NotNull Parser recognizer,
									 @NotNull DFA dfa,
									 int startIndex,
									 int stopIndex,
									 int prediction,
									 @NotNull ATNConfigSet configs)
{
}
 

import org.antlr.v4.runtime.dfa.DFA; //导入依赖的package包/类
@Override
    public void reportAmbiguity(
            Parser recognizer,
            DFA dfa,
            int startIndex,
            int stopIndex,
            boolean exact,
            BitSet ambigAlts,
            ATNConfigSet configs) {
        hasAmbiguity = true;
        ambiguityCount++;
//        allFields.put("__Ambiguity__",new AgentField("true"));
    }
 

import org.antlr.v4.runtime.dfa.DFA; //导入依赖的package包/类
@Override
public void reportAttemptingFullContext(
        Parser recognizer,
        DFA dfa,
        int startIndex,
        int stopIndex,
        BitSet conflictingAlts,
        ATNConfigSet configs) {
}
 

import org.antlr.v4.runtime.dfa.DFA; //导入依赖的package包/类
@Override
public void reportContextSensitivity(
        Parser recognizer,
        DFA dfa,
        int startIndex,
        int stopIndex,
        int prediction,
        ATNConfigSet configs) {

}
 

import org.antlr.v4.runtime.dfa.DFA; //导入依赖的package包/类
@Override
public void reportAmbiguity(
        Parser recognizer,
        DFA dfa,
        int startIndex,
        int stopIndex,
        boolean exact,
        BitSet ambigAlts,
        ATNConfigSet configs) {
    // Ignore this type of problem
}
 

import org.antlr.v4.runtime.dfa.DFA; //导入依赖的package包/类
@Override
public void reportAttemptingFullContext(
        Parser recognizer,
        DFA dfa,
        int startIndex,
        int stopIndex,
        BitSet conflictingAlts,
        ATNConfigSet configs) {
    // Ignore this type of problem
}