X-Git-Url: http://git.megacz.com/?p=sbp.git;a=blobdiff_plain;f=src%2Fedu%2Fberkeley%2Fsbp%2Fmisc%2FDemo.java;h=b3b9f4c2dc93827faff6b927c43624d95862b839;hp=1e5a5bc086f43e9b672b3235742c30eeb5c9fa4a;hb=3784457891d6a8b17429a16493cd65501e02e174;hpb=3f8696dcb17f7088ec004a9ef5960cc4d5fce60f diff --git a/src/edu/berkeley/sbp/misc/Demo.java b/src/edu/berkeley/sbp/misc/Demo.java index 1e5a5bc..b3b9f4c 100644 --- a/src/edu/berkeley/sbp/misc/Demo.java +++ b/src/edu/berkeley/sbp/misc/Demo.java @@ -8,37 +8,62 @@ import java.lang.reflect.*; import java.io.*; public class Demo { + + public static boolean harsh = false; + public static void main(String[] s) throws Exception { + + ReflectiveMeta m = new ReflectiveMeta(); Tree res = new CharParser(MetaGrammar.make()).parse(new FileInputStream(s[0])).expand1(); - - MetaGrammar.Meta m = - new ReflectiveMeta(MG.class, - new Class[] { - MG.Grammar.class, - MG.NonTerminal.class, - MG.Range.class, - MG.El.class, - MG.Seq.class, - MG.NonTerminalReference.class, - MG.StringLiteral.class, - MG.Tree.class, - MG.CharClass.class - }); MetaGrammar.Meta.MetaGrammarFile mgf = m.new MetaGrammarFile(res); MetaGrammar.BuildContext bc = new MetaGrammar.BuildContext(mgf); Union meta = mgf.get("s").build(bc); - System.err.println("parsing " + s[1]); Tree t = new CharParser(meta).parse(new FileInputStream(s[1])).expand1(); + System.out.println("tree:\n" + t.toPrettyString()); - System.out.println(t.toPrettyString()); Reducer red = (Reducer)t.head(); - System.out.println(red.reduce(t)); + MG.Grammar g = (MG.Grammar)red.reduce(t); + System.out.println(g); + + Context cx = new Context(g,m); + Element u = null; + for(MG.NonTerminal nt : g.nonterminals) { + Union el = (Union)cx.get(nt.name); + StringBuffer st = new StringBuffer(); + el.toString(st); + System.err.println(st); + if (nt.name.equals("s")) u = el; + } + System.err.println(); + + System.err.println("== parsing with parsed grammar ================================================================================="); + t = new CharParser((Union)u).parse(new FileInputStream(s[1])).expand1(); + System.out.println(t.toPrettyString()); + + System.err.println("== parsing with parsed-parsed grammar =========================================================================="); + t = new CharParser(new Context(t, m).build()).parse(new FileInputStream(s[1])).expand1(); + System.out.println(t.toPrettyString()); } public static class ReflectiveMeta extends MetaGrammar.Meta { private final Class _cl; private final Class[] _inner; + public ReflectiveMeta() { + this(MG.class, + new Class[] { + MG.Grammar.class, + MG.NonTerminal.class, + MG.AnonUn.class, + MG.Range.class, + MG.El.class, + MG.Seq.class, + MG.NonTerminalReference.class, + MG.StringLiteral.class, + MG.Tree.class, + MG.CharClass.class + }); + } public ReflectiveMeta(Class c, Class[] inner) { this._cl = c; this._inner = inner; @@ -87,7 +112,7 @@ public class Demo { } }; } - public Sequence resolveTag(String tag, String nonTerminalName, Element[] els, Object[] labels, boolean[] drops) { + public Sequence tryResolveTag(String tag, String nonTerminalName, Element[] els, Object[] labels, boolean[] drops) { Production p = new Production(tag, nonTerminalName, els, labels, drops); for(Method m : _cl.getMethods()) if (new TargetMethod(m).isCompatible(p)) @@ -99,20 +124,21 @@ public class Demo { for(Class c : _inner) if (new TargetClass(c).isCompatible(p)) return new TargetClass(c).makeSequence(p); - throw new RuntimeException("could not find a Java method/class/ctor matching tag \""+tag+"\", nonterminal \""+nonTerminalName+"\""); + return null; + } + public Sequence resolveTag(String tag, String nonTerminalName, Element[] els, Object[] labels, boolean[] drops) { + Sequence ret = tryResolveTag(tag, nonTerminalName, els, labels, drops); + if (ret != null) return ret; + String message = "could not find a Java method/class/ctor matching tag \""+tag+ + "\", nonterminal \""+nonTerminalName+"\" with " + els.length + " arguments"; + if (harsh) { + throw new RuntimeException(message); + } else { + System.err.println(message); + return Sequence.rewritingSequence(tag, els, labels, drops); + } } } - /* - public static Object makeFlattener(final Method m, final Element[] els, final Object[] labels, final boolean[] drops) { - return new Reducer() { - public Object reduce(Tree t) { - Object[] o = new Object[m.getParameterTypes()]; - int j = 0; - for(int i=0; i bad2 = new HashSet(); + for(int i=0; i bad = new HashSet(); - for(Seq[] group : sequences) { - Union u2 = new Union(""+anon++); - HashSet bad2 = new HashSet(); - for(Seq seq : group) { - Sequence built = seq.build(cx); - for(Sequence s : bad) - built = built.not(s); - u2.add(built); - bad2.add(built); - } - bad.addAll(bad2); - u.add(Sequence.singleton(u2)); - } - return u; + Union ret = new Union(); + build(cx, ret); + return ret; } } - public static @tag void range(char c) { } + //public static @tag void range(char c) { } public static class Range { public @tag("range") Range(char only) { first = only; last = only; } public @tag("-") Range(char first, char last) { this.first = first; this.last = last; } @@ -475,6 +518,7 @@ public class Demo { public Drop(El e) { this.e = e; } public String getLabel() { return null; } public boolean drop() { return true; } + public String getOwnerTag() { return e.getOwnerTag(); } public Element build(Context cx) { return e.build(cx); } } public static class Label extends El { @@ -482,6 +526,7 @@ public class Demo { public El e; public Label(String label, El e) { this.e = e; this.label = label; } public String getLabel() { return label; } + public String getOwnerTag() { return e.getOwnerTag(); } public Element build(Context cx) { return e.build(cx); } } public static /*abstract*/ class Seq { @@ -490,6 +535,7 @@ public class Demo { El[] elements; El follow; String tag = null; + boolean lame; public Seq(El e) { this(new El[] { e }); } public Seq(El[] elements) { this.elements = elements; } public Seq tag(String tag) { this.tag = tag; return this; } @@ -502,8 +548,8 @@ public class Demo { ret.tag = tag; return ret; } - public Seq and(Seq s) { and.add(s); return this; } - public Seq andnot(Seq s) { not.add(s); return this; } + public Seq and(Seq s) { and.add(s); s.lame = true; return this; } + public Seq andnot(Seq s) { not.add(s); s.lame = true; return this; } public Seq separate(El sep) { El[] elements = new El[this.elements.length * 2 - 1]; for(int i=0; i " + ret); - ret = Sequence.rewritingSequence(tag, els, labels, drops); + ret = cx.rm.resolveTag(tag, cx.cnt, els, labels, drops); } else { int idx = -1; for(int i=0; i map = new HashMap(); + private MG.Grammar grammar; + public String cnt = null; + private ReflectiveMeta rm; + public Context(MG.Grammar g, ReflectiveMeta rm) { + this.grammar = g; + this.rm = rm; + } + public Union build() { + Union ret = null; + for(MG.NonTerminal nt : grammar.nonterminals) { + Union u = get(nt.name); + if ("s".equals(nt.name)) + ret = u; + } + return ret; + } + public Context(Tree t, ReflectiveMeta rm) { + this.rm = rm; + Reducer red = (Reducer)t.head(); + this.grammar = (MG.Grammar)red.reduce(t); + } public Union peek(String name) { return map.get(name); } public void put(String name, Union u) { map.put(name, u); } public Union get(String name) { Union ret = map.get(name); - if (ret==null) map.put(name, ret = new Union(name)); + if (ret != null) return ret; + ret = new Union(name); + map.put(name, ret); + MG.NonTerminal nt = grammar.get(name); + if (nt==null) { + System.err.println("*** warning could not find " + name); + } else { + String old = cnt; + cnt = name; + nt.build(this, ret); + cnt = old; + } return ret; } } - public static Object repeatTag() { return null; } }