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

diff --git a/src/edu/berkeley/sbp/GSS.java b/src/edu/berkeley/sbp/GSS.java
index 7626b4e..db833b9 100644
--- a/src/edu/berkeley/sbp/GSS.java
+++ b/src/edu/berkeley/sbp/GSS.java
@@ -27,7 +27,7 @@ class GSS {
     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>();
@@ -42,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);
         }
@@ -50,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;
@@ -125,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)
@@ -160,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))
@@ -189,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();
@@ -201,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);
@@ -212,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;
@@ -233,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();