Example usage for org.antlr.v4.tool GrammarParserInterpreter parse

Introduction

In this page you can find the example usage for org.antlr.v4.tool GrammarParserInterpreter parse.

Prototype

public ParserRuleContext parse(int startRuleIndex) 

Source Link

Document

Begin parsing at startRuleIndex

Usage

From source file:no.ssb.vtl.test.junit.GrammarRule.java

License:Apache License

/**
 * Parse an expression starting from the given <b>ANTLR rule</b>
 * <p>//w w w  .  j a  v a2 s  . co m
 * In order to get the Rule, use the {@link #withRule(String)} method.
 *
 * @param expression the expression to parse.
 * @param rule       the rule to start from.
 *                   @param diagnostic {@link DiagnosticErrorListener} will be used if true.
 * @return the resulting parse tree.
 * @throws Exception if the expression failed to parse.
 */
public ParserRuleContext parse(String expression, Rule rule, boolean diagnostic) throws Exception {
    Multimap<Integer, String> messages = LinkedListMultimap.create();

    LexerInterpreter lexerInterpreter = grammar.createLexerInterpreter(new ANTLRInputStream(expression));
    GrammarParserInterpreter parserInterpreter = grammar
            .createGrammarParserInterpreter(new CommonTokenStream(lexerInterpreter));

    BaseErrorListener errorListener;
    if (diagnostic) {
        errorListener = new DiagnosticErrorListener();
    } else {
        errorListener = new ConsoleErrorListener();
    }

    BaseErrorListener ruleErrorReporter = new BaseErrorListener() {
        @Override
        public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol, int line,
                int charPositionInLine, String msg, org.antlr.v4.runtime.RecognitionException e) {
            int startLine = line, stopLine = line;
            int startColumn = charPositionInLine, stopColumn = charPositionInLine;
            if (offendingSymbol instanceof Token) {
                Token symbol = (Token) offendingSymbol;
                int start = symbol.getStartIndex();
                int stop = symbol.getStopIndex();
                if (start >= 0 && stop >= 0) {
                    stopColumn = startColumn + (stop - start) + 1;
                }
            }

            messages.put(stopLine,
                    String.format("at [%4s:%6s]:\t%s (%s)\n", String.format("%d,%d", startLine, stopLine),
                            String.format("%d,%d", startColumn, stopColumn), msg,
                            Optional.ofNullable(e).map(ex -> ex.getClass().getSimpleName()).orElse("null")));
        }
    };

    parserInterpreter.setErrorHandler(new GrammarParserInterpreter.BailButConsumeErrorStrategy());
    lexerInterpreter.removeErrorListeners();
    parserInterpreter.removeErrorListeners();

    lexerInterpreter.addErrorListener(errorListener);
    parserInterpreter.addErrorListener(errorListener);
    lexerInterpreter.addErrorListener(ruleErrorReporter);
    parserInterpreter.addErrorListener(ruleErrorReporter);

    ParserRuleContext parse = parserInterpreter.parse(rule.index);

    if (!messages.isEmpty()) {

        StringBuilder expressionWithErrors = new StringBuilder();
        LineNumberReader expressionReader = new LineNumberReader(new StringReader(expression));
        String line;
        while ((line = expressionReader.readLine()) != null) {
            int lineNumber = expressionReader.getLineNumber();
            expressionWithErrors.append(String.format("\t%d:%s%n", lineNumber, line));
            if (messages.containsKey(lineNumber)) {
                expressionWithErrors.append(String.format("%n"));
                for (String message : messages.get(lineNumber)) {
                    expressionWithErrors.append(message);
                }
            }
        }
        throw new Exception(
                String.format("errors parsing expression:%n%n%s%n", expressionWithErrors.toString()));
    }

    return parse;
}

---