/*
 * 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;

using LSL_Float = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLFloat;
using LSL_Integer = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLInteger;
using LSL_Key = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLString;
using LSL_List = OpenSim.Region.ScriptEngine.Shared.LSL_Types.list;
using LSL_Rotation = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Quaternion;
using LSL_String = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLString;
using LSL_Vector = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Vector3;

/**
 * @brief Wrapper class for ILGenerator.
 *        It writes the object code to a file and can then make real ILGenerator calls
 *        based on the file's contents.
 */
namespace OpenSim.Region.ScriptEngine.XMREngine
{
    public enum ScriptObjWriterCode : byte {
        BegMethod, EndMethod, TheEnd,
        DclLabel, DclLocal, DclMethod, MarkLabel,
        EmitNull, EmitField, EmitLocal, EmitType, EmitLabel, EmitMethodExt, 
        EmitMethodInt, EmitCtor, EmitDouble, EmitFloat, EmitInteger, EmitString,
        EmitLabels,
        BegExcBlk, BegCatBlk, BegFinBlk, EndExcBlk
    }

    public class ScriptObjWriter : ScriptMyILGen
    {
        private static Dictionary<short, OpCode> opCodes = PopulateOpCodes ();
        private static Dictionary<string, Type> string2Type = PopulateS2T ();
        private static Dictionary<Type, string> type2String = PopulateT2S ();

        private static MethodInfo monoGetCurrentOffset = typeof (ILGenerator).GetMethod ("Mono_GetCurrentOffset",
                        BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, 
                        new Type[] { typeof (ILGenerator) }, null);

        private static readonly OpCode[] opCodesLdcI4M1P8 = new OpCode[] {
            OpCodes.Ldc_I4_M1, OpCodes.Ldc_I4_0, OpCodes.Ldc_I4_1, OpCodes.Ldc_I4_2, OpCodes.Ldc_I4_3, 
            OpCodes.Ldc_I4_4,  OpCodes.Ldc_I4_5, OpCodes.Ldc_I4_6, OpCodes.Ldc_I4_7, OpCodes.Ldc_I4_8
        };

        private BinaryWriter objFileWriter;
        private string lastErrorAtFile = "";
        private int    lastErrorAtLine = 0;
        private int    lastErrorAtPosn = 0;

        private Dictionary<Type, string> sdTypesRev = new Dictionary<Type, string> ();
        public int labelNumber = 0;
        public int localNumber = 0;

        private string _methName;
        public string methName { get { return _methName; } }

        public Type   retType;
        public Type[] argTypes;

        /**
         * @brief Begin function declaration
         * @param sdTypes    = script-defined types
         * @param methName   = name of the method being declared, eg, "Verify(array,list,string)"
         * @param retType    = its return value type
         * @param argTypes[] = its argument types
         * @param objFileWriter  = file to write its object code to
         *
         * After calling this function, the following functions should be called:
         *    this.BegMethod ();
         *      this.<as required> ();
         *    this.EndMethod ();
         *
         * The design of this object is such that many constructors may be called,
         * but once a BegMethod() is called for one of the objects, no method may
         * called for any of the other objects until EndMethod() is called (or it 
         * would break up the object stream for that method).  But we need to have
         * many constructors possible so we get function headers at the beginning
         * of the object file in case there are forward references to the functions.
         */
        public ScriptObjWriter (TokenScript tokenScript, string methName, Type retType, Type[] argTypes, string[] argNames, BinaryWriter objFileWriter)
        {
            this._methName     = methName;
            this.retType       = retType;
            this.argTypes      = argTypes;
            this.objFileWriter = objFileWriter;

            /*
             * Build list that translates system-defined types to script defined types.
             */
            foreach (TokenDeclSDType sdt in tokenScript.sdSrcTypesValues) {
                Type sys = sdt.GetSysType();
                if (sys != null) sdTypesRev[sys] = sdt.longName.val;
            }

            /*
             * This tells the reader to call 'new DynamicMethod()' to create
             * the function header.  Then any forward reference calls to this
             * method will have a MethodInfo struct to call.
             */
            objFileWriter.Write ((byte)ScriptObjWriterCode.DclMethod);
            objFileWriter.Write (methName);
            objFileWriter.Write (GetStrFromType (retType));

            int nArgs = argTypes.Length;
            objFileWriter.Write (nArgs);
            for (int i = 0; i < nArgs; i ++) {
                objFileWriter.Write (GetStrFromType (argTypes[i]));
                objFileWriter.Write (argNames[i]);
            }
        }

