From 03f91bd299c8c8724fe966f527b7410d2cea675d Mon Sep 17 00:00:00 2001 From: adam Date: Sun, 2 Jul 2006 02:45:18 -0400 Subject: [PATCH] checkpoint darcs-hash:20060702064518-5007d-1371a3d9ffd3b5429f2248c227de35070794658c.gz --- src/edu/berkeley/sbp/Union.java | 36 +++++-- src/edu/berkeley/sbp/misc/Demo.java | 181 +++++++++++++++++++++++++---------- tests/meta.g | 2 + 3 files changed, 162 insertions(+), 57 deletions(-) diff --git a/src/edu/berkeley/sbp/Union.java b/src/edu/berkeley/sbp/Union.java index dce9cbe..4595ebb 100644 --- a/src/edu/berkeley/sbp/Union.java +++ b/src/edu/berkeley/sbp/Union.java @@ -19,6 +19,7 @@ public class Union extends Element implements Iterable { * @param shortForm the "short form" display; usually * @param synthetic if true, this Union's "long form" is "obvious" and should not be displayed when printing the grammar */ + public Union() { this(null, false); } public Union(String shortForm) { this(shortForm, false); } public Union(String shortForm, boolean synthetic) { this.shortForm = shortForm; @@ -62,21 +63,42 @@ public class Union extends Element implements Iterable { // Display ////////////////////////////////////////////////////////////////////////////// - public String toString() { return shortForm; } + public String getName() { + if (shortForm != null) return shortForm; + return "(anon_union)"; + } + public String toString() { + if (shortForm != null) return shortForm; + StringBuffer sb = new StringBuffer(); + sb.append("("); + bodyToString(sb, "", " | "); + sb.append(")"); + return sb.toString(); + } public StringBuffer toString(StringBuffer sb) { if (synthetic) return sb; boolean first = true; + String before = StringUtil.pad(15, getName()) + " = "; if (alternatives.size()==0) { - sb.append(StringUtil.pad(15, shortForm) + " = "); - } else for(Sequence s : this) { + sb.append(before); + } else { + bodyToString(sb, + before, + "\n" + StringUtil.pad(15, "") + " | "); + sb.append('\n'); + } + return sb; + } + + private void bodyToString(StringBuffer sb, String before, String between) { + boolean first = true; + for(Sequence s : this) { + if (s.lame) continue; // FIXME: what to do here about printing out negated sequences? - sb.append(StringUtil.pad(15, first ? shortForm : "") + (first ? " = " : " | ")); + sb.append(first ? before : between); first = false; sb.append(s.toString()); - sb.append('\n'); } - sb.append('\n'); - return sb; } } diff --git a/src/edu/berkeley/sbp/misc/Demo.java b/src/edu/berkeley/sbp/misc/Demo.java index 1e5a5bc..845b1cb 100644 --- a/src/edu/berkeley/sbp/misc/Demo.java +++ b/src/edu/berkeley/sbp/misc/Demo.java @@ -11,11 +11,12 @@ public class Demo { public static void main(String[] s) throws Exception { Tree res = new CharParser(MetaGrammar.make()).parse(new FileInputStream(s[0])).expand1(); - MetaGrammar.Meta m = + ReflectiveMeta m = new ReflectiveMeta(MG.class, new Class[] { MG.Grammar.class, MG.NonTerminal.class, + MG.AnonUn.class, MG.Range.class, MG.El.class, MG.Seq.class, @@ -30,10 +31,30 @@ public class Demo { System.err.println("parsing " + s[1]); Tree t = new CharParser(meta).parse(new FileInputStream(s[1])).expand1(); + System.out.println("tree:\n" + t.toPrettyString()); - System.out.println(t.toPrettyString()); Reducer red = (Reducer)t.head(); - System.out.println(red.reduce(t)); + MG.Grammar g = (MG.Grammar)red.reduce(t); + System.out.println(g); + + Context cx = new Context(g,m); + Element u = null; + for(MG.NonTerminal nt : g.nonterminals) { + 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; + } + 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 ReflectiveMeta extends MetaGrammar.Meta { @@ -99,7 +120,7 @@ public class Demo { for(Class c : _inner) if (new TargetClass(c).isCompatible(p)) return new TargetClass(c).makeSequence(p); - throw new RuntimeException("could not find a Java method/class/ctor matching tag \""+tag+"\", nonterminal \""+nonTerminalName+"\""); + throw new RuntimeException("could not find a Java method/class/ctor matching tag \""+tag+"\", nonterminal \""+nonTerminalName+"\" with " + els.length + " arguments"); } } /* @@ -418,6 +439,12 @@ public class Demo { public static class MG { public static @tag("grammar") class Grammar { + public NonTerminal get(String s) { + for(NonTerminal nt : nonterminals) + if (nt.name.equals(s)) + return nt; + return null; + } public @arg("NonTerminal") NonTerminal[] nonterminals; public String toString() { String ret = "[ "; @@ -425,39 +452,50 @@ public class Demo { return ret + " ]"; } } - public static @nonterminal class NonTerminal extends El { - public @arg("Word") String name; - public @arg("RHS") Seq[][] sequences; - private static int anon = 0; - public NonTerminal() { } - public NonTerminal(Seq[][] sequences) { - this.name = "anon" + (anon++); + 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 bad = new HashSet(); - for(Seq[] group : sequences) { - Union u2 = new Union(""+anon++); - HashSet bad2 = new HashSet(); - for(Seq seq : group) { - Sequence built = seq.build(cx); - for(Sequence s : bad) - built = built.not(s); - u2.add(built); - bad2.add(built); - } - bad.addAll(bad2); - u.add(Sequence.singleton(u2)); - } - return u; + Union ret = new Union(); + build(cx, ret); + return ret; } } - public static @tag void range(char c) { } + //public static @tag void range(char c) { } public static class Range { public @tag("range") Range(char only) { first = only; last = only; } public @tag("-") Range(char first, char last) { this.first = first; this.last = last; } @@ -475,6 +513,7 @@ public class Demo { 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 { @@ -482,6 +521,7 @@ public class Demo { 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 { @@ -490,6 +530,7 @@ public class Demo { 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; } @@ -502,8 +543,8 @@ public class Demo { ret.tag = tag; return ret; } - public Seq and(Seq s) { and.add(s); return this; } - public Seq andnot(Seq s) { not.add(s); return this; } + 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 " + ret); - ret = Sequence.rewritingSequence(tag, els, labels, drops); + ret = cx.rm.resolveTag(tag, cx.cnt, els, labels, drops); } else { int idx = -1; for(int i=0; i 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) map.put(name, ret = new Union(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; } } - public static Object repeatTag() { return null; } } diff --git a/tests/meta.g b/tests/meta.g index 527cd46..7fbcd9a 100644 --- a/tests/meta.g +++ b/tests/meta.g @@ -1,5 +1,7 @@ s = !ws (grammar::Grammar) !ws + Grammar = NonTerminal +/ ws + NonTerminal = Word ^"=" RHS /ws // use 'a'-'z' or 'a-z' instead of [a-z]? -- 1.7.10.4