From d020e44a27745001cc0c9826fa3aee629da25d43 Mon Sep 17 00:00:00 2001 From: adam Date: Sun, 11 Jan 2009 00:18:39 -0500 Subject: [PATCH] updates to GrammarAST darcs-hash:20090111051839-5007d-26ce9e5c6e4f41093bf88762fd009f0e3a0d46cd.gz --- src/edu/berkeley/sbp/meta/GrammarAST.java | 146 +++++++++++++++++++++++++---- 1 file changed, 129 insertions(+), 17 deletions(-) diff --git a/src/edu/berkeley/sbp/meta/GrammarAST.java b/src/edu/berkeley/sbp/meta/GrammarAST.java index 0085ea5..412f7e1 100644 --- a/src/edu/berkeley/sbp/meta/GrammarAST.java +++ b/src/edu/berkeley/sbp/meta/GrammarAST.java @@ -39,6 +39,14 @@ public class GrammarAST { return new GrammarAST(resolver, "").buildGrammar(grammarAST, startingNonterminal); } + 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 +124,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 +151,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,13 +257,15 @@ 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(BuildContext cx) { return alwaysDrop; } + public boolean isDropped(Context cx) { return alwaysDrop; } public Element build(BuildContext cx, NonTerminalNode cnt, boolean dropall) { return cx.get(name); } public ElementNode getElementNode() { return elementNode; } public UnionNode getUnionNode() { return unionNode; } @@ -245,7 +284,17 @@ public class GrammarAST { /** negative conjuncts */ HashSet not = new HashSet(); public boolean alwaysDrop = false; - public boolean isDropped(BuildContext cx) { + + public boolean isTagless() { + if (alwaysDrop) return true; + for(int i=0; i 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(BuildContext cx) { + public boolean isDropped(Context cx) { for(Seq[] seqs : sequences) for(Seq seq : seqs) if (!seq.isDropped(cx)) @@ -449,7 +544,7 @@ public class GrammarAST { this.nonTerminal = nonTerminal.indexOf('.')==-1 ? (prefix + nonTerminal) : nonTerminal; this.parenthesized = parenthesized; } - public NonTerminalNode resolve(BuildContext cx) { + public NonTerminalNode resolve(Context cx) { NonTerminalNode ret = cx.grammar.get(nonTerminal); if (ret==null) throw new RuntimeException("undefined nonterminal: " + nonTerminal); return ret; @@ -459,7 +554,7 @@ public class GrammarAST { if (ret == null) throw new RuntimeException("unknown nonterminal \""+nonTerminal+"\""); return ret.toAtom(cx); } - public boolean isDropped(BuildContext cx) { return resolve(cx).isDropped(cx); } + public boolean isDropped(Context cx) { return resolve(cx).isDropped(cx); } public Element build(BuildContext cx, NonTerminalNode cnt, boolean dropall) { Element ret = cx.get(nonTerminal); if (ret == null) throw new RuntimeException("unknown nonterminal \""+nonTerminal+"\""); @@ -480,7 +575,7 @@ public class GrammarAST { } public String getLiteralTag() { return caret ? thePrefix+string : null; } public String toString() { return "\""+string+"\""; } - public boolean isDropped(BuildContext cx) { return true; } + public boolean isDropped(Context cx) { return true; } public Atom toAtom(BuildContext cx) { if (string.length()!=1) return super.toAtom(cx); Range.Set set = new Range.Set(); @@ -512,7 +607,7 @@ public class GrammarAST { this.e = e; this.sep = sep; this.zero = zero; this.many = many; this.max = max; } public Atom toAtom(BuildContext cx) { return sep==null ? e.toAtom(cx) : super.toAtom(cx); } - public boolean isDropped(BuildContext cx) { return e.isDropped(cx); } + public boolean isDropped(Context cx) { return e.isDropped(cx); } 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: "; @@ -535,16 +630,23 @@ public class GrammarAST { private abstract class ElementNodeWrapper extends ElementNode { protected ElementNode _e; public ElementNodeWrapper(ElementNode e) { this._e = e; } - public boolean isDropped(BuildContext cx) { return _e.isDropped(cx); } + public boolean isDropped(Context cx) { return _e.isDropped(cx); } 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 */ @@ -556,7 +658,7 @@ public class GrammarAST { private class DropNode extends ElementNodeWrapper { public DropNode(ElementNode e) { super(e); } - public boolean isDropped(BuildContext cx) { return true; } + public boolean isDropped(Context cx) { return true; } } /** provides a label on the fields of a Seq */ @@ -568,11 +670,21 @@ public class GrammarAST { ////////////////////////////////////////////////////////////////////////////// - public class BuildContext { + public class Context { public HashMap map = new HashMap(); public GrammarNode grammar; + 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) { this.grammar = g; } + public BuildContext(GrammarNode g) { super(g); } public Union build() { Union ret = null; for(NonTerminalNode nt : grammar.values()) { -- 1.7.10.4