X-Git-Url: http://git.megacz.com/?p=sbp.git;a=blobdiff_plain;f=src%2Fedu%2Fberkeley%2Fsbp%2Fmisc%2FDemo.java;h=c9c18f39b818087f1312edc5b7792873c4b9274b;hp=9c205d8670c78212a5024cdc3388c5f0690edf80;hb=683552e3855cac7417a6f456867a0c1dd96502a4;hpb=9a51c5df6d121f44c34a60fea128c5da7c3dba87 diff --git a/src/edu/berkeley/sbp/misc/Demo.java b/src/edu/berkeley/sbp/misc/Demo.java index 9c205d8..c9c18f3 100644 --- a/src/edu/berkeley/sbp/misc/Demo.java +++ b/src/edu/berkeley/sbp/misc/Demo.java @@ -8,36 +8,58 @@ 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.Epsilon.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); + Tree t = new CharParser(meta).parse(new FileInputStream(s[1])).expand1(); - System.err.println("parsing " + s[1]); - res = new CharParser(meta).parse(new FileInputStream(s[1])).expand1(); + Union u = Demo.make(t, "s"); + + 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()); + } - System.out.println(res); + public static class ReflectiveMetaPlain extends ReflectiveMeta { + public Object repeatTag() { return null; } + public Sequence tryResolveTag(String tag, String nonTerminalName, Element[] els, Object[] labels, boolean[] drops) { + return null; } + public Sequence resolveTag(String tag, String nonTerminalName, Element[] els, Object[] labels, boolean[] drops) { + return Sequence.rewritingSequence(tag, els, labels, drops); + } } 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.AnonUn.class, + MG.Range.class, + MG.El.class, + MG.Seq.class, + MG.NonTerminal.class, + MG.NonTerminalReference.class, + MG.StringLiteral.class, + MG.XTree.class, + MG.CharClass.class + }); + } public ReflectiveMeta(Class c, Class[] inner) { this._cl = c; this._inner = inner; @@ -49,24 +71,29 @@ public class Demo { if (c != null && t.equals("") && c.getSimpleName().equals(s)) return true; return false; } + /* private boolean match(nonterminal t, Class c, String s) { if (t==null) return false; if (t.value().equals(s)) return true; if (c != null && t.equals("") && c.getSimpleName().equals(s)) return true; return false; } + */ private boolean match(Class c, String s, String nonTerminalName) { if (match((tag)c.getAnnotation(tag.class), c, s)) return true; - if (match((nonterminal)c.getAnnotation(nonterminal.class), c, nonTerminalName)) return true; + //if (match((nonterminal)c.getAnnotation(tag.class), c, nonTerminalName)) return true; return false; } public boolean match(Constructor con, String s, String nonTerminalName) { Class c = con.getDeclaringClass(); if (match((tag)con.getAnnotation(tag.class), null, s)) return true; - if (match((nonterminal)con.getAnnotation(nonterminal.class), c, s)) return true; + //if (match((nonterminal)con.getAnnotation(tag.class), c, s)) return true; return false; } - public Sequence resolveTag(String tag, String nonTerminalName, Element[] els, Object[] labels, boolean[] drops) { + public Object repeatTag() { + return new Tree.ArrayBuildingTreeFunctor(); + } + 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)) @@ -78,20 +105,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> t) { return _bindable.impose(new Object[] { t }); } + public boolean isCompatible(Production p) { tag t = getTag(); if (t != null && (t.value().equals(p.tag) || - (t.value().equals("") && p.tag.equals(getName())))) - return buildSequence(p); + (t.value().equals("") && getName().equals(p.tag)))) + return buildSequence(p)!=null; - nonterminal n = getNonTerminal(); + tag n = getTag(); if (n != null && (n.value().equals(p.nonTerminal) || - (n.value().equals("") && p.nonTerminal.equals(getName())))) - return buildSequence(p); + (n.value().equals("") && getName().equals(p.nonTerminal)))) + return buildSequence(p)!=null; return false; } + public int[] buildSequence(Production p, String[] names, arg[] argtags) { int argTagged = 0; for(int i=0; i { + private Production p; + private int[] map; + private String name; + public TargetReducer(Production p, int[] map, String name) { + this.p = p; + this.map = map; + this.name = name; + } + public String toString() { return name; } + public Object invoke(Iterable> t) { + if (isRaw()) return invokeRaw(t); + ArrayList ret = new ArrayList(); + for(Tree tc : t) { + if (tc.head() != null && tc.head() instanceof Functor) + ret.add(((Tree.TreeFunctor)tc.head()).invoke(tc.children())); + else if (tc.numChildren() == 0) + ret.add(tc.head()); + else { + System.err.println("FIXME: don't know what to do about " + tc); + ret.add(null); + } + } + System.err.println("input tree: " + t); + Object[] o = (Object[])ret.toArray(new Object[0]); + int max = 0; + for(int i=0; i name.lastIndexOf('.')) { len--; ofs++; } + */ String[] names = new String[len]; arg[] argtags = new arg[len]; for(int i=0; i res = new CharParser(MetaGrammar.make()).parse(new FileInputStream("tests/meta.g")).expand1(); + MetaGrammar.Meta.MetaGrammarFile mgf = m.new MetaGrammarFile(res); + MetaGrammar.BuildContext bc = new MetaGrammar.BuildContext(mgf); + Union meta = mgf.get("s").build(bc); + Tree t = new CharParser(meta).parse(new FileInputStream("tests/meta.g")).expand1(); + return cached = make(t, "s"); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + public static Union make(Tree t, String s) { return make(t, s, new ReflectiveMeta()); } + public static Union make(Tree t, String s, ReflectiveMeta rm) { + Tree.TreeFunctor red = (Tree.TreeFunctor)t.head(); + MG.Grammar g = (MG.Grammar)red.invoke(t.children()); + Context cx = new Context(g,rm); + Union u = null; + for(MG.NonTerminal nt : g.nonterminals) { + System.out.println(nt.name); + 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; } + return u; } - public class MG { - public @tag void grammar(Grammar g) { } - public @nonterminal void Grammar(NonTerminal[] n) { } - public @nonterminal class Grammar { + public static class MG { + public static @tag("grammar") class Grammar { + public NonTerminal get(String s) { + for(NonTerminal nt : nonterminals) + if (nt.name.equals(s)) + return nt; + return null; + } public @arg("NonTerminal") NonTerminal[] nonterminals; + public String toString() { + String ret = "[ "; + for(NonTerminal nt : nonterminals) ret += nt + ", "; + return ret + " ]"; + } } - public @nonterminal class NonTerminal { - public @arg("Word") String name; - public @arg("RHS") Seq[][] sequences; + public abstract static class Un extends El { + public Seq[][] sequences; + public void build(Context cx, Union u) { + HashSet bad2 = new HashSet(); + for(int i=0; i") Seq arrow(Seq s, Element e) { return null; } - - public @tag("nonTerminal") class NonTerminalReference { public @arg String nonTerminal; } - public @tag("literal") class StringLiteral { public @arg String string; } - public @tag("()") class Epsilon { } - public @tag("{") class Tree { @arg Seq body; } - public @tag("[") class CharClass { public CharClass(Range[] ranges) { } } - - public @tag("++") void plusmax(El e) { } - public @tag("+") void plus(El e) { } - public @tag("++/") void plusmaxfollow(El e, El sep) { } - public @tag("+/") void plusfollow(El e, El sep) { } - public @tag("**") void starmax(El e) { } - public @tag("*") void star(El e) { } - public @tag("**/") void starmaxfollow(El e, El sep) { } - public @tag("*/") void starfollow(El e, El sep) { } - public @tag("!") void bang(El e) { } - public @tag("?") void question(El e) { } - public @tag("^") void caret(String s) { } - public @tag("~") void tilde(El e) { } - public @tag("^^") void doublecaret(El e) { } - public @tag("(") void subexpression(Seq[][] rhs) { } - - public @nonterminal("Word") String word(String s) { return null; } - public @nonterminal("Quoted") String quoted(String s) { return null; } - public @nonterminal("escaped") String c(char c) { return null; } - public @tag("\"\"") String emptystring() { return null; } - public @tag("\r") String lf() { return null; } - public @tag("\n") String cr() { return null; } + public @tag("-") Range(char first, char last) { this.first = first; this.last = last; } + public char first; + public char last; + } + public static abstract class El { + public String getLabel() { return null; } + public String getOwnerTag() { return null; } + public boolean drop() { return false; } + public abstract Element build(Context cx); + } + public static class Drop extends El { + public El e; + 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 { + public String label; + 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 { + HashSet and = new HashSet(); + HashSet not = new HashSet(); + 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; } + public Seq follow(El follow) { this.follow = follow; return this; } + public Seq dup() { + Seq ret = new Seq(elements); + ret.and.addAll(and); + ret.not.addAll(not); + ret.follow = follow; + ret.tag = tag; + return ret; + } + 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") Seq arrow(Seq s, El e) { return s.follow(e); } + public static @tag("::") Seq tag(String tagname, Seq s) { return s.tag(tagname); } + public static @tag("/") Seq slash(Seq s, El e) { return s.separate(e); } + + public static @tag("ps") Seq seq(El[] elements) { return new Seq(elements); } + public static @tag Seq psx(Seq s) { return s; } + public static @tag(":") El colon(String s, El e) { return new Label(s, e); } + public static @tag(")") void close(String foo) { throw new Error("not supported"); } + public static @tag("()") El epsilon() { return new Constant(Union.epsilon); } + + public static @tag("nonTerminal") class NonTerminalReference extends El { + public @arg String nonTerminal; + public Element build(Context cx) { + return cx.get(nonTerminal); + } + } + + public static class StringLiteral extends Constant { + public @tag("literal") StringLiteral(String string) { super(CharRange.string(string)); } + public boolean drop() { return true; } + } + + public static class CharClass extends El { + Range[] ranges; + public @tag("[") CharClass(Range[] ranges) { this.ranges = ranges; } + public Element build(Context cx) { + edu.berkeley.sbp.util.Range.Set set = new edu.berkeley.sbp.util.Range.Set(); + for(Range r : ranges) + set.add(r.first, r.last); + return CharRange.set(set); + } + } + + public static @tag("{") class XTree extends El { + public @arg Seq body; + public Element build(Context cx) { + throw new Error(); + } + } + + public static class Rep extends El { + public El e, sep; + public boolean zero, many, max; + public Rep(El e, El sep, boolean zero, boolean many, boolean max) { + this.e = e; this.sep = sep; this.zero = zero; this.many = many; this.max = max;} + public Element build(Context cx) { + return (!max) + ? Sequence.repeat(e.build(cx), zero, many, sep==null ? null : sep.build(cx), cx.rm.repeatTag()) + : sep==null + ? Sequence.repeatMaximal(MetaGrammar.infer(e.build(cx)), zero, many, cx.rm.repeatTag()) + : Sequence.repeatMaximal(e.build(cx), zero, many, MetaGrammar.infer(sep.build(cx)), cx.rm.repeatTag()); + } + } + public static class Constant extends El { + Element constant; + public Constant(Element constant) { this.constant = constant; } + public Element build(Context cx) { return constant; } + } + public abstract static class PostProcess extends El { + El e; + public PostProcess(El e) { this.e = e; } + public Element build(Context cx) { return postProcess(e.build(cx)); } + public abstract Element postProcess(Element e); + } + + // FIXME: it would be nice if we could hoist this into "Rep" + public static @tag("++") El plusmax(final El e) { return new Rep(e, null, false, true, true); } + public static @tag("+") El plus(final El e) { return new Rep(e, null, false, true, false); } + public static @tag("++/") El plusmaxfollow(final El e, final El sep) { return new Rep(e, sep, false, true, true); } + public static @tag("+/") El plusfollow(final El e, final El sep) { return new Rep(e, sep, false, true, false); } + public static @tag("**") El starmax(final El e) { return new Rep(e, null, true, true, true); } + public static @tag("*") El star(final El e) { return new Rep(e, null, true, true, false); } + public static @tag("**/") El starmaxfollow(final El e, final El sep) { return new Rep(e, sep, true, true, true); } + public static @tag("*/") El starfollow(final El e, final El sep) { return new Rep(e, sep, true, true, false); } + public static @tag("?") El question(final El e) { return new Rep(e, null, true, true, false); } + + public static @tag("!") El bang(final El e) { return new Drop(e); } + + public static @tag("^") El caret(final String s) { + return new Drop(new Constant(CharRange.string(s)) { + public String getOwnerTag() { return s; } + }); + } + + public static @tag("~") El tilde(final El e) { + return new PostProcess(e) { + public Element postProcess(Element e) { + return MetaGrammar.infer((Topology)Atom.toAtom(e).complement()); + } }; } + + public static @tag("^^") void doublecaret(final El e) { throw new Error("not implemented"); } + + //public static @tag("(") El subexpression(Seq[][] rhs) { return new NonTerminal(rhs); } + + public static @tag("Word") String word(String s) { return s; } + public static @tag("Quoted") String quoted(String s) { return s; } + public static @tag("escaped") String c(char c) { return c+""; } + public static @tag("\"\"") String emptystring() { return ""; } + public static @tag("\n") String retur() { return "\n"; } + public static @tag("\r") String lf() { return "\r"; } + } + public static class Context { + HashMap 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; + Tree.TreeFunctor red = (Tree.TreeFunctor)t.head(); + this.grammar = (MG.Grammar)red.invoke(t.children()); + } + 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) 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; + } + } }