added decent error reporting

darcs-hash:20060107094233-5007d-1b1b3e16497e5ff150384e14df7a7729b369196a.gz

diff --git a/TODO b/TODO
index fd55d0b..c7ad150 100644 (file)
--- a/TODO
+++ b/TODO
@@ -131,3 +131,17 @@ Neat Ideas
 
   - Rekers & Koorn note that GLR Substring Parsing can be used to do
     really elegant and generalized "autocompletion".
+
+
+______________________________________________________________________________
+Ideas for the Future
+
+- Incremental parse table construction
+- "lazy GLR" and "lazy trees" -> language with first-class CF matching
+    - perhaps linear boolean grammars instead? (linear time, quad space)
+- Forest parsing => chained parsers
+- unification parsing, attributes, etc
+- RRP grammars?
+- Take another stab at maximal-match?  Nonterminal not-followed-by is
+  too strong.
+- Error recovery based on substring parsing

diff --git a/src/edu/berkeley/sbp/GSS.java b/src/edu/berkeley/sbp/GSS.java
index 311fd29..3843f57 100644 (file)
--- a/src/edu/berkeley/sbp/GSS.java
+++ b/src/edu/berkeley/sbp/GSS.java
@@ -1,6 +1,7 @@
 package edu.berkeley.sbp;
 import edu.berkeley.sbp.*;
 import edu.berkeley.sbp.util.*;
+import edu.berkeley.sbp.Sequence.Position;
 import java.io.*;
 import java.util.*;
 import java.lang.reflect.*;
@@ -41,16 +42,88 @@ class GSS {
             this.location = location;
         }
 
-        public boolean isDone() { return token == null; }
+        public void complain(Node n, HashMap<String,HashSet<String>> errors, boolean force) {
+            if (n.touched) return;
+            n.touched = true;
+            for(Position p : n.state) {
+                //if (!p.isLast()) { 
+                if (((p.isFirst() || p.isLast()) && !force) || p.owner().name==null) {
+                    for(Node n2 : n.parents())
+                        complain(n2, errors, force | p.isFirst());
+                } else {
+                    String seqname = p.owner().name;
+                    HashSet<String> hs = errors.get(seqname);
+                    if (hs==null) errors.put(seqname, hs = new HashSet<String>());
+                    hs.add(p.element()+"");
+                    //String s = "  while parsing " + seqname + ": expected a " + p.element();
+                        //"\n";
+                    /*
+                    s +=       "      parsed: ";
+                    for(Position p2 = p.owner().firstp(); p2 != null && p2 != p && !p2.isLast(); p2 = p2.next()) s += (p2.element() + " ");
+                    s += "\n";
+                    s +=       "    expected: ";
+                    for(Position p2 = p; p2 != null && !p2.isLast(); p2 = p2.next()) s += (p2.element() + " ");
+                    */
+                    //s += "\n";
+                    //errors.add(s);
+                }
+            }
+        }
 
