factored exceptions into non-inner classes

darcs-hash:20060111054412-5007d-ad3f30e5c240b198e82c3ae97f167630c981bbc5.gz

diff --git a/TODO b/TODO
index d03ba8a..1ad1494 100644 (file)
--- a/TODO
+++ b/TODO
@@ -1,9 +1,6 @@
 _____________________________________________________________________________
 Immediately
 
 _____________________________________________________________________________
 Immediately
 

-  - Performance
-     - hash Long->long: it's all bogus
-

   * pick back up cleaning up end of Parser.java (Reduction)
 
   - [more] sensible tree-printout
   * pick back up cleaning up end of Parser.java (Reduction)
 
   - [more] sensible tree-printout

diff --git a/src/edu/berkeley/sbp/Ambiguous.java b/src/edu/berkeley/sbp/Ambiguous.java
new file mode 100644 (file)
index 0000000..56e1af7
--- /dev/null
+++ b/src/edu/berkeley/sbp/Ambiguous.java
@@ -0,0 +1,19 @@
+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.*;
+
+/** if ambiguity checking is enabled, this exception is thrown to signal that the parse was ambiguous */
+public class Ambiguous extends RuntimeException {
+    public final Forest ambiguity;
+    public Ambiguous(Forest ambiguity) { this.ambiguity = ambiguity; }
+    public String toString() {
+        StringBuffer sb = new StringBuffer();
+        sb.append("unresolved ambiguity "/*"at " + ambiguity.getLocation() + ":"*/);
+        for(Object result : ambiguity.expand(false))
+            sb.append("\n    " + result);
+        return sb.toString();
+    }
+}

diff --git a/src/edu/berkeley/sbp/Forest.java b/src/edu/berkeley/sbp/Forest.java
index dbcd3c0..917fea5 100644 (file)
--- a/src/edu/berkeley/sbp/Forest.java
+++ b/src/edu/berkeley/sbp/Forest.java
@@ -10,9 +10,9 @@ import java.lang.reflect.*;
 public abstract class Forest<T> {
 
     /** assume that this forest contains exactly one tree and return it; otherwise throw an exception */
 public abstract class Forest<T> {
 
     /** assume that this forest contains exactly one tree and return it; otherwise throw an exception */

-    public final Tree<T> expand1() throws Parser.Ambiguous, Parser.Failed {
+    public final Tree<T> expand1() throws Ambiguous, ParseFailed {

         Iterator<Tree<T>> it = expand(true).iterator();
         Iterator<Tree<T>> it = expand(true).iterator();

-        if (!it.hasNext()) throw new Parser.Failed();
+        if (!it.hasNext()) throw new ParseFailed();

         return it.next();
     }
 
         return it.next();
     }
 

@@ -143,7 +143,7 @@ public abstract class Forest<T> {
             HashSet<Tree<T>> ret = new HashSet<Tree<T>>();
             for(Body<T> b : results)
                 ret.addAll(b.expand(toss, new ArrayList<Tree<T>>(), 0, new HashSet<Tree<T>>()));
             HashSet<Tree<T>> ret = new HashSet<Tree<T>>();
             for(Body<T> b : results)
                 ret.addAll(b.expand(toss, new ArrayList<Tree<T>>(), 0, new HashSet<Tree<T>>()));

-            if (toss && ret.size() > 1) throw new Parser.Ambiguous(this);
+            if (toss && ret.size() > 1) throw new Ambiguous(this);

             return ret;
         }
         
             return ret;
         }
         

diff --git a/src/edu/berkeley/sbp/GSS.java b/src/edu/berkeley/sbp/GSS.java
index cff543d..8053ae8 100644 (file)
--- a/src/edu/berkeley/sbp/GSS.java
+++ b/src/edu/berkeley/sbp/GSS.java
@@ -154,10 +154,10 @@ class GSS {
             return ret.toString();
         }
         
             return ret.toString();
         }
         

-        public boolean isDone() throws Parser.Failed {
+        public boolean isDone() throws ParseFailed {

             if (token != null) return false;
             if (token==null && finalResult==null)
             if (token != null) return false;
             if (token==null && finalResult==null)

-                throw new Parser.Failed(error(red("unexpected end of file\n")),
+                throw new ParseFailed(error(red("unexpected end of file\n")),

                                         getLocation());
             return true;
         }
                                         getLocation());
             return true;
         }

