javax.persistence.criteria.Order#org.antlr.v4.runtime.tree.ParseTree源码实例Demo

public static void main(String[] args) {
		String prop = "id=\"parrt\"\n";
		ANTLRInputStream input = new ANTLRInputStream(prop);
		PropertyFileLexer lexer = new PropertyFileLexer(input);
		CommonTokenStream tokens = new CommonTokenStream(lexer);
		PropertyFileParser parser = new PropertyFileParser(tokens);
		ParseTree tree = parser.file();
		System.out.println(tree.toStringTree(parser));
//		Trees.inspect(tree, parser);

		ParseTreeWalker walker = new ParseTreeWalker();
		PropertyFileLoader loader = new PropertyFileLoader();
		walker.walk(loader, tree);

		System.out.println(loader.props);
	}
 

/**
 * Compiles input to write to to the writer
 *
 * @param query  input used for compiling
 * @param writer writer that receives the result of compilation
 * @throws CompilationException if compilation fails
 */
@Override
public void compile(FlairQuery query, Writer writer) throws CompilationException {
	try {
		final ANTLRInputStream input = new ANTLRInputStream(query.getStatement());
		final FQLLexer lexer = new FQLLexer(input);
		lexer.removeErrorListeners();
		lexer.addErrorListener(new ThrowingErrorListener());

		final CommonTokenStream tokens = new CommonTokenStream(lexer);

		final FQLParser parser = new FQLParser(tokens);
		parser.removeErrorListeners();
		parser.addErrorListener(new ThrowingErrorListener());

		final ParseTree tree = parser.parse(); // begin parsing at init rule
		// Create a generic parse tree walker that can trigger callbacks
		final ParseTreeWalker walker = new ParseTreeWalker();
		// Walk the tree created during the parse, trigger callbacks
		listener = getListener(writer);
		walker.walk(listener, tree);
	} catch (Exception e) {
		throw new CompilationException(e);
	}
}
 

public static void print(final ParseTree node, final int level, CommonTokenStream stream) {
	final Interval sourceInterval = node.getSourceInterval();

	final Token firstToken = stream.get(sourceInterval.a);

	int line = firstToken.getLine();
	int charStart = firstToken.getCharPositionInLine();

	int endLine = line;
	int endChar = charStart + firstToken.getText().length();

	String data = "@(" + line + ":" + charStart + "," + endLine + ":" + endChar + ") with text: "
			+ firstToken.getText();
	final int tmp = level + 1;
	final StringBuilder sb = new StringBuilder();
	sb.append(StringUtils.repeat("\t", level));
	sb.append(node.getClass().getSimpleName() + ": " + data + " :" + node.getText());
	System.out.println(sb.toString());
	final int n = node.getChildCount();
	for (int i = 0; i < n; i++) {

		final ParseTree c = node.getChild(i);
		print(c, tmp, stream);

	}
}
 

@Test    // expression test 3
  public void test8() {

      String code = "a = 2 | 2 xor 2 * 2";
      String expected = "2 2 MUL 2 XOR 2 OR 0 MSTORE";

SerpentParser parser = ParserUtils.getParser(SerpentLexer.class,
		SerpentParser.class, code);
      ParseTree tree = parser.parse();

      String result = new SerpentToAssemblyCompiler().visit(tree);
      result = result.replaceAll("\\s+", " ");
      result = result.trim();

      assertEquals(expected, result);
  }
 

public static MysqlParser.ScriptContext parse(CharStream cs, int options) {
    MysqlLexer lexer = (options==1) ? new FuckedLexer(cs) : new MysqlLexer(cs);
    CommonTokenStream tokens = new CommonTokenStream(lexer);
    tokens.setTokenSource(lexer);
    MysqlParser parser = new MysqlParser(tokens);
    parser.getInterpreter().setPredictionMode(PredictionMode.SLL);
    parser.setErrorHandler(new BailErrorStrategy());
    boolean success = false;
    try {
        MysqlParser.ScriptContext script = parser.script();
        success = true;
        return script;
    }
    finally {
        if (!success && (parser.lastStatement != null)) {
            _log.debug("last passed statement: {}", ((ParseTree)parser.lastStatement).getText());
        }
    }
}
 

