X-Git-Url: http://git.megacz.com/?p=sbp.git;a=blobdiff_plain;f=src%2Fedu%2Fberkeley%2Fsbp%2Ftib%2FTib.java;h=387f5edda2c3064c1514956377d1b365aa9155bb;hp=881fc88c3c3f99b23faaffa6fe02055845a251d5;hb=f65ffd84486b1deb993d17bcdee5c3a9f5638a8c;hpb=1177435c53540af2247a2fbd7b6fbcf059accbb8 diff --git a/src/edu/berkeley/sbp/tib/Tib.java b/src/edu/berkeley/sbp/tib/Tib.java index 881fc88..387f5ed 100644 --- a/src/edu/berkeley/sbp/tib/Tib.java +++ b/src/edu/berkeley/sbp/tib/Tib.java @@ -1,17 +1,12 @@ -// Copyright 2005 the Contributors, as shown in the revision logs. -// Licensed under the Apache Public Source License 2.0 ("the License"). -// You may not use this file except in compliance with the License. +// Copyright 2006 all rights reserved; see LICENSE file for BSD-style license package edu.berkeley.sbp.tib; import edu.berkeley.sbp.*; import edu.berkeley.sbp.misc.*; +import edu.berkeley.sbp.chr.*; import java.util.*; import java.io.*; -// TODO: multiple {{ }} for superquotation -// TODO: strings -// TODO: comments - /** * A slow, ugly, inefficient, inelegant, ad-hoc parser for TIB files. * @@ -23,47 +18,53 @@ import java.io.*; * experimentation with the TIB spec. Once the spec is finalized it * should probably be rewritten. */ -public class Tib implements Token.Stream { +public class Tib implements Input { + + public String showRegion(Region r) { return ""; } - 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 { + public Tib(String s) throws IOException { this(new StringReader(s)); } + public Tib(Reader r) throws IOException { this(new BufferedReader(r)); } + public Tib(InputStream is) throws IOException { this(new BufferedReader(new InputStreamReader(is))); } + public Tib(BufferedReader br) throws IOException { this.br = br; istack.add(-1); - //cur = parse(br); - //System.out.println("\rparsing: \"" + cur.toString(0, -1) + "\""); } - - private Block cur; + public String getName() { return null; } private String s = ""; int pos = 0; int spos = 0; int _row = 1; int _col = 0; - public Token.Location getLocation() { return new CartesianInput.Location(_row, _col); } + int _scalar = 0; + public Input.Location getLocation() { return new Cartesian.Location(_col, _row, _scalar); } private BufferedReader br; + char left = CharAtom.left; + char right = CharAtom.right; + boolean waiting = false; char waitingChar = ' '; boolean indenting = true; int indentation = 0; private ArrayList istack = new ArrayList(); - public CharToken next(int numstates, int resets, int waits) throws IOException { - CharToken ret = nextc(numstates, resets); - if (ret==CharToken.left) System.out.print("\033[31m{\033[0m"); - else if (ret==CharToken.right) System.out.print("\033[31m}\033[0m"); - else if (ret==null) return null; - else System.out.print(ret.c); + private static boolean debug = "true".equals(System.getProperty("tib.debug", "false")); + public Character next() throws IOException { + Character ret = nextc(); + if (debug) { + if (ret==null) return null; + else if (ret==left) System.err.print("\033[31m{\033[0m"); + else if (ret==right) System.err.print("\033[31m}\033[0m"); + else System.err.print(ret); + } return ret; } - CharToken waitingBrace = null; - public CharToken nextc(int numstates, int resets) throws IOException { + Character waitingBrace = null; + public Character nextc() throws IOException { char c; if (waitingBrace != null) { - CharToken ret = waitingBrace; + Character ret = waitingBrace; waitingBrace = null; return ret; } @@ -75,25 +76,26 @@ public class Tib implements Token.Stream { if (i==-1) { if (istack.size() > 1) { istack.remove(istack.size()-1); - return CharToken.right; + return right; } return null; } c = (char)i; + _scalar++; + if (c=='\n') { _row++; _col=0; } + else _col++; } - if (c=='\n') { _row++; _col=0; } - else _col++; if (indenting) { if (c==' ') { indentation++; return done(c); } - if (c=='\n') { indentation = 0; if (blank) return nextc(numstates, resets); blank = true; waiting = true; waitingChar='\n'; return new CharToken('\n'); } + if (c=='\n') { indentation = 0; if (blank) return nextc(); blank = true; waiting = true; waitingChar='\n'; return '\n'; } int last = istack.size()==0 ? -1 : istack.get(istack.size()-1); if (indentation==last) { if (blank) { indenting = false; waitingChar = c; waiting = true; - waitingBrace = CharToken.left; - return CharToken.right; + waitingBrace = left; + return right; //return nextc(numstates); } blank = false; @@ -107,12 +109,12 @@ public class Tib implements Token.Stream { indenting = false; istack.add(indentation); //System.out.print("\033[31m+"+indentation+"+\033[0m"); - return CharToken.left; + return left; } else /*if (indentation < last)*/ { istack.remove(istack.size()-1); //System.out.print("\033[31m-"+last+"-\033[0m"); blank = true; - return CharToken.right; + return right; } } else { blank = false; @@ -121,299 +123,14 @@ public class Tib implements Token.Stream { } } - public CharToken done(char c) { + public Character done(char c) { switch(c) { - case '{': return CharToken.left; - case '}': return CharToken.right; - default: return new CharToken(c); + case '{': return left; + case '}': return right; + default: return c; } } boolean blank = false; - /* - public CharToken next(int numstates) 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; - _row = cur.endrow; - _col = cur.endcol; - cur = cur.parent; - if (cur==null) return null; - return CharToken.right; - } - Object o = cur.child(pos++); - if (o instanceof String) { - spos = 0; - s = (String)o; - return next(numstates); - } - 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(); - return next(numstates); - } - cur = (Block)o; - pos = 0; - return CharToken.left; - } - */ - public static Block parse(BufferedReader br) throws Invalid, IOException { - int row=0, col=0; - try { - boolean blankLine = false; - Block top = new Block.Root(); - for(String s = br.readLine(); s != null; s = br.readLine()) { - row++; - col=0; - while (s.length() > 0 && - s.charAt(0) == ' ' && - (!(top instanceof Block.Literal) || col < top.col)) { col++; s = s.substring(1); } - if ((top instanceof Block.Literal) && col >= top.col) { top.add(s); continue; } - if (s.length()==0) { blankLine = true; continue; } - while (col < top.col) { - if (s.startsWith("{}") && top instanceof Block.Literal && ((Block.Literal)top).braceCol == col) break; - blankLine = false; - top.endrow = row; - top.endcol = col; - top = top.closeIndent(); - } - if (s.startsWith("{}")) { - int bc = col; - boolean append = top instanceof Block.Literal && ((Block.Literal)top).braceCol == bc; - s = s.substring(2); - col += 2; - while (s.length() > 0 && s.charAt(0) == ' ' && !(append && col >= top.col) ) { col++; s = s.substring(1); } - if (append) top.add(s); else (top = new Block.Literal(top, row, col, bc)).add(s); - continue; - } - while (s.length() > 0 && s.charAt(s.length()-1)==' ') { s = s.substring(0, s.length()-1); } - if (col > top.col) top = new Block.Indent(top, row, col); - else if (blankLine) { top.endrow=row; top.endcol=col; top = top.closeIndent(); top = new Block.Indent(top, row, col); } - blankLine = false; - for(int i=0; i 0) { finishWord(); add(" "); return; } - if (size()==0) return; - if (child(size()-1).equals(" ")) return; - add(" "); - return; - } - - public void add(Block b) { children.addElement(b); } - public Block promote() { parent.parent.replaceLast(this); return close(); } - public Object lastChild() { return children.lastElement(); } - public Block lastChildAsBlock() { return (Block)lastChild(); } - public void replaceLast(Block b) { children.setElementAt(b, children.size()-1); b.parent = this; } - - public void finishWord() { if (pending.length() > 0) { add(pending); pending = ""; } } - - public Block closeBrace() { throw new InternalException("attempt to closeBrace() a "+getClass().getName()); } - public Block closeIndent() { throw new InternalException("attempt to closeIndent() a "+getClass().getName()); } - public Block close() { - while(size() > 0 && child(size()-1).equals(" ")) children.setSize(children.size()-1); - if (size()==0) throw new InternalException("PARSER BUG: attempt to close an empty block (should never happen)"); - if (size() > 1 || !(lastChild() instanceof Block)) return parent; - return lastChildAsBlock().promote(); - } - public String toString() { return toString(80); } - public String toString(int justificationLimit) { return toString(0, 80); } - protected String toString(int indent, int justificationLimit) { - StringBuffer ret = new StringBuffer(); - StringBuffer line = new StringBuffer(); - for(int i=0; i0 && children.elementAt(i-1) instanceof Block && justificationLimit!=-1) ret.append("\n"); - if (o instanceof Block) { - ret.append(justify(line.toString(), indent, justificationLimit)); - line.setLength(0); - if (justificationLimit==-1) { - ret.append("{"); - ret.append(((Block)o).toString(indent+2, justificationLimit)); - ret.append("}"); - } else { - ret.append(((Block)o).toString(indent+2, justificationLimit)); - } - } else { - line.append(o.toString()); - } - } - ret.append(justify(line.toString(), indent, justificationLimit)); - return ret.toString(); - } - - private static class Root extends Block { - public Root() { super(0, Integer.MIN_VALUE); } - public Block close() { throw new InternalException("attempted to close top block"); } - public String toString(int justificationLimit) { return toString(-2, justificationLimit); } - } - - private static class Brace extends Block { - public Brace(Block parent, int row, int col) { super(parent, row, col); } - public Block closeBrace() { return super.close(); } - } - - private static class Indent extends Block { - public Indent(Block parent, int row, int col) { super(parent, row, col); } - public Block closeIndent() { return super.close(); } - } - - private static class Literal extends Block { - private StringBuffer content = new StringBuffer(); - public final int braceCol; - public Literal(Block parent, int row, int col, int braceCol) { super(parent,row,col); this.braceCol = braceCol; } - public boolean isLiteral() { return true; } - public int size() { return 1; } - public Object child(int i) { return i==0 ? content.toString() : null; } - public Block close() { return parent; } - public Block closeIndent() { return close(); } - public void add(String s) { if (content.length()>0) content.append('\n'); content.append(s); } - public String text() { return content.toString(); } - protected String toString(int indent, int justificationLimit) { - StringBuffer ret = new StringBuffer(); - String s = content.toString(); - while(s.length() > 0) { - int nl = s.indexOf('\n'); - if (nl==-1) nl = s.length(); - ret.append(spaces(indent)); - ret.append("{} "); - ret.append(s.substring(0, nl)); - s = s.substring(Math.min(s.length(),nl+1)); - ret.append('\n'); - } - return ret.toString(); - } - } - } - - - // Exceptions ////////////////////////////////////////////////////////////////////////////// - - private static class InternalException extends RuntimeException { public InternalException(String s) { super(s); } } - public static class Invalid extends /*IOException*/RuntimeException { - public Invalid(InternalException ie, int row, int col) { - super(ie.getMessage() + " at " + row + ":" + col); - } - } - - // Testing ////////////////////////////////////////////////////////////////////////////// - - public static void main(String[] s) throws Exception { - System.out.println(parse(new BufferedReader(new InputStreamReader(System.in))).toString(-1)); } - - // Utilities ////////////////////////////////////////////////////////////////////////////// - - public static String spaces(int i) { if (i<=0) return ""; return " " + spaces(i-1); } - - private static String justify(String s, int indent, int justificationLimit) { - if (s.length() == 0) return ""; - if (justificationLimit==-1) return s; - StringBuffer ret = new StringBuffer(); - while(s.length() > 0) { - if (s.charAt(0) == ' ') { s = s.substring(1); continue; } - ret.append(spaces(indent)); - int i = s.indexOf(' '); - if (i==-1) i = s.length(); - while(s.indexOf(' ', i+1) != -1 && s.indexOf(' ', i+1) < justificationLimit-indent) i = s.indexOf(' ', i+1); - if (s.length() + indent < justificationLimit) i = s.length(); - ret.append(s.substring(0, i)); - s = s.substring(i); - ret.append('\n'); - } - 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 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); - } - } }