From 35698bf08ba446ffe96917e8964b5bc43404eda3 Mon Sep 17 00:00:00 2001 From: adam Date: Wed, 28 Jun 2006 00:39:25 -0400 Subject: [PATCH] checkpoint darcs-hash:20060628043925-5007d-7a96b3d37a833f4e486c643edbc546c9412ee230.gz --- src/edu/berkeley/sbp/misc/MetaGrammar.java | 122 +++++++++++++----------- src/edu/berkeley/sbp/misc/MetaGrammarTree.java | 14 +++ tests/regression.tc | 7 ++ 3 files changed, 88 insertions(+), 55 deletions(-) diff --git a/src/edu/berkeley/sbp/misc/MetaGrammar.java b/src/edu/berkeley/sbp/misc/MetaGrammar.java index 4d82952..f5fff5d 100644 --- a/src/edu/berkeley/sbp/misc/MetaGrammar.java +++ b/src/edu/berkeley/sbp/misc/MetaGrammar.java @@ -11,7 +11,7 @@ public class MetaGrammar extends StringWalker { public static Union make() throws Exception { return make(MetaGrammarTree.meta, "s"); } public static Union make(Tree tree, String nt) throws Exception { - Meta.MetaGrammarFile mgf = new MetaGrammar.Meta.MetaGrammarFile(tree); + Meta.MetaGrammarFile mgf = new Meta().new MetaGrammarFile(tree); BuildContext bc = new BuildContext(mgf); return mgf.get(nt).build(bc); } @@ -50,7 +50,7 @@ public class MetaGrammar extends StringWalker { } public static class Meta { - public static class MetaGrammarFile extends HashMap { + public class MetaGrammarFile extends HashMap { public MetaGrammarFile(Tree tree) { if (!tree.head().equals("grammar")) throw new Error(); for(Tree nt : tree.child(0)) @@ -66,7 +66,7 @@ public class MetaGrammar extends StringWalker { return ret; } } - public static class MetaNonterminal { + public class MetaNonterminal { public String name; public MetaUnion rhs; public MetaNonterminal(Tree tree) { @@ -76,12 +76,12 @@ public class MetaGrammar extends StringWalker { public String toString() { return name + " = " + rhs; } public Union build(BuildContext bc) { return rhs.build(bc, name); } } - public static MetaUnion rhs(Tree t) { + public MetaUnion rhs(Tree t) { return t.numChildren()==1 ? new MetaUnion(t.child(0), false) : new MetaUnion(t, true); } - public static class MetaUnion implements MetaSequence { + public class MetaUnion implements MetaSequence { public boolean prioritized; public MetaSequence[] sequences; public Sequence buildSequence(BuildContext bc) { @@ -113,7 +113,6 @@ public class MetaGrammar extends StringWalker { return u; } public MetaUnion(Tree t, boolean prioritized) { - //System.err.println("metaunion: " + t); this.prioritized = prioritized; int i = 0; this.sequences = new MetaSequence[t.numChildren()]; @@ -137,14 +136,14 @@ public class MetaGrammar extends StringWalker { public abstract Sequence buildSequence(BuildContext bc); } - public static MetaSequence makeMetaSequence(Tree t) { - if ("psx".equals(t.head())) return MetaConjunct.make(t.child(0)); - if (t.head().equals("&")) return new MetaAnd(makeMetaSequence(t.child(0)), MetaConjunct.make(t.child(1)), false); - if (t.head().equals("&~")) return new MetaAnd(makeMetaSequence(t.child(0)), MetaConjunct.make(t.child(1)), true); + public MetaSequence makeMetaSequence(Tree t) { + if ("psx".equals(t.head())) return makeMetaConjunct(t.child(0)); + if (t.head().equals("&")) return new MetaAnd(makeMetaSequence(t.child(0)), makeMetaConjunct(t.child(1)), false); + if (t.head().equals("&~")) return new MetaAnd(makeMetaSequence(t.child(0)), makeMetaConjunct(t.child(1)), true); return null; } - public static class MetaAnd implements MetaSequence { + public class MetaAnd implements MetaSequence { boolean not; MetaSequence left; MetaSequence right; @@ -167,15 +166,20 @@ public class MetaGrammar extends StringWalker { public String toString() { return left + " &"+(not?"~":"")+" "+right; } } - public static class MetaConjunct implements MetaSequence { + public class MetaConjunct implements MetaSequence { public boolean negated = false; public MetaClause[] elements; + public HashMap labelMap = new HashMap(); public MetaClause followedBy = null; public String tag; public MetaClause separator; + public void addNamedClause(String name, MetaClause mc) { + labelMap.put(mc, name); + } public Sequence buildSequence(BuildContext bc) { Element[] els = new Element[elements.length + (separator==null?0:(elements.length-1))]; boolean[] drops = new boolean[elements.length + (separator==null?0:(elements.length-1))]; + Object[] labels = new Object[els.length]; boolean unwrap = false; boolean dropAll = false; if (tag!=null && tag.equals("[]")) unwrap = true; @@ -183,6 +187,7 @@ public class MetaGrammar extends StringWalker { for(int i=0; i t) { - //System.err.println("MetaConjunct("+t+")"); elements = new MetaClause[t.numChildren()]; int i = 0; for(Tree tt : t) - elements[i++] = MetaClause.make(tt, this); + elements[i++] = makeMetaClause(tt, this); } public String toString() { String ret = (tag==null ? "" : (tag+":: ")) + (negated ? "~" : ""); @@ -221,20 +226,21 @@ public class MetaGrammar extends StringWalker { if (elements.length > 1) ret += ")"; return ret; } - public static MetaConjunct make(Tree t) { - //System.err.println("MetaConjunct.make("+t+")"); + } + public MetaConjunct makeMetaConjunct(Tree t) { + //System.err.println("makeMetaConjunct("+t+")"); if ("/".equals(t.head())) { - MetaConjunct ret = make(t.child(0)); - ret.separator = MetaClause.make(t.child(1), ret); + MetaConjunct ret = makeMetaConjunct(t.child(0)); + ret.separator = makeMetaClause(t.child(1), ret); return ret; } if ("->".equals(t.head())) { - MetaConjunct ret = make(t.child(0)); - ret.followedBy = MetaClause.make(t.child(1), ret); + MetaConjunct ret = makeMetaConjunct(t.child(0)); + ret.followedBy = makeMetaClause(t.child(1), ret); return ret; } if ("::".equals(t.head())) { - MetaConjunct ret = make(t.child(1)); + MetaConjunct ret = makeMetaConjunct(t.child(1)); ret.tag = string(t.child(0)); return ret; } @@ -243,27 +249,21 @@ public class MetaGrammar extends StringWalker { } return new MetaConjunct(t); } - } - public static abstract class MetaClause { - public String label = null; - public boolean drop = false; - public boolean lift = false; - public abstract Element build(BuildContext bc); - public static MetaClause make(Tree t, MetaConjunct c) { - //System.err.println("MetaClause.make("+t+")"); + public MetaClause makeMetaClause(Tree t, MetaConjunct c) { + //System.err.println("MetaClause.makeMetaClause("+t+")"); if (t==null) return new MetaEpsilon(); if (t.head()==null) return new MetaEpsilon(); if (t.head().equals("{")) throw new Error("metatree: " + t); - if (t.head().equals("*")) return new MetaRepeat(make(t.child(0), c), false, null, true, true); - if (t.head().equals("+")) return new MetaRepeat(make(t.child(0), c), false, null, false, true); - if (t.head().equals("?")) return new MetaRepeat(make(t.child(0), c), false, null, true, false); - if (t.head().equals("**")) return new MetaRepeat(make(t.child(0), c), true, null, true, true); - if (t.head().equals("++")) return new MetaRepeat(make(t.child(0), c), true, null, false, true); - if (t.head().equals("*/")) return new MetaRepeat(make(t.child(0), c), false, make(t.child(1), c), true, true); - if (t.head().equals("+/")) return new MetaRepeat(make(t.child(0), c), false, make(t.child(1), c), false, true); - if (t.head().equals("**/")) return new MetaRepeat(make(t.child(0), c), true, make(t.child(1), c), true, true); - if (t.head().equals("++/")) return new MetaRepeat(make(t.child(0), c), true, make(t.child(1), c), false, true); + if (t.head().equals("*")) return new MetaRepeat(makeMetaClause(t.child(0), c), false, null, true, true); + if (t.head().equals("+")) return new MetaRepeat(makeMetaClause(t.child(0), c), false, null, false, true); + if (t.head().equals("?")) return new MetaRepeat(makeMetaClause(t.child(0), c), false, null, true, false); + if (t.head().equals("**")) return new MetaRepeat(makeMetaClause(t.child(0), c), true, null, true, true); + if (t.head().equals("++")) return new MetaRepeat(makeMetaClause(t.child(0), c), true, null, false, true); + if (t.head().equals("*/")) return new MetaRepeat(makeMetaClause(t.child(0), c), false, makeMetaClause(t.child(1), c), true, true); + if (t.head().equals("+/")) return new MetaRepeat(makeMetaClause(t.child(0), c), false, makeMetaClause(t.child(1), c), false, true); + if (t.head().equals("**/")) return new MetaRepeat(makeMetaClause(t.child(0), c), true, makeMetaClause(t.child(1), c), true, true); + if (t.head().equals("++/")) return new MetaRepeat(makeMetaClause(t.child(0), c), true, makeMetaClause(t.child(1), c), false, true); if (t.head().equals("()")) return new MetaEpsilon(); if (t.head().equals("[")) return new MetaRange(t.child(0)); if (t.head().equals("literal")) return new MetaStringLiteral(t.child(0)); @@ -271,12 +271,25 @@ public class MetaGrammar extends StringWalker { if (t.head().equals(")")) return new MetaSelfReference(); if (t.head().equals("(")) return new MetaParens(t.child(0)); if (t.head().equals("~")) return new MetaInvert(t.child(0), c); - if (t.head().equals("!")) { MetaClause mc = make(t.child(0), c); mc.drop = true; return mc; } + if (t.head().equals("!")) { MetaClause mc = makeMetaClause(t.child(0), c); mc.drop = true; return mc; } if (t.head().equals("^")) { c.tag = string(t.child(0)); return new MetaStringLiteral(t.child(0)); } if (t.head().equals("^^")) throw new Error("carets: " + t); + if (t.head().equals(":")) { + String name = string(t.child(0)); + MetaClause clause = makeMetaClause(t.child(1), c); + c.addNamedClause(name, clause); + return clause; + } throw new Error("unknown: " + t); } - public static class MetaRepeat extends MetaClause { + + public abstract class MetaClause { + public String label = null; + public boolean drop = false; + public boolean lift = false; + public abstract Element build(BuildContext bc); + } + public class MetaRepeat extends MetaClause { public MetaClause element, separator; public boolean maximal, zero, many; public Element build(BuildContext bc) { @@ -302,7 +315,11 @@ public class MetaGrammar extends StringWalker { (separator==null?"":(" /"+separator)); } } - public static class MetaParens extends MetaClause { + public class MetaEpsilon extends MetaClause { + public String toString() { return "()"; } + public Element build(BuildContext bc) { return Union.epsilon; } + } + public class MetaParens extends MetaClause { public MetaUnion body; public MetaParens(Tree t) { this.body = rhs(t); } public String toString() { return "( " + body + " )"; } @@ -311,18 +328,14 @@ public class MetaGrammar extends StringWalker { /* public static class MetaTree extends MetaClause { public MetaConjunct body; - public MetaTree(Tree t) { this.body = MetaConjunct.make(t); } + public MetaTree(Tree t) { this.body = makeMetaConjunct(t); } public String toString() { return "{ " + body + " }"; } public Element build(BuildContext bc) { return new Union("{}");// body.buildSequence(); } } */ - public static class MetaEpsilon extends MetaClause { - public String toString() { return "()"; } - public Element build(BuildContext bc) { return Union.epsilon; } - } - public static class MetaRange extends MetaClause { + public class MetaRange extends MetaClause { Range.Set range = new Range.Set(); public String toString() { return range.toString(); } public Element build(BuildContext bc) { return set(range); } @@ -337,29 +350,28 @@ public class MetaGrammar extends StringWalker { } } } - public static class MetaStringLiteral extends MetaClause { + public class MetaStringLiteral extends MetaClause { public String literal; public Element build(BuildContext bc) { return string(literal); } public MetaStringLiteral(Tree literal) { this.literal = string(literal); this.drop = true; } public String toString() { return "\""+StringUtil.escapify(literal, "\"\r\n\\")+"\""; } } - public static class MetaNonterminalReference extends MetaClause { + public class MetaNonterminalReference extends MetaClause { public String name; public MetaNonterminalReference(Tree name) { this.name = string(name); } public Element build(BuildContext bc) { return bc.build(name); } public String toString() { return name; } } - public static class MetaSelfReference extends MetaClause { + public class MetaSelfReference extends MetaClause { public String toString() { return "(*)"; } public Element build(BuildContext bc) { return new Union("(*)"); /* FIXME */ } } - public static class MetaInvert extends MetaClause { + public class MetaInvert extends MetaClause { public MetaClause element; - public MetaInvert(Tree t, MetaConjunct c) { this.element = make(t, c); } + public MetaInvert(Tree t, MetaConjunct c) { this.element = makeMetaClause(t, c); } public String toString() { return "~"+element; } public Element build(BuildContext bc) { return infer((Topology)Atom.toAtom(element.build(bc)).complement()); } } - } } diff --git a/src/edu/berkeley/sbp/misc/MetaGrammarTree.java b/src/edu/berkeley/sbp/misc/MetaGrammarTree.java index b9b9b2b..b383862 100644 --- a/src/edu/berkeley/sbp/misc/MetaGrammarTree.java +++ b/src/edu/berkeley/sbp/misc/MetaGrammarTree.java @@ -80,6 +80,13 @@ public class MetaGrammarTree { + + + + + + + // DO NOT EDIT STUFF BELOW: IT IS AUTOMATICALLY GENERATED new edu.berkeley.sbp.Tree(null, "grammar", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "=", new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, null, new edu.berkeley.sbp.Tree[] { new edu.berkeley.sbp.Tree(null, "G", new edu.berkeley.sbp.Tree[] { }), new edu.berkeley.sbp.Tree(null, "r", new edu.berkeley.sbp.Tree[] { }), @@ -636,3 +643,10 @@ new edu.berkeley.sbp.Tree(null, "grammar", new edu.berkeley.sbp.Tree[] { new edu + + + + + + + diff --git a/tests/regression.tc b/tests/regression.tc index 025f56e..48a9bae 100644 --- a/tests/regression.tc +++ b/tests/regression.tc @@ -390,3 +390,10 @@ testcase { x = [123] } + +testcase { + input "ab"; + + s = a:"a" b:"b" +} + -- 1.7.10.4