checkpoint

[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 975b2b1..8d6709d 100644 (file)
--- a/src/edu/berkeley/sbp/Sequence.java
+++ b/src/edu/berkeley/sbp/Sequence.java
@@ -33,7 +33,8 @@ public abstract class Sequence extends Element implements Iterable<Element> {
     }
 
     /** the empty sequence (matches the empty string) */
-    public static final Sequence empty = new Sequence.Constant.Empty();
+    static final Sequence empty = new Sequence.Constant.Empty();
+    public static Sequence empty() { return empty; }
 
     /** after matching the sequence, do not add anything to the output tree */
     public static Sequence drop(Element[] e) { return new Constant.Drop(e); }
@@ -64,8 +65,8 @@ public abstract class Sequence extends Element implements Iterable<Element> {
     public Sequence not(Sequence s) { Sequence ret = dup(); ret.hates.add(s); s.hated.add(ret); return ret; }
     public Sequence followedBy(Atom a) { Sequence ret = dup(); ret.follow = a; return ret; }
 
-    public Iterable<Sequence> needs() { return needs; }
-    public Iterable<Sequence> hates() { return hates; }
+    Iterable<Sequence> needs() { return needs; }
+    Iterable<Sequence> hates() { return hates; }
 
     Position firstp() { return firstp; }
 
@@ -199,13 +200,13 @@ public abstract class Sequence extends Element implements Iterable<Element> {
         Sequence _clone() { return new Singleton(elements,idx); }
     }
 
-    public static Unwrap unwrap(Element[] e, Object tag, boolean[] drops) { return new Unwrap(e, tag, drops); }
+    public static Sequence unwrap(Element[] e, Object tag, boolean[] drops) { return new Unwrap(e, tag, drops); }
     static class Unwrap extends Sequence {
         private boolean[] drops;
         private final Object tag;
         public Unwrap(Element[] e, Object tag)                  { super(e); this.drops = null; this.tag = tag; }
         public Unwrap(Element[] e, Object tag, boolean[] drops) { super(e); this.drops = drops; this.tag = tag; }
-        Sequence _clone() { return new Unwrap(elements, drops); }
+        Sequence _clone() { return new Unwrap(elements, tag, drops); }
         public <T> Forest<T> postReduce(Input.Region loc, Forest<T>[] args, Position p) {
             for(int i=0; i<args.length; i++) if (args[i]==null) throw new Error();
             if (drops==null) return Forest.create(loc, (T)tag, args, true);
@@ -264,40 +265,4 @@ public abstract class Sequence extends Element implements Iterable<Element> {
         }
     }
 
-    // Repeat //////////////////////////////////////////////////////////////////////////////
-
-    /** repeat zero or one times */
-    public  static Element maybe(Element e)                             { return new Repeat(e, true, false, null, null); }
-    public  static Element maybe(Element e, Object tag)                 { return new Repeat(e, true, false, null, tag); }
-    /** repeat zero or more times */
-    public  static Element many0(Element e)                             { return new Repeat(e, true, true, null, null); }
-    public  static Element many0(Element e, Object tag)                 { return new Repeat(e, true, true, null, tag); }
-    /** repeat zero or more times, separated by <tt>sep</tt> */
-    public  static Element many0(Element e, Element sep)                { return new Repeat(e, true, true, sep, null); }
-    public  static Element many0(Element e, Element sep, Object tag)    { return new Repeat(e, true, true, sep, tag); }
-    /** repeat one or more times */
-    public  static Element many1(Element e)                             { return new Repeat(e, false, true, null, null); }
-    public  static Element many1(Element e, Object tag)                 { return new Repeat(e, false, true, null, tag); }
-    /** repeat one or more times, separated by <tt>sep</tt> */
-    public  static Element many1(Element e, Element sep)                { return new Repeat(e, false, true, sep, null); }
-    public  static Element many1(Element e, Element sep, Object tag)    { return new Repeat(e, false, true, sep, tag); }
-
-    /** repeat zero or more times, matching a maximal sequence of atoms */
-    public  static Element maximal0(Atom e)                             { return new Repeat.Maximal(e, true, true, null); }
-    public  static Element maximal0(Atom e, Object tag)                 { return new Repeat.Maximal(e, true, true, tag); }
-    /** repeat one or more times, matching a maximal sequence of atoms */
-    public  static Element maximal1(Atom e)                             { return new Repeat.Maximal(e, false, true, null); }
-    public  static Element maximal1(Atom e, Object tag)                 { return new Repeat.Maximal(e, false, true, tag); }
-    /** repeat one or more times, separated by an atom <tt>sep</tt>, matching a maximal sequence */
-    public  static Element maximal1(Element e, Atom sep)                { return new Repeat.Maximal(e, false, true, sep, null); }
-    public  static Element maximal1(Element e, Atom sep, Object tag)    { return new Repeat.Maximal(e, false, true, sep, tag); }
-
-    public  static Element repeatMaximal(Atom e, boolean zero, boolean many, Object tag) {
-        return new Repeat.Maximal(e, zero, many, tag); }
-    public  static Element repeatMaximal(Element e, boolean zero, boolean many, Atom sep, Object tag) {
-        return new Repeat.Maximal(e, zero, many, sep, tag); }
-    public  static Element repeat(Element e, boolean zero, boolean many, Object tag) {
-        return new Repeat(e, zero, many, tag); }
-    public  static Element repeat(Element e, boolean zero, boolean many, Element sep, Object tag) {
-        return new Repeat(e, zero, many, sep, tag); }
 }