Java RuleNode.getChildCount方法代码示例

import org.antlr.v4.runtime.tree.RuleNode; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public Object visitChildren(final RuleNode node) {

	final int n = node.getChildCount();

	for (int i = 0; i < n; i++) {
		final ParseTree c = node.getChild(i);
		c.accept(this);

	}
	final String textToFind = node.getText();
	if (StringUtils.containsIgnoreCase(textToFind, tempText)
			|| StringUtils.containsIgnoreCase(tempText, textToFind)) {
		nodes.add(new ParsedNode(node));
	}
	return null;

}
 

import org.antlr.v4.runtime.tree.RuleNode; //导入方法依赖的package包/类
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);

}
 

import org.antlr.v4.runtime.tree.RuleNode; //导入方法依赖的package包/类
public String visitChildren(RuleNode node) {
int n = node.getChildCount();
if (n > 1) {
    StringBuilder result = new StringBuilder();
    ParseTree child;
    String childResult;
    for (int i = 0; i < n; i++) {
	child = node.getChild(i);
	childResult = child.accept(this);
	if (childResult != null) {
	    if (i > 0) {
		result.append(' ');
	    }
	    result.append(childResult);
	}
    }
    return result.toString();
} else {
    if (n == 1) {
	return node.getChild(0).accept(this);
    } else {
	return node.getText();
    }
}
   }
 

import org.antlr.v4.runtime.tree.RuleNode; //导入方法依赖的package包/类
public List<String> visitChildren(RuleNode node) {
List<String> result = defaultResult();
List<String> childResult;
ParseTree child;
int n = node.getChildCount();
for (int i = 0; i < n; i++) {
    if (!shouldVisitNextChild(node, result)) {
	break;
    }

    child = node.getChild(i);
    childResult = child.accept(this);
    if (childResult != null) {
	if (result != null) {
	    result.addAll(childResult);
	} else {
	    result = childResult;
	}
    }
}
return result;
   }
 

import org.antlr.v4.runtime.tree.RuleNode; //导入方法依赖的package包/类
@Override
public Integer visitChildren(RuleNode arg0) {
	int iHash = 1;
	boolean bVisit = false;
	
	for (int i = arg0.getChildCount() - 1; i >= 0; i--) {
		Integer iVisit = visit(arg0.getChild(i));
		
		// If the visit resulted no hash ignore the hash.
		if (iVisit != null) {
			iHash = iHash * PRIME + iVisit;
			bVisit = true;
		}
	}
	
	if (bVisit) {
		return iHash;
	} else {
		return defaultResult(); // No result.
	}
}
 

import org.antlr.v4.runtime.tree.RuleNode; //导入方法依赖的package包/类
public String visitChildren(RuleNode node, List<Integer> withoutNodes) {
    if(node == null) return "";
    String result = this.defaultResult();
    int n = node.getChildCount();

    for(int i = 0; i < n && this.shouldVisitNextChild(node, result); ++i) {
        if(withoutNodes != null && withoutNodes.contains(i)) continue;
        ParseTree c = node.getChild(i);
        String childResult = c instanceof TerminalNode ? printTerminalNode((TerminalNode) c) : c.accept(this);
        result = this.aggregateResult(result, childResult);
    }

    return result;
}
 

import org.antlr.v4.runtime.tree.RuleNode; //导入方法依赖的package包/类
public String visitWithoutTerminals(RuleNode node) {
    String result = this.defaultResult();
    int n = node.getChildCount();

    for(int i = 0; i < n && this.shouldVisitNextChild(node, result); ++i) {
        ParseTree c = node.getChild(i);
        if(c instanceof TerminalNode) continue;
        String childResult = c.accept(this);
        result = this.aggregateResult(result, childResult);
    }

    return result;
}
 

import org.antlr.v4.runtime.tree.RuleNode; //导入方法依赖的package包/类
public String visitWithoutStrings(RuleNode node, String string) {
    String result = this.defaultResult();
    int n = node.getChildCount();

    for(int i = 0; i < n && this.shouldVisitNextChild(node, result); ++i) {
        ParseTree c = node.getChild(i);
        if(string.contains(c.getText())) continue;
        String childResult = c instanceof TerminalNode ? printTerminalNode((TerminalNode) c) : c.accept(this);
        result = this.aggregateResult(result, childResult);
    }

    return result;
}
 