        /**
         * @brief Begin outputting object code for the function
         */
        public void BegMethod ()
        {
            /*
             * This tells the reader to call methodInfo.GetILGenerator()
             * so it can start writing CIL code for the method.
             */
            objFileWriter.Write ((byte)ScriptObjWriterCode.BegMethod);
            objFileWriter.Write (methName);
        }

        /**
         * @brief End of object code for the function
         */
        public void EndMethod ()
        {
            /*
             * This tells the reader that all code for the method has
             * been written and so it will typically call CreateDelegate()
             * to finalize the method and create an entrypoint.
             */
            objFileWriter.Write ((byte)ScriptObjWriterCode.EndMethod);

            objFileWriter = null;
        }

        /**
         * @brief Declare a local variable for use by the function
         */
        public ScriptMyLocal DeclareLocal (Type type, string name)
        {
            ScriptMyLocal myLocal = new ScriptMyLocal ();
            myLocal.type   = type;
            myLocal.name   = name;
            myLocal.number = localNumber ++;
            myLocal.isReferenced = true;  // so ScriptCollector won't optimize references away
            return DeclareLocal (myLocal);
        }
        public ScriptMyLocal DeclareLocal (ScriptMyLocal myLocal)
        {
            objFileWriter.Write ((byte)ScriptObjWriterCode.DclLocal);
            objFileWriter.Write (myLocal.number);
            objFileWriter.Write (myLocal.name);
            objFileWriter.Write (GetStrFromType (myLocal.type));
            return myLocal;
        }

        /**
         * @brief Define a label for use by the function
         */
        public ScriptMyLabel DefineLabel (string name)
        {
            ScriptMyLabel myLabel = new ScriptMyLabel ();
            myLabel.name   = name;
            myLabel.number = labelNumber ++;
            return DefineLabel (myLabel);
        }
        public ScriptMyLabel DefineLabel (ScriptMyLabel myLabel)
        {
            objFileWriter.Write ((byte)ScriptObjWriterCode.DclLabel);
            objFileWriter.Write (myLabel.number);
            objFileWriter.Write (myLabel.name);
            return myLabel;
        }

        /**
         * @brief try/catch blocks.
         */
        public void BeginExceptionBlock ()
        {
            objFileWriter.Write ((byte)ScriptObjWriterCode.BegExcBlk);
        }

        public void BeginCatchBlock (Type excType)
        {
            objFileWriter.Write ((byte)ScriptObjWriterCode.BegCatBlk);
            objFileWriter.Write (GetStrFromType (excType));
        }

        public void BeginFinallyBlock ()
        {
            objFileWriter.Write ((byte)ScriptObjWriterCode.BegFinBlk);
        }

        public void EndExceptionBlock ()
        {
            objFileWriter.Write ((byte)ScriptObjWriterCode.EndExcBlk);
        }

        public void Emit (Token errorAt, OpCode opcode)
        {
            objFileWriter.Write ((byte)ScriptObjWriterCode.EmitNull);
            WriteOpCode (errorAt, opcode);
        }

        public void Emit (Token errorAt, OpCode opcode, FieldInfo field)
        {
            objFileWriter.Write ((byte)ScriptObjWriterCode.EmitField);
            WriteOpCode (errorAt, opcode);
            objFileWriter.Write (GetStrFromType (field.ReflectedType));
            objFileWriter.Write (field.Name);
        }

        public void Emit (Token errorAt, OpCode opcode, ScriptMyLocal myLocal)
        {
            objFileWriter.Write ((byte)ScriptObjWriterCode.EmitLocal);
            WriteOpCode (errorAt, opcode);
            objFileWriter.Write (myLocal.number);
        }

        public void Emit (Token errorAt, OpCode opcode, Type type)
        {
            objFileWriter.Write ((byte)ScriptObjWriterCode.EmitType);
            WriteOpCode (errorAt, opcode);
            objFileWriter.Write (GetStrFromType (type));
        }

        public void Emit (Token errorAt, OpCode opcode, ScriptMyLabel myLabel)
        {
            objFileWriter.Write ((byte)ScriptObjWriterCode.EmitLabel);
            WriteOpCode (errorAt, opcode);
            objFileWriter.Write (myLabel.number);
        }

