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

public static Program parse(String source) {
    RankPLLexer lexer = new RankPLLexer(new ANTLRInputStream(source));
    TokenStream tokens = new CommonTokenStream(lexer);
    RankPLParser parser = new RankPLParser(tokens);
    parser.setErrorHandler(new BailErrorStrategy());
    ConcreteParser classVisitor = new ConcreteParser();

    // Parse
    Program program = null;
    try {
        program = (Program) classVisitor.visit(parser.program());
    } catch (ParseCancellationException e) {
        System.out.println("Syntax error");
        lexer = new RankPLLexer(new ANTLRInputStream(source));
        tokens = new CommonTokenStream(lexer);
        parser = new RankPLParser(tokens);
        classVisitor = new ConcreteParser();
        try {
            program = (Program) classVisitor.visit(parser.program());
        } catch (Exception ex) {
            // Ignore
        }
        return null;
    }
    return program;
}

/**
 * Parse the given Thrift {@code text}, using the given {@code location}
 * to anchor parsed elements withing the file.
 * @param location the {@link Location} of the data being parsed.
 * @param text the text to be parsed.
 * @param reporter an {@link ErrorReporter} to collect warnings.
 * @return a representation of the parsed Thrift data.
 */
public static ThriftFileElement parse(Location location, String text, ErrorReporter reporter) {
    ANTLRInputStream charStream = new ANTLRInputStream(text);
    AntlrThriftLexer lexer = new AntlrThriftLexer(charStream);
    CommonTokenStream tokenStream = new CommonTokenStream(lexer);
    AntlrThriftParser antlrParser = new AntlrThriftParser(tokenStream);

    ThriftListener thriftListener = new ThriftListener(tokenStream, reporter, location);

    ParseTreeWalker walker = new ParseTreeWalker();
    walker.walk(thriftListener, antlrParser.document());

    if (reporter.hasError()) {
        String errorReports = Joiner.on('\n').join(reporter.formattedReports());
        String message = String.format(Locale.US, "Syntax errors in %s:\n%s", location, errorReports);
        throw new IllegalStateException(message);
    }

    return thriftListener.buildFileElement();
}

@Override
public Sequence eval(final Sequence[] args, final Sequence contextSequence) throws XPathException {
    final ANTLRInputStream is = new ANTLRInputStream(args[0].getStringValue());

    final CorpusQLLexer lexer = new CorpusQLLexer(is);
    final CommonTokenStream tokens = new CommonTokenStream(lexer);
    final CorpusQLParser parser = new CorpusQLParser(tokens);

    final ParseTree tree = parser.query();

    final MemTreeBuilder builder = new MemTreeBuilder();
    builder.startDocument();

    final CorpusQLXMLVisitor xmlVisitor = new CorpusQLXMLVisitor(builder);
    xmlVisitor.visit(tree);

    builder.endDocument();

    return builder.getDocument();
}

public Boolean validateJSON()
{

    ANTLRInputStream input = new ANTLRInputStream(json_template);
    JSONLexer lexer = new JSONLexer(input);
    CommonTokenStream tokens = new CommonTokenStream(lexer);
    JSONParser parser = new JSONParser(tokens);

    BuildJsonConfigErrorListener errorListener = new BuildJsonConfigErrorListener();
    parser.removeErrorListeners();
    parser.addErrorListener(errorListener);

    ParseTree tree = parser.json();
    BuildJsonParseTreeConfigVisitor eval = new BuildJsonParseTreeConfigVisitor(inputSchema);
    eval.visit(tree);
    return true;
}

public static <L extends Lexer, P extends Parser> P newParser(
    Function<CharStream, L> lexerFactory,
    Function<TokenStream, P> parserFactory,
    String input,
    boolean useBailErrorStrategy,
    boolean removeErrorListeners) {
  CharStream charStream = new ANTLRInputStream(input);
  L lexer = lexerFactory.apply(charStream);
  if (removeErrorListeners) {
    lexer.removeErrorListeners();
  }

  TokenStream tokenStream = new CommonTokenStream(lexer);
  P parser = parserFactory.apply(tokenStream);
  if (useBailErrorStrategy) {
    parser.setErrorHandler(new BailErrorStrategy());
  }
  if (removeErrorListeners) {
    parser.removeErrorListeners();
  }

  return parser;
}

