import org.spoofax.interpreter.terms.IStrategoConstructor; //导入依赖的package包/类
private IStrategoTerm doBuildExplode(ITermFactory factory, IStrategoTerm actualCtor, IStrategoTerm actualArgs) throws InterpreterException {
    if (!(Tools.isTermList(actualArgs))) {
        throw new InterpreterException("Not a list: " + actualArgs);
    }

    String n = ((IStrategoString)actualCtor).stringValue();
    IStrategoTerm[] realArgs = ((IStrategoList)actualArgs).getAllSubterms();
    
    if (n.equals(""))
        return factory.makeTuple(realArgs);
    
    boolean quoted = false;
    if (n.length() > 1 && n.charAt(0) == '"') {
        n = n.substring(1, n.length() - 1);
        quoted = true;
    }

    if(quoted && realArgs.length == 0) {
        return factory.makeString(n);
    }
    
    IStrategoConstructor afun = factory.makeConstructor(n, realArgs.length);
    return factory.makeAppl(afun, realArgs);
}
 

import org.spoofax.interpreter.terms.IStrategoConstructor; //导入依赖的package包/类
private IStrategoTerm buildOp(String ctr, IContext env, IStrategoAppl t, ITermFactory factory) 
throws  InterpreterException {
    
    IStrategoList children = (IStrategoList) t.getSubterm(1);

    IStrategoConstructor ctor = factory.makeConstructor(ctr, children.size());
    IStrategoTerm[] kids = new IStrategoTerm[children.size()];

    for (int i = children.size() -1 ; i >= 0; i--) {
        IStrategoTerm kid = buildTerm(env, (IStrategoAppl) children.getSubterm(i));
        if (kid == null) {
            return null;
        }
        kids[i] = kid;
    }

    return factory.makeAppl(ctor, kids);
}
 

import org.spoofax.interpreter.terms.IStrategoConstructor; //导入依赖的package包/类
private boolean makeAppl(IContext env, IStrategoString nameTerm, IStrategoTerm argsTerm) {
    if (argsTerm.getTermType() != IStrategoTerm.LIST)
        return false;
    
    String name = nameTerm.stringValue();
    for (int i = 0; i < name.length(); i++) {
        char c = name.charAt(i);
        if (!(Character.isLetterOrDigit(c) || c == '_' || c == '-'
            || c == '+' || c == '*' || c == '$')) {
            name = name.substring(0, i);
            break;
        }
    }
    
    IStrategoList args = (IStrategoList) argsTerm;
    
    if (name.length() == 0) { // tuple
        env.setCurrent(env.getFactory().makeTuple(args.getAllSubterms()));
    } else {
        IStrategoConstructor cons = env.getFactory().makeConstructor(name, args.size());
        env.setCurrent(env.getFactory().makeAppl(cons, args.getAllSubterms()));
    }        
    return true;
}
 

import org.spoofax.interpreter.terms.IStrategoConstructor; //导入依赖的package包/类
protected KeywordRecognizer(ParseTable table) {
	if (table != null) {
		IStrategoConstructor litFun = table.getFactory().makeConstructor("lit", 1);
		for (Label l : table.getLabels()) {
			if (l != null) {
				IStrategoTerm rhs = termAt(l.getProduction(), 1);
				if (isTermAppl(rhs) && ((IStrategoAppl) rhs).getConstructor() == litFun) {
					IStrategoNamed lit = termAt(rhs, 0);
					String litString = lit.getName();
					if (isPotentialKeyword(litString))
						keywords.add(litString);
				}
			}
		}
	}
}
 

import org.spoofax.interpreter.terms.IStrategoConstructor; //导入依赖的package包/类
/** 
 * Get the RTG sort name of a pattern.
 */
public String tryGetSort(IStrategoAppl currentAppl) {
	IStrategoConstructor cons = currentAppl.getConstructor();
	if (cons == cfFun)
		return tryGetSort(applAt(currentAppl, 0));
	if (cons == lexFun)
		return tryGetSort(applAt(currentAppl, 0));
	if (cons == sortFun)
		return javaString(termAt(currentAppl, 0));
	if (cons == parameterizedSortFun)
		return getParameterizedSortName(currentAppl);
	if (cons == charClassFun)
		return null;
	if (cons == altFun)
		return getAltSortName(currentAppl);
	return null;
}
 

import org.spoofax.interpreter.terms.IStrategoConstructor; //导入依赖的package包/类
public boolean isList(IStrategoAppl rhs, IStrategoAppl attrs) {
	IStrategoAppl details = rhs;
	
	if (details.getConstructor() == varsymFun)
		details = termAt(details, 0);
	
	if (details.getConstructor() == cfFun)
		details = termAt(details, 0);
	              	
  	if (details.getConstructor() == optFun)
  		details = termAt(details, 0);
  	
	IStrategoConstructor fun = details.getConstructor();
	
	 // FIXME: Spoofax/159: AsfixImploder creates tuples instead of lists for seqs
	if (isIterFun(fun) || seqFun == fun)
	  return true;
	
  return isFlatten(rhs, attrs);
}
 