public String translateString(Translator trans, String markdown, String startRule) throws Exception {
	CharStream input = CharStreams.fromString(markdown);
	BookishLexer lexer = new BookishLexer(input);
	CommonTokenStream tokens = new CommonTokenStream(lexer);
	BookishParser parser = new BookishParser(tokens,null, 0);
	parser.removeErrorListeners();
	parser.addErrorListener(new ConsoleErrorListener() {
		@Override
		public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol, int line, int charPositionInLine, String msg, RecognitionException e) {
			msg = "Parsing author string: "+msg;
			super.syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, e);
		}
	});
	Method startMethod = BookishParser.class.getMethod(startRule, (Class[])null);
	ParseTree doctree = (ParseTree)startMethod.invoke(parser, (Object[])null);

	OutputModelObject omo = trans.visit(doctree); // get single chapter

	ModelConverter converter = new ModelConverter(trans.templates);
	ST outputST = converter.walk(omo);
	return outputST.render();
}
 

/**
 * BdsCompiler program
 */
public ProgramUnit compile() {
	if (debug) log("Loading file: '" + programFileName + "'");

	// Convert to AST
	ParseTree tree = parseProgram();
	if (tree == null) return null;

	// Convert to BdsNodes
	programUnit = createModel(tree);
	if (programUnit == null) return null;

	CompilerMessages.reset();

	// Add local symbols
	if (addSymbols()) return null;

	// Type-checking
	if (typeChecking()) return null;

	// Cleanup: Free some memory by reseting structure we won't use any more
	TypeCheckedNodes.get().reset();

	// OK
	return programUnit;
}
 

@Override
protected ParseTree parse(Parser parser, IElementType root) {
	int startRule;
	if (root instanceof IFileElementType) {
		startRule = ANTLRv4Parser.RULE_grammarSpec;
	}
	else if (root == ANTLRv4TokenTypes.TOKEN_ELEMENT_TYPES.get(ANTLRv4Lexer.TOKEN_REF)
		|| root == ANTLRv4TokenTypes.TOKEN_ELEMENT_TYPES.get(ANTLRv4Lexer.RULE_REF)) {
		startRule = ANTLRv4Parser.RULE_atom;
	}
	else {
		startRule = Token.INVALID_TYPE;
	}

	switch (startRule) {
	case ANTLRv4Parser.RULE_grammarSpec:
		return ((ANTLRv4Parser) parser).grammarSpec();

	case ANTLRv4Parser.RULE_atom:
		return ((ANTLRv4Parser) parser).atom();

	default:
		String ruleName = ANTLRv4Parser.ruleNames[startRule];
		throw new UnsupportedOperationException(String.format("cannot start parsing using root element %s", root));
	}
}
 

private Collection<YangExpr> parsePredicate(final PredicateContext expr) {
    final ParseTree first = expr.getChild(0);
    if (first instanceof LeafListPredicateContext) {
        return ImmutableSet.of(YangBinaryOperator.EQUALS.exprWith(YangLocationPath.self(),
            parseEqStringValue(getChild(((LeafListPredicateContext) first)
                .getChild(LeafListPredicateExprContext.class, 0), EqQuotedStringContext.class, 1))));
    } else if (first instanceof PosContext) {
        return ImmutableSet.of(YangBinaryOperator.EQUALS.exprWith(FunctionSupport.POSITION,
            mathSupport.createNumber(((PosContext) first).getToken(instanceIdentifierParser.PositiveIntegerValue, 0)
                .getText())));
    }

    final int length = expr.getChildCount();
    final List<YangExpr> ret = new ArrayList<>(length);
    for (int i = 0; i < length; ++i) {
        final KeyPredicateExprContext pred = getChild(expr, KeyPredicateContext.class, i)
                .getChild(KeyPredicateExprContext.class, 0);
        ret.add(YangBinaryOperator.EQUALS.exprWith(
            createChildExpr(getChild(pred, NodeIdentifierContext.class, 0)),
            parseEqStringValue(getChild(pred, EqQuotedStringContext.class, 1))));

    }

    return ret;
}
 

