factor Pos out of Position in preparation for serialiable parse tables

[sbp.git] / src / edu / berkeley / sbp / Sequence.java

diff --git a/src/edu/berkeley/sbp/Sequence.java b/src/edu/berkeley/sbp/Sequence.java
index 1c76aef..25d091f 100644 (file)
--- a/src/edu/berkeley/sbp/Sequence.java
+++ b/src/edu/berkeley/sbp/Sequence.java
@@ -24,10 +24,26 @@ public abstract class Sequence implements Iterable<Element>, SequenceOrElement {
     HashMap<Sequence,Boolean> canNeed = new HashMap<Sequence,Boolean>();
     HashMap<Sequence,Boolean> canKill = new HashMap<Sequence,Boolean>();
 
-    final Position          firstp;
+    final Position firstp;
 
     Atom follow = null;
 
+    private static int global_sernum = 0;
+    private int sernum = global_sernum++;
+    int[] needs_int() {
+        int[] ret = new int[needs.size()];
+        int i = 0;
+        for(Sequence s : needs) ret[i++] = s.sernum;
+        return ret;
+    }
+    int[] hates_int() {
+        int[] ret = new int[hates.size()];
+        int i = 0;
+        for(Sequence s : hates) ret[i++] = s.sernum;
+        return ret;
+    }
+
+
     // Static Constructors //////////////////////////////////////////////////////////////////////////////
 
     /** create a sequence of one element */
@@ -118,32 +134,59 @@ public abstract class Sequence implements Iterable<Element>, SequenceOrElement {
 
     // Position //////////////////////////////////////////////////////////////////////////////
 
-    /** the imaginary position before or after an element of a sequence; corresponds to an "LR item" */
-    class Position implements IntegerMappable {
+    static abstract class Pos implements IntegerMappable, Comparable<Pos>, Serializable {
+        final Forest[] holder;
+        Pos(int len) { this.holder = new Forest[len]; }
 
-        public int ord = -1;
+        public abstract int   provides();
+        public abstract int[] needs();
+        public abstract int[] hates();
+        public abstract boolean            owner_needed_or_hated();
+
+        public abstract int numPops();
+        public abstract <T> Forest<T> rewrite(Input.Region loc, Grammar cache);
+    }
 
-        private Forest zero = null;
+    /** the imaginary position before or after an element of a sequence; corresponds to an "LR item" */
+    class Position extends Pos implements IntegerMappable {
         /*
-        public Forest zero(Input.Region reg) {
-            if (zero != null) return zero;
-            if (pos > 0) throw new RuntimeException("Position.zero(): pos>0");
-            return zero = rewrite(reg);
+        public Pos getPos() {
+            return new DumbPos(elements.length, provides(), needs(), hates(), owner_needed_or_hated(), numPops(), 
+                public int   provides();
+                public int[] needs();
+                public int[] hates();
+                public boolean            owner_needed_or_hated();
+                public int numPops();
+                public <T> Forest<T> rewrite(Input.Region loc, Grammar cache)
+            };
         }
         */
+        public int ord = -1;
+        public int ord()     { return ord; }
+        public int numPops() { return pos; }
+
                 final int      pos;
         private final Position next;
         private final Position prev;
-                final Forest[] holder;
+
+        public int     provides() { return owner().sernum; }
+        public int[]   needs() { return owner().needs_int(); }
+        public int[]   hates() { return owner().hates_int(); }
+        public boolean owner_needed_or_hated() { return owner().needed_or_hated; }
         
         private Position(int pos, Position prev) {
+            super(elements.length);
             this.pos      = pos;
             this.next     = pos==elements.length ? null : new Position(pos+1, this);
-            this.holder   = new Forest[elements.length];
             this.prev     = prev;
         }
 
+        public int compareTo(Pos p) {
+            return ord - ((Position)p).ord;
+        }
+
         boolean isFirst() { return pos==0; }
+        public int pos() { return pos; }
 
         /** the element immediately after this Position, or null if this is the last Position */
         public Element  element() { return pos>=elements.length ? null : elements[pos]; }
@@ -161,7 +204,7 @@ public abstract class Sequence implements Iterable<Element>, SequenceOrElement {
 
         // Position /////////////////////////////////////////////////////////////////////////////////
 
-        final <T> Forest<T> rewrite(Input.Region loc, Grammar cache) {
+        public final <T> Forest<T> rewrite(Input.Region loc, Grammar cache) {
             if (this==firstp()) epsilonForm(loc, cache);
             for(int i=0; i<pos; i++) if (holder[i]==null) throw new Error("realbad " + i);
             for(int i=pos; i<elements.length; i++) {
@@ -188,6 +231,7 @@ public abstract class Sequence implements Iterable<Element>, SequenceOrElement {
     }
     private static int master_position_idx = 0;
 
+
     // toString //////////////////////////////////////////////////////////////////////////////
 
     public String toString() { return toString(new StringBuffer(), false).toString(); }
@@ -215,22 +259,6 @@ public abstract class Sequence implements Iterable<Element>, SequenceOrElement {
 
     // Specialized Subclasses //////////////////////////////////////////////////////////////////////////////
 
-    static class Constant extends Sequence {
-        private final Object result;
-        public Constant(Element[] e, Object result) {
-            super(e);
-            if (result==null) throw new Error("constant sequences may not have result==null");
-            this.result = result;
-        }
-        Sequence _clone() { return new Constant(elements, result); }
-        public <T> Forest<T> postReduce(Input.Region loc, Forest<T>[] args, Position p) {
-            return (Forest<T>)Forest.create(loc, result, null, false);
-        }
-        Forest epsilonForm(Input.Region loc, Grammar cache) {
-            return Forest.create(loc, result, null, false);
-        }
-    }
-
     static class Singleton extends Sequence {
         private final int idx;
         public Singleton(Element e) { this(new Element[] { e }, 0); }
@@ -243,7 +271,7 @@ public abstract class Sequence implements Iterable<Element>, SequenceOrElement {
     }
 
     static class RewritingSequence extends Sequence {
-        private Object tag;
+        private final Object    tag;
         private final boolean[] drops;
         private final boolean[] lifts;
         Sequence _clone() { return new RewritingSequence(tag, elements, drops); }