X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=src%2Fedu%2Fberkeley%2Fsbp%2FParser.java;h=75f3ace8064784f45d3186eb6a99b21317aeb1a9;hb=a7b84506c2e1ed63343db215f76afced082e2826;hp=3bafbfe427e33176572a1301ce1d99a40f8fe2b1;hpb=cf349fcf2f460e53ad5f9dd0397eb382c4aa92b2;p=sbp.git

diff --git a/src/edu/berkeley/sbp/Parser.java b/src/edu/berkeley/sbp/Parser.java
index 3bafbfe..75f3ace 100644
--- a/src/edu/berkeley/sbp/Parser.java
+++ b/src/edu/berkeley/sbp/Parser.java
@@ -8,19 +8,19 @@ import java.util.*;
 /** a parser which translates streams of Tokens of type T into a Forest<R> */
 public abstract class Parser<Tok, Result> {
 
-    private final Table pt;
+    protected final Table<Tok> pt;
 
     /** create a parser to parse the grammar with start symbol <tt>u</tt> */
     protected Parser(Union u, Topology<Tok> top)  { this.pt = new Table<Tok>(u, top); }
-    protected Parser(Table pt)                    { this.pt = pt; }
+    protected Parser(Table<Tok> pt)               { this.pt = pt; }
 
     /** implement this method to create the output forest corresponding to a lone shifted input token */
-    public abstract Forest<Result> shiftToken(Tok t, Token.Location loc);
+    public abstract Forest<Result> shiftToken(Tok t, Input.Location loc);
 
     /** parse <tt>input</tt>, using the table <tt>pt</tt> to drive the parser */
-    public Forest<Result> parse(Token.Stream<Tok> input) throws IOException, ParseFailed {
+    public Forest<Result> parse(Input<Tok> input) throws IOException, ParseFailed {
         GSS gss = new GSS();
-        Token.Location loc = input.getLocation();
+        Input.Location loc = input.getLocation();
         GSS.Phase current = gss.new Phase<Tok>(null, this, null, input.next(1, 0, 0), loc, null);
         current.newNode(null, Forest.leaf(null, null), pt.start, true);
         int count = 1;
@@ -38,10 +38,17 @@ public abstract class Parser<Tok, Result> {
     // Table //////////////////////////////////////////////////////////////////////////////
 
     /** an SLR(1) parse table which may contain conflicts */
-    static class Table<Tok> extends Walk.Cache {
+    public static class Table<Tok> extends Walk.Cache {
 
         public final Walk.Cache cache = this;
 
+        public void optimize(Functor<Tok,Integer> f) {
+            for(State<Tok> state : all_states.values()) {
+                state.oreductions = state.reductions.optimize(f);
+                state.oshifts = state.shifts.optimize(f);
+            }
+        }
+
         private void walk(Element e, HashSet<Element> hs) {
             if (e==null) return;
             if (hs.contains(e)) return;
@@ -59,6 +66,7 @@ public abstract class Parser<Tok, Result> {
 
         /** used to generate unique values for State.idx */
         private int master_state_idx = 0;
+        HashMap<HashSet<Position>,State<Tok>>   all_states    = new HashMap<HashSet<Position>,State<Tok>>();
 
         /** construct a parse table for the given grammar */
         public Table(Topology top) { this("s", top); }
@@ -71,7 +79,6 @@ public abstract class Parser<Tok, Result> {
             cache.eof.put(start0, true);
 
             // construct the set of states
-            HashMap<HashSet<Position>,State<Tok>>   all_states    = new HashMap<HashSet<Position>,State<Tok>>();
             HashSet<Element>                        all_elements  = new HashSet<Element>();
             walk(start0, all_elements);
             for(Element e : all_elements)
@@ -102,10 +109,6 @@ public abstract class Parser<Tok, Result> {
                     if (p.element() != null && p.element() instanceof Atom)
                         state.shifts.addAll(state.gotoSetTerminals.subset(((Atom)p.element())));
                 }
-            for(State<Tok> state : all_states.values()) {
-                state.oreductions = state.reductions.optimize();
-                state.oshifts = state.shifts.optimize();
-            }
         }
 
         private boolean isRightNullable(Position p) {