/** expand this forest into a set of trees */
public abstract HashSet<Tree<T>> expand(boolean toss);
- public abstract boolean empty();
- static <T> Forest<T> singleton(Token.Location loc, Sequence creator) { return create(loc, null, new Forest[] { }, creator, false, true); }
- static <T> Forest<T> singleton(Token.Location loc, Forest<T> body, Sequence creator) { return create(loc, null, new Forest[] { body }, creator, false, true); }
- static <T> Forest<T> leaf(Token.Location loc, T tag, Sequence creator) { return create(loc, tag, null, creator, false, false); }
- public static <T> Forest<T> create(Token.Location loc, T tag, Forest<T>[] tokens, Sequence creator, boolean unwrap, boolean singleton) {
- return new MultiForest<T>(loc, tag, tokens, creator, unwrap, singleton);
+ static <T> Forest<T> singleton(Token.Location loc) { return create(loc, null, new Forest[] { }, false, true); }
+ static <T> Forest<T> singleton(Token.Location loc, Forest<T> body) { return create(loc, null, new Forest[] { body }, false, true); }
+ static <T> Forest<T> leaf(Token.Location loc, T tag) { return create(loc, tag, null, false, false); }
+ public static <T> Forest<T> create(Token.Location loc, T tag, Forest<T>[] tokens, boolean unwrap, boolean singleton) {
+ return new MultiForest<T>(loc, tag, tokens, unwrap, singleton);
}
// Body //////////////////////////////////////////////////////////////////////////////
private final Token.Location location;
private final T tag;
private final Forest<T>[] tokens;
- private final Sequence creator;
private final boolean unwrap;
private final boolean singleton;
- private Body(Token.Location loc, T tag, Forest<T>[] tokens, Sequence creator, boolean unwrap, boolean singleton) {
+ private Body(Token.Location loc, T tag, Forest<T>[] tokens, boolean unwrap, boolean singleton) {
this.location = loc;
this.tag = tag;
this.tokens = tokens==null ? emptyForestArray : new Forest[tokens.length];
if (tokens != null) System.arraycopy(tokens, 0, this.tokens, 0, tokens.length);
if (tokens != null) for(int i=0; i<tokens.length; i++) if (tokens[i]==null) throw new Error(i+"");
- this.creator = creator;
this.unwrap = unwrap;
this.singleton = singleton;
}
* viewed, it becomes immutable
*/
static class Ref<T> extends IterableForest<T> {
- public boolean empty() {
- if (res!=null) return res.empty();
- for(Forest f : hp) if (!f.empty()) return false;
- return true;
- }
private FastSet<Forest> hp = new FastSet<Forest>();
private Forest res = null;
public Ref() { }
// Implementations //////////////////////////////////////////////////////////////////////////////
private static class MultiForest<T> extends IterableForest<T> {
- public boolean empty() { return results.size()>0; }
private final FastSet<Body<T>> results;
private MultiForest(FastSet<Body<T>> results) { this.results = results; }
- public MultiForest(Token.Location loc, T tag, Forest<T>[] tokens, Sequence creator, boolean unwrap, boolean singleton) {
- this.results = new FastSet<Body<T>>(new Body(loc, tag, tokens, creator, unwrap, singleton));
+ public MultiForest(Token.Location loc, T tag, Forest<T>[] tokens, boolean unwrap, boolean singleton) {
+ this.results = new FastSet<Body<T>>(new Body(loc, tag, tokens, unwrap, singleton));
}
public Iterator<Body<T>> iterator() { return results.iterator(); }
private final Object result;
public Constant(Element[] e, Object result, HashSet<Sequence> and, HashSet<Sequence> not) { super(e, and, not); this.result = result; }
public <T> Forest<T> postReduce(Token.Location loc, Forest<T>[] args) {
- return (Forest<T>)Forest.leaf(loc, result, this);
+ return (Forest<T>)Forest.leaf(loc, result);
}
static class Drop extends Constant {
public Drop(Element[] e, HashSet<Sequence> and, HashSet<Sequence> not, boolean lame) {
private final int idx;
public Singleton(Element e, HashSet<Sequence> and, HashSet<Sequence> not) { this(new Element[] { e }, 0, and, not); }
public Singleton(Element[] e, int idx, HashSet<Sequence> and, HashSet<Sequence> not) { super(e, and, not); this.idx = idx; }
- public <T> Forest<T> postReduce(Token.Location loc, Forest<T>[] args) { return (Forest<T>)Forest.singleton(loc, args[idx], this); }
+ public <T> Forest<T> postReduce(Token.Location loc, Forest<T>[] args) { return (Forest<T>)Forest.singleton(loc, args[idx]); }
}
public static class Unwrap extends Sequence {
public Unwrap(Element[] e, boolean[] drops, HashSet<Sequence> and, HashSet<Sequence> not) { super(e, and, not); this.drops = drops; }
public <T> Forest<T> postReduce(Token.Location loc, Forest<T>[] args) {
for(int i=0; i<args.length; i++) if (args[i]==null) throw new Error();
- if (drops==null) return Forest.create(loc, null, args, this, true, false);
+ if (drops==null) return Forest.create(loc, null, args, true, false);
int count = 0;
for(int i=0; i<drops.length; i++) if (!drops[i]) count++;
Forest<T>[] args2 = new Forest[count];
int j = 0;
for(int i=0; i<args.length; i++) if (!drops[i]) args2[j++] = args[i];
- return Forest.create(loc, null, args2, this, true, false);
+ return Forest.create(loc, null, args2, true, false);
}
}
int j = 0;
for(int i=0; i<args.length; i++) if (!drops[i]) args2[j++] = args[i];
//System.out.println("reduce \""+tag+"\"");
- return Forest.create(loc, (T)tag, args2, this, false, false);
+ return Forest.create(loc, (T)tag, args2, false, false);
}
public StringBuffer toString(StringBuffer sb, boolean spacing) {
int len = sb.length();