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

public static void main(String[] args) {
    String code =
        "int x;\n" +
        "A b;\n";
    ANTLRInputStream input = new ANTLRInputStream(code);
    LangLexer lexer = new LangLexer(input);
    CommonTokenStream tokens = new CommonTokenStream(lexer);
    LangParser parser = new LangParser(tokens);
    ParseTree tree = parser.file(); // start up

    System.out.println(tree.toStringTree(parser));

    ParseTreeWalker walker = new ParseTreeWalker();
    Gen listener = new Gen();
    walker.walk(listener, tree);

    System.out.println(listener.file.toString());
}

/**
 * Processes an {@link org.antlr.v4.runtime.ANTLRInputStream}.
 *
 * @param inputStream The input stream.
 * @return The document.
 *
 * @throws com.torchmind.candle.api.error.CandleException when lexing or parsing fails.
 */
@Nonnull
protected Candle read (@Nonnull ANTLRInputStream inputStream) throws CandleException {
        try {
                CandleLexer lexer = new CandleLexer (inputStream);
                lexer.addErrorListener (new LexerErrorListener ());

                CommonTokenStream tokenStream = new CommonTokenStream (lexer);
                CandleParser parser = new CandleParser (tokenStream);
                parser.setErrorHandler (new ParserErrorStrategy ());

                ParseTreeWalker walker = new ParseTreeWalker ();
                CandleListener listener = new CandleListener (this);

                this.clear ();
                walker.walk (listener, parser.candle ());
                return this;
        } catch (RuntimeException ex) {
                if (ex.getCause () instanceof CandleException) { throw ((CandleException) ex.getCause ()); }
                throw ex;
        }
}

@Override
protected void parse(File sourceFile) throws ParseException {
    try {
        GrammarConfiguration configuration = LanguageBase.createGrammarConfiguration(this,
                sourceFile,
                CPP14Lexer.class,
                CPP14Parser.class,
                new DefaultErrorListener(sourceFile));
        ((CPP14Lexer) configuration.lexer).setSupport(this);
        ParseTree tree = ((CPP14Parser) configuration.parser).translationunit();
        ParseTreeWalker walker = new ParseTreeWalker();
        walker.walk(new CPPParseTreeListener(this), tree);
    } catch (Exception e) {
        throw new ParseException(e);
    }

}

@Override
protected void parse(File sourceFile) throws ParseException {
    try {
        GrammarConfiguration configuration = LanguageBase.createGrammarConfiguration(this,
                sourceFile,
                ObjCLexer.class,
                ObjCParser.class,
                new DefaultErrorListener(sourceFile));
        ParseTree tree = ((ObjCParser) configuration.parser).translation_unit();
        ParseTreeWalker walker = new ParseTreeWalker();
        walker.walk(new ObjCParseTreeListener(this), tree);
    } catch (Exception e) {
        throw new ParseException(e);
    }

}

@Override
public void graph() {
    // first pass to extract defs
    super.graph();

    // second pass to extract refs
    firstPass = false;
    for (Map.Entry<File, ParseTree> entry : trees.entrySet()) {
        processingPath.push(PathUtil.relativizeCwd(entry.getKey().toPath()));
        LOGGER.info("Extracting refs from {}", getCurrentFile());
        try {
            ParseTreeWalker walker = new ParseTreeWalker();
            walker.walk(new SwiftParseTreeListener(this), entry.getValue());
        } catch (Exception e) {
            LOGGER.error("Failed to process {} - unexpected error", getCurrentFile(), e);
        } finally {
            processingPath.pop();
        }
    }
}

@Override
protected void parse(File sourceFile) throws ParseException {
    try {
        GrammarConfiguration configuration = LanguageBase.createGrammarConfiguration(
                this,
                sourceFile,
                SwiftLexer.class,
                SwiftParser.class,
                new DefaultErrorListener(sourceFile));
        ParseTree tree = ((SwiftParser) configuration.parser).top_level();
        ParseTreeWalker walker = new ParseTreeWalker();
        walker.walk(new SwiftParseTreeListener(this), tree);
        trees.put(sourceFile, tree);
    } catch (Exception e) {
        throw new ParseException(e);
    }
}

/**
 * Fire off the full parse of the input and return the resulting DOM object.
 * Any errors encountered during the parse will be logged in the Log class.
 * <p>
 * @see Log
 * <p>
 * @return the DOM built by parsing the string or file.
 */
@Override
public DOM build() {
  ParserErrorListener parserListener = new ParserErrorListener(dom);
  ISELexer lexer = new ISELexer(ais);
  lexer.removeErrorListeners();
  lexer.addErrorListener(parserListener);

  CommonTokenStream tokenStream = new CommonTokenStream(lexer);

  ISEParser parser = new ISEParser(tokenStream);
  parser.removeErrorListeners();
  parser.addErrorListener(parserListener);

  ParseTreeWalker ptw = new ParseTreeWalker();
  tokens = parser.getTokenStream();
  ParseTree pt = parser.document();
  ptw.walk(this, pt);
  dom.index();
  return dom;
}

@Override
public void parse(String sql) throws SQLSyntaxErrorException {
    try {
        CharStream input = new CaseInsensitiveInputStream(sql);
        ANTLRErrorListener errorListener = new InternalErrorListener();
        SQLLexer sqlLexer = new SQLLexer(input);
        sqlLexer.removeErrorListeners();
        sqlLexer.addErrorListener(errorListener);
        CommonTokenStream commonTokenStream = new CommonTokenStream(sqlLexer);
        SQLParser sqlParser = new SQLParser(commonTokenStream);
        sqlParser.removeErrorListeners();
        sqlParser.addErrorListener(errorListener);
        ParseTree parseTree = sqlParser.query();
        ParseTreeWalker walker = new ParseTreeWalker();
        walker.walk(this, parseTree);
    } catch (ParseException e) {
        errors.add(e.getMessage());
    }
    if (!errors.isEmpty()) {
        String message = errors.stream().collect(Collectors.joining("; "));
        throw new SQLSyntaxErrorException(message);
    }
}

public List<String> getQueries() throws SQLDataException {
    CharStream input = new ANTLRInputStream(sqlWithPlaceholders);
    ANTLRErrorListener errorListener = new InternalErrorListener();
    ParametersLexer parametersLexer = new ParametersLexer(input);
    parametersLexer.removeErrorListeners();
    parametersLexer.addErrorListener(errorListener);
    CommonTokenStream commonTokenStream = new CommonTokenStream(parametersLexer);
    ParametersParser parametersParser = new ParametersParser(commonTokenStream);
    parametersParser.removeErrorListeners();
    parametersParser.addErrorListener(errorListener);
    ParseTree parseTree = parametersParser.queries();
    ParseTreeWalker walker = new ParseTreeWalker();
    walker.walk(this, parseTree);
    if (exception.isPresent()) {
        throw exception.get();
    }
    return preparedQueries;
}

public Archetype parse(CharStream stream) {
    errors = new ADLParserErrors();
    errorListener = new ADLErrorListener(errors);

    lexer = new AdlLexer(stream);
    lexer.addErrorListener(errorListener);
    parser = new AdlParser(new CommonTokenStream(lexer));
    parser.addErrorListener(errorListener);
    tree = parser.adl(); // parse
    //System.out.println(tree.toStringTree(parser));

    ADLListener listener = new ADLListener(errors);
    walker= new ParseTreeWalker();
    walker.walk(listener, tree);
    Archetype result = listener.getArchetype();
    if(modelConstraintImposer != null && result.getDefinition() != null) {
        modelConstraintImposer.imposeConstraints(result.getDefinition());
    }
    return result;

}