import org.antlr.v4.runtime.tree.RuleNode; //导入方法依赖的package包/类
public String visitWithoutClasses(RuleNode node, Class nodeType) {
    String result = this.defaultResult();
    int n = node.getChildCount();

    for(int i = 0; i < n && this.shouldVisitNextChild(node, result); ++i) {
        ParseTree c = node.getChild(i);
        if(c.getClass() == nodeType) continue;
        String childResult = c instanceof TerminalNode ? printTerminalNode((TerminalNode) c) : c.accept(this);
        result = this.aggregateResult(result, childResult);
    }

    return result;
}
 

import org.antlr.v4.runtime.tree.RuleNode; //导入方法依赖的package包/类
@Override
public String visitChildren(final RuleNode arg0) {
  String visitString = "";
  for (int i = 0; i < arg0.getChildCount(); i++) {
    visitString += this.visit(arg0.getChild(i));
  }
  return visitString;
}
 

import org.antlr.v4.runtime.tree.RuleNode; //导入方法依赖的package包/类
private static void parseTreeWalker(ParseTree node, Consumer<RuleNode> f) {
    RuleNode rule = checkNode(node, RuleNode.class);
    if (rule == null) {
        return;
    }
    f.accept(rule);
    for (int i = 0; i < rule.getChildCount(); i++) {
        parseTreeWalker(rule.getChild(i), f);
    }
}
 

import org.antlr.v4.runtime.tree.RuleNode; //导入方法依赖的package包/类
public String visitChildren(RuleNode arg0) {
	int childrenCount = arg0.getChildCount();
	StringBuilder builder = new StringBuilder();
	increaseIndentationLevel();
	for(int i = 0; i < childrenCount; i++){
		builder.append(arg0.getChild(i).accept(this));
	}
	decreaseIndentationLevel();
	return builder.toString();
}
 

import org.antlr.v4.runtime.tree.RuleNode; //导入方法依赖的package包/类
/**
 * Parse the AST constant node and return Object value.
 *
 * @param node - parse node for which to parse the string value
 * @return value matching AST node type
 */
public static Object parse(ParseTree node) {
    if (node instanceof TerminalNode) {
        TerminalNode terminal = (TerminalNode) node;
        switch (terminal.getSymbol().getType()) {
            case EsperEPL2GrammarParser.BOOLEAN_TRUE:
                return BoolValue.parseString(terminal.getText());
            case EsperEPL2GrammarParser.BOOLEAN_FALSE:
                return BoolValue.parseString(terminal.getText());
            case EsperEPL2GrammarParser.VALUE_NULL:
                return null;
            default:
                throw ASTWalkException.from("Encountered unexpected constant type " + terminal.getSymbol().getType(), terminal.getSymbol());
        }
    } else {
        RuleNode ruleNode = (RuleNode) node;
        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 parseNumber(number, 1);
            } else {
                return parseNumber(number, 1);
            }
        } else if (ruleIndex == EsperEPL2GrammarParser.RULE_stringconstant) {
            return StringValue.parseString(node.getText());
        } else if (ruleIndex == EsperEPL2GrammarParser.RULE_constant) {
            return parse(ruleNode.getChild(0));
        }
        throw ASTWalkException.from("Encountered unrecognized constant", node.getText());
    }
}
 

import org.antlr.v4.runtime.tree.RuleNode; //导入方法依赖的package包/类
@Override
public String visitChildren(RuleNode node) {
	StringBuilder builder = new StringBuilder();
	builder.append(System.lineSeparator());
	int childrenCount = node.getChildCount();
	increaseIndentation();
	for (int i = 0; i < childrenCount; i++) {
		builder.append(node.getChild(i).accept(this));
	}
	decreaseIndentation();
	return builder.toString();
}
 

import org.antlr.v4.runtime.tree.RuleNode; //导入方法依赖的package包/类
private void appendSpaceToAggregateField(final StringBuilder sb, final RuleNode ctx) {
  for (int i = 0; i < ctx.getChildCount(); i++) {
    final ParseTree child = ctx.getChild(i);

    if (child instanceof RuleNode) {
      appendSpaceToAggregateField(sb, (RuleNode) child);

      if (child instanceof OptionAggregateValueFieldContext) {
        sb.append(AGREGATE_VALUE_FIELD_DELIMITER);
      }
    } else {
      sb.append(child.getText());
    }
  }
}