Java IStrategoTerm.getSubtermCount方法代码示例

import org.spoofax.interpreter.terms.IStrategoTerm; //导入方法依赖的package包/类
private static boolean topdownHasSpaces(IStrategoTerm term) {
    Iterator<IStrategoTerm> iterator = TermVisitor.tryGetListIterator(term);

    for(int i = 0, max = term.getSubtermCount(); i < max; i++) {
        IStrategoTerm child = iterator == null ? term.getSubterm(i) : iterator.next();

        if(isRangeAppl(child)) {
            int start = intAt(child, 0);
            int end = intAt(child, 1);

            if(start <= ' ' && ' ' <= end)
                return true;
        } else {
            if(topdownHasSpaces(child))
                return true;
        }
    }

    return false;
}
 

import org.spoofax.interpreter.terms.IStrategoTerm; //导入方法依赖的package包/类
@Override
public final boolean call(IContext env, Strategy[] svars, IStrategoTerm[] tvars) {
	final IStrategoTerm location = tvars[0];
	if(!Tools.isTermTuple(location) && location.getSubtermCount() != 4)
		return false;

	final String filename = Tools.asJavaString(location.getSubterm(0));
	final int line = Tools.asJavaInt(location.getSubterm(1));
	final int column = Tools.asJavaInt(location.getSubterm(2));
	final int startOffset = Tools.asJavaInt(location.getSubterm(3));
	final int endOffset = Tools.asJavaInt(location.getSubterm(4));

	final ImploderAttachment attachment =
		ImploderAttachment.createCompactPositionAttachment(filename, line, column, startOffset, endOffset);
	env.current().putAttachment(attachment);

	return true;
}
 

import org.spoofax.interpreter.terms.IStrategoTerm; //导入方法依赖的package包/类
@Override
public boolean call(IContext env, Strategy[] svars, IStrategoTerm[] tvars)
        throws InterpreterException {
    
    IStrategoTerm input = tvars[0];
    
    if(!Tools.isTermAppl(input) && !isTermTuple(input))
        return false;
    
    Strategy c = svars[0];
    int arity = input.getSubtermCount();
    IStrategoTerm[] result = new IStrategoTerm[arity];
    IStrategoTerm[] applArgs = input.getAllSubterms();
    for(int i = 0; i < arity; i++) {
        env.setCurrent(applArgs[i]);
        if(!c.evaluate(env))
            return false;
        result[i] = env.current();
    }
    env.setCurrent(env.getFactory().makeList(result));
    return true;
}
 

import org.spoofax.interpreter.terms.IStrategoTerm; //导入方法依赖的package包/类
private void configureAmbNodes(IStrategoTerm result, boolean isBracket, boolean isCompletion,
    boolean isNestedCompletion, boolean isSinglePlaceholderCompletion) {
    for(int i = 0; i < result.getSubtermCount(); i++) {
        IStrategoTerm child = result.getSubterm(i);
        if(child instanceof IStrategoAppl) {
            if(((IStrategoAppl) child).getConstructor().getName().equals("amb")) {
                IStrategoTerm ambList = child.getSubterm(0);
                configureAmbNodes(ambList, isBracket, isCompletion, isNestedCompletion,
                    isSinglePlaceholderCompletion);
            } else {
                IToken left = getLeftToken(child);
                IToken right = getRightToken(child);
                if(ImploderAttachment.get(child).isCompletion()) {
                    configure(child, child.getAttachment(ImploderAttachment.TYPE).getSort(), left, right, false,
                        isBracket, true, false, isSinglePlaceholderCompletion);
                } else {
                    configure(child, child.getAttachment(ImploderAttachment.TYPE).getSort(), left, right, false,
                        isBracket, isCompletion, isNestedCompletion, isSinglePlaceholderCompletion);
                }
            }
        }
    }
}
 

import org.spoofax.interpreter.terms.IStrategoTerm; //导入方法依赖的package包/类
@Nullable
public static List<String> termListContents(IStrategoTerm t) {
    if(t == null)
        return null;

    List<String> results = Lists.newArrayList();

    if(t.getSubtermCount() == 1 && "Values".equals(tryGetName(t))) {
        IStrategoList values = Tools.listAt(t, 0);
        for(int i = 0; i < values.getSubtermCount(); i++) {
            results.add(termContents(termAt(values, i)));
        }
    } else {
        return null;
    }

    return results;
}
 

import org.spoofax.interpreter.terms.IStrategoTerm; //导入方法依赖的package包/类
public static void resolveAmbiguitiesByIndentation(IStrategoTerm node)
{
    if (node.getSubtermCount()>1)
    {
        IStrategoList contents;
        if ("amb".equals(((IStrategoNamed) node).getName())){
            contents = termAt(node, 0);
        }
        else{
            contents = termAt(node, 1);
        }
        for (int i = 0; i < contents.getSubtermCount(); i++) {
            resolveAmbiguitiesByIndentation(contents.getSubterm(i));
        }
    }

    if ("amb".equals(((IStrategoNamed) node).getName())){
        IStrategoList ambs = termAt(node, 0);
        node = ambs.getSubterm(0);
    }
}
 

import org.spoofax.interpreter.terms.IStrategoTerm; //导入方法依赖的package包/类
private static boolean isIncrementalProduction(IStrategoTerm prod, IStrategoConstructor incrementalFun) {
	IStrategoTerm attrsContainer = termAt(prod, 2);
	if (attrsContainer.getSubtermCount() > 0) {
		IStrategoList attrs = termAt(attrsContainer, 0);
		while (!attrs.isEmpty()) {
			IStrategoTerm attr = attrs.head();
			if (attr.getSubtermCount() == 1)
				attr = attr.getSubterm(0);
			if (tryGetConstructor(attr) == incrementalFun)
				return true;
			attrs = attrs.tail();
		}
	}
	return false;
}
 