import org.spoofax.interpreter.terms.IStrategoConstructor; //导入依赖的package包/类
public IStrategoAppl makeAppl(IStrategoConstructor ctr, IStrategoTerm... kids) {
    IStrategoAppl t = constructASTNode(ctr, kids);
    if(t == null) {
        if(DebugUtil.isDebugging()) {
            System.err.println("Generic fallback for:");
            System.err.println("Construct: " + ctr.getName() + "/" + ctr.getArity() + " with " + kids.length + " kids");
            for(int i = 0; i < kids.length; i++) {
                if(kids[i] instanceof WrappedASTNodeList) {
                    WrappedASTNodeList l = (WrappedASTNodeList)kids[i];
                    if(!l.isEmpty()) 
                        System.err.println("  [" + l.get(0) + "]");
                    else
                        System.err.println("  " + l + " - empty");
                } else
                    System.err.println("  " + kids[i]);
            }
        }
        return ctr.instantiate(this, kids);
    }
    return t;
}
 

import org.spoofax.interpreter.terms.IStrategoConstructor; //导入依赖的package包/类
private static String tryGetSort(IStrategoAppl appl) {
    IStrategoConstructor cons = appl.getConstructor();

    if("sort".equals(cons.getName()))
        return javaString(termAt(appl, 0));
    else if("cf".equals(cons.getName()) || "lex".equals(cons.getName()))
        return tryGetSort(applAt(appl, 0));
    else if("parameterized-sort".equals(cons.getName()))
        return getParameterizedSortName(appl);
    else if("char-class".equals(cons.getName()))
        return null;
    else if("alt".equals(cons.getName()))
        return getAltSortName(appl);
    else
        return null;
}
 

import org.spoofax.interpreter.terms.IStrategoConstructor; //导入依赖的package包/类
@Override public IStrategoAppl makeAppl(IStrategoConstructor ctr, IStrategoTerm[] kids, IStrategoList annotations) {
    IStrategoAppl term = super.makeAppl(ctr, kids, annotations);

    SortType[] sorts = checkConstruction(ctr, kids, term, null);
    if(sorts != null)
        TypesmartSortAttachment.put(term, sorts);
    return term;
}
 

import org.spoofax.interpreter.terms.IStrategoConstructor; //导入依赖的package包/类
/**
 * Recheck invariant of typesmart constrcutor.
 */
@Override public IStrategoAppl replaceAppl(IStrategoConstructor ctr, IStrategoTerm[] kids, IStrategoAppl old) {
    IStrategoAppl term = super.makeAppl(ctr, kids, old.getAnnotations());

    SortType[] sorts = checkConstruction(ctr, kids, term, old.getAllSubterms());
    if(sorts != null)
        TypesmartSortAttachment.put(term, sorts);
    return term;
}
 

import org.spoofax.interpreter.terms.IStrategoConstructor; //导入依赖的package包/类
@Override public IStrategoAppl makeAppl(IStrategoConstructor ctr, IStrategoTerm[] terms,
    IStrategoList annotations) {
    int storageType = defaultStorageType;
    storageType = min(storageType, getStorageType(terms));
    if(storageType != 0)
        storageType = min(storageType, getStorageType(annotations));
    assert ctr.getArity() == terms.length;
    return new StrategoAppl(ctr, terms, annotations, storageType);
}
 

import org.spoofax.interpreter.terms.IStrategoConstructor; //导入依赖的package包/类
public StrategoAppl(IStrategoConstructor ctor, IStrategoTerm[] kids, IStrategoList annotations, int storageType) {
    super(annotations, storageType);
    this.ctor = ctor;
    this.kids = kids;
    
    if (storageType != MUTABLE) initImmutableHashCode();
}
 

import org.spoofax.interpreter.terms.IStrategoConstructor; //导入依赖的package包/类
@Override
public IStrategoAppl replaceAppl(IStrategoConstructor constructor, IStrategoTerm[] kids,
		IStrategoAppl oldTerm) {
	
	IStrategoList annos = oldTerm.getAnnotations();
	IStrategoAppl result = makeAppl(constructor, ensureChildLinks(kids, oldTerm), annos);
	//TODO: child links only when same signature
	return (IStrategoAppl) ensureLink(result, oldTerm, false);
}
 

