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

1 files changed, 1040 insertions, 0 deletions

diff --git a/OpenSim/Region/ScriptEngine/YEngine/MMRScriptObjWriter.cs b/OpenSim/Region/ScriptEngine/YEngine/MMRScriptObjWriter.cs
new file mode 100644
index 0000000..b87bc72
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/YEngine/MMRScriptObjWriter.cs
@@ -0,0 +1,1040 @@
+/*
+ * 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.Yengine
+{
+    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;
+    }
+}