X-Git-Url: http://git.megacz.com/?p=sbp.git;a=blobdiff_plain;f=src%2Fedu%2Fberkeley%2Fsbp%2Ftib%2FTib.java;h=8ee70ca237ec5b9148f2ae3e29f82e0f2ba9bbc4;hp=7b3270f933dab95fd91659035765b1cb802aa900;hb=fd97655ce34c3aff1a47bfb2f45775ac711923b1;hpb=695b95cf0b6140177098a5a2d7117aec4017e470

diff --git a/src/edu/berkeley/sbp/tib/Tib.java b/src/edu/berkeley/sbp/tib/Tib.java
index 7b3270f..8ee70ca 100644
--- a/src/edu/berkeley/sbp/tib/Tib.java
+++ b/src/edu/berkeley/sbp/tib/Tib.java
@@ -21,40 +21,54 @@ import java.io.*;
  *
  *   This was written as an ad-hoc parser to facilitate
  *   experimentation with the TIB spec.  Once the spec is finalized it
- *   should probably be rewritten using a parser-generator, if
- *   possible (it is unclear whether or not the associated grammar is
- *   context-free).
+ *   should probably be rewritten.
  */
 public class Tib implements Token.Stream<CharToken> {
 
     public Tib(String s) throws IOException, Invalid { this(new StringReader(s)); }
     public Tib(Reader r) throws IOException, Invalid { this(new BufferedReader(r)); }
     public Tib(InputStream is) throws IOException, Invalid { this(new BufferedReader(new InputStreamReader(is))); }
-    public Tib(BufferedReader br) throws IOException, Invalid { cur = parse(br); }
+    public Tib(BufferedReader br) throws IOException, Invalid {
+        cur = parse(br);
+        System.out.println("\rparsing: \"" + cur.toString(0, -1) + "\"");
+    }
 
     private Block cur;
     private String s = null;
     int pos = 0;
     int spos = 0;
 
+    int _row = 0;
+    int _col = 0;
+    public Token.Location getLocation() { return new CharToken.CartesianLocation(_row, _col); }
     public CharToken next() throws IOException {
+        if (cur==null) return null;
+        if (s != null) {
+            if (spos < s.length()) {
+                char c = s.charAt(spos++);
+                if (c=='\n') { _row++; _col = 0; }
+                else _col++;
+                return new CharToken(c);
+            }
+            s = null;
+        }
         if (pos >= cur.size()) {
             pos = cur.iip+1;
             cur = cur.parent;
+            if (cur==null) return null;
             return CharToken.right;
         }
-
-        if (s != null) {
-            if (spos < s.length())
-                return new CharToken(s.charAt(spos++), 0, 0);
-            s = null;
-        }
         Object o = cur.child(pos++);
         if (o instanceof String) {
             spos = 0;
             s = (String)o;
             return next();
         }
+        if (o instanceof Block) {
+            Block b = (Block)o;
+            _row = b.row;
+            _col = b.col;
+        }
         if (((Block)o).isLiteral()) {
             spos = 0;
             s = ((Block.Literal)o).text();
@@ -114,7 +128,7 @@ public class Tib implements Token.Stream<CharToken> {
         }
     }
 
-    public static class Block /*implements Token*/ {
+    public static class Block {
                       Block  parent;
         public  final int    row;
         public  final int    col;
@@ -122,7 +136,6 @@ public class Tib implements Token.Stream<CharToken> {
         private final Vector children = new Vector();
         private       String pending  = "";
 
-        //public Location getLocation() { return /*new Location.Cartesian(row, col)*/null; }
         public int    size() { return children.size(); }
         public Object child(int i) { return children.elementAt(i); }
         public boolean isLiteral() {  return false; }
@@ -273,5 +286,37 @@ public class Tib implements Token.Stream<CharToken> {
         return ret.toString();
     }
 
+    // Grammar //////////////////////////////////////////////////////////////////////////////
+
+    public static class Grammar extends MetaGrammar {
+        private int anon = 0;
+        private final Element ws = Repeat.maximal0(nonTerminal("w"));
+        public Grammar() { dropAll.add(ws); }
+        public Object walk(Tree<String> tree) {
+            String head = tree.head();
+            if (tree.numChildren()==0) return super.walk(tree);
+            if ("{".equals(head)) {
+                String s = "braced"+(anon++);
+                Union u = nonTerminal(s);
+                Union u2 = ((PreSequence)walk(tree, 0)).sparse(ws).buildUnion();
+                u2.add(Sequence.singleton(new Element[] { u }, 0, null, null));
+                return nonTerminal(s,
+                                   new PreSequence[][] {
+                                       new PreSequence[] {
+                                           new PreSequence(new Element[] { CharToken.leftBrace,
+                                                                           ws,
+                                                                           u2,
+                                                                           ws,
+                                                                           CharToken.rightBrace
+                                           })
+                                       }
+                                   },
+                                   false,
+                                   false);
+            }
+            return super.walk(tree);
+        }
+    }
+
 }