@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; } }
@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; } }
@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 TerminalNode ) { TerminalNode tnode = (TerminalNode)c; if ( (tnode.getSymbol().getType() == tokenType && !invert) || (tnode.getSymbol().getType() != tokenType && invert) ) { nodes.add(tnode); } } } return nodes; } }
@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; } }
@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; } }
@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; } }
@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; } }
public static List<Tree> getSeparators(ParserRuleContext ctx, List<? extends ParserRuleContext> siblings) { ParserRuleContext first = siblings.get(0); ParserRuleContext last = siblings.get(siblings.size()-1); int start = BuffUtils.indexOf(ctx, first); int end = BuffUtils.indexOf(ctx, last); List<Tree> elements = Trees.getChildren(ctx).subList(start, end+1); return BuffUtils.filter(elements, c -> c instanceof TerminalNode); }
@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; } }
@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; } }
@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; } }
@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; } }
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); } } } }
@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 TerminalNode ) { TerminalNode tnode = (TerminalNode)c; if ( (tnode.getSymbol().getType() == tokenType && !invert) || (tnode.getSymbol().getType() != tokenType && invert) ) { nodes.add(tnode); } } } return nodes; } }
@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 TerminalNode ) { TerminalNode tnode = (TerminalNode)c; if ( (tnode.getSymbol().getType() == tokenType && !invert) || (tnode.getSymbol().getType() != tokenType && invert) ) { nodes.add(tnode); } } } return nodes; } }
@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 TerminalNode ) { TerminalNode tnode = (TerminalNode)c; if ( (tnode.getSymbol().getType() == tokenType && !invert) || (tnode.getSymbol().getType() != tokenType && invert) ) { nodes.add(tnode); } } } return nodes; } }
@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 TerminalNode ) { TerminalNode tnode = (TerminalNode)c; if ( (tnode.getSymbol().getType() == tokenType && !invert) || (tnode.getSymbol().getType() != tokenType && invert) ) { nodes.add(tnode); } } } return nodes; } }