        public void Emit (Token errorAt, OpCode opcode, ScriptMyLabel[] myLabels)
        {
            objFileWriter.Write ((byte)ScriptObjWriterCode.EmitLabels);
            WriteOpCode (errorAt, opcode);
            int nLabels = myLabels.Length;
            objFileWriter.Write (nLabels);
            for (int i = 0; i < nLabels; i ++) {
                objFileWriter.Write (myLabels[i].number);
            }
        }

        public void Emit (Token errorAt, OpCode opcode, ScriptObjWriter method)
        {
            if (method == null) throw new ArgumentNullException ("method");
            objFileWriter.Write ((byte)ScriptObjWriterCode.EmitMethodInt);
            WriteOpCode (errorAt, opcode);
            objFileWriter.Write (method.methName);
        }

        public void Emit (Token errorAt, OpCode opcode, MethodInfo method)
        {
            objFileWriter.Write ((byte)ScriptObjWriterCode.EmitMethodExt);
            WriteOpCode (errorAt, opcode);
            objFileWriter.Write (method.Name);
            objFileWriter.Write (GetStrFromType (method.ReflectedType));
            ParameterInfo[] parms = method.GetParameters ();
            int nArgs = parms.Length;
            objFileWriter.Write (nArgs);
            for (int i = 0; i < nArgs; i ++) {
                objFileWriter.Write (GetStrFromType (parms[i].ParameterType));
            }
        }

        public void Emit (Token errorAt, OpCode opcode, ConstructorInfo ctor)
        {
            objFileWriter.Write ((byte)ScriptObjWriterCode.EmitCtor);
            WriteOpCode (errorAt, opcode);
            objFileWriter.Write (GetStrFromType (ctor.ReflectedType));
            ParameterInfo[] parms = ctor.GetParameters ();
            int nArgs = parms.Length;
            objFileWriter.Write (nArgs);
            for (int i = 0; i < nArgs; i ++) {
                objFileWriter.Write (GetStrFromType (parms[i].ParameterType));
            }
        }

        public void Emit (Token errorAt, OpCode opcode, double value)
        {
            if (opcode != OpCodes.Ldc_R8) {
                throw new Exception ("bad opcode " + opcode.ToString ());
            }
            objFileWriter.Write ((byte)ScriptObjWriterCode.EmitDouble);
            WriteOpCode (errorAt, opcode);
            objFileWriter.Write (value);
        }

        public void Emit (Token errorAt, OpCode opcode, float value)
        {
            if (opcode != OpCodes.Ldc_R4) {
                throw new Exception ("bad opcode " + opcode.ToString ());
            }
            objFileWriter.Write ((byte)ScriptObjWriterCode.EmitFloat);
            WriteOpCode (errorAt, opcode);
            objFileWriter.Write (value);
        }

        public void Emit (Token errorAt, OpCode opcode, int value)
        {
            objFileWriter.Write ((byte)ScriptObjWriterCode.EmitInteger);
            WriteOpCode (errorAt, opcode);
            objFileWriter.Write (value);
        }

        public void Emit (Token errorAt, OpCode opcode, string value)
        {
            objFileWriter.Write ((byte)ScriptObjWriterCode.EmitString);
            WriteOpCode (errorAt, opcode);
            objFileWriter.Write (value);
        }

        /**
         * @brief Declare that the target of a label is the next instruction.
         */
        public void MarkLabel (ScriptMyLabel myLabel)
        {
            objFileWriter.Write ((byte)ScriptObjWriterCode.MarkLabel);
            objFileWriter.Write (myLabel.number);
        }

        /**
         * @brief Write end-of-file marker to binary file.
         */
        public static void TheEnd (BinaryWriter objFileWriter)
        {
            objFileWriter.Write ((byte)ScriptObjWriterCode.TheEnd);
        }

