Examples with Result org.antlr.v4.misc.EscapeSequenceParsing.Result used on opensource projects

Example 56 with Result

use of org.antlr.v4.misc.EscapeSequenceParsing.Result in project antlr4 by antlr.

the class TestVisitors method testVisitErrorNode.

/**
	 * This test verifies the basic behavior of visitors, with an emphasis on
	 * {@link AbstractParseTreeVisitor#visitErrorNode}.
	 */
@Test
public void testVisitErrorNode() {
    String input = "";
    VisitorBasicLexer lexer = new VisitorBasicLexer(new ANTLRInputStream(input));
    VisitorBasicParser parser = new VisitorBasicParser(new CommonTokenStream(lexer));
    final List<String> errors = new ArrayList<>();
    parser.removeErrorListeners();
    parser.addErrorListener(new BaseErrorListener() {

        @Override
        public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol, int line, int charPositionInLine, String msg, RecognitionException e) {
            errors.add("line " + line + ":" + charPositionInLine + " " + msg);
        }
    });
    VisitorBasicParser.SContext context = parser.s();
    Assert.assertEquals("(s <missing 'A'> <EOF>)", context.toStringTree(parser));
    Assert.assertEquals(1, errors.size());
    Assert.assertEquals("line 1:0 missing 'A' at '<EOF>'", errors.get(0));
    VisitorBasicVisitor<String> listener = new VisitorBasicBaseVisitor<String>() {

        @Override
        public String visitErrorNode(ErrorNode node) {
            return "Error encountered: " + node.getSymbol();
        }

        @Override
        protected String defaultResult() {
            return "";
        }

        @Override
        protected String aggregateResult(String aggregate, String nextResult) {
            return aggregate + nextResult;
        }
    };
    String result = listener.visit(context);
    String expected = "Error encountered: [@-1,-1:-1='<missing 'A'>',<1>,1:0]";
    Assert.assertEquals(expected, result);
}

Example 57 with Result

use of org.antlr.v4.misc.EscapeSequenceParsing.Result in project antlr4 by antlr.

the class TestVisitors method testCalculatorVisitor.

/**
	 * This test verifies that the visitor correctly dispatches calls for labeled outer alternatives.
	 */
@Test
public void testCalculatorVisitor() {
    String input = "2 + 8 / 2";
    VisitorCalcLexer lexer = new VisitorCalcLexer(new ANTLRInputStream(input));
    VisitorCalcParser parser = new VisitorCalcParser(new CommonTokenStream(lexer));
    VisitorCalcParser.SContext context = parser.s();
    Assert.assertEquals("(s (expr (expr 2) + (expr (expr 8) / (expr 2))) <EOF>)", context.toStringTree(parser));
    VisitorCalcVisitor<Integer> listener = new VisitorCalcBaseVisitor<Integer>() {

        @Override
        public Integer visitS(VisitorCalcParser.SContext ctx) {
            return visit(ctx.expr());
        }

        @Override
        public Integer visitNumber(VisitorCalcParser.NumberContext ctx) {
            return Integer.valueOf(ctx.INT().getText());
        }

        @Override
        public Integer visitMultiply(VisitorCalcParser.MultiplyContext ctx) {
            Integer left = visit(ctx.expr(0));
            Integer right = visit(ctx.expr(1));
            if (ctx.MUL() != null) {
                return left * right;
            } else {
                return left / right;
            }
        }

        @Override
        public Integer visitAdd(VisitorCalcParser.AddContext ctx) {
            Integer left = visit(ctx.expr(0));
            Integer right = visit(ctx.expr(1));
            if (ctx.ADD() != null) {
                return left + right;
            } else {
                return left - right;
            }
        }

        @Override
        protected Integer defaultResult() {
            throw new RuntimeException("Should not be reachable");
        }

        @Override
        protected Integer aggregateResult(Integer aggregate, Integer nextResult) {
            throw new RuntimeException("Should not be reachable");
        }
    };
    int result = listener.visit(context);
    int expected = 6;
    Assert.assertEquals(expected, result);
}

Example 58 with Result

use of org.antlr.v4.misc.EscapeSequenceParsing.Result in project antlr4 by antlr.

the class BaseBrowserTest method execParser.

@Override
public String execParser(String grammarFileName, String grammarStr, String parserName, String lexerName, String listenerName, String visitorName, String startRuleName, String input, boolean showDiagnosticErrors) {
    boolean success = rawGenerateAndBuildRecognizer(grammarFileName, grammarStr, parserName, lexerName, "-visitor");
    assertTrue(success);
    rawBuildRecognizerTestFile(parserName, lexerName, listenerName, visitorName, startRuleName, showDiagnosticErrors);
    String result = null;
    try {
        result = execRecognizer(input);
    } catch (Exception e) {
        e.printStackTrace(System.err);
    }
    return result;
}

Example 59 with Result

use of org.antlr.v4.misc.EscapeSequenceParsing.Result in project antlr4 by antlr.

the class BaseBrowserTest method checkRuleATN.

void checkRuleATN(Grammar g, String ruleName, String expecting) {
    ParserATNFactory f = new ParserATNFactory(g);
    ATN atn = f.createATN();
    DOTGenerator dot = new DOTGenerator(g);
    System.out.println(dot.getDOT(atn.ruleToStartState[g.getRule(ruleName).index]));
    Rule r = g.getRule(ruleName);
    ATNState startState = atn.ruleToStartState[r.index];
    ATNPrinter serializer = new ATNPrinter(g, startState);
    String result = serializer.asString();
    //System.out.print(result);
    assertEquals(expecting, result);
}

Example 60 with Result

use of org.antlr.v4.misc.EscapeSequenceParsing.Result in project antlr4 by antlr.

the class BasePythonTest method execStartRule.

public ParseTree execStartRule(String startRuleName, Parser parser) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
    Method startRule = null;
    Object[] args = null;
    try {
        startRule = parser.getClass().getMethod(startRuleName);
    } catch (NoSuchMethodException nsme) {
        // try with int _p arg for recursive func
        startRule = parser.getClass().getMethod(startRuleName, int.class);
        args = new Integer[] { 0 };
    }
    ParseTree result = (ParseTree) startRule.invoke(parser, args);
    //		System.out.println("parse tree = "+result.toStringTree(parser));
    return result;
}