X-Git-Url: http://git.megacz.com/?p=sbp.git;a=blobdiff_plain;f=src%2Fedu%2Fberkeley%2Fsbp%2Fmisc%2FDemo.java;h=92c9194e91821509ee592d8c591903886907a01b;hp=3174b6259c5e9451b255d3b5bcbb98b1af1bd0b9;hb=3c03a0a1131b46a23ccfdeab2cb4fbd59ee05b7a;hpb=4f85e595f1d2d00f7e139226e91b780920bc5fc2 diff --git a/src/edu/berkeley/sbp/misc/Demo.java b/src/edu/berkeley/sbp/misc/Demo.java index 3174b62..92c9194 100644 --- a/src/edu/berkeley/sbp/misc/Demo.java +++ b/src/edu/berkeley/sbp/misc/Demo.java @@ -8,38 +8,49 @@ 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); - System.err.println("parsing " + s[1]); + Union meta = mgf.get("s").build(bc); Tree t = 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()); - Reducer red = (Reducer)t.head(); - System.out.println(red.reduce(t)); } 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; @@ -70,7 +81,7 @@ public class Demo { } public Object repeatTag() { return new Reducer() { - public String toString() { return "[**]"; } + public String toString() { return ""; } public Object reduce(Tree t) { Object[] ret = new Object[t.numChildren()]; for(int i=0; i bad2 = new HashSet(); + for(int i=0; i") Seq arrow(Seq s, El e) { return new Seq(); } - - public static @tag("nonTerminal") class NonTerminalReference extends El { public @arg String nonTerminal; } - public static @tag("literal") class StringLiteral extends El { public @arg String string; } - public static @tag("()") class Epsilon extends El { } - public static @tag("{") class Tree extends El { public @arg Seq body; } - public static class CharClass extends El { public @tag("[") CharClass(Range[] ranges) { } } - - public static @tag("++") void plusmax(El e) { } - public static @tag("+") void plus(El e) { } - public static @tag("++/") void plusmaxfollow(El e, El sep) { } - public static @tag("+/") void plusfollow(El e, El sep) { } - public static @tag("**") void starmax(El e) { } - public static @tag("*") void star(El e) { } - public static @tag("**/") void starmaxfollow(El e, El sep) { } - public static @tag("*/") void starfollow(El e, El sep) { } - public static @tag("!") void bang(El e) { } - public static @tag("?") void question(El e) { } - public static @tag("^") void caret(String s) { } - public static @tag("~") void tilde(El e) { } - public static @tag("^^") void doublecaret(El e) { } - public static @tag("(") void subexpression(/*Seq[][]*/Object rhs) { } - - public static @nonterminal("Word") String word(String s) { return null; } - public static @nonterminal("Quoted") String quoted(String s) { return null; } - public static @nonterminal("escaped") String c(char c) { return null; } - public static @tag("\"\"") String emptystring() { return null; } - public static @tag("\r") String lf() { return null; } - public static @tag("\n") String cr() { return null; } + 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 Tree 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 @nonterminal("Word") String word(String s) { return s; } + public static @nonterminal("Quoted") String quoted(String s) { return s; } + public static @nonterminal("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; + 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) 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; + } + } }