        /**
         * @brief Take an object file created by ScriptObjWriter() and convert it to a series of dynamic methods.
         * @param sdTypes   = script-defined types
         * @param objReader = where to read object file from (as written by ScriptObjWriter above).
         * @param scriptObjCode.EndMethod = called for each method defined at the end of the methods definition
         * @param objectTokens = write disassemble/decompile data (or null if not wanted)
         */
        public static void CreateObjCode (Dictionary<string, TokenDeclSDType> sdTypes, BinaryReader objReader,
                ScriptObjCode scriptObjCode, ObjectTokens objectTokens)
        {
            Dictionary<string, DynamicMethod> methods = new Dictionary<string, DynamicMethod> ();
            DynamicMethod method = null;
            ILGenerator ilGen = null;
            Dictionary<int, Label> labels = new Dictionary<int, Label> ();
            Dictionary<int, LocalBuilder> locals = new Dictionary<int, LocalBuilder> ();
            Dictionary<int, string> labelNames = new Dictionary<int, string> ();
            Dictionary<int, string> localNames = new Dictionary<int, string> ();
            object[] ilGenArg = new object[1];
            int offset = 0;
            Dictionary<int, ScriptSrcLoc> srcLocs = null;
            string srcFile = "";
            int    srcLine = 0;
            int    srcPosn = 0;

            while (true) {

                /*
                 * Get IL instruction offset at beginning of instruction.
                 */
                offset = 0;
                if ((ilGen != null) && (monoGetCurrentOffset != null)) {
                    offset = (int)monoGetCurrentOffset.Invoke (null, ilGenArg);
                }

                /*
                 * Read and decode next internal format code from input file (.xmrobj file).
                 */
                ScriptObjWriterCode code = (ScriptObjWriterCode)objReader.ReadByte ();
                switch (code) {

                    /*
                     * Reached end-of-file so we are all done.
                     */
                    case ScriptObjWriterCode.TheEnd: {
                        return;
                    }

                    /*
                     * Beginning of method's contents.
                     * Method must have already been declared via DclMethod
                     * so all we need is its name to retrieve from methods[].
                     */
                    case ScriptObjWriterCode.BegMethod: {
                        string methName = objReader.ReadString ();

                        method = methods[methName];
                        ilGen  = method.GetILGenerator ();
                        ilGenArg[0] = ilGen;

                        labels.Clear ();
                        locals.Clear ();
                        labelNames.Clear ();
                        localNames.Clear ();

                        srcLocs = new Dictionary<int, ScriptSrcLoc> ();
                        if (objectTokens != null) objectTokens.BegMethod (method);
                        break;
                    }

                    /*
                     * End of method's contents (ie, an OpCodes.Ret was probably just output).
                     * Call the callback to tell it the method is complete, and it can do whatever
                     * it wants with the method.
                     */
                    case ScriptObjWriterCode.EndMethod: {
                        ilGen = null;
                        ilGenArg[0] = null;
                        scriptObjCode.EndMethod (method, srcLocs);
                        srcLocs = null;
                        if (objectTokens != null) objectTokens.EndMethod ();
                        break;
                    }

                    /*
                     * Declare a label for branching to.
                     */
                    case ScriptObjWriterCode.DclLabel: {
                        int number  = objReader.ReadInt32 ();
                        string name = objReader.ReadString ();

                        labels.Add (number, ilGen.DefineLabel ());
                        labelNames.Add (number, name + "_" + number.ToString ());
                        if (objectTokens != null) objectTokens.DefineLabel (number, name);
                        break;
                    }

                    /*
                     * Declare a local variable to store into.
                     */
                    case ScriptObjWriterCode.DclLocal: {
                        int number  = objReader.ReadInt32 ();
                        string name = objReader.ReadString ();
                        string type = objReader.ReadString ();
                        Type syType = GetTypeFromStr (sdTypes, type);

                        locals.Add (number, ilGen.DeclareLocal (syType));
                        localNames.Add (number, name + "_" + number.ToString ());
                        if (objectTokens != null) objectTokens.DefineLocal (number, name, type, syType);
                        break;
                    }

                    /*
                     * Declare a method that will subsequently be defined.
                     * We create the DynamicMethod object at this point in case there
                     * are forward references from other method bodies.
                     */
                    case ScriptObjWriterCode.DclMethod: {
                        string methName = objReader.ReadString ();
                        Type retType    = GetTypeFromStr (sdTypes, objReader.ReadString ());
                        int nArgs       = objReader.ReadInt32 ();

                        Type[] argTypes = new Type[nArgs];
                        string[] argNames = new string[nArgs];
                        for (int i = 0; i < nArgs; i ++) {
                            argTypes[i] = GetTypeFromStr (sdTypes, objReader.ReadString ());
                            argNames[i] = objReader.ReadString ();
                        }
                        methods.Add (methName, new DynamicMethod (methName, retType, argTypes));
                        if (objectTokens != null) objectTokens.DefineMethod (methName, retType, argTypes, argNames);
                        break;
                    }

                    /*
                     * Mark a previously declared label at this spot.
                     */
                    case ScriptObjWriterCode.MarkLabel: {
                        int number = objReader.ReadInt32 ();

                        ilGen.MarkLabel (labels[number]);

                        if (objectTokens != null) objectTokens.MarkLabel (offset, number);
                        break;
                    }

                    /*
                     * Try/Catch blocks.
                     */
                    case ScriptObjWriterCode.BegExcBlk: {
                        ilGen.BeginExceptionBlock ();
                        if (objectTokens != null) objectTokens.BegExcBlk (offset);
                        break;
                    }

                    case ScriptObjWriterCode.BegCatBlk: {
                        Type excType = GetTypeFromStr (sdTypes, objReader.ReadString ());
                        ilGen.BeginCatchBlock (excType);
                        if (objectTokens != null) objectTokens.BegCatBlk (offset, excType);
                        break;
                    }

                    case ScriptObjWriterCode.BegFinBlk: {
                        ilGen.BeginFinallyBlock ();
                        if (objectTokens != null) objectTokens.BegFinBlk (offset);
                        break;
                    }

                    case ScriptObjWriterCode.EndExcBlk: {
                        ilGen.EndExceptionBlock ();
                        if (objectTokens != null) objectTokens.EndExcBlk (offset);
                        break;
                    }

                    /*
                     * Emit an opcode with no operand.
                     */
                    case ScriptObjWriterCode.EmitNull: {
                        OpCode opCode = ReadOpCode (objReader, ref srcFile, ref srcLine, ref srcPosn);

                        SaveSrcLoc (srcLocs, offset, srcFile, srcLine, srcPosn);
                        ilGen.Emit (opCode);

                        if (objectTokens != null) objectTokens.EmitNull (offset, opCode);
                        break;
                    }

                    /*
                     * Emit an opcode with a FieldInfo operand.
                     */
                    case ScriptObjWriterCode.EmitField: {
                        OpCode opCode      = ReadOpCode (objReader, ref srcFile, ref srcLine, ref srcPosn);
                        Type reflectedType = GetTypeFromStr (sdTypes, objReader.ReadString ());
                        string fieldName   = objReader.ReadString ();

                        FieldInfo field    = reflectedType.GetField (fieldName);
                        SaveSrcLoc (srcLocs, offset, srcFile, srcLine, srcPosn);
                        ilGen.Emit (opCode, field);

                        if (objectTokens != null) objectTokens.EmitField (offset, opCode, field);
                        break;
                    }

                    /*
                     * Emit an opcode with a LocalBuilder operand.
                     */
                    case ScriptObjWriterCode.EmitLocal: {
                        OpCode opCode = ReadOpCode (objReader, ref srcFile, ref srcLine, ref srcPosn);
                        int number    = objReader.ReadInt32 ();
                        SaveSrcLoc (srcLocs, offset, srcFile, srcLine, srcPosn);
                        ilGen.Emit (opCode, locals[number]);

                        if (objectTokens != null) objectTokens.EmitLocal (offset, opCode, number);
                        break;
                    }

                    /*
                     * Emit an opcode with a Type operand.
                     */
                    case ScriptObjWriterCode.EmitType: {
                        OpCode opCode = ReadOpCode (objReader, ref srcFile, ref srcLine, ref srcPosn);
                        string name   = objReader.ReadString ();
                        Type type     = GetTypeFromStr (sdTypes, name);

                        SaveSrcLoc (srcLocs, offset, srcFile, srcLine, srcPosn);
                        ilGen.Emit (opCode, type);

                        if (objectTokens != null) objectTokens.EmitType (offset, opCode, type);
                        break;
                    }

                    /*
                     * Emit an opcode with a Label operand.
                     */
                    case ScriptObjWriterCode.EmitLabel: {
                        OpCode opCode = ReadOpCode (objReader, ref srcFile, ref srcLine, ref srcPosn);
                        int number    = objReader.ReadInt32 ();

                        SaveSrcLoc (srcLocs, offset, srcFile, srcLine, srcPosn);
                        ilGen.Emit (opCode, labels[number]);

                        if (objectTokens != null) objectTokens.EmitLabel (offset, opCode, number);
                        break;
                    }

                    /*
                     * Emit an opcode with a Label array operand.
                     */
                    case ScriptObjWriterCode.EmitLabels: {
                        OpCode opCode = ReadOpCode (objReader, ref srcFile, ref srcLine, ref srcPosn);
                        int nLabels   = objReader.ReadInt32 ();
                        Label[] lbls  = new Label[nLabels];
                        int[] nums    = new int[nLabels];
                        for (int i = 0; i < nLabels; i ++) {
                            nums[i] = objReader.ReadInt32 ();
                            lbls[i] = labels[nums[i]];
                        }

                        SaveSrcLoc (srcLocs, offset, srcFile, srcLine, srcPosn);
                        ilGen.Emit (opCode, lbls);

                        if (objectTokens != null) objectTokens.EmitLabels (offset, opCode, nums);
                        break;
                    }

                    /*
                     * Emit an opcode with a MethodInfo operand (such as a call) of an external function.
                     */
                    case ScriptObjWriterCode.EmitMethodExt: {
                        OpCode opCode   = ReadOpCode (objReader, ref srcFile, ref srcLine, ref srcPosn);
                        string methName = objReader.ReadString ();
                        Type methType   = GetTypeFromStr (sdTypes, objReader.ReadString ());
                        int nArgs       = objReader.ReadInt32 ();

                        Type[] argTypes = new Type[nArgs];
                        for (int i = 0; i < nArgs; i ++) {
                            argTypes[i] = GetTypeFromStr (sdTypes, objReader.ReadString ());
                        }
                        MethodInfo methInfo = methType.GetMethod (methName, argTypes);
                        SaveSrcLoc (srcLocs, offset, srcFile, srcLine, srcPosn);
                        ilGen.Emit (opCode, methInfo);

                        if (objectTokens != null) objectTokens.EmitMethod (offset, opCode, methInfo);
                        break;
                    }

                    /*
                     * Emit an opcode with a MethodInfo operand of an internal function
                     * (previously declared via DclMethod).
                     */
                    case ScriptObjWriterCode.EmitMethodInt: {
                        OpCode opCode   = ReadOpCode (objReader, ref srcFile, ref srcLine, ref srcPosn);
                        string methName = objReader.ReadString ();

                        MethodInfo methInfo = methods[methName];
                        SaveSrcLoc (srcLocs, offset, srcFile, srcLine, srcPosn);
                        ilGen.Emit (opCode, methInfo);

                        if (objectTokens != null) objectTokens.EmitMethod (offset, opCode, methInfo);
                        break;
                    }

                    /*
                     * Emit an opcode with a ConstructorInfo operand.
                     */
                    case ScriptObjWriterCode.EmitCtor: {
                        OpCode opCode   = ReadOpCode (objReader, ref srcFile, ref srcLine, ref srcPosn);
                        Type ctorType   = GetTypeFromStr (sdTypes, objReader.ReadString ());
                        int nArgs       = objReader.ReadInt32 ();
                        Type[] argTypes = new Type[nArgs];
                        for (int i = 0; i < nArgs; i ++) {
                            argTypes[i] = GetTypeFromStr (sdTypes, objReader.ReadString ());
                        }

                        ConstructorInfo ctorInfo = ctorType.GetConstructor (argTypes);
                        SaveSrcLoc (srcLocs, offset, srcFile, srcLine, srcPosn);
                        ilGen.Emit (opCode, ctorInfo);

                        if (objectTokens != null) objectTokens.EmitCtor (offset, opCode, ctorInfo);
                        break;
                    }

                    /*
                     * Emit an opcode with a constant operand of various types.
                     */
                    case ScriptObjWriterCode.EmitDouble: {
                        OpCode opCode = ReadOpCode (objReader, ref srcFile, ref srcLine, ref srcPosn);
                        double value  = objReader.ReadDouble ();

                        if (opCode != OpCodes.Ldc_R8) {
                            throw new Exception ("bad opcode " + opCode.ToString ());
                        }
                        SaveSrcLoc (srcLocs, offset, srcFile, srcLine, srcPosn);
                        ilGen.Emit (opCode, value);

                        if (objectTokens != null) objectTokens.EmitDouble (offset, opCode, value);
                        break;
                    }

                    case ScriptObjWriterCode.EmitFloat: {
                        OpCode opCode = ReadOpCode (objReader, ref srcFile, ref srcLine, ref srcPosn);
                        float value   = objReader.ReadSingle ();

                        if (opCode != OpCodes.Ldc_R4) {
                            throw new Exception ("bad opcode " + opCode.ToString ());
                        }
                        SaveSrcLoc (srcLocs, offset, srcFile, srcLine, srcPosn);
                        ilGen.Emit (opCode, value);

                        if (objectTokens != null) objectTokens.EmitFloat (offset, opCode, value);
                        break;
                    }

                    case ScriptObjWriterCode.EmitInteger: {
                        OpCode opCode = ReadOpCode (objReader, ref srcFile, ref srcLine, ref srcPosn);
                        int value     = objReader.ReadInt32 ();

                        SaveSrcLoc (srcLocs, offset, srcFile, srcLine, srcPosn);

                        if (opCode == OpCodes.Ldc_I4) {
                            if ((value >= -1) && (value <= 8)) {
                                opCode = opCodesLdcI4M1P8[value+1];
                                ilGen.Emit (opCode);
                                if (objectTokens != null) objectTokens.EmitNull (offset, opCode);
                                break;
                            }
                            if ((value >= 0) && (value <= 127)) {
                                opCode = OpCodes.Ldc_I4_S;
                                ilGen.Emit (OpCodes.Ldc_I4_S, (sbyte)value);
                                goto pemitint;
                            }
                        }

                        ilGen.Emit (opCode, value);
                        pemitint:
                        if (objectTokens != null) objectTokens.EmitInteger (offset, opCode, value);
                        break;
                    }

                    case ScriptObjWriterCode.EmitString: {
                        OpCode opCode = ReadOpCode (objReader, ref srcFile, ref srcLine, ref srcPosn);
                        string value  = objReader.ReadString ();

                        SaveSrcLoc (srcLocs, offset, srcFile, srcLine, srcPosn);
                        ilGen.Emit (opCode, value);

                        if (objectTokens != null) objectTokens.EmitString (offset, opCode, value);
                        break;
                    }

                    /*
                     * Who knows what?
                     */
                    default: throw new Exception ("bad ScriptObjWriterCode " + ((byte)code).ToString ());
                }
            }
        }

