/*
 * 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.XMREngine
{
    /**
     * @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));
        }
    }
}