X-Git-Url: http://git.megacz.com/?p=sbp.git;a=blobdiff_plain;f=src%2Fedu%2Fberkeley%2Fsbp%2Fmisc%2FRegressionTests.java;h=beb71107dbd80b1e95d4279091f61398e6708386;hp=e61673aefc0e24cda20d5d5bdf7536d63dcd97b6;hb=45d799349e635f1a99e3974e4504a43d5a7aaf33;hpb=c1325de42a4ddfad3ff9b10bfdda11078e38e8a6 diff --git a/src/edu/berkeley/sbp/misc/RegressionTests.java b/src/edu/berkeley/sbp/misc/RegressionTests.java index e61673a..beb7110 100644 --- a/src/edu/berkeley/sbp/misc/RegressionTests.java +++ b/src/edu/berkeley/sbp/misc/RegressionTests.java @@ -1,59 +1,16 @@ package edu.berkeley.sbp.misc; import java.io.*; import java.util.*; -import edu.berkeley.sbp.*; +import java.lang.reflect.*; import edu.berkeley.sbp.*; import edu.berkeley.sbp.misc.*; -import edu.berkeley.sbp.*; - -// priorities are all messy and dont get serialized -// 1. Error messages -// 2. Java MetaGrammar (proof of concept) -// 3. Ivan's MetaGrammar -// 4. Documentation format -// - TIB - -// TODO: better API for interfacing with Java -// TODO: error messages -// TODO: integrate with TIB - -// Element -// Walk -// ParseTable / GSS -// MetaGrammar (necessary/relevant?) -// Tree (cleanup?) -// Union.SubUnion -// Repeat - -// FEATURE: serialization of ParseTable's, generation of Java code -// FEATURE: infer reject elements for literals -// FEATURE: prefer whitespace higher up -// FEATURE: full conjunctive and boolean grammars -// FEATURE: "ambiguity modulo dropped fragments"? can this be checked for statically? eliminated statically? -// - drop stuff during the parsing process (drop nodes) - -// LATER: Element -- parameterize over the input token type? Makes a huge mess... -// LATER: Go back to where Sequence is not an Element? -// - The original motivation for making Sequence "first class" was the fact that -// in order to do associativity right you need to have per-Sequence follow sets +import edu.berkeley.sbp.tib.*; +import edu.berkeley.sbp.chr.*; +import edu.berkeley.sbp.util.*; public class RegressionTests { public static boolean yes = false; - public static class MyWalker extends ReflectiveWalker { - public String top(Object[] o) { return "top("+join(o)+")"; } - public String str(String[] s) { String ret = ""; for(String st : s) ret += st; return ret; } - public String join(Object[] o) { String ret = ""; for(Object st : o) ret += st; return ret; } - public String whilex(Object s, Object y) { return "while("+s+") " + y; } - public String seq(Object[] statements) { - String ret = ""; - for(Object s : statements) ret += s + ";\n"; - return ret; - } - /* - public String bl(String s) { return "{" + s + "}"; } - */ - }; public static void main(String[] s) throws Exception { try { @@ -65,20 +22,28 @@ public class RegressionTests { s = s2; } - Tree res = new Parser(MetaGrammar.make(), CharToken.top()).parse1(new CharToken.Stream(new InputStreamReader(new FileInputStream(s[0])))); - Union meta = ((MetaGrammar)new MetaGrammar().walk(res)).done(); + //MetaGrammar mg0 = new MetaGrammar(); + //mg0.walk(MetaGrammar.meta); + //System.out.println(mg0); + Tree res = new CharParser(MetaGrammar.make()).parse(new FileInputStream(s[0])).expand1(); + MetaGrammar mg = (MetaGrammar)new MetaGrammar().walk(res); + //System.out.println(mg); + Union meta = mg.done(); SequenceInputStream sis = new SequenceInputStream(new FileInputStream(s[0]), new FileInputStream(s[1])); - res = new Parser(meta, CharToken.top()).parse1(new CharToken.Stream(new InputStreamReader(sis), "parsing " + s[1] + " using " + s[0])); + res = new CharParser(meta).parse(sis).expand1(); Union testcasegrammar = ((MetaGrammar)new MetaGrammar("ts").walk(res)).done("ts"); if (testcasegrammar==null) return; - CharToken.Stream cs = new CharToken.Stream(new InputStreamReader(new FileInputStream(s[2])), "parsing " + s[2] + " using " + s[1]); - Parser parser = new Parser(testcasegrammar, CharToken.top()); + CharParser parser = new CharParser(testcasegrammar); if (profile) { System.out.println("\nready..."); System.in.read(); } - Forest r2 = parser.parse(cs); + System.gc(); + long now = System.currentTimeMillis(); + Forest r2 = parser.parse(new FileInputStream(s[2])); + System.out.println(); + System.out.println("elapsed = " + (System.currentTimeMillis()-now) + "ms"); if (profile) { System.out.println("\ndone"); System.in.read(); @@ -96,10 +61,14 @@ public class RegressionTests { } public static class TestCase { - public final String input; + private final boolean tib; + private final boolean jav; + 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, boolean jav) throws IOException { + this.tib = tib; + this.jav = jav; this.input = input; this.output = output; this.grammar = grammar; @@ -111,53 +80,172 @@ public class RegressionTests { return ret; } public boolean execute() throws Exception { - Forest res = new Parser(grammar, - CharToken.top()).parse(new CharToken.Stream(new StringReader(input), input.indexOf('\n')==-1?"\""+input+"\": ":"")); + if (jav) { + Forest tree = new CharParser(grammar).parse(new StringReader(input)); + FileOutputStream fos = new FileOutputStream("/Users/megacz/Desktop/out.dot"); + PrintWriter p = new PrintWriter(new OutputStreamWriter(fos)); + GraphViz gv = new GraphViz(); + tree.toGraphViz(gv); + gv.dump(p); + p.flush(); + p.close(); + return true; + } + Forest res = null; + ParseFailed pfe = null; + try { + res = tib + ? /*new CharParser(grammar).parse(new Tib(input))*/ null + : new CharParser(grammar).parse(new StringReader(input)); + } catch (ParseFailed pf) { + pfe = pf; + } + //ystem.out.println("res=="+res); Collection> results = res==null ? new HashSet>() : res.expand(false); System.out.print("\r"); if (results.size() == 0 && output.length > 0) { System.out.print("\033[31m"); System.out.println("PARSE FAILED"); System.out.print("\033[0m"); + if (pfe != null) pfe.printStackTrace(); } else { - System.out.println("\r \r"); + System.out.print("\r \r"); } HashSet outs = new HashSet(); - for(String s : output) outs.add(s.trim()); + if (output != null) for(String s : output) outs.add(s.trim()); boolean bad = false; for (Tree r : results) { String s = r.toString().trim(); if (outs.contains(s)) { outs.remove(s); continue; } + if (!bad) System.out.println(input); System.out.print("\033[33m"); System.out.println(" GOT: " + s); bad = true; } for(String s : outs) { + if (!bad) System.out.println(input); System.out.print("\033[31m"); System.out.println("EXPECTED: " + s); bad = true; } if (bad) { - System.out.print("\033[0m"); + System.out.println("\033[0m"); return true; } - System.out.println("\033[32mPASS\033[0m"); + System.out.println("\r\033[32mPASS\033[0m "); return false; } } 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 MetaGrammar grammar(Object[] o) { return this; } - public Object walk(String tag, Object[] args) { - if ("testcase".equals(tag)) { - if (args.length==2) return testcase((String)args[0], new String[0], (Union)args[1]); - return testcase((String)args[0], (String[])args[1], (Union)args[2]); } - else if ("grammar".equals(tag)) return done("s"); - else return super.walk(tag, args); + public Object walk(Tree tree) { + try { + if ("grammar".equals(tree.head())) { walkChildren(tree); return done("s"); } + else if ("output".equals(tree.head())) return string(tree.children()); + else if ("input".equals(tree.head())) return string(tree.children()); + else if ("javacase".equals(tree.head()) || "tibcase".equals(tree.head()) || "testcase".equals(tree.head())) { + String input = string(tree.child(0)); + String[] output = tree.numChildren()>2 ? ((String[])walk(tree, 1)) : new String[0]; + boolean tib = "tibcase".equals(tree.head()); + boolean jav = "javacase".equals(tree.head()); + MetaGrammar gram = jav ? new JavaGrammar() : tib ? /*new Tib.Grammar()*/null : new MetaGrammar(); + Union grammar = (Union)((MetaGrammar)(gram.walk(tree, tree.numChildren()-1))).done("s"); + return new TestCase(input, output, grammar, tib, jav); + } else if ("ts".equals(tree.head())) return walk(tree, 0); + else return super.walk(tree); + } catch (Exception e) { + throw new Error(e); + } + } + } + + public static class JavaGrammar extends MetaGrammar { + public Object convertLabel(String label) { return new ClassMark(label); } + public Object convertFieldLabel(String label) { return new FieldMark(label); } + + private static class FieldMark { + public final String field; + public FieldMark(String field) { this.field = field; } + public String toString() { return "."+field; } + } + private static class ClassMark { + public final String clazz; + public ClassMark(String clazz) { this.clazz = clazz; } + public String toString() { return clazz+"$"; } + } + + public static Object build(Tree t, Class c) throws Exception { + System.out.println("** build " + c.getName() + " " + t.toPrettyString()); + Object h = t.head(); + if (h instanceof ClassMark) return build2(t, Class.forName(JavaGrammar.class.getName()+"$"+((ClassMark)h).clazz)); + Object o = null; + if (t.numChildren()==0) o = t.head(); + else if (t.head()==null) return build2(t, c); + else if (t.head() instanceof FieldMark) { + return build2(new Tree(null, new Tree[] { t }), c); + } else { + throw new Exception("don't know how to cope: " + c.getName() + " <- " + t.toPrettyString()); + } + return Reflection.rebuild(o, c); + } + private static Object build2(Tree t, Class c) throws Exception { + System.out.println("** build2 " + c.getName() + " " + t.toPrettyString()); + if (!Reflection.isConcrete(c)) { + Field f = c.getField("subclasses"); + if (f==null) throw new Exception("don't know how to cope: " + c.getName() + " <- " + t.toPrettyString()); + Class[] subs = (Class[])f.get(null); + OUTER: for(int i=0; i t2 : t) { + Object o2 = t2.head(); + System.out.println("checking " + o2 + " in " + subs[i].getName()); + if (o2 instanceof FieldMark) { + if (subs[i].getField(((FieldMark)o2).field)==null) continue OUTER; + } + } + c = subs[i]; + break; + } + } + Object o = c.newInstance(); + for(Tree t2 : t) { + Object o2 = t2.head(); + if (o2 instanceof FieldMark) { + FieldMark f = (FieldMark)o2; + Field field = c.getField(ReflectiveWalker.mangle(f.field)); + Object tgt = build(t2.child(0), field.getType()); + System.out.println("setting " + f.field + + " on a " + o.getClass().getName() + + " to " + (tgt==null?"null":tgt.getClass().getName())); + field.set(o, tgt); + } + } + System.out.println("returning a " + o.getClass().getName()); + return o; + } + public static Object build(Tree t) throws Exception { + Object h = t.head(); + if (h instanceof ClassMark) { + ClassMark cm = (ClassMark)h; + Class c = Class.forName(JavaGrammar.class.getName() + "$" + ReflectiveWalker.mangle(cm.clazz)); + return build2(t, c); + } + + return h==null ? null : h.toString(); } + + public static interface Expr { + public static Class[] subclasses = new Class[] { _plus_.class, num.class }; + } + public static class _plus_ implements Expr { + public Expr left; + public Expr right; + public String toString() { return left + "+" + right; } + } + public static class num implements Expr { + public String val; + public String toString() { return "["+val+"]"; } + } + } private static String pad(int i,String s) { return s.length() >= i ? s : pad(i-1,s)+" "; }