public static class Hack<T extends Token> extends Atom<T> {
private final Atom<T> a;
static final Topology leftright =
- edu.berkeley.sbp.misc.CharToken.rightBrace.union(edu.berkeley.sbp.misc.CharToken.leftBrace);
+ edu.berkeley.sbp.misc.CharRange.rightBrace.union(edu.berkeley.sbp.misc.CharRange.leftBrace);
public Hack(Atom<T> a) { this.a = a; }
public Topology<T> top() { return ((Topology<T>)a.top()).minus(leftright); }
public String toString() { return "~"+a; }
public class CharRange extends Atom<Character> {
private String esc(char c) { return StringUtil.escapify(c+"", "[]-~\\\"\'"); }
private Topology<Character> t;
+ public CharRange(char a) { this(a,a); }
+ public CharRange(char a, char b) { this(new CharTopology(a, b)); }
public CharRange(Topology<Character> t) { this.t = t; }
public Topology<Character> top() { return t; }
public String toString() {
sb.append(']');
return sb.toString();
}
- public static final Atom leftBrace = CharToken.leftBrace;
- public static final Atom rightBrace = CharToken.rightBrace;
- public static Atom set(Range.Set r) { return new CharRange(new IntegerTopology<Character>(CharToken.c2i, r)); }
+
+ public static final char left = (char)9998;
+ public static final char right = (char)9999;
+ public static final Atom leftBrace = new CharRange(left,left) { public String toString() { return "{"; } };
+ public static final Atom rightBrace = new CharRange(right,right) { public String toString() { return "}"; } };
+
+ public static Atom set(Range.Set r) { return new CharRange(new CharTopology(r)); }
private static final Range.Set all = new Range.Set(new Range(0, Character.MAX_VALUE));
/** returns an element which exactly matches the string given */
Element ret;
if (s.length() == 1) {
ret =
- new CharRange(new IntegerTopology<Character>(CharToken.c2i, (int)s.charAt(0))) {
+ new CharRange(s.charAt(0)) {
public String toString() { return escapified; } };
} else {
Union ret2 = new Union("\""+s+"\"_str", true) {
public String toString() { return escapified; } };
Element[] refs = new Element[s.length()];
- for(int i=0; i<refs.length; i++) refs[i] = new CharRange(new IntegerTopology<Character>(CharToken.c2i, (int)s.charAt(i)));
+ for(int i=0; i<refs.length; i++) refs[i] = new CharRange(s.charAt(i));
ret2.add(Sequence.constant(refs, s, null, null));
ret = ret2;
}
}
public CharToStringParser(Union u) {
- super(u, new IntegerTopology<Character>(CharToken.c2i));
- pt.optimize(CharToken.c2i);
+ super(u, new CharTopology());
+ pt.optimize(new CharTopology());
}
public Forest<String> shiftToken(Character ct, Location loc) {
return Forest.create(loc, ct.toString(), null, false, false);
+++ /dev/null
-package edu.berkeley.sbp.misc;
-import java.io.*;
-import java.util.*;
-import java.lang.reflect.*;
-import java.lang.ref.*;
-import edu.berkeley.sbp.*;
-import edu.berkeley.sbp.Token.Location;
-import edu.berkeley.sbp.util.*;
-
-/** an implementation of Token for streams of Java <tt>char</tt> values */
-public class CharToken {
-
- public static final Functor<Character,Integer> c2i = new Functor<Character,Integer>() {
- public Integer invoke(Character c) { return (int)c.charValue(); }
- };
-
- public static final Atom leftBrace = new CharRange(new IntegerTopology<Character>(c2i, 9998)) { public String toString() { return "{"; } };
- public static final Atom rightBrace = new CharRange(new IntegerTopology<Character>(c2i, 9999)) { public String toString() { return "}"; } };
- public static final Character left = new Character((char)9998);
- public static final Character right = new Character((char)9999);
-
-}
public Token.Location getLocation() { return new CartesianInput.Location(_row, _col); }
private BufferedReader br;
+ char left = CharRange.left;
+ char right = CharRange.right;
+
boolean waiting = false;
char waitingChar = ' ';
boolean indenting = true;
private ArrayList<Integer> istack = new ArrayList<Integer>();
public Character next(int numstates, int resets, int waits) throws IOException {
Character 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");
+ if (ret==left) System.out.print("\033[31m{\033[0m");
+ else if (ret==right) System.out.print("\033[31m}\033[0m");
else if (ret==null) return null;
else System.out.print(ret);
return ret;
if (i==-1) {
if (istack.size() > 1) {
istack.remove(istack.size()-1);
- return CharToken.right;
+ return right;
}
return null;
}
indenting = false;
waitingChar = c;
waiting = true;
- waitingBrace = CharToken.left;
- return CharToken.right;
+ waitingBrace = left;
+ return right;
//return nextc(numstates);
}
blank = false;
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;
public Character done(char c) {
switch(c) {
- case '{': return CharToken.left;
- case '}': return CharToken.right;
+ case '{': return left;
+ case '}': return right;
default: return c;
}
}
return nonTerminal(s,
new PreSequence[][] {
new PreSequence[] {
- new PreSequence(new Element[] { CharToken.leftBrace,
+ new PreSequence(new Element[] { CharRange.leftBrace,
ws,
u2,
ws,
- CharToken.rightBrace
+ CharRange.rightBrace
})
}
},
/*
public class Braces extends Union {
- private static final Element left = CharToken.string("{");
- private static final Element right = CharToken.string("}");
+ private static final Element left = string("{");
+ private static final Element right = string("}");
public static String join(Object[] e) {
StringBuffer ret = new StringBuffer();
public IntegerTopology(Functor<V,Integer> f, int a) { this(f, a, a); }
public IntegerTopology(Functor<V,Integer> f, int a, int b) { this(f, new Range(a, b)); }
public IntegerTopology(Functor<V,Integer> f, Range r) { this(f, new Range.Set(r)); }
- public IntegerTopology(Functor<V,Integer> f, Range.Set rs) { this.rs = rs; this.f = f; }
-
+ public IntegerTopology(Functor<V,Integer> f, Range.Set rs) {
+ this.rs = rs;
+ this.f = f==null?(this instanceof Functor ? (Functor)this : null):f;
+ }
+
public Topology<V> empty() { return new IntegerTopology<V>(f); }
public boolean contains(V v) { return rs.contains(toInt(v)); }