X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=src%2Fedu%2Fberkeley%2Fsbp%2Fmisc%2FDemo.java;h=fa6d733125025a6b81bb70caf0f2ac2fd1912335;hb=0bf2fced924400a496fb154be71188864296564c;hp=02482fa3619b601656c2eef809b98b5b0b03d2e7;hpb=98ae7592861f7e7d3bf5744b5db84ffdefc6011d;p=sbp.git diff --git a/src/edu/berkeley/sbp/misc/Demo.java b/src/edu/berkeley/sbp/misc/Demo.java index 02482fa..fa6d733 100644 --- a/src/edu/berkeley/sbp/misc/Demo.java +++ b/src/edu/berkeley/sbp/misc/Demo.java @@ -2,136 +2,119 @@ package edu.berkeley.sbp.misc; import edu.berkeley.sbp.util.*; import edu.berkeley.sbp.*; import edu.berkeley.sbp.chr.*; +import edu.berkeley.sbp.bind.*; import java.util.*; import java.lang.annotation.*; 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.out.println(res); + 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 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); + } + public ReflectiveMeta(Class c) { + this._cl = c; + this._inner = c.getDeclaredClasses(); + } public ReflectiveMeta(Class c, Class[] inner) { this._cl = c; this._inner = inner; } - private boolean match(Method m, String s) { return match(m.getAnnotation(tag.class), null, s); } - private boolean match(tag t, Class c, String s) { + private boolean match(Method m, String s) { return match(m.getAnnotation(bind.as.class), null, s); } + private boolean match(bind.as 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(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((bind.as)c.getAnnotation(bind.as.class), c, s)) return true; + //if (match((nonterminal)c.getAnnotation(bind.as.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((bind.as)con.getAnnotation(bind.as.class), null, s)) return true; + //if (match((nonterminal)con.getAnnotation(bind.as.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)) - return Sequence.rewritingSequence(m, els, labels, drops); + if (new Target(m).isCompatible(p)) + return new Target(m).makeSequence(p); for(Class c : _inner) for(Constructor con : c.getConstructors()) - if (new TargetConstructor(con).isCompatible(p)) - return Sequence.rewritingSequence(con, els, labels, drops); + if (new Target(con).isCompatible(p)) + return new Target(con).makeSequence(p); for(Class c : _inner) - if (new TargetClass(c).isCompatible(p)) - return Sequence.rewritingSequence(c, els, labels, drops); - throw new RuntimeException("could not find a Java method/class/ctor matching tag \""+tag+"\", nonterminal \""+nonTerminalName+"\""); + if (new Target(c).isCompatible(p)) + return new Target(c).makeSequence(p); + 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 { + private int[] map; + private String name; + private Bindable _bindable; + private boolean _israw; + public TargetReducer(Production p, int[] map, String name, Bindable b, boolean raw) { + this.map = map; + this.name = name; + this._bindable = b; + this._israw = raw; + } + public String toString() { return name; } + public Object invoke(Iterable> t) { + if (_israw) return _bindable.impose(new Object[] { 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); + } } - int[] ret = buildSequence(p, names, argtags); - if (ret!=null) return true; - for(Constructor c : _class.getConstructors()) - if (new TargetConstructor(c).buildSequence(p)) - return true; - return false; + 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 class TargetMethod extends Target { - public final Method _method; - public TargetMethod(Method _method) { this._method = _method; } - public String getName() { return _method.getName(); } - public tag getTag() { return (tag)_method.getAnnotation(tag.class); } - public nonterminal getNonTerminal() { return (nonterminal)_method.getAnnotation(nonterminal.class); } - public boolean buildSequence(Production p) { - Annotation[][] annotations = _method.getParameterAnnotations(); - String[] names = new String[annotations.length]; - arg[] argtags = new arg[annotations.length]; - for(int i=0; i 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 @arg("NonTerminal") NonTerminal[] nonterminals; - } - public @nonterminal class NonTerminal { - public @arg("Word") String name; - public @arg("RHS") Seq[][] sequences; - } - - public @tag void range(char c) { } - public @nonterminal class Range { - public @tag("range") Range(char only) { first = only; last = only; } - public @arg char first; - public @arg char last; - } - public class El { } - public abstract @nonterminal("Sequence") class Seq { } - public @tag("&") Seq and(Sequence s, Element[] elements) { return null; } - public @tag("&~") Seq andnot(Sequence s, Element[] elements) { return null; } - public @tag Seq ps(Element[] elements) { return null; } - public @tag("::") Seq tag(String tagname, Seq seq) { return null; } - public @tag(":") void colon(String s, Element e) { } - public @tag(")") void close(String foo) { } - public @tag("/") Seq slash(Seq s, Element e) { return null; } - public @tag("->") 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 static class MG { + public static @bind.as("grammar") class Grammar { + public NonTerminal get(String s) { + for(NonTerminal nt : nonterminals) + if (nt.name.equals(s)) + return nt; + return null; + } + public @bind.arg("NonTerminal") NonTerminal[] nonterminals; + public String toString() { + String ret = "[ "; + for(NonTerminal nt : nonterminals) ret += nt + ", "; + return ret + " ]"; + } + } + 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 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 @bind.as("::") Seq tag(String tagname, Seq s) { return s.tag(tagname); } + public static @bind.as("/") Seq slash(Seq s, El e) { return s.separate(e); } + + public static @bind.as("ps") Seq seq(El[] elements) { return new Seq(elements); } + public static @bind.as Seq psx(Seq s) { return s; } + public static @bind.as(":") El colon(String s, El e) { return new Label(s, e); } + public static @bind.as(")") void close(String foo) { throw new Error("not supported"); } + public static @bind.as("()") El epsilon() { return new Constant(Union.epsilon); } + + public static @bind.as("nonTerminal") class NonTerminalReference extends El { + public @bind.arg String nonTerminal; + public Element build(Context cx) { + return cx.get(nonTerminal); + } + } + + public static class StringLiteral extends Constant { + public @bind.as("literal") StringLiteral(String string) { super(CharRange.string(string)); } + public boolean drop() { return true; } + } + + public static class CharClass extends El { + Range[] ranges; + public @bind.as("[") 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 @bind.as("{") class XTree extends El { + public @bind.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 @bind.as("++") El plusmax(final El e) { return new Rep(e, null, false, true, true); } + public static @bind.as("+") El plus(final El e) { return new Rep(e, null, false, true, false); } + public static @bind.as("++/") El plusmaxfollow(final El e, final El sep) { return new Rep(e, sep, false, true, true); } + public static @bind.as("+/") El plusfollow(final El e, final El sep) { return new Rep(e, sep, false, true, false); } + public static @bind.as("**") El starmax(final El e) { return new Rep(e, null, true, true, true); } + public static @bind.as("*") El star(final El e) { return new Rep(e, null, true, true, false); } + public static @bind.as("**/") El starmaxfollow(final El e, final El sep) { return new Rep(e, sep, true, true, true); } + public static @bind.as("*/") El starfollow(final El e, final El sep) { return new Rep(e, sep, true, true, false); } + public static @bind.as("?") El question(final El e) { return new Rep(e, null, true, true, false); } + + public static @bind.as("!") El bang(final El e) { return new Drop(e); } + + public static @bind.as("^") El caret(final String s) { + return new Drop(new Constant(CharRange.string(s)) { + public String getOwnerTag() { return s; } + }); + } + + public static @bind.as("~") El tilde(final El e) { + return new PostProcess(e) { + public Element postProcess(Element e) { + return MetaGrammar.infer((Topology)Atom.toAtom(e).complement()); + } }; } + + public static @bind.as("^^") void doublecaret(final El e) { throw new Error("not implemented"); } + + //public static @bind.as("(") El subexpression(Seq[][] rhs) { return new NonTerminal(rhs); } + + public static @bind.as("Word") String word(String s) { return s; } + public static @bind.as("Quoted") String quoted(String s) { return s; } + public static @bind.as("escaped") String c(char c) { return c+""; } + public static @bind.as("\"\"") String emptystring() { return ""; } + public static @bind.as("\n") String retur() { return "\n"; } + public static @bind.as("\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; + } + } }