X-Git-Url: http://git.megacz.com/?p=sbp.git;a=blobdiff_plain;f=src%2Fedu%2Fberkeley%2Fsbp%2FGSS.java;h=db833b9d824af74ca76f5f4a2647de739b930b9a;hp=bde44df40c8af28d1dd3d1d9f45e2fe31adc800f;hb=24219bdf084b45273e869cd19382d1640b396566;hpb=ef61db31ac4d0674b5206803ea04013d6292cf3d

diff --git a/src/edu/berkeley/sbp/GSS.java b/src/edu/berkeley/sbp/GSS.java
index bde44df..db833b9 100644
--- a/src/edu/berkeley/sbp/GSS.java
+++ b/src/edu/berkeley/sbp/GSS.java
@@ -1,8 +1,11 @@
+// Copyright 2006-2007 all rights reserved; see LICENSE file for BSD-style license
+
 package edu.berkeley.sbp;
 import edu.berkeley.sbp.*;
 import edu.berkeley.sbp.util.*;
 import edu.berkeley.sbp.Parser.Table.*;
-import edu.berkeley.sbp.Sequence.Position;
+import edu.berkeley.sbp.Sequence.Pos;
+import edu.berkeley.sbp.Sequence.Pos;
 import java.io.*;
 import java.util.*;
 import java.lang.reflect.*;
