OpenSim-Test/OpenSim/Region/ScriptEngine/YEngine/MMRScriptCompValu.cs

/*
 * 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.Yengine;
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.Yengine
{

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