change naming: use pred/succ rather than parent/child

[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 a726297..bf58e64 100644 (file)
--- a/src/edu/berkeley/sbp/GSS.java
+++ b/src/edu/berkeley/sbp/GSS.java
@@ -1,10 +1,11 @@
-// Copyright 2006 all rights reserved; see LICENSE file for BSD-style license
+// Copyright 2006-2007 all rights reserved; see LICENSE file for BSD-style license
 
 package edu.berkeley.sbp;
 import edu.berkeley.sbp.*;
 import edu.berkeley.sbp.util.*;
 import edu.berkeley.sbp.Parser.Table.*;
-import edu.berkeley.sbp.Sequence.Position;
+import edu.berkeley.sbp.Sequence.Pos;
+import edu.berkeley.sbp.Sequence.Pos;
 import java.io.*;
 import java.util.*;
 import java.lang.reflect.*;
@@ -26,7 +27,7 @@ class GSS {
     class Phase<Tok> implements Invokable<State, Result>, IntegerMappable, GraphViz.ToGraphViz, Iterable<Node> {
 
         // FIXME: right now, these are the performance bottleneck
-        private HashMapBag<Integer,Sequence>       performed       = new HashMapBag<Integer,Sequence>();
+        private HashMapBag<Integer,Integer>       performed       = new HashMapBag<Integer,Integer>();
 
         public Forest.Many finalResult;
         private PriorityQueue<Reduction> reductionQueue = new PriorityQueue<Reduction>();
@@ -71,29 +72,26 @@ class GSS {
             numReductions = 0;
 
             int minPhasePos = Integer.MAX_VALUE;
-            int maxOrd = -1;
             Reduction best = null;
             //System.out.println("==============================================================================");
             while(!reductionQueue.isEmpty()) {
                 Reduction r = reductionQueue.poll();
                 //System.out.println("- " + r);
-                if (r.parentPhase() != null)
-                    if (r.parentPhase().pos > minPhasePos)
+                if (r.predPhase() != null)
+                    if (r.predPhase().pos > minPhasePos)
                         throw new Error();
                 r.perform();
-                if (r.parentPhase() != null) {
-                    if (r.parentPhase().pos < minPhasePos) {
-                        minPhasePos = r.parentPhase().pos;
-                        maxOrd = r.reduction().ord;
+                if (r.predPhase() != null) {
+                    if (r.predPhase().pos < minPhasePos) {
+                        minPhasePos = r.predPhase().pos;
                         best = r;
-                    } else if (r.parentPhase().pos == minPhasePos) {
+                    } else if (r.predPhase().pos == minPhasePos) {
                         /*
                         if (best != null && Parser.mastercache.comparePositions(r.reduction(), best.reduction()) < 0)
                             throw new Error("\n"+r+"\n"+best+"\n"+
                                             Parser.mastercache.comparePositions(r.reduction(), best.reduction())+"\n"+r.compareTo(best)+
                                             "\n"+(r.reduction().ord-best.reduction().ord));
                         */
-                        maxOrd = r.reduction().ord;
                         best = r;
                     }
                 }
@@ -115,7 +113,7 @@ class GSS {
         public boolean        isFrontier() { return hash!=null; }
 
         /** perform all shift operations, adding promoted nodes to <tt>next</tt> */
-        private void shift(Phase next, Forest result) throws ParseFailed {
+        private void shift(Phase next, Forest f) throws ParseFailed {
             this.next = next;
             // this massively improves GC performance
             if (prev != null) {
@@ -132,7 +130,8 @@ class GSS {
                         finalResult.merge(r.getForest());
                 }
                 if (token == null) continue;
-                n.state().invokeShifts(token, this, new Result(result, n, null));
+                Result result = new Result(f, n, null);
+                n.state().invokeShifts(token, this, result);
             }
             numNewNodes = next==null ? 0 : next.hash.size();
             viewPos = this.pos;
@@ -160,19 +159,18 @@ class GSS {
             return getLocation().createRegion(getNextLocation());
         }
 
-        void newNodeFromReduction(Result result, State state, Position reduction) {
+        void newNodeFromReduction(Result result, State state, Pos reduction) {
             int pos = result.phase().pos;
-            Sequence owner = reduction.owner();
-            for(Sequence s : owner.hates())
+            for(int s : reduction.hates())
                 if (performed.contains(pos, s))
                     return;
-            for(Sequence s : owner.needs())
+            for(int s : reduction.needs())
                 if (!performed.contains(pos, s))
                     return;
-            if (owner.needed_or_hated && !performed.contains(pos, owner))
-                performed.add(pos, owner);
+            if (reduction.owner_needed_or_hated() && !performed.contains(pos, reduction.provides()))
+                performed.add(pos, reduction.provides());
             if (state!=null)
-                newNode(result, state, reduction.pos<=0);
+                newNode(result, state, reduction.numPops()<=0);
         }
 
         /** add a new node (merging with existing nodes if possible)
@@ -192,6 +190,7 @@ class GSS {
                 if (!state.canReduce(token)) return false;
             } while(false);
             Node n = new Node(Phase.this, result, state, fromEmptyReduction);  // ALLOC
+            /** FIXME: this null-result can be used to notice bogus/dead states */
             for(Object s : state.conjunctStates)
                 newNode(new Result(null, n, null), (State)s, fromEmptyReduction);
             return !n.state().doomed();