@@ -10,431 +13,211 @@ import java.lang.reflect.*;
 /** implements Tomita's Graph Structured Stack */
 class GSS {
 
-    public static int count = 0;
-    
-    public GSS() { }
-
-    private Phase.Node[] reducing_list = null;
-    public int resets = 0;
-    public int waits = 0;
+    Input input;
+    private Parser parser;
+    public GSS(Input input, Parser parser) { this.input = input; this.parser = parser;}
+    public Input getInput() { return input; }
 
-    HashMapBag<Sequence,Phase.Waiting> waiting         = new HashMapBag<Sequence,Phase.Waiting>();
-    HashMapBag<Integer,Sequence>       performed       = new HashMapBag<Integer,Sequence>();
-    HashMapBag<Integer,Sequence>       lastperformed   = new HashMapBag<Integer,Sequence>();
-    HashMapBag<Integer,Sequence>       expected        = new HashMapBag<Integer,Sequence>();
-    
-    /** FIXME */
-    public  Forest.Ref finalResult;
+    /*
+    HashSet<Reduction> finishedReductions = new HashSet<Reduction>();
+    */
+    int numNewNodes = 0;
+    int numOldNodes = 0;
+    int viewPos = 0;
+    int numReductions = 0;
 
     /** corresponds to a positions <i>between tokens</i> the input stream; same as Tomita's U_i's */
-    class Phase<Tok> implements Invokable<State, Forest, Phase<Tok>.Node>, IntegerMappable, GraphViz.ToGraphViz, Iterable<Phase.Node> {
+    class Phase<Tok> implements Invokable<State, StateNode, Forest>, IntegerMappable, GraphViz.ToGraphViz, Iterable<StateNode> {
+
+        // FIXME: right now, these are the performance bottleneck
+        private HashMapBag<Integer,Integer>       performed       = new HashMapBag<Integer,Integer>();
+
+        public Forest.Many finalResult;
+        private PriorityQueue<Reduction> reductionQueue = new PriorityQueue<Reduction>();
 
-        public Iterator<Phase.Node> iterator() { return hash.iterator(); }
-        public void invoke(State st, Forest result, Node n) {
-            good |= next.newNode(n, result, st, false);
+        Parser parser() { return parser; }
+        public void addReduction(Reduction r) {
+            //System.out.println("+ " + r);
+            parser.spin();
+            reductionQueue.add(r);
+        }
+
+        public void invoke(State st, StateNode pred, Forest f) {
+            parser.spin();
+            good |= next.newNode(f, null, pred, st, false);
         }
 
         /** the token immediately after this phase */
         final Tok token;
-
-        private final int pos;
-
-        boolean reducing;
-        private IntPairMap<Phase.Node> hash;  /* ALLOC */
-        private IntPairMap<Forest> singularReductions;  /* ALLOC */
-        private boolean closed;
-        private boolean good;
+        final int pos;
+        public IntPairMap<StateNode> hash = new IntPairMap<StateNode>();  /* ALLOC */
+        private boolean good = false;
         private Phase next = null;
         private Phase prev;
         private Input.Location location;
-        public final Parser parser;
-
+        private Input.Location nextLocation;
+        
         private Forest forest;
 
-        public Phase(Phase prev, Parser parser, Phase previous, Tok token, Input.Location location, Forest forest) throws ParseFailed {
+        public Phase(State startState) throws ParseFailed, IOException {
+            this(null, null);
+            newNode(null, null, null, startState, true);
+        }
+        public Phase(Phase prev, Forest forest) throws ParseFailed, IOException {
+            this.location = input.getLocation();
+            this.token = (Tok)input.next();
+            this.nextLocation = input.getLocation();
             this.prev = prev;
             this.forest = forest;
-            this.parser = parser;
-            this.pos = previous==null ? 0 : previous.pos+1;
-            this.token = token;
-            this.location = location;
-            performed.clear();
-            reset();
-        }
-
-        public void reset() throws ParseFailed {
-            waiting.clear();
-            expected.clear();
-            lastperformed.clear();
-            lastperformed.addAll(performed);
-            performed.clear();
-            hash = new IntPairMap<Phase.Node>();
-            singularReductions = new IntPairMap<Forest>();
-            reset = false;
-            good = false;
-            closed = false;
-            reducing = false;
-            finalResult = null;
+            this.pos = prev==null ? 0 : prev.pos+1;
             if (prev != null) prev.shift(this, forest);
-        }
-
-      
-        public boolean isDone() throws ParseFailed {
-            if (token != null) return false;
-            if (token==null && finalResult==null)
-                throw new ParseFailed(ParseFailed.error(ANSI.red("unexpected end of file\n"), token, hash.values()), getLocation());
-            return true;
-        }
-
-        public Input.Location getLocation() { return location; }
+            numReductions = 0;
+            /*
+            finishedReductions.clear();
+            */
 
-        /** add a new node (merging with existing nodes if possible)
-         *  @param parent             the parent of the new node
-         *  @param result             the SPPF result corresponding to the new node
-         *  @param state              the state that the new node is in
-         *  @param fromEmptyReduction true iff this node is being created as a result of a reduction of length zero (see GRMLR paper)
-         *  @param start              the earliest part of the input contributing to this node (used to make merging decisions)
-         */
-        public boolean newNode(Node parent, Forest pending, State state, boolean fromEmptyReduction) {
-            Node p = hash.get(state, parent==null?null:parent.phase());
-            if (p != null)  return newNode2(p, parent, pending, state, fromEmptyReduction);
-            else            return newNode3(parent, pending, state, fromEmptyReduction);
-        }
-        public void newNode(Node parent, Forest pending, State state, boolean fromEmptyReduction, Position reduction) {
-            int pos = parent==null?0:parent.phase()==null?0:parent.phase().pos;
-            Sequence owner = reduction==null ? null : reduction.owner();
-            if (reduction!=null) {
-                if (owner.hates!=null) {
-                    for (Sequence s : performed.getAll(pos))
-                        if (owner.hates.contains(s))
-                            return;
-                    for (Sequence s : lastperformed.getAll(pos))
-                        if (owner.hates.contains(s)) {
-                            //System.out.println("now expecting ["+pos+"] => " + s);
-                            expected.add(pos, s);
-                            return;
-                        }
-                }
-                if (owner.needs != null)
-                    for(Sequence s : owner.needs)
-                        if (!performed.contains(pos, s)) {
-                            waiting.add(s, new Waiting(parent, pending, state, fromEmptyReduction, reduction));
-                            return;
-                        }
-                if (!performed.contains(pos, owner)) {
-                    performed.add(pos, owner);
-                    if (owner.hated != null)
-                        for(Sequence seq : owner.hated)
-                            if (performed.contains(pos, seq)) {
-                                performed.remove(pos, seq);
-                                reset = true;
-                            }
-                }
-            }
-            if (!owner.lame)
-                newNode(parent, pending, state, fromEmptyReduction);
-            if (reduction != null) {
-                boolean redo = true;
-                while(redo) {
-                    redo = false;
-                    for(Waiting w : waiting.getAll(owner)) {
-                        if (w.parent==parent || (parent!=null&&w.parent!=null&&w.parent.phase()==parent.phase())) {
-                            waiting.remove(owner, w);
-                            w.perform();
-                            redo = true;
-                            break;
-                        }
+            int minPhasePos = Integer.MAX_VALUE;
+            Reduction best = null;
+            //System.out.println("==============================================================================");
+            while(!reductionQueue.isEmpty()) {
+                Reduction r = reductionQueue.poll();
+                //System.out.println("- " + r);
+                if (r.predPhase() != null)
+                    if (r.predPhase().pos > minPhasePos)
+                        throw new Error();
+                r.perform();
+                if (r.predPhase() != null) {
+                    if (r.predPhase().pos < minPhasePos) {
+                        minPhasePos = r.predPhase().pos;
+                        best = r;
+                    } else if (r.predPhase().pos == minPhasePos) {
+                        /*
+                        if (best != null && Parser.mastercache.comparePositions(r.reduction(), best.reduction()) < 0)
+                            throw new Error("\n"+r+"\n"+best+"\n"+
+                                            Parser.mastercache.comparePositions(r.reduction(), best.reduction())+"\n"+r.compareTo(best)+
+                                            "\n"+(r.reduction().ord-best.reduction().ord));
+                        */
+                        best = r;
                     }
                 }
+                /*
+                finishedReductions.add(r);
+                */
+                numReductions++;
             }
+            if (token==null) shift(null, null);
         }
-        private boolean newNode2(Node p, Node parent, Forest pending, State state, boolean fromEmptyReduction) {
-            //if (p.parents().contains(parent)) return true;
-            p.merge(parent, pending);
-            p.parents().add(parent, true);
-            if (p!=parent && !fromEmptyReduction && reducing) p.performReductions(parent);
-            return true;
-        }
-        private boolean newNode3(Node parent, Forest pending, State state, boolean fromEmptyReduction) {
-            do {
-                if (token != null && state.canShift(token)) break;
-                if (state.isAccepting()) break;
-                if (token==null) break;
-                if (!state.canReduce(token)) return false;
-                //if (count > 1) break;
-                //if (r.numPop == 0) break;
-                //r.reduce(pending, parent, null, Phase.this, null);
-                //return;
-            } while(false);
 
-            Node n = new Node(parent, pending, state);  // ALLOC
-            if (reducing) {
-                n.performEmptyReductions();
-                if (!fromEmptyReduction) n.performReductions(parent);
-            }
+        public boolean isDone() throws ParseFailed {
+            if (token != null) return false;
+            if (token==null && finalResult==null)
+                ParseFailed.error("unexpected end of file", this, null,
+                                  getLocation().createRegion(getLocation()));
             return true;
         }
 
-        /** perform all reduction operations */
-        public void reduce() throws ParseFailed {
-            try {
-                reducing = true;
-                if (reducing_list==null || reducing_list.length < hash.size())
-                    reducing_list = new Phase.Node[hash.size() * 4];
-                hash.toArray(reducing_list);
-                int num = hash.size();
-                for(int i=0; i<num; i++) {
-                    Node n = reducing_list[i];
-                    n.performEmptyReductions();
-                    // INVARIANT: we never "see" a node until its parent-set is complete, modulo merges
-                }
-                for(int i=0; i<num; i++) {
-                    Node n = reducing_list[i];
-                    reducing_list[i] = null;
-                    n.performReductions();
-                }
-                if (reset) {
-                    reset = false;
-                    resets++;
-                    throw new Reset();
-                }                
-                for(int i : expected)
-                    for(Sequence s : expected.getAll(i))
-                        if (!performed.contains(i, s)) {
-                            //System.out.println("resetting due to pos="+i+": " + s + " " + System.identityHashCode(s));
-                            resets++;
-                            throw new Reset();
-                        }
-            } catch (Reset r) {
-                reset();
-                reduce();
-            }
-            count = 0;
-        }
-
-        private boolean reset = false;
-        class Reset extends RuntimeException { }
+        public Input.Location getLocation() { return location; }
+        public Input.Location getNextLocation() { return nextLocation; }
+        public boolean        isFrontier() { return hash!=null; }
 
         /** perform all shift operations, adding promoted nodes to <tt>next</tt> */
-        public void shift(Phase next, Forest result) throws ParseFailed {
+        private void shift(Phase next, Forest f) throws ParseFailed {
+            this.next = next;
             // this massively improves GC performance
-            if (prev!=null && parser.helpgc) {
+            if (prev != null) {
+                IntPairMap<StateNode> h = prev.hash;
                 prev.hash = null;
-                prev.singularReductions = null;
-            }
-            this.next = next;
-            closed = true;
-            Forest res = null;
-            boolean ok = false;
-            for(Phase.Node n : hash.values()) {
-                if (token == null && n.state.isAccepting()) {
-                    if (finalResult==null) finalResult = new Forest.Ref();
-                    for(Object f : n.results())
-                        finalResult.merge((Forest)f);
+                prev.performed = null;
+                for(StateNode n : h) n.check();
+            }
+            numOldNodes = hash.size();
+            for(StateNode n : hash.values()) {
+                if (token == null && n.state().isAccepting()) {
+                    if (finalResult==null) finalResult = new Forest.Many();
+                    for(Result r : n)
+                        finalResult.merge(r.getForest());
                 }
                 if (token == null) continue;
-                n.state.invokeShifts(token, this, result, n);
+                n.state().invokeShifts(token, this, n, f);
+            }
+            numNewNodes = next==null ? 0 : next.hash.size();
+            viewPos = this.pos;
+
+            if (!good && token!=null) {
+                String toks = token+"";
+                if (toks.length()==1 && toks.charAt(0) == edu.berkeley.sbp.chr.CharAtom.left) {
+                    ParseFailed.error("unexpected increase in indentation", this,
+                                      token, getRegionFromThisToNext());
+                } else if (toks.length()==1 && toks.charAt(0) == edu.berkeley.sbp.chr.CharAtom.right) {
+                    ParseFailed.error("unexpected decrease in indentation", this,
+                                      token, getRegionFromThisToNext());
+                } else {
+                    ParseFailed.error("unexpected character '"+ANSI.cyan(StringUtil.escapify(token+"",
+                                                                                             "\\\'\r\n"))+"'",
+                                      this, token, getRegionFromThisToNext());
+                }
             }
-
-            if (!good && token!=null)
-                throw new ParseFailed(ParseFailed.error(ANSI.red("unexpected character ")+" \'"+
-                                                        ANSI.purple(StringUtil.escapify(token+"", "\\\'\r\n"))+
-                                                        "\' encountered at "+
-                                                        ANSI.green(getLocation())+"\n", token, hash.values()),
-                                        getLocation());
             if (token==null && finalResult==null)
-                throw new ParseFailed(ParseFailed.error(ANSI.red("unexpected end of file\n"), token, hash.values()),
-                                        getLocation());
+                ParseFailed.error("unexpected end of file", this, null,
+                                  getLocation().createRegion(getLocation()));
+            for(StateNode n : hash) n.check();
         }
 
-
-        class Waiting {
-            Node parent;
-            Forest pending;
-            State state;
-            boolean fromEmptyReduction;
-            Position reduction;
-            public Waiting(Node parent, Forest pending, State state, boolean fromEmptyReduction, Position reduction) {
-                waits++;
-                this.parent = parent;
-                this.pending = pending;
-                this.state = state;
-                this.fromEmptyReduction = fromEmptyReduction;
-                this.reduction = reduction;
-            }
-            public void perform() {
-                //System.out.println("performing: " + reduction.position);
-                newNode(parent, pending, state, fromEmptyReduction, reduction);
-            }
+        Input.Region getRegionFromThisToNext() {
+            return getLocation().createRegion(getNextLocation());
         }
-       
-        // Node /////////////////////////////////////////////////////////////////////////////////
 
-        /** a node in the GSS */
-        final class Node implements Invokable<Position, Node, Node>, IntegerMappable, GraphViz.ToGraphViz {
-            public FastSet<Node> set = new FastSet<Node>();
-
-        public GraphViz.Node toGraphViz(GraphViz gv) {
-            if (gv.hasNode(this)) return gv.createNode(this);
-            GraphViz.Node n = gv.createNode(this);
-            n.label = ""+state.toStringx();
-            n.shape = "rectangle";
-            n.fill = "green";
-            //GraphViz.Node f = pending().toGraphViz(gv);
-            //n.add(f);
-            for(Forest result : results()) n.edge(result, "");
-            for(Node parent : parents()) n.edge(parent, "");
-            ((GraphViz.Group)phase().toGraphViz(gv)).add(n);
-            return n;
+        void newNodeFromReduction(Forest f, Pos reduction, StateNode pred) {
+            int pos = pred.phase().pos;
+            for(int s : reduction.hates())
+                if (performed.contains(pos, s))
+                    return;
+            for(int s : reduction.needs())
+                if (!performed.contains(pos, s))
+                    return;
+            if (reduction.owner_needed_or_hated() && !performed.contains(pos, reduction.provides()))
+                performed.add(pos, reduction.provides());
+            Parser.Table.State state = (Parser.Table.State)pred.state().gotoSetNonTerminals.get(reduction);
+            if (state!=null)
+                newNode(f, reduction, pred, state, reduction.numPops()<=0);
         }
-        public boolean isTransparent() { return false; }
-        public boolean isHidden() { return false; }
-
-
-            //private Forest.Ref holder = new Forest.Ref();
-            private boolean allqueued = false;
-
-            /** what state this node is in */
-            public final Parser.Table<Tok>.State<Tok> state;
-
-            /** which Phase this Node belongs to (node that Node is also a non-static inner class of Phase) */
-            public  Phase phase() { return Phase.this; }
-            //private HashMap<Node,Forest> resultMap = new HashMap<Node,Forest>();
-
-            private HashSet<Forest.Ref> resultMap = new HashSet<Forest.Ref>();
-            public void merge(Node parent, Forest result) {
-                for(Forest.Ref f : results()) {
-                    if (f.parents.contains(parent) && f.parents.size()==1) {
-                        f.merge(result);
-                        return;
-                    }
-                }
-                Forest.Ref f = new Forest.Ref();
-                f.parents.add(parent);
-                f.merge(result);
-                resultMap.add(f);
-                set.add(parent, true);
-                /*
-                Forest.Ref f = (Forest.Ref)resultMap.get(parent);
-                if (f==null) { f = new Forest.Ref(); resultMap.put(parent, f); }
-                f.merge(result);
-                set.add(parent, true);
-                */
-            }
-            public Iterable<Forest.Ref> results() { return resultMap; }
-            //private Forest pending(Node n) {
-                //return !Phase.this.closed ? holder : holder.resolve();
-                /*
-                for(Forest f : resultMap)
-                    if (resultMap.contains(f, n))
-                        return f;
-                return null;
-                */
-            /*
-                return resultMap.get(n);
-            }
-            */
-            public  FastSet<Node> parents() { return set; }
 
-            public void performReductions() {
-                if (allqueued) return;
-                allqueued = true;
-                state.invokeReductions(token, this, this, null);
-            }
-
-            public void performReductions(Node n2) {
-                if (!allqueued) performReductions();
-                else            state.invokeReductions(token, this, this, n2);
-            }
-
-            public void performEmptyReductions() { state.invokeReductions(token, this, null, null); }
-            public final void invoke(Position r, Node n, Node n2) {
-                //if (r.owner().lame) return;
-                if (n==null || n2==null || r.pos==0) {
-                    if (r.pos==0) {
-                        if (n==null) n = this;
-                        else return;
-                    }
-                    if (n==null) return;
-                    Forest[] holder = new Forest[r.pos];
-                    if (r.pos==0) n.finish(r, r.zero(), n.phase(), holder);
-                    else          n.reduce(r, r.pos-1,  n.phase(), holder, null, null);
-                } else {
-                    Forest[] holder = new Forest[r.pos];
-                    if (r.pos<=0) throw new Error("called wrong form of reduce()");
-                    int pos = r.pos-1;
-                    n.reduce(r, pos, n.phase(), holder, n2, null);
-                }
-            }
-
-            /*
-            public void reduce(Position r, int pos, Phase target, Forest[] holder) {
-                reduce(r, pos, target, holder, null); }
-            public void reduce(Position r, int pos, Phase target, Forest[] holder, Node only) {
-                reduce(r, pos, target, holder, only, this.pending());
-            }
-            */
-            public void reduce(Position r, int pos, Phase target, Forest[] holder, Node only, Forest pending) {
-                Forest old = holder[pos];
-                holder[pos] = pending;
-                if (pos==0) {
-
-                    // FIXME: I'm unsure about this -- basically we want to deal with the case where
-                    //        there are two nodes, each of whose Ref points to the same Forest instance.
-                    //        Some node in the next phase has both of these as parents.  This might happen
-                    //        since the same reduction can appear in more than one state.
-
-                    for(Forest result : results())
-                        for(Node child : ((Forest.Ref<?>)result).parents) {
-                            if (only != null && child!=only) continue;
-                            pending = holder[pos] = result;
-                            System.arraycopy(holder, 0, r.holder, 0, holder.length);
-                            for(int i=0; i<r.pos; i++) if (r.holder[i]==null) throw new Error("realbad");
-                            Forest rex = null;
-                            if (r.pos==1)  rex = singularReductions.get(pending, r);
-                            if (rex==null) {
-                                rex = r.rewrite(phase().getLocation());
-                                if (r.pos==1) singularReductions.put(pending, r, rex);
-                            }
-                            child.finish(r, rex, target, holder);
-                        }
-                } else {
-                    for(Forest result : results())
-                        for(Node child : ((Forest.Ref<?>)result).parents) {
-                            if (only!=null && child!=only) continue;
-                            holder[pos] = result;
-                            child.reduce(r, pos-1, target, holder, null, null);
-                        }
-                }
-                holder[pos] = old;
-            }
-
-            public void finish(Position r, Forest result, Phase<Tok> target, Forest[] holder) {
-                Parser.Table<Tok>.State<Tok> state0 = state.gotoSetNonTerminals.get(r.owner());
-                if (result==null) throw new Error();
-                if (state0!=null)
-                    target.newNode(this, result, state0, r.pos<=0, r);
-            }
-
-            private Node(Node parent, Forest pending, State state) {
-                this.state = state;
-                this.merge(parent, pending);
-                Phase start = parent==null ? null : parent.phase();
-                if (parent != null) parents().add(parent, true);
-                if (Phase.this.hash.get(state, start) != null) throw new Error("severe problem!");
-                Phase.this.hash.put(state, start, this);
+        /** add a new node (merging with existing nodes if possible)
+         *  @param parent             the parent of the new node
+         *  @param result             the SPPF result corresponding to the new node
+         *  @param state              the state that the new node is in
+         *  @param fromEmptyReduction true iff this node is being created as a result of a reduction of length zero (see GRMLR paper)
+         *  @param start              the earliest part of the input contributing to this node (used to make merging decisions)
+         */
+        private boolean newNode(Forest f, Pos reduction, StateNode pred, State state, boolean fromEmptyReduction) {
+            StateNode p = pred==null ? null : hash.get(state, pred.phase());
+            if (p != null) {
+                p.addResult(f, reduction, pred);
+                return !state.doomed();
             }
-            public int toInt() { return idx; }
-            private final int idx = node_idx++;
+            do {
+                if (token != null && state.canShift(token)) break;
+                if (state.isAccepting()) break;
+                if (token==null) break;
+                if (!state.canReduce(token)) return false;
+            } while(false);
+            StateNode n = new StateNode(Phase.this, f, reduction, pred, state, fromEmptyReduction);  // ALLOC
+            /** FIXME: this null-result can be used to notice bogus/dead states */
+            for(Object s : state.conjunctStates)
+                newNode(null, null, n, (State)s, fromEmptyReduction);
+            return !n.state().doomed();
         }
-        private int node_idx = 0;
 
         public int toInt() { return pos+1; }
         public int size() { return hash==null ? 0 : hash.size(); }
+        public int pos() { return pos; }
+        public Tok getToken() { return token; }
+        public Iterator<StateNode> iterator() { return hash.iterator(); }
+        public GSS getGSS() { return GSS.this; }
 
         // GraphViz //////////////////////////////////////////////////////////////////////////////
 
-        public GraphViz.Node toGraphViz(GraphViz gv) {
+        public GraphViz.StateNode toGraphViz(GraphViz gv) {
             if (gv.hasNode(this)) return gv.createNode(this);
             GraphViz.Group g = gv.createGroup(this);
             g.label = "Phase " + pos;
@@ -445,5 +228,17 @@ class GSS {
         public boolean isTransparent() { return false; }
         public boolean isHidden() { return false; }
 
+        public void dumpGraphViz(String filename) throws IOException {
+            FileOutputStream fos = new FileOutputStream(filename);
+            PrintWriter p = new PrintWriter(new OutputStreamWriter(fos));
+            GraphViz gv = new GraphViz();
+            for(Object n : this)
+                ((StateNode)n).toGraphViz(gv);
+            gv.dump(p);
+            p.flush();
+            p.close();
+        }
+
     }
+
 }