checkpoint

[sbp.git] / src / edu / berkeley / sbp / misc / MetaGrammar.java

diff --git a/src/edu/berkeley/sbp/misc/MetaGrammar.java b/src/edu/berkeley/sbp/misc/MetaGrammar.java
index f8c40ba..ca889b7 100644 (file)
--- a/src/edu/berkeley/sbp/misc/MetaGrammar.java
+++ b/src/edu/berkeley/sbp/misc/MetaGrammar.java
@@ -51,8 +51,8 @@ public class MetaGrammar extends ReflectiveWalker {
 
     // MetaGrammar //////////////////////////////////////////////////////////////////////////////
 
-    public PreSequence _amp_(PreSequence p, Object[] o)        { return p.and(new PreSequence(o, null).buildSequence(null, true, false, true)); }
-    public PreSequence _amp__tilde_(PreSequence p, Object[] o) { return p.not(new PreSequence(o, null).buildSequence(null, true, false, true)); }
+    public PreSequence _amp_(PreSequence p, Object[] o)        { return p.and(new PreSequence(o, null).buildSequence(null, true, false)); }
+    public PreSequence _amp__tilde_(PreSequence p, Object[] o) { return p.not(new PreSequence(o, null).buildSequence(null, true, false)); }
     public Element     epsilon(Object o, Object b)                                    { return Union.epsilon; }
     public Object      _leftparen__rightparen_(Object o)                              { return Union.epsilon; }
     public Element     _rightparen_(Object e)                                         { return SELF; }
@@ -71,7 +71,7 @@ public class MetaGrammar extends ReflectiveWalker {
             HashSet<Sequence> temp = new HashSet<Sequence>();
             for(PreSequence pre : s[i]) {
                 pre.not.addAll(seqs);
-                Sequence seq = pre.buildSequence(n, false, dropAll, false);
+                Sequence seq = pre.buildSequence(n, false, dropAll);
                 temp.add(seq);
                 n.add(seq);
             }
@@ -87,20 +87,15 @@ public class MetaGrammar extends ReflectiveWalker {
                                new PreSequence[] {
                                    new PreSequence(new Element[] { leftBrace(),
                                                                    p.buildUnion(),
-                                                                   rightBrace() })
+                                                                   rightBrace()
+                                   })
                                }
                            },
                            false,
                            false);
     }
 
-    public PreSequence rewrite(Object[] o)                     { return new PreSequence(o, null); }
-
-    public PreSequence seqx(PreSequence p, String tag) { return _equals__greater_(p, tag); }
-    public PreSequence _equals__greater_(PreSequence p, String tag) {
-        p.tag = tag;
-        return p;
-    }
+    public PreSequence _equals__greater_(PreSequence p, String tag) { p.tag = tag; return p; }
 
     public PreSequence ps(Object[] o) { return new PreSequence(o); }
     public PreSequence ps2(Object[] o1, String s, Object[] o2) {
@@ -124,11 +119,18 @@ public class MetaGrammar extends ReflectiveWalker {
     public Object _plus__plus_(final Element r)             { return Repeat.maximal(Repeat.many1(r)); }
     public Element _question_(final Element r)              { return Repeat.maybe(r); }
 
-    public MetaGrammar gram(Object o, MetaGrammar g, Object o2) { return g; }
-    public MetaGrammar  grammar(Object[] o) { return this; }
+    public Object walk(Tree<String> tree) {
+        String head = tree.head();
+        if (tree.numChildren()==0) return super.walk(tree);
+        if      ("\\n".equals(head)) return new Character('\n');
+        else if ("\\r".equals(head)) return new Character('\r');
+        //else if ("grammar".equals(head)) { for(Tree<String> t : tree.children()) walk(t); return this; }
+        else return super.walk(tree);
+    }
+
     public MetaGrammar grammar(Object o, Union[] u, Object x) { return this; }
-    public char    _backslash_n() { return '\n'; }
-    public char    _backslash_r() { return '\r'; }
+    public Object gram(Object o, Object g, Object o2) { return g; }
+    public MetaGrammar  grammar(Object[] o) { return this; }
     public Element    literal(String s) { Element ret = string(s); dropAll.add(ret); return ret; }
     public Range     _minus_(char a, char b) { return new Range(a, b); }
     public Range     range(char a)         { return new Range(a, a); }
@@ -143,6 +145,8 @@ public class MetaGrammar extends ReflectiveWalker {
         return set(ret);
     }
 
+    //////////////////////////////////////////////////////////////////////////////
+
     public class PreSequence {
         public final HashSet<Sequence> and  = new HashSet<Sequence>();
         public final HashSet<Sequence> not  = new HashSet<Sequence>();
@@ -193,8 +197,8 @@ public class MetaGrammar extends ReflectiveWalker {
             u.add(buildSequence(u));
             return u;
         }
-        public Sequence buildSequence(Union u) { return buildSequence(u, false, false, false); }
-        public Sequence buildSequence(Union u, boolean lame, boolean dropAll, boolean keeper) {
+        public Sequence buildSequence(Union u) { return buildSequence(u, false, false); }
+        public Sequence buildSequence(Union u, boolean lame, boolean dropAll) {
             for(Sequence s : and) u.add(s);
             for(Sequence s : not) u.add(s);
             HashSet<Sequence> set = new HashSet<Sequence>();
@@ -214,9 +218,10 @@ public class MetaGrammar extends ReflectiveWalker {
                 }
             }
             Element[] expansion = o2;
-            Sequence ret = dropAll || lame || keeper ? Sequence.drop(expansion, and, not, lame) : null;
-            if (ret==null && tag!=null) ret = Sequence.rewritingSequence(tag, expansion, drops, and, not);
-            if (ret==null) {
+            Sequence ret = null;
+            if (dropAll || lame) ret = Sequence.drop(expansion, and, not, lame);
+            else if (tag!=null) ret = Sequence.rewritingSequence(tag, expansion, drops, and, not);
+            else {
                 int idx = -1;
                 for(int i=0; i<expansion.length; i++) {
                     if (!drops[i]) idx = i;