public static String getNodeText(Tree t, Parser recog) { String[] ruleNames = recog != null ? recog.getRuleNames() : null; List<String> ruleNamesList = ruleNames != null ? Arrays.asList(ruleNames) : null; return getNodeText(t, ruleNamesList); }
/** Replace any subtree siblings of root that are completely to left * or right of lookahead range with a CommonToken(Token.INVALID_TYPE,"...") * node. The source interval for t is not altered to suit smaller range! * * WARNING: destructive to t. * * @since 4.5.1 */ public static void stripChildrenOutOfRange(ParserRuleContext t, ParserRuleContext root, int startIndex, int stopIndex) { if ( t==null ) return; for (int i = 0; i < t.getChildCount(); i++) { ParseTree child = t.getChild(i); Interval range = child.getSourceInterval(); if ( child instanceof ParserRuleContext && (range.b < startIndex || range.a > stopIndex) ) { if ( isAncestorOf(child, root) ) { // replace only if subtree doesn't have displayed root CommonToken abbrev = new CommonToken(Token.INVALID_TYPE, "..."); t.children.set(i, new TerminalNodeImpl(abbrev)); } } } }
@Override public Collection<ParseTree> evaluate(ParseTree t) { return Trees.findAllTokenNodes(t, tokenType); } }
/** Print out a whole tree in LISP form. {@link #getNodeText} is used on the * node payloads to get the text for the nodes. */ public static String toStringTree(final Tree t, final List<String> ruleNames) { String s = Utils.escapeWhitespace(getNodeText(t, ruleNames), false); if ( t.getChildCount()==0 ) return s; StringBuilder buf = new StringBuilder(); buf.append("("); s = Utils.escapeWhitespace(getNodeText(t, ruleNames), false); buf.append(s); buf.append(' '); for (int i = 0; i<t.getChildCount(); i++) { if ( i>0 ) buf.append(' '); buf.append(toStringTree(t.getChild(i), ruleNames)); } buf.append(")"); return buf.toString(); }
Trees.getRootOfSubtreeEnclosingRegion(tt, startIndex, stopTreeAt); if ( Trees.isAncestorOf(parser.getOverrideDecisionRoot(), subtree) ) { subtree = parser.getOverrideDecisionRoot(); Trees.stripChildrenOutOfRange(subtree, parser.getOverrideDecisionRoot(), startIndex, stopTreeAt); trees.add(subtree);
ParserRuleContext t = parser.parse(startRuleIndex); GrammarInterpreterRuleContext ambigSubTree = (GrammarInterpreterRuleContext) Trees.getRootOfSubtreeEnclosingRegion(t, startIndex, stopIndex); if ( Trees.isAncestorOf(parser.getOverrideDecisionRoot(), ambigSubTree) ) { ambigSubTree = (GrammarInterpreterRuleContext)parser.getOverrideDecisionRoot();
@Override public Collection<ParseTree> evaluate(final ParseTree t) { if ( invert ) return new ArrayList<ParseTree>(); // !* is weird but valid (empty) List<ParseTree> kids = new ArrayList<ParseTree>(); for (Tree c : Trees.getChildren(t)) { kids.add((ParseTree)c); } return kids; } }
/** Print out a whole tree, not just a node, in LISP format * (root child1 .. childN). Print just a node if this is a leaf. * We have to know the recognizer so we can get rule names. */ @Override public String toStringTree(Parser recog) { return Trees.toStringTree(this, recog); }
/** Find smallest subtree of t enclosing range startTokenIndex..stopTokenIndex * inclusively using postorder traversal. Recursive depth-first-search. * * @since 4.5.1 */ public static ParserRuleContext getRootOfSubtreeEnclosingRegion(ParseTree t, int startTokenIndex, // inclusive int stopTokenIndex) // inclusive { int n = t.getChildCount(); for (int i = 0; i<n; i++) { ParseTree child = t.getChild(i); ParserRuleContext r = getRootOfSubtreeEnclosingRegion(child, startTokenIndex, stopTokenIndex); if ( r!=null ) return r; } if ( t instanceof ParserRuleContext ) { ParserRuleContext r = (ParserRuleContext) t; if ( startTokenIndex>=r.getStart().getTokenIndex() && // is range fully contained in t? (r.getStop()==null || stopTokenIndex<=r.getStop().getTokenIndex()) ) { // note: r.getStop()==null likely implies that we bailed out of parser and there's nothing to the right return r; } } return null; }
public static List<ParseTree> findAllNodes(ParseTree t, int index, boolean findTokens) { List<ParseTree> nodes = new ArrayList<ParseTree>(); _findAllNodes(t, index, findTokens, nodes); return nodes; }
public static Collection<ParseTree> findAllTokenNodes(ParseTree t, int ttype) { return findAllNodes(t, ttype, true); }
@Override public Collection<ParseTree> evaluate(ParseTree t) { return Trees.findAllRuleNodes(t, ruleIndex); } }
/** Return first node satisfying the pred * * @since 4.5.1 */ public static Tree findNodeSuchThat(Tree t, Predicate<Tree> pred) { if ( pred.test(t) ) return t; if ( t==null ) return null; int n = t.getChildCount(); for (int i = 0 ; i < n ; i++){ Tree u = findNodeSuchThat(t.getChild(i), pred); if ( u!=null ) return u; } return null; }
Trees.getRootOfSubtreeEnclosingRegion(tt, startIndex, stopTreeAt); if ( Trees.isAncestorOf(parser.getOverrideDecisionRoot(), subtree) ) { subtree = parser.getOverrideDecisionRoot(); Trees.stripChildrenOutOfRange(subtree, parser.getOverrideDecisionRoot(), startIndex, stopTreeAt); trees.add(subtree);
ParserRuleContext t = parser.parse(startRuleIndex); GrammarInterpreterRuleContext ambigSubTree = (GrammarInterpreterRuleContext) Trees.getRootOfSubtreeEnclosingRegion(t, startIndex, stopIndex); if ( Trees.isAncestorOf(parser.getOverrideDecisionRoot(), ambigSubTree) ) { ambigSubTree = (GrammarInterpreterRuleContext) parser.getOverrideDecisionRoot();
/** Print out a whole tree in LISP form. {@link #getNodeText} is used on the * node payloads to get the text for the nodes. */ public static String toStringTree(final Tree t, final List<String> ruleNames) { String s = Utils.escapeWhitespace(getNodeText(t, ruleNames), false); if ( t.getChildCount()==0 ) return s; StringBuilder buf = new StringBuilder(); buf.append("("); s = Utils.escapeWhitespace(getNodeText(t, ruleNames), false); buf.append(s); buf.append(' '); for (int i = 0; i<t.getChildCount(); i++) { if ( i>0 ) buf.append(' '); buf.append(toStringTree(t.getChild(i), ruleNames)); } buf.append(")"); return buf.toString(); }
@Override public Collection<ParseTree> evaluate(ParseTree t) { // return all children of t that match nodeName List<ParseTree> nodes = new ArrayList<ParseTree>(); for (Tree c : Trees.getChildren(t)) { if ( c instanceof ParserRuleContext ) { ParserRuleContext ctx = (ParserRuleContext)c; if ( (ctx.getRuleIndex() == ruleIndex && !invert) || (ctx.getRuleIndex() != ruleIndex && invert) ) { nodes.add(ctx); } } } return nodes; } }
/** Print out a whole tree, not just a node, in LISP format * (root child1 .. childN). Print just a node if this is a leaf. */ public String toStringTree(List<String> ruleNames) { return Trees.toStringTree(this, ruleNames); }
/** Given a token index into buffer, find surrounding rule then return * char position of start of next rule. */ public static int getCharIndexOfNextRuleStart(ParserRuleContext tree, int tokenIndex) { final ParserRuleContext selNode = Trees.getRootOfSubtreeEnclosingRegion(tree, tokenIndex, tokenIndex); final ParserRuleContext ruleRoot = (ParserRuleContext) getAncestorWithType(selNode, ANTLRv4Parser.RuleSpecContext.class); return ruleRoot.getStop().getStopIndex() + 2; // insert after '\n' following ';' // int ruleIndex = childIndexOf(ruleRoot.getParent(), ruleRoot); // ParserRuleContext nextRuleRoot = (ParserRuleContext)ruleRoot.getParent().getChild(ruleIndex+1); // if ( nextRuleRoot==null ) { // this rule must be last in grammar; put after ';' of this rule // } // return nextRuleRoot.getStart().getStartIndex(); } }
public static void _findAllNodes(ParseTree t, int index, boolean findTokens, List<? super ParseTree> nodes) { // check this node (the root) first if ( findTokens && t instanceof TerminalNode ) { TerminalNode tnode = (TerminalNode)t; if ( tnode.getSymbol().getType()==index ) nodes.add(t); } else if ( !findTokens && t instanceof ParserRuleContext ) { ParserRuleContext ctx = (ParserRuleContext)t; if ( ctx.getRuleIndex() == index ) nodes.add(t); } // check children for (int i = 0; i < t.getChildCount(); i++){ _findAllNodes(t.getChild(i), index, findTokens, nodes); } }