X-Git-Url: http://git.megacz.com/?p=sbp.git;a=blobdiff_plain;f=src%2Fedu%2Fberkeley%2Fsbp%2FStateNode.java;h=c67b1af021926ae64257e34330b855a7b45790b4;hp=768d8bfb6c7397c26eb818bd03f84194f6c6dd0a;hb=c1a7dcf0dd5b839d82215263d0f57470e905a73d;hpb=36d88939587827b1cea9ab842ec70bd168a08be1

diff --git a/src/edu/berkeley/sbp/StateNode.java b/src/edu/berkeley/sbp/StateNode.java
index 768d8bf..c67b1af 100644
--- a/src/edu/berkeley/sbp/StateNode.java
+++ b/src/edu/berkeley/sbp/StateNode.java
@@ -15,12 +15,15 @@ final class StateNode
     extends Node<ResultNode>
     implements Invokable<Pos, ResultNode, Object> {
 
-    private boolean fromEmptyReduction;
     private final Parser.Table.State state;
 
     /** which GSS.Phase this StateNode belongs to */
     public Parser.Table.State state() { return state; }
     public boolean isDoomedState() { return state.doomed; }
+    public boolean hasPathToRoot() {
+        if (state.doomed) return false;
+        return super.hasPathToRoot();
+    }
 
     public void check() {
         if (destroyed) return;
@@ -30,10 +33,10 @@ final class StateNode
         //      - be on the frontier or
         //      - have a non-doomed node closer to the frontier than themself
         if (phase().isFrontier()) dead = false;
-        else for(ResultNode r : successors)
+        else for(ResultNode r : successors())
                  if (state.doomed) { if (r.hasSuccessors()) { dead = false; break; } }
                  else              { if (r.hasNonDoomedSuccessors()) { dead = false; break; } }
-        dead |= predecessors.size()==0;
+        dead |= !hasPredecessors();
         if (!dead) return;
         if (phase() != null && phase().hash != null)
             phase().hash.remove(state, predecessorPhase());
@@ -48,23 +51,24 @@ final class StateNode
             phase().newNodeFromReduction(r.rewrite(region), r, this);
         } else {
             // never start reductions at a node that was created via a right-nulled rule
-            if (only.reduction().numPops()==0) return;
+            if (only.reduction() != null && only.reduction().numPops()==0) return;
             reduce(r, r.numPops()-1, phase(), only);
         }
     }
 
     private void reduce(Pos r, int pos, GSS.Phase target, ResultNode only) {
-        for(ResultNode res : predecessors)
+        for(ResultNode res : this)
             if (only == null || res == only)
                 for(StateNode pred : res) {
                     Forest[] holder = r.holder;
                     Forest old = pos >= holder.length ? null : holder[pos];
                     if (pos < holder.length) holder[pos] = res.getForest();
                     if (pos>0)  pred.reduce(r, pos-1, target, null);
-                    else {
-                        Input.Region region = pred.phase().getLocation().createRegion(target.getLocation());
-                        new Reduction(pred, r, r.rewrite(region), target);
-                    }
+                    else new Reduction(pred, r,
+                                       pred.hasPathToRoot()              
+                                       ? r.rewrite(pred.phase().getLocation().createRegion(target.getLocation()))
+                                       : null,
+                                       target);
                     if (pos < holder.length) holder[pos] = old;
                 }
     }
@@ -72,7 +76,6 @@ final class StateNode
     StateNode(GSS.Phase phase, ResultNode pred, State state) {
         super(phase, pred.phase());
         this.state = state;
-        this.fromEmptyReduction = pred!=null && pred.reduction()!=null && pred.reduction().numPops()==0;
         if (phase.hash.get(state, pred.phase()) != null) throw new Error("severe problem!");
         phase.hash.put(state, pred.phase(), this);
         addPred(pred);
@@ -82,7 +85,7 @@ final class StateNode
     // Add/Remove Successors/Predecessors //////////////////////////////////////////////////////////////////////////////
 
     public void addPred(Forest f, Pos reduction, StateNode pred) {
-        for(ResultNode r : predecessors)
+        for(ResultNode r : this)
             if (r.predecessorsContains(pred)) {
                 r.merge(f);
                 return;