@@ -304,7 +304,7 @@ class GSS {
         }
 
         /** perform all shift operations, adding promoted nodes to <tt>next</tt> */
         }
 
         /** perform all shift operations, adding promoted nodes to <tt>next</tt> */

-        public void shift(Phase next, Forest result) throws Parser.Failed {
+        public void shift(Phase next, Forest result) throws ParseFailed {

             if (prev!=null) prev.hash = null;
             this.next = next;
             closed = true;
             if (prev!=null) prev.hash = null;
             this.next = next;
             closed = true;

@@ -320,10 +320,10 @@ class GSS {
             }
 
             if (!good && token!=null)
             }
 
             if (!good && token!=null)

-                throw new Parser.Failed(error(red("unexpected character")+" "+purple(token)+" encountered at "+green(getLocation())+"\n"),
+                throw new ParseFailed(error(red("unexpected character")+" "+purple(token)+" encountered at "+green(getLocation())+"\n"),

                                         getLocation());
             if (token==null && finalResult==null)
                                         getLocation());
             if (token==null && finalResult==null)

-                throw new Parser.Failed(error(red("unexpected end of file\n")),
+                throw new ParseFailed(error(red("unexpected end of file\n")),

                                         getLocation());
 
             // this massively improves GC performance
                                         getLocation());
 
             // this massively improves GC performance

diff --git a/src/edu/berkeley/sbp/ParseFailed.java b/src/edu/berkeley/sbp/ParseFailed.java
new file mode 100644 (file)
index 0000000..d46570b
--- /dev/null
+++ b/src/edu/berkeley/sbp/ParseFailed.java
@@ -0,0 +1,15 @@
+package edu.berkeley.sbp;
+import edu.berkeley.sbp.*;
+import edu.berkeley.sbp.util.*;
+import java.io.*;
+import java.util.*;
+
+/** thrown when the parser arrives at a state from which it is clear that no valid parse can result */
+public class ParseFailed extends RuntimeException {
+    private final Token.Location location;
+    private final String message;
+    public ParseFailed() { this("", null); }
+    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))*/; }
+}

diff --git a/src/edu/berkeley/sbp/Parser.java b/src/edu/berkeley/sbp/Parser.java
index cbf9b47..db08afc 100644 (file)
--- a/src/edu/berkeley/sbp/Parser.java
+++ b/src/edu/berkeley/sbp/Parser.java
@@ -1,28 +1,27 @@
 package edu.berkeley.sbp;
 import edu.berkeley.sbp.*;
 import edu.berkeley.sbp.util.*;
 package edu.berkeley.sbp;
 import edu.berkeley.sbp.*;
 import edu.berkeley.sbp.util.*;

-import edu.berkeley.sbp.*;

 import edu.berkeley.sbp.Sequence.Position;
 import edu.berkeley.sbp.Sequence.Position;

-import edu.berkeley.sbp.*;

 import java.io.*;
 import java.util.*;
 import java.io.*;
 import java.util.*;

