checkpoint

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

diff --git a/src/edu/berkeley/sbp/GSS.java b/src/edu/berkeley/sbp/GSS.java
index 1d91f89..02f521e 100644 (file)
--- a/src/edu/berkeley/sbp/GSS.java
+++ b/src/edu/berkeley/sbp/GSS.java
@@ -10,6 +10,7 @@ import java.lang.reflect.*;
 /** implements Tomita's Graph Structured Stack */
 class GSS {
 
+    public static int count = 0;
     public GSS() { }
 
     private Phase.Node[] reducing_list = null;
@@ -25,7 +26,7 @@ class GSS {
     public  Forest.Ref finalResult;
 
     /** corresponds to a positions <i>between tokens</i> the input stream; same as Tomita's U_i's */
-    public class Phase<Tok> implements Invokable<State, Forest, Phase<Tok>.Node>, IntegerMappable {
+    class Phase<Tok> implements Invokable<State, Forest, Phase<Tok>.Node>, IntegerMappable {
 
         public void invoke(State st, Forest result, Node n) {
             good |= next.newNode(n, result, st, false);
@@ -66,6 +67,7 @@ class GSS {
             singularReductions = new IntPairMap<Forest>();
             expectedInhibit.clear();
             expectedInhibit.addAll(inhibited);
+            reset = false;
             good = false;
             closed = false;
             reducing = false;
@@ -113,7 +115,7 @@ class GSS {
             }
             if (!owner.lame)
                 newNode(parent, pending, state, fromEmptyReduction);
-            if (reduction!=null) inhibit(reduction, parent==null?0:parent.phase().pos);
+            if (reduction!=null) uninhibit(reduction, parent==null?0:parent.phase().pos);
             if (reduction != null) {
                 boolean redo = true;
                 while(redo) {
@@ -156,34 +158,28 @@ class GSS {
             return true;
         }
 
-        public void uninhibit(int p, Sequence s) {
+        public void inhibit(int p, Sequence s) {
+            if (inhibited.contains(p, s)) return;
+            inhibited.add(p, s);
             if (s.hated!=null)
                 for(Sequence s2 : s.hated)
-                    inhibited.remove(p, s2);
+                    uninhibit(p, s2);
+            if (s.needed!=null)
+                for(Sequence s2 : s.needed)
+                    if (performed.contains(p, s2))
+                        throw new Reset();
+            if (performed.contains(p, s)) throw new Reset();
         }
 
-        public void inhibit(Position r, int p) {
-            if (r.owner().hated == null) return;
-            // remember that dead states are still allowed to shift -- just not allowed to reduce
-            boolean reset = false;
-            for(Sequence seq : r.owner().hated) {
-                if (performed.contains(p,seq)) {
-                    uninhibit(p, seq);
-                    //System.out.println("\nresetting due to " + r.owner() + " killing " + seq);
-                    //inhibited.clear();
-                    inhibited.add(p, seq);
-                    //inhibited = new HashMapBag<Integer,Sequence>();
-                    reset = true;
-                    resets++;
-                    throw new Reset();
-                }
-                inhibited.add(p, seq);
-                expectedInhibit.remove(p, seq);
-            }
+        public void uninhibit(Position r, int p) { uninhibit(p, r.owner()); }
+        public void uninhibit(int p, Sequence s) {
+            if (s.hated != null)
+                for(Sequence seq : s.hated)
+                    inhibit(p, seq);
         }
         
         /** perform all reduction operations */
-        public void reduce() throws ParseFailed{
+        public void reduce() throws ParseFailed {
             try {
                 reducing = true;
                 if (reducing_list==null || reducing_list.length < hash.size())
@@ -200,17 +196,26 @@ class GSS {
                     reducing_list[i] = null;
                     n.performReductions();
                 }
+                /*
                 if (expectedInhibit.size() > 0) {
                     inhibited.removeAll(expectedInhibit);
                     System.out.println("\n!!!!\n");
                     throw new Reset();
                 }
+                */
+                if (reset) {
+                    reset = false;
+                    resets++;
+                    throw new Reset();
+                }                
             } catch (Reset r) {
                 reset();
                 reduce();
             }
+            count = 0;
         }
 
+        private boolean reset = false;
         class Reset extends RuntimeException { }
 
         /** perform all shift operations, adding promoted nodes to <tt>next</tt> */
@@ -245,7 +250,7 @@ class GSS {
         }
 
 
-        public class Waiting {
+        class Waiting {
             Node parent;
             Forest pending;
             State state;
@@ -268,7 +273,7 @@ class GSS {
         // Node /////////////////////////////////////////////////////////////////////////////////
 
         /** a node in the GSS */
-        public final class Node extends FastSet<Node> implements Invokable<Position, Node, Node>, IntegerMappable {
+        final class Node extends FastSet<Node> implements Invokable<Position, Node, Node>, IntegerMappable {
 
             private Forest.Ref holder = null;
             private boolean allqueued = false;