@Test
public void test() {

	final CharStream charStream = CharStreams.fromString("\r\nSELECT\r\n 1");

	final TSqlLexer lexer = new TSqlLexer(charStream);

	final CommonTokenStream stream = new CommonTokenStream(lexer);

	stream.fill();
	TSqlParser parser = new TSqlParser(stream);
	ParseTree child = parser.tsql_file().getChild(0);
	DefaultLinesProvider lines = new DefaultLinesProvider(stream);
	int line = lines.getLine(new ParsedNode(child));
	Assert.assertEquals(2, line);

}
 

private static void generateAST(RuleContext ctx, boolean verbose, int indentation) {
       boolean toBeIgnored = !verbose && ctx.getChildCount() == 1 && ctx.getChild(0) instanceof ParserRuleContext;

       if (!toBeIgnored) {
           String ruleName = Java8Parser.ruleNames[ctx.getRuleIndex()];
    LineNum.add(Integer.toString(indentation));
           Type.add(ruleName);
           Content.add(ctx.getText());
}
       for (int i = 0; i < ctx.getChildCount(); i++) {
           ParseTree element = ctx.getChild(i);
           if (element instanceof RuleContext) {
               generateAST((RuleContext) element, verbose, indentation + (toBeIgnored ? 0 : 1));
           }
       }
   }
 

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);

	ST output = listener.file.getTemplate();
	System.out.println(output.render());
}
 

private Object run(GeneratorContext gctx, VdmContext ctx, Parameters params, StmtContext rule) {
    ParseTree stmt = rule.getChild(0);
    Generator<ParseTree> generator = InstructionGenerator.getGenerator(stmt);
    Instruction code = generator.gen(gctx, stmt);
    if (code == null) {
        return null;
    }
    try {
        Object result = code.run(ctx, params, 0);
        return result;
    }
    finally {
        if (generator instanceof DdlGenerator<?>) {
            // mysql commits after every ddl statement
            ctx.getSession().commit();
        }
    }
}
 

@Override
@SuppressWarnings("unchecked")
public void exitVerboseBetweenQuery(CQNGrammarParser.VerboseBetweenQueryContext ctx) {
    Attribute<O, Comparable> attribute = queryParser.getAttribute(ctx.attributeName(), Comparable.class);
    List<? extends ParseTree> queryParameters = ctx.queryParameter(), booleanParameters = ctx.BooleanLiteral();
    Comparable lowerValue = queryParser.parseValue(attribute, queryParameters.get(0));
    boolean lowerInclusive = queryParser.parseValue(Boolean.class, booleanParameters.get(0));
    Comparable upperValue = queryParser.parseValue(attribute, queryParameters.get(1));
    boolean upperInclusive = queryParser.parseValue(Boolean.class, booleanParameters.get(1));
    addParsedQuery(ctx, QueryFactory.between(attribute, lowerValue, lowerInclusive, upperValue, upperInclusive));
}
 

public <A> Attribute<O, A> getAttribute(ParseTree attributeNameContext, Class<A> expectedSuperType) {
    String attributeName = parseValue(String.class, attributeNameContext.getText());
    Attribute<O, ?> attribute = attributes.get(attributeName);
    if (attribute == null) {
        throw new IllegalStateException("No such attribute has been registered with the parser: " + attributeName);
    }
    if (!expectedSuperType.isAssignableFrom(attribute.getAttributeType())) {
        throw new IllegalStateException("Non-" + expectedSuperType.getSimpleName() + " attribute used in a query which requires a " + expectedSuperType.getSimpleName() + " attribute: " + attribute.getAttributeName());
    }
    @SuppressWarnings("unchecked")
    Attribute<O, A> result = (Attribute<O, A>) attribute;
    return result;
}
 

@Override
public WalkResult walk(ParseTree tree, String value) {
    String actualValue = getActualValue(tree, value);

    if (actualValue != null &&
        actualValue.toLowerCase().endsWith(desiredValue)) {
        return walkNextStep(tree, actualValue);
    }
    return null;
}
 

@Override
public WalkResult walk(ParseTree tree, String value) {
    String actualValue = getActualValue(tree, value);

    if (actualValue != null &&
        actualValue.equalsIgnoreCase(desiredValue)) {
        return walkNextStep(tree, actualValue);
    }
    return null;
}
 