public SGFReader(String sgfString) {
    ANTLRInputStream inputStream = new ANTLRInputStream(sgfString);
    SGFLexer lexer = new SGFLexer(inputStream);
    CommonTokenStream tokens = new CommonTokenStream(lexer);
    parser = new SGFParser(tokens);

    visitor = new SGFVisitor();
}

@Before
public void commonSetup() {
    ANTLRInputStream inputStream = new ANTLRInputStream("");
    sgfLexer = new SGFLexer(inputStream);
    CommonTokenStream tokenStream = new CommonTokenStream(sgfLexer);

    parser = new SGFParser(tokenStream);

    StringWriter errorWriter = new StringWriter();
    errorListener = new SGFErrorListener(errorWriter);
    parser.removeErrorListeners();
    parser.addErrorListener(errorListener);

    visitor = new SGFVisitor();
}

/**
 * Parses the expression using antlr, aborts the parsing on the first error.
 *
 * @param expression
 *            an expression, not {@code null}
 * @return a {@link ParseTree} for further processing
 * @throws ExpressionException
 */
ParseTree parseExpression(String expression) throws ExpressionException {
    if (expression == null) {
        throw new IllegalArgumentException("expression must not be null");
    }
    ANTLRInputStream in = new ANTLRInputStream(expression);
    FunctionExpressionLexer lexer = new CapitulatingFunctionExpressionLexer(in);
    CommonTokenStream tokens = new CommonTokenStream(lexer);
    FunctionExpressionParser parser = new FunctionExpressionParser(tokens);

    parser.removeErrorListeners();
    lexer.removeErrorListeners();
    ExpressionErrorListener listener = new ExpressionErrorListener();
    parser.addErrorListener(listener);
    lexer.addErrorListener(listener);
    parser.setErrorHandler(new CapitulatingErrorStrategy());

    try {
        ParseTree tree = parser.operationExp();
        if (listener.containsError()) {
            throw new ExpressionException(listener.getErrorMessage(), listener.getErrorLine());
        } else {
            return tree;
        }
    } catch (CapitulatingRuntimeException e) {
        if (listener.containsError()) {
            throw new ExpressionException(listener.getErrorMessage(), listener.getErrorLine());
        } else {
            // cannot happen since the parser and lexer always register the error before trying
            // to recover
            throw new ExpressionException("Unknown error");
        }
    }

}

/**
 * Constructor
 * @param styledDocument the StyledDocument instance to analyse
 */
public BooleanExpANTLRHandler(StyledDocument styledDocument) {
    try {
        this.styledDocument = styledDocument;
        lexer = new FormalPropertyDescriptionLexer(new ANTLRInputStream(
                styledDocument.getText(0, styledDocument.getLength())));
        CommonTokenStream ts = new CommonTokenStream(lexer);
        parser = new FormalPropertyDescriptionParser(ts);
    } catch (BadLocationException ex) {
        Logger.getLogger(BooleanExpANTLRHandler.class.getName()).log(Level.SEVERE, null, ex);
    }
}

/**
 * Method that parses the current input of a BooleanExpCodeArea and returns a
 * FormalPropertyDescriptionParser.BooleanExpListContext object which can then be used for building an AST
 * out of the input.
 * @return a BooleanExpListContext node from the ANTLR generated ParseTree.
 */
public FormalPropertyDescriptionParser.BooleanExpListContext getParseTree() {
    String text = null;
    try {
        text = styledDocument.getText(0, styledDocument.getLength());
    } catch (BadLocationException e) {
        e.printStackTrace();
    }
    lexer.setInputStream(new ANTLRInputStream(text));
    CommonTokenStream ts = new CommonTokenStream(lexer);
    parser.setTokenStream(ts);
    return parser.booleanExpList();
}