refactored error reporting

darcs-hash:20060111071626-5007d-755bc87a2f352b64b35103888258aadacca6ae54.gz

diff --git a/src/edu/berkeley/sbp/GSS.java b/src/edu/berkeley/sbp/GSS.java
index 7fefafc..d2b040d 100644 (file)
--- a/src/edu/berkeley/sbp/GSS.java
+++ b/src/edu/berkeley/sbp/GSS.java
@@ -21,37 +21,28 @@ class GSS {
     HashMapBag<Sequence,Phase.Waiting> waiting   = new HashMapBag<Sequence,Phase.Waiting>();
     HashMapBag<Integer,Sequence>       performed = new HashMapBag<Integer,Sequence>();
     
+    /** FIXME */
+    public  Forest.Ref finalResult;
+
     /** corresponds to a positions <i>between tokens</i> the input stream; same as Tomita's U_i's */
     public class Phase implements Invokable<State, Forest, GSS.Phase.Node>, IntegerMappable {
-        public int toInt() { return pos+1; }
 
         /** the token immediately after this phase */
-        public  final Token token;
-
-        boolean reducing;
+        final Token token;
 
-        /** currently this is necessary only for the code() hack -- it doesn't actually correspond to the input */
         private final int pos;
 
-        /** FIXME */
-        public  Forest.Ref finalResult;
-
-        /** all nodes, keyed by the value returned by code() */
-        /*private*/ IntPairMap<Phase.Node> hash;  /* ALLOC */
-
-        /** the number of nodes in this phase */
-        private int numNodes;
-
-        boolean closed;
-
+        boolean reducing;
+        private IntPairMap<Phase.Node> hash;  /* ALLOC */
+        private boolean closed;
         private boolean good;
         private Phase next = null;
-
+        private Phase prev;
         private Token.Location location;
         public final Parser parser;
 
         private Forest forest;
-        Phase prev;
+
         public Phase(Phase prev, Parser parser, Phase previous, Token token, Token.Location location, Forest forest) {
             this.prev = prev;
             this.forest = forest;
@@ -69,80 +60,16 @@ class GSS {
             hash = new IntPairMap<Phase.Node>();
             good = false;
             closed = false;
-            numNodes = 0;
             reducing = false;
             finalResult = null;
             if (prev != null) prev.shift(this, forest);
         }
 
-        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.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()+"");
-                }
-            }
-        }
-
-        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()) {
-                //System.out.println(n.state);
-                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 ParseFailed {
             if (token != null) return false;
             if (token==null && finalResult==null)
-                throw new ParseFailed(error(red("unexpected end of file\n")),
-                                        getLocation());
+                throw new ParseFailed(ParseFailed.error(ANSI.red("unexpected end of file\n"), token, hash.values()), getLocation());
             return true;
         }
 
@@ -276,6 +203,7 @@ class GSS {
 
         /** perform all shift operations, adding promoted nodes to <tt>next</tt> */
         public void shift(Phase next, Forest result) throws ParseFailed {
+            // this massively improves GC performance
             if (prev!=null) prev.hash = null;
             this.next = next;
             closed = true;
@@ -291,14 +219,11 @@ class GSS {
             }
 
             if (!good && token!=null)
-                throw new ParseFailed(error(red("unexpected character")+" "+purple(token)+" encountered at "+green(getLocation())+"\n"),
+                throw new ParseFailed(ParseFailed.error(ANSI.red("unexpected character")+" "+ANSI.purple(token)+" encountered at "+ANSI.green(getLocation())+"\n", token, hash.values()),
                                         getLocation());
             if (token==null && finalResult==null)
-                throw new ParseFailed(error(red("unexpected end of file\n")),
+                throw new ParseFailed(ParseFailed.error(ANSI.red("unexpected end of file\n"), token, hash.values()),
                                         getLocation());
-
-            // this massively improves GC performance
-            //hash = null;
         }
 
 
@@ -379,16 +304,11 @@ class GSS {
                 if (parent != null) parents().add(parent, true);
                 if (Phase.this.hash.get(state, start) != null) throw new Error("severe problem!");
                 Phase.this.hash.put(state, start, this);
-                Phase.this.numNodes++;
             }
         }
 
+        public int toInt() { return pos+1; }
+        public int size() { return hash==null ? 0 : hash.size(); }
     }
 
-    /** helper method */
-    private static boolean equal(Object a, Object b) {
-        if (a==null && b==null) return true;
-        if (a==null || b==null) return false;
-        return a.equals(b);
-    }
 }

diff --git a/src/edu/berkeley/sbp/ParseFailed.java b/src/edu/berkeley/sbp/ParseFailed.java
index d46570b..9a7012f 100644 (file)
--- a/src/edu/berkeley/sbp/ParseFailed.java
+++ b/src/edu/berkeley/sbp/ParseFailed.java
@@ -1,5 +1,8 @@
 package edu.berkeley.sbp;
 import edu.berkeley.sbp.*;
+import edu.berkeley.sbp.Sequence.Position;
+import edu.berkeley.sbp.GSS.Phase;
+import edu.berkeley.sbp.GSS.Phase.Node;
 import edu.berkeley.sbp.util.*;
 import java.io.*;
 import java.util.*;
@@ -12,4 +15,61 @@ public class ParseFailed extends RuntimeException {
     public ParseFailed(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 static 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.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()+"");
+            }
+        }
+    }
+
+    public static String el(Object e) {
+        String s = e.toString();
+        if (s.length()==0 || s.charAt(0)!='\"' || s.charAt(s.length()-1)!='\"') return ANSI.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 ANSI.purple(ret.toString());
+    }
+    public static String error(String message, Token token, Iterable<Node> nodes) {
+        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 : nodes) {
+            //System.out.println(n.state);
+            complain(n, errors, false);
+        }
+        for(String s : errors.keySet()) {
+            ret.append("    while parsing " + ANSI.yellow(s));
+            HashSet<String> hs = errors.get(s);
+            if (hs.size()==1) ret.append(" expected " + ANSI.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(ANSI.yellow(el(s2)));
+                }
+                ret.append("\n");
+            }
+        }
+        return ret.toString();
+    }
+
 }

diff --git a/src/edu/berkeley/sbp/Parser.java b/src/edu/berkeley/sbp/Parser.java
index 8869281..41eae02 100644 (file)
--- a/src/edu/berkeley/sbp/Parser.java
+++ b/src/edu/berkeley/sbp/Parser.java
@@ -32,8 +32,8 @@ public abstract class Parser<T extends Token, R> {
             current.reduce();
             Forest forest = current.token==null ? null : shiftedToken((T)current.token, loc);
             GSS.Phase next = gss.new Phase(current, this, current, input.next(count, gss.resets, gss.waits), loc, forest);
-            count = next.hash.size();
-            if (current.isDone()) return (Forest<R>)current.finalResult;
+            count = next.size();
+            if (current.isDone()) return (Forest<R>)gss.finalResult;
             current = next;
         }
     }