Examples with DFA org.antlr.v4.runtime.dfa.DFA used on opensource projects

Example 16 with DFA

use of org.antlr.v4.runtime.dfa.DFA in project antlr4 by tunnelvisionlabs.

the class TestATNParserPrediction method testEmptyInput.

@Test
public void testEmptyInput() throws Exception {
    LexerGrammar lg = new LexerGrammar("lexer grammar L;\n" + "A : 'a' ;\n" + "B : 'b' ;\n" + "C : 'c' ;\n");
    Grammar g = new Grammar("parser grammar T;\n" + "a : A | ;");
    int decision = 0;
    checkPredictedAlt(lg, g, decision, "a", 1);
    checkPredictedAlt(lg, g, decision, "", 2);
    // After matching these inputs for decision, what is DFA after each prediction?
    String[] inputs = { "a", "" };
    String[] dfa = { "s0-'a'->:s1=>1\n", "s0-EOF->:s2=>2\n" + "s0-'a'->:s1=>1\n" };
    checkDFAConstruction(lg, g, decision, inputs, dfa);
}

Example 17 with DFA

use of org.antlr.v4.runtime.dfa.DFA in project antlr4 by tunnelvisionlabs.

the class TestATNParserPrediction method testRuleRefxory.

@Test
public void testRuleRefxory() throws Exception {
    LexerGrammar lg = new LexerGrammar("lexer grammar L;\n" + "A : 'a' ;\n" + "B : 'b' ;\n" + "C : 'c' ;\n");
    Grammar g = new Grammar("parser grammar T;\n" + "a : x | y ;\n" + "x : A ;\n" + "y : B ;\n");
    int decision = 0;
    checkPredictedAlt(lg, g, decision, "a", 1);
    checkPredictedAlt(lg, g, decision, "b", 2);
    // After matching these inputs for decision, what is DFA after each prediction?
    String[] inputs = { "a", "b", "a" };
    String[] dfa = { "s0-'a'->:s1=>1\n", "s0-'a'->:s1=>1\n" + "s0-'b'->:s2=>2\n", // don't change after it works
    "s0-'a'->:s1=>1\n" + "s0-'b'->:s2=>2\n" };
    checkDFAConstruction(lg, g, decision, inputs, dfa);
}

Example 18 with DFA

use of org.antlr.v4.runtime.dfa.DFA in project antlr4 by tunnelvisionlabs.

the class TestATNParserPrediction method testPEGAchillesHeel.

@Test
public void testPEGAchillesHeel() throws Exception {
    LexerGrammar lg = new LexerGrammar("lexer grammar L;\n" + "A : 'a' ;\n" + "B : 'b' ;\n" + "C : 'c' ;\n");
    Grammar g = new Grammar("parser grammar T;\n" + "a : A | A B ;");
    checkPredictedAlt(lg, g, 0, "a", 1);
    checkPredictedAlt(lg, g, 0, "ab", 2);
    checkPredictedAlt(lg, g, 0, "abc", 2);
    String[] inputs = { "a", "ab", "abc" };
    String[] dfa = { "s0-'a'->s1\n" + "s1-EOF->:s2=>1\n", "s0-'a'->s1\n" + "s1-EOF->:s2=>1\n" + "s1-'b'->:s3=>2\n", "s0-'a'->s1\n" + "s1-EOF->:s2=>1\n" + "s1-'b'->:s3=>2\n" };
    checkDFAConstruction(lg, g, 0, inputs, dfa);
}

Example 19 with DFA

use of org.antlr.v4.runtime.dfa.DFA in project antlr4 by tunnelvisionlabs.

the class TestATNParserPrediction method checkDFAConstruction.

public void checkDFAConstruction(LexerGrammar lg, Grammar g, int decision, String[] inputString, String[] dfaString) {
    // Tool.internalOption_ShowATNConfigsInDFA = true;
    ATN lexatn = createATN(lg, true);
    LexerATNSimulator lexInterp = new LexerATNSimulator(lexatn);
    semanticProcess(lg);
    g.importVocab(lg);
    semanticProcess(g);
    ParserInterpreterForTesting interp = new ParserInterpreterForTesting(g, null);
    for (int i = 0; i < inputString.length; i++) {
        // Check DFA
        IntegerList types = getTokenTypesViaATN(inputString[i], lexInterp);
        System.out.println(types);
        TokenStream input = new IntTokenStream(types);
        try {
            interp.adaptivePredict(input, decision, ParserRuleContext.emptyContext());
        } catch (NoViableAltException nvae) {
            nvae.printStackTrace(System.err);
        }
        DFA dfa = interp.getATNSimulator().atn.decisionToDFA[decision];
        assertEquals(dfaString[i], dfa.toString(g.getVocabulary(), g.rules.keySet().toArray(new String[g.rules.size()])));
    }
}

Example 20 with DFA

use of org.antlr.v4.runtime.dfa.DFA in project antlr4 by tunnelvisionlabs.

the class TestATNParserPrediction method testOptionalRuleChasesGlobalFollow.

@Test
public void testOptionalRuleChasesGlobalFollow() throws Exception {
    LexerGrammar lg = new LexerGrammar("lexer grammar L;\n" + "A : 'a' ;\n" + "B : 'b' ;\n" + "C : 'c' ;\n");
    Grammar g = new Grammar("parser grammar T;\n" + "tokens {A,B,C}\n" + "a : x B ;\n" + "b : x C ;\n" + "x : A | ;\n");
    int decision = 0;
    checkPredictedAlt(lg, g, decision, "a", 1);
    checkPredictedAlt(lg, g, decision, "b", 2);
    checkPredictedAlt(lg, g, decision, "c", 2);
    // After matching these inputs for decision, what is DFA after each prediction?
    String[] inputs = { "a", "b", "c", "c" };
    String[] dfa = { "s0-'a'->:s1=>1\n", "s0-'a'->:s1=>1\n" + "s0-'b'->:s2=>2\n", "s0-'a'->:s1=>1\n" + "s0-'b'->:s2=>2\n" + "s0-'c'->:s3=>2\n", "s0-'a'->:s1=>1\n" + "s0-'b'->:s2=>2\n" + "s0-'c'->:s3=>2\n" };
    checkDFAConstruction(lg, g, decision, inputs, dfa);
}