X-Git-Url: http://git.megacz.com/?p=sbp.git;a=blobdiff_plain;f=src%2Fedu%2Fberkeley%2Fsbp%2Fmeta%2FGrammarAST.java;h=0b4ba07d9d21cc74210d2cc4ffd863bf9d7069a5;hp=1c1ef3de09dfb6302742049d243cee5e80c35fae;hb=f05128e0aee9894a93455dd425ed6104a90a3999;hpb=fec264a3cce7bb2f0016343c86c3cc63d7321eac diff --git a/src/edu/berkeley/sbp/meta/GrammarAST.java b/src/edu/berkeley/sbp/meta/GrammarAST.java index 1c1ef3d..0b4ba07 100644 --- a/src/edu/berkeley/sbp/meta/GrammarAST.java +++ b/src/edu/berkeley/sbp/meta/GrammarAST.java @@ -39,6 +39,15 @@ public class GrammarAST { return new GrammarAST(resolver, "").buildGrammar(grammarAST, startingNonterminal); } + /** This does not work yet */ + public static void emitCode(PrintWriter pw, Tree grammarAST, String startingNonterminal, ImportResolver resolver) { + GrammarAST ga = new GrammarAST(resolver, ""); + Object o = ga.walk(grammarAST); + GrammarAST.GrammarNode gn = (GrammarAST.GrammarNode)o; + EmitContext ecx = ga.new EmitContext(gn); + gn.emitCode(ecx, pw, "com.foo", "ClassName"); + } + private static Object illegalTag = ""; // this is the tag that should never appear in the non-dropped output FIXME // Instance ////////////////////////////////////////////////////////////////////////////// @@ -116,9 +125,9 @@ public class GrammarAST { if (head.equals("Quoted")) return stringifyChildren(t); if (head.equals("Literal")) return new LiteralNode(walkString(t.child(0))); if (head.equals("->")) return walkSeq(t.child(0)).follow(walkElement(t.child(1))); - if (head.equals("DropNT")) return new NonTerminalNode(walkString(t.child(0)), (Seq[][])walkChildren(t.child(1)), false, null, true); + if (head.equals("DropNT")) return new NonTerminalNode(walkString(t.child(0)), (Seq[][])walkChildren(t.child(1)), false, null, true, false); if (head.equals("=")) return new NonTerminalNode(walkString(t.child(0)), (Seq[][])walk(t.child(2)), - true, t.size()==2 ? null : walkString(t.child(1)), false); + true, t.size()==2 ? null : walkString(t.child(1)), false, false); if (head.equals("&")) return walkSeq(t.child(0)).and(walkSeq(t.child(1))); if (head.equals("&~")) return walkSeq(t.child(0)).andnot(walkSeq(t.child(1))); if (head.equals("/")) return (walkSeq(t.child(0))).separate(walkElement(t.child(1))); @@ -143,14 +152,14 @@ public class GrammarAST { if (head.equals("SubGrammar")) return GrammarAST.buildFromAST(t.child(0), "s", resolver); if (head.equals("NonTerminal")) return new NonTerminalNode(walkString(t.child(0)), - (Seq[][])walkChildren(t.child(1)), false, null, false); + (Seq[][])walkChildren(t.child(1)), false, null, false, false); if (head.equals("Colons")) { String tag = walkString(t.child(0)); Seq[][] seqs = (Seq[][])walk(t.child(1)); for(Seq[] seq : seqs) for(int i=0; i= 'A' && nt.name.charAt(0) <= 'Z')) continue; + StringBuffer fieldDeclarations = new StringBuffer(); + StringBuffer walkCode = new StringBuffer(); + nt.getUnionNode().emitCode(cx, fieldDeclarations, walkCode); + if (nt.tagged) { + pw.println(" public static class " + nt.name + "{"); + pw.println(fieldDeclarations); + pw.println(" }"); + pw.println(" public static " + nt.name + " walk"+nt.name+"(Tree t) {"); + pw.println(" int i = 0;"); + pw.println(walkCode); + pw.println(" }"); + } else { + // FIXME; list who extends it + pw.println(" public static interface " + nt.name + "{ }"); + // FIXME: what on earth is this going to be? + pw.println(" public static " + nt.name + " walk"+nt.name+"(Tree t) {"); + pw.println(" throw new Error(\"FIXME\");"); + pw.println(" }"); + } + } + pw.println("}"); + } } /** a NonTerminal is always a union at the top level */ @@ -220,14 +258,16 @@ public class GrammarAST { public final String name; public final ElementNode elementNode; public final UnionNode unionNode; - public NonTerminalNode(String name, Seq[][] sequences, boolean rep, String sep, boolean alwaysDrop) { + public final boolean tagged; + public NonTerminalNode(String name, Seq[][] sequences, boolean rep, String sep, boolean alwaysDrop, boolean tagged) { this.name = prefix + name; this.alwaysDrop = alwaysDrop; + this.tagged = tagged; this.unionNode = new UnionNode(sequences, rep, sep==null?null:(prefix + sep)); this.elementNode = alwaysDrop ? new DropNode(unionNode) : unionNode; } public boolean isDropped(Context cx) { return alwaysDrop; } - public Element build(Context cx, NonTerminalNode cnt, boolean dropall) { return cx.get(name); } + public Element build(BuildContext cx, NonTerminalNode cnt, boolean dropall) { return cx.get(name); } public ElementNode getElementNode() { return elementNode; } public UnionNode getUnionNode() { return unionNode; } } @@ -245,6 +285,16 @@ public class GrammarAST { /** negative conjuncts */ HashSet not = new HashSet(); public boolean alwaysDrop = false; + + public boolean isTagless() { + if (alwaysDrop) return true; + for(int i=0; i, **, ++, or a similar character-class"+ " operator on a [potentially] multicharacter production"); @@ -301,14 +351,14 @@ public class GrammarAST { this.elements = elements; return this; } - public Sequence build(Context cx, Union u, NonTerminalNode cnt, boolean dropall) { + public Sequence build(BuildContext cx, Union u, NonTerminalNode cnt, boolean dropall) { Sequence ret = build0(cx, cnt, dropall); for(Seq s : and) ret = ret.and(s.build(cx, null, cnt, true)); for(Seq s : not) ret = ret.andnot(s.build(cx, null, cnt, true)); if (u!=null) u.add(ret); return ret; } - public Sequence build0(Context cx, NonTerminalNode cnt, boolean dropall) { + public Sequence build0(BuildContext cx, NonTerminalNode cnt, boolean dropall) { boolean[] drops = new boolean[elements.length]; Element[] els = new Element[elements.length]; dropall |= isDropped(cx); @@ -361,8 +411,28 @@ public class GrammarAST { public String getFieldName() { return null; } public boolean isLifted() { return false; } public boolean isDropped(Context cx) { return false; } - public Atom toAtom(Context cx) { throw new Error("can't convert a " + this.getClass().getName() + " to an atom: " + this); } - public abstract Element build(Context cx, NonTerminalNode cnt, boolean dropall); + //public abstract boolean isTagless(); + public boolean isTagless() { return false; } + public void _emitCode(EmitContext cx, + StringBuffer fieldDeclarations, + StringBuffer walkCode) { + throw new RuntimeException("not implemented " + this.getClass().getName()); + } + public final void emitCode(EmitContext cx, + StringBuffer fieldDeclarations, + StringBuffer walkCode) { + if (isDropped(cx)) return; + if (isTagless()) { + // parse just the literal text, create an int/float/char/string + // FIXME: how do we know which one? + walkCode.append(" stringify"); + } else { + } + _emitCode(cx, fieldDeclarations, walkCode); + walkCode.append(" i++;"); + } + public Atom toAtom(BuildContext cx) { throw new Error("can't convert a " + this.getClass().getName() + " to an atom: " + this); } + public abstract Element build(BuildContext cx, NonTerminalNode cnt, boolean dropall); } /** a union, produced by a ( .. | .. | .. ) construct */ @@ -384,6 +454,32 @@ public class GrammarAST { this.rep = rep; this.sep = sep; } + + public boolean isTagless() { + for (Seq[] ss : sequences) + for (Seq s : ss) + if (!s.isTagless()) return false; + return true; + } + + public String[] getPossibleEmitClasses() { + HashSet cl = new HashSet (); + for(Seq[] ss : sequences) + for(Seq s : ss) { + /* + String cls = s.getEmitClass(); + if (cls != null) cl.add(cls); + */ + } + return (String[])cl.toArray(new String[0]); + } + + public void _emitCode(EmitContext cx, + StringBuffer fieldDeclarations, + StringBuffer walkCode) { + throw new RuntimeException("not implemented " + this.getClass().getName()); + } + public String getFieldName() { return null; } public boolean isLifted() { return false; } public boolean isDropped(Context cx) { @@ -393,7 +489,7 @@ public class GrammarAST { return false; return true; } - public Atom toAtom(Context cx) { + public Atom toAtom(BuildContext cx) { Atom ret = null; for(Seq[] ss : sequences) for(Seq s : ss) @@ -401,9 +497,9 @@ public class GrammarAST { return ret; } - public Element build(Context cx, NonTerminalNode cnt, boolean dropall) { + public Element build(BuildContext cx, NonTerminalNode cnt, boolean dropall) { return buildIntoPreallocatedUnion(cx, cnt, dropall, new Union(null, false)); } - public Element buildIntoPreallocatedUnion(Context cx, NonTerminalNode cnt, boolean dropall, Union u) { + public Element buildIntoPreallocatedUnion(BuildContext cx, NonTerminalNode cnt, boolean dropall, Union u) { Union urep = null; if (rep) { urep = new Union(null, false); @@ -454,17 +550,18 @@ public class GrammarAST { if (ret==null) throw new RuntimeException("undefined nonterminal: " + nonTerminal); return ret; } - public Atom toAtom(Context cx) { + public Atom toAtom(BuildContext cx) { ElementNode ret = cx.grammar.get(nonTerminal).getElementNode(); if (ret == null) throw new RuntimeException("unknown nonterminal \""+nonTerminal+"\""); return ret.toAtom(cx); } public boolean isDropped(Context cx) { return resolve(cx).isDropped(cx); } - public Element build(Context cx, NonTerminalNode cnt, boolean dropall) { + public Element build(BuildContext cx, NonTerminalNode cnt, boolean dropall) { Element ret = cx.get(nonTerminal); if (ret == null) throw new RuntimeException("unknown nonterminal \""+nonTerminal+"\""); return ret; } + public String getFieldName() { return StringUtil.uncapitalize(nonTerminal); } } /** a literal string */ @@ -480,13 +577,13 @@ public class GrammarAST { public String getLiteralTag() { return caret ? thePrefix+string : null; } public String toString() { return "\""+string+"\""; } public boolean isDropped(Context cx) { return true; } - public Atom toAtom(Context cx) { + public Atom toAtom(BuildContext cx) { if (string.length()!=1) return super.toAtom(cx); Range.Set set = new Range.Set(); set.add(string.charAt(0), string.charAt(0)); return CharAtom.set(set); } - public Element build(Context cx, NonTerminalNode cnt, boolean dropall) { return CharAtom.string(string); } + public Element build(BuildContext cx, NonTerminalNode cnt, boolean dropall) { return CharAtom.string(string); } } /** an atom (usually a character class) */ @@ -495,8 +592,8 @@ public class GrammarAST { public AtomNode() { this(new char[0][]); } public AtomNode(char[][] ranges) { this.ranges = ranges; } public AtomNode(char[] range) { this.ranges = new char[][] { range }; } - public Element build(Context cx, NonTerminalNode cnt, boolean dropall) { return toAtom(cx); } - public Atom toAtom(Context cx) { + public Element build(BuildContext cx, NonTerminalNode cnt, boolean dropall) { return toAtom(cx); } + public Atom toAtom(BuildContext cx) { Range.Set set = new Range.Set(); for(char[] r : ranges) set.add(r[0], r[1]); return CharAtom.set(set); @@ -510,9 +607,9 @@ public class GrammarAST { public RepeatNode(ElementNode e, ElementNode sep, boolean zero, boolean many, boolean max) { this.e = e; this.sep = sep; this.zero = zero; this.many = many; this.max = max; } - public Atom toAtom(Context cx) { return sep==null ? e.toAtom(cx) : super.toAtom(cx); } + public Atom toAtom(BuildContext cx) { return sep==null ? e.toAtom(cx) : super.toAtom(cx); } public boolean isDropped(Context cx) { return e.isDropped(cx); } - public Element build(Context cx, NonTerminalNode cnt, boolean dropall) { + public Element build(BuildContext cx, NonTerminalNode cnt, boolean dropall) { Element ret = build(cx, cnt, dropall, illegalTag); String must = "must be tagged unless they appear within a dropped expression or their contents are dropped: "; if (!dropall && !isDropped(cx) && !e.isDropped(cx)) @@ -521,7 +618,7 @@ public class GrammarAST { else throw new RuntimeException("one-or-more repetitions (+) " + must + ret); return ret; } - public Element build(Context cx, NonTerminalNode cnt, boolean dropall, Object repeatTag) { + public Element build(BuildContext cx, NonTerminalNode cnt, boolean dropall, Object repeatTag) { return (!max) ? Repeat.repeat(e.build(cx, null, dropall), zero, many, sep==null ? null : sep.build(cx, null, dropall), repeatTag) : sep==null @@ -535,21 +632,29 @@ public class GrammarAST { protected ElementNode _e; public ElementNodeWrapper(ElementNode e) { this._e = e; } public boolean isDropped(Context cx) { return _e.isDropped(cx); } - public Atom toAtom(Context cx) { return _e.toAtom(cx); } - public Element build(Context cx, NonTerminalNode cnt, boolean dropall) { return _e.build(cx, cnt, dropall); } + public Atom toAtom(BuildContext cx) { return _e.toAtom(cx); } + public Element build(BuildContext cx, NonTerminalNode cnt, boolean dropall) { return _e.build(cx, cnt, dropall); } + public String getFieldName() { return _e.getFieldName(); } + public void _emitCode(EmitContext cx, StringBuffer fieldDeclarations, StringBuffer walkCode) { + _e._emitCode(cx, fieldDeclarations, walkCode); + } } /** a backtick node indicating that, when building the AST, the node's children should be inserted here */ private class BacktickNode extends ElementNodeWrapper { public BacktickNode(ElementNode e) { super(e); } public boolean isLifted() { return true; } + public String getFieldName() { throw new Error("FIXME: backtick isn't a single field"); } + public void _emitCode(EmitContext cx, StringBuffer fieldDeclarations, StringBuffer walkCode) { + _e._emitCode(cx, fieldDeclarations, walkCode); + } } /** negation */ private class TildeNode extends ElementNodeWrapper { public TildeNode(ElementNode e) { super(e); } - public Atom toAtom(Context cx) { return (Atom)((Topology)_e.toAtom(cx).complement()); } - public Element build(Context cx, NonTerminalNode cnt, boolean dropall) { return toAtom(cx); } + public Atom toAtom(BuildContext cx) { return (Atom)((Topology)_e.toAtom(cx).complement()); } + public Element build(BuildContext cx, NonTerminalNode cnt, boolean dropall) { return toAtom(cx); } } private class DropNode extends ElementNodeWrapper { @@ -561,6 +666,7 @@ public class GrammarAST { private class LabelNode extends ElementNodeWrapper { public final String label; public LabelNode(String label, ElementNode e) { super(e); this.label = label; } + public String getFieldName() { return label; } } ////////////////////////////////////////////////////////////////////////////// @@ -568,8 +674,18 @@ public class GrammarAST { public class Context { public HashMap map = new HashMap(); public GrammarNode grammar; - public Context(Tree t) { } + public Context() { } public Context(GrammarNode g) { this.grammar = g; } + } + + + public class EmitContext extends Context { + public EmitContext(GrammarNode g) { super(g); } + } + + public class BuildContext extends Context { + public BuildContext(Tree t) { } + public BuildContext(GrammarNode g) { super(g); } public Union build() { Union ret = null; for(NonTerminalNode nt : grammar.values()) {