        /**
         * @brief Generate array to quickly translate OpCode.Value to full OpCode struct.
         */
        private static Dictionary<short, OpCode> PopulateOpCodes ()
        {
            Dictionary<short, OpCode> opCodeDict = new Dictionary<short, OpCode> ();
            FieldInfo[] fields = typeof (OpCodes).GetFields ();
            for (int i = 0; i < fields.Length; i ++) {
                OpCode opcode = (OpCode)fields[i].GetValue (null);
                opCodeDict.Add (opcode.Value, opcode);
            }
            return opCodeDict;
        }

        /**
         * @brief Write opcode out to file.
         */
        private void WriteOpCode (Token errorAt, OpCode opcode)
        {
            if (errorAt == null) {
                objFileWriter.Write ("");
                objFileWriter.Write (lastErrorAtLine);
                objFileWriter.Write (lastErrorAtPosn);
            } else {
                if (errorAt.file != lastErrorAtFile) {
                    objFileWriter.Write (errorAt.file);
                    lastErrorAtFile = errorAt.file;
                } else {
                    objFileWriter.Write ("");
                }
                objFileWriter.Write (errorAt.line);
                objFileWriter.Write (errorAt.posn);
                lastErrorAtLine = errorAt.line;
                lastErrorAtPosn = errorAt.posn;
            }
            objFileWriter.Write (opcode.Value);
        }

