/** assume that this forest contains exactly one tree and return it; otherwise throw an exception */
public abstract Tree<T> expand1() throws Ambiguous;
/** assume that this forest contains exactly one tree and return it; otherwise throw an exception */
public abstract Tree<T> expand1() throws Ambiguous;
public void expand(HashSet<Tree<T>> ht) { expand(ht, new HashSet<Forest<T>>(), null); }
/** create a new forest */
public void expand(HashSet<Tree<T>> ht) { expand(ht, new HashSet<Forest<T>>(), null); }
/** create a new forest */
- public static <T> Forest<T> create(Input.Region loc, T head, Forest<T>[] children, boolean unwrap) {
- return new One<T>(loc, head, children, unwrap);
+ public static <T> Forest<T> create(Input.Region loc, T head, Forest<T>[] children, boolean lift) {
+ return new One<T>(loc, head, children, lift);
// Package-Private //////////////////////////////////////////////////////////////////////////////
abstract void expand(HashSet<Tree<T>> ht, HashSet<Forest<T>> ignore, Tree<T> bogus);
abstract void gather(HashSet<Forest<T>> ignore);
// Package-Private //////////////////////////////////////////////////////////////////////////////
abstract void expand(HashSet<Tree<T>> ht, HashSet<Forest<T>> ignore, Tree<T> bogus);
abstract void gather(HashSet<Forest<T>> ignore);
// One //////////////////////////////////////////////////////////////////////////////
/** A "single" forest with a head and child subforests */
// One //////////////////////////////////////////////////////////////////////////////
/** A "single" forest with a head and child subforests */
private final Input.Region location;
private final T head;
private final Forest<T>[] children;
/** if true, the last child's children are considered children of this node */
private final Input.Region location;
private final T head;
private final Forest<T>[] children;
/** if true, the last child's children are considered children of this node */
- private One(Input.Region loc, T head, Forest<T>[] children, boolean unwrap) {
+ private One(Input.Region loc, T head, Forest<T>[] children, boolean lift) {
this.location = loc;
this.head = head;
this.children = children==null ? emptyForestArray : new Forest[children.length];
if (children != null) System.arraycopy(children, 0, this.children, 0, children.length);
if (children != null) for(int i=0; i<children.length; i++) if (children[i]==null) throw new Error(i+"");
this.location = loc;
this.head = head;
this.children = children==null ? emptyForestArray : new Forest[children.length];
if (children != null) System.arraycopy(children, 0, this.children, 0, children.length);
if (children != null) for(int i=0; i<children.length; i++) if (children[i]==null) throw new Error(i+"");
}
public Tree<T> expand1() throws Ambiguous {
Tree<T>[] ret = new Tree[children.length];
for(int i=0; i<children.length; i++) ret[i] = children[i].expand1();
}
public Tree<T> expand1() throws Ambiguous {
Tree<T>[] ret = new Tree[children.length];
for(int i=0; i<children.length; i++) ret[i] = children[i].expand1();
- return new Tree<T>(location, head, ret, unwrap);
+ return new Tree<T>(location, head, ret, lift);
if (ignore.contains(this)) { ht.add(bogus); return; }
expand(0, new Tree[children.length], ht, ignore, bogus);
}
private void expand(final int i, Tree<T>[] ta, HashSet<Tree<T>> ht, HashSet<Forest<T>> ignore, Tree<T> bogus) {
if (i==children.length) {
if (ignore.contains(this)) { ht.add(bogus); return; }
expand(0, new Tree[children.length], ht, ignore, bogus);
}
private void expand(final int i, Tree<T>[] ta, HashSet<Tree<T>> ht, HashSet<Forest<T>> ignore, Tree<T> bogus) {
if (i==children.length) {
- ht.add(new Tree<T>(location, head, ta, unwrap));
+ ht.add(new Tree<T>(location, head, ta, lift));
} else {
HashSet<Tree<T>> ht2 = new HashSet<Tree<T>>();
children[i].expand(ht2, ignore, bogus);
} else {
HashSet<Tree<T>> ht2 = new HashSet<Tree<T>>();
children[i].expand(ht2, ignore, bogus);
// Many //////////////////////////////////////////////////////////////////////////////
/** An "ambiguity node"; this is immutable once it has been "looked at" */
// Many //////////////////////////////////////////////////////////////////////////////
/** An "ambiguity node"; this is immutable once it has been "looked at" */
HashSet<GSS.Phase.Node> parents = new HashSet<GSS.Phase.Node>();
private FastSet<Forest<T>> hp = new FastSet<Forest<T>>();
HashSet<GSS.Phase.Node> parents = new HashSet<GSS.Phase.Node>();
private FastSet<Forest<T>> hp = new FastSet<Forest<T>>();
touched();
if (ignore.contains(this)) { ht.add(bogus); return; }
for (Forest<T> f : hp) f.expand(ht, ignore, bogus);
touched();
if (ignore.contains(this)) { ht.add(bogus); return; }
for (Forest<T> f : hp) f.expand(ht, ignore, bogus);