refactoring of Node class and more stringent checks

[sbp.git] / src / edu / berkeley / sbp / StateNode.java

diff --git a/src/edu/berkeley/sbp/StateNode.java b/src/edu/berkeley/sbp/StateNode.java
index bb461cb..af1a3e9 100644 (file)
--- a/src/edu/berkeley/sbp/StateNode.java
+++ b/src/edu/berkeley/sbp/StateNode.java
@@ -15,12 +15,13 @@ final class StateNode
     extends Node<ResultNode>
     implements Invokable<Pos, ResultNode, Object> {
 
+    private final Parser.Table.State state;
+    private  boolean fromEmptyReduction;
+
     /** which GSS.Phase this StateNode belongs to */
-    public GSS.Phase phase() { return phase; }
     public Iterator<ResultNode> iterator() { return predecessors.iterator(); }
     public Parser.Table.State state() { return state; }
-
-    boolean destroyed = false;
+    public boolean isDoomedState() { return state.doomed; }
 
     public void check() {
         if (destroyed) return;
@@ -29,38 +30,17 @@ final class StateNode
         // - non-doomed nodes must either:
         //      - be on the frontier or
         //      - have a non-doomed node closer to the frontier than themself
-        if (phase.isFrontier()) dead = false;
+        if (phase().isFrontier()) dead = false;
         else for(ResultNode r : successors)
-                 if (state.doomed) { if (r.usedByAnyNode()) { dead = false; break; } }
-                 else              { if (r.usedByNonDoomedNode()) { dead = false; break; } }
+                 if (state.doomed) { if (r.hasSuccessors()) { dead = false; break; } }
+                 else              { if (r.hasNonDoomedSuccessors()) { dead = false; break; } }
         dead |= predecessors.size()==0;
         if (!dead) return;
-        destroyed = true;
         if (phase() != null && phase().hash != null)
-            phase().hash.remove(state, predPhase);
-        while(successors.size()>0)
-            for(ResultNode r : successors) {
-                successors.remove(r);
-                r.removePred(this);
-                break;
-            }
-        while(predecessors.size()>0)
-            for(ResultNode r : predecessors) {
-                predecessors.remove(r);
-                r.removeSucc(this);
-                break;
-            }
-        predecessors = null;
-        successors = null;
+            phase().hash.remove(state, predecessorPhase());
+        destroy();
     }
 
-    //////////////////////////////////////////////////////////////////////
-
-    private final GSS.Phase phase;
-    private final GSS.Phase predPhase;
-    private final Parser.Table.State state;
-    private  boolean fromEmptyReduction;
-
     public final void invoke(Pos r, ResultNode only, Object o) {
         boolean emptyProductions = only==null;
         if (emptyProductions != (r.numPops()==0)) return;
@@ -94,43 +74,28 @@ final class StateNode
         this(phase, new ResultNode(f, reduction, pred), state, fromEmptyReduction);
     }
     StateNode(GSS.Phase phase, ResultNode pred, State state, boolean fromEmptyReduction) {
-        this.phase = phase;
+        super(phase, pred.phase());
         this.state = state;
         this.fromEmptyReduction = fromEmptyReduction;
         if (phase.hash.get(state, pred.phase()) != null) throw new Error("severe problem!");
-        this.predPhase = pred.phase();
         phase.hash.put(state, pred.phase(), this);
-
-        predecessors.add(pred);
-        pred.addSucc(this);
-        if (!fromEmptyReduction)
-            state.invokeReductions(phase().getToken(), this, pred);
-
+        addPred(pred);
         state.invokeEpsilonReductions(phase().token, this);
     }
 
     // Add/Remove Successors/Predecessors //////////////////////////////////////////////////////////////////////////////
 
-    public void removeSucc(ResultNode succ)   {
-        successors.remove(succ);
-        check();
-    }
-    public void removePred(ResultNode result) {
-        predecessors.remove(result);
-        check();
-    }
-    public void addSucc(ResultNode succ)      {
-        successors.add(succ);
-    }
     public void addPred(Forest f, Pos reduction, StateNode pred) {
         for(ResultNode r : predecessors)
             if (r.predecessorsContains(pred)) {
                 r.merge(f);
                 return;
             }
-        ResultNode result = new ResultNode(f, reduction, pred);
-        predecessors.add(result);
-        result.addSucc(this);
-        if (!this.fromEmptyReduction) state.invokeReductions(phase().getToken(), this, result);
+        addPred(new ResultNode(f, reduction, pred));
+    }
+    protected void addPred(ResultNode result) {
+        super.addPred(result);
+        if (!this.fromEmptyReduction)
+            state.invokeReductions(phase().getToken(), this, result);
     }
 }