        /**
         * @brief Read opcode in from file.
         */
        private static OpCode ReadOpCode (BinaryReader objReader, ref string srcFile, ref int srcLine, ref int srcPosn)
        {
            string f = objReader.ReadString ();
            if (f != "") srcFile = f;
            srcLine = objReader.ReadInt32 ();
            srcPosn = objReader.ReadInt32 ();

            short value = objReader.ReadInt16 ();
            return opCodes[value];
        }

        /**
         * @brief Save an IL_offset -> source location translation entry
         * @param srcLocs = saved entries for the current function
         * @param offset = offset in IL object code for next instruction
         * @param src{File,Line,Posn} = location in source file corresponding to opcode
         * @returns with entry added to srcLocs
         */
        private static void SaveSrcLoc (Dictionary<int, ScriptSrcLoc> srcLocs, int offset, string srcFile, int srcLine, int srcPosn)
        {
            ScriptSrcLoc srcLoc = new ScriptSrcLoc ();
            srcLoc.file = srcFile;
            srcLoc.line = srcLine;
            srcLoc.posn = srcPosn;
            srcLocs[offset] = srcLoc;
        }

        /**
         * @brief Create type<->string conversions.
         *        Using Type.AssemblyQualifiedName is horribly inefficient
         *        and all our types should be known.
         */
        private static Dictionary<string, Type> PopulateS2T ()
        {
            Dictionary<string, Type> s2t = new Dictionary<string, Type> ();

            s2t.Add ("badcallx", typeof (ScriptBadCallNoException));
            s2t.Add ("binopstr", typeof (BinOpStr));
            s2t.Add ("bool",     typeof (bool));
            s2t.Add ("char",     typeof (char));
            s2t.Add ("delegate", typeof (Delegate));
            s2t.Add ("delarr[]", typeof (Delegate[]));
            s2t.Add ("double",   typeof (double));
            s2t.Add ("exceptn",  typeof (Exception));
            s2t.Add ("float",    typeof (float));
            s2t.Add ("htlist",   typeof (HeapTrackerList));
            s2t.Add ("htobject", typeof (HeapTrackerObject));
            s2t.Add ("htstring", typeof (HeapTrackerString));
            s2t.Add ("inlfunc",  typeof (CompValuInline));
            s2t.Add ("int",      typeof (int));
            s2t.Add ("int*",     typeof (int).MakeByRefType ());
            s2t.Add ("intrlokd", typeof (System.Threading.Interlocked));
            s2t.Add ("lslfloat", typeof (LSL_Float));
            s2t.Add ("lslint",   typeof (LSL_Integer));
            s2t.Add ("lsllist",  typeof (LSL_List));
            s2t.Add ("lslrot",   typeof (LSL_Rotation));
            s2t.Add ("lslstr",   typeof (LSL_String));
            s2t.Add ("lslvec",   typeof (LSL_Vector));
            s2t.Add ("math",     typeof (Math));
            s2t.Add ("midround", typeof (MidpointRounding));
            s2t.Add ("object",   typeof (object));
            s2t.Add ("object*",  typeof (object).MakeByRefType ());
            s2t.Add ("object[]", typeof (object[]));
            s2t.Add ("scrbase",  typeof (ScriptBaseClass));
            s2t.Add ("scrcode",  typeof (ScriptCodeGen));
            s2t.Add ("sdtclobj", typeof (XMRSDTypeClObj));
            s2t.Add ("string",   typeof (string));
            s2t.Add ("typecast", typeof (TypeCast));
            s2t.Add ("undstatx", typeof (ScriptUndefinedStateException));
            s2t.Add ("void",     typeof (void));
            s2t.Add ("xmrarray", typeof (XMR_Array));
            s2t.Add ("xmrinst",  typeof (XMRInstAbstract));

            return s2t;
        }

