X-Git-Url: http://git.megacz.com/?p=sbp.git;a=blobdiff_plain;f=src%2Fedu%2Fberkeley%2Fsbp%2Fmisc%2FDemo.java;h=845b1cbd49a093330d86e6448d2577e54dfcb5aa;hp=1e5a5bc086f43e9b672b3235742c30eeb5c9fa4a;hb=03f91bd299c8c8724fe966f527b7410d2cea675d;hpb=3f8696dcb17f7088ec004a9ef5960cc4d5fce60f

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<String> 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<Sequence> bad2 = new HashSet<Sequence>();
+                for(int i=0; i<sequences.length; i++) {
+                    Seq[] group = sequences[i];
+                    Union u2 = new Union();
+                    if (sequences.length==1) u2 = u;
+                    for(int j=0; j<group.length; j++) {
+                        group[j].build(cx, u2);
+                    }
+                    if (sequences.length==1) break;
+                    Sequence seq = Sequence.singleton(u2);
+                    for(Sequence s : bad2) {
+                        s.lame = true;
+                        seq = seq.not(s);
+                    }
+                    u.add(seq);
+                    bad2.add(Sequence.singleton(u2));
+                }
+            }
+        }
+        public static class NonTerminal extends Un {
+            public String  name = null;
+            public @nonterminal("NonTerminal") NonTerminal(@arg("Word") String name,
+                                                           @arg("RHS") Seq[][] sequences) {
+                this.name = name;
+                this.sequences = sequences;
+            }
+            public Element build(Context cx) { return cx.get(name); }
+        }
+
+        public static class AnonUn extends Un {
+            public @tag("(") AnonUn(Seq[][] sequences) {
                 this.sequences = sequences;
             }
             public Element build(Context cx) {
-                Element ret = cx.peek(name);
-                if (ret != null) return ret;
-                Union u = new Union(name);
-                cx.put(name, u);
-                HashSet<Sequence> bad = new HashSet<Sequence>();
-                for(Seq[] group : sequences) {
-                    Union u2 = new Union(""+anon++);
-                    HashSet<Sequence> bad2 = new HashSet<Sequence>();
-                    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<this.elements.length; i++) {
@@ -514,7 +555,14 @@ public class Demo {
                 this.elements = elements;
                 return this;
             }
-            public Sequence build(Context cx) {
+            public Sequence build(Context cx, Union u) {
+                Sequence ret = build0(cx);
+                for(Seq s : and) { Sequence dork = s.build(cx, u); dork.lame = true; ret = ret.and(dork); }
+                for(Seq s : not) { Sequence dork = s.build(cx, u); dork.lame = true; ret = ret.not(dork); }
+                u.add(ret);
+                return ret;
+            }
+            public Sequence build0(Context cx) {
                 boolean unwrap = false;
                 boolean dropAll = false;
                 if (tag!=null && tag.equals("[]")) unwrap  = true;
@@ -531,12 +579,9 @@ public class Demo {
                 }
                 Sequence ret = null;
                 if (dropAll)     ret = Sequence.drop(els, false);
-                else if (unwrap) ret = Sequence.unwrap(els, repeatTag(), drops);
+                else if (unwrap) ret = Sequence.unwrap(els, cx.rm.repeatTag(), drops);
                 else if (tag!=null) {
-                    //FIXME
-                    //ret = resolveTag(tag, bc.currentNonTerminal==null ? null : bc.currentNonTerminal.name, els, labels, drops);
-                    //System.err.println("resolvetag " + tag + " => " + 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<els.length; i++)
@@ -548,6 +593,7 @@ public class Demo {
                 }
                 if (this.follow != null)
                     ret.follow = MetaGrammar.infer(this.follow.build(cx));
+                ret.lame = this.lame;
                 return ret;
             }
         }
@@ -565,17 +611,21 @@ public class Demo {
 
         public static @tag("nonTerminal") class NonTerminalReference extends El {
             public @arg String nonTerminal;
-            public Element build(Context cx) { return cx.get(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);
+                for(Range r : ranges)
+                        set.add(r.first, r.last);
                 return CharRange.set(set);
             }
         }
@@ -593,11 +643,11 @@ public class Demo {
             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), repeatTag())
+                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,                                   repeatTag())
-                    : Sequence.repeatMaximal(e.build(cx),                    zero, many, MetaGrammar.infer(sep.build(cx)), repeatTag());
+                    ? 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 {
@@ -626,9 +676,9 @@ public class Demo {
         public static @tag("!")   El bang(final El e)                        { return new Drop(e); }
 
         public static @tag("^")   El caret(final String s) {
-            return new Constant(CharRange.string(s)) {
+            return new Drop(new Constant(CharRange.string(s)) {
                     public String getOwnerTag() { return s; }
-                };
+                });
         }
 
         public static @tag("~")   El tilde(final El e) {
@@ -639,7 +689,7 @@ public class Demo {
 
         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 @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; }
@@ -651,14 +701,45 @@ public class Demo {
     }
     public static class Context {
         HashMap<String,Union> map = new HashMap<String,Union>();
+        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; }
 }