From: adam Date: Mon, 26 Mar 2007 05:48:14 +0000 (-0400) Subject: Sequence: cleanup, mostly inert X-Git-Tag: tag_for_25-Mar~9 X-Git-Url: http://git.megacz.com/?p=sbp.git;a=commitdiff_plain;h=a4cd33f348d3802ed746e517c23205958a4ceeb4 Sequence: cleanup, mostly inert darcs-hash:20070326054814-5007d-ec3f993591eddd18973669fa39a188926443c4ed.gz --- diff --git a/src/edu/berkeley/sbp/Sequence.java b/src/edu/berkeley/sbp/Sequence.java index a029274..2c36c8d 100644 --- a/src/edu/berkeley/sbp/Sequence.java +++ b/src/edu/berkeley/sbp/Sequence.java @@ -14,34 +14,22 @@ public abstract class Sequence implements Iterable, SequenceOrElement { protected final Element[] elements; - public boolean needed_or_hated = false; - - public HashMap canNeed = new HashMap(); - public HashMap canKill = new HashMap(); - - final HashSet hated = new HashSet(); + boolean needed_or_hated = false; + boolean in_a_union = false; final HashSet needs = new HashSet(); final HashSet hates = new HashSet(); + // FIXME: these are ugly -- migrate into Cache + HashMap canNeed = new HashMap(); + HashMap canKill = new HashMap(); + final Position firstp; Atom follow = null; // Static Constructors ////////////////////////////////////////////////////////////////////////////// - abstract Sequence _clone(); - Sequence dup() { - Sequence ret = _clone(); - for(Sequence s : needs) { ret.needs.add(s); } - for(Sequence s : hates) { ret.hates.add(s); s.hated.add(ret); } - ret.follow = follow; - return ret; - } - - /** create an empty sequence (matches the empty string) */ - public static Sequence create() { return new Sequence.Constant.Empty(); } - /** create a sequence of one element */ public static Sequence create(Element e) { return create(new Element[] { e }, 0); } @@ -67,27 +55,45 @@ public abstract class Sequence implements Iterable, SequenceOrElement { : new RewritingSequence(head, e, drop); } - //////////////////////////////////////////////////////////////////////////////// - /** return a new sequence identical to this one, but with a positive conjunct s */ - public Sequence and(Sequence s) { Sequence ret = dup(); ret.needs.add(s); s.needed_or_hated=true; return ret; } + public Sequence and(Sequence s) { + if (s.in_a_union) + throw new RuntimeException("you may not use a sequence as a conjunct if it belongs to a Union"); + Sequence ret = dup(); + ret.needs.add(s); + s.needed_or_hated=true; + return ret; + } /** return a new sequence identical to this one, but with a negative conjunct s */ - public Sequence andnot(Sequence s) { Sequence ret = dup(); ret.hates.add(s); s.hated.add(ret); s.needed_or_hated=true; return ret; } + public Sequence andnot(Sequence s) { + if (s.in_a_union) + throw new RuntimeException("you may not use a sequence as a conjunct if it belongs to a Union"); + Sequence ret = dup(); + ret.hates.add(s); + s.needed_or_hated=true; + return ret; + } /** return a new sequence identical to this one, but with a follow-set restricted to a */ public Sequence followedBy(Atom a) { Sequence ret = dup(); ret.follow = a; return ret; } - boolean hatesAny(Iterable it) { - if (hates.isEmpty()) return false; - for(Sequence s : it) if (hates.contains(s)) return true; - return false; + //////////////////////////////////////////////////////////////////////////////// + + abstract Sequence _clone(); + private Sequence dup() { + Sequence ret = _clone(); + for(Sequence s : needs) { ret.needs.add(s); } + for(Sequence s : hates) { ret.hates.add(s); } + ret.follow = follow; + return ret; } Iterable needs() { return needs; } Iterable hates() { return hates; } Position firstp() { return firstp; } + Position lastp() { return firstp().last(); } public Iterator iterator() { return new ArrayIterator(elements); } protected Sequence(Element[] elements) { @@ -136,12 +142,14 @@ public abstract class Sequence implements Iterable, SequenceOrElement { final int pos; private final Position next; + private final Position prev; final Forest[] holder; private Position(int pos) { this.pos = pos; this.next = pos==elements.length ? null : new Position(pos+1); this.holder = new Forest[elements.length]; + this.prev = prev; } boolean isFirst() { return pos==0; } @@ -157,6 +165,8 @@ public abstract class Sequence implements Iterable, SequenceOrElement { /** true iff this Position is the last one in the sequence */ public boolean isLast() { return next()==null; } + public Position last() { return isLast() ? this : next().last(); } + public Position prev() { return prev; } // Position ///////////////////////////////////////////////////////////////////////////////// @@ -196,7 +206,7 @@ public abstract class Sequence implements Iterable, SequenceOrElement { StringBuffer toString(StringBuffer sb) { return toString(sb, true); } StringBuffer toString(StringBuffer sb, boolean spacing) { for(int i=0; i, SequenceOrElement { static class Constant extends Sequence { private final Object result; - public Constant(Element[] e, Object result) { super(e); this.result = result; } + public Constant(Element[] e, Object result) { + super(e); + if (result==null) throw new Error("constant sequences may not have result==null"); + this.result = result; + } Sequence _clone() { return new Constant(elements, result); } public Forest postReduce(Input.Region loc, Forest[] args, Position p) { return (Forest)Forest.create(loc, result, null, false); } - static class Drop extends Constant { - Sequence _clone() { return new Drop(elements); } - public Drop(Element[] e) { super(e, null); } - } - static class Empty extends Sequence.Constant.Drop { - Sequence _clone() { return new Empty(); } - public Empty() { super(new Element[] { }); } } } static class Singleton extends Sequence { @@ -244,7 +251,7 @@ public abstract class Sequence implements Iterable, SequenceOrElement { static class Unwrap extends Sequence { private boolean[] drops; private final Object tag; - public Unwrap(Element[] e, Object tag) { super(e); this.drops = null; this.tag = tag; } + public Unwrap(Element[] e, Object tag) { this(e, tag, null); } public Unwrap(Element[] e, Object tag, boolean[] drops) { super(e); this.drops = drops; this.tag = tag; } Sequence _clone() { return new Unwrap(elements, tag, drops); } public Forest postReduce(Input.Region loc, Forest[] args, Position p) { @@ -259,30 +266,15 @@ public abstract class Sequence implements Iterable, SequenceOrElement { } } - - - static class RegionRewritingSequence extends RewritingSequence { - private Functor tagf; - public RegionRewritingSequence(Functor tagfunctor, Element[] e, boolean[] drops) { - super(null, e, drops); - this.tagf = tagfunctor; - } - public Forest postReduce(Input.Region loc, Forest[] args, Position p) { - this.tag = tagf.invoke(loc); - Forest ret = super.postReduce(loc, args, p); - this.tag = null; - return ret; - } - } - static class RewritingSequence extends Sequence { - /*private*/public /*final*/ Object tag; + private Object tag; private final boolean[] drops; private int count = 0; Sequence _clone() { return new RewritingSequence(tag, elements, drops); } public RewritingSequence(Object tag, Element[] e) { this(tag, e, null); } public RewritingSequence(Object tag, Element[] e, boolean[] drops) { super(e); + if (tag==null) throw new Error(); this.tag = tag; this.drops = drops == null ? new boolean[e.length] : drops; for(int i=0; i