-        private String error = "generic syntax error";
-        public void checkFailure() throws Parser.Failed {
+        public String black(Object o) { return "\033[30m"+o+"\033[0m"; }
+        public String red(Object o) { return "\033[31m"+o+"\033[0m"; }
+        public String green(Object o) { return "\033[32m"+o+"\033[0m"; }
+        public String yellow(Object o) { return "\033[33m"+o+"\033[0m"; }
+        public String blue(Object o) { return "\033[34m"+o+"\033[0m"; }
+        public String purple(Object o) { return "\033[35m"+o+"\033[0m"; }
+        public String cyan(Object o) { return "\033[36m"+o+"\033[0m"; }
+        public String el(Object e) {
+            String s = e.toString();
+            if (s.length()==0 || s.charAt(0)!='\"' || s.charAt(s.length()-1)!='\"') return yellow(s);
+            s = s.substring(1);
+            s = s.substring(0, s.length()-1);
+            StringBuffer ret = new StringBuffer();
+            for(int i=0; i<s.length(); i++) {
+                if (s.charAt(i)=='\\' && i<s.length()-1) ret.append(s.charAt(++i));
+                else ret.append(s);
+            }
+            return purple(ret.toString());
+        }
+        public String error(String message) {
+            String lookAhead = token==null ? "<EOF>" : token.toString();
+            StringBuffer ret = new StringBuffer();
+            ret.append("\n  ");
+            ret.append(message);
+            HashMap<String,HashSet<String>> errors = new HashMap<String,HashSet<String>>();
+            for(Node n : hash.values()) complain(n, errors, false);
+            for(String s : errors.keySet()) {
+                ret.append("    while parsing " + yellow(s));
+                HashSet<String> hs = errors.get(s);
+                if (hs.size()==1) ret.append(" expected " + yellow(el(hs.iterator().next())) + "\n");
+                else {
+                    ret.append(" expected ");
+                    boolean first = true;
+                    for(String s2 : hs) {
+                        if (!first) ret.append(" or ");
+                        first = false;
+                        ret.append(yellow(el(s2)));
+                    }
+                    ret.append("\n");
+                }
+            }
+            return ret.toString();
+        }
+        
+        public boolean isDone() throws Parser.Failed {
+            if (token != null) return false;
             if (token==null && finalResult==null)
-                throw new Parser.Failed(error, getLocation());
-            if (numNodes <= 0)
-                throw new Parser.Failed(error, getLocation());
+                throw new Parser.Failed(error(red("unexpected end of file\n")),
+                                        getLocation());
+            return true;
         }
 
+        private String error = "generic syntax error";
+
         public Token.Location getLocation() { return location; }
 
         /** add a new node (merging with existing nodes if possible)
@@ -60,25 +133,26 @@ class GSS {
          *  @param fromEmptyReduction true iff this node is being created as a result of a reduction of length zero (see GRMLR paper)
          *  @param start              the earliest part of the input contributing to this node (used to make merging decisions)
          */
-        public void newNode(Node parent, Forest pending, Parser.Table.State state, boolean fromEmptyReduction) {
+        public boolean newNode(Node parent, Forest pending, Parser.Table.State state, boolean fromEmptyReduction) {
             Node p = hash.get(code(state, parent==null?null:parent.phase()));
-            if (p != null)  newNode2(p, parent, pending, state, fromEmptyReduction);
-            else            newNode3(parent, pending, state, fromEmptyReduction);
+            if (p != null)  return newNode2(p, parent, pending, state, fromEmptyReduction);
+            else            return newNode3(parent, pending, state, fromEmptyReduction);
         }
-        private void newNode2(Node p, Node parent, Forest pending, Parser.Table.State state, boolean fromEmptyReduction) {
+        private boolean newNode2(Node p, Node parent, Forest pending, Parser.Table.State state, boolean fromEmptyReduction) {
             p.holder.merge(pending);
-            if (p.parents().contains(parent)) return;
+            if (p.parents().contains(parent)) return true;
             //if (p.fe && p.phase() != parent.phase()) throw new Error("yep yep");
             //if (!p.fe && p.phase() == parent.phase()) throw new Error("yep yep2");
             p.parents().add(parent, true);
             if (p!=parent && !fromEmptyReduction) p.queueReductions(parent);
+            return true;
         }
-        private void newNode3(Node parent, Forest pending, Parser.Table.State state, boolean fromEmptyReduction) {
+        private boolean newNode3(Node parent, Forest pending, Parser.Table.State state, boolean fromEmptyReduction) {
             do {
                 if (token != null && state.canShift(token)) break;
                 if (state.isAccepting()) break;
                 if (token==null) break;
-                if (!state.canReduce(token)) return;
+                //if (!state.canReduce(token)) return false;
                 //if (count > 1) break;
                 //if (r.numPop == 0) break;
                 //r.reduce(pending, parent, null, Phase.this, null);
@@ -88,6 +162,7 @@ class GSS {
             Node n = new Node(parent, pending, state, fromEmptyReduction);  // ALLOC
             n.queueEmptyReductions();
             if (!fromEmptyReduction) n.queueReductions(parent);
+            return true;
         }
 
         
@@ -111,13 +186,14 @@ class GSS {
             }
         }
 
+        private boolean good = false;
         public void invoke(Parser.Table.State st, Forest result, Node n) {
-            next.newNode(n, result, st, false);
+            good |= next.newNode(n, result, st, false);
         }
         private Phase next = null;
 
         /** perform all shift operations, adding promoted nodes to <tt>next</tt> */
-        public void shift(Phase next, Forest result) {
+        public void shift(Phase next, Forest result) throws Parser.Failed {
             this.next = next;
             closed = true;
             Forest res = null;
@@ -126,41 +202,20 @@ class GSS {
                 if (n.holder==null) continue;
                 n.holder.resolve();
                 if (token == null && n.state.isAccepting()) {
-                    ok = true;
                     if (finalResult==null) finalResult = new Forest.Ref();
                     finalResult.merge(n.holder);
                 }
                 if (!n.holder.valid()) continue;
                 if (token == null) continue;
                 n.state.invokeShifts(token, this, result, n);
-                /*
-                for(Parser.Table.State st : n.state.getShifts(token)) {
-                    if (res == null) res = result;
-                    next.newNode(n, res, st, true, this);
-                    ok = true;
-                }
-                */
             }
 
-            if (!ok && token != null) {
-                StringBuffer error = new StringBuffer();
-                error.append("error: unable to shift token \"" + token + "\"\n");
-                //error.append("  before: " +pendingReductions+ "\n");
-                //error.append("  before: " +totalReductions+ "\n");
-                //for(Phase.Node n : hash.values()) {
-                //n.queueReductions();
-                //n.queueEmptyReductions();
-                //}
-                //error.append("  after: " +pendingReductions+ "\n");
-                //error.append("  candidate states:\n");
-                //for(Phase.Node n : hash.values()) {
-                    //for(Sequence.Position p : n.state) error.append("        " + p + "\n");
-                    //error.append("        --\n");
-                //for(Parser.Table.Reduction r : n.state.getReductions(token)) error.append("        " + r + "\n");
-                    //error.append("        ==\n");
-                //}
-                next.error = error.toString();
-            }
+            if (!good && token!=null)
+                throw new Parser.Failed(error(red("unexpected character")+" "+purple(token)+" encountered at "+green(getLocation())+"\n"),
+                                        getLocation());
+            if (token==null && finalResult==null)
+                throw new Parser.Failed(error(red("unexpected end of file\n")),
+                                        getLocation());
 
             // this massively improves GC performance
             hash = null;
@@ -172,6 +227,7 @@ class GSS {
         /** a node in the GSS */
         public final class Node extends FastSet<Node> implements Invokable<Parser.Table.Reduction, Node, Node> {
 
+            public boolean touched = false;
             private Forest.Ref holder = null;
             private boolean allqueued = false;
 

diff --git a/src/edu/berkeley/sbp/Parser.java b/src/edu/berkeley/sbp/Parser.java
index 1a0d307..ddee582 100644 (file)
--- a/src/edu/berkeley/sbp/Parser.java
+++ b/src/edu/berkeley/sbp/Parser.java
@@ -41,12 +41,12 @@ public abstract class Parser<T extends Token, R> {
         int count = 1;
         for(;;) {
             loc = input.getLocation();
+            //current.checkFailure();
             GSS.Phase next = gss.new Phase(current, input.next(count), loc);
             current.reduce();
             Forest forest = current.token==null ? null : shiftedToken((T)current.token, loc);
             current.shift(next, forest);
             count = next.hash.size();
-            current.checkFailure();
             if (current.isDone()) return (Forest<R>)current.finalResult;
             current = next;
         }
@@ -61,7 +61,7 @@ public abstract class Parser<T extends Token, R> {
         public Failed() { this("", null); }
         public Failed(String message, Token.Location loc) { this.location = loc; this.message = message; }
         public Token.Location getLocation() { return location; }
-        public String toString() { return message + (location==null ? "" : (" at " + location)); }
+        public String toString() { return message/* + (location==null ? "" : (" at " + location))*/; }
     }
 
     public static class Ambiguous extends RuntimeException {

diff --git a/src/edu/berkeley/sbp/Sequence.java b/src/edu/berkeley/sbp/Sequence.java
index 9f2fb59..065150c 100644 (file)
--- a/src/edu/berkeley/sbp/Sequence.java
+++ b/src/edu/berkeley/sbp/Sequence.java
@@ -36,6 +36,8 @@ public abstract class Sequence extends Element implements Iterable<Element> {
     ////////////////////////////////////////////////////////////////////////////////
 
     public Element noFollow = null;
+    public String name = null;
+    public void setName(String name) { this.name = name; }
     public final Topology noFollow() { return noFollow==null ? null : noFollow.toAtom(); }
 
     Topology toAtom() {
@@ -45,6 +47,8 @@ public abstract class Sequence extends Element implements Iterable<Element> {
 
     protected final Element[] elements;
 
+          HashSet<Sequence> needed;
+          HashSet<Sequence> hated;
     final HashSet<Sequence> needs;
     final HashSet<Sequence> hates;
           boolean           lame  = false;
@@ -56,6 +60,12 @@ public abstract class Sequence extends Element implements Iterable<Element> {
     protected Sequence(Element[] elements, HashSet<Sequence> and, HashSet<Sequence> not) {
         this.needs = and==null ? new HashSet<Sequence>() : and;
         this.hates = not==null ? new HashSet<Sequence>() : not;
+        if (this.needs != null)
+            for(Sequence s : this.needs)
+                (s.needed==null?(s.needed=new HashSet<Sequence>()):s.needed).add(this);
+        if (this.hates != null)
+            for(Sequence s : this.hates)
+                (s.hated==null?(s.hated=new HashSet<Sequence>()):s.hated).add(this);
         this.elements = elements;
         this.firstp = new Position(0);
     }

diff --git a/src/edu/berkeley/sbp/Union.java b/src/edu/berkeley/sbp/Union.java
index 9ac5e61..ea2e2db 100644 (file)
--- a/src/edu/berkeley/sbp/Union.java
+++ b/src/edu/berkeley/sbp/Union.java
@@ -30,7 +30,13 @@ public class Union extends Element implements Iterable<Sequence> {
     }
 
     /** adds an alternative */
-    public void add(Sequence s) { alternatives.add(s); }
+    public void add(Sequence s) {
+        alternatives.add(s);
+        if (/*!synthetic &&*/ shortForm!=null
+            && Character.isUpperCase(shortForm.charAt(0))
+            )
+            s.setName(toString());
+    }
 
     /**
      *  Since every cycle in a non-degenerate grammar contains at

diff --git a/src/edu/berkeley/sbp/misc/MetaGrammar.java b/src/edu/berkeley/sbp/misc/MetaGrammar.java
index 9dd3e62..146e94d 100644 (file)
--- a/src/edu/berkeley/sbp/misc/MetaGrammar.java
+++ b/src/edu/berkeley/sbp/misc/MetaGrammar.java
@@ -348,9 +348,12 @@ public class MetaGrammar extends StringWalker {
 
 
 
+
+
+
         // DO NOT EDIT STUFF BELOW: IT IS AUTOMATICALLY GENERATED
 new edu.berkeley.sbp.Tree(null, "gram", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "grammar", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "::=", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "s", new edu.berkeley.sbp.Tree[] { })}),
-        new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "=>", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "psy", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "ps", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "nonTerminal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "g", new edu.berkeley.sbp.Tree[] { }),
+        new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "=>", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "psy", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "ps", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "nonTerminal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "G", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "r", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "a", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "m", new edu.berkeley.sbp.Tree[] { }),
@@ -376,7 +379,7 @@ new edu.berkeley.sbp.Tree(null, "gram", new edu.berkeley.sbp.Tree[] { new edu.be
         new edu.berkeley.sbp.Tree(null, "!::=", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "w", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "p", new edu.berkeley.sbp.Tree[] { })}),
         new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "psy", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "ps", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "++", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "nonTerminal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "w", new edu.berkeley.sbp.Tree[] { })})})})})})})})})}),
-        new edu.berkeley.sbp.Tree(null, "::=", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "g", new edu.berkeley.sbp.Tree[] { }),
+        new edu.berkeley.sbp.Tree(null, "::=", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "G", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "r", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "a", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "m", new edu.berkeley.sbp.Tree[] { }),
@@ -449,7 +452,7 @@ new edu.berkeley.sbp.Tree(null, "gram", new edu.berkeley.sbp.Tree[] { new edu.be
         new edu.berkeley.sbp.Tree(null, "v", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "e", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "s", new edu.berkeley.sbp.Tree[] { })}),
-        new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "psy", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "ps", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "+/", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "(", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "psy", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "ps", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "+/", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "nonTerminal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "c", new edu.berkeley.sbp.Tree[] { }),
+        new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "psy", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "ps", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "+/", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "(", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "psy", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "ps", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "+/", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "nonTerminal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "C", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "o", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "n", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "j", new edu.berkeley.sbp.Tree[] { }),
@@ -468,7 +471,7 @@ new edu.berkeley.sbp.Tree(null, "gram", new edu.berkeley.sbp.Tree[] { new edu.be
         new edu.berkeley.sbp.Tree(null, "literal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, ">", new edu.berkeley.sbp.Tree[] { })})}),
         new edu.berkeley.sbp.Tree(null, "nonTerminal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "w", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "s", new edu.berkeley.sbp.Tree[] { })})})})})})})})})})})})})})})}),
-        new edu.berkeley.sbp.Tree(null, "::=", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "c", new edu.berkeley.sbp.Tree[] { }),
+        new edu.berkeley.sbp.Tree(null, "::=", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "C", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "o", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "n", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "j", new edu.berkeley.sbp.Tree[] { }),
@@ -477,7 +480,7 @@ new edu.berkeley.sbp.Tree(null, "gram", new edu.berkeley.sbp.Tree[] { new edu.be
         new edu.berkeley.sbp.Tree(null, "c", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "t", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "s", new edu.berkeley.sbp.Tree[] { })}),
-        new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "psy", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "ps", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "nonTerminal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "s", new edu.berkeley.sbp.Tree[] { }),
+        new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "psy", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "ps", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "nonTerminal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "S", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "e", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "q", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "u", new edu.berkeley.sbp.Tree[] { }),
@@ -485,7 +488,7 @@ new edu.berkeley.sbp.Tree(null, "gram", new edu.berkeley.sbp.Tree[] { new edu.be
         new edu.berkeley.sbp.Tree(null, "n", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "c", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "e", new edu.berkeley.sbp.Tree[] { })})})})})}),
-        new edu.berkeley.sbp.Tree(null, "psy", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "/", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "ps2", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "nonTerminal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "s", new edu.berkeley.sbp.Tree[] { }),
+        new edu.berkeley.sbp.Tree(null, "psy", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "/", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "ps2", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "nonTerminal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "S", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "e", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "q", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "u", new edu.berkeley.sbp.Tree[] { }),
@@ -499,7 +502,7 @@ new edu.berkeley.sbp.Tree(null, "gram", new edu.berkeley.sbp.Tree[] { new edu.be
         new edu.berkeley.sbp.Tree(null, "s", new edu.berkeley.sbp.Tree[] { })})})})})}),
         new edu.berkeley.sbp.Tree(null, "nonTerminal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "w", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "s", new edu.berkeley.sbp.Tree[] { })})})})}),
-        new edu.berkeley.sbp.Tree(null, "psy", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "/", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "ps2", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "nonTerminal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "s", new edu.berkeley.sbp.Tree[] { }),
+        new edu.berkeley.sbp.Tree(null, "psy", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "/", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "ps2", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "nonTerminal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "S", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "e", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "q", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "u", new edu.berkeley.sbp.Tree[] { }),
@@ -527,7 +530,7 @@ new edu.berkeley.sbp.Tree(null, "gram", new edu.berkeley.sbp.Tree[] { new edu.be
         new edu.berkeley.sbp.Tree(null, "nonTerminal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "w", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "s", new edu.berkeley.sbp.Tree[] { })})})})})})})})})}),
         new edu.berkeley.sbp.Tree(null, "literal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "^", new edu.berkeley.sbp.Tree[] { })})}),
-        new edu.berkeley.sbp.Tree(null, "nonTerminal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "q", new edu.berkeley.sbp.Tree[] { }),
+        new edu.berkeley.sbp.Tree(null, "nonTerminal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "Q", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "u", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "o", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "t", new edu.berkeley.sbp.Tree[] { }),
@@ -603,7 +606,7 @@ new edu.berkeley.sbp.Tree(null, "gram", new edu.berkeley.sbp.Tree[] { new edu.be
         new edu.berkeley.sbp.Tree(null, "y", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "l", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "r", new edu.berkeley.sbp.Tree[] { })})})})})}),
-        new edu.berkeley.sbp.Tree(null, "::=", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "s", new edu.berkeley.sbp.Tree[] { }),
+        new edu.berkeley.sbp.Tree(null, "::=", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "S", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "e", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "q", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "u", new edu.berkeley.sbp.Tree[] { }),
@@ -611,7 +614,7 @@ new edu.berkeley.sbp.Tree(null, "gram", new edu.berkeley.sbp.Tree[] { new edu.be
         new edu.berkeley.sbp.Tree(null, "n", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "c", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "e", new edu.berkeley.sbp.Tree[] { })}),
-        new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "=>", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "psy", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "ps", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "nonTerminal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "q", new edu.berkeley.sbp.Tree[] { }),
+        new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "=>", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "psy", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "ps", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "nonTerminal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "Q", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "u", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "o", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "t", new edu.berkeley.sbp.Tree[] { }),
@@ -644,7 +647,7 @@ new edu.berkeley.sbp.Tree(null, "gram", new edu.berkeley.sbp.Tree[] { new edu.be
         new edu.berkeley.sbp.Tree(null, "o", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "r", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "d", new edu.berkeley.sbp.Tree[] { })})})})})}),
-        new edu.berkeley.sbp.Tree(null, "psy", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "ps", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "nonTerminal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "q", new edu.berkeley.sbp.Tree[] { }),
+        new edu.berkeley.sbp.Tree(null, "psy", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "ps", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "nonTerminal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "Q", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "u", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "o", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "t", new edu.berkeley.sbp.Tree[] { }),
@@ -664,7 +667,7 @@ new edu.berkeley.sbp.Tree(null, "gram", new edu.berkeley.sbp.Tree[] { new edu.be
         new edu.berkeley.sbp.Tree(null, "p", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "e", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "d", new edu.berkeley.sbp.Tree[] { })})})})})})})})}),
-        new edu.berkeley.sbp.Tree(null, "::=", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "r", new edu.berkeley.sbp.Tree[] { }),
+        new edu.berkeley.sbp.Tree(null, "::=", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "R", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "a", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "n", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "g", new edu.berkeley.sbp.Tree[] { }),
@@ -697,7 +700,7 @@ new edu.berkeley.sbp.Tree(null, "gram", new edu.berkeley.sbp.Tree[] { new edu.be
         new edu.berkeley.sbp.Tree(null, "n", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "a", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "l", new edu.berkeley.sbp.Tree[] { })})}),
-        new edu.berkeley.sbp.Tree(null, "=>", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "psy", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "ps", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "nonTerminal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "q", new edu.berkeley.sbp.Tree[] { }),
+        new edu.berkeley.sbp.Tree(null, "=>", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "psy", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "ps", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "nonTerminal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "Q", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "u", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "o", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "t", new edu.berkeley.sbp.Tree[] { }),
@@ -716,7 +719,7 @@ new edu.berkeley.sbp.Tree(null, "gram", new edu.berkeley.sbp.Tree[] { new edu.be
         new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { })})}),
         new edu.berkeley.sbp.Tree(null, "psy", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "/", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "ps2", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "{", new edu.berkeley.sbp.Tree[] { })}),
-        new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "nonTerminal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "s", new edu.berkeley.sbp.Tree[] { }),
+        new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "nonTerminal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "S", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "e", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "q", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "u", new edu.berkeley.sbp.Tree[] { }),
@@ -729,7 +732,7 @@ new edu.berkeley.sbp.Tree(null, "gram", new edu.berkeley.sbp.Tree[] { new edu.be
         new edu.berkeley.sbp.Tree(null, "s", new edu.berkeley.sbp.Tree[] { })})})})}),
         new edu.berkeley.sbp.Tree(null, "psy", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "ps2", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "[", new edu.berkeley.sbp.Tree[] { })}),
-        new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "*", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "nonTerminal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "r", new edu.berkeley.sbp.Tree[] { }),
+        new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "*", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "nonTerminal", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "R", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "a", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "n", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "g", new edu.berkeley.sbp.Tree[] { }),
@@ -832,7 +835,7 @@ new edu.berkeley.sbp.Tree(null, "gram", new edu.berkeley.sbp.Tree[] { new edu.be
         new edu.berkeley.sbp.Tree(null, "-", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "0", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "9", new edu.berkeley.sbp.Tree[] { })}),
         new edu.berkeley.sbp.Tree(null, "range", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "_", new edu.berkeley.sbp.Tree[] { })})})})})})})})})})}),
-        new edu.berkeley.sbp.Tree(null, "::=", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "q", new edu.berkeley.sbp.Tree[] { }),
+        new edu.berkeley.sbp.Tree(null, "::=", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "Q", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "u", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "o", new edu.berkeley.sbp.Tree[] { }),
         new edu.berkeley.sbp.Tree(null, "t", new edu.berkeley.sbp.Tree[] { }),
@@ -954,3 +957,6 @@ new edu.berkeley.sbp.Tree(null, "gram", new edu.berkeley.sbp.Tree[] { new edu.be
 
 
 
+
+
+

diff --git a/src/edu/berkeley/sbp/misc/RegressionTests.java b/src/edu/berkeley/sbp/misc/RegressionTests.java
index 7da0b26..b247021 100644 (file)
--- a/src/edu/berkeley/sbp/misc/RegressionTests.java
+++ b/src/edu/berkeley/sbp/misc/RegressionTests.java
@@ -78,13 +78,20 @@ public class RegressionTests {
             return ret;
         }
         public boolean execute() throws Exception {
-            Forest<String> res = new CharToken.CharToStringParser(grammar).parse(inp);
+            Forest<String> res = null;
+            Parser.Failed pfe = null;
+            try {
+                res = new CharToken.CharToStringParser(grammar).parse(inp);
+            } catch (Parser.Failed pf) {
+                pfe = pf;
+            }
             Collection<Tree<String>> results = res==null ? new HashSet<Tree<String>>() : res.expand(false);
             System.out.print("\r");
             if (results.size() == 0 && output.length > 0) {
                 System.out.print("\033[31m");
                 System.out.println("PARSE FAILED");
                 System.out.print("\033[0m");
+                if (pfe != null) pfe.printStackTrace();
             } else {
                 System.out.print("\r                                                                                                              \r");
             }

diff --git a/src/edu/berkeley/sbp/tib/Tib.java b/src/edu/berkeley/sbp/tib/Tib.java
index 69ac824..9ec8bd8 100644 (file)
--- a/src/edu/berkeley/sbp/tib/Tib.java
+++ b/src/edu/berkeley/sbp/tib/Tib.java
@@ -106,11 +106,11 @@ public class Tib implements Token.Stream<CharToken> {
             if (indentation > last) {
                 indenting = false;
                 istack.add(indentation);
-                System.out.print("\033[31m+"+indentation+"+\033[0m");
+                //System.out.print("\033[31m+"+indentation+"+\033[0m");
                 return CharToken.left;
             } else /*if (indentation < last)*/ {
                 istack.remove(istack.size()-1);
-                System.out.print("\033[31m-"+last+"-\033[0m");
+                //System.out.print("\033[31m-"+last+"-\033[0m");
                 blank = true;
                 return CharToken.right;
             }
@@ -120,6 +120,7 @@ public class Tib implements Token.Stream<CharToken> {
             return done(c);
         }
     }
+
     public CharToken done(char c) {
         switch(c) {
             case '{': return CharToken.left;

diff --git a/tests/meta.g b/tests/meta.g
index 7859386..0f69022 100644 (file)
--- a/tests/meta.g
+++ b/tests/meta.g
@@ -1,41 +1,41 @@
-s         ::=  grammar ws                  => "gram"
+s         ::=  Grammar ws                  => "gram"
 ws       !::=  w** | w** "//" (~[\n]*) "\n" ws
 wp       !::=  w++
-grammar   ::=  r +/ ws                        => "grammar"
+Grammar   ::=  r +/ ws                        => "grammar"
 
 r         ::=  word  ^"::=" alternatives /ws
             |  word ^"!::=" alternatives /ws
 
-alternatives  ::=  (conjuncts +/ (ws "|" ws)) +/ (ws ">" ws)
+alternatives  ::=  (Conjuncts +/ (ws "|" ws)) +/ (ws ">" ws)
 
-conjuncts     ::=  sequence
-                |  sequence ^"&"  e*/ws   /ws
-                |  sequence ^"&~" e*/ws   /ws
+Conjuncts     ::=  Sequence
+                |  Sequence ^"&"  e*/ws   /ws
+                |  Sequence ^"&~" e*/ws   /ws
 
 ps         ::= e*/ws                              => "ps"
-             | (e+/ws ws)? "^" quoted (ws e+/ws)? => "ps2"
+             | (e+/ws ws)? "^" Quoted (ws e+/ws)? => "ps2"
 psy        ::= ps
              | ps wp ^"/" ws e
 psx        ::= psy                   => "psy"
              | e "<-" psy        /ws => "psyl"
              |        psy "->" e /ws => "psyr"
              | e "<-" psy "->" e /ws => "psylr"
-sequence   ::= quoted => "qprod"
+Sequence   ::= Quoted => "qprod"
              > psx
              | psx  "=>" ^"[]"         /ws
-             | psx ^"=>" (word|quoted) /ws
+             | psx ^"=>" (word|Quoted) /ws
 
 ec       ::= ~[\-\]\\]
            | escaped
 
-range    ::= ec          => "range"
+Range    ::= ec          => "range"
            | ec ^"-" ec
 
 e        ::=  word                          => "nonTerminal"
-           |  quoted                        => "literal"
+           |  Quoted                        => "literal"
            |    ^"()"
-           |    ^"{" sequence "}"       /ws
-           |    ^"["  range* "]"
+           |    ^"{" Sequence "}"       /ws
+           |    ^"["  Range* "]"
 
            |  (e ^"++"    /ws > e ^"+"    /ws)
            |  (e ^"++/" e /ws > e ^"+/" e /ws)
@@ -51,7 +51,7 @@ w       !::= " "
            | "\n"
            | "\r"
 word     ::= [a-zA-Z0-9_]++
-quoted   ::= "\"" ((~[\"\\] | escaped)+) "\""
+Quoted   ::= "\"" ((~[\"\\] | escaped)+) "\""
            | "\"\"" => ""
 escaped  ::= "\\n" => "\n"
            | "\\r" => "\r"

diff --git a/tests/regression.tc b/tests/regression.tc
index f0815a8..7d170e0 100644 (file)
--- a/tests/regression.tc
+++ b/tests/regression.tc
@@ -19,23 +19,6 @@
 //    s ::= ()       => s0
 //}
 
-tibcase {
-    input 
-"
-  hello 
-    there
-    how
-      { are }
-";
-    output "yep:{are}";
-
-    s        ::= { Hello } => "yep"
-    w        ::= " " | "\n"
-    ws      !::= w**
-    Hello    ::= "hello" ws { "there" "how" { "are" } }
-}
-
-
 testcase {
     input "ab c";
     output "1:{{a b} {c}}";

diff --git a/tests/testcase.g b/tests/testcase.g
index 175f1e3..75380bd 100644 (file)
--- a/tests/testcase.g
+++ b/tests/testcase.g
@@ -1,9 +1,9 @@
 ts       ::= ws tests ws => ts
 tests    ::= test */ ws
 ws       !::= w*
-test     ::= ^"testcase" "{" input output +/ ws   grammar "}" /ws
-           | ^"testcase" "{" input                grammar "}" /ws
-           | ^"tibcase"  "{" input output +/ ws   grammar "}" /ws
-           | ^"tibcase"  "{" input                grammar "}" /ws
-output   ::= ^"output" quoted ";" /ws
-input    ::= "input"  quoted ";" /ws
+test     ::= ^"testcase" "{" input output +/ ws   Grammar "}" /ws
+           | ^"testcase" "{" input                Grammar "}" /ws
+           | ^"tibcase"  "{" input output +/ ws   Grammar "}" /ws
+           | ^"tibcase"  "{" input                Grammar "}" /ws
+output   ::= ^"output" Quoted ";" /ws
+input    ::= "input"  Quoted ";" /ws

diff --git a/tests/tibdoc.g b/tests/tibdoc.g
index adc6e5e..81061e5 100644 (file)
--- a/tests/tibdoc.g
+++ b/tests/tibdoc.g
@@ -43,18 +43,18 @@ Paragraph  ::= { "\"\"" ws text  }  => "blockquote"
              > { "---" "-"*      }  => "hr"
              > { text }             => "p"
 
-text       ::= item
-itemx      ::= ws item | ()
-item       ::= blockquote
-             > pre         itemx => []
-             > structured  itemx => []
-             > structuredx itemx => []
-             > styled      itemx => []
-             > qtext       itemx => []
-             > alphanum++  itemx => []
-             > symbol      itemx => []
-//             > sym++       itemx => []
-             > Paragraph   itemx => []
+text       ::= Item
+Itemx      ::= ws Item | ()
+Item       ::= blockquote
+             > pre         Itemx => []
+             > structured  Itemx => []
+             > structuredx Itemx => []
+             > styled      Itemx => []
+             > qtext       Itemx => []
+             > alphanum++  Itemx => []
+             > symbol      Itemx => []
+//             > sym++       Itemx => []
+             > Paragraph   Itemx => []
 
 symbol     ::= sym++