-import java.lang.reflect.*;

 
 /** a parser which translates streams of Tokens of type T into a Forest<R> */
 public abstract class Parser<T extends Token, R> {
 
 
 /** a parser which translates streams of Tokens of type T into a Forest<R> */
 public abstract class Parser<T extends Token, R> {
 

-    public final Table pt;
+    private final Table pt;

 
     /** create a parser to parse the grammar with start symbol <tt>u</tt> */
     protected Parser(Union u)  { this.pt = new Table(u, top()); }
 
     /** create a parser to parse the grammar with start symbol <tt>u</tt> */
     protected Parser(Union u)  { this.pt = new Table(u, top()); }

-    protected Parser(Table pt) { this.pt = pt; }
+    //protected Parser(Table pt) { this.pt = pt; }

 
 

+    /** implement this method to create the output forest corresponding to a lone shifted input token */

     public abstract Forest<R> shiftedToken(T t, Token.Location loc);
     public abstract Forest<R> shiftedToken(T t, Token.Location loc);

-    public abstract Topology<T> top();

 
 

+    /** this method must return an empty topology of the input token type */
+    public abstract Topology<T> top();

 
 

-    /** parse <tt>input</tt> for a exactly one unique result, throwing <tt>Ambiguous</tt> if not unique or <tt>Failed</tt> if none */
-    public Tree<R> parse1(Token.Stream<T> input) throws IOException, Failed, Ambiguous {
+    /** parse <tt>input</tt> for a exactly one unique result, throwing <tt>Ambiguous</tt> if not unique or <tt>ParseFailed</tt> if none */
+    public Tree<R> parse1(Token.Stream<T> input) throws IOException, ParseFailed, Ambiguous {

         Forest<R> ret = parse(input);
         try { return ret.expand1(); }
         catch (Ambiguous a) {
         Forest<R> ret = parse(input);
         try { return ret.expand1(); }
         catch (Ambiguous a) {

@@ -33,7 +32,7 @@ public abstract class Parser<T extends Token, R> {
     }
 
     /** parse <tt>input</tt>, using the table <tt>pt</tt> to drive the parser */
     }
 
     /** parse <tt>input</tt>, using the table <tt>pt</tt> to drive the parser */

-    public Forest<R> parse(Token.Stream<T> input) throws IOException, Failed {
+    public Forest<R> parse(Token.Stream<T> input) throws IOException, ParseFailed {

         GSS gss = new GSS();
         Token.Location loc = input.getLocation();
         GSS.Phase current = gss.new Phase(null, this, null, input.next(1, 0, 0), loc, null);
         GSS gss = new GSS();
         Token.Location loc = input.getLocation();
         GSS.Phase current = gss.new Phase(null, this, null, input.next(1, 0, 0), loc, null);

@@ -53,27 +52,6 @@ public abstract class Parser<T extends Token, R> {
 
     // Exceptions //////////////////////////////////////////////////////////////////////////////
 
 
     // Exceptions //////////////////////////////////////////////////////////////////////////////
 

-    public static class Failed extends RuntimeException {
-        private final Token.Location location;
-        private final String         message;
-        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 static class Ambiguous extends RuntimeException {
-        public final Forest ambiguity;
-        public Ambiguous(Forest ambiguity) { this.ambiguity = ambiguity; }
-        public String toString() {
-            StringBuffer sb = new StringBuffer();
-            sb.append("unresolved ambiguity "/*"at " + ambiguity.getLocation() + ":"*/);
-            for(Object result : ambiguity.expand(false))
-                sb.append("\n    " + result);
-            return sb.toString();
-        }
-    }
-

 
     // Table //////////////////////////////////////////////////////////////////////////////
 
 
     // Table //////////////////////////////////////////////////////////////////////////////
 

diff --git a/src/edu/berkeley/sbp/misc/RegressionTests.java b/src/edu/berkeley/sbp/misc/RegressionTests.java
index a3d471d..266e8d5 100644 (file)
--- a/src/edu/berkeley/sbp/misc/RegressionTests.java
+++ b/src/edu/berkeley/sbp/misc/RegressionTests.java
@@ -79,10 +79,10 @@ public class RegressionTests {
         }
         public boolean execute() throws Exception {
             Forest<String> res = null;
         }
         public boolean execute() throws Exception {
             Forest<String> res = null;

-            Parser.Failed pfe = null;
+            ParseFailed pfe = null;

             try {
                 res = new CharToken.CharToStringParser(grammar).parse(inp);
             try {
                 res = new CharToken.CharToStringParser(grammar).parse(inp);

-            } catch (Parser.Failed pf) {
+            } catch (ParseFailed pf) {

                 pfe = pf;
             }
             //ystem.out.println("res=="+res);
                 pfe = pf;
             }
             //ystem.out.println("res=="+res);

diff --git a/src/edu/berkeley/sbp/util/IntPairMap.java b/src/edu/berkeley/sbp/util/IntPairMap.java
index c355488..db12004 100644 (file)
--- a/src/edu/berkeley/sbp/util/IntPairMap.java
+++ b/src/edu/berkeley/sbp/util/IntPairMap.java
@@ -1,7 +1,8 @@
 package edu.berkeley.sbp.util;
 import java.util.*;
 
 package edu.berkeley.sbp.util;
 import java.util.*;
 

-/** a mapping from keys of type <tt>K</tt> to <i>sets</i> of values of type <tt>T</tt> */
+// FEATURE: make this faster (plenty of ways: quadradic probing hash table is one)
+/** a sparse mapping from pairs of <tt>int</tt>'s to <tt>V</tt>'s */

 public final class IntPairMap<V> {
 
     private final HashMap<Long, V> hm = new HashMap<Long, V>();
 public final class IntPairMap<V> {
 
     private final HashMap<Long, V> hm = new HashMap<Long, V>();