/*
 * 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 OpenSim.Region.ScriptEngine.XMREngine;
using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using System.Reflection.Emit;

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 Compute values used during code generation to keep track of where computed values are stored.
 *
 *        Conceptually holds the memory address and type of the value
 *        such as that used for a local variable, global variable, temporary variable.
 *        Also used for things like constants and function/method entrypoints,
 *        they are basically treated as read-only variables.
 *
 *            cv.type - type of the value
 *
 *            cv.PushVal() - pushes the value on the CIL stack
 *            cv.PushRef() - pushes address of the value on the CIL stack
 *
 *            cv.PopPre()  - gets ready to pop from the CIL stack
 *                           ...by possibly pushing something
 *                <push value to be popped>
 *            cv.PushPre() - pops value from the CIL stack
 *
 *        If the type is a TokenTypeSDTypeDelegate, the location is callable, 
 *        so you get these additional functions:
 *
 *            cv.GetRetType()  - gets function/method's return value type
 *                               TokenTypeVoid if void
 *                               null if not a delegate
 *            cv.GetArgTypes() - gets array of argument types
 *                               as seen by script level, ie, 
 *                               does not include any hidden 'this' type
 *            cv.GetArgSig()   - gets argument signature eg, "(integer,list)"
 *                               null if not a delegate
 *
 *            cv.CallPre()     - gets ready to call the function/method
 *                               ...by possibly pushing something
 *                                  such as a 'this' pointer
 *                <push call args left-to-right>
 *            cv.CallPost()    - calls the function/method
 */

namespace OpenSim.Region.ScriptEngine.XMREngine
{

    /**
     * @brief Location of a value
     *        Includes constants, expressions and temp variables.
     */
    public abstract class CompValu {
        protected static readonly MethodInfo gsmdMethodInfo = 
                typeof (XMRInstAbstract).GetMethod ("GetScriptMethodDelegate", 
                                                    new Type[] { typeof (string), typeof (string), typeof (object) });

        private static readonly MethodInfo avpmListMethInfo   = typeof (XMRInstArrays).GetMethod ("PopList",   new Type[] { typeof (int), typeof (LSL_List) });
        private static readonly MethodInfo avpmObjectMethInfo = typeof (XMRInstArrays).GetMethod ("PopObject", new Type[] { typeof (int), typeof (object) });
        private static readonly MethodInfo avpmStringMethInfo = typeof (XMRInstArrays).GetMethod ("PopString", new Type[] { typeof (int), typeof (string) });

        public TokenType type;        // type of the value and where in the source it was used

        public CompValu (TokenType type)
        {
            this.type = type;
        }

        public Type ToSysType()
        {
            return (type.ToLSLWrapType () != null) ? type.ToLSLWrapType () : type.ToSysType ();
        }

        // if a field of an XMRInstArrays array cannot be directly written,
        // get the method that can write it
        private static MethodInfo ArrVarPopMeth (FieldInfo fi)
        {
            if (fi.Name == "iarLists")   return avpmListMethInfo;
            if (fi.Name == "iarObjects") return avpmObjectMethInfo;
            if (fi.Name == "iarStrings") return avpmStringMethInfo;
            return null;
        }

        // emit code to push value onto stack
        public void PushVal (ScriptCodeGen scg, Token errorAt, TokenType stackType)
        {
            this.PushVal (scg, errorAt, stackType, false);
        }
        public void PushVal (ScriptCodeGen scg, Token errorAt, TokenType stackType, bool explicitAllowed)
        {
            this.PushVal (scg, errorAt);
            TypeCast.CastTopOfStack (scg, errorAt, this.type, stackType, explicitAllowed);
        }
        public abstract void PushVal (ScriptCodeGen scg, Token errorAt);
        public abstract void PushRef (ScriptCodeGen scg, Token errorAt);

        // emit code to pop value from stack
        public void PopPost (ScriptCodeGen scg, Token errorAt, TokenType stackType)
        {
            TypeCast.CastTopOfStack (scg, errorAt, stackType, this.type, false);
            this.PopPost (scg, errorAt);
        }
        public virtual void PopPre (ScriptCodeGen scg, Token errorAt) { }  // call this before pushing value to be popped
        public abstract void PopPost (ScriptCodeGen scg, Token errorAt);   // call this after pushing value to be popped

        // return true: doing a PushVal() does not involve CheckRun()
        //       false: otherwise
        public virtual bool IsReadTrivial (ScriptCodeGen scg, Token readAt)
        {
            return true;
        }

        /*
         * These additional functions are available if the type is a delegate
         */
        public TokenType GetRetType ()
        {
            if (!(type is TokenTypeSDTypeDelegate)) return null;
            return ((TokenTypeSDTypeDelegate)type).decl.GetRetType ();
        }
        public TokenType[] GetArgTypes ()
        {
            if (!(type is TokenTypeSDTypeDelegate)) return null;
            return ((TokenTypeSDTypeDelegate)type).decl.GetArgTypes ();
        }
        public string GetArgSig ()
        {
            if (!(type is TokenTypeSDTypeDelegate)) return null;
            return ((TokenTypeSDTypeDelegate)type).decl.GetArgSig ();
        }

        // These are used only if type is a delegate too
        // - but it is a real delegate pointer in a global or local variable or a field, etc
        //   ie, PushVal() pushes a delegate pointer
        // - so we must have CallPre() push the delegate pointer as a 'this' for this.Invoke(...)
        // - and CallPost() call the delegate's Invoke() method
        // - we assume the target function is non-trivial so we always use a call label
        public virtual void CallPre (ScriptCodeGen scg, Token errorAt)   // call this before pushing arguments
        {
            new ScriptCodeGen.CallLabel (scg, errorAt);
            this.PushVal (scg, errorAt);
        }
        public virtual void CallPost (ScriptCodeGen scg, Token errorAt)  // call this after pushing arguments
        {
            TokenTypeSDTypeDelegate ttd = (TokenTypeSDTypeDelegate)type;
            MethodInfo invokeMethodInfo = ttd.decl.GetInvokerInfo ();
            scg.ilGen.Emit (errorAt, OpCodes.Callvirt, invokeMethodInfo);
            scg.openCallLabel = null;
        }

        /*
         * Utilities used by CompValuGlobalVar and CompValuInstField
         * where the value is located in a type-dependent array.
         */
        protected void EmitFieldPushVal (ScriptCodeGen scg, Token errorAt, TokenDeclVar var)
        {
            scg.ilGen.Emit (errorAt, OpCodes.Ldfld, var.vTableArray);   // which array
            scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4, var.vTableIndex);  // which array element
            if (type is TokenTypeFloat) {
                scg.ilGen.Emit (errorAt, OpCodes.Ldelem_R8);
            } else if (type is TokenTypeInt) {
                scg.ilGen.Emit (errorAt, OpCodes.Ldelem_I4);
            } else if (type is TokenTypeSDTypeDelegate) {
                scg.ilGen.Emit (errorAt, OpCodes.Ldelem, typeof (object));
                scg.ilGen.Emit (errorAt, OpCodes.Castclass, ToSysType ());
            } else {
                scg.ilGen.Emit (errorAt, OpCodes.Ldelem, ToSysType ());
            }
        }

