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

private static ParseTree parseSQL(String sql) {
    CharStream charStream = new ANTLRInputStream(sql);
    RQLLexer lexer = new RQLLexer(charStream);
    lexer.setTokenFactory(new CommonTokenFactory(true));
    TokenStream tokenStream = new UnbufferedTokenStream<CommonToken>(lexer);
    RQLParser parser = new RQLParser(tokenStream);
    parser.setErrorHandler(new BailErrorStrategy());
    return parser.root();
}

protected void initialize(String input)
{
    StringTemplateCSSLexer lexer = new StringTemplateCSSLexer(new ANTLRInputStream(input));

    CommonTokenStream tokens = new CommonTokenStream(lexer);

    StringTemplateCSSParser parser = new StringTemplateCSSParser(tokens);

    parser.setErrorHandler(new BailErrorStrategy());

    ParseTree tree = parser.css();

    Collection<ParseTree> selectorCombinations = XPath.findAll(tree, "//selectorCombination", parser);

    final StringUtils stringUtils = StringUtils.getInstance();

    this.selectors = new ArrayList<List<String>>(selectorCombinations.size());
    this.properties = new HashMap<List<String>, Map<String, String>>();

    for (ParseTree selectorCombination : selectorCombinations) {
        List<String> currentSelectors = new ArrayList<String>(selectorCombination.getChildCount());
        this.selectors.add(currentSelectors);

        for (int index = 0; index < selectorCombination.getChildCount(); index++) {
            String text = selectorCombination.getChild(index).getText();
            currentSelectors.add(text);
        }
        Map<String, String> block = retrieveProperties(selectorCombination, stringUtils);

        this.properties.put(currentSelectors, block);
    }
}

@NonNull
public static SQLiteParser createParser(@NonNull String sql) {
    CharStream source = new ANTLRInputStream(sql);
    Lexer lexer = new SQLiteLexer(source);
    TokenStream tokenStream = new CommonTokenStream(lexer);
    SQLiteParser parser = new SQLiteParser(tokenStream);
    parser.setErrorHandler(new BailErrorStrategy());
    return parser;
}

private QueryListener parse(Function<HeroicQueryParser, ParserRuleContext> op, String input) {
    final HeroicQueryLexer lexer = new HeroicQueryLexer(new ANTLRInputStream(input));

    final CommonTokenStream tokens = new CommonTokenStream(lexer);
    final HeroicQueryParser parser = new HeroicQueryParser(tokens);

    parser.removeErrorListeners();
    parser.setErrorHandler(new BailErrorStrategy());

    final ParserRuleContext context;

    try {
        context = op.apply(parser);
    } catch (final ParseCancellationException e) {
        if (!(e.getCause() instanceof RecognitionException)) {
            throw e;
        }

        throw toParseException((RecognitionException) e.getCause());
    }

    final QueryListener listener = new QueryListener();

    ParseTreeWalker.DEFAULT.walk(listener, context);

    final Token last = lexer.getToken();

    if (last.getType() != Token.EOF) {
        throw new ParseException(
            String.format("garbage at end of string: '%s'", last.getText()), null,
            last.getLine(), last.getCharPositionInLine());
    }

    return listener;
}

/**
 * Constructs a new parser.
 * @param f the formula factory
 */
public PropositionalParser(final FormulaFactory f) {
  super(f);
  this.lexer = new PropositionalLexer(null);
  CommonTokenStream tokens = new CommonTokenStream(this.lexer);
  this.parser = new LogicNGPropositionalParser(tokens);
  this.parser.setFormulaFactory(f);
  this.lexer.removeErrorListeners();
  this.parser.removeErrorListeners();
  this.parser.setErrorHandler(new BailErrorStrategy());
}

/**
 * Constructs a new parser for pseudo boolean formulas.
 * @param f the formula factory
 */
public PseudoBooleanParser(final FormulaFactory f) {
  super(f);
  this.lexer = new PseudoBooleanLexer(null);
  CommonTokenStream tokens = new CommonTokenStream(this.lexer);
  this.parser = new LogicNGPseudoBooleanParser(tokens);
  this.parser.setFormulaFactory(f);
  this.lexer.removeErrorListeners();
  this.parser.removeErrorListeners();
  this.parser.setErrorHandler(new BailErrorStrategy());
}

public static JsonPath compile(String path) {
    JsonPathLexer lexer = new JsonPathLexer(CharStreams.fromString(path));
    CommonTokenStream tokens = new CommonTokenStream(lexer);
    JsonPathParser parser = new JsonPathParser(tokens);
    parser.setErrorHandler(new BailErrorStrategy());
    JsonPathParser.PathContext tree = parser.path();
    JsonPathCompiler compiler = new JsonPathCompiler();
    compiler.visit(tree);
    return compiler.pathBuilder.build();
}

public static SOQLParser.StatementContext getStatementContext(String query) {
  SOQLLexer lexer = new SOQLLexer(new ANTLRInputStream(query));
  CommonTokenStream tokens = new CommonTokenStream(lexer);
  SOQLParser parser = new SOQLParser(tokens);
  parser.setErrorHandler(new BailErrorStrategy());
  return parser.statement();
}

private ParserRuleContext parseQuery (String q) {
    // TODO replace AqlLexer with lexer for your Antlr4 grammar!
    Lexer qlLexer = new AqlLexer((CharStream) null);
    ParserRuleContext tree = null;
    // Like p. 111
    try {
        // Tokenize input data
        ANTLRInputStream input = new ANTLRInputStream(q);
        qlLexer.setInputStream(input);
        CommonTokenStream tokens = new CommonTokenStream(qlLexer);
        // TODO replace AqlParser with parser for your Antlr4
        // grammar!
        parser = new AqlParser(tokens);

        // Don't throw out erroneous stuff
        parser.setErrorHandler(new BailErrorStrategy());
        parser.removeErrorListeners();

        // Get starting rule from parser
        // TODO replace AqlParser with parser for your Antlr4
        // grammar!
        Method startRule = AqlParser.class.getMethod("start");
        tree = (ParserRuleContext) startRule
                .invoke(parser, (Object[]) null);
    }

    // Some things went wrong ...
    catch (Exception e) {
        System.err.println(e.getMessage());
    }

    // Return the generated tree
    return tree;
}

private ParserRuleContext parseAnnisQuery (String query) {
    Lexer lexer = new AqlLexer((CharStream) null);
    ParserRuleContext tree = null;
    Antlr4DescriptiveErrorListener errorListener = new Antlr4DescriptiveErrorListener(
            query);
    // Like p. 111
    try {
        // Tokenize input data
        ANTLRInputStream input = new ANTLRInputStream(query);
        lexer.setInputStream(input);
        CommonTokenStream tokens = new CommonTokenStream(lexer);
        parser = new AqlParser(tokens);
        // Don't throw out erroneous stuff
        parser.setErrorHandler(new BailErrorStrategy());
        lexer.removeErrorListeners();
        lexer.addErrorListener(errorListener);
        parser.removeErrorListeners();
        parser.addErrorListener(errorListener);
        // Get starting rule from parser
        Method startRule = AqlParser.class.getMethod("start");
        tree = (ParserRuleContext) startRule.invoke(parser,
                (Object[]) null);
    }
    // Some things went wrong ...
    catch (Exception e) {
        log.error("Could not parse query. "
                + "Please make sure it is well-formed.");
        log.error(errorListener.generateFullErrorMsg().toString());
        addError(errorListener.generateFullErrorMsg());
    }
    return tree;
}