private static void parseTypeSpec(DataType dataType, ParseTree tree) {
    if (tree == null) {
        return;
    }

    if (tree instanceof CParser.StructOrUnionContext) {
        return;
    }
    if (tree instanceof CParser.TypedefNameContext) {
        if (dataType.getType().isEmpty()) {
            dataType.appendTypeName(tree.getText());
        }
        return;
    }

    if (tree instanceof TerminalNode) {
        String value = tree.getText();
        if ("const".equals(value)) {
            dataType.setConst();
        } else if ("*".equals(value)) {
            dataType.increasePointerCount();
        } else {
            dataType.appendTypeName(value);
        }
        return;
    }

    for (int i = 0; i < tree.getChildCount(); i++) {
        parseTypeSpec(dataType, tree.getChild(i));
    }
}
 

private AST(AST parent, ParseTree tree, List<AST> children) {
  this.payload = getPayload(tree);
  this.children = children;
  if (parent == null) {
    walk(tree, this);
  }
  else {
    parent.children.add(this);
  }
}
 

private static void getText(StringBuilder sb, ParseTree tree) {
    if (tree instanceof TerminalNode) {
        sb.append("\"v\" : \"").append(tree.getText()).append('"');
        return;
    }
    sb.append('"');
    sb.append(tree.getClass().getSimpleName()).append("\" : {");
    for (int i = 0; i < tree.getChildCount(); i++) {
        getText(sb, tree.getChild(i));
        if (i < tree.getChildCount() - 1) {
            sb.append(',');
        }
    }
    sb.append('}');
}
 

public IParsedNode[] getSiblings() {
	final List<IParsedNode> nodes = new ArrayList<>();
	if (this.item == null || this.item.getParent() == null) {
		return nodes.toArray(new IParsedNode[0]);
	}
	ParseTree parseTreeItem = this.item.getParent();
	visit(nodes, parseTreeItem, 0);
	return nodes.toArray(new IParsedNode[0]);

}
 

/**
 * Invoked by 'switch' parsing
 * Return last index in tree that was parsed + 1
 */
protected int parse(ParseTree tree, int idx) {
	List<Statement> stats = new ArrayList<>();

	idx = findIndex(tree, "case", idx);
	if (idx < 0) return idx; // No case statements found
	lineAndPos(tree.getChild(idx));

	// Add 'case' expression
	idx++;
	expression = (Expression) factory(tree, idx++);
	if (isTerminal(tree, idx, ":")) idx++; // ':'

	// Add all statement
	while (idx < tree.getChildCount()) {
		if (isEndOfStatements(tree, idx)) break;
		Statement stat = (Statement) factory(tree, idx++);
		if (stat != null) stats.add(stat);
	}
	statements = stats.toArray(new Statement[0]);

	// Create an expression for comparing 'switch' expresion to 'case' expression
	exprEq = new ExpressionEq(this, null);
	exprEq.setLeft(((Switch) parent).getSwitchExpr());
	exprEq.setRight(expression);

	return idx;
}
 

/**
 * Parse child nodes between child[offset] and child[max]
 * Note:  child[max] is NOT parsed
 */
protected void parse(ParseTree tree, int offset, int max) {
	int num = (max - offset + 1) / 2; // Comma separated list of expressions
	expressions = new Expression[num];

	// Note, we add 2 to skip the next ',' separator
	for (int i = offset, j = 0; i < max; j++, i += 2) {
		if (lineNum <= 0) lineAndPos(tree.getChild(i)); // Set line number if not already done
		expressions[j] = (Expression) factory(tree, i);
	}
}
 

public void enterEveryRule(ParserRuleContext ctx) {
	// Find sibling lists that are children of this parent node
	Set<Class> completed = new HashSet<>(); // only count sibling list for each subtree type once
	for (int i = 0; i<ctx.getChildCount(); i++) {
		ParseTree child = ctx.getChild(i);

		if ( completed.contains(child.getClass()) ) continue; // avoid counting repeatedly
		completed.add(child.getClass());
		if ( child instanceof TerminalNode ) continue; // tokens are separators at most not siblings

		// found subtree child
		List<? extends ParserRuleContext> siblings =
			ctx.getRuleContexts(((ParserRuleContext) child).getClass());
		if ( siblings.size()>1 ) { // we found a list
			// check for separator by looking between first two siblings (assume all are same)
			ParserRuleContext first = siblings.get(0);
			ParserRuleContext second = siblings.get(1);
			List<Tree> children = Trees.getChildren(ctx);

			int firstIndex = children.indexOf(first);
			int secondIndex = children.indexOf(second);

			if ( firstIndex+1 == secondIndex ) continue; // nothing between first and second so no separator

			ParseTree between = ctx.getChild(firstIndex+1);
			if ( between instanceof TerminalNode ) { // is it a token?
				Token separator = ((TerminalNode) between).getSymbol();
				visitNonSingletonWithSeparator(ctx, siblings, separator);
			}
		}
	}
}
 