        private static Dictionary<Type, string> PopulateT2S ()
        {
            Dictionary<string, Type> s2t = PopulateS2T ();
            Dictionary<Type, string> t2s = new Dictionary<Type, string> ();
            foreach (KeyValuePair<string, Type> kvp in s2t) {
                t2s.Add (kvp.Value, kvp.Key);
            }
            return t2s;
        }

        /**
         * @brief Add to list of internally recognized types.
         */
        public static void DefineInternalType (string name, Type type)
        {
            if (!string2Type.ContainsKey(name))
            {
                string2Type.Add (name, type);
                type2String.Add (type, name);
            }
        }

        private string GetStrFromType (Type t)
        {
            string s = GetStrFromTypeWork (t);
            return s;
        }
        private string GetStrFromTypeWork (Type t)
        {
            string s;

            // internal fixed types like int and xmrarray etc
            if (type2String.TryGetValue (t, out s)) return s;

            // script-defined types
            if (sdTypesRev.TryGetValue (t, out s)) return "sdt$" + s;

            // inline function types
            s = TokenDeclSDTypeDelegate.TryGetInlineName (t);
            if (s != null) return s;

            // last resort
            return t.AssemblyQualifiedName;
        }

        private static Type GetTypeFromStr (Dictionary<string, TokenDeclSDType> sdTypes, string s)
        {
            Type t;

            // internal fixed types like int and xmrarray etc
            if (string2Type.TryGetValue (s, out t)) return t;

            // script-defined types
            if (s.StartsWith ("sdt$")) return sdTypes[s.Substring(4)].GetSysType ();

            // inline function types
            t = TokenDeclSDTypeDelegate.TryGetInlineSysType (s);
            if (t != null) return t;

            // last resort
            return Type.GetType (s, true);
        }
    }

    public class ScriptSrcLoc {
        public string file;
        public int line;
        public int posn;
    }
}