import org.spoofax.interpreter.terms.IStrategoTerm; //导入方法依赖的package包/类
public static void topdown(IStrategoTermVisitor visitor, IStrategoTerm initialTerm) {
    final Stack<IStrategoTerm> stack = new Stack<IStrategoTerm>();
    stack.push(initialTerm);
    while(!stack.empty()) {
        final IStrategoTerm term = stack.pop();
        if(!dispatch(visitor, term)) {
            continue;
        }
        for(int i = term.getSubtermCount() -1; i >= 0; --i) {
            stack.push(term.getSubterm(i));
        }
    }
}
 

import org.spoofax.interpreter.terms.IStrategoTerm; //导入方法依赖的package包/类
protected void topdownPrintMatching(IStrategoTerm trm) {
	printMatching(trm);
	for (int i = 0; i < trm.getSubtermCount(); i++) {
		topdownPrintMatching(trm.getSubterm(i));
	}
		
}
 

import org.spoofax.interpreter.terms.IStrategoTerm; //导入方法依赖的package包/类
private boolean haveSameSignature(IStrategoTerm term, IStrategoTerm origin) {
	if(term instanceof StrategoAppl && origin instanceof StrategoAppl){
		if(!((StrategoAppl)term).getConstructor().equals(((StrategoAppl)origin).getConstructor()))
			return false;
	}
	return 	
		term.getTermType() == origin.getTermType() && 
		term.getSubtermCount() == origin.getSubtermCount();
}
 

import org.spoofax.interpreter.terms.IStrategoTerm; //导入方法依赖的package包/类
public IStrategoTerm strip(IStrategoTerm term) {
	if (term == null)
		return null;
	
	// Kids
	boolean isRebuildNeeded = false;
	IStrategoTerm[] kids = TermFactory.EMPTY;
	if (term.getSubtermCount() > 0) {
		kids = term.getAllSubterms();
		IStrategoTerm[] newKids = tryStripKids(kids);
		if (newKids != null) {
			isRebuildNeeded = true;
			kids = newKids;
		}
	}
	
	// Annotations
	IStrategoList annos = term.getAnnotations();
	IStrategoTerm[] newAnnos = tryStripAnnos(annos);
	if (newAnnos != null) {
		isRebuildNeeded = true;
		annos = factory.makeList(newAnnos);
	}
	
	// Self
	if (!isRebuildNeeded)
		isRebuildNeeded = term.getAttachment(null) != null;
	
	return isRebuildNeeded
		? converter.convertShallow(term, kids, annos)
		: term;
}
 

import org.spoofax.interpreter.terms.IStrategoTerm; //导入方法依赖的package包/类
/**
 * Traverses all terms in t2 in bottum-up order and tries to construct a matching for those.
 * @param root1
 * @param t2
 */
private void matchTerminalsBottomUp(IStrategoTerm root1, IStrategoTerm t2) {
	for (int i = 0; i < t2.getSubtermCount(); i++) {
		matchTerminalsBottomUp(root1, t2.getSubterm(i));
	}
	tryMatchTerminalNode(root1, t2);
}
 

import org.spoofax.interpreter.terms.IStrategoTerm; //导入方法依赖的package包/类
/**
 * True iff one of these conditions hold:
 * 1. both are Appl with same constructor name and same number of subterms
 * 2. both are lists
 * 3. both are tuples
 * @param t1
 * @param t2
 * @return
 */
public static boolean haveSameSignature(IStrategoTerm t1, IStrategoTerm t2){
	if(t1 == null || t2 == null)
		return false;
	if(t1.getTermType() == StrategoTerm.APPL && t2.getTermType() == StrategoTerm.APPL){
		boolean sameConstructorName = haveSameConstructorName(t1, t2);
		return sameConstructorName && t1.getSubtermCount() == t2.getSubtermCount();
	}
	if (Tools.isTermList(t1) && Tools.isTermList(t2))
		return true;
	if (Tools.isTermTuple(t1) && Tools.isTermTuple(t2))
		return true;
	else
		return false;
}
 

import org.spoofax.interpreter.terms.IStrategoTerm; //导入方法依赖的package包/类
protected int countMatches(IStrategoTerm trm) {
	int nrOfMatches = 0;
	if(TermMatchAttachment.getMatchedTerm(trm) != null)
		nrOfMatches += 1;
	for (int i = 0; i < trm.getSubtermCount(); i++) {
		nrOfMatches += countMatches(trm.getSubterm(i));
	}
	return nrOfMatches;
}
 

import org.spoofax.interpreter.terms.IStrategoTerm; //导入方法依赖的package包/类
private ArrayList<RecoverInterpretation> getRecoverCandidatesFromChildTerms(
		IStrategoTerm visitedTerm, IStrategoTerm term, IStrategoTerm parent) {
	if(visitedTerm.getSubtermCount() == 0)
		return new ArrayList<RecoverInterpretation>();
	int startIndex = 0;
	int endIndex = visitedTerm.getSubtermCount() - 1;
	ArrayList<RecoverInterpretation> candidatesFromSubterms = getRecoverCandidatesFromChildTerms(visitedTerm, startIndex, endIndex, term, parent);
	return candidatesFromSubterms;
}