private OperatorNode<ExpressionOperator> readUnOp(ExpressionOperator op, ParseTree node, Scope scope) {
    assert (node instanceof TerminalNode) || (node.getChildCount() == 1) || (node instanceof UnaryExpressionContext);
    if (node instanceof TerminalNode) {
        return OperatorNode.create(op, convertExpr(node, scope));
    } else if (node.getChildCount() == 1) {
        return OperatorNode.create(op, convertExpr(node.getChild(0), scope));
    } else {
        return OperatorNode.create(op, convertExpr(node.getChild(1), scope));
    }
}
 

/**
 * <p>Getter for the field <code>constructs</code>.</p>
 *
 * @param m a {@link java.io.InputStream} object.
 * @return a {@link java.util.Map} object.
 * @throws com.sap.psr.vulas.FileAnalysisException if any.
 * @throws java.io.IOException if any.
 * @throws org.antlr.v4.runtime.RecognitionException if any.
 */
public Map<ConstructId, Construct> getConstructs(InputStream m) throws FileAnalysisException, IOException, RecognitionException {
	final ANTLRInputStream input = new ANTLRInputStream(m);
	final Python335Lexer lexer = new Python335Lexer(input);
	final CommonTokenStream tokens = new CommonTokenStream(lexer);
	final Python335Parser parser = new Python335Parser(tokens);
	final ParseTree root = parser.file_input();
	final ParseTreeWalker walker = new ParseTreeWalker();
	
	try {
		walker.walk(this, root);
	}
	catch(IllegalStateException ise) {
		throw new FileAnalysisException("Parser error", ise);
	}

	// Update module body after the parsing of the entire file
	if(this.stmts!=null && this.stmts.size()>0) {
		final StringBuffer b = new StringBuffer();
		for(String stmt: this.stmts)
			if(!stmt.trim().equals(""))
				b.append(stmt);
		this.constructs.get(this.module).setContent(b.toString());
	}
	
	return this.constructs;
}
 

@Override
public OutputModelObject visitList_item(BookishParser.List_itemContext ctx) {
	List<OutputModelObject> elements = new ArrayList<>();
	for (ParseTree el : ctx.children) {
		elements.add( visit(el) );
	}
	return new ListItem(elements);
}
 

private void parseBean(File sqlFile, GlobalConfig globalConfig) throws IOException {
    CharStream input = new ANTLRFileStream(sqlFile.getAbsolutePath());
    CreateTableLexer lexer = new CreateTableLexer(input);
    CommonTokenStream tokens = new CommonTokenStream(lexer);
    CreateTableParser parser = new CreateTableParser(tokens);
    ParseTree tree = parser.sql();

    ParseTreeWalker walker = new ParseTreeWalker();
    CreateTableListenerImpl extractor = new CreateTableListenerImpl(globalConfig);
    walker.walk(extractor, tree);
    beans = extractor.getTables();
}
 

@Override
public WalkResult walk(ParseTree tree, String value) {
    String actualValue = getActualValue(tree, value);
    if (actualValue != null) {
        // Sanitize the provided value
        actualValue = replaceString(actualValue, "_", ".");
        actualValue = replaceString(actualValue, "/", " ");
        actualValue = replaceString(actualValue, ", ", ".");
    }

    return walkNextStep(tree, actualValue);
}
 

@Override
public OutputModelObject visitFile(LangParser.FileContext ctx) {
	OutputFile file = new OutputFile();
	for (ParseTree child : ctx.children) {
		OutputModelObject m = visit(child);
		file.add(m);
	}
	return file;
}