checkpoint

darcs-hash:20060115092900-5007d-dc3054f2bb2d035ccaa6ad46134d9b7c042e2249.gz

diff --git a/src/edu/berkeley/sbp/Parser.java b/src/edu/berkeley/sbp/Parser.java
index 3bafbfe..60da9e4 100644 (file)
--- a/src/edu/berkeley/sbp/Parser.java
+++ b/src/edu/berkeley/sbp/Parser.java
@@ -8,11 +8,11 @@ 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);
@@ -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) {

diff --git a/src/edu/berkeley/sbp/misc/CharRange.java b/src/edu/berkeley/sbp/misc/CharRange.java
index 59ee325..5a1c24c 100644 (file)
--- a/src/edu/berkeley/sbp/misc/CharRange.java
+++ b/src/edu/berkeley/sbp/misc/CharRange.java
@@ -36,7 +36,7 @@ public class CharRange extends Atom<CharToken> {
     }
     public static final Atom leftBrace  = CharToken.leftBrace;
     public static final Atom rightBrace = CharToken.rightBrace;
-    public static Atom set(Range.Set r) { return new CharRange(new IntegerTopology<CharToken>(null, r)); }
+    public static Atom set(Range.Set r) { return new CharRange(new IntegerTopology<CharToken>(CharToken.c2i, r)); }
     private static final Range.Set all = new Range.Set(new Range(0, Character.MAX_VALUE));
 
     /** returns an element which exactly matches the string given */
@@ -46,13 +46,13 @@ public class CharRange extends Atom<CharToken> {
         Element ret;
         if (s.length() == 1) {
             ret =
-                new CharRange(new IntegerTopology<CharToken>(null, (int)s.charAt(0))) {
+                new CharRange(new IntegerTopology<CharToken>(CharToken.c2i, (int)s.charAt(0))) {
                     public String toString() { return escapified; } };
         } else {
             Union ret2 = new Union("\""+s+"\"_str", true) {
                     public String toString() { return escapified; } };
             Element[] refs = new Element[s.length()];
-            for(int i=0; i<refs.length; i++) refs[i] = new CharRange(new IntegerTopology<CharToken>(null, (int)s.charAt(i)));
+            for(int i=0; i<refs.length; i++) refs[i] = new CharRange(new IntegerTopology<CharToken>(CharToken.c2i, (int)s.charAt(i)));
             ret2.add(Sequence.constant(refs, s, null, null));
             ret = ret2;
         }

diff --git a/src/edu/berkeley/sbp/misc/CharToStringParser.java b/src/edu/berkeley/sbp/misc/CharToStringParser.java
index c66ff5d..f4395b9 100644 (file)
--- a/src/edu/berkeley/sbp/misc/CharToStringParser.java
+++ b/src/edu/berkeley/sbp/misc/CharToStringParser.java
@@ -15,7 +15,10 @@ public class CharToStringParser extends Parser<CharToken,String> {
         return super.parse(new Stream(r));
     }
 
-    public CharToStringParser(Union u) { super(u, new IntegerTopology<CharToken>(null)); }
+    public CharToStringParser(Union u) {
+        super(u, new IntegerTopology<CharToken>(CharToken.c2i));
+        pt.optimize(CharToken.c2i);
+    }
     public Forest<String> shiftToken(CharToken ct, Location loc) {
         return Forest.create(loc, ct.result(), null, false, false);
     }

diff --git a/src/edu/berkeley/sbp/misc/CharToken.java b/src/edu/berkeley/sbp/misc/CharToken.java
index eafe882..580e851 100644 (file)
--- a/src/edu/berkeley/sbp/misc/CharToken.java
+++ b/src/edu/berkeley/sbp/misc/CharToken.java
@@ -8,10 +8,14 @@ import edu.berkeley.sbp.Token.Location;
 import edu.berkeley.sbp.util.*;
 
 /** an implementation of Token for streams of Java <tt>char</tt> values */
-public class CharToken implements IntegerMappable {
+public class CharToken {
 
-    public static final Atom leftBrace  = new CharRange(new IntegerTopology<CharToken>(null, 9998)) { public String toString() { return "{"; } };
-    public static final Atom rightBrace = new CharRange(new IntegerTopology<CharToken>(null, 9999)) { public String toString() { return "}"; } };
+    public static final Functor<CharToken,Integer> c2i = new Functor<CharToken,Integer>() {
+        public Integer invoke(CharToken c) { return new Integer(c.c); }
+    };
+
+    public static final Atom leftBrace  = new CharRange(new IntegerTopology<CharToken>(c2i, 9998)) { public String toString() { return "{"; } };
+    public static final Atom rightBrace = new CharRange(new IntegerTopology<CharToken>(c2i, 9999)) { public String toString() { return "}"; } };
     public static final CharToken left       = new CharToken((char)9998);
     public static final CharToken right      = new CharToken((char)9999);
     

diff --git a/src/edu/berkeley/sbp/util/TopologicalBag.java b/src/edu/berkeley/sbp/util/TopologicalBag.java
index 9a18eef..2595602 100644 (file)
--- a/src/edu/berkeley/sbp/util/TopologicalBag.java
+++ b/src/edu/berkeley/sbp/util/TopologicalBag.java
@@ -135,7 +135,7 @@ public class TopologicalBag<K,V> implements MapBag<Topology<K>,V>, VisitableMap<
         }
     }
 
-    public VisitableMap<K,V> optimize() {
+    public VisitableMap<K,V> optimize(final Functor<K,Integer> f) {
         ArrayList<Long> min_ = new ArrayList<Long>();
         ArrayList<Long> max_ = new ArrayList<Long>();
         ArrayList<Object[]> v_ = new ArrayList<Object[]>();
@@ -157,16 +157,14 @@ public class TopologicalBag<K,V> implements MapBag<Topology<K>,V>, VisitableMap<
         final Object[][]   v = new Object[size][]; v_.toArray(v);
         return new VisitableMap<K,V>() {
             public boolean contains(K k) {
-                IntegerMappable im = (IntegerMappable)k;
-                int asint = im.toInt();
+                int asint = f.invoke(k);
                 for(int i=0; i<size; i++)
                     if (min[i] <= asint && max[i] >= asint && v[i].length > 0)
                         return true;
                 return false;
             }
             public <B,C> void invoke(K k, Invokable<V,B,C> ivbc, B b, C c) {
-                IntegerMappable im = (IntegerMappable)k;
-                int asint = im.toInt();
+                int asint = f.invoke(k);
                 for(int i=0; i<size; i++) {
                     if (min[i] <= asint && max[i] >= asint) {
                         Object[] arr = v[i];