/** * The discovery of a rule node, involves sending two events: the generic * {@link ParseTreeListener#enterEveryRule} and a * {@link RuleContext}-specific event. First we trigger the generic and then * the rule specific. We to them in reverse order upon finishing the node. */ protected void enterRule(ParseTreeListener listener, RuleNode r) { ParserRuleContext ctx = (ParserRuleContext)r.getRuleContext(); listener.enterEveryRule(ctx); ctx.enterRule(listener); }
/** Is {@code t} {@code (expr <expr>)} subtree? */ protected RuleTagToken getRuleTagToken(ParseTree t) { if ( t instanceof RuleNode ) { RuleNode r = (RuleNode)t; if ( r.getChildCount()==1 && r.getChild(0) instanceof TerminalNode ) { TerminalNode c = (TerminalNode)r.getChild(0); if ( c.getSymbol() instanceof RuleTagToken ) { // System.out.println("rule tag subtree "+t.toStringTree(parser)); return (RuleTagToken)c.getSymbol(); } } } return null; }
int ruleIndex = ruleNode.getRuleContext().getRuleIndex(); if (ruleIndex == EsperEPL2GrammarParser.RULE_number) { return parseNumber(ruleNode, 1); } else if (ruleIndex == EsperEPL2GrammarParser.RULE_numberconstant) { RuleNode number = findChildRuleByType(ruleNode, EsperEPL2GrammarParser.RULE_number); if (ruleNode.getChildCount() > 1) { if (ASTUtil.isTerminatedOfType(ruleNode.getChild(0), EsperEPL2GrammarLexer.MINUS)) { return parseNumber(number, -1); return StringValue.parseString(node.getText()); } else if (ruleIndex == EsperEPL2GrammarParser.RULE_constant) { return parse(ruleNode.getChild(0));
private static int getSingleChildTokenType(RuleNode node) { return ((TerminalNode) node.getChild(0)).getSymbol().getType(); } }
static <C, T extends RuleNode, V extends GherkinBaseVisitor<C>> List<C> visitOptionalNode(T node, V visitor) { if (node == null) { return Collections.emptyList(); } else { return Collections.singletonList(node.accept(visitor)); } } }
private static Object parseNumber(RuleNode number, int factor) { int tokenType = getSingleChildTokenType(number); if (tokenType == EsperEPL2GrammarLexer.IntegerLiteral) { return parseIntLongByte(number.getText(), factor); } else if (tokenType == EsperEPL2GrammarLexer.FloatingPointLiteral) { String numberText = number.getText(); if (numberText.endsWith("f") || numberText.endsWith("F")) { return Float.parseFloat(number.getText()) * factor; } else { return Double.parseDouble(number.getText()) * factor; } } throw ASTWalkException.from("Encountered unrecognized constant", number.getText()); }
int ruleIndex = ruleNode.getRuleContext().getRuleIndex(); if (ruleIndex == EsperEPL2GrammarParser.RULE_number) { return parseNumber(ruleNode, 1); } else if (ruleIndex == EsperEPL2GrammarParser.RULE_numberconstant) { RuleNode number = findChildRuleByType(ruleNode, EsperEPL2GrammarParser.RULE_number); if (ruleNode.getChildCount() > 1) { if (ASTUtil.isTerminatedOfType(ruleNode.getChild(0), EsperEPL2GrammarLexer.MINUS)) { return parseNumber(number, -1); return StringValue.parseString(node.getText()); } else if (ruleIndex == EsperEPL2GrammarParser.RULE_constant) { return parse(ruleNode.getChild(0));
private static int getSingleChildTokenType(RuleNode node) { return ((TerminalNode) node.getChild(0)).getSymbol().getType(); } }
static <C, T extends RuleNode, V extends GherkinBaseVisitor<C>> List<C> visitNodes(List<T> ruleNodes, V visitor) { List<C> result = new ArrayList<>(ruleNodes.size()); for (T node : ruleNodes) { result.add(node.accept(visitor)); } return result; }
private static Object parseNumber(RuleNode number, int factor) { int tokenType = getSingleChildTokenType(number); if (tokenType == EsperEPL2GrammarLexer.IntegerLiteral) { return parseIntLongByte(number.getText(), factor); } else if (tokenType == EsperEPL2GrammarLexer.FloatingPointLiteral) { String numberText = number.getText(); if (numberText.endsWith("f") || numberText.endsWith("F")) { return Float.parseFloat(number.getText()) * factor; } else { return Double.parseDouble(number.getText()) * factor; } } throw ASTWalkException.from("Encountered unrecognized constant", number.getText()); }
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); }
protected void exitRule(ParseTreeListener listener, RuleNode r) { ParserRuleContext ctx = (ParserRuleContext)r.getRuleContext(); ctx.exitRule(listener); listener.exitEveryRule(ctx); } }
static <C, T extends RuleNode, V extends Visitors.AggregatingVisitor<C>> List<C> visitNodesAndAggregate(List<T> ruleNodes, V visitor) { List<C> result = new ArrayList<>(ruleNodes.size()); for (T node : ruleNodes) { result.addAll(node.accept(visitor)); } return result; }
/** * {@inheritDoc} * * <p>The default implementation initializes the aggregate result to * {@link #defaultResult defaultResult()}. Before visiting each child, it * calls {@link #shouldVisitNextChild shouldVisitNextChild}; if the result * is {@code false} no more children are visited and the current aggregate * result is returned. After visiting a child, the aggregate result is * updated by calling {@link #aggregateResult aggregateResult} with the * previous aggregate result and the result of visiting the child.</p> * * <p>The default implementation is not safe for use in visitors that modify * the tree structure. Visitors that modify the tree should override this * method to behave properly in respect to the specific algorithm in use.</p> */ @Override public T visitChildren(RuleNode node) { T result = defaultResult(); int n = node.getChildCount(); for (int i=0; i<n; i++) { if (!shouldVisitNextChild(node, result)) { break; } ParseTree c = node.getChild(i); T childResult = c.accept(this); result = aggregateResult(result, childResult); } return result; }
private static boolean isRuleOfType(Tree child, int ruleNum) { if (!(child instanceof RuleNode)) { return false; } RuleNode ruleNode = (RuleNode) child; return ruleNode.getRuleContext().getRuleIndex() == ruleNum; }
/** Is {@code t} {@code (expr <expr>)} subtree? */ protected RuleTagToken getRuleTagToken(ParseTree t) { if ( t instanceof RuleNode ) { RuleNode r = (RuleNode)t; if ( r.getChildCount()==1 && r.getChild(0) instanceof TerminalNode ) { TerminalNode c = (TerminalNode)r.getChild(0); if ( c.getSymbol() instanceof RuleTagToken ) { // System.out.println("rule tag subtree "+t.toStringTree(parser)); return (RuleTagToken)c.getSymbol(); } } } return null; }
public static int getRuleIndexIfProvided(ParseTree tree) { if (!(tree instanceof RuleNode)) { return -1; } RuleNode ruleNode = (RuleNode) tree; return ruleNode.getRuleContext().getRuleIndex(); }
/** Is {@code t} {@code (expr <expr>)} subtree? */ protected RuleTagToken getRuleTagToken(ParseTree t) { if ( t instanceof RuleNode ) { RuleNode r = (RuleNode)t; if ( r.getChildCount()==1 && r.getChild(0) instanceof TerminalNode ) { TerminalNode c = (TerminalNode)r.getChild(0); if ( c.getSymbol() instanceof RuleTagToken ) { // System.out.println("rule tag subtree "+t.toStringTree(parser)); return (RuleTagToken)c.getSymbol(); } } } return null; }
private static boolean isRuleOfType(Tree child, int ruleNum) { if (!(child instanceof RuleNode)) { return false; } RuleNode ruleNode = (RuleNode) child; return ruleNode.getRuleContext().getRuleIndex() == ruleNum; }
/** Is {@code t} {@code (expr <expr>)} subtree? */ protected RuleTagToken getRuleTagToken(ParseTree t) { if ( t instanceof RuleNode ) { RuleNode r = (RuleNode)t; if ( r.getChildCount()==1 && r.getChild(0) instanceof TerminalNode ) { TerminalNode c = (TerminalNode)r.getChild(0); if ( c.getSymbol() instanceof RuleTagToken ) { // System.out.println("rule tag subtree "+t.toStringTree(parser)); return (RuleTagToken)c.getSymbol(); } } } return null; }