X-Git-Url: http://git.megacz.com/?p=sbp.git;a=blobdiff_plain;f=src%2Fedu%2Fberkeley%2Fsbp%2FGSS.java;h=db833b9d824af74ca76f5f4a2647de739b930b9a;hp=3876d581d687681ebea114f34ceef62b68d118ca;hb=24219bdf084b45273e869cd19382d1640b396566;hpb=6f1b2b1cba77222aeed1594d878b8c1250e31c1f

diff --git a/src/edu/berkeley/sbp/GSS.java b/src/edu/berkeley/sbp/GSS.java
index 3876d58..db833b9 100644
--- a/src/edu/berkeley/sbp/GSS.java
+++ b/src/edu/berkeley/sbp/GSS.java
@@ -18,13 +18,16 @@ class GSS {
     public GSS(Input input, Parser parser) { this.input = input; this.parser = parser;}
     public Input getInput() { return input; }
 
+    /*
+    HashSet<Reduction> finishedReductions = new HashSet<Reduction>();
+    */
     int numNewNodes = 0;
     int numOldNodes = 0;
     int viewPos = 0;
     int numReductions = 0;
 
     /** corresponds to a positions <i>between tokens</i> the input stream; same as Tomita's U_i's */
-    class Phase<Tok> implements Invokable<State, Node, Forest>, IntegerMappable, GraphViz.ToGraphViz, Iterable<Node> {
+    class Phase<Tok> implements Invokable<State, StateNode, Forest>, IntegerMappable, GraphViz.ToGraphViz, Iterable<StateNode> {
 
         // FIXME: right now, these are the performance bottleneck
         private HashMapBag<Integer,Integer>       performed       = new HashMapBag<Integer,Integer>();
@@ -39,7 +42,7 @@ class GSS {
             reductionQueue.add(r);
         }
 
-        public void invoke(State st, Node pred, Forest f) {
+        public void invoke(State st, StateNode pred, Forest f) {
             parser.spin();
             good |= next.newNode(f, null, pred, st, false);
         }
@@ -47,7 +50,7 @@ class GSS {
         /** the token immediately after this phase */
         final Tok token;
         final int pos;
-        public IntPairMap<Node> hash = new IntPairMap<Node>();  /* ALLOC */
+        public IntPairMap<StateNode> hash = new IntPairMap<StateNode>();  /* ALLOC */
         private boolean good = false;
         private Phase next = null;
         private Phase prev;
@@ -69,6 +72,9 @@ class GSS {
             this.pos = prev==null ? 0 : prev.pos+1;
             if (prev != null) prev.shift(this, forest);
             numReductions = 0;
+            /*
+            finishedReductions.clear();
+            */
 
             int minPhasePos = Integer.MAX_VALUE;
             Reduction best = null;
@@ -94,6 +100,9 @@ class GSS {
                         best = r;
                     }
                 }
+                /*
+                finishedReductions.add(r);
+                */
                 numReductions++;
             }
             if (token==null) shift(null, null);
@@ -116,13 +125,13 @@ class GSS {
             this.next = next;
             // this massively improves GC performance
             if (prev != null) {
-                IntPairMap<Node> h = prev.hash;
+                IntPairMap<StateNode> h = prev.hash;
                 prev.hash = null;
                 prev.performed = null;
-                for(Node n : h) n.check();
+                for(StateNode n : h) n.check();
             }
             numOldNodes = hash.size();
-            for(Node n : hash.values()) {
+            for(StateNode n : hash.values()) {
                 if (token == null && n.state().isAccepting()) {
                     if (finalResult==null) finalResult = new Forest.Many();
                     for(Result r : n)
@@ -151,14 +160,14 @@ class GSS {
             if (token==null && finalResult==null)
                 ParseFailed.error("unexpected end of file", this, null,
                                   getLocation().createRegion(getLocation()));
-            for(Node n : hash) n.check();
+            for(StateNode n : hash) n.check();
         }
 
         Input.Region getRegionFromThisToNext() {
             return getLocation().createRegion(getNextLocation());
         }
 
-        void newNodeFromReduction(Forest f, Pos reduction, Node pred) {
+        void newNodeFromReduction(Forest f, Pos reduction, StateNode pred) {
             int pos = pred.phase().pos;
             for(int s : reduction.hates())
                 if (performed.contains(pos, s))
@@ -180,8 +189,8 @@ class GSS {
          *  @param fromEmptyReduction true iff this node is being created as a result of a reduction of length zero (see GRMLR paper)
          *  @param start              the earliest part of the input contributing to this node (used to make merging decisions)
          */
-        private boolean newNode(Forest f, Pos reduction, Node pred, State state, boolean fromEmptyReduction) {
-            Node p = pred==null ? null : hash.get(state, pred.phase());
+        private boolean newNode(Forest f, Pos reduction, StateNode pred, State state, boolean fromEmptyReduction) {
+            StateNode p = pred==null ? null : hash.get(state, pred.phase());
             if (p != null) {
                 p.addResult(f, reduction, pred);
                 return !state.doomed();
@@ -192,7 +201,7 @@ class GSS {
                 if (token==null) break;
                 if (!state.canReduce(token)) return false;
             } while(false);
-            Node n = new Node(Phase.this, f, reduction, pred, state, fromEmptyReduction);  // ALLOC
+            StateNode n = new StateNode(Phase.this, f, reduction, pred, state, fromEmptyReduction);  // ALLOC
             /** FIXME: this null-result can be used to notice bogus/dead states */
             for(Object s : state.conjunctStates)
                 newNode(null, null, n, (State)s, fromEmptyReduction);
@@ -203,12 +212,12 @@ class GSS {
         public int size() { return hash==null ? 0 : hash.size(); }
         public int pos() { return pos; }
         public Tok getToken() { return token; }
-        public Iterator<Node> iterator() { return hash.iterator(); }
+        public Iterator<StateNode> iterator() { return hash.iterator(); }
         public GSS getGSS() { return GSS.this; }
 
         // GraphViz //////////////////////////////////////////////////////////////////////////////
 
-        public GraphViz.Node toGraphViz(GraphViz gv) {
+        public GraphViz.StateNode toGraphViz(GraphViz gv) {
             if (gv.hasNode(this)) return gv.createNode(this);
             GraphViz.Group g = gv.createGroup(this);
             g.label = "Phase " + pos;
@@ -224,7 +233,7 @@ class GSS {
             PrintWriter p = new PrintWriter(new OutputStreamWriter(fos));
             GraphViz gv = new GraphViz();
             for(Object n : this)
-                ((Node)n).toGraphViz(gv);
+                ((StateNode)n).toGraphViz(gv);
             gv.dump(p);
             p.flush();
             p.close();