refactored Parser.Table.start0 stuff

darcs-hash:20060102074135-5007d-6500b0a94530c7125d26866c4f5d9c9d381f63b8.gz

diff --git a/src/edu/berkeley/sbp/Parser.java b/src/edu/berkeley/sbp/Parser.java
index 5b31b31..8518313 100644 (file)
--- a/src/edu/berkeley/sbp/Parser.java
+++ b/src/edu/berkeley/sbp/Parser.java
@@ -74,17 +74,8 @@ public abstract class Parser<T extends Token, R> {
     /** an SLR(1) parse table which may contain conflicts */
     static class Table {
 
-        private final Union start0 = new Union("0");
-        private final Sequence start0seq;
-        
         public final Walk.Cache cache = new Walk.Cache();
         
-        public HashSet<Position> closure()       {
-            HashSet<Position> hp = new HashSet<Position>();
-            reachable(start0, hp);
-            return hp;
-        }
-        
         private void walk(Element e, HashSet<Element> hs) {
             if (e==null) return;
             if (hs.contains(e)) return;
@@ -96,11 +87,6 @@ public abstract class Parser<T extends Token, R> {
                     walk(p.element(), hs);
             }
         }
-        public HashSet<Element> walk() {
-            HashSet<Element> ret = new HashSet<Element>();
-            walk(start0, ret);
-            return ret;
-        }
 
         /*
         public String toString() {
@@ -121,27 +107,29 @@ public abstract class Parser<T extends Token, R> {
         /** construct a parse table for the given grammar */
         public Table(Topology top) { this("s", top); }
         public Table(String startSymbol, Topology top) { this(new Union(startSymbol), top); }
-        public Table(Union u, Topology top) {
+        public Table(Union ux, Topology top) {
+            Union start0 = new Union("0");
+            start0.add(new Sequence.Singleton(ux, null, null));
+
+            for(Sequence s : start0) cache.eof.put(s, true);
             cache.eof.put(start0, true);
-            start0seq = new Sequence.Singleton(u, null, null);
-            cache.eof.put(start0seq, true);
-            start0.add(start0seq);
 
             // construct the set of states
             HashMap<HashSet<Position>,State>   all_states    = new HashMap<HashSet<Position>,State>();
-            HashSet<Element>                   all_elements  = walk();
-            all_elements.add(start0);
-            all_elements.add(start0seq);
+            HashSet<Element>                   all_elements  = new HashSet<Element>();
+            walk(start0, all_elements);
             for(Element e : all_elements)
                 cache.ys.put(e, new Walk.YieldSet(e, cache).walk());
-            this.start = new State(closure(), all_states, all_elements);
+            HashSet<Position> hp = new HashSet<Position>();
+            reachable(start0, hp);
+            this.start = new State(hp, all_states, all_elements);
 
             // for each state, fill in the corresponding "row" of the parse table
             for(State state : all_states.values())
                 for(Position p : state.hs) {
 
                     // the Grammar's designated "last position" is the only accepting state
-                    if (p==start0seq.firstp().next())
+                    if (start0.contains(p.owner()) && p.next()==null)
                         state.accept = true;
 
                     // FIXME: how does right-nullability interact with follow restrictions?

diff --git a/src/edu/berkeley/sbp/Union.java b/src/edu/berkeley/sbp/Union.java
index 8780d9e..9ac5e61 100644 (file)
--- a/src/edu/berkeley/sbp/Union.java
+++ b/src/edu/berkeley/sbp/Union.java
@@ -15,6 +15,7 @@ public class Union extends Element implements Iterable<Sequence> {
     private final List<Sequence> alternatives = new ArrayList<Sequence>();
 
     public Iterator<Sequence> iterator() { return alternatives.iterator(); }
+    public boolean contains(Sequence s) { return alternatives.contains(s); }
 
     Topology toAtom() {
         if (alternatives.size()==0) throw new RuntimeException("cannot build an Atom from a Union with no productions");