X-Git-Url: http://git.megacz.com/?p=sbp.git;a=blobdiff_plain;f=src%2Fedu%2Fberkeley%2Fsbp%2FSequence.java;h=430f29813c37952956b6cf0762f4a4c03219840f;hp=25d091faf93422920227b4445eebe77063252cc3;hb=260e46cff8995fb5a01e94c1a707d0ffff0a5382;hpb=4692c8e9ba0c4b44ac5222f5bf5168703c478cbd

diff --git a/src/edu/berkeley/sbp/Sequence.java b/src/edu/berkeley/sbp/Sequence.java
index 25d091f..430f298 100644
--- a/src/edu/berkeley/sbp/Sequence.java
+++ b/src/edu/berkeley/sbp/Sequence.java
@@ -1,4 +1,4 @@
-// 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.util.*;
@@ -115,8 +115,8 @@ public abstract class Sequence implements Iterable<Element>, SequenceOrElement {
     Iterable<Sequence> needs() { return needs; }
     Iterable<Sequence> hates() { return hates; }
 
-    Position firstp() { return firstp; }
-    Position lastp() { return firstp().last(); }
+    Pos firstp() { return firstp; }
+    Pos lastp() { return firstp().last(); }
 
     public Iterator<Element> iterator()    { return new ArrayIterator<Element>(elements); }
     protected Sequence(Element[] elements) {
@@ -124,10 +124,10 @@ public abstract class Sequence implements Iterable<Element>, SequenceOrElement {
         for(int i=0; i<elements.length; i++)
             if (elements[i]==null)
                 throw new RuntimeException("cannot have nulls in a sequence: " + this);
-        this.firstp = new Position(0, null);
+        this.firstp = new Position(this, 0, null);
     }
 
-    abstract Forest epsilonForm(Input.Region loc, Grammar cache);
+    abstract Forest epsilonForm(Input.Region loc);
 
     protected abstract <T> Forest<T> postReduce(Input.Region loc, Forest<T>[] args, Position p);
 
@@ -135,20 +135,41 @@ public abstract class Sequence implements Iterable<Element>, SequenceOrElement {
     // Position //////////////////////////////////////////////////////////////////////////////
 
     static abstract class Pos implements IntegerMappable, Comparable<Pos>, Serializable {
+
+        public int ord = -1;
+        private transient Sequence owner;
+
+        public int ord()     { return ord; }
+
         final Forest[] holder;
-        Pos(int len) { this.holder = new Forest[len]; }
+
+        Pos(int len, Sequence owner) {
+            this.owner = owner;
+            this.holder = new Forest[len];
+        }
 
         public abstract int   provides();
         public abstract int[] needs();
         public abstract int[] hates();
         public abstract boolean            owner_needed_or_hated();
 
+        public abstract boolean isFirst();
+        public abstract boolean isLast();
+        public abstract Pos last();
+        public abstract Pos prev();
+        public abstract Pos next();
+
+        /** the element which produces the sequence to which this Position belongs */
+        public Sequence owner() { return owner; }
+
+        abstract Element  element();
+
         public abstract int numPops();
-        public abstract <T> Forest<T> rewrite(Input.Region loc, Grammar cache);
+        public abstract <T> Forest<T> rewrite(Input.Region loc);
     }
 
     /** the imaginary position before or after an element of a sequence; corresponds to an "LR item" */
-    class Position extends Pos implements IntegerMappable {
+    private static class Position extends Pos implements IntegerMappable {
         /*
         public Pos getPos() {
             return new DumbPos(elements.length, provides(), needs(), hates(), owner_needed_or_hated(), numPops(), 
@@ -157,27 +178,25 @@ public abstract class Sequence implements Iterable<Element>, SequenceOrElement {
                 public int[] hates();
                 public boolean            owner_needed_or_hated();
                 public int numPops();
-                public <T> Forest<T> rewrite(Input.Region loc, Grammar cache)
+                public <T> Forest<T> rewrite(Input.Region loc)
             };
         }
         */
-        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     int      pos;
+        private final     Position next;
+        private final     Position prev;
 
         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);
+        private Position(Sequence owner, int pos, Position prev) {
+            super(owner.elements.length,owner);
             this.pos      = pos;
-            this.next     = pos==elements.length ? null : new Position(pos+1, this);
+            this.next     = pos==owner.elements.length ? null : new Position(owner, pos+1, this);
             this.prev     = prev;
         }
 
@@ -185,14 +204,11 @@ public abstract class Sequence implements Iterable<Element>, SequenceOrElement {
             return ord - ((Position)p).ord;
         }
 
-        boolean isFirst() { return pos==0; }
+        public 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]; }
-
-        /** the element which produces the sequence to which this Position belongs */
-        public Sequence owner() { return Sequence.this; }
+        public Element  element() { return pos>=owner().elements.length ? null : owner().elements[pos]; }
 
         /** the next Position (the Position after <tt>this.element()</tt>) */
         public Position next() { return next; }
@@ -204,20 +220,20 @@ public abstract class Sequence implements Iterable<Element>, SequenceOrElement {
 
         // Position /////////////////////////////////////////////////////////////////////////////////
 
-        public final <T> Forest<T> rewrite(Input.Region loc, Grammar cache) {
-            if (this==firstp()) epsilonForm(loc, cache);
+        public final <T> Forest<T> rewrite(Input.Region loc) {
+            if (isFirst()) return owner().epsilonForm(loc);
             for(int i=0; i<pos; i++) if (holder[i]==null) throw new Error("realbad " + i);
-            for(int i=pos; i<elements.length; i++) {
-                if (holder[i]==null) holder[i] = ((Union)elements[i]).epsilonForm(loc, cache);
+            for(int i=pos; i<owner().elements.length; i++) {
+                if (holder[i]==null) holder[i] = ((Union)owner().elements[i]).epsilonForm(loc);
                 if (holder[i]==null) throw new Error("bad");
             }
-            return Sequence.this.postReduce(loc, holder, this);
+            return owner().postReduce(loc, holder, this);
         }
 
         public String   toString() {
             StringBuffer ret = new StringBuffer();
             ret.append("<{");
-            for(Position p = Sequence.this.firstp(); p != null; p = p.next()) {
+            for(Position p = (Position)owner().firstp(); p != null; p = p.next()) {
                 ret.append(' ');
                 if (p==this) ret.append(" | ");
                 if (p.element()!=null) ret.append(p.element());
@@ -256,7 +272,6 @@ public abstract class Sequence implements Iterable<Element>, SequenceOrElement {
         return sb;
     }
 
-
     // Specialized Subclasses //////////////////////////////////////////////////////////////////////////////
 
     static class Singleton extends Sequence {
@@ -265,8 +280,8 @@ public abstract class Sequence implements Iterable<Element>, SequenceOrElement {
         public Singleton(Element[] e, int idx) { super(e); this.idx = idx; }
         public <T> Forest<T> postReduce(Input.Region loc, Forest<T>[] args, Position p) { return args[idx]; }
         Sequence _clone() { return new Singleton(elements,idx); }
-        Forest epsilonForm(Input.Region loc, Grammar cache) {
-            return ((Union)elements[idx]).epsilonForm(loc, cache);
+        Forest epsilonForm(Input.Region loc) {
+            return ((Union)elements[idx]).epsilonForm(loc);
         }
     }
 
@@ -305,7 +320,7 @@ public abstract class Sequence implements Iterable<Element>, SequenceOrElement {
             if (spacing) for(int i=0; i<50-len; i++) sb.append(' ');
             return sb;
         }
-        Forest epsilonForm(Input.Region loc, Grammar cache) {
+        Forest epsilonForm(Input.Region loc) {
             return Forest.create(loc, tag, new Forest[0], lifts);
         }
     }