Refine search
/** * Execute statements from an include file */ void include(String content) throws Exception { InputStream input = new ByteArrayInputStream(content.getBytes("UTF-8")); HplsqlLexer lexer = new HplsqlLexer(new ANTLRInputStream(input)); CommonTokenStream tokens = new CommonTokenStream(lexer); HplsqlParser parser = new HplsqlParser(tokens); ParseTree tree = parser.program(); visit(tree); }
public int LT(int i) { return LA(i); }
@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(); }
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(); }
public XPathElement[] split(String path) { ANTLRInputStream in; try { in = new ANTLRInputStream(new StringReader(path)); lexer.removeErrorListeners(); lexer.addErrorListener(new XPathLexerErrorListener()); CommonTokenStream tokenStream = new CommonTokenStream(lexer); try { tokenStream.fill(); List<Token> tokens = tokenStream.getTokens();
private static TokenSource getLexer(String sql, Set<String> terminators) { requireNonNull(sql, "sql is null"); CharStream stream = new CaseInsensitiveStream(new ANTLRInputStream(sql)); return new DelimiterLexer(stream, terminators); }
private static ParserRuleContext parseTypeCalculation(String calculation) { TypeCalculationLexer lexer = new TypeCalculationLexer(new CaseInsensitiveStream(new ANTLRInputStream(calculation))); CommonTokenStream tokenStream = new CommonTokenStream(lexer); TypeCalculationParser parser = new TypeCalculationParser(tokenStream); lexer.removeErrorListeners(); lexer.addErrorListener(ERROR_LISTENER); parser.removeErrorListeners(); parser.addErrorListener(ERROR_LISTENER); ParserRuleContext tree; try { // first, try parsing with potentially faster SLL mode parser.getInterpreter().setPredictionMode(PredictionMode.SLL); tree = parser.typeCalculation(); } catch (ParseCancellationException ex) { // if we fail, parse with LL mode tokenStream.reset(); // rewind input stream parser.reset(); parser.getInterpreter().setPredictionMode(PredictionMode.LL); tree = parser.typeCalculation(); } return tree; }
@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()); }
public FormatListener() { this.lexer = new FeatureResultsLexer( new ANTLRInputStream( "" ) ); this.parser = new FeatureResultsParser( new CommonTokenStream( lexer ) ); this.walker = new ParseTreeWalker(); this.parameterVerifier = new ParameterVerifier(); this.resultsVerifier = new ResultsVerifier(); }
public static Operator gen(GeneratorContext ctx, Planner cursorMeta, String expr) { CharStream cs = new ANTLRInputStream(expr); MysqlLexer lexer = new MysqlLexer(cs); CommonTokenStream tokens = new CommonTokenStream(lexer); tokens.setTokenSource(lexer); MysqlParser parser = new MysqlParser(tokens); parser.setErrorHandler(new BailErrorStrategy()); MysqlParser.ExprContext rule = parser.expr(); return gen(ctx, cursorMeta, rule); }
public boolean parseResults( String value ) { resetListeners( resultsVerifier ); lexer.setInputStream( new ANTLRInputStream( value ) ); walker.walk( resultsVerifier, parser.value() ); return resultsVerifier.getOkAndReset(); }
public static CommonTokenStream tokenizeANTLRGrammar(String text) { ANTLRInputStream input = new ANTLRInputStream(text); ANTLRv4Lexer lexer = new ANTLRv4Lexer(input); CommonTokenStream tokens = new TokenStreamSubset(lexer); tokens.fill(); return tokens; }
/** consume() ahead until p==index; can't just set p=index as we must * update line and charPositionInLine. If we seek backwards, just set p */ @Override public void seek(int index) { if ( index<=p ) { p = index; // just jump; don't update stream state (line, ...) return; } // seek forward, consume until p hits index or n (whichever comes first) index = Math.min(index, n); while ( p<index ) { consume(); } }
public ScriptDefinition assemble(InputStream in) throws IOException rs2asmLexer lexer = new rs2asmLexer(new ANTLRInputStream(in)); CommonTokenStream tokens = new CommonTokenStream(lexer); ParseTreeWalker walker = new ParseTreeWalker(); walker.walk(labelVisitor, progContext); walker.walk(listener, progContext);
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 static void printLex(InputStream in) throws Exception { Java7Lexer lex = new Java7Lexer(new ANTLRInputStream(in)); CommonTokenStream tokens = new CommonTokenStream(lex); tokens.fill(); for (Token token : tokens.getTokens()) { System.out.println(token.getType() + " " + token.getText()); } }
public static void smaliFile(String name, InputStream in, DexFileVisitor dcv) throws IOException { try (InputStreamReader reader = new InputStreamReader(in, StandardCharsets.UTF_8)) { ANTLRInputStream is = new ANTLRInputStream(reader); is.name = name; smali0(dcv, is); } }
try { CharStream charStream = new ANTLRInputStream(expression); PQL2Lexer lexer = new PQL2Lexer(charStream); lexer.setTokenFactory(new CommonTokenFactory(true)); ParseTreeWalker walker = new ParseTreeWalker(); Pql2AstListener listener = new Pql2AstListener(expression); walker.walk(listener, parseTree);
public boolean parseParameter( String value ) { resetListeners( parameterVerifier ); lexer.setInputStream( new ANTLRInputStream( value ) ); walker.walk( parameterVerifier, parser.value() ); return parameterVerifier.getOkAndReset(); }
@Override public void consume() { input.consume(); }