private static String cleanJavadoc(JavadocParser.DocumentationContext ctx) { StringBuilder buff = new StringBuilder(); JavadocParserBaseListener listener = new JavadocParserBaseListener() { @Override public void enterDescriptionLine(final JavadocParser.DescriptionLineContext ctx) { buff.append(ctx.getText()).append("\n"); } }; ParseTreeWalker.DEFAULT.walk(listener, ctx); return buff.toString(); }
/** * Walks the provided parse tree using the list of listeners. * * @param listeners List of parse tree listeners. * @param tree Parse tree. */ private void walkParseTree(List<SwiftBaseListener> listeners, TopLevelContext tree) { ParseTreeWalker walker = new ParseTreeWalker(); listeners.forEach(listener -> walker.walk(listener, tree)); }
@VisibleForTesting static Expr parse(String in, ExprMacroTable macroTable, boolean withFlatten) { ExprLexer lexer = new ExprLexer(new ANTLRInputStream(in)); CommonTokenStream tokens = new CommonTokenStream(lexer); ExprParser parser = new ExprParser(tokens); parser.setBuildParseTree(true); ParseTree parseTree = parser.expr(); ParseTreeWalker walker = new ParseTreeWalker(); ExprListenerImpl listener = new ExprListenerImpl(parseTree, macroTable); walker.walk(listener, parseTree); return withFlatten ? flatten(listener.getAST()) : listener.getAST(); }
ParseTreeWalker.DEFAULT.walk(listener, parseJavadoc(file, doc)); return new DocItem(method, pattern, summary, text.toString(), params, returns.toString(), statusCodes(returns.toString()));
private static List<IdentifierContext> getDeclarationNames(TopLevelContext ctx, Declaration decl) { DeclarationListener listener = new DeclarationListener(decl); ParseTreeWalker walker = new ParseTreeWalker(); walker.walk(listener, ctx); return listener.getDeclarations(); }
private void extractIdentifier(ParserRuleContext ctx) { IdentifierExtractor extractor = new IdentifierExtractor(); ParseTreeWalker walker = new ParseTreeWalker(); walker.walk(extractor, ctx); if (extractor.getIdentifier() != null) { declarations.add(extractor.getIdentifier()); } }
private static List<SchemaChange> parseSQL(String currentDB, String sql) { ANTLRInputStream input = new ANTLRInputStream(sql); mysqlLexer lexer = new mysqlLexer(input); lexer.removeErrorListeners(); TokenStream tokens = new CommonTokenStream(lexer); LOGGER.debug("SQL_PARSE <- \"" + sql + "\""); mysqlParser parser = new mysqlParser(tokens); parser.removeErrorListeners(); MysqlParserListener listener = new MysqlParserListener(currentDB, tokens); ParseTree tree = parser.parse(); ParseTreeWalker.DEFAULT.walk(listener, tree); LOGGER.debug("SQL_PARSE -> " + tree.toStringTree(parser)); return listener.getSchemaChanges(); }
ParseTreeWalker.DEFAULT.walk(listener, parser.text()); return statusCodes;
public Pipeline parsePipeline(String id, String source) { final ParseContext parseContext = new ParseContext(false); final SyntaxErrorListener errorListener = new SyntaxErrorListener(parseContext); final RuleLangLexer lexer = new RuleLangLexer(new ANTLRInputStream(source)); lexer.removeErrorListeners(); lexer.addErrorListener(errorListener); final RuleLangParser parser = new RuleLangParser(new CommonTokenStream(lexer)); parser.setErrorHandler(new DefaultErrorStrategy()); parser.removeErrorListeners(); parser.addErrorListener(errorListener); final RuleLangParser.PipelineContext pipelineContext = parser.pipeline(); WALKER.walk(new PipelineAstBuilder(parseContext), pipelineContext); if (parseContext.getErrors().isEmpty()) { final Pipeline pipeline = parseContext.pipelines.get(0); return pipeline.withId(id); } throw new ParseException(parseContext.getErrors()); }
public List<Pipeline> parsePipelines(String pipelines) throws ParseException { final ParseContext parseContext = new ParseContext(false); final SyntaxErrorListener errorListener = new SyntaxErrorListener(parseContext); final RuleLangLexer lexer = new RuleLangLexer(new ANTLRInputStream(pipelines)); lexer.removeErrorListeners(); lexer.addErrorListener(errorListener); final RuleLangParser parser = new RuleLangParser(new CommonTokenStream(lexer)); parser.setErrorHandler(new DefaultErrorStrategy()); parser.removeErrorListeners(); parser.addErrorListener(errorListener); final RuleLangParser.PipelineDeclsContext pipelineDeclsContext = parser.pipelineDecls(); WALKER.walk(new PipelineAstBuilder(parseContext), pipelineDeclsContext); if (parseContext.getErrors().isEmpty()) { return parseContext.pipelines; } throw new ParseException(parseContext.getErrors()); }
public List<DocItem> collect(Path file) throws IOException { this.file = file; doc = new ArrayList<>(); CharStream input = CharStreams.fromPath(file, StandardCharsets.UTF_8); FuzzyDocLexer lexer = new FuzzyDocLexer(input); ANTLRErrorListener error = errorListener(LoggerFactory.getLogger(DocCollector.class), file); lexer.removeErrorListeners(); lexer.addErrorListener(error); TokenStream tokens = new CommonTokenStream(lexer); FuzzyDocParser parser = new FuzzyDocParser(tokens); parser.removeErrorListeners(); parser.addErrorListener(error); ParseTreeWalker.DEFAULT.walk(this, parser.source()); return doc; }
private AutocompleteResult find(String txt, int cur, ClassLoader l, Imports imports) { registry = AutocompleteRegistryFactory.createRegistry(cps); ClassUtils cu = createClassUtils(l); setup(cu, registry); AutocompleteRegistryFactory.addDefaultImports(cu, registry, imports.toListOfStrings(), cps); Lexer lexer = new JavaLexer(new ANTLRInputStream(txt)); CommonTokenStream tokens = new CommonTokenStream(lexer); // Create a parser that reads from the scanner JavaParser parser = new JavaParser(tokens); parser.removeErrorListeners(); // start parsing at the compilationUnit rule ParserRuleContext t = parser.compilationUnit(); ParseTreeWalker walker = new ParseTreeWalker(); List<AutocompleteCandidate> q = new ArrayList<AutocompleteCandidate>(); JavaImportDeclarationCompletion extractor = new JavaImportDeclarationCompletion(txt, cur, registry, cps, cu); JavaNameBuilder extractor2 = new JavaNameBuilder(registry, cu); JavaNodeCompletion extractor3 = new JavaNodeCompletion(txt, cur, registry, cu); walker.walk(extractor, t); if (extractor.getQuery() != null) q.addAll(extractor.getQuery()); walker.walk(extractor2, t); walker.walk(extractor3, t); if (extractor3.getQuery() != null) q.addAll(extractor3.getQuery()); List<String> ret = registry.searchCandidates(q); if (!ret.isEmpty()) { return new AutocompleteResult(ret, getStartIndex(extractor, extractor2, extractor3)); } return findAutocompleteResult(txt, cur, cu); }
GroovyNodeCompletion extractor3 = new GroovyNodeCompletion(txt, cur, registry, cu); walker.walk(extractor, t); if (extractor.getQuery() != null) q.addAll(extractor.getQuery()); walker.walk(extractor2, t); walker.walk(extractor3, t); if (extractor3.getQuery() != null) q.addAll(extractor3.getQuery());
@Override public TransformExpressionTree compileToExpressionTree(String expression) { CharStream charStream = new ANTLRInputStream(expression); PQL2Lexer lexer = new PQL2Lexer(charStream); lexer.setTokenFactory(new CommonTokenFactory(true)); TokenStream tokenStream = new UnbufferedTokenStream<CommonToken>(lexer); PQL2Parser parser = new PQL2Parser(tokenStream); parser.setErrorHandler(new BailErrorStrategy()); // Parse ParseTree parseTree = parser.expression(); ParseTreeWalker walker = new ParseTreeWalker(); Pql2AstListener listener = new Pql2AstListener(expression); walker.walk(listener, parseTree); return new TransformExpressionTree(listener.getRootNode()); }
@Override public void parse(String ddlContent, Tables databaseTables) { this.databaseTables = databaseTables; CodePointCharStream ddlContentCharStream = CharStreams.fromString(ddlContent); L lexer = createNewLexerInstance(new CaseChangingCharStream(ddlContentCharStream, isGrammarInUpperCase())); P parser = createNewParserInstance(new CommonTokenStream(lexer)); dataTypeResolver = initializeDataTypeResolver(); // remove default console output printing error listener parser.removeErrorListener(ConsoleErrorListener.INSTANCE); ParsingErrorListener parsingErrorListener = new ParsingErrorListener(AbstractDdlParser::accumulateParsingFailure); parser.addErrorListener(parsingErrorListener); ParseTree parseTree = parseTree(parser); if (parsingErrorListener.getErrors().isEmpty()) { antlrDdlParserListener = createParseTreeWalkerListener(); if (antlrDdlParserListener != null) { ParseTreeWalker.DEFAULT.walk(antlrDdlParserListener, parseTree); if (throwErrorsFromTreeWalk && !antlrDdlParserListener.getErrors().isEmpty()) { throwParsingException(antlrDdlParserListener.getErrors()); } } } else { throwParsingException(parsingErrorListener.getErrors()); } }
walker.walk(listener, parseTree);
/** * Parse the raw EQL query and apply it to the supplied query. */ public static <T> void parse(String raw, SpiQuery<T> query) { EQLLexer lexer = new EQLLexer(CharStreams.fromString(raw)); CommonTokenStream tokens = new CommonTokenStream(lexer); EQLParser parser = new EQLParser(tokens); parser.addErrorListener(errorListener); EQLParser.Select_statementContext context = parser.select_statement(); EqlAdapter<T> adapter = new EqlAdapter<>(query); ParseTreeWalker walker = new ParseTreeWalker(); walker.walk(adapter, context); query.simplifyExpressions(); }
public void walk(ParseTreeListener listener, ParseTree t) { if ( t instanceof ErrorNode) { listener.visitErrorNode((ErrorNode)t); return; } else if ( t instanceof TerminalNode) { listener.visitTerminal((TerminalNode)t); return; } RuleNode r = (RuleNode)t; enterRule(listener, r); int n = r.getChildCount(); for (int i = 0; i<n; i++) { walk(listener, r.getChild(i)); } exitRule(listener, r); }