From 95c87aa402977de2b96c48bd14c439b46ad49777 Mon Sep 17 00:00:00 2001 From: adam Date: Sat, 11 Feb 2006 20:19:42 -0500 Subject: [PATCH] added JavaCase darcs-hash:20060212011942-5007d-7fb16f772d225422a249d37a07184dd2b0dbd244.gz --- src/edu/berkeley/sbp/misc/RegressionTests.java | 108 +++++++++++++++++++++++- 1 file changed, 104 insertions(+), 4 deletions(-) diff --git a/src/edu/berkeley/sbp/misc/RegressionTests.java b/src/edu/berkeley/sbp/misc/RegressionTests.java index cf0b4e3..b31d5c3 100644 --- a/src/edu/berkeley/sbp/misc/RegressionTests.java +++ b/src/edu/berkeley/sbp/misc/RegressionTests.java @@ -1,10 +1,12 @@ package edu.berkeley.sbp.misc; import java.io.*; import java.util.*; +import java.lang.reflect.*; import edu.berkeley.sbp.*; import edu.berkeley.sbp.misc.*; import edu.berkeley.sbp.tib.*; import edu.berkeley.sbp.chr.*; +import edu.berkeley.sbp.util.*; public class RegressionTests { @@ -60,11 +62,13 @@ public class RegressionTests { public static class TestCase { 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, boolean tib) throws IOException { + 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; @@ -76,6 +80,12 @@ public class RegressionTests { return ret; } public boolean execute() throws Exception { + if (jav) { + Tree tree = new CharParser(grammar).parse(new StringReader(input)).expand1(); + System.out.println(tree); + System.out.println(JavaGrammar.build(tree)); + return true; + } Forest res = null; ParseFailed pfe = null; try { @@ -128,13 +138,14 @@ public class RegressionTests { 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 ("tibcase".equals(tree.head()) || "testcase".equals(tree.head())) { + 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()); - MetaGrammar gram = tib ? new Tib.Grammar() : new MetaGrammar(); + boolean jav = "javacase".equals(tree.head()); + MetaGrammar gram = jav ? new JavaGrammar() : tib ? new Tib.Grammar() : new MetaGrammar(); Union grammar = (Union)((MetaGrammar)(gram.walk(tree, tree.numChildren()-1))).done("s"); - return new TestCase(input, output, grammar, tib); + 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) { @@ -143,6 +154,95 @@ public class RegressionTests { } } + 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)+" "; } } -- 1.7.10.4