import org.spoofax.interpreter.terms.IStrategoConstructor; //导入依赖的package包/类
@Override
public IStrategoAppl makeAppl(IStrategoConstructor constructor, IStrategoTerm[] kids, IStrategoList annotations) {
	IStrategoAppl result = baseFactory.makeAppl(constructor, kids, annotations);
	assert ParentAttachment.get(result) == null :
		"Unexpected parent attachment; doubly wrapped term factory?";
	configure(result, kids);
	return result;
}
 

import org.spoofax.interpreter.terms.IStrategoConstructor; //导入依赖的package包/类
@Override
protected boolean doSlowMatch(IStrategoTerm second, int commonStorageType) {
	if (second == this)
		return true;
	if (second == null || second.getTermType() != CTOR)
		return false;
	
	IStrategoConstructor other = (IStrategoConstructor) second;
	
    return name.equals(other.getName()) && arity == other.getArity();
}
 

import org.spoofax.interpreter.terms.IStrategoConstructor; //导入依赖的package包/类
private void readAllSymbols() throws IOException {

        for (int i = 0; i < nrUniqueSymbols; i++) {
            SymEntry e = new SymEntry();
            symbols[i] = e;

            IStrategoTerm fun = readSymbol();
            e.fun = fun;
            int arity = e.arity = fun instanceof IStrategoConstructor ? ((IStrategoConstructor) fun).getArity() : 0;

            int v = reader.readInt();
            e.nrTerms = v;
            e.termWidth = bitWidth(v);
            // FIXME: original code is inconsistent at this point!
            e.terms = (v == 0) ? null : new IStrategoTerm[v];

            if (arity == 0) {
                e.nrTopSyms = null;
                e.symWidth = null;
                e.topSyms = null;
            } else {

                e.nrTopSyms = new int[arity];
                e.symWidth = new int[arity];
                e.topSyms = new int[arity][];
            }
            for (int j = 0; j < arity; j++) {
                v = reader.readInt();
                e.nrTopSyms[j] = v;
                e.symWidth[j] = bitWidth(v);
                e.topSyms[j] = new int[v];

                for (int k = 0; k < e.nrTopSyms[j]; k++) {
                    v = reader.readInt();
                    e.topSyms[j][k] = v;
                }
            }
        }
    }
 

import org.spoofax.interpreter.terms.IStrategoConstructor; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private GuardedLChoice parseGuardedLChoice(IStrategoAppl t) throws InterpreterException {

	LinkedList<Pair<Strategy,Strategy>> s = new LinkedList<Pair<Strategy,Strategy>>();
    IStrategoConstructor ctor = context.getStrategoSignature().getGuardedLChoice();

	while (t.getConstructor().equals(ctor)) {
      s.add(new Pair<Strategy,Strategy>(parseStrategy(Tools.applAt(t, 0)), parseStrategy(Tools.applAt(t, 1))));
      t = Tools.applAt(t, 2);
	}

	s.add(new Pair<Strategy,Strategy>(parseStrategy(t), null));

    return new GuardedLChoice(s.toArray(new Pair[0]));
}
 

import org.spoofax.interpreter.terms.IStrategoConstructor; //导入依赖的package包/类
/**
 * Evaluates a stratego expression. Must be fully desugared,
 * using C names in SDefTs and SCallTs.
 *
 * @see org.strategoxt.HybridInterpreter#evaluate  A variant of evaluate() with desugaring support.
 */
public boolean evaluate(IStrategoAppl s)
        throws InterpreterErrorExit, InterpreterExit, UndefinedStrategyException, InterpreterException {

    final ITermFactory factory = getFactory();
    final IStrategoConstructor sdefT = factory.makeConstructor("SDefT", 4);

    if (s.getConstructor() != sdefT)
        s = factory.makeAppl(sdefT, factory.makeString("interpreter_evaluate_dummy_0_0"), factory.makeList(), factory.makeList(), s);

    SDefT def = loader.parseSDefT(s);
    return evaluate(def);
}
 

import org.spoofax.interpreter.terms.IStrategoConstructor; //导入依赖的package包/类
public static IncrementalSortSet read(ParseTable table) {
	IStrategoConstructor incrementalFun = table.getFactory().makeConstructor("incremental", 0);
	ProductionAttributeReader reader = new ProductionAttributeReader(table.getFactory());
	Set<String> sorts = new HashSet<String>();
	
	for (int i = ParseTable.LABEL_BASE, max = table.getProductionCount(); i < max; i++) {
		IStrategoTerm prod = table.getProduction(i);
		if (isIncrementalProduction(prod, incrementalFun))
			sorts.add(reader.getSort(applAt(prod, 1)));
	}
	return create(table, true, sorts);
}
 

import org.spoofax.interpreter.terms.IStrategoConstructor; //导入依赖的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;
}