return new CharRange(new IntegerTopology<CharToken>(new Range.Set(new Range((int)start, (int)end)).complement().intersect(all)));
}
+ public static final Atom leftBrace = new Atom(new IntegerTopology<CharToken>(-3)) { public String toString() { return "{"; } };
+ public static final Atom rightBrace = new Atom(new IntegerTopology<CharToken>(-4)) { public String toString() { return "}"; } };
+
private static final Range.Set all = new Range.Set(new Range(0, Character.MAX_VALUE));
public static final Atom any = new CharRange(new IntegerTopology<CharToken>(all));
public static final Atom none = new CharRange(new IntegerTopology<CharToken>());
}
public Object _backslash__leftbrace_(String s) { return SELF; }
- public Object _leftbrace_(String s) { return SELF; }
- public Object _plus_(final Element r) { return Repeat.many1(r); }
+ public Object _leftbrace_(PreSequence p) {
+ return nonTerminal("braced"+(anon++),
+ new PreSequence[][] {
+ new PreSequence[] {
+ new PreSequence(CharToken.leftBrace),
+ p,
+ new PreSequence(CharToken.rightBrace)
+ }
+ },
+ false,
+ false);
+ }
- public PreSequence rewrite(Object[] o) { return new PreSequence(o, null); }
- public PreSequence _equals__greater_(Object[] o, String s) { return new PreSequence(o, s); }
+ public Object _plus_(final Element r) { return Repeat.many1(r); }
+ public PreSequence rewrite(Object[] o) { return new PreSequence(o, null); }
+ public PreSequence _equals__greater_(Object[] o, String s) { return new PreSequence(o, s); }
public PreSequence seq(Object[] o, Object sep, String tag) { return new PreSequence(sep==null ? o : _slash_(o, sep), tag); }
- public Object[] seq(Object[] o) { return o; }
+ public Object[] seq(Object[] o) { return o; }
public Object[] _slash_(Object[] o, Object sep) {
if (o.length <= 1) return o;
Object[] ret = new Object[o.length * 2 - 1];
public /*final*/ String tag;
public final Object[] o;
+ public PreSequence(Object o) { this(new Object[] { o }, null); }
+ public PreSequence(Object[] o) { this(o, null); }
public PreSequence(Object[] o, String tag) { this.o = o; this.tag = tag; }
boolean[] drops = null;
public Union buildUnion() {
}
return ret.toString();
}
+ /*
public Object walk(Tree<String> tree) {
if (tree.head()!=null) {
Member m = member("$"+normalize(tree.head()), 0, false);
+ if (m!=null) {
+ if ((m instanceof Method) && ((Method)m).getReturnType()==Void.TYPE) {
+ Reflection.fuzzyInvoke(target, m, new Object[0]);
+ }
+ }
}
return super.walk(tree);
}
+ */
public Object walk(String tag, Object[] argo) {
if (argo.length==0) return super.walk(tag, argo);
if (argo==null) return tag;
import java.io.*;
import java.util.*;
import edu.berkeley.sbp.*;
-import edu.berkeley.sbp.*;
import edu.berkeley.sbp.misc.*;
-import edu.berkeley.sbp.*;
+import edu.berkeley.sbp.tib.*;
public class RegressionTests {
}
public static class TestCase {
+ private final Token.Stream inp;
public final String input;
public final String[] output;
public final Union grammar;
- public TestCase(String input, String[] output, Union grammar) {
+ public TestCase(String input, String[] output, Union grammar, boolean tib) {
+ this.inp = tib
+ ? new CharToken.Stream(new StringReader(input), input.indexOf('\n')==-1?"\""+input+"\": ":"")
+ /*: new TibCharToken.Stream(new StringReader(input))*/
+ : new CharToken.Stream(new StringReader(input), input.indexOf('\n')==-1?"\""+input+"\": ":"")
+ ;
this.input = input;
this.output = output;
this.grammar = grammar;
return ret;
}
public boolean execute() throws Exception {
- Forest<String> res = new Parser(grammar,
- CharToken.top()).parse(new CharToken.Stream(new StringReader(input), input.indexOf('\n')==-1?"\""+input+"\": ":""));
+ Forest<String> res = new Parser(grammar, CharToken.top()).parse(inp);
Collection<Tree<String>> results = res==null ? new HashSet<Tree<String>>() : res.expand(false);
System.out.print("\r");
if (results.size() == 0 && output.length > 0) {
public static class TestCaseBuilder extends MetaGrammar {
public TestCase[] ts(Object o1, TestCase[] ts, Object o2) { return ts; }
public TestCase[] ts(TestCase[] ts) { return ts; }
- public TestCase testcase(String input, String[] output, Union grammar) { return new TestCase(input, output, grammar); }
- public TestCase testcase(String input, Union grammar) { return new TestCase(input, new String[0], grammar); }
+ public TestCase testcase(String input, String[] output, Union grammar) { return new TestCase(input, output, grammar, false); }
+ public TestCase testcase(String input, Union grammar) { return new TestCase(input, new String[0], grammar, false); }
+ public TestCase tibcase(String input, Union grammar) { return new TestCase(input, new String[0], grammar, false); }
public MetaGrammar grammar(Object[] o) { return this; }
public Object walk(String tag, Object[] args) {
if ("grammar".equals(tag)) return done("s");
* possible (it is unclear whether or not the associated grammar is
* context-free).
*/
-public class Tib /*implements Token.Stream<TibToken>*/ {
+public class Tib /*implements Token.Stream<TreeToken<String>>*/ {
/*
+ public final String str;
- private String str;
-
+ public Tib(String s) { this(new StringReader(s)); }
+ public Tib(Reader r) { this(new BufferedReader(r)); }
public Tib(InputStream is) { this(new BufferedReader(new InputStreamReader(is))); }
- public Tib(BufferedReader br) {
- Block b = parse(br);
- }
+ public Tib(BufferedReader br) { str = parse(br).toString(0,-1); }
public Token next() throws IOException {
if (pos >= str.length()) return Atom.EOF;
}
return ret.toString();
}
- */
+ */
}
e ::= word => "nonTerminal"
| quoted => "literal"
| ^"()"
- | ^"{" alternatives "}" /ws
+ | ^"{" sequence "}" /ws
| ^"[" (range*) "]"
| ^"[~" (range*) "]"
| ^"^" quoted /ws
// s ::= () => s0
//}
+//tibcase {
+// input "
+// hello
+// there
+// how
+// { are }
+//";
+//
+// s ::= ws S ws
+// ws !::= w*
+// S ::= { Hello }
+// Hello ::= "hello" { "there" "how" { "are" } }
+//}
+
testcase {
input "ab c";
output "1:{{a b} {c}}";
ws !::= w*
test ::= ^"testcase" "{" input output +/ ws grammar "}" /ws
| ^"testcase" "{" input grammar "}" /ws
+ | ^"tibcase" "{" input grammar "}" /ws
output ::= "output" quoted ";" /ws
input ::= "input" quoted ";" /ws