        protected void EmitFieldPushRef (ScriptCodeGen scg, Token errorAt, TokenDeclVar var)
        {
            if (ArrVarPopMeth (var.vTableArray) != null) {
                scg.ErrorMsg (errorAt, "can't take address of this variable");
            }
            scg.ilGen.Emit (errorAt, OpCodes.Ldfld, var.vTableArray);
            scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4, var.vTableIndex);
            scg.ilGen.Emit (errorAt, OpCodes.Ldelema, ToSysType());
        }

        protected void EmitFieldPopPre (ScriptCodeGen scg, Token errorAt, TokenDeclVar var)
        {
            if (ArrVarPopMeth (var.vTableArray) != null) {
                scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4, var.vTableIndex);
            } else {
                scg.ilGen.Emit (errorAt, OpCodes.Ldfld, var.vTableArray);
                scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4, var.vTableIndex);
            }
        }

        protected void EmitFieldPopPost (ScriptCodeGen scg, Token errorAt, TokenDeclVar var)
        {
            if (ArrVarPopMeth (var.vTableArray) != null) {
                scg.ilGen.Emit (errorAt, OpCodes.Call, ArrVarPopMeth (var.vTableArray));
            } else if (type is TokenTypeFloat) {
                scg.ilGen.Emit (errorAt, OpCodes.Stelem_R8);
            } else if (type is TokenTypeInt) {
                scg.ilGen.Emit (errorAt, OpCodes.Stelem_I4);
            } else if (type is TokenTypeSDTypeDelegate) {
                scg.ilGen.Emit (errorAt, OpCodes.Stelem, typeof (object));
            } else {
                scg.ilGen.Emit (errorAt, OpCodes.Stelem, ToSysType ());
            }
        }

        /**
         * @brief With value pushed on stack, emit code to set a property by calling its setter() method.
         * @param scg = which script is being compiled
         * @param errorAt = for error messages
         * @param type = property type
         * @param setProp = setter() method
         */
        protected void EmitPopPostProp (ScriptCodeGen scg, Token errorAt, TokenType type, CompValu setProp)
        {
            ScriptMyLocal temp = scg.ilGen.DeclareLocal (type.ToSysType (), "__spr_" + errorAt.Unique);
            scg.ilGen.Emit   (errorAt, OpCodes.Stloc, temp);
            setProp.CallPre  (scg, errorAt);
            scg.ilGen.Emit   (errorAt, OpCodes.Ldloc, temp);
            setProp.CallPost (scg, errorAt);
        }
    }

    // The value is kept in an (XMR_Array) array element
    public class CompValuArEle : CompValu {
        public  CompValu arr;
        private CompValu idx;
        private TokenTypeObject tto;

        private static readonly MethodInfo getByKeyMethodInfo = typeof (XMR_Array).GetMethod ("GetByKey", 
                                                                                              new Type[] { typeof (object) });
        private static readonly MethodInfo setByKeyMethodInfo = typeof (XMR_Array).GetMethod ("SetByKey", 
                                                                                              new Type[] { typeof (object),
                                                                                                           typeof (object) });

        // type = TokenTypeObject always, as our array elements are always of type 'object'
        // arr  = where the array object itself is stored
        // idx  = where the index value is stored
        public CompValuArEle (TokenType type, CompValu arr, CompValu idx) : base (type)
        {
            this.arr = arr;
            this.idx = idx;
            this.tto = new TokenTypeObject (this.type);
        }
        public override void PushVal (ScriptCodeGen scg, Token errorAt)
        {
            arr.PushVal (scg, errorAt);   // array
            idx.PushVal (scg, errorAt, this.tto);  // key
            scg.ilGen.Emit (errorAt, OpCodes.Call, getByKeyMethodInfo);
        }
        public override void PushRef (ScriptCodeGen scg, Token errorAt)
        {
            scg.ErrorMsg (errorAt, "array element not allowed here");
            scg.ilGen.Emit (errorAt, OpCodes.Ldnull);
        }
        public override void PopPre (ScriptCodeGen scg, Token errorAt)
        {
            arr.PushVal (scg, errorAt);            // array
            idx.PushVal (scg, errorAt, this.tto);  // key
        }
        public override void PopPost (ScriptCodeGen scg, Token errorAt)
        {
            scg.ilGen.Emit (errorAt, OpCodes.Call, setByKeyMethodInfo);
        }

        // non-trivial because it needs to be copied into a temp
        // in case the idiot does dumb-ass side effects tricks
        //   eg,  (x = 0) + x + 2
        //   should read old value of x not 0
        // but if 'xmroption norighttoleft;' in effect,
        // we can read it in any order so reading an
        // XMR_Array element is trivial
        public override bool IsReadTrivial (ScriptCodeGen scg, Token readAt)
        {
            return readAt.nr2l;
        }
    }

    // The value is kept in the current function's argument list
    public class CompValuArg : CompValu {
        public int index;
        public bool readOnly;

        private static OpCode[] ldargs = { OpCodes.Ldarg_0, OpCodes.Ldarg_1, 
                                           OpCodes.Ldarg_2, OpCodes.Ldarg_3 };

        public CompValuArg (TokenType type, int index) : base (type)
        {
            this.index = index;
        }
        public CompValuArg (TokenType type, int index, bool ro) : base (type)
        {
            this.index = index;
            this.readOnly = ro;
        }
        public override void PushVal (ScriptCodeGen scg, Token errorAt)
        {
                 if (index < ldargs.Length) scg.ilGen.Emit (errorAt, ldargs[index]);
            else if (index <= 255) scg.ilGen.Emit (errorAt, OpCodes.Ldarg_S, index);
                                else scg.ilGen.Emit (errorAt, OpCodes.Ldarg, index);
        }
        public override void PushRef (ScriptCodeGen scg, Token errorAt)
        {
            if (readOnly) {
                scg.ErrorMsg (errorAt, "location cannot be written to");
            }
            if (index <= 255) scg.ilGen.Emit (errorAt, OpCodes.Ldarga_S, index);
                           else scg.ilGen.Emit (errorAt, OpCodes.Ldarga, index);
        }
        public override void PopPost (ScriptCodeGen scg, Token errorAt)
        {
            if (readOnly) {
                scg.ErrorMsg (errorAt, "location cannot be written to");
            }
            scg.ilGen.Emit (errorAt, OpCodes.Starg, index);
        }

        // non-trivial because it needs to be copied into a temp
        // in case the idiot does dumb-ass side effects tricks
        //   eg,  (x = 0) + x + 2
        //   should read old value of x not 0
        // but if 'xmroption norighttoleft;' in effect,
        // we can read it in any order so reading an
        // argument is trivial
        public override bool IsReadTrivial (ScriptCodeGen scg, Token readAt)
        {
            return readAt.nr2l;
        }
    }

    // The value is a character constant
    public class CompValuChar : CompValu {
        public char x;

        public CompValuChar (TokenType type, char x) : base (type)
        {
            if (!(this.type is TokenTypeChar)) {
                this.type = new TokenTypeChar (this.type);
            }
            this.x = x;
        }
        public override void PushVal (ScriptCodeGen scg, Token errorAt)
        {
            scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4, (int)x);
        }
        public override void PushRef (ScriptCodeGen scg, Token errorAt)
        {
            throw new Exception ("cannot get constant's address");
        }
        public override void PopPost (ScriptCodeGen scg, Token errorAt)
        {
            throw new Exception ("cannot store into contant");
        }
    }

    // The value is kept in a struct/class field of an internal struct/class
    public class CompValuField : CompValu {
        CompValu obj;
        FieldInfo field;

        public CompValuField (TokenType type, CompValu obj, FieldInfo field) : base (type)
        {
            this.obj   = obj;
            this.field = field;
        }
        public override void PushVal (ScriptCodeGen scg, Token errorAt)
        {
            if (field.ReflectedType.IsValueType) {
                obj.PushRef (scg, errorAt);
            } else {
                obj.PushVal (scg, errorAt);
            }
            scg.ilGen.Emit (errorAt, OpCodes.Ldfld, field);
        }
        public override void PushRef (ScriptCodeGen scg, Token errorAt)
        {
            if (field.ReflectedType.IsValueType) {
                obj.PushRef (scg, errorAt);
            } else {
                obj.PushVal (scg, errorAt);
            }
            scg.ilGen.Emit (errorAt, OpCodes.Ldflda, field);
        }
        public override void PopPre (ScriptCodeGen scg, Token errorAt)
        {
            if (field.ReflectedType.IsValueType) {
                obj.PushRef (scg, errorAt);
            } else {
                obj.PushVal (scg, errorAt);
            }
        }
        public override void PopPost (ScriptCodeGen scg, Token errorAt)
        {
            scg.ilGen.Emit (errorAt, OpCodes.Stfld, field);
        }

        // non-trivial because it needs to be copied into a temp
        // in case the idiot does dumb-ass side effects tricks
        //   eg,  (x = 0) + x + 2
        //   should read old value of x not 0
        // but if 'xmroption norighttoleft;' in effect,
        // we can read it in any order so reading an
        // field of a class/struct is trivial
        public override bool IsReadTrivial (ScriptCodeGen scg, Token readAt)
        {
            return readAt.nr2l;
        }
    }

    // Accessing an element of a fixed-dimension array
    public class CompValuFixArEl : CompValu {
        private CompValu   baseRVal;
        private CompValu[] subRVals;

        private int nSubs;
        private TokenDeclVar getFunc;
        private TokenDeclVar setFunc;
        private TokenTypeInt tokenTypeInt;

        /**
         * @brief Set up to access an element of an array.
         * @param scg = what script we are compiling
         * @param baseRVal = what array we are accessing
         * @param subRVals = the subscripts being applied
         */
        public CompValuFixArEl (ScriptCodeGen scg, CompValu baseRVal, CompValu[] subRVals) : base (GetElementType (scg, baseRVal, subRVals))
        {
            this.baseRVal = baseRVal;  // location of the array itself
            this.subRVals = subRVals;  // subscript values
            this.nSubs    = subRVals.Length;

            TokenTypeSDTypeClass sdtType = (TokenTypeSDTypeClass)baseRVal.type;
            TokenDeclSDTypeClass sdtDecl = sdtType.decl;
            tokenTypeInt = new TokenTypeInt (sdtType);

            TokenName name = new TokenName (sdtType, "Get");
            TokenType[] argsig = new TokenType[nSubs];
            for (int i = 0; i < nSubs; i ++) {
                argsig[i] = tokenTypeInt;
            }
            getFunc = scg.FindThisMember (sdtDecl, name, argsig);

            name = new TokenName (sdtType, "Set");
            argsig = new TokenType[nSubs+1];
            for (int i = 0; i < nSubs; i ++) {
                argsig[i] = tokenTypeInt;
            }
            argsig[nSubs] = getFunc.retType;
            setFunc = scg.FindThisMember (sdtDecl, name, argsig);
        }

        /**
         * @brief Read array element and push value on stack.
         */
        public override void PushVal (ScriptCodeGen scg, Token errorAt)
        {
            // call script-defined class' Get() method to fetch the value
            baseRVal.PushVal (scg, errorAt);
            for (int i = 0; i < nSubs; i ++) {
                subRVals[i].PushVal (scg, errorAt, tokenTypeInt);
            }
            scg.ilGen.Emit (errorAt, OpCodes.Call, getFunc.ilGen);
        }

        /**
         * @brief Push address of array element on stack.
         */
        public override void PushRef (ScriptCodeGen scg, Token errorAt)
        {
            throw new Exception ("tu stOOpid to get array element address");
        }

        /**
         * @brief Prepare to write array element.
         */
        public override void PopPre (ScriptCodeGen scg, Token errorAt)
        {
            // set up call to script-defined class' Set() method to write the value
            baseRVal.PushVal (scg, errorAt);
            for (int i = 0; i < nSubs; i ++) {
                subRVals[i].PushVal (scg, errorAt, tokenTypeInt);
            }
        }

        /**
         * @brief Pop value from stack and write array element.
         */
        public override void PopPost (ScriptCodeGen scg, Token errorAt)
        {
            // call script-defined class' Set() method to write the value
            scg.ilGen.Emit (errorAt, OpCodes.Call, setFunc.ilGen);
        }

        /**
         * @brief Get the array element type by getting the Get() functions return type.
         *        Crude but effective.
         * @param scg = what script we are compiling
         * @param baseRVal = what array we are accessing
         * @param subRVals = the subscripts being applied
         * @returns array element type
         */
        private static TokenType GetElementType (ScriptCodeGen scg, CompValu baseRVal, CompValu[] subRVals)
        {
            TokenTypeSDTypeClass sdtType = (TokenTypeSDTypeClass)baseRVal.type;
            TokenDeclSDTypeClass sdtDecl = sdtType.decl;
            TokenName name = new TokenName (sdtType, "Get");
            int nSubs = subRVals.Length;
            TokenType[] argsig = new TokenType[nSubs];
            argsig[0] = new TokenTypeInt (sdtType);
            for (int i = 0; ++ i < nSubs;) {
                argsig[i] = argsig[0];
            }
            TokenDeclVar getFunc = scg.FindThisMember (sdtDecl, name, argsig);
            return getFunc.retType;
        }

        // non-trivial because it needs to be copied into a temp
        // in case the idiot does dumb-ass side effects tricks
        //   eg,  (x = 0) + x + 2
        //   should read old value of x not 0
        // but if 'xmroption norighttoleft;' in effect,
        // we can read it in any order so reading an
        // fixed-dimension array element is trivial
        public override bool IsReadTrivial (ScriptCodeGen scg, Token readAt)
        {
            return readAt.nr2l;
        }
    }

    // The value is a float constant
    public class CompValuFloat : CompValu {
        public double x;

        public CompValuFloat (TokenType type, double x) : base (type)
        {
            if (!(this.type is TokenTypeFloat)) {
                this.type = new TokenTypeFloat (this.type);
            }
            this.x = x;
        }
        public override void PushVal (ScriptCodeGen scg, Token errorAt)
        {
            scg.ilGen.Emit (errorAt, OpCodes.Ldc_R8, x);
        }
        public override void PushRef (ScriptCodeGen scg, Token errorAt)
        {
            throw new Exception ("cannot get constant's address");
        }
        public override void PopPost (ScriptCodeGen scg, Token errorAt)
        {
            throw new Exception ("cannot store into constant");
        }
    }

    // The value is the entrypoint of a script-defined global function.
    // These are also used for script-defined type static methods as the calling convention is the same,
    // ie, the XMRInstance pointer is a hidden first argument.
    // There is just one of these created when the function is being compiled as there is only one value
    // of the function.
    public class CompValuGlobalMeth : CompValu {
        private TokenDeclVar func;

        public CompValuGlobalMeth (TokenDeclVar declFunc) : base (declFunc.GetDelType ())
        {
            this.func = declFunc;
        }

        /**
         * @brief PushVal for a function/method means push a delegate on the stack.
         *        We build a call to the DynamicMethod's CreateDelegate() function 
         *        to create the delegate.  Slip the scriptinstance pointer as the 
         *        function's arg 0 so it will get passed to the function when called.
         */
        public override void PushVal (ScriptCodeGen scg, Token errorAt)
        {
            string dtn = type.ToString ();
            if (dtn.StartsWith ("delegate ")) dtn = dtn.Substring (9);

            // delegateinstance = (signature)scriptinstance.GetScriptMethodDelegate (methName, signature, arg0);
            //   where methName = [<sdtclass>.]<methname>(<argtypes>)
            //        signature = <rettype>(<argtypes>)
            //             arg0 = scriptinstance (XMRInstance)
            scg.PushXMRInst ();                                     // [0] scriptinstance
            scg.ilGen.Emit (errorAt, OpCodes.Ldstr, func.ilGen.methName);    // [1] method name
            scg.ilGen.Emit (errorAt, OpCodes.Ldstr, dtn);                    // [2] delegate type name
            scg.PushXMRInst ();                                     // [3] scriptinstance
            scg.ilGen.Emit (errorAt, OpCodes.Callvirt, gsmdMethodInfo);      // [0] delegate instance
            scg.ilGen.Emit (errorAt, OpCodes.Castclass, type.ToSysType ());  // [0] cast to correct delegate class
        }
        public override void PushRef (ScriptCodeGen scg, Token errorAt)
        {
            throw new Exception ("cannot get ref to global method");
        }
        public override void PopPost (ScriptCodeGen scg, Token errorAt)
        {
            throw new Exception ("cannot store into global method");
        }

        /**
         * @brief A direct call is much simpler than pushing a delegate.
         *        Just push the XMRInstance pointer, push the args and finally call the function.
         */
        public override void CallPre (ScriptCodeGen scg, Token errorAt)
        {
            if (!this.func.IsFuncTrivial (scg)) new ScriptCodeGen.CallLabel (scg, errorAt);

            // all script-defined global functions are static methods created by DynamicMethod()
            // and the first argument is always the XMR_Instance pointer
            scg.PushXMRInst ();
        }
        public override void CallPost (ScriptCodeGen scg, Token errorAt)
        {
            scg.ilGen.Emit (errorAt, OpCodes.Call, func.ilGen);
            if (!this.func.IsFuncTrivial (scg)) scg.openCallLabel = null;
        }
    }

    // The value is in a script-global variable = ScriptModule instance variable
    // It could also be a script-global property
    public class CompValuGlobalVar : CompValu {
        private static readonly FieldInfo glblVarsFieldInfo = typeof (XMRInstAbstract).GetField ("glblVars");

        private TokenDeclVar declVar;

        public CompValuGlobalVar (TokenDeclVar declVar, XMRInstArSizes glblSizes) : base (declVar.type)
        {
            this.declVar = declVar;
            if ((declVar.getProp == null) && (declVar.setProp == null)) {
                declVar.type.AssignVarSlot (declVar, glblSizes);
            }
        }
        public override void PushVal (ScriptCodeGen scg, Token errorAt)
        {
            if ((declVar.getProp == null) && (declVar.setProp == null)) {
                scg.PushXMRInst ();
                scg.ilGen.Emit (errorAt, OpCodes.Ldfld, glblVarsFieldInfo);
                EmitFieldPushVal (scg, errorAt, declVar);
            } else if (declVar.getProp != null) {
                declVar.getProp.location.CallPre  (scg, errorAt);
                declVar.getProp.location.CallPost (scg, errorAt);
            } else {
                scg.ErrorMsg (errorAt, "property not readable");
                scg.PushDefaultValue (declVar.type);
            }
        }
        public override void PushRef (ScriptCodeGen scg, Token errorAt)
        {
            if ((declVar.getProp == null) && (declVar.setProp == null)) {
                scg.PushXMRInst ();
                scg.ilGen.Emit (errorAt, OpCodes.Ldfld, glblVarsFieldInfo);
                EmitFieldPushRef (scg, errorAt, declVar);
            } else {
                scg.ErrorMsg (errorAt, "cannot get address of property");
            }
        }
        public override void PopPre (ScriptCodeGen scg, Token errorAt)
        {
            if ((declVar.getProp == null) && (declVar.setProp == null)) {
                scg.PushXMRInst ();
                scg.ilGen.Emit (errorAt, OpCodes.Ldfld, glblVarsFieldInfo);
                EmitFieldPopPre (scg, errorAt, declVar);
            } else if (declVar.setProp == null) {
                scg.ErrorMsg (errorAt, "property not writable");
            }
        }
        public override void PopPost (ScriptCodeGen scg, Token errorAt)
        {
            if ((declVar.getProp == null) && (declVar.setProp == null)) {
                EmitFieldPopPost (scg, errorAt, declVar);
            } else if (declVar.setProp != null) {
                EmitPopPostProp (scg, errorAt, declVar.type, declVar.setProp.location);
            } else {
                scg.ilGen.Emit (errorAt, OpCodes.Pop);
            }
        }

        // non-trivial because it needs to be copied into a temp
        // in case the idiot does dumb-ass side effects tricks
        //   eg,  (x = 0) + x + 2
        //   should read old value of x not 0
        // but if 'xmroption norighttoleft;' in effect,
        // we can read it in any order so reading an
        // global variable is trivial provided it is 
        // not a property or the property function is
        // trivial.
        public override bool IsReadTrivial (ScriptCodeGen scg, Token readAt)
        {
            return readAt.nr2l && ((declVar.getProp == null) || declVar.getProp.IsFuncTrivial (scg));
        }
    }

    // The value is in an $idxprop property of a script-defined type class or interface instance.
    // Reading and writing is via a method call.
    public class CompValuIdxProp : CompValu {
        private TokenDeclVar idxProp;  // $idxprop property within baseRVal
        private CompValu baseRVal;     // pointer to class or interface object containing property
        private TokenType[] argTypes;  // argument types as required by $idxprop declaration
        private CompValu[] indices;    // actual index values to pass to getter/setter method
        private CompValu setProp;      // location of setter method

        public CompValuIdxProp (TokenDeclVar idxProp, CompValu baseRVal, TokenType[] argTypes, CompValu[] indices) : base (idxProp.type)
        {           
            this.idxProp  = idxProp;
            this.baseRVal = baseRVal;
            this.argTypes = argTypes;
            this.indices  = indices;
        }

        /**
         * @brief Pushing the property's value is a matter of calling the getter method
         *        with the supplied argument list as is.
         */
        public override void PushVal (ScriptCodeGen scg, Token errorAt)
        {
            if (idxProp.getProp != null) {
                if (!idxProp.getProp.IsFuncTrivial (scg)) {
                    for (int i = indices.Length; -- i >= 0;) {
                        indices[i] = scg.Trivialize (indices[i], errorAt);
                    }
                }
                CompValu getProp = GetIdxPropMeth (idxProp.getProp);
                getProp.CallPre (scg, errorAt);
                for (int i = 0; i < indices.Length; i ++) {
                    indices[i].PushVal (scg, errorAt, argTypes[i]);
                }
                getProp.CallPost (scg, errorAt);
            } else {
                // write-only property
                scg.ErrorMsg (errorAt, "member not readable");
                scg.PushDefaultValue (idxProp.type);
            }
        }

        /**
         * @brief A property does not have a memory address.
         */
        public override void PushRef (ScriptCodeGen scg, Token errorAt)
        {
            scg.ErrorMsg (errorAt, "member has no address");
            scg.ilGen.Emit (errorAt, OpCodes.Ldnull);
        }

        /**
         * @brief Preparing to write a property consists of preparing to call the setter method
         *        then pushing the index arguments.
         */
        public override void PopPre (ScriptCodeGen scg, Token errorAt)
        {
            if (idxProp.setProp != null) {
                if (!idxProp.setProp.IsFuncTrivial (scg)) {
                    for (int i = indices.Length; -- i >= 0;) {
                        indices[i] = scg.Trivialize (indices[i], errorAt);
                    }
                }
                this.setProp = GetIdxPropMeth (idxProp.setProp);
                this.setProp.CallPre (scg, errorAt);
                for (int i = 0; i < indices.Length; i ++) {
                    indices[i].PushVal (scg, errorAt, argTypes[i]);
                }
            } else {
                // read-only property
                scg.ErrorMsg (errorAt, "member not writable");
            }
        }

        /**
         * @brief Finishing writing a property consists of finishing the call to the setter method
         *        now that the value to be written has been pushed by our caller.
         */
        public override void PopPost (ScriptCodeGen scg, Token errorAt)
        {
            if (idxProp.setProp != null) {
                this.setProp.CallPost (scg, errorAt);
            } else {
                scg.ilGen.Emit (errorAt, OpCodes.Pop);
            }
        }

        public override bool IsReadTrivial (ScriptCodeGen scg, Token readAt)
        {
            // if no getter, reading would throw an error, so doesn't really matter what we say
            if (idxProp.getProp == null) return true;

            // assume interface methods are always non-trivial because we don't know anything about the actual implementation
            if (baseRVal.type is TokenTypeSDTypeInterface) return false;

            // accessing it in any way can't be trivial if reading the pointer isn't trivial
            if (!baseRVal.IsReadTrivial (scg, readAt)) return false;

            // likewise with the indices
            foreach (CompValu idx in indices) {
                if (!idx.IsReadTrivial (scg, readAt)) return false;
            }

            // now the only way it can be non-trivial to read is if the getter() method itself is non-trivial.
            return idxProp.getProp.IsFuncTrivial (scg);
        }

        /**
         * @brief Get how to call the getter or setter method.
         */
        private CompValu GetIdxPropMeth (TokenDeclVar meth)
        {
            if (baseRVal.type is TokenTypeSDTypeClass) {
                return new CompValuInstMember (meth, baseRVal, false);
            }
            return new CompValuIntfMember (meth, baseRVal);
        }
    }

    // This represents the type and location of an internally-defined function
    // that a script can call
    public class CompValuInline : CompValu {
        public TokenDeclInline declInline;

        public CompValuInline (TokenDeclInline declInline) : base (declInline.GetDelType ())
        {
            this.declInline = declInline;
        }

        public override void PushVal (ScriptCodeGen scg, Token errorAt)
        {
            scg.ErrorMsg (errorAt, "cannot use built-in for delegate, wrap it");
            scg.ilGen.Emit (errorAt, OpCodes.Ldnull);
        }
        public override void PushRef (ScriptCodeGen scg, Token errorAt)
        {
            scg.ErrorMsg (errorAt, "cannot use built-in for delegate, wrap it");
            scg.ilGen.Emit (errorAt, OpCodes.Ldnull);
        }
        public override void PopPre (ScriptCodeGen scg, Token errorAt)
        {
            scg.ErrorMsg (errorAt, "cannot use built-in for delegate, wrap it");
        }
        public override void PopPost (ScriptCodeGen scg, Token errorAt)
        {
            scg.ErrorMsg (errorAt, "cannot use built-in for delegate, wrap it");
            scg.ilGen.Emit (errorAt, OpCodes.Pop);
        }
    }

    // The value is the entrypoint of a script-defined type's interface method combined with
    // the pointer used to access the method.  Thus there is one of these per call site.
    // They also handle accessing interface properties.
    public class CompValuIntfMember : CompValu {
        private TokenDeclVar declVar;
        private CompValu baseRVal;

        public CompValuIntfMember (TokenDeclVar declVar, CompValu baseRVal) : base (declVar.type)
        {
            if (this.type == null) throw new Exception ("interface member type is null");
            this.declVar  = declVar;   // which element of the baseRVal vector to be accessed
            this.baseRVal = baseRVal;  // the vector of delegates implementing the interface
        }

        /**
         * @brief Reading a method's value means getting a delegate to that method.
         *        Reading a property's value means calling the getter method for that property.
         */
        public override void PushVal (ScriptCodeGen scg, Token errorAt)
        {
            if (declVar.retType != null) {
                baseRVal.PushVal (scg, errorAt);                        // push pointer to delegate array on stack
                scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4, declVar.vTableIndex);   // select which delegate to access
                scg.ilGen.Emit (errorAt, OpCodes.Ldelem, typeof (Delegate));     // push delegate on stack
                scg.ilGen.Emit (errorAt, OpCodes.Castclass, type.ToSysType ());  // cast to correct delegate class
            } else if (declVar.getProp != null) {
                CompValu getProp = new CompValuIntfMember (declVar.getProp, baseRVal);
                getProp.CallPre  (scg, errorAt);                        // reading property, call its getter
                getProp.CallPost (scg, errorAt);                        // ... with no arguments
            } else {
                scg.ErrorMsg (errorAt, "member not readable");
                scg.PushDefaultValue (declVar.type);
            }
        }

        /**
         * @brief Can't get the address of either a method or a property.
         */
        public override void PushRef (ScriptCodeGen scg, Token errorAt)
        {
            scg.ErrorMsg (errorAt, "member has no address");
            scg.ilGen.Emit (errorAt, OpCodes.Ldnull);
        }

        /**
         * @brief Can't write a method.
         *        For property, it means calling the setter method for that property.
         */
        public override void PopPre (ScriptCodeGen scg, Token errorAt)
        {
            if (declVar.setProp == null) {
                // read-only property
                scg.ErrorMsg (errorAt, "member not writable");
            }
        }
        public override void PopPost (ScriptCodeGen scg, Token errorAt)
        {
            if (declVar.setProp != null) {
                CompValu setProp = new CompValuIntfMember (declVar.setProp, baseRVal);
                EmitPopPostProp (scg, errorAt, declVar.type, setProp);
            } else {
                scg.ilGen.Emit (errorAt, OpCodes.Pop);
            }
        }

        /**
         * @brief Reading a method (ie, it's delegate) is always trivial, it's just retrieving
         *        an element from the delegate array that make up the interface object.
         *
         *        Reading a property is always non-trivial because we don't know which implementation 
         *        the interface is pointing to, so we don't know if it's trivial or not, so assume 
         *        the worst, ie, that it is non-trivial and might call CheckRun().
         *
         *        But all that assumes that locating the interface object in the first place is 
         *        trivial, ie, baseRVal.PushVal() must not call CheckRun() either.
         */
        public override bool IsReadTrivial (ScriptCodeGen scg, Token readAt)
        {
            return baseRVal.IsReadTrivial (scg, readAt) && (declVar.getProp == null);
        }

        /**
         * @brief We just defer to the default CallPre() and CallPost() methods.
         *        They expect this.PushVal() to push a delegate to the method to be called.
         *        If this member is a method, our PushVal() will read the correct element 
         *        of the iTable array and push it on the stack, ready for Invoke() to be
         *        called.  If this member is a property, the only way it can be called is 
         *        if the property is a delegate, in which case PushVal() will retrieve the 
         *        delegate by calling the property's getter method.
         */
    }

    // The value is the entrypoint of an internal instance method
    // such as XMR_Array.index()
    public class CompValuIntInstMeth : CompValu {
        private TokenTypeSDTypeDelegate delType;
        private CompValu baseRVal;
        private MethodInfo methInfo;

        public CompValuIntInstMeth (TokenTypeSDTypeDelegate delType, CompValu baseRVal, MethodInfo methInfo) : base (delType)
        {
            this.delType  = delType;
            this.baseRVal = baseRVal;
            this.methInfo = methInfo;
        }

        public override void PushVal (ScriptCodeGen scg, Token errorAt)
        {
            // its value, ie, without applying the (arglist), is a delegate...
            baseRVal.PushVal (scg, errorAt);
            scg.ilGen.Emit (errorAt, OpCodes.Ldftn, methInfo);
            scg.ilGen.Emit (errorAt, OpCodes.Newobj, delType.decl.GetConstructorInfo ());
        }
        public override void PushRef (ScriptCodeGen scg, Token errorAt)
        {
            throw new Exception ("cannot get ref to instance method");
        }
        public override void PopPost (ScriptCodeGen scg, Token errorAt)
        {
            throw new Exception ("cannot store into instance method");
        }

        public override void CallPre (ScriptCodeGen scg, Token errorAt)
        {
            // internal instance methods are always trivial so never need a CallLabel.
            baseRVal.PushVal (scg, errorAt);
        }
        public override void CallPost (ScriptCodeGen scg, Token errorAt)
        {
            scg.ilGen.Emit (errorAt, OpCodes.Call, methInfo);
        }
    }

    // The value is fetched by calling an internal instance method
    // such as XMR_Array.count
    public class CompValuIntInstROProp : CompValu {
        private CompValu baseRVal;
        private MethodInfo methInfo;

        public CompValuIntInstROProp (TokenType valType, CompValu baseRVal, MethodInfo methInfo) : base (valType)
        {
            this.baseRVal = baseRVal;
            this.methInfo = methInfo;
        }

        public override void PushVal (ScriptCodeGen scg, Token errorAt)
        {
            baseRVal.PushVal (scg, errorAt);
            scg.ilGen.Emit (errorAt, OpCodes.Call, methInfo);
        }
        public override void PushRef (ScriptCodeGen scg, Token errorAt)
        {
            scg.ErrorMsg (errorAt, "cannot get ref to read-only property");
            scg.ilGen.Emit (errorAt, OpCodes.Ldnull);
        }
        public override void PopPost (ScriptCodeGen scg, Token errorAt)
        {
            scg.ErrorMsg (errorAt, "cannot store into read-only property");
            scg.ilGen.Emit (errorAt, OpCodes.Pop);
        }
    }

    // The value is in a member of a script-defined type class instance.
    //       field: value is in one of the arrays contained within XMRSDTypeClObj.instVars
    //      method: value is a delegate; can be called
    //    property: reading and writing is via a method call
    public class CompValuInstMember : CompValu {
        private static readonly FieldInfo instVarsFieldInfo = typeof (XMRSDTypeClObj).GetField ("instVars");
        private static readonly FieldInfo vTableFieldInfo   = typeof (XMRSDTypeClObj).GetField ("sdtcVTable");

        private TokenDeclVar declVar;  // member being accessed
        private CompValu baseRVal;     // pointer to particular object instance
        private bool ignoreVirt;       // ignore virtual attribute; use declVar's non-virtual method/property

        public CompValuInstMember (TokenDeclVar declVar, CompValu baseRVal, bool ignoreVirt) : base (declVar.type)
        {
            this.declVar    = declVar;
            this.baseRVal   = baseRVal;
            this.ignoreVirt = ignoreVirt;
        }

        public override void PushVal (ScriptCodeGen scg, Token errorAt)
        {
            if (declVar.retType != null) {
                // a method's value, ie, without applying the (arglist), is a delegate...
                PushValMethod (scg, errorAt);
            } else if (declVar.vTableArray != null) {
                // a field's value is its XMRSDTypeClObj.instVars array element
                baseRVal.PushVal (scg, errorAt);
                scg.ilGen.Emit (errorAt, OpCodes.Ldfld, instVarsFieldInfo);
                EmitFieldPushVal (scg, errorAt, declVar);
            } else if (declVar.getProp != null) {
                // a property's value is calling its get method with no arguments
                CompValu getProp = new CompValuInstMember (declVar.getProp, baseRVal, ignoreVirt);
                getProp.CallPre  (scg, errorAt);
                getProp.CallPost (scg, errorAt);
            } else {
                // write-only property
                scg.ErrorMsg (errorAt, "member not readable");
                scg.PushDefaultValue (declVar.type);
            }
        }
        public override void PushRef (ScriptCodeGen scg, Token errorAt)
        {
            if (declVar.vTableArray != null) {
                // a field's value is its XMRSDTypeClObj.instVars array element
                baseRVal.PushVal (scg, errorAt);
                scg.ilGen.Emit (errorAt, OpCodes.Ldfld, instVarsFieldInfo);
                EmitFieldPushRef (scg, errorAt, declVar);
            } else {
                scg.ErrorMsg (errorAt, "member has no address");
                scg.ilGen.Emit (errorAt, OpCodes.Ldnull);
            }
        }
        public override void PopPre (ScriptCodeGen scg, Token errorAt)
        {
            if (declVar.vTableArray != null) {
                // a field's value is its XMRSDTypeClObj.instVars array element
                baseRVal.PushVal (scg, errorAt);
                scg.ilGen.Emit (errorAt, OpCodes.Ldfld, instVarsFieldInfo);
                EmitFieldPopPre (scg, errorAt, declVar);
            } else if (declVar.setProp == null) {
                // read-only property
                scg.ErrorMsg (errorAt, "member not writable");
            }
        }
        public override void PopPost (ScriptCodeGen scg, Token errorAt)
        {
            if (declVar.vTableArray != null) {
                EmitFieldPopPost (scg, errorAt, declVar);
            } else if (declVar.setProp != null) {
                CompValu setProp = new CompValuInstMember (declVar.setProp, baseRVal, ignoreVirt);
                EmitPopPostProp (scg, errorAt, declVar.type, setProp);
            } else {
                scg.ilGen.Emit (errorAt, OpCodes.Pop);
            }
        }

        public override bool IsReadTrivial (ScriptCodeGen scg, Token readAt)
        {
            // accessing it in any way can't be trivial if reading the pointer isn't trivial.
            // this also handles strict right-to-left mode detection as the side-effect can
            // only apply to the pointer (it can't change which field or method we access).
            if (!baseRVal.IsReadTrivial (scg, readAt)) return false;

            // now the only way it can be non-trivial to read is if it is a property and the 
            // getter() method is non-trivial.  reading a method means getting a delegate 
            // which is always trivial, and reading a simple field is always trivial, ie, no 
            // CheckRun() call can possibly be involved.
            if (declVar.retType != null) {
                // a method's value, ie, without applying the (arglist), is a delegate...
                return true;
            }
            if (declVar.vTableArray != null) {
                // a field's value is its XMRSDTypeClObj.instVars array element
                return true;
            }
            if (declVar.getProp != null) {
                // a property's value is calling its get method with no arguments
                return declVar.getProp.IsFuncTrivial (scg);
            }

            // write-only property
            return true;
        }

        public override void CallPre (ScriptCodeGen scg, Token errorAt)
        {
            if (declVar.retType != null) {
                CallPreMethod (scg, errorAt);
            } else {
                base.CallPre (scg, errorAt);
            }
        }
        public override void CallPost (ScriptCodeGen scg, Token errorAt)
        {
            if (declVar.retType != null) {
                CallPostMethod (scg, errorAt);
            } else {
                base.CallPost (scg, errorAt);
            }
        }

        /**
         * @brief A PushVal() for a method means to push a delegate for the method on the stack.
         */
        private void PushValMethod (ScriptCodeGen scg, Token errorAt)
        {
            if ((declVar.sdtFlags & ScriptReduce.SDT_STATIC) != 0) throw new Exception ("dont use for statics");

            if (ignoreVirt || (declVar.vTableIndex < 0)) {

                /*
                 * Non-virtual instance method, create a delegate that references the method.
                 */
                string dtn = type.ToString ();

                // delegateinstance = (signature)scriptinstance.GetScriptMethodDelegate (methName, signature, arg0);
                //   where methName = <sdtclass>.<methname>(<argtypes>)
                //        signature = <rettype>(<argtypes>)
                //             arg0 = sdt istance (XMRSDTypeClObj) 'this' value
                scg.PushXMRInst ();                                     // [0] scriptinstance
                scg.ilGen.Emit (errorAt, OpCodes.Ldstr, declVar.ilGen.methName); // [1] method name
                scg.ilGen.Emit (errorAt, OpCodes.Ldstr, dtn);                    // [2] delegate type name
                baseRVal.PushVal (scg, errorAt);                        // [3] sdtinstance
                scg.ilGen.Emit (errorAt, OpCodes.Callvirt, gsmdMethodInfo);      // [0] delegate instance
                scg.ilGen.Emit (errorAt, OpCodes.Castclass, type.ToSysType ());  // [0] cast to correct delegate class
            } else {

                /*
                 * Virtual instance method, get the delegate from the vtable.
                 */
                baseRVal.PushVal (scg, errorAt);                                 // 'this' selecting the instance
                scg.ilGen.Emit (errorAt, OpCodes.Ldfld, vTableFieldInfo);        // get pointer to instance's vtable array
                scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4, declVar.vTableIndex);   // select vtable element
                scg.ilGen.Emit (errorAt, OpCodes.Ldelem, typeof (Delegate));     // get delegate pointer = 'this' for 'Invoke()'
                scg.ilGen.Emit (errorAt, OpCodes.Castclass, type.ToSysType ());  // cast to correct delegate class
            }
        }

        private void CallPreMethod (ScriptCodeGen scg, Token errorAt)
        {
            if ((declVar.sdtFlags & ScriptReduce.SDT_STATIC) != 0) throw new Exception ("dont use for statics");

            if (!this.declVar.IsFuncTrivial (scg)) new ScriptCodeGen.CallLabel (scg, errorAt);

            if (ignoreVirt || (declVar.vTableIndex < 0)) {
                baseRVal.PushVal (scg, errorAt);                                 // 'this' being passed directly to method
            } else {
                baseRVal.PushVal (scg, errorAt);                                 // 'this' selecting the instance
                scg.ilGen.Emit (errorAt, OpCodes.Ldfld, vTableFieldInfo);        // get pointer to instance's vtable array
                scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4, declVar.vTableIndex);   // select vtable element
                scg.ilGen.Emit (errorAt, OpCodes.Ldelem, typeof (Delegate));     // get delegate pointer = 'this' for 'Invoke()'
                scg.ilGen.Emit (errorAt, OpCodes.Castclass, type.ToSysType ());  // cast to correct delegate class
            }
        }
        private void CallPostMethod (ScriptCodeGen scg, Token errorAt)
        {
            if (ignoreVirt || (declVar.vTableIndex < 0)) {
                // non-virt instance, just call function directly
                scg.ilGen.Emit (errorAt, OpCodes.Call, declVar.ilGen);
            } else {
                // virtual, call via delegate Invoke(...) method
                TokenTypeSDTypeDelegate ttd = (TokenTypeSDTypeDelegate)type;
                MethodInfo invokeMethodInfo = ttd.decl.GetInvokerInfo ();
                scg.ilGen.Emit (errorAt, OpCodes.Callvirt, invokeMethodInfo);
            }

            if (!this.declVar.IsFuncTrivial (scg)) scg.openCallLabel = null;
        }
    }

    // The value is an integer constant
    public class CompValuInteger : CompValu {
        public int x;

        public CompValuInteger (TokenType type, int x) : base (type)
        {
            if (!(this.type is TokenTypeInt)) {
                this.type = new TokenTypeInt (this.type);
            }
            this.x = x;
        }
        public override void PushVal (ScriptCodeGen scg, Token errorAt)
        {
            scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4, x);
        }
        public override void PushRef (ScriptCodeGen scg, Token errorAt)
        {
            throw new Exception ("cannot get constant's address");
        }
        public override void PopPost (ScriptCodeGen scg, Token errorAt)
        {
            throw new Exception ("cannot store into constant");
        }
    }

    // The value is an element of a list
    public class CompValuListEl : CompValu {
        private static readonly MethodInfo getElementFromListMethodInfo = 
                 typeof (CompValuListEl).GetMethod ("GetElementFromList", new Type[] { typeof (LSL_List), typeof (int) });

        private CompValu theList;
        private CompValu subscript;

        public CompValuListEl (TokenType type, CompValu theList, CompValu subscript) : base (type)
        {
            this.theList   = theList;
            this.subscript = subscript;
        }
        public override void PushVal (ScriptCodeGen scg, Token errorAt)
        {
            theList.PushVal (scg, errorAt, new TokenTypeList (type));
            subscript.PushVal (scg, errorAt, new TokenTypeInt (type));
            scg.ilGen.Emit (errorAt, OpCodes.Call, getElementFromListMethodInfo);
        }
        public override void PushRef (ScriptCodeGen scg, Token errorAt)
        {
            throw new Exception ("cannot get list element's address");
        }
        public override void PopPost (ScriptCodeGen scg, Token errorAt)
        {
            scg.ErrorMsg (errorAt, "cannot store into list element");
            scg.ilGen.Emit (errorAt, OpCodes.Pop);
        }

        public static object GetElementFromList (LSL_List lis, int idx)
        {
            object element = lis.Data[idx];
            if (element is LSL_Float)                return TypeCast.EHArgUnwrapFloat    (element);
            if (element is LSL_Integer)              return TypeCast.EHArgUnwrapInteger  (element);
            if (element is LSL_String)               return TypeCast.EHArgUnwrapString   (element);
            if (element is OpenMetaverse.Quaternion) return TypeCast.EHArgUnwrapRotation (element);
            if (element is OpenMetaverse.Vector3)    return TypeCast.EHArgUnwrapVector   (element);
            return element;
        }
    }

    // The value is kept in a script-addressable local variable
    public class CompValuLocalVar : CompValu {
        private static int htpopseq = 0;

        private ScriptMyLocal localBuilder;

        public CompValuLocalVar (TokenType type, string name, ScriptCodeGen scg) : base (type)
        {
            if (type.ToHeapTrackerType () != null) {
                this.localBuilder = scg.ilGen.DeclareLocal (type.ToHeapTrackerType (), name);
                scg.PushXMRInst ();
                scg.ilGen.Emit (type, OpCodes.Newobj, type.GetHeapTrackerCtor ());
                scg.ilGen.Emit (type, OpCodes.Stloc, localBuilder);
            } else {
                this.localBuilder = scg.ilGen.DeclareLocal (ToSysType (), name);
            }
        }

        public override void PushVal (ScriptCodeGen scg, Token errorAt)
        {
            scg.ilGen.Emit (errorAt, OpCodes.Ldloc, localBuilder);
            if (type.ToHeapTrackerType () != null) {
                type.CallHeapTrackerPushMeth (errorAt, scg.ilGen);
            }
        }
        public override void PushRef (ScriptCodeGen scg, Token errorAt)
        {
            if (type.ToHeapTrackerType () != null) {
                scg.ErrorMsg (errorAt, "can't take ref of heap-tracked type " + type.ToString ());
                scg.ilGen.Emit (errorAt, OpCodes.Ldnull);
            } else {
                scg.ilGen.Emit (errorAt, OpCodes.Ldloca, localBuilder);
            }
        }

        public override void PopPre (ScriptCodeGen scg, Token errorAt)
        {
            if (type.ToHeapTrackerType () != null) {
                scg.ilGen.Emit (errorAt, OpCodes.Ldloc, localBuilder);
            }
        }
        public override void PopPost (ScriptCodeGen scg, Token errorAt)
        {
            if (type.ToHeapTrackerType () != null) {
                type.CallHeapTrackerPopMeth (errorAt, scg.ilGen);
            } else {
                scg.ilGen.Emit (errorAt, OpCodes.Stloc, localBuilder);
            }
        }

        public void Pop (ScriptCodeGen scg, Token errorAt)
        {
            if (type.ToHeapTrackerType () != null) {
                /*
                 * Popping into a heap tracker wrapped local variable.
                 * First pop value into a temp var, then call the heap tracker's pop method.
                 */
                ScriptMyLocal htpop = scg.ilGen.DeclareLocal (type.ToSysType (), "htpop$" + (++ htpopseq).ToString ());
                scg.ilGen.Emit (errorAt, OpCodes.Stloc, htpop);
                scg.ilGen.Emit (errorAt, OpCodes.Ldloc, localBuilder);
                scg.ilGen.Emit (errorAt, OpCodes.Ldloc, htpop);
                type.CallHeapTrackerPopMeth (errorAt, scg.ilGen);
            } else {

                /*
                 * Not a heap-tracked local var, just pop directly into it.
                 */
                scg.ilGen.Emit (errorAt, OpCodes.Stloc, localBuilder);
            }
        }

        // non-trivial because it needs to be copied into a temp
        // in case the idiot does dumb-ass side effects tricks
        //   eg,  (x = 0) + x + 2
        //   should read old value of x not 0
        // but if 'xmroption norighttoleft;' in effect,
        // we can read it in any order so reading a
        // local variable is trivial.
        public override bool IsReadTrivial (ScriptCodeGen scg, Token readAt)
        {
            return readAt.nr2l;
        }
    }

    // The value is a null
    public class CompValuNull : CompValu {
        public CompValuNull (TokenType type) : base (type) { }
        public override void PushVal (ScriptCodeGen scg, Token errorAt)
        {
            scg.ilGen.Emit (errorAt, OpCodes.Ldnull);
        }
        public override void PushRef (ScriptCodeGen scg, Token errorAt)
        {
            throw new Exception ("cannot get null's address");
        }
        public override void PopPost (ScriptCodeGen scg, Token errorAt)
        {
            throw new Exception ("cannot store into null");
        }
    }

    // The value is a rotation
    public class CompValuRot : CompValu {
        public CompValu x;
        public CompValu y;
        public CompValu z;
        public CompValu w;

        private static readonly ConstructorInfo lslRotConstructorInfo = 
                typeof (LSL_Rotation).GetConstructor (new Type[] { typeof (double), 
                                                                   typeof (double), 
                                                                   typeof (double), 
                                                                   typeof (double) });

        public CompValuRot (TokenType type, CompValu x, CompValu y, CompValu z, CompValu w) :
                base (type)
        {
            if (!(type is TokenTypeRot)) {
                this.type = new TokenTypeRot (type);
            }
            this.x = x;
            this.y = y;
            this.z = z;
            this.w = w;
        }
        public override void PushVal (ScriptCodeGen scg, Token errorAt)
        {
            this.x.PushVal (scg, errorAt, new TokenTypeFloat (this.x.type));
            this.y.PushVal (scg, errorAt, new TokenTypeFloat (this.y.type));
            this.z.PushVal (scg, errorAt, new TokenTypeFloat (this.z.type));
            this.w.PushVal (scg, errorAt, new TokenTypeFloat (this.w.type));
            scg.ilGen.Emit (errorAt, OpCodes.Newobj, lslRotConstructorInfo);
        }
        public override void PushRef (ScriptCodeGen scg, Token errorAt)
        {
            throw new Exception ("cannot get constant's address");
        }
        public override void PopPost (ScriptCodeGen scg, Token errorAt)
        {
            throw new Exception ("cannot store into constant");
        }

        public override bool IsReadTrivial (ScriptCodeGen scg, Token readAt)
        {
            // the supplied values must be trivial because when we call their PushVal()s
            // there will be stuff on the stack for all but the first PushVal() and so
            // they would have a non-empty stack at their call label.
            if (!this.w.IsReadTrivial (scg, readAt) ||
                !this.x.IsReadTrivial (scg, readAt) ||
                !this.y.IsReadTrivial (scg, readAt) ||
                !this.z.IsReadTrivial (scg, readAt)) {
                throw new Exception ("rotation values must be trivial");
            }

            return true;
        }
    }

    // The value is in a static field of an internally defined struct/class
    public class CompValuSField : CompValu {
        public FieldInfo field;

        public CompValuSField (TokenType type, FieldInfo field) : base (type)
        {
            this.field = field;
        }
        public override void PushVal (ScriptCodeGen scg, Token errorAt)
        {
            if ((field.Attributes & FieldAttributes.Literal) == 0) {
                scg.ilGen.Emit (errorAt, OpCodes.Ldsfld, field);
                return;
            }
            if (field.FieldType == typeof (LSL_Rotation)) {
                LSL_Rotation rot = (LSL_Rotation)field.GetValue (null);
                scg.ilGen.Emit (errorAt, OpCodes.Ldc_R8, rot.x);
                scg.ilGen.Emit (errorAt, OpCodes.Ldc_R8, rot.y);
                scg.ilGen.Emit (errorAt, OpCodes.Ldc_R8, rot.z);
                scg.ilGen.Emit (errorAt, OpCodes.Ldc_R8, rot.s);
                scg.ilGen.Emit (errorAt, OpCodes.Newobj, ScriptCodeGen.lslRotationConstructorInfo);
                return;
            }
            if (field.FieldType == typeof (LSL_Vector)) {
                LSL_Vector vec = (LSL_Vector)field.GetValue (null);
                scg.ilGen.Emit (errorAt, OpCodes.Ldc_R8, vec.x);
                scg.ilGen.Emit (errorAt, OpCodes.Ldc_R8, vec.y);
                scg.ilGen.Emit (errorAt, OpCodes.Ldc_R8, vec.z);
                scg.ilGen.Emit (errorAt, OpCodes.Newobj, ScriptCodeGen.lslRotationConstructorInfo);
                return;
            }
            if (field.FieldType == typeof (string)) {
                string str = (string)field.GetValue (null);
                scg.ilGen.Emit (errorAt, OpCodes.Ldstr, str);
                return;
            }
            throw new Exception ("unsupported literal type " + field.FieldType.Name);
        }
        public override void PushRef (ScriptCodeGen scg, Token errorAt)
        {
            if ((field.Attributes & FieldAttributes.Literal) != 0) {
                throw new Exception ("can't write a constant");
            }
            scg.ilGen.Emit (errorAt, OpCodes.Ldflda, field);
        }
        public override void PopPre (ScriptCodeGen scg, Token errorAt)
        {
        }
        public override void PopPost (ScriptCodeGen scg, Token errorAt)
        {
            if ((field.Attributes & FieldAttributes.Literal) != 0) {
                throw new Exception ("can't write a constant");
            }
            scg.ilGen.Emit (errorAt, OpCodes.Stsfld, field);
        }

        // non-trivial because it needs to be copied into a temp
        // in case the idiot does dumb-ass side effects tricks
        //   eg,  (x = 0) + x + 2
        //   should read old value of x not 0
        // but if 'xmroption norighttoleft;' in effect,
        // we can read it in any order so reading a
        // local variable is trivial.
        public override bool IsReadTrivial (ScriptCodeGen scg, Token readAt)
        {
            return readAt.nr2l;
        }
    }

    // The value is a character within a string
    public class CompValuStrChr : CompValu {
        private static readonly MethodInfo getCharFromStringMethodInfo = 
                 typeof (CompValuStrChr).GetMethod ("GetCharFromString", new Type[] { typeof (string), typeof (int) });

        private CompValu theString;
        private CompValu subscript;

        public CompValuStrChr (TokenType type, CompValu theString, CompValu subscript) : base (type)
        {
            this.theString = theString;
            this.subscript = subscript;
        }
        public override void PushVal (ScriptCodeGen scg, Token errorAt)
        {
            theString.PushVal (scg, errorAt, new TokenTypeStr (type));
            subscript.PushVal (scg, errorAt, new TokenTypeInt (type));
            scg.ilGen.Emit (errorAt, OpCodes.Call, getCharFromStringMethodInfo);
        }
        public override void PushRef (ScriptCodeGen scg, Token errorAt)
        {
            throw new Exception ("cannot get string character's address");
        }
        public override void PopPost (ScriptCodeGen scg, Token errorAt)
        {
            scg.ErrorMsg (errorAt, "cannot store into string character");
            scg.ilGen.Emit (errorAt, OpCodes.Pop);
        }

        public static char GetCharFromString (string s, int i)
        {
            return s[i];
        }
    }

    // The value is a key or string constant
    public class CompValuString : CompValu {
        public string x;

        public CompValuString (TokenType type, string x) : base (type)
        {
            if (!(type is TokenTypeKey) && !(this.type is TokenTypeStr)) {
                throw new Exception ("bad type " + type.ToString ());
            }
            this.x = x;
        }
        public override void PushVal (ScriptCodeGen scg, Token errorAt)
        {
            scg.ilGen.Emit (errorAt, OpCodes.Ldstr, x);
        }
        public override void PushRef (ScriptCodeGen scg, Token errorAt)
        {
            throw new Exception ("cannot get constant's address");
        }
        public override void PopPost (ScriptCodeGen scg, Token errorAt)
        {
            throw new Exception ("cannot store into constant");
        }
    }

    // The value is kept in a temp local variable
    public class CompValuTemp : CompValu {
        public ScriptMyLocal localBuilder;

        public CompValuTemp (TokenType type, ScriptCodeGen scg) : base (type)
        {
            string name = "tmp$" + (++ scg.tempCompValuNum);
            this.localBuilder = scg.ilGen.DeclareLocal (ToSysType(), name);
        }
        protected CompValuTemp (TokenType type) : base (type) { }  // CompValuVoid uses this

        public override void PushVal (ScriptCodeGen scg, Token errorAt)
        {
            scg.ilGen.Emit (errorAt, OpCodes.Ldloc, localBuilder);
        }
        public override void PushRef (ScriptCodeGen scg, Token errorAt)
        {
            scg.ilGen.Emit (errorAt, OpCodes.Ldloca, localBuilder);
        }
        public override void PopPost (ScriptCodeGen scg, Token errorAt)
        {
            scg.ilGen.Emit (errorAt, OpCodes.Stloc, localBuilder);
        }
        public void Pop (ScriptCodeGen scg, Token errorAt, TokenType stackType)
        {
            TypeCast.CastTopOfStack (scg, errorAt, stackType, this.type, false);
            this.PopPost (scg, errorAt);  // in case PopPost() overridden eg by CompValuVoid
        }
        public void Pop (ScriptCodeGen scg, Token errorAt)
        {
            this.PopPost (scg, errorAt);  // in case PopPost() overridden eg by CompValuVoid
        }
    }

    // The value is a vector
    public class CompValuVec : CompValu {
        public CompValu x;
        public CompValu y;
        public CompValu z;

        private static readonly ConstructorInfo lslVecConstructorInfo = 
                typeof (LSL_Vector).GetConstructor (new Type[] { typeof (double), 
                                                                 typeof (double), 
                                                                 typeof (double) });

        public CompValuVec (TokenType type, CompValu x, CompValu y, CompValu z) : base (type)
        {
            if (!(type is TokenTypeVec)) {
                this.type = new TokenTypeVec (type);
            }
            this.x = x;
            this.y = y;
            this.z = z;
        }
        public override void PushVal (ScriptCodeGen scg, Token errorAt)
        {
            this.x.PushVal (scg, errorAt, new TokenTypeFloat (this.x.type));
            this.y.PushVal (scg, errorAt, new TokenTypeFloat (this.y.type));
            this.z.PushVal (scg, errorAt, new TokenTypeFloat (this.z.type));
            scg.ilGen.Emit (errorAt, OpCodes.Newobj, lslVecConstructorInfo);
        }
        public override void PushRef (ScriptCodeGen scg, Token errorAt)
        {
            throw new Exception ("cannot get constant's address");
        }
        public override void PopPost (ScriptCodeGen scg, Token errorAt)
        {
            throw new Exception ("cannot store into constant");
        }

        public override bool IsReadTrivial (ScriptCodeGen scg, Token readAt)
        {
            // the supplied values must be trivial because when we call their PushVal()s
            // there will be stuff on the stack for all but the first PushVal() and so
            // they would have a non-empty stack at their call label.
            if (!this.x.IsReadTrivial (scg, readAt) ||
                !this.y.IsReadTrivial (scg, readAt) ||
                !this.z.IsReadTrivial (scg, readAt)) {
                throw new Exception ("vector values must be trivial");
            }

            return true;
        }
    }

    // Used to indicate value will be discarded (eg, where to put return value from a call)
    public class CompValuVoid : CompValuTemp {
        public CompValuVoid (Token token) : base ((token is TokenTypeVoid) ? (TokenTypeVoid)token : new TokenTypeVoid (token))
        { }
        public override void PushVal (ScriptCodeGen scg, Token errorAt) { }
        public override void PushRef (ScriptCodeGen scg, Token errorAt)
        {
            throw new Exception ("cannot get void address");
        }
        public override void PopPost (ScriptCodeGen scg, Token errorAt) { }
    }
}