rename XMREngine as Yengine (still not all done), big mess source formating changes, move state files to proper folder, fix a source file locking on errors, more changes for cross platform including from Mike,... yes yes i know a messy commit

1 files changed, 3105 insertions, 0 deletions

diff --git a/OpenSim/Region/ScriptEngine/YEngine/MMRScriptCollector.cs b/OpenSim/Region/ScriptEngine/YEngine/MMRScriptCollector.cs
new file mode 100644
index 0000000..4a57823
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/YEngine/MMRScriptCollector.cs
@@ -0,0 +1,3105 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using OpenSim.Region.ScriptEngine.Shared.ScriptBase;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Text;
+
+
+/**
+ * @brief Wrapper class for ScriptMyILGen to do simple optimizations.
+ *        The main one is to figure out which locals are active at the labels
+ *        so the stack capture/restore code doesn't have to do everything.
+ *        Second is it removes unnecessary back-to-back stloc/ldloc's.
+ */
+
+namespace OpenSim.Region.ScriptEngine.Yengine
+{
+    /**
+     * @brief This is a list that keeps track of types pushed on the evaluation stack.
+     */
+    public class StackDepth: List<Type>
+    {
+        public List<bool> isBoxeds = new List<bool>();
+
+        /**
+         * @brief Clear both stacks.
+         */
+        public new void Clear()
+        {
+            base.Clear();
+            isBoxeds.Clear();
+        }
+
+        /**
+         * @brief Pop call parameters and validate the types.
+         */
+        public void Pop(ParameterInfo[] pis)
+        {
+            int n = pis.Length;
+            int c = this.Count;
+            if(n > c)
+                throw new Exception("stack going negative");
+            for(int i = n; --i >= 0;)
+            {
+                --c;
+                ExpectedVsOnStack(pis[i].ParameterType, this[c], isBoxeds[c]);
+            }
+            Pop(n);
+        }
+
+        /**
+         * @brief Pop values and validate the types.
+         */
+        public void Pop(Type[] ts)
+        {
+            int n = ts.Length;
+            int c = this.Count;
+            if(n > c)
+                throw new Exception("stack going negative");
+            for(int i = ts.Length; --i >= 0;)
+            {
+                --c;
+                ExpectedVsOnStack(ts[i], this[c], isBoxeds[c]);
+            }
+            Pop(n);
+        }
+
+        /**
+         * @brief Pop a single value and validate the type.
+         */
+        public void Pop(Type t)
+        {
+            int c = this.Count;
+            if(c < 1)
+                throw new Exception("stack going negative");
+            ExpectedVsOnStack(t, this[c - 1], isBoxeds[c - 1]);
+            Pop(1);
+        }
+
+        /**
+         * @brief Pop a single value and validate that it is a numeric type.
+         */
+        public Type PopNumVal()
+        {
+            int c = this.Count;
+            if(c < 1)
+                throw new Exception("stack going negative");
+            Type st = this[--c];
+            if(st == null)
+            {
+                throw new Exception("stack has null, expecting a numeric");
+            }
+            if(isBoxeds[c])
+            {
+                throw new Exception("stack is boxed " + st.Name + ", expecting a numeric");
+            }
+            if((st != typeof(bool)) && (st != typeof(char)) && (st != typeof(int)) &&
+                (st != typeof(long)) && (st != typeof(float)) && (st != typeof(double)))
+            {
+                throw new Exception("stack has " + st.Name + ", expecting a numeric");
+            }
+            return Pop(1);
+        }
+
+        /**
+         * @brief Pop a single value and validate that it is a reference type
+         */
+        public Type PopRef()
+        {
+            int c = this.Count;
+            if(c < 1)
+                throw new Exception("stack going negative");
+            Type st = this[--c];
+            if((st != null) && !isBoxeds[c] && st.IsValueType)
+            {
+                throw new Exception("stack has " + st.Name + ", expecting a ref type");
+            }
+            return Pop(1);
+        }
+
+        /**
+         * @brief Pop a single value and validate that it is a value type
+         */
+        public Type PopValue()
+        {
+            int c = this.Count;
+            if(c < 1)
+                throw new Exception("stack going negative");
+            Type st = this[--c];
+            if(st == null)
+            {
+                throw new Exception("stack has null, expecting a value type");
+            }
+            if(!st.IsValueType)
+            {
+                throw new Exception("stack has " + st.Name + ", expecting a value type");
+            }
+            if(isBoxeds[c])
+            {
+                throw new Exception("stack has boxed " + st.Name + ", expecting an unboxed value type");
+            }
+            return Pop(1);
+        }
+
+        // ex = what is expected to be on stack
+        // st = what is actually on stack (null for ldnull)
+        // stBoxed = stack value is boxed
+        public static void ExpectedVsOnStack(Type ex, Type st, bool stBoxed)
+        {
+            // ldnull pushed on stack can go into any pointer type
+            if(st == null)
+            {
+                if(ex.IsByRef || ex.IsPointer || ex.IsClass || ex.IsInterface)
+                    return;
+                throw new Exception("stack has null, expect " + ex.Name);
+            }
+
+            // simple case of expecting an object
+            // ...so the stack can have object,string, etc
+            // but we cant allow int = boxed int here
+            if(ex.IsAssignableFrom(st) && !stBoxed)
+                return;
+
+            // case of expecting an enum on the stack
+            // but all the CIL code knows about are ints etc
+            // so convert the Enum type to integer or whatever
+            // and that should be assignable from what's on stack
+            if(ex.IsEnum && typeof(int).IsAssignableFrom(st))
+                return;
+
+            // bool, char, int are interchangeable on the stack
+            if((ex == typeof(bool) || ex == typeof(char) || ex == typeof(int)) &&
+                (st == typeof(bool) || st == typeof(char) || st == typeof(int)))
+                return;
+
+            // float and double are interchangeable on the stack
+            if((ex == typeof(float) || ex == typeof(double)) &&
+                (st == typeof(float) || st == typeof(double)))
+                return;
+
+            // object can accept any boxed type
+            if((ex == typeof(object)) && stBoxed)
+                return;
+
+            // otherwise, it is disallowed
+            throw new Exception("stack has " + StackTypeString(st, stBoxed) + ", expect " + ex.Name);
+        }
+
+        /**
+         * @brief Pop values without any validation.
+         */
+        public Type Pop(int n)
+        {
+            if(this.Count != isBoxeds.Count)
+                throw new Exception("isBoxeds count bad");
+            Type lastPopped = null;
+            int c = this.Count;
+            if(n > c)
+                throw new Exception("stack going negative");
+            if(n > 0)
+            {
+                lastPopped = this[c - n];
+                this.RemoveRange(c - n, n);
+                isBoxeds.RemoveRange(c - n, n);
+            }
+            if(this.Count != isBoxeds.Count)
+                throw new Exception("isBoxeds count bad");
+            return lastPopped;
+        }
+
+        /**
+         * @brief Peek at the n'th stack value.
+         *        n = 0 : top of stack
+         *            1 : next to top
+         *                ...
+         */
+        public Type Peek(int n)
+        {
+            int c = this.Count;
+            if(n > c - 1)
+                throw new Exception("stack going negative");
+            if(this.Count != isBoxeds.Count)
+                throw new Exception("isBoxeds count bad");
+            return this[c - n - 1];
+        }
+        public bool PeekBoxed(int n)
+        {
+            int c = isBoxeds.Count;
+            if(n > c - 1)
+                throw new Exception("stack going negative");
+            if(this.Count != isBoxeds.Count)
+                throw new Exception("isBoxeds count bad");
+            return isBoxeds[c - n - 1];
+        }
+
+        /**
+         * @brief Push a single value of the given type.
+         */
+        public void Push(Type t)
+        {
+            Push(t, false);
+        }
+        public void Push(Type t, bool isBoxed)
+        {
+            if(this.Count != isBoxeds.Count)
+                throw new Exception("isBoxeds count bad");
+            this.Add(t);
+            isBoxeds.Add(isBoxed);
+        }
+
+        /**
+         * @brief See if the types at a given label exactly match those on the stack.
+         *        We should have the stack types be the same no matter how we branched 
+         *        or fell through to a particular label.
+         */
+        public void Matches(ScriptMyLabel label)
+        {
+            Type[] ts = label.stackDepth;
+            bool[] tsBoxeds = label.stackBoxeds;
+            int i;
+
+            if(this.Count != isBoxeds.Count)
+                throw new Exception("isBoxeds count bad");
+
+            if(ts == null)
+            {
+                label.stackDepth = this.ToArray();
+                label.stackBoxeds = isBoxeds.ToArray();
+            }
+            else if(ts.Length != this.Count)
+            {
+                throw new Exception("stack depth mismatch");
+            }
+            else
+            {
+                for(i = this.Count; --i >= 0;)
+                {
+                    if(tsBoxeds[i] != this.isBoxeds[i])
+                        goto mismatch;
+                    if(ts[i] == this[i])
+                        continue;
+                    if((ts[i] == typeof(bool) || ts[i] == typeof(char) || ts[i] == typeof(int)) &&
+                        (this[i] == typeof(bool) || this[i] == typeof(char) || this[i] == typeof(int)))
+                        continue;
+                    if((ts[i] == typeof(double) || ts[i] == typeof(float)) &&
+                        (this[i] == typeof(double) || this[i] == typeof(float)))
+                        continue;
+                    goto mismatch;
+                }
+            }
+            return;
+            mismatch:
+            throw new Exception("stack type mismatch: " + StackTypeString(ts[i], tsBoxeds[i]) + " vs " + StackTypeString(this[i], this.isBoxeds[i]));
+        }
+
+        private static string StackTypeString(Type ts, bool isBoxed)
+        {
+            if(!isBoxed)
+                return ts.Name;
+            return "[" + ts.Name + "]";
+        }
+    }
+
+    /**
+     * @brief One of these per opcode and label in the function plus other misc markers.
+     *        They form the CIL instruction stream of the function.
+     */
+    public abstract class GraphNode
+    {
+        private static readonly bool DEBUG = false;
+
+        public const int OPINDENT = 4;
+        public const int OPDEBLEN = 12;
+
+        public ScriptCollector coll;
+        public GraphNodeBeginExceptionBlock tryBlock;  // start of enclosing try block
+                                                       // valid in the try section
+                                                       // null in the catch/finally sections
+                                                       // null outside of try block
+                                                       // for the try node itself, links to outer try block
+        public GraphNodeBeginExceptionBlock excBlock;  // start of enclosing try block
+                                                       // valid in the try/catch/finally sections
+                                                       // null outside of try/catch/finally block
+                                                       // for the try node itself, links to outer try block
+
+        /*
+         * List of nodes in order as originally given.
+         */
+        public GraphNode nextLin, prevLin;
+        public int linSeqNo;
+
+        /**
+         * @brief Save pointer to collector.
+         */
+        public GraphNode(ScriptCollector coll)
+        {
+            this.coll = coll;
+        }
+
+        /**
+         * @brief Chain graph node to end of linear list.
+         */
+        public virtual void ChainLin()
+        {
+            coll.lastLin.nextLin = this;
+            this.prevLin = coll.lastLin;
+            coll.lastLin = this;
+            this.tryBlock = coll.curTryBlock;
+            this.excBlock = coll.curExcBlock;
+
+            if(DEBUG)
+            {
+                StringBuilder sb = new StringBuilder("ChainLin*:");
+                sb.Append(coll.stackDepth.Count.ToString("D2"));
+                sb.Append(' ');
+                this.DebString(sb);
+                Console.WriteLine(sb.ToString());
+            }
+        }
+
+        /**
+         * @brief Append full info to debugging string for printing out the instruction.
+         */
+        public void DebStringExt(StringBuilder sb)
+        {
+            int x = sb.Length;
+            sb.Append(this.linSeqNo.ToString().PadLeft(5));
+            sb.Append(": ");
+            this.DebString(sb);
+
+            if(this.ReadsLocal() != null)
+                ScriptCollector.PadToLength(sb, x + 60, " [read]");
+            if(this.WritesLocal() != null)
+                ScriptCollector.PadToLength(sb, x + 68, " [write]");
+            ScriptCollector.PadToLength(sb, x + 72, " ->");
+            bool first = true;
+            foreach(GraphNode nn in this.NextNodes)
+            {
+                if(first)
+                {
+                    sb.Append(nn.linSeqNo.ToString().PadLeft(5));
+                    first = false;
+                }
+                else
+                {
+                    sb.Append(',');
+                    sb.Append(nn.linSeqNo);
+                }
+            }
+        }
+
+        /**
+         * @brief See if it's possible for it to fall through to the next inline (nextLin) instruction.
+         */
+        public virtual bool CanFallThrough()
+        {
+            return true;
+        }
+
+        /**
+         * @brief Append to debugging string for printing out the instruction.
+         */
+        public abstract void DebString(StringBuilder sb);
+        public override string ToString()
+        {
+            StringBuilder sb = new StringBuilder();
+            this.DebString(sb);
+            return sb.ToString();
+        }
+
+        /**
+         * @brief See if this instruction reads a local variable.
+         */
+        public virtual ScriptMyLocal ReadsLocal()
+        {
+            return null;
+        }
+
+        /**
+         * @brief See if this instruction writes a local variable.
+         */
+        public virtual ScriptMyLocal WritesLocal()
+        {
+            return null;
+        }
+
+        /**
+         * @brief Write this instruction out to the wrapped object file.
+         */
+        public abstract void WriteOutOne(ScriptMyILGen ilGen);
+
+        /**
+         * @brief Iterate through all the possible next nodes, including the next inline node, if any.
+         *        The next inline code is excluded if the instruction never falls through, eg, return, unconditional branch.
+         *        It includes a possible conditional branch to the beginning of the corresponding catch/finally of every 
+         *        instruction in a try section.
+         */
+        private System.Collections.Generic.IEnumerable<GraphNode> nextNodes, nextNodesCatchFinally;
+        public System.Collections.Generic.IEnumerable<GraphNode> NextNodes
+        {
+            get
+            {
+                if(nextNodes == null)
+                {
+                    nextNodes = GetNNEnumerable();
+                    nextNodesCatchFinally = new NNEnumerableCatchFinally(this);
+                }
+                return nextNodesCatchFinally;
+            }
+        }
+
+        /**
+         * @brief This acts as a wrapper around all the other NNEnumerable's below.
+         *        It assumes every instruction in a try { } can throw an exception so it 
+         *        says that every instruction in a try { } can conditionally branch to 
+         *        the beginning of the corresponding catch { } or finally { }.
+         */
+        private class NNEnumerableCatchFinally: System.Collections.Generic.IEnumerable<GraphNode>
+        {
+            private GraphNode gn;
+            public NNEnumerableCatchFinally(GraphNode gn)
+            {
+                this.gn = gn;
+            }
+            System.Collections.Generic.IEnumerator<GraphNode> System.Collections.Generic.IEnumerable<GraphNode>.GetEnumerator()
+            {
+                return new NNEnumeratorCatchFinally(gn);
+            }
+            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+            {
+                return new NNEnumeratorCatchFinally(gn);
+            }
+        }
+        private class NNEnumeratorCatchFinally: NNEnumeratorBase
+        {
+            private GraphNode gn;
+            private int index = 0;
+            private System.Collections.Generic.IEnumerator<GraphNode> realEnumerator;
+            public NNEnumeratorCatchFinally(GraphNode gn)
+            {
+                this.gn = gn;
+                this.realEnumerator = gn.nextNodes.GetEnumerator();
+            }
+            public override bool MoveNext()
+            {
+                /*
+                 * First off, return any targets the instruction can come up with.
+                 */
+                if(realEnumerator.MoveNext())
+                {
+                    nn = realEnumerator.Current;
+                    return true;
+                }
+
+                /*
+                 * Then if this instruction is in a try section, say this instruction 
+                 * can potentially branch to the beginning of the corresponding 
+                 * catch/finally.
+                 */
+                if((index == 0) && (gn.tryBlock != null))
+                {
+                    index++;
+                    nn = gn.tryBlock.catchFinallyBlock;
+                    return true;
+                }
+
+                /*
+                 * That's all we can do.
+                 */
+                nn = null;
+                return false;
+            }
+            public override void Reset()
+            {
+                realEnumerator.Reset();
+                index = 0;
+                nn = null;
+            }
+        }
+
+        /**
+         * @brief This default iterator always returns the next inline node as the one-and-only next node.
+         *        Other instructions need to override it if they can possibly do other than that.
+         */
+
+        /**
+         * @brief GetNNEnumerable() gets the nextnode enumerable part of a GraphNode,
+         *        which in turn gives the list of nodes that can possibly be next in 
+         *        a flow-control sense.  It simply instantiates the NNEnumerator sub-
+         *        class which does the actual enumeration.
+         */
+        protected virtual System.Collections.Generic.IEnumerable<GraphNode> GetNNEnumerable()
+        {
+            return new NNEnumerable(this, typeof(NNEnumerator));
+        }
+
+        private class NNEnumerator: NNEnumeratorBase
+        {
+            private GraphNode gn;
+            private int index;
+            public NNEnumerator(GraphNode gn)
+            {
+                this.gn = gn;
+            }
+            public override bool MoveNext()
+            {
+                switch(index)
+                {
+                    case 0:
+                        {
+                            index++;
+                            nn = gn.nextLin;
+                            return nn != null;
+                        }
+                    case 1:
+                        {
+                            nn = null;
+                            return false;
+                        }
+                }
+                throw new Exception();
+            }
+            public override void Reset()
+            {
+                index = 0;
+                nn = null;
+            }
+        }
+    }
+
+    /**
+     * @brief Things that derive from this are the beginning of a block.
+     *        A block of code is that which begins with a label or is the beginning of all code
+     *        and it contains no labels, ie, it can't be jumped into other than at its beginning.
+     */
+    public abstract class GraphNodeBlock: GraphNode
+    {
+        public List<ScriptMyLocal> localsWrittenBeforeRead = new List<ScriptMyLocal>();
+        public List<ScriptMyLocal> localsReadBeforeWritten = new List<ScriptMyLocal>();
+        public int hasBeenResolved;
+        public GraphNodeBlock(ScriptCollector coll) : base(coll) { }
+    }
+
+    /**
+     * @brief This placeholder is at the beginning of the code so the first few instructions 
+     *        belong to some block.
+     */
+    public class GraphNodeBegin: GraphNodeBlock
+    {
+        public GraphNodeBegin(ScriptCollector coll) : base(coll) { }
+        public override void DebString(StringBuilder sb)
+        {
+            sb.Append("begin");
+        }
+        public override void WriteOutOne(ScriptMyILGen ilGen)
+        {
+        }
+    }
+
+    /**
+     * @brief Beginning of try block.
+     */
+    public class GraphNodeBeginExceptionBlock: GraphNodeBlock
+    {
+        public GraphNodeBeginExceptionBlock outerTryBlock;      // next outer try opcode or null
+        public GraphNodeCatchFinallyBlock catchFinallyBlock;  // start of associated catch or finally
+        public GraphNodeEndExceptionBlock endExcBlock;        // end of associated catch or finally
+        public int excBlkSeqNo;                                 // debugging
+
+        public GraphNodeBeginExceptionBlock(ScriptCollector coll) : base(coll)
+        {
+        }
+
+        public override void ChainLin()
+        {
+            base.ChainLin();
+
+            // we should always start try blocks with nothing on stack
+            // ...as CLI wipes stack for various conditions
+            if(coll.stackDepth.Count != 0)
+            {
+                throw new Exception("stack depth " + coll.stackDepth.Count);
+            }
+        }
+
+        public override void DebString(StringBuilder sb)
+        {
+            sb.Append("  beginexceptionblock_");
+            sb.Append(excBlkSeqNo);
+        }
+
+        public override void WriteOutOne(ScriptMyILGen ilGen)
+        {
+            ilGen.BeginExceptionBlock();
+        }
+    }
+
+    /**
+     * @brief Beginning of catch or finally block.
+     */
+    public abstract class GraphNodeCatchFinallyBlock: GraphNodeBlock
+    {
+        public GraphNodeCatchFinallyBlock(ScriptCollector coll) : base(coll)
+        {
+        }
+
+        public override void ChainLin()
+        {
+            base.ChainLin();
+
+            // we should always start catch/finally blocks with nothing on stack
+            // ...as CLI wipes stack for various conditions
+            if(coll.stackDepth.Count != 0)
+            {
+                throw new Exception("stack depth " + coll.stackDepth.Count);
+            }
+        }
+    }
+
+    /**
+     * @brief Beginning of catch block.
+     */
+    public class GraphNodeBeginCatchBlock: GraphNodeCatchFinallyBlock
+    {
+        public Type excType;
+
+        public GraphNodeBeginCatchBlock(ScriptCollector coll, Type excType) : base(coll)
+        {
+            this.excType = excType;
+        }
+
+        public override void ChainLin()
+        {
+            base.ChainLin();
+
+            // catch block always enters with one value on stack
+            if(coll.stackDepth.Count != 0)
+            {
+                throw new Exception("stack depth " + coll.stackDepth.Count);
+            }
+            coll.stackDepth.Push(excType);
+        }
+
+        public override void DebString(StringBuilder sb)
+        {
+            sb.Append("  begincatchblock_");
+            sb.Append(excBlock.excBlkSeqNo);
+        }
+
+        public override void WriteOutOne(ScriptMyILGen ilGen)
+        {
+            ilGen.BeginCatchBlock(excType);
+        }
+
+        /**
+         * @brief The beginning of every catch { } conditinally branches to the beginning 
+         *        of all outer catch { }s up to and including the next outer finally { }.
+         */
+        protected override System.Collections.Generic.IEnumerable<GraphNode> GetNNEnumerable()
+        {
+            return new NNEnumerable(this, typeof(NNEnumerator));
+        }
+
+        private class NNEnumerator: NNEnumeratorBase
+        {
+            private GraphNodeBeginCatchBlock gn;
+            private int index;
+            public NNEnumerator(GraphNodeBeginCatchBlock gn)
+            {
+                this.gn = gn;
+            }
+            public override bool MoveNext()
+            {
+                while(true)
+                {
+                    switch(index)
+                    {
+                        case 0:
+                            {
+                                // start with the fallthru
+                                nn = gn.nextLin;
+                                index++;
+                                return true;
+                            }
+
+                        case 1:
+                            {
+                                // get the first outer catch { } or finally { }
+                                // pretend we last returned beginning of this catch { }
+                                // then loop back to get next outer catch { } or finally { }
+                                nn = gn;
+                                break;
+                            }
+
+                        case 2:
+                            {
+                                // nn points to a catch { } previously returned
+                                // get the corresponding try { }
+                                GraphNodeBeginExceptionBlock nntry = nn.excBlock;
+
+                                // step out to next outer try { }
+                                nntry = nntry.excBlock;
+                                if(nntry == null)
+                                    break;
+
+                                // return corresponding catch { } or finally { }
+                                nn = nntry.catchFinallyBlock;
+
+                                // if it's a finally { } we don't do anything after that
+                                if(nn is GraphNodeBeginFinallyBlock)
+                                    index++;
+                                return true;
+                            }
+
+                        case 3:
+                            {
+                                // we've returned the fallthru, catches and one finally
+                                // so there's nothing more to say
+                                nn = null;
+                                return false;
+                            }
+
+                        default:
+                            throw new Exception();
+                    }
+                    index++;
+                }
+            }
+            public override void Reset()
+            {
+                index = 0;
+                nn = null;
+            }
+        }
+    }
+
+    /**
+     * @brief Beginning of finally block.
+     */
+    public class GraphNodeBeginFinallyBlock: GraphNodeCatchFinallyBlock
+    {
+
+        // leaveTargets has a list of all the targets of any contained 
+        // leave instructions, ie, where an endfinally can possibly jump.
+        // But only those targets within the next outer finally { }, we 
+        // don't contain any targets outside of that, those targets are 
+        // stored in the actual finally that will jump to the target.
+        // The endfinally enumerator assumes that it is always possible 
+        // for it to jump to the next outer finally (as would happen for
+        // an uncaught exception), so no need to do anything special.
+        public List<GraphNodeBlock> leaveTargets = new List<GraphNodeBlock>();
+
+        public GraphNodeBeginFinallyBlock(ScriptCollector coll) : base(coll)
+        {
+        }
+
+        public override void DebString(StringBuilder sb)
+        {
+            sb.Append("  beginfinallyblock_");
+            sb.Append(excBlock.excBlkSeqNo);
+        }
+
+        public override void WriteOutOne(ScriptMyILGen ilGen)
+        {
+            ilGen.BeginFinallyBlock();
+        }
+    }
+
+    /**
+     * @brief End of try/catch/finally block.
+     */
+    public class GraphNodeEndExceptionBlock: GraphNode
+    {
+        public GraphNodeEndExceptionBlock(ScriptCollector coll) : base(coll)
+        {
+        }
+
+        public override void ChainLin()
+        {
+            base.ChainLin();
+
+            // we should always end exception blocks with nothing on stack
+            // ...as CLI wipes stack for various conditions
+            if(coll.stackDepth.Count != 0)
+            {
+                throw new Exception("stack depth " + coll.stackDepth.Count);
+            }
+        }
+
+        public override void DebString(StringBuilder sb)
+        {
+            sb.Append("  endexceptionblock_");
+            sb.Append(excBlock.excBlkSeqNo);
+        }
+
+        public override void WriteOutOne(ScriptMyILGen ilGen)
+        {
+            ilGen.EndExceptionBlock();
+        }
+    }
+
+    /**
+     * @brief Actual instruction emits...
+     */
+    public abstract class GraphNodeEmit: GraphNode
+    {
+        public OpCode opcode;
+        public Token errorAt;
+
+        public GraphNodeEmit(ScriptCollector coll, Token errorAt, OpCode opcode) : base(coll)
+        {
+            this.opcode = opcode;
+            this.errorAt = errorAt;
+        }
+
+        public override void ChainLin()
+        {
+            base.ChainLin();
+
+            // compute resultant stack depth
+            int stack = coll.stackDepth.Count;
+
+            if((stack != 0) && ((opcode == OpCodes.Endfinally) || (opcode == OpCodes.Leave) || (opcode == OpCodes.Rethrow)))
+            {
+                throw new Exception(opcode + " stack depth " + stack);
+            }
+            if((stack != 1) && (opcode == OpCodes.Throw))
+            {
+                throw new Exception(opcode + " stack depth " + stack);
+            }
+        }
+
+        /**
+         * @brief See if it's possible for it to fall through to the next inline (nextLin) instruction.
+         */
+        public override bool CanFallThrough()
+        {
+            switch(opcode.FlowControl)
+            {
+                case FlowControl.Branch:
+                    return false;  // unconditional branch
+                case FlowControl.Break:
+                    return true;   // break
+                case FlowControl.Call:
+                    return true;   // call
+                case FlowControl.Cond_Branch:
+                    return true;   // conditional branch
+                case FlowControl.Next:
+                    return true;   // falls through to next instruction
+                case FlowControl.Return:
+                    return false;  // return
+                case FlowControl.Throw:
+                    return false;  // throw
+                default:
+                    {
+                        string op = opcode.ToString();
+                        if(op == "volatile.")
+                            return true;
+                        throw new Exception("unknown flow control " + opcode.FlowControl + " for " + op);
+                    }
+            }
+        }
+
+        // if followed by OpCodes.Pop, it can be discarded
+        public bool isPoppable
+        {
+            get
+            {
+                return
+                    ((opcode.StackBehaviourPop == StackBehaviour.Pop0) &&    // ldarg,ldloc,ldsfld
+                     (opcode.StackBehaviourPush == StackBehaviour.Push1)) ||
+                    ((opcode.StackBehaviourPop == StackBehaviour.Pop0) &&    // ldarga,ldloca,ldc,ldsflda,...
+                     (opcode.StackBehaviourPush == StackBehaviour.Pushi)) ||
+                    (opcode == OpCodes.Ldnull) ||
+                    (opcode == OpCodes.Ldc_R4) ||
+                    (opcode == OpCodes.Ldc_R8) ||
+                    (opcode == OpCodes.Ldstr) ||
+                    (opcode == OpCodes.Ldc_I8) ||
+                    (opcode == OpCodes.Dup);
+            }
+        }
+
+        public override void DebString(StringBuilder sb)
+        {
+            sb.Append("".PadRight(OPINDENT));
+            sb.Append(opcode.ToString().PadRight(OPDEBLEN));
+        }
+
+        /**
+         * @brief If instruction is terminating, we say there is nothing following (eg, return).
+         *        Otherwise, say the one-and-only next instruction is the next instruction inline.
+         */
+        protected override System.Collections.Generic.IEnumerable<GraphNode> GetNNEnumerable()
+        {
+            return new NNEnumerable(this, typeof(NNEnumerator));
+        }
+
+        private class NNEnumerator: NNEnumeratorBase
+        {
+            private GraphNodeEmit gn;
+            private int index;
+            public NNEnumerator(GraphNodeEmit gn)
+            {
+                this.gn = gn;
+            }
+            public override bool MoveNext()
+            {
+                switch(index)
+                {
+                    case 0:
+                        {
+                            if(gn.CanFallThrough())
+                            {
+                                index++;
+                                nn = gn.nextLin;
+                                return nn != null;
+                            }
+                            return false;
+                        }
+                    case 1:
+                        {
+                            nn = null;
+                            return false;
+                        }
+                }
+                throw new Exception();
+            }
+            public override void Reset()
+            {
+                index = 0;
+                nn = null;
+            }
+        }
+    }
+
+    public class GraphNodeEmitNull: GraphNodeEmit
+    {
+        public GraphNodeEmitNull(ScriptCollector coll, Token errorAt, OpCode opcode) : base(coll, errorAt, opcode)
+        {
+        }
+
+        public override void ChainLin()
+        {
+            base.ChainLin();
+
+            switch(opcode.ToString())
+            {
+                case "nop":
+                    break;
+                case "break":
+                    break;
+                case "volatile.":
+                    break;
+                case "ldarg.0":
+                    coll.stackDepth.Push(coll.wrapped.argTypes[0]);
+                    break;
+                case "ldarg.1":
+                    coll.stackDepth.Push(coll.wrapped.argTypes[1]);
+                    break;
+                case "ldarg.2":
+                    coll.stackDepth.Push(coll.wrapped.argTypes[2]);
+                    break;
+                case "ldarg.3":
+                    coll.stackDepth.Push(coll.wrapped.argTypes[3]);
+                    break;
+                case "ldnull":
+                    coll.stackDepth.Push(null);
+                    break;
+                case "ldc.i4.m1":
+                case "ldc.i4.0":
+                case "ldc.i4.1":
+                case "ldc.i4.2":
+                case "ldc.i4.3":
+                case "ldc.i4.4":
+                case "ldc.i4.5":
+                case "ldc.i4.6":
+                case "ldc.i4.7":
+                case "ldc.i4.8":
+                    {
+                        coll.stackDepth.Push(typeof(int));
+                        break;
+                    }
+                case "dup":
+                    {
+                        Type t = coll.stackDepth.Peek(0);
+                        bool b = coll.stackDepth.PeekBoxed(0);
+                        coll.stackDepth.Push(t, b);
+                        break;
+                    }
+                case "pop":
+                    {
+                        coll.stackDepth.Pop(1);
+                        break;
+                    }
+                case "ret":
+                    {
+                        int sd = (coll.wrapped.retType != typeof(void)) ? 1 : 0;
+                        if(coll.stackDepth.Count != sd)
+                            throw new Exception("bad stack depth");
+                        if(sd > 0)
+                        {
+                            coll.stackDepth.Pop(coll.wrapped.retType);
+                        }
+                        break;
+                    }
+                case "add":
+                case "sub":
+                case "mul":
+                case "div":
+                case "div.un":
+                case "rem":
+                case "rem.un":
+                case "and":
+                case "or":
+                case "xor":
+                case "shl":
+                case "shr":
+                case "shr.un":
+                case "add.ovf":
+                case "add.ovf.un":
+                case "mul.ovf":
+                case "mul.ovf.un":
+                case "sub.ovf":
+                case "sub.ovf.un":
+                    {
+                        coll.stackDepth.PopNumVal();
+                        Type t = coll.stackDepth.PopNumVal();
+                        coll.stackDepth.Push(t);
+                        break;
+                    }
+                case "neg":
+                case "not":
+                    {
+                        Type t = coll.stackDepth.PopNumVal();
+                        coll.stackDepth.Push(t);
+                        break;
+                    }
+                case "conv.i1":
+                case "conv.i2":
+                case "conv.i4":
+                case "conv.i8":
+                case "conv.r4":
+                case "conv.r8":
+                case "conv.u4":
+                case "conv.u8":
+                case "conv.r.un":
+                case "conv.ovf.i1.un":
+                case "conv.ovf.i2.un":
+                case "conv.ovf.i4.un":
+                case "conv.ovf.i8.un":
+                case "conv.ovf.u1.un":
+                case "conv.ovf.u2.un":
+                case "conv.ovf.u4.un":
+                case "conv.ovf.u8.un":
+                case "conv.ovf.i.un":
+                case "conv.ovf.u.un":
+                case "conv.ovf.i1":
+                case "conv.ovf.u1":
+                case "conv.ovf.i2":
+                case "conv.ovf.u2":
+                case "conv.ovf.i4":
+                case "conv.ovf.u4":
+                case "conv.ovf.i8":
+                case "conv.ovf.u8":
+                case "conv.u2":
+                case "conv.u1":
+                case "conv.i":
+                case "conv.ovf.i":
+                case "conv.ovf.u":
+                case "conv.u":
+                    {
+                        coll.stackDepth.PopNumVal();
+                        coll.stackDepth.Push(ConvToType(opcode));
+                        break;
+                    }
+                case "throw":
+                    {
+                        if(coll.stackDepth.Count != 1)
+                            throw new Exception("bad stack depth " + coll.stackDepth.Count);
+                        coll.stackDepth.PopRef();
+                        break;
+                    }
+                case "ldlen":
+                    {
+                        coll.stackDepth.Pop(typeof(string));
+                        coll.stackDepth.Push(typeof(int));
+                        break;
+                    }
+                case "ldelem.i1":
+                case "ldelem.u1":
+                case "ldelem.i2":
+                case "ldelem.u2":
+                case "ldelem.i4":
+                case "ldelem.u4":
+                case "ldelem.i8":
+                case "ldelem.i":
+                case "ldelem.r4":
+                case "ldelem.r8":
+                case "ldelem.ref":
+                    {
+                        Type t = coll.stackDepth.Peek(1).GetElementType();
+                        coll.stackDepth.Pop(typeof(int));
+                        coll.stackDepth.Pop(t.MakeArrayType());
+                        coll.stackDepth.Push(t);
+                        break;
+                    }
+                case "stelem.i":
+                case "stelem.i1":
+                case "stelem.i2":
+                case "stelem.i4":
+                case "stelem.i8":
+                case "stelem.r4":
+                case "stelem.r8":
+                case "stelem.ref":
+                    {
+                        Type t = coll.stackDepth.Peek(2).GetElementType();
+                        coll.stackDepth.Pop(t);
+                        coll.stackDepth.Pop(typeof(int));
+                        coll.stackDepth.Pop(t.MakeArrayType());
+                        break;
+                    }
+                case "endfinally":
+                case "rethrow":
+                    {
+                        if(coll.stackDepth.Count != 0)
+                            throw new Exception("bad stack depth " + coll.stackDepth.Count);
+                        break;
+                    }
+                case "ceq":
+                    {
+                        Type t = coll.stackDepth.Pop(1);
+                        if(t == null)
+                        {
+                            coll.stackDepth.PopRef();
+                        }
+                        else
+                        {
+                            coll.stackDepth.Pop(t);
+                        }
+                        coll.stackDepth.Push(typeof(int));
+                        break;
+                    }
+                case "cgt":
+                case "cgt.un":
+                case "clt":
+                case "clt.un":
+                    {
+                        coll.stackDepth.PopNumVal();
+                        coll.stackDepth.PopNumVal();
+                        coll.stackDepth.Push(typeof(int));
+                        break;
+                    }
+                case "ldind.i4":
+                    {
+                        coll.stackDepth.Pop(typeof(int).MakeByRefType());
+                        coll.stackDepth.Push(typeof(int));
+                        break;
+                    }
+                case "stind.i4":
+                    {
+                        coll.stackDepth.Pop(typeof(int));
+                        coll.stackDepth.Pop(typeof(int).MakeByRefType());
+                        break;
+                    }
+                default:
+                    throw new Exception("unknown opcode " + opcode.ToString());
+            }
+        }
+
+        private static Type ConvToType(OpCode opcode)
+        {
+            string s = opcode.ToString();
+            s = s.Substring(5);  // strip off "conv."
+            if(s.StartsWith("ovf."))
+                s = s.Substring(4);
+            if(s.EndsWith(".un"))
+                s = s.Substring(0, s.Length - 3);
+
+            switch(s)
+            {
+                case "i":
+                    return typeof(IntPtr);
+                case "i1":
+                    return typeof(sbyte);
+                case "i2":
+                    return typeof(short);
+                case "i4":
+                    return typeof(int);
+                case "i8":
+                    return typeof(long);
+                case "r":
+                case "r4":
+                    return typeof(float);
+                case "r8":
+                    return typeof(double);
+                case "u1":
+                    return typeof(byte);
+                case "u2":
+                    return typeof(ushort);
+                case "u4":
+                    return typeof(uint);
+                case "u8":
+                    return typeof(ulong);
+                case "u":
+                    return typeof(UIntPtr);
+                default:
+                    throw new Exception("unknown opcode " + opcode.ToString());
+            }
+        }
+
+        public override void WriteOutOne(ScriptMyILGen ilGen)
+        {
+            ilGen.Emit(errorAt, opcode);
+        }
+    }
+
+    public class GraphNodeEmitNullEndfinally: GraphNodeEmitNull
+    {
+        public GraphNodeEmitNullEndfinally(ScriptCollector coll, Token errorAt) : base(coll, errorAt, OpCodes.Endfinally)
+        {
+        }
+
+        /**
+         * @brief Endfinally can branch to:
+         *          1) the corresponding EndExceptionBlock
+         *          2) any of the corresponding BeginFinallyBlock's leaveTargets
+         *          3) the next outer BeginFinallyBlock
+         */
+        protected override System.Collections.Generic.IEnumerable<GraphNode> GetNNEnumerable()
+        {
+            return new NNEnumerable(this, typeof(NNEnumerator));
+        }
+
+        private class NNEnumerator: NNEnumeratorBase
+        {
+            private GraphNodeEmitNullEndfinally gn;
+            private IEnumerator<GraphNodeBlock> leaveTargetEnumerator;
+            private int index;
+            public NNEnumerator(GraphNodeEmitNullEndfinally gn)
+            {
+                this.gn = gn;
+
+                // endfinally instruction must be within some try/catch/finally mess
+                GraphNodeBeginExceptionBlock thistry = gn.excBlock;
+
+                // endfinally instruction must be within some finally { } mess
+                GraphNodeBeginFinallyBlock thisfin = (GraphNodeBeginFinallyBlock)thistry.catchFinallyBlock;
+
+                // get the list of the finally { } leave instruction targets
+                this.leaveTargetEnumerator = thisfin.leaveTargets.GetEnumerator();
+            }
+            public override bool MoveNext()
+            {
+                while(true)
+                {
+                    switch(index)
+                    {
+
+                        // to start, return end of our finally { }
+                        case 0:
+                            {
+                                GraphNodeBeginExceptionBlock thistry = gn.excBlock;
+                                nn = thistry.endExcBlock;
+                                if(nn == null)
+                                    throw new NullReferenceException("thistry.endExcBlock");
+                                index++;
+                                return true;
+                            }
+
+                        // return next one of our finally { }'s leave targets
+                        // ie, where any leave instructions in the try { } want 
+                        // the finally { } to go to when it finishes
+                        case 1:
+                            {
+                                if(this.leaveTargetEnumerator.MoveNext())
+                                {
+                                    nn = this.leaveTargetEnumerator.Current;
+                                    if(nn == null)
+                                        throw new NullReferenceException("this.leaveTargetEnumerator.Current");
+                                    return true;
+                                }
+                                break;
+                            }
+
+                        // return beginning of next outer finally { }
+                        case 2:
+                            {
+                                GraphNodeBeginExceptionBlock nntry = gn.excBlock;
+                                while((nntry = nntry.excBlock) != null)
+                                {
+                                    if(nntry.catchFinallyBlock is GraphNodeBeginFinallyBlock)
+                                    {
+                                        nn = nntry.catchFinallyBlock;
+                                        if(nn == null)
+                                            throw new NullReferenceException("nntry.catchFinallyBlock");
+                                        index++;
+                                        return true;
+                                    }
+                                }
+                                break;
+                            }
+
+                        // got nothing more
+                        case 3:
+                            {
+                                return false;
+                            }
+
+                        default:
+                            throw new Exception();
+                    }
+                    index++;
+                }
+            }
+            public override void Reset()
+            {
+                leaveTargetEnumerator.Reset();
+                index = 0;
+                nn = null;
+            }
+        }
+    }
+
+    public class GraphNodeEmitField: GraphNodeEmit
+    {
+        public FieldInfo field;
+
+        public GraphNodeEmitField(ScriptCollector coll, Token errorAt, OpCode opcode, FieldInfo field) : base(coll, errorAt, opcode)
+        {
+            this.field = field;
+        }
+
+        public override void ChainLin()
+        {
+            base.ChainLin();
+
+            switch(opcode.ToString())
+            {
+                case "ldfld":
+                    PopPointer();
+                    coll.stackDepth.Push(field.FieldType);
+                    break;
+                case "ldflda":
+                    PopPointer();
+                    coll.stackDepth.Push(field.FieldType.MakeByRefType());
+                    break;
+                case "stfld":
+                    coll.stackDepth.Pop(field.FieldType);
+                    PopPointer();
+                    break;
+                case "ldsfld":
+                    coll.stackDepth.Push(field.FieldType);
+                    break;
+                case "ldsflda":
+                    coll.stackDepth.Push(field.FieldType.MakeByRefType());
+                    break;
+                case "stsfld":
+                    coll.stackDepth.Pop(field.FieldType);
+                    break;
+                default:
+                    throw new Exception("unknown opcode " + opcode.ToString());
+            }
+        }
+        private void PopPointer()
+        {
+            Type t = field.DeclaringType;               // get class/field type
+            if(t.IsValueType)
+            {
+                Type brt = t.MakeByRefType();      // if value type, eg Vector, it can be pushed by reference or by value
+                int c = coll.stackDepth.Count;
+                if((c > 0) && (coll.stackDepth[c - 1] == brt))
+                    t = brt;
+            }
+            coll.stackDepth.Pop(t);                    // type of what should be on the stack pointing to object or struct
+        }
+
+        public override void DebString(StringBuilder sb)
+        {
+            base.DebString(sb);
+            sb.Append(field.Name);
+        }
+
+        public override void WriteOutOne(ScriptMyILGen ilGen)
+        {
+            ilGen.Emit(errorAt, opcode, field);
+        }
+    }
+
+    public class GraphNodeEmitLocal: GraphNodeEmit
+    {
+        public ScriptMyLocal myLocal;
+
+        public GraphNodeEmitLocal(ScriptCollector coll, Token errorAt, OpCode opcode, ScriptMyLocal myLocal) : base(coll, errorAt, opcode)
+        {
+            this.myLocal = myLocal;
+        }
+
+        public override void ChainLin()
+        {
+            base.ChainLin();
+
+            switch(opcode.ToString())
+            {
+                case "ldloc":
+                    coll.stackDepth.Push(myLocal.type);
+                    break;
+                case "ldloca":
+                    coll.stackDepth.Push(myLocal.type.MakeByRefType());
+                    break;
+                case "stloc":
+                    coll.stackDepth.Pop(myLocal.type);
+                    break;
+                default:
+                    throw new Exception("unknown opcode " + opcode.ToString());
+            }
+        }
+
+        public override void DebString(StringBuilder sb)
+        {
+            base.DebString(sb);
+            sb.Append(myLocal.name);
+        }
+
+        public override ScriptMyLocal ReadsLocal()
+        {
+            if(opcode == OpCodes.Ldloc)
+                return myLocal;
+            if(opcode == OpCodes.Ldloca)
+                return myLocal;
+            if(opcode == OpCodes.Stloc)
+                return null;
+            throw new Exception("unknown opcode " + opcode);
+        }
+        public override ScriptMyLocal WritesLocal()
+        {
+            if(opcode == OpCodes.Ldloc)
+                return null;
+            if(opcode == OpCodes.Ldloca)
+                return myLocal;
+            if(opcode == OpCodes.Stloc)
+                return myLocal;
+            throw new Exception("unknown opcode " + opcode);
+        }
+
+        public override void WriteOutOne(ScriptMyILGen ilGen)
+        {
+            ilGen.Emit(errorAt, opcode, myLocal);
+        }
+    }
+
+    public class GraphNodeEmitType: GraphNodeEmit
+    {
+        public Type type;
+
+        public GraphNodeEmitType(ScriptCollector coll, Token errorAt, OpCode opcode, Type type) : base(coll, errorAt, opcode)
+        {
+            this.type = type;
+        }
+
+        public override void ChainLin()
+        {
+            base.ChainLin();
+
+            switch(opcode.ToString())
+            {
+                case "castclass":
+                case "isinst":
+                    {
+                        coll.stackDepth.PopRef();
+                        coll.stackDepth.Push(type, type.IsValueType);
+                        break;
+                    }
+                case "box":
+                    {
+                        if(!type.IsValueType)
+                            throw new Exception("can't box a non-value type");
+                        coll.stackDepth.Pop(type);
+                        coll.stackDepth.Push(type, true);
+                        break;
+                    }
+                case "unbox":
+                case "unbox.any":
+                    {
+                        if(!type.IsValueType)
+                            throw new Exception("can't unbox to a non-value type");
+                        coll.stackDepth.PopRef();
+                        coll.stackDepth.Push(type);
+                        break;
+                    }
+                case "newarr":
+                    {
+                        coll.stackDepth.Pop(typeof(int));
+                        coll.stackDepth.Push(type.MakeArrayType());
+                        break;
+                    }
+                case "sizeof":
+                    {
+                        coll.stackDepth.Pop(1);
+                        coll.stackDepth.Push(typeof(int));
+                        break;
+                    }
+                case "ldelem":
+                    {
+                        coll.stackDepth.Pop(typeof(int));
+                        coll.stackDepth.Pop(type.MakeArrayType());
+                        coll.stackDepth.Push(type);
+                        break;
+                    }
+                case "ldelema":
+                    {
+                        coll.stackDepth.Pop(typeof(int));
+                        coll.stackDepth.Pop(type.MakeArrayType());
+                        coll.stackDepth.Push(type.MakeByRefType());
+                        break;
+                    }
+                case "stelem":
+                    {
+                        coll.stackDepth.Pop(type);
+                        coll.stackDepth.Pop(typeof(int));
+                        coll.stackDepth.Pop(type.MakeArrayType());
+                        break;
+                    }
+                default:
+                    throw new Exception("unknown opcode " + opcode.ToString());
+            }
+        }
+
+        public override void DebString(StringBuilder sb)
+        {
+            base.DebString(sb);
+            sb.Append(type.Name);
+        }
+
+        public override void WriteOutOne(ScriptMyILGen ilGen)
+        {
+            ilGen.Emit(errorAt, opcode, type);
+        }
+    }
+
+    public class GraphNodeEmitLabel: GraphNodeEmit
+    {
+        public ScriptMyLabel myLabel;
+
+        public GraphNodeEmitLabel(ScriptCollector coll, Token errorAt, OpCode opcode, ScriptMyLabel myLabel) : base(coll, errorAt, opcode)
+        {
+            this.myLabel = myLabel;
+        }
+
+        public override void ChainLin()
+        {
+            base.ChainLin();
+
+            switch(opcode.ToString())
+            {
+                case "brfalse.s":
+                case "brtrue.s":
+                case "brfalse":
+                case "brtrue":
+                    {
+                        coll.stackDepth.Pop(1);
+                        break;
+                    }
+                case "beq.s":
+                case "bge.s":
+                case "bgt.s":
+                case "ble.s":
+                case "blt.s":
+                case "bne.un.s":
+                case "bge.un.s":
+                case "bgt.un.s":
+                case "ble.un.s":
+                case "blt.un.s":
+                case "beq":
+                case "bge":
+                case "bgt":
+                case "ble":
+                case "blt":
+                case "bne.un":
+                case "bge.un":
+                case "bgt.un":
+                case "ble.un":
+                case "blt.un":
+                    {
+                        coll.stackDepth.PopNumVal();
+                        coll.stackDepth.PopNumVal();
+                        break;
+                    }
+                case "br":
+                case "br.s":
+                    break;
+                case "leave":
+                    {
+                        if(coll.stackDepth.Count != 0)
+                            throw new Exception("bad stack depth " + coll.stackDepth.Count);
+                        break;
+                    }
+                default:
+                    throw new Exception("unknown opcode " + opcode.ToString());
+            }
+
+            // if a target doesn't have a depth yet, set its depth to the depth after instruction executes
+            // otherwise, make sure it matches all other branches to that target and what fell through to it
+            coll.stackDepth.Matches(myLabel);
+        }
+
+        public override void DebString(StringBuilder sb)
+        {
+            base.DebString(sb);
+            sb.Append(myLabel.name);
+        }
+
+        public override void WriteOutOne(ScriptMyILGen ilGen)
+        {
+            ilGen.Emit(errorAt, opcode, myLabel);
+        }
+
+        /**
+         * @brief Conditional branches return the next inline followed by the branch target
+         *        Unconditional branches return only the branch target
+         *        But if the target is outside our scope (eg __retlbl), omit it from the list
+         */
+        protected override System.Collections.Generic.IEnumerable<GraphNode> GetNNEnumerable()
+        {
+            return new NNEnumerable(this, typeof(NNEnumerator));
+        }
+
+        private class NNEnumerator: NNEnumeratorBase
+        {
+            private GraphNodeEmitLabel gn;
+            private int index;
+            public NNEnumerator(GraphNodeEmitLabel gn)
+            {
+                this.gn = gn;
+            }
+            public override bool MoveNext()
+            {
+                switch(gn.opcode.FlowControl)
+                {
+                    case FlowControl.Branch:
+                        {
+                            // unconditional branch just goes to target and nothing else
+                            switch(index)
+                            {
+                                case 0:
+                                    {
+                                        nn = gn.myLabel.whereAmI;
+                                        index++;
+                                        return nn != null;
+                                    }
+                                case 1:
+                                    {
+                                        return false;
+                                    }
+                            }
+                            throw new Exception();
+                        }
+                    case FlowControl.Cond_Branch:
+                        {
+                            // conditional branch goes inline and to target
+                            switch(index)
+                            {
+                                case 0:
+                                    {
+                                        nn = gn.nextLin;
+                                        index++;
+                                        return true;
+                                    }
+                                case 1:
+                                    {
+                                        nn = gn.myLabel.whereAmI;
+                                        index++;
+                                        return nn != null;
+                                    }
+                                case 2:
+                                    {
+                                        return false;
+                                    }
+                            }
+                            throw new Exception();
+                        }
+                    default:
+                        throw new Exception("unknown flow control " + gn.opcode.FlowControl.ToString() +
+                                             " of " + gn.opcode.ToString());
+                }
+            }
+            public override void Reset()
+            {
+                index = 0;
+                nn = null;
+            }
+        }
+    }
+
+    public class GraphNodeEmitLabelLeave: GraphNodeEmitLabel
+    {
+        public GraphNodeBlock unwindTo;  // if unwinding, innermost finally block being unwound
+                                         //         else, same as myTarget.whereAmI
+                                         // null if unwinding completely out of scope, eg, __retlbl
+
+        public GraphNodeEmitLabelLeave(ScriptCollector coll, Token errorAt, ScriptMyLabel myLabel) : base(coll, errorAt, OpCodes.Leave, myLabel)
+        {
+        }
+
+        /**
+         * @brief Leave instructions have exactly one unconditional next node.
+         *        Either the given target if within the same try block 
+         *        or the beginning of the intervening finally block.
+         */
+        protected override System.Collections.Generic.IEnumerable<GraphNode> GetNNEnumerable()
+        {
+            return new NNEnumerable(this, typeof(NNEnumerator));
+        }
+
+        private class NNEnumerator: NNEnumeratorBase
+        {
+            private GraphNodeEmitLabelLeave gn;
+            private int index;
+            public NNEnumerator(GraphNodeEmitLabelLeave gn)
+            {
+                this.gn = gn;
+            }
+            public override bool MoveNext()
+            {
+                if(index == 0)
+                {
+                    nn = gn.unwindTo;
+                    index++;
+                    return nn != null;
+                }
+                nn = null;
+                return false;
+            }
+            public override void Reset()
+            {
+                index = 0;
+                nn = null;
+            }
+        }
+    }
+
+    public class GraphNodeEmitLabels: GraphNodeEmit
+    {
+        public ScriptMyLabel[] myLabels;
+
+        public GraphNodeEmitLabels(ScriptCollector coll, Token errorAt, OpCode opcode, ScriptMyLabel[] myLabels) : base(coll, errorAt, opcode)
+        {
+            this.myLabels = myLabels;
+        }
+
+        public override void ChainLin()
+        {
+            base.ChainLin();
+
+            switch(opcode.ToString())
+            {
+                case "switch":
+                    {
+                        coll.stackDepth.Pop(typeof(int));
+                        break;
+                    }
+                default:
+                    throw new Exception("unknown opcode " + opcode.ToString());
+            }
+
+            // if a target doesn't have a depth yet, set its depth to the depth after instruction executes
+            // otherwise, make sure it matches all other branches to that target and what fell through to it
+            foreach(ScriptMyLabel myLabel in myLabels)
+            {
+                coll.stackDepth.Matches(myLabel);
+            }
+        }
+
+        public override void DebString(StringBuilder sb)
+        {
+            base.DebString(sb);
+            bool first = true;
+            foreach(ScriptMyLabel lbl in myLabels)
+            {
+                if(!first)
+                    sb.Append(',');
+                sb.Append(lbl.name);
+                first = false;
+            }
+        }
+
+        public override void WriteOutOne(ScriptMyILGen ilGen)
+        {
+            ilGen.Emit(errorAt, opcode, myLabels);
+        }
+
+        /**
+         * @brief Return list of all labels followed by the next linear instruction
+         *        But if the target is outside our scope (eg __retlbl), omit it from the list
+         */
+        protected override System.Collections.Generic.IEnumerable<GraphNode> GetNNEnumerable()
+        {
+            return new NNEnumerable(this, typeof(NNEnumerator));
+        }
+
+        private class NNEnumerator: NNEnumeratorBase
+        {
+            private GraphNodeEmitLabels gn;
+            private int index;
+            public NNEnumerator(GraphNodeEmitLabels gn)
+            {
+                this.gn = gn;
+            }
+            public override bool MoveNext()
+            {
+                /*
+                 * Return next from list of switch case labels.
+                 */
+                while(index < gn.myLabels.Length)
+                {
+                    nn = gn.myLabels[index++].whereAmI;
+                    if(nn != null)
+                        return true;
+                }
+
+                /*
+                 * If all ran out, the switch instruction falls through.
+                 */
+                if(index == gn.myLabels.Length)
+                {
+                    index++;
+                    nn = gn.nextLin;
+                    return true;
+                }
+
+                /*
+                 * Even ran out of that, say there's nothing more.
+                 */
+                nn = null;
+                return false;
+            }
+            public override void Reset()
+            {
+                index = 0;
+                nn = null;
+            }
+        }
+    }
+
+    public class GraphNodeEmitIntMeth: GraphNodeEmit
+    {
+        public ScriptObjWriter method;
+
+        public GraphNodeEmitIntMeth(ScriptCollector coll, Token errorAt, OpCode opcode, ScriptObjWriter method) : base(coll, errorAt, opcode)
+        {
+            this.method = method;
+        }
+
+        public override void ChainLin()
+        {
+            base.ChainLin();
+
+            switch(opcode.ToString())
+            {
+                case "call":
+                    {
+
+                        // calls have Varpop so pop the number of arguments
+                        // they are all static so there is no separate 'this' parameter
+                        coll.stackDepth.Pop(this.method.argTypes);
+
+                        // calls are also Varpush so they push a return value iff non-void
+                        if(this.method.retType != typeof(void))
+                            coll.stackDepth.Push(this.method.retType);
+                        break;
+                    }
+
+                default:
+                    throw new Exception("unknown opcode " + opcode.ToString());
+            }
+        }
+
+        public override void DebString(StringBuilder sb)
+        {
+            base.DebString(sb);
+            sb.Append(method.methName);
+        }
+
+        public override void WriteOutOne(ScriptMyILGen ilGen)
+        {
+            ilGen.Emit(errorAt, opcode, method);
+        }
+    }
+
+    public class GraphNodeEmitExtMeth: GraphNodeEmit
+    {
+        public MethodInfo method;
+
+        public GraphNodeEmitExtMeth(ScriptCollector coll, Token errorAt, OpCode opcode, MethodInfo method) : base(coll, errorAt, opcode)
+        {
+            this.method = method;
+        }
+
+        public override void ChainLin()
+        {
+            base.ChainLin();
+
+            switch(opcode.ToString())
+            {
+                case "call":
+                case "callvirt":
+                    {
+
+                        // calls have Varpop so pop the number of arguments
+                        coll.stackDepth.Pop(this.method.GetParameters());
+                        if((this.method.CallingConvention & CallingConventions.HasThis) != 0)
+                        {
+                            coll.stackDepth.Pop(method.DeclaringType);
+                        }
+
+                        // calls are also Varpush so they push a return value iff non-void
+                        if(this.method.ReturnType != typeof(void))
+                            coll.stackDepth.Push(this.method.ReturnType);
+                        break;
+                    }
+
+                default:
+                    throw new Exception("unknown opcode " + opcode.ToString());
+            }
+        }
+
+        public override void DebString(StringBuilder sb)
+        {
+            base.DebString(sb);
+            sb.Append(method.Name);
+        }
+
+        public override void WriteOutOne(ScriptMyILGen ilGen)
+        {
+            ilGen.Emit(errorAt, opcode, method);
+        }
+    }
+
+    public class GraphNodeEmitCtor: GraphNodeEmit
+    {
+        public ConstructorInfo ctor;
+
+        public GraphNodeEmitCtor(ScriptCollector coll, Token errorAt, OpCode opcode, ConstructorInfo ctor) : base(coll, errorAt, opcode)
+        {
+            this.ctor = ctor;
+        }
+
+        public override void ChainLin()
+        {
+            base.ChainLin();
+
+            switch(opcode.ToString())
+            {
+                case "newobj":
+                    {
+                        coll.stackDepth.Pop(ctor.GetParameters());
+                        coll.stackDepth.Push(ctor.DeclaringType);
+                        break;
+                    }
+
+                default:
+                    throw new Exception("unknown opcode " + opcode.ToString());
+            }
+        }
+
+        public override void DebString(StringBuilder sb)
+        {
+            base.DebString(sb);
+            sb.Append(ctor.ReflectedType.Name);
+        }
+
+        public override void WriteOutOne(ScriptMyILGen ilGen)
+        {
+            ilGen.Emit(errorAt, opcode, ctor);
+        }
+    }
+
+    public class GraphNodeEmitDouble: GraphNodeEmit
+    {
+        public double value;
+
+        public GraphNodeEmitDouble(ScriptCollector coll, Token errorAt, OpCode opcode, double value) : base(coll, errorAt, opcode)
+        {
+            this.value = value;
+        }
+
+        public override void ChainLin()
+        {
+            base.ChainLin();
+
+            switch(opcode.ToString())
+            {
+                case "ldc.r8":
+                    coll.stackDepth.Push(typeof(double));
+                    break;
+                default:
+                    throw new Exception("unknown opcode " + opcode.ToString());
+            }
+        }
+
+        public override void DebString(StringBuilder sb)
+        {
+            base.DebString(sb);
+            sb.Append(value);
+        }
+
+        public override void WriteOutOne(ScriptMyILGen ilGen)
+        {
+            ilGen.Emit(errorAt, opcode, value);
+        }
+    }
+
+    public class GraphNodeEmitFloat: GraphNodeEmit
+    {
+        public float value;
+
+        public GraphNodeEmitFloat(ScriptCollector coll, Token errorAt, OpCode opcode, float value) : base(coll, errorAt, opcode)
+        {
+            this.value = value;
+        }
+
+        public override void ChainLin()
+        {
+            base.ChainLin();
+
+            switch(opcode.ToString())
+            {
+                case "ldc.r4":
+                    coll.stackDepth.Push(typeof(float));
+                    break;
+                default:
+                    throw new Exception("unknown opcode " + opcode.ToString());
+            }
+        }
+
+        public override void DebString(StringBuilder sb)
+        {
+            base.DebString(sb);
+            sb.Append(value);
+        }
+
+        public override void WriteOutOne(ScriptMyILGen ilGen)
+        {
+            ilGen.Emit(errorAt, opcode, value);
+        }
+    }
+
+    public class GraphNodeEmitInt: GraphNodeEmit
+    {
+        public int value;
+
+        public GraphNodeEmitInt(ScriptCollector coll, Token errorAt, OpCode opcode, int value) : base(coll, errorAt, opcode)
+        {
+            this.value = value;
+        }
+
+        public override void ChainLin()
+        {
+            base.ChainLin();
+
+            switch(opcode.ToString())
+            {
+                case "ldarg":
+                case "ldarg.s":
+                    coll.stackDepth.Push(coll.wrapped.argTypes[value]);
+                    break;
+                case "ldarga":
+                case "ldarga.s":
+                    coll.stackDepth.Push(coll.wrapped.argTypes[value].MakeByRefType());
+                    break;
+                case "starg":
+                case "starg.s":
+                    coll.stackDepth.Pop(coll.wrapped.argTypes[value]);
+                    break;
+                case "ldc.i4":
+                case "ldc.i4.s":
+                    coll.stackDepth.Push(typeof(int));
+                    break;
+                default:
+                    throw new Exception("unknown opcode " + opcode.ToString());
+            }
+        }
+
+        public override void DebString(StringBuilder sb)
+        {
+            base.DebString(sb);
+            sb.Append(value);
+        }
+
+        public override void WriteOutOne(ScriptMyILGen ilGen)
+        {
+            ilGen.Emit(errorAt, opcode, value);
+        }
+    }
+
+    public class GraphNodeEmitString: GraphNodeEmit
+    {
+        public string value;
+
+        public GraphNodeEmitString(ScriptCollector coll, Token errorAt, OpCode opcode, string value) : base(coll, errorAt, opcode)
+        {
+            this.value = value;
+        }
+
+        public override void ChainLin()
+        {
+            base.ChainLin();
+
+            switch(opcode.ToString())
+            {
+                case "ldstr":
+                    coll.stackDepth.Push(typeof(string));
+                    break;
+                default:
+                    throw new Exception("unknown opcode " + opcode.ToString());
+            }
+        }
+
+        public override void DebString(StringBuilder sb)
+        {
+            base.DebString(sb);
+            sb.Append("\"");
+            sb.Append(value);
+            sb.Append("\"");
+        }
+
+        public override void WriteOutOne(ScriptMyILGen ilGen)
+        {
+            ilGen.Emit(errorAt, opcode, value);
+        }
+    }
+
+    public class GraphNodeMarkLabel: GraphNodeBlock
+    {
+        public ScriptMyLabel myLabel;
+
+        public GraphNodeMarkLabel(ScriptCollector coll, ScriptMyLabel myLabel) : base(coll)
+        {
+            this.myLabel = myLabel;
+        }
+
+        public override void ChainLin()
+        {
+            base.ChainLin();
+
+            // if previous instruction can fall through to this label,
+            //     if the label doesn't yet have a stack depth, mark it with current stack depth
+            //     else, the label's stack depth from forward branches and current stack depth must match
+            // else,
+            //     label must have had a forward branch to it so we can know stack depth
+            //     set the current stack depth to the label's stack depth as of that forward branch
+            if(myLabel.whereAmI.prevLin.CanFallThrough())
+            {
+                coll.stackDepth.Matches(myLabel);
+            }
+            else
+            {
+                if(myLabel.stackDepth == null)
+                {
+                    throw new Exception("stack depth unknown at " + myLabel.name);
+                }
+                coll.stackDepth.Clear();
+                int n = myLabel.stackDepth.Length;
+                for(int i = 0; i < n; i++)
+                {
+                    coll.stackDepth.Push(myLabel.stackDepth[i], myLabel.stackBoxeds[i]);
+                }
+            }
+        }
+
+        public override void DebString(StringBuilder sb)
+        {
+            sb.Append(myLabel.name);
+            sb.Append(':');
+            if(myLabel.stackDepth != null)
+            {
+                sb.Append("  [");
+                sb.Append(myLabel.stackDepth.Length);
+                sb.Append(']');
+            }
+        }
+
+        public override void WriteOutOne(ScriptMyILGen ilGen)
+        {
+            ilGen.MarkLabel(myLabel);
+        }
+    }
+
+
+    /**
+     * @brief Generates enumerator that steps through list of nodes that can
+     *        possibly be next in a flow-control sense.
+     */
+    public class NNEnumerable: System.Collections.Generic.IEnumerable<GraphNode>
+    {
+        private object[] cps;
+        private ConstructorInfo ci;
+
+        public NNEnumerable(GraphNode gn, Type nnEnumeratorType)
+        {
+            this.cps = new object[] { gn };
+            this.ci = nnEnumeratorType.GetConstructor(new Type[] { gn.GetType() });
+        }
+        System.Collections.Generic.IEnumerator<GraphNode> System.Collections.Generic.IEnumerable<GraphNode>.GetEnumerator()
+        {
+            return (System.Collections.Generic.IEnumerator<GraphNode>)ci.Invoke(cps);
+        }
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            return (System.Collections.IEnumerator)ci.Invoke(cps);
+        }
+    }
+
+
+    /**
+     * @brief Steps through list of nodes that can possible be next in a flow-control sense.
+     */
+    public abstract class NNEnumeratorBase: System.Collections.Generic.IEnumerator<GraphNode>
+    {
+        protected GraphNode nn;
+
+        public abstract bool MoveNext();
+        public abstract void Reset();
+
+        GraphNode System.Collections.Generic.IEnumerator<GraphNode>.Current
+        {
+            get
+            {
+                return this.nn;
+            }
+        }
+        object System.Collections.IEnumerator.Current
+        {
+            get
+            {
+                return this.nn;
+            }
+        }
+        void System.IDisposable.Dispose()
+        {
+        }
+    }
+
+
+    public class ScriptCollector: ScriptMyILGen
+    {
+        public static readonly bool DEBUG = false;
+
+        public ScriptObjWriter wrapped;
+        public GraphNode firstLin, lastLin;
+        private bool resolvedSomething;
+        private int resolveSequence;
+        private int excBlkSeqNos;
+        public StackDepth stackDepth = new StackDepth();
+
+        public GraphNodeBeginExceptionBlock curTryBlock = null;  // pushed at beginning of try
+                                                                 // popped at BEGINNING of catch/finally
+        public GraphNodeBeginExceptionBlock curExcBlock = null;  // pushed at beginning of try
+                                                                 // popped at END of catch/finally
+
+        private List<ScriptMyLocal> declaredLocals = new List<ScriptMyLocal>();
+        private List<ScriptMyLabel> definedLabels = new List<ScriptMyLabel>();
+
+        public string methName
+        {
+            get
+            {
+                return wrapped.methName;
+            }
+        }
+
+        /**
+         * @brief Wrap the optimizer around the ScriptObjWriter to collect the instruction stream.
+         *        All stream-writing calls get saved to our graph nodes instead of being written to object file.
+         */
+        public ScriptCollector(ScriptObjWriter wrapped)
+        {
+            this.wrapped = wrapped;
+            GraphNodeBegin gnb = new GraphNodeBegin(this);
+            this.firstLin = gnb;
+            this.lastLin = gnb;
+        }
+
+        public ScriptMyLocal DeclareLocal(Type type, string name)
+        {
+            ScriptMyLocal loc = new ScriptMyLocal();
+            loc.name = name;
+            loc.type = type;
+            loc.number = wrapped.localNumber++;
+            declaredLocals.Add(loc);
+            return loc;
+        }
+
+        public ScriptMyLabel DefineLabel(string name)
+        {
+            ScriptMyLabel lbl = new ScriptMyLabel();
+            lbl.name = name;
+            lbl.number = wrapped.labelNumber++;
+            definedLabels.Add(lbl);
+            return lbl;
+        }
+
+        public void BeginExceptionBlock()
+        {
+            GraphNodeBeginExceptionBlock tryBlock = new GraphNodeBeginExceptionBlock(this);
+            tryBlock.ChainLin();
+            tryBlock.excBlkSeqNo = ++this.excBlkSeqNos;
+            this.curExcBlock = tryBlock;
+            this.curTryBlock = tryBlock;
+        }
+
+        public void BeginCatchBlock(Type excType)
+        {
+            GraphNodeBeginCatchBlock catchBlock = new GraphNodeBeginCatchBlock(this, excType);
+            catchBlock.ChainLin();
+            if(curExcBlock.catchFinallyBlock != null)
+                throw new Exception("only one catch/finally allowed per try");
+            curExcBlock.catchFinallyBlock = catchBlock;
+            curTryBlock = curExcBlock.tryBlock;
+        }
+
+        public void BeginFinallyBlock()
+        {
+            GraphNodeBeginFinallyBlock finallyBlock = new GraphNodeBeginFinallyBlock(this);
+            finallyBlock.ChainLin();
+            if(curExcBlock.catchFinallyBlock != null)
+                throw new Exception("only one catch/finally allowed per try");
+            curExcBlock.catchFinallyBlock = finallyBlock;
+            curTryBlock = curExcBlock.tryBlock;
+        }
+
+        public void EndExceptionBlock()
+        {
+            GraphNodeEndExceptionBlock endExcBlock = new GraphNodeEndExceptionBlock(this);
+            endExcBlock.ChainLin();
+            curExcBlock.endExcBlock = endExcBlock;
+            curTryBlock = curExcBlock.tryBlock;
+            curExcBlock = curExcBlock.excBlock;
+        }
+
+        public void Emit(Token errorAt, OpCode opcode)
+        {
+            if(opcode == OpCodes.Endfinally)
+            {
+                new GraphNodeEmitNullEndfinally(this, errorAt).ChainLin();
+            }
+            else
+            {
+                new GraphNodeEmitNull(this, errorAt, opcode).ChainLin();
+            }
+        }
+
+        public void Emit(Token errorAt, OpCode opcode, FieldInfo field)
+        {
+            if(field == null)
+                throw new ArgumentNullException("field");
+            new GraphNodeEmitField(this, errorAt, opcode, field).ChainLin();
+        }
+
+        public void Emit(Token errorAt, OpCode opcode, ScriptMyLocal myLocal)
+        {
+            new GraphNodeEmitLocal(this, errorAt, opcode, myLocal).ChainLin();
+        }
+
+        public void Emit(Token errorAt, OpCode opcode, Type type)
+        {
+            new GraphNodeEmitType(this, errorAt, opcode, type).ChainLin();
+        }
+
+        public void Emit(Token errorAt, OpCode opcode, ScriptMyLabel myLabel)
+        {
+            if(opcode == OpCodes.Leave)
+            {
+                new GraphNodeEmitLabelLeave(this, errorAt, myLabel).ChainLin();
+            }
+            else
+            {
+                new GraphNodeEmitLabel(this, errorAt, opcode, myLabel).ChainLin();
+            }
+        }
+
+        public void Emit(Token errorAt, OpCode opcode, ScriptMyLabel[] myLabels)
+        {
+            new GraphNodeEmitLabels(this, errorAt, opcode, myLabels).ChainLin();
+        }
+
+        public void Emit(Token errorAt, OpCode opcode, ScriptObjWriter method)
+        {
+            if(method == null)
+                throw new ArgumentNullException("method");
+            new GraphNodeEmitIntMeth(this, errorAt, opcode, method).ChainLin();
+        }
+
+        public void Emit(Token errorAt, OpCode opcode, MethodInfo method)
+        {
+            if(method == null)
+                throw new ArgumentNullException("method");
+            new GraphNodeEmitExtMeth(this, errorAt, opcode, method).ChainLin();
+        }
+
+        public void Emit(Token errorAt, OpCode opcode, ConstructorInfo ctor)
+        {
+            if(ctor == null)
+                throw new ArgumentNullException("ctor");
+            new GraphNodeEmitCtor(this, errorAt, opcode, ctor).ChainLin();
+        }
+
+        public void Emit(Token errorAt, OpCode opcode, double value)
+        {
+            new GraphNodeEmitDouble(this, errorAt, opcode, value).ChainLin();
+        }
+
+        public void Emit(Token errorAt, OpCode opcode, float value)
+        {
+            new GraphNodeEmitFloat(this, errorAt, opcode, value).ChainLin();
+        }
+
+        public void Emit(Token errorAt, OpCode opcode, int value)
+        {
+            new GraphNodeEmitInt(this, errorAt, opcode, value).ChainLin();
+        }
+
+        public void Emit(Token errorAt, OpCode opcode, string value)
+        {
+            new GraphNodeEmitString(this, errorAt, opcode, value).ChainLin();
+        }
+
+        public void MarkLabel(ScriptMyLabel myLabel)
+        {
+            myLabel.whereAmI = new GraphNodeMarkLabel(this, myLabel);
+            myLabel.whereAmI.ChainLin();
+        }
+
+        /**
+         * @brief Write the whole graph out to the object file.
+         */
+        public ScriptMyILGen WriteOutAll()
+        {
+            foreach(ScriptMyLocal loc in declaredLocals)
+            {
+                if(loc.isReferenced)
+                    wrapped.DeclareLocal(loc);
+            }
+            foreach(ScriptMyLabel lbl in definedLabels)
+            {
+                wrapped.DefineLabel(lbl);
+            }
+            for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
+            {
+                gn.WriteOutOne(wrapped);
+            }
+            return wrapped;
+        }
+
+        /**
+         * @brief Perform optimizations.
+         */
+        public void Optimize()
+        {
+            if(curExcBlock != null)
+                throw new Exception("exception block still open");
+
+            /*
+             * If an instruction says it doesn't fall through, remove all instructions to
+             * the end of the block.
+             */
+            for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
+            {
+                if(!gn.CanFallThrough())
+                {
+                    GraphNode nn;
+                    while(((nn = gn.nextLin) != null) && !(nn is GraphNodeBlock) &&
+                                              !(nn is GraphNodeEndExceptionBlock))
+                    {
+                        if((gn.nextLin = nn.nextLin) != null)
+                        {
+                            nn.nextLin.prevLin = gn;
+                        }
+                    }
+                }
+            }
+
+            /*
+             * Scan for OpCodes.Leave instructions.
+             * For each found, its target for flow analysis purposes is the beginning of the corresponding
+             * finally block.  And the end of the finally block gets a conditional branch target of the 
+             * leave instruction's target.  A leave instruction can unwind zero or more finally blocks.
+             */
+            for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
+            {
+                if(gn is GraphNodeEmitLabelLeave)
+                {
+                    GraphNodeEmitLabelLeave leaveInstr = (GraphNodeEmitLabelLeave)gn;         // the leave instruction
+                    GraphNodeMarkLabel leaveTarget = leaveInstr.myLabel.whereAmI;             // label being targeted by leave
+                    GraphNodeBeginExceptionBlock leaveTargetsTryBlock =                       // try block directly enclosing leave target
+                        (leaveTarget == null) ? null : leaveTarget.tryBlock;              // ...it must not be unwound
+
+                    /*
+                     * Step through try { }s from the leave instruction towards its target looking for try { }s with finally { }s.
+                     * The leave instruction unconditionally branches to the beginning of the innermost one found.
+                     * The end of the last one found conditionally branches to the leave instruction's target.
+                     * If none found, the leave is a simple unconditional branch to its target.
+                     */
+                    GraphNodeBeginFinallyBlock innerFinallyBlock = null;
+                    for(GraphNodeBeginExceptionBlock tryBlock = leaveInstr.tryBlock;
+                         tryBlock != leaveTargetsTryBlock;
+                         tryBlock = tryBlock.tryBlock)
+                    {
+                        if(tryBlock == null)
+                            throw new Exception("leave target not at or outer to leave instruction");
+                        GraphNodeCatchFinallyBlock cfb = tryBlock.catchFinallyBlock;
+                        if(cfb is GraphNodeBeginFinallyBlock)
+                        {
+                            if(innerFinallyBlock == null)
+                            {
+                                leaveInstr.unwindTo = cfb;
+                            }
+                            innerFinallyBlock = (GraphNodeBeginFinallyBlock)cfb;
+                        }
+                    }
+
+                    /*
+                     * The end of the outermost finally being unwound can conditionally jump to the target of the leave instruction.
+                     * In the case of no finallies being unwound, the leave is just a simple unconditional branch.
+                     */
+                    if(innerFinallyBlock == null)
+                    {
+                        leaveInstr.unwindTo = leaveTarget;
+                    }
+                    else if(!innerFinallyBlock.leaveTargets.Contains(leaveTarget))
+                    {
+                        innerFinallyBlock.leaveTargets.Add(leaveTarget);
+                    }
+                }
+            }
+
+            /*
+             * See which variables a particular block reads before writing.
+             * This just considers the block itself and nothing that it branches to or fallsthru to.
+             */
+            GraphNodeBlock currentBlock = null;
+            for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
+            {
+                if(gn is GraphNodeBlock)
+                    currentBlock = (GraphNodeBlock)gn;
+                ScriptMyLocal rdlcl = gn.ReadsLocal();
+                if((rdlcl != null) &&
+                    !currentBlock.localsWrittenBeforeRead.Contains(rdlcl) &&
+                    !currentBlock.localsReadBeforeWritten.Contains(rdlcl))
+                {
+                    currentBlock.localsReadBeforeWritten.Add(rdlcl);
+                }
+                ScriptMyLocal wrlcl = gn.WritesLocal();
+                if((wrlcl != null) &&
+                    !currentBlock.localsWrittenBeforeRead.Contains(wrlcl) &&
+                    !currentBlock.localsReadBeforeWritten.Contains(wrlcl))
+                {
+                    currentBlock.localsWrittenBeforeRead.Add(wrlcl);
+                }
+            }
+
+            /*
+             * For every block we branch to, add that blocks readables to our list of readables,
+             * because we need to have those values valid on entry to our block.  But if we write the 
+             * variable before we can possibly branch to that block, then we don't need to have it valid 
+             * on entry to our block.  So basically it looks like the branch instruction is reading 
+             * everything required by any blocks it can branch to.
+             */
+            do
+            {
+                this.resolvedSomething = false;
+                this.resolveSequence++;
+                this.ResolveBlock((GraphNodeBlock)firstLin);
+            } while(this.resolvedSomething);
+
+            /*
+             * Repeat the cutting loops as long as we keep finding stuff.
+             */
+            bool didSomething;
+            do
+            {
+                didSomething = false;
+
+                /*
+                 * Strip out ldc.i4.1/xor/ldc.i4.1/xor
+                 */
+                for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
+                {
+                    if(!(gn is GraphNodeEmit))
+                        continue;
+                    GraphNodeEmit xor2 = (GraphNodeEmit)gn;
+                    if(xor2.opcode != OpCodes.Xor)
+                        continue;
+                    if(!(xor2.prevLin is GraphNodeEmit))
+                        continue;
+                    GraphNodeEmit ld12 = (GraphNodeEmit)xor2.prevLin;
+                    if(ld12.opcode != OpCodes.Ldc_I4_1)
+                        continue;
+                    if(!(ld12.prevLin is GraphNodeEmit))
+                        continue;
+                    GraphNodeEmit xor1 = (GraphNodeEmit)ld12.prevLin;
+                    if(xor1.opcode != OpCodes.Xor)
+                        continue;
+                    if(!(xor2.prevLin is GraphNodeEmit))
+                        continue;
+                    GraphNodeEmit ld11 = (GraphNodeEmit)xor1.prevLin;
+                    if(ld11.opcode != OpCodes.Ldc_I4_1)
+                        continue;
+                    ld11.prevLin.nextLin = xor2.nextLin;
+                    xor2.nextLin.prevLin = ld11.prevLin;
+                    didSomething = true;
+                }
+
+                /*
+                 * Replace c{cond}/ldc.i4.1/xor/br{false,true} -> c{cond}/br{true,false}
+                 */
+                for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
+                {
+                    if(!(gn is GraphNodeEmit))
+                        continue;
+                    GraphNodeEmit brft = (GraphNodeEmit)gn;
+                    if((brft.opcode != OpCodes.Brfalse) && (brft.opcode != OpCodes.Brtrue))
+                        continue;
+                    if(!(brft.prevLin is GraphNodeEmit))
+                        continue;
+                    GraphNodeEmit xor = (GraphNodeEmit)brft.prevLin;
+                    if(xor.opcode != OpCodes.Xor)
+                        continue;
+                    if(!(xor.prevLin is GraphNodeEmit))
+                        continue;
+                    GraphNodeEmit ldc = (GraphNodeEmit)xor.prevLin;
+                    if(ldc.opcode != OpCodes.Ldc_I4_1)
+                        continue;
+                    if(!(ldc.prevLin is GraphNodeEmit))
+                        continue;
+                    GraphNodeEmit cmp = (GraphNodeEmit)ldc.prevLin;
+                    if(cmp.opcode.StackBehaviourPop != StackBehaviour.Pop1_pop1)
+                        continue;
+                    if(cmp.opcode.StackBehaviourPush != StackBehaviour.Pushi)
+                        continue;
+                    cmp.nextLin = brft;
+                    brft.prevLin = cmp;
+                    brft.opcode = (brft.opcode == OpCodes.Brfalse) ? OpCodes.Brtrue : OpCodes.Brfalse;
+                    didSomething = true;
+                }
+
+                /*
+                 * Replace c{cond}/br{false,true} -> b{!,}{cond}
+                 */
+                for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
+                {
+                    if(!(gn is GraphNodeEmit))
+                        continue;
+                    GraphNodeEmit brft = (GraphNodeEmit)gn;
+                    if((brft.opcode != OpCodes.Brfalse) && (brft.opcode != OpCodes.Brtrue))
+                        continue;
+                    if(!(brft.prevLin is GraphNodeEmit))
+                        continue;
+                    GraphNodeEmit cmp = (GraphNodeEmit)brft.prevLin;
+                    if(cmp.opcode.StackBehaviourPop != StackBehaviour.Pop1_pop1)
+                        continue;
+                    if(cmp.opcode.StackBehaviourPush != StackBehaviour.Pushi)
+                        continue;
+                    cmp.prevLin.nextLin = brft;
+                    brft.prevLin = cmp.prevLin;
+                    bool brtru = (brft.opcode == OpCodes.Brtrue);
+                    if(cmp.opcode == OpCodes.Ceq)
+                        brft.opcode = brtru ? OpCodes.Beq : OpCodes.Bne_Un;
+                    else if(cmp.opcode == OpCodes.Cgt)
+                        brft.opcode = brtru ? OpCodes.Bgt : OpCodes.Ble;
+                    else if(cmp.opcode == OpCodes.Cgt_Un)
+                        brft.opcode = brtru ? OpCodes.Bgt_Un : OpCodes.Ble_Un;
+                    else if(cmp.opcode == OpCodes.Clt)
+                        brft.opcode = brtru ? OpCodes.Blt : OpCodes.Bge;
+                    else if(cmp.opcode == OpCodes.Clt_Un)
+                        brft.opcode = brtru ? OpCodes.Blt_Un : OpCodes.Bge_Un;
+                    else
+                        throw new Exception();
+                    didSomething = true;
+                }
+
+                /*
+                 * Replace ld{c.i4.0,null}/br{ne.un,eq} -> br{true,false}
+                 */
+                for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
+                {
+                    if(!(gn is GraphNodeEmit))
+                        continue;
+                    GraphNodeEmit brcc = (GraphNodeEmit)gn;
+                    if((brcc.opcode != OpCodes.Bne_Un) && (brcc.opcode != OpCodes.Beq))
+                        continue;
+                    if(!(brcc.prevLin is GraphNodeEmit))
+                        continue;
+                    GraphNodeEmit ldc0 = (GraphNodeEmit)brcc.prevLin;
+                    if((ldc0.opcode != OpCodes.Ldc_I4_0) && (ldc0.opcode != OpCodes.Ldnull))
+                        continue;
+                    ldc0.prevLin.nextLin = brcc;
+                    brcc.prevLin = ldc0.prevLin;
+                    brcc.opcode = (brcc.opcode == OpCodes.Bne_Un) ? OpCodes.Brtrue : OpCodes.Brfalse;
+                    didSomething = true;
+                }
+
+                /*
+                 * Replace:
+                 *    ldloc v1
+                 *    stloc v2
+                 *    ld<anything> except ld<anything> v2
+                 *    ldloc v2
+                 *      ...v2 unreferenced hereafter
+                 * With:
+                 *    ld<anything> except ld<anything> v2
+                 *    ldloc v1
+                 */
+                for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
+                {
+
+                    // check for 'ldloc v1' instruction
+                    if(!(gn is GraphNodeEmitLocal))
+                        continue;
+                    GraphNodeEmitLocal ldlv1 = (GraphNodeEmitLocal)gn;
+                    if(ldlv1.opcode != OpCodes.Ldloc)
+                        continue;
+
+                    // check for 'stloc v2' instruction
+                    if(!(ldlv1.nextLin is GraphNodeEmitLocal))
+                        continue;
+                    GraphNodeEmitLocal stlv2 = (GraphNodeEmitLocal)ldlv1.nextLin;
+                    if(stlv2.opcode != OpCodes.Stloc)
+                        continue;
+
+                    // check for 'ld<anything> except ld<anything> v2' instruction
+                    if(!(stlv2.nextLin is GraphNodeEmit))
+                        continue;
+                    GraphNodeEmit ldany = (GraphNodeEmit)stlv2.nextLin;
+                    if(!ldany.opcode.ToString().StartsWith("ld"))
+                        continue;
+                    if((ldany is GraphNodeEmitLocal) &&
+                        ((GraphNodeEmitLocal)ldany).myLocal == stlv2.myLocal)
+                        continue;
+
+                    // check for 'ldloc v2' instruction
+                    if(!(ldany.nextLin is GraphNodeEmitLocal))
+                        continue;
+                    GraphNodeEmitLocal ldlv2 = (GraphNodeEmitLocal)ldany.nextLin;
+                    if(ldlv2.opcode != OpCodes.Ldloc)
+                        continue;
+                    if(ldlv2.myLocal != stlv2.myLocal)
+                        continue;
+
+                    // check that v2 is not needed after this at all
+                    if(IsLocalNeededAfterThis(ldlv2, ldlv2.myLocal))
+                        continue;
+
+                    // make 'ld<anything>...' the first instruction
+                    ldany.prevLin = ldlv1.prevLin;
+                    ldany.prevLin.nextLin = ldany;
+
+                    // make 'ldloc v1' the second instruction
+                    ldany.nextLin = ldlv1;
+                    ldlv1.prevLin = ldany;
+
+                    // and make 'ldloc v1' the last instruction
+                    ldlv1.nextLin = ldlv2.nextLin;
+                    ldlv1.nextLin.prevLin = ldlv1;
+
+                    didSomething = true;
+                }
+
+                /*
+                 * Remove all the stloc/ldloc that are back-to-back without the local
+                 * being needed afterwards.  If it is needed afterwards, replace the 
+                 * stloc/ldloc with dup/stloc.
+                 */
+                for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
+                {
+                    if((gn is GraphNodeEmitLocal) &&
+                        (gn.prevLin is GraphNodeEmitLocal))
+                    {
+                        GraphNodeEmitLocal stloc = (GraphNodeEmitLocal)gn.prevLin;
+                        GraphNodeEmitLocal ldloc = (GraphNodeEmitLocal)gn;
+                        if((stloc.opcode == OpCodes.Stloc) &&
+                            (ldloc.opcode == OpCodes.Ldloc) &&
+                            (stloc.myLocal == ldloc.myLocal))
+                        {
+                            if(IsLocalNeededAfterThis(ldloc, ldloc.myLocal))
+                            {
+                                GraphNodeEmitNull dup = new GraphNodeEmitNull(this, stloc.errorAt, OpCodes.Dup);
+                                dup.nextLin = stloc;
+                                dup.prevLin = stloc.prevLin;
+                                stloc.nextLin = ldloc.nextLin;
+                                stloc.prevLin = dup;
+                                dup.prevLin.nextLin = dup;
+                                stloc.nextLin.prevLin = stloc;
+                                gn = stloc;
+                            }
+                            else
+                            {
+                                stloc.prevLin.nextLin = ldloc.nextLin;
+                                ldloc.nextLin.prevLin = stloc.prevLin;
+                                gn = stloc.prevLin;
+                            }
+                            didSomething = true;
+                        }
+                    }
+                }
+
+                /*
+                 * Remove all write-only local variables, ie, those with no ldloc[a] references.
+                 * Replace any stloc instructions with pops.
+                 */
+                for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
+                {
+                    ScriptMyLocal rdlcl = gn.ReadsLocal();
+                    if(rdlcl != null)
+                        rdlcl.isReferenced = true;
+                }
+                for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
+                {
+                    ScriptMyLocal wrlcl = gn.WritesLocal();
+                    if((wrlcl != null) && !wrlcl.isReferenced)
+                    {
+                        if(!(gn is GraphNodeEmitLocal) || (((GraphNodeEmitLocal)gn).opcode != OpCodes.Stloc))
+                        {
+                            throw new Exception("expecting stloc");
+                        }
+                        GraphNodeEmitNull pop = new GraphNodeEmitNull(this, ((GraphNodeEmit)gn).errorAt, OpCodes.Pop);
+                        pop.nextLin = gn.nextLin;
+                        pop.prevLin = gn.prevLin;
+                        gn.nextLin.prevLin = pop;
+                        gn.prevLin.nextLin = pop;
+                        gn = pop;
+                        didSomething = true;
+                    }
+                }
+
+                /*
+                 * Remove any Ld<const>/Dup,Pop.
+                 */
+                for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
+                {
+                    if((gn is GraphNodeEmit) &&
+                        (gn.nextLin is GraphNodeEmit))
+                    {
+                        GraphNodeEmit gne = (GraphNodeEmit)gn;
+                        GraphNodeEmit nne = (GraphNodeEmit)gn.nextLin;
+                        if(gne.isPoppable && (nne.opcode == OpCodes.Pop))
+                        {
+                            gne.prevLin.nextLin = nne.nextLin;
+                            nne.nextLin.prevLin = gne.prevLin;
+                            gn = gne.prevLin;
+                            didSomething = true;
+                        }
+                    }
+                }
+            } while(didSomething);
+
+            /*
+             * Dump out the results.
+             */
+            if(DEBUG)
+            {
+                Console.WriteLine("");
+                Console.WriteLine(methName);
+                Console.WriteLine("  resolveSequence=" + this.resolveSequence);
+
+                Console.WriteLine("  Locals:");
+                foreach(ScriptMyLocal loc in declaredLocals)
+                {
+                    Console.WriteLine("    " + loc.type.Name + "  " + loc.name);
+                }
+
+                Console.WriteLine("  Labels:");
+                foreach(ScriptMyLabel lbl in definedLabels)
+                {
+                    Console.WriteLine("    " + lbl.name);
+                }
+
+                Console.WriteLine("  Code:");
+                DumpCode();
+            }
+        }
+
+        private void DumpCode()
+        {
+            int linSeqNos = 0;
+            for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
+            {
+                gn.linSeqNo = ++linSeqNos;
+            }
+            for(GraphNode gn = firstLin; gn != null; gn = gn.nextLin)
+            {
+                StringBuilder sb = new StringBuilder();
+                gn.DebStringExt(sb);
+                Console.WriteLine(sb.ToString());
+                if(gn is GraphNodeBlock)
+                {
+                    GraphNodeBlock gnb = (GraphNodeBlock)gn;
+                    foreach(ScriptMyLocal lcl in gnb.localsReadBeforeWritten)
+                    {
+                        Console.WriteLine("         reads " + lcl.name);
+                    }
+                }
+            }
+        }
+
+        /**
+         * @brief Scan the given block for branches to other blocks.
+         *        For any locals read by those blocks, mark them as being read by this block, 
+         *        provided this block has not written them by that point.  This makes it look 
+         *        as though the branch instruction is reading all the locals needed by any 
+         *        target blocks.
+         */
+        private void ResolveBlock(GraphNodeBlock currentBlock)
+        {
+            if(currentBlock.hasBeenResolved == this.resolveSequence)
+                return;
+
+            /*
+             * So we don't recurse forever on a backward branch.
+             */
+            currentBlock.hasBeenResolved = this.resolveSequence;
+
+            /*
+             * Assume we haven't written any locals yet.
+             */
+            List<ScriptMyLocal> localsWrittenSoFar = new List<ScriptMyLocal>();
+
+            /*
+             * Scan through the instructions in this block.
+             */
+            for(GraphNode gn = currentBlock; gn != null;)
+            {
+
+                /*
+                 * See if the instruction writes a local we don't know about yet.
+                 */
+                ScriptMyLocal wrlcl = gn.WritesLocal();
+                if((wrlcl != null) && !localsWrittenSoFar.Contains(wrlcl))
+                {
+                    localsWrittenSoFar.Add(wrlcl);
+                }
+
+                /*
+                 * Scan through all the possible next instructions after this.
+                 * Note that if we are in the first part of a try/catch/finally block, 
+                 * every instruction conditionally branches to the beginning of the 
+                 * second part (the catch/finally block).
+                 */
+                GraphNode nextFallthruNode = null;
+                foreach(GraphNode nn in gn.NextNodes)
+                {
+                    if(nn is GraphNodeBlock)
+                    {
+
+                        /*
+                         * Start of a block, go through all locals needed by that block on entry.
+                         */
+                        GraphNodeBlock nextBlock = (GraphNodeBlock)nn;
+                        ResolveBlock(nextBlock);
+                        foreach(ScriptMyLocal readByNextBlock in nextBlock.localsReadBeforeWritten)
+                        {
+
+                            /*
+                             * If this block hasn't written it by now and this block doesn't already
+                             * require it on entry, say this block requires it on entry.
+                             */
+                            if(!localsWrittenSoFar.Contains(readByNextBlock) &&
+                                !currentBlock.localsReadBeforeWritten.Contains(readByNextBlock))
+                            {
+                                currentBlock.localsReadBeforeWritten.Add(readByNextBlock);
+                                this.resolvedSomething = true;
+                            }
+                        }
+                    }
+                    else
+                    {
+
+                        /*
+                         * Not start of a block, should be normal fallthru instruction.
+                         */
+                        if(nextFallthruNode != null)
+                            throw new Exception("more than one fallthru from " + gn.ToString());
+                        nextFallthruNode = nn;
+                    }
+                }
+
+                /*
+                 * Process next instruction if it isn't the start of a block.
+                 */
+                if(nextFallthruNode == gn)
+                    throw new Exception("can't fallthru to self");
+                gn = nextFallthruNode;
+            }
+        }
+
+        /**
+         * @brief Figure out whether the value in a local var is needed after the given instruction.
+         *        True if we reach the end of the program on all branches before reading it
+         *        True if we write the local var on all branches before reading it
+         *        False otherwise
+         */
+        private bool IsLocalNeededAfterThis(GraphNode node, ScriptMyLocal local)
+        {
+            do
+            {
+                GraphNode nextFallthruNode = null;
+                foreach(GraphNode nn in node.NextNodes)
+                {
+                    if(nn is GraphNodeBlock)
+                    {
+                        if(((GraphNodeBlock)nn).localsReadBeforeWritten.Contains(local))
+                        {
+                            return true;
+                        }
+                    }
+                    else
+                    {
+                        nextFallthruNode = nn;
+                    }
+                }
+                node = nextFallthruNode;
+                if(node == null)
+                    return false;
+                if(node.ReadsLocal() == local)
+                    return true;
+            } while(node.WritesLocal() != local);
+            return false;
+        }
+
+        public static void PadToLength(StringBuilder sb, int len, string str)
+        {
+            int pad = len - sb.Length;
+            if(pad < 0)
+                pad = 0;
+            sb.Append(str.PadLeft(pad));
+        }
+    }
+}