OpenSim
/
OpenSimMirror
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
OpenSimMirror/OpenSim/Region/ScriptEngine/XMREngine/MMRScriptCodeGen.cs

6259 lines
288 KiB
C#
Raw Blame History

/*
* 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 System.Runtime.Serialization;
using System.Text;
using System.Threading;
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 translate a reduced script token into corresponding CIL code.
* The single script token contains a tokenized and textured version of the whole script file.
*/
namespace OpenSim.Region.ScriptEngine.XMREngine
{
public interface IScriptCodeGen
{
ScriptMyILGen ilGen { get; } // the output instruction stream
void ErrorMsg (Token token, string message);
void PushDefaultValue (TokenType type);
void PushXMRInst ();
}
public class ScriptCodeGen : IScriptCodeGen
{
private static readonly bool DEBUG_STACKCAPRES = false;
private static readonly bool DEBUG_TRYSTMT = false;
public static readonly string OBJECT_CODE_MAGIC = "XMRObjectCode";
public static int COMPILED_VERSION_VALUE = 20; // incremented when compiler changes for compatibility testing
public static readonly int CALL_FRAME_MEMUSE = 64;
public static readonly int STRING_LEN_TO_MEMUSE = 2;
public static Type xmrInstSuperType = null; // typeof whatever is actually malloc'd for script instances
// - must inherit from XMRInstAbstract
/*
* Static tables that there only needs to be one copy of for all.
*/
private static VarDict legalEventHandlers = CreateLegalEventHandlers ();
private static CompValu[] zeroCompValus = new CompValu[0];
private static TokenType[] zeroArgs = new TokenType[0];
private static TokenTypeBool tokenTypeBool = new TokenTypeBool (null);
private static TokenTypeExc tokenTypeExc = new TokenTypeExc (null);
private static TokenTypeFloat tokenTypeFlt = new TokenTypeFloat (null);
private static TokenTypeInt tokenTypeInt = new TokenTypeInt (null);
private static TokenTypeObject tokenTypeObj = new TokenTypeObject (null);
private static TokenTypeRot tokenTypeRot = new TokenTypeRot (null);
private static TokenTypeStr tokenTypeStr = new TokenTypeStr (null);
private static TokenTypeVec tokenTypeVec = new TokenTypeVec (null);
private static Type[] instanceTypeArg = new Type[] { typeof (XMRInstAbstract) };
private static string[] instanceNameArg = new string[] { "$xmrthis" };
private static ConstructorInfo lslFloatConstructorInfo = typeof (LSL_Float).GetConstructor (new Type[] { typeof (double) });
private static ConstructorInfo lslIntegerConstructorInfo = typeof (LSL_Integer).GetConstructor (new Type[] { typeof (int) });
private static ConstructorInfo lslListConstructorInfo = typeof (LSL_List).GetConstructor (new Type[] { typeof (object[]) });
public static ConstructorInfo lslRotationConstructorInfo = typeof (LSL_Rotation).GetConstructor (new Type[] { typeof (double), typeof (double), typeof (double), typeof (double) });
private static ConstructorInfo lslStringConstructorInfo = typeof (LSL_String).GetConstructor (new Type[] { typeof (string) });
public static ConstructorInfo lslVectorConstructorInfo = typeof (LSL_Vector).GetConstructor (new Type[] { typeof (double), typeof (double), typeof (double) });
private static ConstructorInfo scriptBadCallNoExceptionConstructorInfo = typeof (ScriptBadCallNoException).GetConstructor (new Type[] { typeof (int) });
private static ConstructorInfo scriptChangeStateExceptionConstructorInfo = typeof (ScriptChangeStateException).GetConstructor (new Type[] { typeof (int) });
private static ConstructorInfo scriptRestoreCatchExceptionConstructorInfo = typeof (ScriptRestoreCatchException).GetConstructor (new Type[] { typeof (Exception) });
private static ConstructorInfo scriptUndefinedStateExceptionConstructorInfo = typeof (ScriptUndefinedStateException).GetConstructor (new Type[] { typeof (string) });
private static ConstructorInfo sdtClassConstructorInfo = typeof (XMRSDTypeClObj).GetConstructor (new Type[] { typeof (XMRInstAbstract), typeof (int) });
private static ConstructorInfo xmrArrayConstructorInfo = typeof (XMR_Array).GetConstructor (new Type[] { typeof (XMRInstAbstract) });
private static FieldInfo callModeFieldInfo = typeof (XMRInstAbstract).GetField ("callMode");
private static FieldInfo doGblInitFieldInfo = typeof (XMRInstAbstract).GetField ("doGblInit");
private static FieldInfo ehArgsFieldInfo = typeof (XMRInstAbstract).GetField ("ehArgs");
private static FieldInfo rotationXFieldInfo = typeof (LSL_Rotation).GetField ("x");
private static FieldInfo rotationYFieldInfo = typeof (LSL_Rotation).GetField ("y");
private static FieldInfo rotationZFieldInfo = typeof (LSL_Rotation).GetField ("z");
private static FieldInfo rotationSFieldInfo = typeof (LSL_Rotation).GetField ("s");
private static FieldInfo sdtXMRInstFieldInfo = typeof (XMRSDTypeClObj).GetField ("xmrInst");
private static FieldInfo vectorXFieldInfo = typeof (LSL_Vector).GetField ("x");
private static FieldInfo vectorYFieldInfo = typeof (LSL_Vector).GetField ("y");
private static FieldInfo vectorZFieldInfo = typeof (LSL_Vector).GetField ("z");
private static MethodInfo arrayClearMethodInfo = typeof (XMR_Array).GetMethod ("__pub_clear", new Type[] { });
private static MethodInfo arrayCountMethodInfo = typeof (XMR_Array).GetMethod ("__pub_count", new Type[] { });
private static MethodInfo arrayIndexMethodInfo = typeof (XMR_Array).GetMethod ("__pub_index", new Type[] { typeof (int) });
private static MethodInfo arrayValueMethodInfo = typeof (XMR_Array).GetMethod ("__pub_value", new Type[] { typeof (int) });
private static MethodInfo checkRunStackMethInfo = typeof (XMRInstAbstract).GetMethod ("CheckRunStack", new Type[] { });
private static MethodInfo checkRunQuickMethInfo = typeof (XMRInstAbstract).GetMethod ("CheckRunQuick", new Type[] { });
private static MethodInfo ehArgUnwrapFloat = GetStaticMethod (typeof (TypeCast), "EHArgUnwrapFloat", new Type[] { typeof (object) });
private static MethodInfo ehArgUnwrapInteger = GetStaticMethod (typeof (TypeCast), "EHArgUnwrapInteger", new Type[] { typeof (object) });
private static MethodInfo ehArgUnwrapRotation = GetStaticMethod (typeof (TypeCast), "EHArgUnwrapRotation", new Type[] { typeof (object) });
private static MethodInfo ehArgUnwrapString = GetStaticMethod (typeof (TypeCast), "EHArgUnwrapString", new Type[] { typeof (object) });
private static MethodInfo ehArgUnwrapVector = GetStaticMethod (typeof (TypeCast), "EHArgUnwrapVector", new Type[] { typeof (object) });
private static MethodInfo xmrArrPubIndexMethod = typeof (XMR_Array).GetMethod ("__pub_index", new Type[] { typeof (int) });
private static MethodInfo xmrArrPubValueMethod = typeof (XMR_Array).GetMethod ("__pub_value", new Type[] { typeof (int) });
private static MethodInfo captureStackFrameMethodInfo = typeof (XMRInstAbstract).GetMethod ("CaptureStackFrame", new Type[] { typeof (string), typeof (int), typeof (int) });
private static MethodInfo restoreStackFrameMethodInfo = typeof (XMRInstAbstract).GetMethod ("RestoreStackFrame", new Type[] { typeof (string), typeof (int).MakeByRefType () });
private static MethodInfo stringCompareMethodInfo = GetStaticMethod (typeof (String), "Compare", new Type[] { typeof (string), typeof (string), typeof (StringComparison) });
private static MethodInfo stringConcat2MethodInfo = GetStaticMethod (typeof (String), "Concat", new Type[] { typeof (string), typeof (string) });
private static MethodInfo stringConcat3MethodInfo = GetStaticMethod (typeof (String), "Concat", new Type[] { typeof (string), typeof (string), typeof (string) });
private static MethodInfo stringConcat4MethodInfo = GetStaticMethod (typeof (String), "Concat", new Type[] { typeof (string), typeof (string), typeof (string), typeof (string) });
private static MethodInfo lslRotationNegateMethodInfo = GetStaticMethod (typeof (ScriptCodeGen),
"LSLRotationNegate",
new Type[] { typeof (LSL_Rotation) });
private static MethodInfo lslVectorNegateMethodInfo = GetStaticMethod (typeof (ScriptCodeGen),
"LSLVectorNegate",
new Type[] { typeof (LSL_Vector) });
private static MethodInfo scriptRestoreCatchExceptionUnwrap = GetStaticMethod (typeof (ScriptRestoreCatchException), "Unwrap", new Type[] { typeof (Exception) });
private static MethodInfo thrownExceptionWrapMethodInfo = GetStaticMethod (typeof (ScriptThrownException), "Wrap", new Type[] { typeof (object) });
private static MethodInfo catchExcToStrMethodInfo = GetStaticMethod (typeof (ScriptCodeGen),
"CatchExcToStr",
new Type[] { typeof (Exception) });
private static MethodInfo consoleWriteMethodInfo = GetStaticMethod (typeof (ScriptCodeGen), "ConsoleWrite", new Type[] { typeof (object) });
public static void ConsoleWrite (object o)
{
if (o == null) o = "<<null>>";
Console.Write (o.ToString ());
}
public static bool CodeGen (TokenScript tokenScript, BinaryWriter objFileWriter, string sourceHash)
{
/*
* Run compiler such that it has a 'this' context for convenience.
*/
ScriptCodeGen scg = new ScriptCodeGen (tokenScript, objFileWriter, sourceHash);
/*
* Return pointer to resultant script object code.
*/
return !scg.youveAnError;
}
/*
* There is one set of these variables for each script being compiled.
*/
private bool mightGetHere = false;
private bool youveAnError = false;
private BreakContTarg curBreakTarg = null;
private BreakContTarg curContTarg = null;
private int lastErrorLine = 0;
private int nStates = 0;
private string sourceHash;
private string lastErrorFile = "";
private string[] stateNames;
private XMRInstArSizes glblSizes = new XMRInstArSizes ();
private Token errorMessageToken = null;
private TokenDeclVar curDeclFunc = null;
private TokenStmtBlock curStmtBlock = null;
private BinaryWriter objFileWriter = null;
private TokenScript tokenScript = null;
public int tempCompValuNum = 0;
private TokenDeclSDTypeClass currentSDTClass = null;
private Dictionary<string, int> stateIndices = null;
// These get cleared at beginning of every function definition
private ScriptMyLocal instancePointer; // holds XMRInstanceSuperType pointer
private ScriptMyLabel retLabel = null; // where to jump to exit function
private ScriptMyLocal retValue = null;
private ScriptMyLocal actCallNo = null; // for the active try/catch/finally stack or the big one outside them all
private LinkedList<CallLabel> actCallLabels = new LinkedList<CallLabel> (); // for the active try/catch/finally stack or the big one outside them all
private LinkedList<CallLabel> allCallLabels = new LinkedList<CallLabel> (); // this holds each and every one for all stacks in total
public CallLabel openCallLabel = null; // only one call label can be open at a time
// - the call label is open from the time of CallPre() until corresponding CallPost()
// - so no non-trivial pushes/pops etc allowed between a CallPre() and a CallPost()
private ScriptMyILGen _ilGen;
public ScriptMyILGen ilGen { get { return _ilGen; } }
private ScriptCodeGen (TokenScript tokenScript, BinaryWriter objFileWriter, string sourceHash)
{
this.tokenScript = tokenScript;
this.objFileWriter = objFileWriter;
this.sourceHash = sourceHash;
try {
PerformCompilation ();
} catch {
// if we've an error, just punt on any exception
// it's probably just a null reference from something
// not being filled in etc.
if (!youveAnError) throw;
} finally {
objFileWriter = null;
}
}
/**
* @brief Convert 'tokenScript' to 'objFileWriter' format.
* 'tokenScript' is a parsed/reduced abstract syntax tree of the script source file
* 'objFileWriter' is a serialized form of the CIL code that we generate
*/
private void PerformCompilation ()
{
/*
* errorMessageToken is used only when the given token doesn't have a
* output delegate associated with it such as for backend API functions
* that only have one copy for the whole system. It is kept up-to-date
* approximately but is rarely needed so going to assume it doesn't have
* to be exact.
*/
errorMessageToken = tokenScript;
/*
* Set up dictionary to translate state names to their index number.
*/
stateIndices = new Dictionary<string, int> ();
/*
* Assign each state its own unique index.
* The default state gets 0.
*/
nStates = 0;
tokenScript.defaultState.body.index = nStates ++;
stateIndices.Add ("default", 0);
foreach (KeyValuePair<string, TokenDeclState> kvp in tokenScript.states) {
TokenDeclState declState = kvp.Value;
declState.body.index = nStates ++;
stateIndices.Add (declState.name.val, declState.body.index);
}
/*
* Make up an array that translates state indices to state name strings.
*/
stateNames = new string[nStates];
stateNames[0] = "default";
foreach (KeyValuePair<string, TokenDeclState> kvp in tokenScript.states) {
TokenDeclState declState = kvp.Value;
stateNames[declState.body.index] = declState.name.val;
}
/*
* Make sure we have delegates for all script-defined functions and methods,
* creating anonymous ones if needed. Note that this includes all property
* getter and setter methods.
*/
foreach (TokenDeclVar declFunc in tokenScript.variablesStack) {
if (declFunc.retType != null) {
declFunc.GetDelType ();
}
}
while (true) {
bool itIsAGoodDayToDie = true;
try {
foreach (TokenDeclSDType sdType in tokenScript.sdSrcTypesValues) {
itIsAGoodDayToDie = false;
if (sdType is TokenDeclSDTypeClass) {
TokenDeclSDTypeClass sdtClass = (TokenDeclSDTypeClass)sdType;
foreach (TokenDeclVar declFunc in sdtClass.members) {
if (declFunc.retType != null) {
declFunc.GetDelType ();
if (declFunc.funcNameSig.val.StartsWith ("$ctor(")) {
// this is for the "$new()" static method that we create below.
// See GenerateStmtNewobj() etc.
new TokenTypeSDTypeDelegate (declFunc, sdtClass.MakeRefToken (declFunc),
declFunc.argDecl.types, tokenScript);
}
}
}
}
if (sdType is TokenDeclSDTypeInterface) {
TokenDeclSDTypeInterface sdtIFace = (TokenDeclSDTypeInterface)sdType;
foreach (TokenDeclVar declFunc in sdtIFace.methsNProps) {
if (declFunc.retType != null) {
declFunc.GetDelType ();
}
}
}
itIsAGoodDayToDie = true;
}
break;
} catch (InvalidOperationException) {
if (!itIsAGoodDayToDie) throw;
// fetching the delegate created an anonymous entry in tokenScript.sdSrcTypesValues
// which made the foreach statement puque, so start over...
}
}
/*
* No more types can be defined or we won't be able to write them to the object file.
*/
tokenScript.sdSrcTypesSeal ();
/*
* Assign all global variables a slot in its corresponding XMRInstance.gbl<Type>s[] array.
* Global variables are simply elements of those arrays at runtime, thus we don't need to create
* an unique class for each script, we can just use XMRInstance as is for all.
*/
foreach (TokenDeclVar declVar in tokenScript.variablesStack) {
/*
* Omit 'constant' variables as they are coded inline so don't need a slot.
*/
if (declVar.constant) continue;
/*
* Do functions later.
*/
if (declVar.retType != null) continue;
/*
* Create entry in the value array for the variable or property.
*/
declVar.location = new CompValuGlobalVar (declVar, glblSizes);
}
/*
* Likewise for any static fields in script-defined classes.
* They can be referenced anywhere by <typename>.<fieldname>, see
* GenerateFromLValSField().
*/
foreach (TokenDeclSDType sdType in tokenScript.sdSrcTypesValues) {
if (!(sdType is TokenDeclSDTypeClass)) continue;
TokenDeclSDTypeClass sdtClass = (TokenDeclSDTypeClass)sdType;
foreach (TokenDeclVar declVar in sdtClass.members) {
/*
* Omit 'constant' variables as they are coded inline so don't need a slot.
*/
if (declVar.constant) continue;
/*
* Do methods later.
*/
if (declVar.retType != null) continue;
/*
* Ignore non-static fields for now.
* They get assigned below.
*/
if ((declVar.sdtFlags & ScriptReduce.SDT_STATIC) == 0) continue;
/*
* Create entry in the value array for the static field or static property.
*/
declVar.location = new CompValuGlobalVar (declVar, glblSizes);
}
}
/*
* Assign slots for all interface method prototypes.
* These indices are used to index the array of delegates that holds a class' implementation of an
* interface.
* Properties do not get a slot because they aren't called as such. But their corresponding
* <name>$get() and <name>$set(<type>) methods are in the table and they each get a slot.
*/
foreach (TokenDeclSDType sdType in tokenScript.sdSrcTypesValues) {
if (!(sdType is TokenDeclSDTypeInterface)) continue;
TokenDeclSDTypeInterface sdtIFace = (TokenDeclSDTypeInterface)sdType;
int vti = 0;
foreach (TokenDeclVar im in sdtIFace.methsNProps) {
if ((im.getProp == null) && (im.setProp == null)) {
im.vTableIndex = vti ++;
}
}
}
/*
* Assign slots for all instance fields and virtual methods of script-defined classes.
*/
int maxExtends = tokenScript.sdSrcTypesCount;
bool didOne;
do {
didOne = false;
foreach (TokenDeclSDType sdType in tokenScript.sdSrcTypesValues) {
if (!(sdType is TokenDeclSDTypeClass)) continue;
TokenDeclSDTypeClass sdtClass = (TokenDeclSDTypeClass)sdType;
if (sdtClass.slotsAssigned) continue;
/*
* If this class extends another, the extended class has to already
* be set up, because our slots add on to the end of the extended class.
*/
TokenDeclSDTypeClass extends = sdtClass.extends;
if (extends != null) {
if (!extends.slotsAssigned) continue;
sdtClass.instSizes = extends.instSizes;
sdtClass.numVirtFuncs = extends.numVirtFuncs;
sdtClass.numInterfaces = extends.numInterfaces;
int n = maxExtends;
for (TokenDeclSDTypeClass ex = extends; ex != null; ex = ex.extends) {
if (-- n < 0) break;
}
if (n < 0) {
ErrorMsg (sdtClass, "loop in extended classes");
sdtClass.slotsAssigned = true;
continue;
}
}
/*
* Extended class's slots all assigned, assign our instance fields
* slots in the XMRSDTypeClObj arrays.
*/
foreach (TokenDeclVar declVar in sdtClass.members) {
if (declVar.retType != null) continue;
if (declVar.constant) continue;
if ((declVar.sdtFlags & ScriptReduce.SDT_STATIC) != 0) continue;
if ((declVar.getProp == null) && (declVar.setProp == null)) {
declVar.type.AssignVarSlot (declVar, sdtClass.instSizes);
}
}
/*
* ... and assign virtual method vtable slots.
*
* - : error if any overridden method, doesn't need a slot
* abstract : error if any overridden method, alloc new slot but leave it empty
* new : ignore any overridden method, doesn't need a slot
* new abstract : ignore any overridden method, alloc new slot but leave it empty
* override : must have overridden abstract/virtual, use old slot
* override abstract : must have overridden abstract, use old slot but it is still empty
* static : error if any overridden method, doesn't need a slot
* static new : ignore any overridden method, doesn't need a slot
* virtual : error if any overridden method, alloc new slot and fill it in
* virtual new : ignore any overridden method, alloc new slot and fill it in
*/
foreach (TokenDeclVar declFunc in sdtClass.members) {
if (declFunc.retType == null) continue;
curDeclFunc = declFunc;
/*
* See if there is a method in an extended class that this method overshadows.
* If so, check for various conflicts.
* In any case, SDT_NEW on our method means to ignore any overshadowed method.
*/
string declLongName = sdtClass.longName.val + "." + declFunc.funcNameSig.val;
uint declFlags = declFunc.sdtFlags;
TokenDeclVar overridden = null;
if ((declFlags & ScriptReduce.SDT_NEW) == 0) {
for (TokenDeclSDTypeClass sdtd = extends; sdtd != null; sdtd = sdtd.extends) {
overridden = FindExactWithRet (sdtd.members, declFunc.name, declFunc.retType, declFunc.argDecl.types);
if (overridden != null) break;
}
}
if (overridden != null) do {
string overLongName = overridden.sdtClass.longName.val;
uint overFlags = overridden.sdtFlags;
/*
* See if overridden method allows itself to be overridden.
*/
if ((overFlags & ScriptReduce.SDT_ABSTRACT) != 0) {
if ((declFlags & (ScriptReduce.SDT_ABSTRACT | ScriptReduce.SDT_OVERRIDE)) == 0) {
ErrorMsg (declFunc, declLongName + " overshadows abstract " + overLongName + " but is not marked abstract, new or override");
break;
}
} else if ((overFlags & ScriptReduce.SDT_FINAL) != 0) {
ErrorMsg (declFunc, declLongName + " overshadows final " + overLongName + " but is not marked new");
} else if ((overFlags & (ScriptReduce.SDT_OVERRIDE | ScriptReduce.SDT_VIRTUAL)) != 0) {
if ((declFlags & (ScriptReduce.SDT_NEW | ScriptReduce.SDT_OVERRIDE)) == 0) {
ErrorMsg (declFunc, declLongName + " overshadows virtual " + overLongName + " but is not marked new or override");
break;
}
} else {
ErrorMsg (declFunc, declLongName + " overshadows non-virtual " + overLongName + " but is not marked new");
break;
}
/*
* See if our method is capable of overriding the other method.
*/
if ((declFlags & ScriptReduce.SDT_ABSTRACT) != 0) {
if ((overFlags & ScriptReduce.SDT_ABSTRACT) == 0) {
ErrorMsg (declFunc, declLongName + " abstract overshadows non-abstract " + overLongName + " but is not marked new");
break;
}
} else if ((declFlags & ScriptReduce.SDT_OVERRIDE) != 0) {
if ((overFlags & (ScriptReduce.SDT_ABSTRACT | ScriptReduce.SDT_OVERRIDE | ScriptReduce.SDT_VIRTUAL)) == 0) {
ErrorMsg (declFunc, declLongName + " override overshadows non-abstract/non-virtual " + overLongName);
break;
}
} else {
ErrorMsg (declFunc, declLongName + " overshadows " + overLongName + " but is not marked new");
break;
}
} while (false);
/*
* Now we can assign it a vtable slot if it needs one (ie, it is virtual).
*/
declFunc.vTableIndex = -1;
if (overridden != null) {
declFunc.vTableIndex = overridden.vTableIndex;
} else if ((declFlags & ScriptReduce.SDT_OVERRIDE) != 0) {
ErrorMsg (declFunc, declLongName + " marked override but nothing matching found that it overrides");
}
if ((declFlags & (ScriptReduce.SDT_ABSTRACT | ScriptReduce.SDT_VIRTUAL)) != 0) {
declFunc.vTableIndex = sdtClass.numVirtFuncs ++;
}
}
curDeclFunc = null;
/*
* ... and assign implemented interface slots.
* Note that our implementations of a given interface is completely independent of any
* rootward class's implementation of that same interface.
*/
int nIFaces = sdtClass.numInterfaces + sdtClass.implements.Count;
sdtClass.iFaces = new TokenDeclSDTypeInterface[nIFaces];
sdtClass.iImplFunc = new TokenDeclVar[nIFaces][];
for (int i = 0; i < sdtClass.numInterfaces; i ++) {
sdtClass.iFaces[i] = extends.iFaces[i];
sdtClass.iImplFunc[i] = extends.iImplFunc[i];
}
foreach (TokenDeclSDTypeInterface intf in sdtClass.implements) {
int i = sdtClass.numInterfaces ++;
sdtClass.iFaces[i] = intf;
sdtClass.intfIndices.Add (intf.longName.val, i);
int nMeths = 0;
foreach (TokenDeclVar m in intf.methsNProps) {
if ((m.getProp == null) && (m.setProp == null)) nMeths ++;
}
sdtClass.iImplFunc[i] = new TokenDeclVar[nMeths];
}
foreach (TokenDeclVar classMeth in sdtClass.members) {
if (classMeth.retType == null) continue;
curDeclFunc = classMeth;
for (TokenIntfImpl intfImpl = classMeth.implements; intfImpl != null; intfImpl = (TokenIntfImpl)intfImpl.nextToken) {
/*
* One of the class methods implements an interface method.
* Try to find the interface method that is implemented and verify its signature.
*/
TokenDeclSDTypeInterface intfType = intfImpl.intfType.decl;
TokenDeclVar intfMeth = FindExactWithRet (intfType.methsNProps, intfImpl.methName, classMeth.retType, classMeth.argDecl.types);
if (intfMeth == null) {
ErrorMsg (intfImpl, "interface does not define method " + intfImpl.methName.val + classMeth.argDecl.GetArgSig ());
continue;
}
/*
* See if this class was declared to implement that interface.
*/
bool found = false;
foreach (TokenDeclSDTypeInterface intf in sdtClass.implements) {
if (intf == intfType) {
found = true;
break;
}
}
if (!found) {
ErrorMsg (intfImpl, "class not declared to implement " + intfType.longName.val);
continue;
}
/*
* Get index in iFaces[] and iImplFunc[] arrays.
* Start scanning from the end in case one of our rootward classes also implements the interface.
* We should always be successful because we know by now that this class implements the interface.
*/
int i;
for (i = sdtClass.numInterfaces; -- i >= 0;) {
if (sdtClass.iFaces[i] == intfType) break;
}
/*
* Now remember which of the class methods implements that interface method.
*/
int j = intfMeth.vTableIndex;
if (sdtClass.iImplFunc[i][j] != null) {
ErrorMsg (intfImpl, "also implemented by " + sdtClass.iImplFunc[i][j].funcNameSig.val);
continue;
}
sdtClass.iImplFunc[i][j] = classMeth;
}
}
curDeclFunc = null;
/*
* Now make sure this class implements all methods for all declared interfaces.
*/
for (int i = sdtClass.numInterfaces - sdtClass.implements.Count; i < sdtClass.numInterfaces; i ++) {
TokenDeclVar[] implementations = sdtClass.iImplFunc[i];
for (int j = implementations.Length; -- j >= 0;) {
if (implementations[j] == null) {
TokenDeclSDTypeInterface intf = sdtClass.iFaces[i];
TokenDeclVar meth = null;
foreach (TokenDeclVar im in intf.methsNProps) {
if (im.vTableIndex == j) {
meth = im;
break;
}
}
ErrorMsg (sdtClass, "does not implement " + intf.longName.val + "." + meth.funcNameSig.val);
}
}
}
/*
* All slots for this class have been assigned.
*/
sdtClass.slotsAssigned = true;
didOne = true;
}
} while (didOne);
/*
* Compute final values for all variables/fields declared as 'constant'.
* Note that there may be forward references.
*/
do {
didOne = false;
foreach (TokenDeclVar tdv in tokenScript.variablesStack) {
if (tdv.constant && !(tdv.init is TokenRValConst)) {
tdv.init = tdv.init.TryComputeConstant (LookupInitConstants, ref didOne);
}
}
foreach (TokenDeclSDType sdType in tokenScript.sdSrcTypesValues) {
if (!(sdType is TokenDeclSDTypeClass)) continue;
currentSDTClass = (TokenDeclSDTypeClass)sdType;
foreach (TokenDeclVar tdv in currentSDTClass.members) {
if (tdv.constant && !(tdv.init is TokenRValConst)) {
tdv.init = tdv.init.TryComputeConstant (LookupInitConstants, ref didOne);
}
}
}
currentSDTClass = null;
} while (didOne);
/*
* Now we should be able to assign all those constants their type and location.
*/
foreach (TokenDeclVar tdv in tokenScript.variablesStack) {
if (tdv.constant) {
if (tdv.init is TokenRValConst) {
TokenRValConst rvc = (TokenRValConst)tdv.init;
tdv.type = rvc.tokType;
tdv.location = rvc.GetCompValu ();
} else {
ErrorMsg (tdv, "value is not constant");
}
}
}
foreach (TokenDeclSDType sdType in tokenScript.sdSrcTypesValues) {
if (!(sdType is TokenDeclSDTypeClass)) continue;
currentSDTClass = (TokenDeclSDTypeClass)sdType;
foreach (TokenDeclVar tdv in currentSDTClass.members) {
if (tdv.constant) {
if (tdv.init is TokenRValConst) {
TokenRValConst rvc = (TokenRValConst)tdv.init;
tdv.type = rvc.tokType;
tdv.location = rvc.GetCompValu ();
} else {
ErrorMsg (tdv, "value is not constant");
}
}
}
}
currentSDTClass = null;
/*
* For all classes that define all the methods needed for the class, ie, they aren't abstract,
* define a static class.$new() method with same args as the $ctor(s). This will allow the
* class to be instantiated via the new operator.
*/
foreach (TokenDeclSDType sdType in tokenScript.sdSrcTypesValues) {
if (!(sdType is TokenDeclSDTypeClass)) continue;
TokenDeclSDTypeClass sdtClass = (TokenDeclSDTypeClass)sdType;
/*
* See if the class as it stands would be able to fill every slot of its vtable.
*/
bool[] filled = new bool[sdtClass.numVirtFuncs];
int numFilled = 0;
for (TokenDeclSDTypeClass sdtc = sdtClass; sdtc != null; sdtc = sdtc.extends) {
foreach (TokenDeclVar tdf in sdtc.members) {
if ((tdf.retType != null) && (tdf.vTableIndex >= 0) && ((tdf.sdtFlags & ScriptReduce.SDT_ABSTRACT) == 0)) {
if (!filled[tdf.vTableIndex]) {
filled[tdf.vTableIndex] = true;
numFilled ++;
}
}
}
}
/*
* If so, define a static class.$new() method for every constructor defined for the class.
* Give it the same access (private/protected/public) as the script declared for the constructor.
* Note that the reducer made sure there is at least a default constructor for every class.
*/
if (numFilled >= sdtClass.numVirtFuncs) {
List<TokenDeclVar> newobjDeclFuncs = new List<TokenDeclVar> ();
foreach (TokenDeclVar ctorDeclFunc in sdtClass.members) {
if ((ctorDeclFunc.funcNameSig != null) && ctorDeclFunc.funcNameSig.val.StartsWith ("$ctor(")) {
TokenDeclVar newobjDeclFunc = DefineNewobjFunc (ctorDeclFunc);
newobjDeclFuncs.Add (newobjDeclFunc);
}
}
foreach (TokenDeclVar newobjDeclFunc in newobjDeclFuncs) {
sdtClass.members.AddEntry (newobjDeclFunc);
}
}
}
/*
* Write fixed portion of object file.
*/
objFileWriter.Write (OBJECT_CODE_MAGIC.ToCharArray ());
objFileWriter.Write (COMPILED_VERSION_VALUE);
objFileWriter.Write (sourceHash);
objFileWriter.Write (tokenScript.expiryDays);
glblSizes.WriteToFile (objFileWriter);
objFileWriter.Write (nStates);
for (int i = 0; i < nStates; i ++) {
objFileWriter.Write (stateNames[i]);
}
/*
* For debugging, we also write out global variable array slot assignments.
*/
foreach (TokenDeclVar declVar in tokenScript.variablesStack) {
if (declVar.retType == null) {
WriteOutGblAssignment ("", declVar);
}
}
foreach (TokenDeclSDType sdType in tokenScript.sdSrcTypesValues) {
if (!(sdType is TokenDeclSDTypeClass)) continue;
TokenDeclSDTypeClass sdtClass = (TokenDeclSDTypeClass)sdType;
foreach (TokenDeclVar declVar in sdtClass.members) {
if ((declVar.sdtFlags & ScriptReduce.SDT_STATIC) != 0) {
WriteOutGblAssignment (sdtClass.longName.val + ".", declVar);
}
}
}
objFileWriter.Write ("");
/*
* Write out script-defined types.
*/
foreach (TokenDeclSDType sdType in tokenScript.sdSrcTypesValues) {
objFileWriter.Write (sdType.longName.val);
sdType.WriteToFile (objFileWriter);
}
objFileWriter.Write ("");
/*
* Output function headers then bodies.
* Do all headers first in case bodies do forward references.
* Do both global functions, script-defined class static methods and
* script-defined instance methods, as we handle the differences
* during compilation of the functions/methods themselves.
*/
for (int pass = 0; pass < 2; pass ++) {
foreach (TokenDeclVar declFunc in tokenScript.variablesStack) {
if (declFunc.retType != null) {
if (pass == 0) GenerateMethodHeader (declFunc);
else GenerateMethodBody (declFunc);
}
}
foreach (TokenDeclSDType sdType in tokenScript.sdSrcTypesValues) {
if (sdType is TokenDeclSDTypeClass) {
TokenDeclSDTypeClass sdtClass = (TokenDeclSDTypeClass)sdType;
foreach (TokenDeclVar declFunc in sdtClass.members) {
if ((declFunc.retType != null) && ((declFunc.sdtFlags & ScriptReduce.SDT_ABSTRACT) == 0)) {
if (pass == 0) GenerateMethodHeader (declFunc);
else GenerateMethodBody (declFunc);
}
}
}
}
}
/*
* Output default state event handler functions.
* Each event handler is a private static method named 'default <eventname>'.
* Splice in a default state_entry() handler if none defined so we can init global vars.
*/
TokenDeclVar defaultStateEntry = null;
for (defaultStateEntry = tokenScript.defaultState.body.eventFuncs;
defaultStateEntry != null;
defaultStateEntry = (TokenDeclVar)defaultStateEntry.nextToken) {
if (defaultStateEntry.funcNameSig.val == "state_entry()") break;
}
if (defaultStateEntry == null) {
defaultStateEntry = new TokenDeclVar (tokenScript.defaultState.body, null, tokenScript);
defaultStateEntry.name = new TokenName (tokenScript.defaultState.body, "state_entry");
defaultStateEntry.retType = new TokenTypeVoid (tokenScript.defaultState.body);
defaultStateEntry.argDecl = new TokenArgDecl (tokenScript.defaultState.body);
defaultStateEntry.body = new TokenStmtBlock (tokenScript.defaultState.body);
defaultStateEntry.body.function = defaultStateEntry;
defaultStateEntry.nextToken = tokenScript.defaultState.body.eventFuncs;
tokenScript.defaultState.body.eventFuncs = defaultStateEntry;
}
GenerateStateEventHandlers ("default", tokenScript.defaultState.body);
/*
* Output script-defined state event handler methods.
* Each event handler is a private static method named <statename> <eventname>
*/
foreach (KeyValuePair<string, TokenDeclState> kvp in tokenScript.states) {
TokenDeclState declState = kvp.Value;
GenerateStateEventHandlers (declState.name.val, declState.body);
}
ScriptObjWriter.TheEnd (objFileWriter);
}
/**
* @brief Write out what slot was assigned for a global or sdtclass static variable.
* Constants, functions, instance fields, methods, properties do not have slots in the global variables arrays.
*/
private void WriteOutGblAssignment (string pfx, TokenDeclVar declVar)
{
if (!declVar.constant && (declVar.retType == null) && (declVar.getProp == null) && (declVar.setProp == null)) {
objFileWriter.Write (pfx + declVar.name.val); // string
objFileWriter.Write (declVar.vTableArray.Name); // string
objFileWriter.Write (declVar.vTableIndex); // int
}
}
/**
* @brief generate event handler code
* Writes out a function definition for each state handler
* named <statename> <eventname>
*
* However, each has just 'XMRInstance __sw' as its single argument
* and each of its user-visible argments is extracted from __sw.ehArgs[].
*
* So we end up generating something like this:
*
* private static void <statename> <eventname>(XMRInstance __sw)
* {
* <typeArg0> <nameArg0> = (<typeArg0>)__sw.ehArgs[0];
* <typeArg1> <nameArg1> = (<typeArg1>)__sw.ehArgs[1];
*
* ... script code ...
* }
*
* The continuations code assumes there will be no references to ehArgs[]
* after the first call to CheckRun() as CheckRun() makes no attempt to
* serialize the ehArgs[] array, as doing so would be redundant. Any values
* from ehArgs[] that are being used will be in local stack variables and
* thus preserved that way.
*/
private void GenerateStateEventHandlers (string statename, TokenStateBody body)
{
Dictionary<string,TokenDeclVar> statehandlers = new Dictionary<string,TokenDeclVar> ();
for (Token t = body.eventFuncs; t != null; t = t.nextToken) {
TokenDeclVar tdv = (TokenDeclVar)t;
string eventname = tdv.GetSimpleName ();
if (statehandlers.ContainsKey (eventname)) {
ErrorMsg (tdv, "event handler " + eventname + " already defined for state " + statename);
} else {
statehandlers.Add (eventname, tdv);
GenerateEventHandler (statename, tdv);
}
}
}
private void GenerateEventHandler (string statename, TokenDeclVar declFunc)
{
string eventname = declFunc.GetSimpleName ();
TokenArgDecl argDecl = declFunc.argDecl;
/*
* Make sure event handler name is valid and that number and type of arguments is correct.
* Apparently some scripts exist with fewer than correct number of args in their declaration
* so allow for that. It is ok because the handlers are called with the arguments in an
* object[] array, and we just won't access the missing argments in the vector. But the
* specified types must match one of the prototypes in legalEventHandlers.
*/
TokenDeclVar protoDeclFunc = legalEventHandlers.FindExact (eventname, argDecl.types);
if (protoDeclFunc == null) {
ErrorMsg (declFunc, "unknown event handler " + eventname + argDecl.GetArgSig ());
return;
}
/*
* Output function header.
* They just have the XMRInstAbstract pointer as the one argument.
*/
string functionName = statename + " " + eventname;
_ilGen = new ScriptObjWriter (tokenScript,
functionName,
typeof (void),
instanceTypeArg,
instanceNameArg,
objFileWriter);
StartFunctionBody (declFunc);
/*
* Create a temp to hold XMRInstanceSuperType version of arg 0.
*/
instancePointer = ilGen.DeclareLocal (xmrInstSuperType, "__xmrinst");
ilGen.Emit (declFunc, OpCodes.Ldarg_0);
ilGen.Emit (declFunc, OpCodes.Castclass, xmrInstSuperType);
ilGen.Emit (declFunc, OpCodes.Stloc, instancePointer);
/*
* Output args as variable definitions and initialize each from __sw.ehArgs[].
* If the script writer goofed, the typecast will complain.
*/
int nArgs = argDecl.vars.Length;
for (int i = 0; i < nArgs; i ++) {
/*
* Say that the argument variable is going to be located in a local var.
*/
TokenDeclVar argVar = argDecl.vars[i];
TokenType argTokType = argVar.type;
CompValuLocalVar local = new CompValuLocalVar (argTokType, argVar.name.val, this);
argVar.location = local;
/*
* Copy from the ehArgs[i] element to the temp var.
* Cast as needed, there is a lot of craziness like OpenMetaverse.Quaternion.
*/
local.PopPre (this, argVar.name);
PushXMRInst (); // instance
ilGen.Emit (declFunc, OpCodes.Ldfld, ehArgsFieldInfo); // instance.ehArgs (array of objects)
ilGen.Emit (declFunc, OpCodes.Ldc_I4, i); // array index = i
ilGen.Emit (declFunc, OpCodes.Ldelem, typeof (object)); // select the argument we want
TokenType stkTokType = tokenTypeObj; // stack has a type 'object' on it now
Type argSysType = argTokType.ToSysType (); // this is the type the script expects
if (argSysType == typeof (double)) { // LSL_Float/double -> double
ilGen.Emit (declFunc, OpCodes.Call, ehArgUnwrapFloat);
stkTokType = tokenTypeFlt; // stack has a type 'double' on it now
}
if (argSysType == typeof (int)) { // LSL_Integer/int -> int
ilGen.Emit (declFunc, OpCodes.Call, ehArgUnwrapInteger);
stkTokType = tokenTypeInt; // stack has a type 'int' on it now
}
if (argSysType == typeof (LSL_List)) { // LSL_List -> LSL_List
TypeCast.CastTopOfStack (this, argVar.name, stkTokType, argTokType, true);
stkTokType = argTokType; // stack has a type 'LSL_List' on it now
}
if (argSysType == typeof (LSL_Rotation)) { // OpenMetaverse.Quaternion/LSL_Rotation -> LSL_Rotation
ilGen.Emit (declFunc, OpCodes.Call, ehArgUnwrapRotation);
stkTokType = tokenTypeRot; // stack has a type 'LSL_Rotation' on it now
}
if (argSysType == typeof (string)) { // LSL_Key/LSL_String/string -> string
ilGen.Emit (declFunc, OpCodes.Call, ehArgUnwrapString);
stkTokType = tokenTypeStr; // stack has a type 'string' on it now
}
if (argSysType == typeof (LSL_Vector)) { // OpenMetaverse.Vector3/LSL_Vector -> LSL_Vector
ilGen.Emit (declFunc, OpCodes.Call, ehArgUnwrapVector);
stkTokType = tokenTypeVec; // stack has a type 'LSL_Vector' on it now
}
local.PopPost (this, argVar.name, stkTokType); // pop stack type into argtype
}
/*
* Output code for the statements and clean up.
*/
GenerateFuncBody ();
}
/**
* @brief generate header for an arbitrary script-defined global function.
* @param declFunc = function being defined
*/
private void GenerateMethodHeader (TokenDeclVar declFunc)
{
curDeclFunc = declFunc;
/*
* Make up array of all argument types as seen by the code generator.
* We splice in XMRInstanceSuperType or XMRSDTypeClObj for the first
* arg as the function itself is static, followed by script-visible
* arg types.
*/
TokenArgDecl argDecl = declFunc.argDecl;
int nArgs = argDecl.vars.Length;
Type[] argTypes = new Type[nArgs+1];
string[] argNames = new string[nArgs+1];
if (IsSDTInstMethod ()) {
argTypes[0] = typeof (XMRSDTypeClObj);
argNames[0] = "$sdtthis";
} else {
argTypes[0] = xmrInstSuperType;
argNames[0] = "$xmrthis";
}
for (int i = 0; i < nArgs; i ++) {
argTypes[i+1] = argDecl.vars[i].type.ToSysType ();
argNames[i+1] = argDecl.vars[i].name.val;
}
/*
* Set up entrypoint.
*/
string objCodeName = declFunc.GetObjCodeName ();
declFunc.ilGen = new ScriptObjWriter (tokenScript,
objCodeName,
declFunc.retType.ToSysType (),
argTypes,
argNames,
objFileWriter);
/*
* This says how to generate a call to the function and to get a delegate.
*/
declFunc.location = new CompValuGlobalMeth (declFunc);
curDeclFunc = null;
}
/**
* @brief generate code for an arbitrary script-defined function.
* @param name = name of the function
* @param argDecl = argument declarations
* @param body = function's code body
*/
private void GenerateMethodBody (TokenDeclVar declFunc)
{
/*
* Set up code generator for the function's contents.
*/
_ilGen = declFunc.ilGen;
StartFunctionBody (declFunc);
/*
* Create a temp to hold XMRInstanceSuperType version of arg 0.
* For most functions, arg 0 is already XMRInstanceSuperType.
* But for script-defined class instance methods, arg 0 holds
* the XMRSDTypeClObj pointer and so we read the XMRInstAbstract
* pointer from its XMRSDTypeClObj.xmrInst field then cast it to
* XMRInstanceSuperType.
*/
if (IsSDTInstMethod ()) {
instancePointer = ilGen.DeclareLocal (xmrInstSuperType, "__xmrinst");
ilGen.Emit (declFunc, OpCodes.Ldarg_0);
ilGen.Emit (declFunc, OpCodes.Ldfld, sdtXMRInstFieldInfo);
ilGen.Emit (declFunc, OpCodes.Castclass, xmrInstSuperType);
ilGen.Emit (declFunc, OpCodes.Stloc, instancePointer);
}
/*
* Define location of all script-level arguments so script body can access them.
* The argument indices need to have +1 added to them because XMRInstance or
* XMRSDTypeClObj is spliced in at arg 0.
*/
TokenArgDecl argDecl = declFunc.argDecl;
int nArgs = argDecl.vars.Length;
for (int i = 0; i < nArgs; i ++) {
TokenDeclVar argVar = argDecl.vars[i];
argVar.location = new CompValuArg (argVar.type, i + 1);
}
/*
* Output code for the statements and clean up.
*/
GenerateFuncBody ();
}
private void StartFunctionBody (TokenDeclVar declFunc)
{
/*
* Start current function being processed.
* Set 'mightGetHere' as the code at the top is always executed.
*/
instancePointer = null;
mightGetHere = true;
curBreakTarg = null;
curContTarg = null;
curDeclFunc = declFunc;
/*
* Start generating code.
*/
((ScriptObjWriter)ilGen).BegMethod ();
}
/**
* @brief Define function for a script-defined type's <typename>.$new(<argsig>) method.
* See GenerateStmtNewobj() for more info.
*/
private TokenDeclVar DefineNewobjFunc (TokenDeclVar ctorDeclFunc)
{
/*
* Set up 'static classname $new(params-same-as-ctor) { }'.
*/
TokenDeclVar newobjDeclFunc = new TokenDeclVar (ctorDeclFunc, null, tokenScript);
newobjDeclFunc.name = new TokenName (newobjDeclFunc, "$new");
newobjDeclFunc.retType = ctorDeclFunc.sdtClass.MakeRefToken (newobjDeclFunc);
newobjDeclFunc.argDecl = ctorDeclFunc.argDecl;
newobjDeclFunc.sdtClass = ctorDeclFunc.sdtClass;
newobjDeclFunc.sdtFlags = ScriptReduce.SDT_STATIC | ctorDeclFunc.sdtFlags;
/*
* Declare local variable named '$objptr' in a frame just under
* what the '$new(...)' function's arguments are declared in.
*/
TokenDeclVar objptrVar = new TokenDeclVar (newobjDeclFunc, newobjDeclFunc, tokenScript);
objptrVar.type = newobjDeclFunc.retType;
objptrVar.name = new TokenName (newobjDeclFunc, "$objptr");
VarDict newFrame = new VarDict (false);
newFrame.outerVarDict = ctorDeclFunc.argDecl.varDict;
newFrame.AddEntry (objptrVar);
/*
* Set up '$objptr.$ctor'
*/
TokenLValName objptrLValName = new TokenLValName (objptrVar.name, newFrame);
// ref a var by giving its name
TokenLValIField objptrDotCtor = new TokenLValIField (newobjDeclFunc); // an instance member reference
objptrDotCtor.baseRVal = objptrLValName; // '$objptr'
objptrDotCtor.fieldName = ctorDeclFunc.name; // '.' '$ctor'
/*
* Set up '$objptr.$ctor(arglist)' call for use in the '$new(...)' body.
* Copy the arglist from the constructor declaration so triviality
* processing will pick the correct overloaded constructor.
*/
TokenRValCall callCtorRVal = new TokenRValCall (newobjDeclFunc); // doing a call of some sort
callCtorRVal.meth = objptrDotCtor; // calling $objptr.$ctor()
TokenDeclVar[] argList = newobjDeclFunc.argDecl.vars; // get args $new() was declared with
callCtorRVal.nArgs = argList.Length; // ...that is nArgs we are passing to $objptr.$ctor()
for (int i = argList.Length; -- i >= 0;) {
TokenDeclVar arg = argList[i]; // find out about one of the args
TokenLValName argLValName = new TokenLValName (arg.name, ctorDeclFunc.argDecl.varDict);
// pass arg of that name to $objptr.$ctor()
argLValName.nextToken = callCtorRVal.args; // link to list of args passed to $objptr.$ctor()
callCtorRVal.args = argLValName;
}
/*
* Set up a funky call to the constructor for the code body.
* This will let code generator know there is some craziness.
* See GenerateStmtNewobj().
*
* This is in essence:
* {
* classname $objptr = newobj (classname);
* $objptr.$ctor (...);
* return $objptr;
* }
*/
TokenStmtNewobj newobjStmtBody = new TokenStmtNewobj (ctorDeclFunc);
newobjStmtBody.objptrVar = objptrVar;
newobjStmtBody.rValCall = callCtorRVal;
TokenStmtBlock newobjBody = new TokenStmtBlock (ctorDeclFunc);
newobjBody.statements = newobjStmtBody;
/*
* Link that code as the body of the function.
*/
newobjDeclFunc.body = newobjBody;
/*
* Say the function calls '$objptr.$ctor(arglist)' so we will inherit ctor's triviality.
*/
newobjDeclFunc.unknownTrivialityCalls.AddLast (callCtorRVal);
return newobjDeclFunc;
}
private class TokenStmtNewobj : TokenStmt {
public TokenDeclVar objptrVar;
public TokenRValCall rValCall;
public TokenStmtNewobj (Token original) : base (original) { }
}
/**
* @brief Output function body (either event handler or script-defined method).
*/
private void GenerateFuncBody ()
{
/*
* We want to know if the function's code is trivial, ie,
* if it doesn't have anything that might be an infinite
* loop and that is doesn't call anything that might have
* an infinite loop. If it is, we don't need any CheckRun()
* stuff or any of the frame save/restore stuff.
*/
bool isTrivial = curDeclFunc.IsFuncTrivial (this);
/*
* Clear list of all call labels.
* A call label is inserted just before every call that can possibly
* call CheckRun(), including any direct calls to CheckRun().
* Then, when restoring stack, we can just switch to this label to
* resume at the correct spot.
*/
actCallLabels.Clear ();
allCallLabels.Clear ();
openCallLabel = null;
/*
* Alloc stack space for local vars.
*/
AllocLocalVarStackSpace ();
/*
* Any return statements inside function body jump to this label
* after putting return value in __retval.
*/
retLabel = ilGen.DefineLabel ("__retlbl");
retValue = null;
if (!(curDeclFunc.retType is TokenTypeVoid)) {
retValue = ilGen.DeclareLocal (curDeclFunc.retType.ToSysType (), "__retval");
}
/*
* Output:
* int __mainCallNo = -1;
* try {
* if (instance.callMode != CallMode_NORMAL) goto __cmRestore;
*/
actCallNo = null;
ScriptMyLabel cmRestore = null;
if (!isTrivial) {
actCallNo = ilGen.DeclareLocal (typeof (int), "__mainCallNo");
SetCallNo (curDeclFunc, actCallNo, -1);
cmRestore = ilGen.DefineLabel ("__cmRestore");
ilGen.BeginExceptionBlock ();
PushXMRInst ();
ilGen.Emit (curDeclFunc, OpCodes.Ldfld, ScriptCodeGen.callModeFieldInfo);
ilGen.Emit (curDeclFunc, OpCodes.Ldc_I4, XMRInstAbstract.CallMode_NORMAL);
ilGen.Emit (curDeclFunc, OpCodes.Bne_Un, cmRestore);
}
/*
* Splice in the code optimizer for the body of the function.
*/
ScriptCollector collector = new ScriptCollector ((ScriptObjWriter)ilGen);
_ilGen = collector;
/*
* If this is the default state_entry() handler, output code to set all global
* variables to their initial values. Note that every script must have a
* default state_entry() handler, we provide one if the script doesn't explicitly
* define one.
*/
string methname = ilGen.methName;
if (methname == "default state_entry") {
// if (!doGblInit) goto skipGblInit;
ScriptMyLabel skipGblInitLabel = ilGen.DefineLabel ("__skipGblInit");
PushXMRInst (); // instance
ilGen.Emit (curDeclFunc, OpCodes.Ldfld, doGblInitFieldInfo); // instance.doGblInit
ilGen.Emit (curDeclFunc, OpCodes.Brfalse, skipGblInitLabel);
// $globalvarinit();
TokenDeclVar gviFunc = tokenScript.globalVarInit;
if (gviFunc.body.statements != null) {
gviFunc.location.CallPre (this, gviFunc);
gviFunc.location.CallPost (this, gviFunc);
}
// various $staticfieldinit();
foreach (TokenDeclSDType sdType in tokenScript.sdSrcTypesValues) {
if (sdType is TokenDeclSDTypeClass) {
TokenDeclVar sfiFunc = ((TokenDeclSDTypeClass)sdType).staticFieldInit;
if ((sfiFunc != null) && (sfiFunc.body.statements != null)) {
sfiFunc.location.CallPre (this, sfiFunc);
sfiFunc.location.CallPost (this, sfiFunc);
}
}
}
// doGblInit = 0;
PushXMRInst (); // instance
ilGen.Emit (curDeclFunc, OpCodes.Ldc_I4_0);
ilGen.Emit (curDeclFunc, OpCodes.Stfld, doGblInitFieldInfo); // instance.doGblInit
//skipGblInit:
ilGen.MarkLabel (skipGblInitLabel);
}
/*
* If this is a script-defined type constructor, call the base constructor and call
* this class's $instfieldinit() method to initialize instance fields.
*/
if ((curDeclFunc.sdtClass != null) && curDeclFunc.funcNameSig.val.StartsWith ("$ctor(")) {
if (curDeclFunc.baseCtorCall != null) {
GenerateFromRValCall (curDeclFunc.baseCtorCall);
}
TokenDeclVar ifiFunc = ((TokenDeclSDTypeClass)curDeclFunc.sdtClass).instFieldInit;
if (ifiFunc.body.statements != null) {
CompValu thisCompValu = new CompValuArg (ifiFunc.sdtClass.MakeRefToken (ifiFunc), 0);
CompValu ifiFuncLocn = new CompValuInstMember (ifiFunc, thisCompValu, true);
ifiFuncLocn.CallPre (this, ifiFunc);
ifiFuncLocn.CallPost (this, ifiFunc);
}
}
/*
* See if time to suspend in case they are doing a loop with recursion.
*/
if (!isTrivial) EmitCallCheckRun (curDeclFunc, true);
/*
* Output code body.
*/
GenerateStmtBlock (curDeclFunc.body);
/*
* If code falls through to this point, means they are missing
* a return statement. And that is legal only if the function
* returns 'void'.
*/
if (mightGetHere) {
if (!(curDeclFunc.retType is TokenTypeVoid)) {
ErrorMsg (curDeclFunc.body, "missing final return statement");
}
ilGen.Emit (curDeclFunc, OpCodes.Leave, retLabel);
}
/*
* End of the code to be optimized.
* Do optimizations then write it all out to object file.
* After this, all code gets written directly to object file.
* Optimization must be completed before we scan the allCallLabels
* list below to look for active locals and temps.
*/
collector.Optimize ();
_ilGen = collector.WriteOutAll ();
collector = null;
/*
* Output code to restore stack frame from stream.
* It jumps back to the call labels within the function body.
*/
List<ScriptMyLocal> activeTemps = null;
if (!isTrivial) {
/*
* Build list of locals and temps active at all the call labels.
*/
activeTemps = new List<ScriptMyLocal> ();
foreach (CallLabel cl in allCallLabels) {
foreach (ScriptMyLocal lcl in cl.callLabel.whereAmI.localsReadBeforeWritten) {
if (!activeTemps.Contains (lcl)) {
activeTemps.Add (lcl);
}
}
}
/*
* Output code to restore the args, locals and temps then jump to
* the call label that we were interrupted at.
*/
ilGen.MarkLabel (cmRestore);
GenerateFrameRestoreCode (activeTemps);
}
/*
* Output epilog that saves stack frame state if CallMode_SAVE.
*
* finally {
* if (instance.callMode != CallMode_SAVE) goto __endFin;
* GenerateFrameCaptureCode();
* __endFin:
* }
*/
ScriptMyLabel endFin = null;
if (!isTrivial) {
ilGen.BeginFinallyBlock ();
endFin = ilGen.DefineLabel ("__endFin");
PushXMRInst ();
ilGen.Emit (curDeclFunc, OpCodes.Ldfld, callModeFieldInfo);
ilGen.Emit (curDeclFunc, OpCodes.Ldc_I4, XMRInstAbstract.CallMode_SAVE);
ilGen.Emit (curDeclFunc, OpCodes.Bne_Un, endFin);
GenerateFrameCaptureCode (activeTemps);
ilGen.MarkLabel (endFin);
ilGen.Emit (curDeclFunc, OpCodes.Endfinally);
ilGen.EndExceptionBlock ();
}
/*
* Output the 'real' return opcode.
*/
ilGen.MarkLabel (retLabel);
if (!(curDeclFunc.retType is TokenTypeVoid)) {
ilGen.Emit (curDeclFunc, OpCodes.Ldloc, retValue);
}
ilGen.Emit (curDeclFunc, OpCodes.Ret);
retLabel = null;
retValue = null;
/*
* No more instructions for this method.
*/
((ScriptObjWriter)ilGen).EndMethod ();
_ilGen = null;
/*
* Not generating function code any more.
*/
curBreakTarg = null;
curContTarg = null;
curDeclFunc = null;
}
/**
* @brief Allocate stack space for all local variables, regardless of
* which { } statement block they are actually defined in.
*/
private void AllocLocalVarStackSpace ()
{
foreach (TokenDeclVar localVar in curDeclFunc.localVars) {
/*
* Skip all 'constant' vars as they were handled by the reducer.
*/
if (localVar.constant) continue;
/*
* Get a stack location for the local variable.
*/
localVar.location = new CompValuLocalVar (localVar.type, localVar.name.val, this);
}
}
/**
* @brief Generate code to write all arguments and locals to the capture stack frame.
* This includes temp variables.
* We only need to save what is active at the point of callLabels through because
* those are the only points we will jump to on restore. This saves us from saving
* all the little temp vars we create.
* @param activeTemps = list of locals and temps that we care about, ie, which
* ones get restored by GenerateFrameRestoreCode().
*/
private void GenerateFrameCaptureCode (List<ScriptMyLocal> activeTemps)
{
/*
* Compute total number of slots we need to save stuff.
* Assume we need to save all call arguments.
*/
int nSaves = curDeclFunc.argDecl.vars.Length + activeTemps.Count;
/*
* Output code to allocate a stack frame object with an object array.
* This also pushes the stack frame object on the instance.stackFrames list.
* It returns a pointer to the object array it allocated.
*/
PushXMRInst ();
ilGen.Emit (curDeclFunc, OpCodes.Ldstr, ilGen.methName);
GetCallNo (curDeclFunc, actCallNo);
ilGen.Emit (curDeclFunc, OpCodes.Ldc_I4, nSaves);
ilGen.Emit (curDeclFunc, OpCodes.Call, captureStackFrameMethodInfo);
if (DEBUG_STACKCAPRES) {
ilGen.Emit (curDeclFunc, OpCodes.Ldstr, ilGen.methName + "*: capture mainCallNo=");
ilGen.Emit (curDeclFunc, OpCodes.Call, consoleWriteMethodInfo);
ilGen.Emit (curDeclFunc, OpCodes.Ldloc, actCallNo);
ilGen.Emit (curDeclFunc, OpCodes.Box, typeof (int));
ilGen.Emit (curDeclFunc, OpCodes.Call, consoleWriteMethodInfo);
}
/*
* Copy arg values to object array, boxing as needed.
*/
int i = 0;
foreach (TokenDeclVar argVar in curDeclFunc.argDecl.varDict) {
ilGen.Emit (curDeclFunc, OpCodes.Dup);
ilGen.Emit (curDeclFunc, OpCodes.Ldc_I4, i);
argVar.location.PushVal (this, argVar.name, tokenTypeObj);
if (DEBUG_STACKCAPRES) {
ilGen.Emit (curDeclFunc, OpCodes.Ldstr, "\n arg:" + argVar.name.val + "=");
ilGen.Emit (curDeclFunc, OpCodes.Call, consoleWriteMethodInfo);
ilGen.Emit (curDeclFunc, OpCodes.Dup);
ilGen.Emit (curDeclFunc, OpCodes.Call, consoleWriteMethodInfo);
}
ilGen.Emit (curDeclFunc, OpCodes.Stelem_Ref);
i ++;
}
/*
* Copy local and temp values to object array, boxing as needed.
*/
foreach (ScriptMyLocal lcl in activeTemps) {
ilGen.Emit (curDeclFunc, OpCodes.Dup);
ilGen.Emit (curDeclFunc, OpCodes.Ldc_I4, i ++);
ilGen.Emit (curDeclFunc, OpCodes.Ldloc, lcl);
Type t = lcl.type;
if (t == typeof (HeapTrackerList)) {
t = HeapTrackerList.GenPush (curDeclFunc, ilGen);
}
if (t == typeof (HeapTrackerObject)) {
t = HeapTrackerObject.GenPush (curDeclFunc, ilGen);
}
if (t == typeof(HeapTrackerString)) {
t = HeapTrackerString.GenPush (curDeclFunc, ilGen);
}
if (t.IsValueType) {
ilGen.Emit (curDeclFunc, OpCodes.Box, t);
}
if (DEBUG_STACKCAPRES) {
ilGen.Emit (curDeclFunc, OpCodes.Ldstr, "\n lcl:" + lcl.name + "=");
ilGen.Emit (curDeclFunc, OpCodes.Call, consoleWriteMethodInfo);
ilGen.Emit (curDeclFunc, OpCodes.Dup);
ilGen.Emit (curDeclFunc, OpCodes.Call, consoleWriteMethodInfo);
}
ilGen.Emit (curDeclFunc, OpCodes.Stelem_Ref);
}
if (DEBUG_STACKCAPRES) {
ilGen.Emit (curDeclFunc, OpCodes.Ldstr, "\n");
ilGen.Emit (curDeclFunc, OpCodes.Call, consoleWriteMethodInfo);
}
ilGen.Emit (curDeclFunc, OpCodes.Pop);
}
/**
* @brief Generate code to restore all arguments and locals from the restore stack frame.
* This includes temp variables.
*/
private void GenerateFrameRestoreCode (List<ScriptMyLocal> activeTemps)
{
ScriptMyLocal objArray = ilGen.DeclareLocal (typeof (object[]), "__restObjArray");
/*
* Output code to pop stack frame from instance.stackFrames.
* It returns a pointer to the object array that contains values to be restored.
*/
PushXMRInst ();
ilGen.Emit (curDeclFunc, OpCodes.Ldstr, ilGen.methName);
ilGen.Emit (curDeclFunc, OpCodes.Ldloca, actCallNo); // __mainCallNo
ilGen.Emit (curDeclFunc, OpCodes.Call, restoreStackFrameMethodInfo);
ilGen.Emit (curDeclFunc, OpCodes.Stloc, objArray);
if (DEBUG_STACKCAPRES) {
ilGen.Emit (curDeclFunc, OpCodes.Ldstr, ilGen.methName + "*: restore mainCallNo=");
ilGen.Emit (curDeclFunc, OpCodes.Call, consoleWriteMethodInfo);
ilGen.Emit (curDeclFunc, OpCodes.Ldloc, actCallNo);
ilGen.Emit (curDeclFunc, OpCodes.Box, typeof (int));
ilGen.Emit (curDeclFunc, OpCodes.Call, consoleWriteMethodInfo);
}
/*
* Restore argument values from object array, unboxing as needed.
* Although the caller has restored them to what it called us with, it's possible that this
* function has modified them since, so we need to do our own restore.
*/
int i = 0;
foreach (TokenDeclVar argVar in curDeclFunc.argDecl.varDict) {
CompValu argLoc = argVar.location;
argLoc.PopPre (this, argVar.name);
ilGen.Emit (curDeclFunc, OpCodes.Ldloc, objArray);
ilGen.Emit (curDeclFunc, OpCodes.Ldc_I4, i);
ilGen.Emit (curDeclFunc, OpCodes.Ldelem_Ref);
if (DEBUG_STACKCAPRES) {
ilGen.Emit (curDeclFunc, OpCodes.Ldstr, "\n arg:" + argVar.name.val + "=");
ilGen.Emit (curDeclFunc, OpCodes.Call, consoleWriteMethodInfo);
ilGen.Emit (curDeclFunc, OpCodes.Dup);
ilGen.Emit (curDeclFunc, OpCodes.Call, consoleWriteMethodInfo);
}
TypeCast.CastTopOfStack (this, argVar.name, tokenTypeObj, argLoc.type, true);
argLoc.PopPost (this, argVar.name);
i ++;
}
/*
* Restore local and temp values from object array, unboxing as needed.
*/
foreach (ScriptMyLocal lcl in activeTemps) {
Type t = lcl.type;
Type u = t;
if (t == typeof (HeapTrackerList)) u = typeof (LSL_List);
if (t == typeof (HeapTrackerObject)) u = typeof (object);
if (t == typeof (HeapTrackerString)) u = typeof (string);
if (u != t) {
ilGen.Emit (curDeclFunc, OpCodes.Ldloc, lcl);
}
ilGen.Emit (curDeclFunc, OpCodes.Ldloc, objArray);
ilGen.Emit (curDeclFunc, OpCodes.Ldc_I4, i ++);
ilGen.Emit (curDeclFunc, OpCodes.Ldelem_Ref);
if (DEBUG_STACKCAPRES) {
ilGen.Emit (curDeclFunc, OpCodes.Ldstr, "\n lcl:" + lcl.name + "=");
ilGen.Emit (curDeclFunc, OpCodes.Call, consoleWriteMethodInfo);
ilGen.Emit (curDeclFunc, OpCodes.Dup);
ilGen.Emit (curDeclFunc, OpCodes.Call, consoleWriteMethodInfo);
}
if (u.IsValueType) {
ilGen.Emit (curDeclFunc, OpCodes.Unbox_Any, u);
} else if (u != typeof (object)) {
ilGen.Emit (curDeclFunc, OpCodes.Castclass, u);
}
if (u != t) {
if (t == typeof (HeapTrackerList)) HeapTrackerList.GenPop (curDeclFunc, ilGen);
if (t == typeof (HeapTrackerObject)) HeapTrackerObject.GenPop (curDeclFunc, ilGen);
if (t == typeof (HeapTrackerString)) HeapTrackerString.GenPop (curDeclFunc, ilGen);
} else {
ilGen.Emit (curDeclFunc, OpCodes.Stloc, lcl);
}
}
if (DEBUG_STACKCAPRES) {
ilGen.Emit (curDeclFunc, OpCodes.Ldstr, "\n");
ilGen.Emit (curDeclFunc, OpCodes.Call, consoleWriteMethodInfo);
}
OutputCallNoSwitchStmt ();
}
/**
* @brief Output a switch statement with a case for each possible
* value of whatever callNo is currently active, either
* __mainCallNo or one of the try/catch/finally's callNos.
*
* switch (callNo) {
* case 0: goto __call_0;
* case 1: goto __call_1;
* ...
* }
* throw new ScriptBadCallNoException (callNo);
*/
private void OutputCallNoSwitchStmt ()
{
ScriptMyLabel[] callLabels = new ScriptMyLabel[actCallLabels.Count];
foreach (CallLabel cl in actCallLabels) {
callLabels[cl.index] = cl.callLabel;
}
GetCallNo (curDeclFunc, actCallNo);
ilGen.Emit (curDeclFunc, OpCodes.Switch, callLabels);
GetCallNo (curDeclFunc, actCallNo);
ilGen.Emit (curDeclFunc, OpCodes.Newobj, scriptBadCallNoExceptionConstructorInfo);
ilGen.Emit (curDeclFunc, OpCodes.Throw);
}
/**
* @brief There is one of these per call that can possibly call CheckRun(),
* including direct calls to CheckRun().
* They mark points that the stack capture/restore code will save & restore to.
* All object-code level local vars active at the call label's point will
* be saved & restored.
*
* callNo = 5;
* __call_5:
* push call arguments from temps
* call SomethingThatCallsCheckRun()
*
* If SomethingThatCallsCheckRun() actually calls CheckRun(), our restore code
* will restore our args, locals & temps, then jump to __call_5, which will then
* call SomethingThatCallsCheckRun() again, which will restore its stuff likewise.
* When eventually the actual CheckRun() call is restored, it will turn off restore
* mode (by changing callMode from CallMode_RESTORE to CallMode_NORMAL) and return,
* allowing the code to run normally from that point.
*/
public class CallLabel {
public int index; // sequential integer, starting at 0, within actCallLabels
// - used for the switch statement
public ScriptMyLabel callLabel; // the actual label token
public CallLabel (ScriptCodeGen scg, Token errorAt)
{
if (scg.openCallLabel != null) throw new Exception ("call label already open");
if (!scg.curDeclFunc.IsFuncTrivial (scg)) {
this.index = scg.actCallLabels.Count;
string name = "__call_" + index + "_" + scg.allCallLabels.Count;
/*
* Make sure eval stack is empty because the frame capture/restore
* code expects such (restore switch stmt has an empty stack).
*/
int depth = ((ScriptCollector)scg.ilGen).stackDepth.Count;
if (depth > 0) {
// maybe need to call Trivialize()
throw new Exception ("call label stack depth " + depth + " at " + errorAt.SrcLoc);
}
/*
* Eval stack is empty so the restore code can handle it.
*/
this.index = scg.actCallLabels.Count;
scg.actCallLabels.AddLast (this);
scg.allCallLabels.AddLast (this);
this.callLabel = scg.ilGen.DefineLabel (name);
scg.SetCallNo (errorAt, scg.actCallNo, this.index);
scg.ilGen.MarkLabel (this.callLabel);
}
scg.openCallLabel = this;
}
};
/**
* @brief generate code for an arbitrary statement.
*/
private void GenerateStmt (TokenStmt stmt)
{
errorMessageToken = stmt;
if (stmt is TokenDeclVar) { GenerateDeclVar ((TokenDeclVar)stmt); return; }
if (stmt is TokenStmtBlock) { GenerateStmtBlock ((TokenStmtBlock)stmt); return; }
if (stmt is TokenStmtBreak) { GenerateStmtBreak ((TokenStmtBreak)stmt); return; }
if (stmt is TokenStmtCont) { GenerateStmtCont ((TokenStmtCont)stmt); return; }
if (stmt is TokenStmtDo) { GenerateStmtDo ((TokenStmtDo)stmt); return; }
if (stmt is TokenStmtFor) { GenerateStmtFor ((TokenStmtFor)stmt); return; }
if (stmt is TokenStmtForEach) { GenerateStmtForEach ((TokenStmtForEach)stmt); return; }
if (stmt is TokenStmtIf) { GenerateStmtIf ((TokenStmtIf)stmt); return; }
if (stmt is TokenStmtJump) { GenerateStmtJump ((TokenStmtJump)stmt); return; }
if (stmt is TokenStmtLabel) { GenerateStmtLabel ((TokenStmtLabel)stmt); return; }
if (stmt is TokenStmtNewobj) { GenerateStmtNewobj ((TokenStmtNewobj)stmt); return; }
if (stmt is TokenStmtNull) { return; }
if (stmt is TokenStmtRet) { GenerateStmtRet ((TokenStmtRet)stmt); return; }
if (stmt is TokenStmtRVal) { GenerateStmtRVal ((TokenStmtRVal)stmt); return; }
if (stmt is TokenStmtState) { GenerateStmtState ((TokenStmtState)stmt); return; }
if (stmt is TokenStmtSwitch) { GenerateStmtSwitch ((TokenStmtSwitch)stmt); return; }
if (stmt is TokenStmtThrow) { GenerateStmtThrow ((TokenStmtThrow)stmt); return; }
if (stmt is TokenStmtTry) { GenerateStmtTry ((TokenStmtTry)stmt); return; }
if (stmt is TokenStmtVarIniDef) { GenerateStmtVarIniDef ((TokenStmtVarIniDef)stmt); return; }
if (stmt is TokenStmtWhile) { GenerateStmtWhile ((TokenStmtWhile)stmt); return; }
throw new Exception ("unknown TokenStmt type " + stmt.GetType ().ToString ());
}
/**
* @brief generate statement block (ie, with braces)
*/
private void GenerateStmtBlock (TokenStmtBlock stmtBlock)
{
if (!mightGetHere) return;
/*
* Push new current statement block pointer for anyone who cares.
*/
TokenStmtBlock oldStmtBlock = curStmtBlock;
curStmtBlock = stmtBlock;
/*
* Output the statements that make up the block.
*/
for (Token t = stmtBlock.statements; t != null; t = t.nextToken) {
GenerateStmt ((TokenStmt)t);
}
/*
* Pop the current statement block.
*/
curStmtBlock = oldStmtBlock;
}
/**
* @brief output code for a 'break' statement
*/
private void GenerateStmtBreak (TokenStmtBreak breakStmt)
{
if (!mightGetHere) return;
/*
* Make sure we are in a breakable situation.
*/
if (curBreakTarg == null) {
ErrorMsg (breakStmt, "not in a breakable situation");
return;
}
/*
* Tell anyone who cares that the break target was actually used.
*/
curBreakTarg.used = true;
/*
* Output the instructions.
*/
EmitJumpCode (curBreakTarg.label, curBreakTarg.block, breakStmt);
}
/**
* @brief output code for a 'continue' statement
*/
private void GenerateStmtCont (TokenStmtCont contStmt)
{
if (!mightGetHere) return;
/*
* Make sure we are in a contable situation.
*/
if (curContTarg == null) {
ErrorMsg (contStmt, "not in a continueable situation");
return;
}
/*
* Tell anyone who cares that the continue target was actually used.
*/
curContTarg.used = true;
/*
* Output the instructions.
*/
EmitJumpCode (curContTarg.label, curContTarg.block, contStmt);
}
/**
* @brief output code for a 'do' statement
*/
private void GenerateStmtDo (TokenStmtDo doStmt)
{
if (!mightGetHere) return;
BreakContTarg oldBreakTarg = curBreakTarg;
BreakContTarg oldContTarg = curContTarg;
ScriptMyLabel loopLabel = ilGen.DefineLabel ("doloop_" + doStmt.Unique);
curBreakTarg = new BreakContTarg (this, "dobreak_" + doStmt.Unique);
curContTarg = new BreakContTarg (this, "docont_" + doStmt.Unique);
ilGen.MarkLabel (loopLabel);
GenerateStmt (doStmt.bodyStmt);
if (curContTarg.used) {
ilGen.MarkLabel (curContTarg.label);
mightGetHere = true;
}
if (mightGetHere) {
EmitCallCheckRun (doStmt, false);
CompValu testRVal = GenerateFromRVal (doStmt.testRVal);
if (IsConstBoolExprTrue (testRVal)) {
/*
* Unconditional looping, unconditional branch and
* say we never fall through to next statement.
*/
ilGen.Emit (doStmt, OpCodes.Br, loopLabel);
mightGetHere = false;
} else {
/*
* Conditional looping, test and brach back to top of loop.
*/
testRVal.PushVal (this, doStmt.testRVal, tokenTypeBool);
ilGen.Emit (doStmt, OpCodes.Brtrue, loopLabel);
}
}
/*
* If 'break' statement was used, output target label.
* And assume that since a 'break' statement was used, it's possible for the code to get here.
*/
if (curBreakTarg.used) {
ilGen.MarkLabel (curBreakTarg.label);
mightGetHere = true;
}
curBreakTarg = oldBreakTarg;
curContTarg = oldContTarg;
}
/**
* @brief output code for a 'for' statement
*/
private void GenerateStmtFor (TokenStmtFor forStmt)
{
if (!mightGetHere) return;
BreakContTarg oldBreakTarg = curBreakTarg;
BreakContTarg oldContTarg = curContTarg;
ScriptMyLabel loopLabel = ilGen.DefineLabel ("forloop_" + forStmt.Unique);
curBreakTarg = new BreakContTarg (this, "forbreak_" + forStmt.Unique);
curContTarg = new BreakContTarg (this, "forcont_" + forStmt.Unique);
if (forStmt.initStmt != null) {
GenerateStmt (forStmt.initStmt);
}
ilGen.MarkLabel (loopLabel);
/*
* See if we have a test expression that is other than a constant TRUE.
* If so, test it and conditionally branch to end if false.
*/
if (forStmt.testRVal != null) {
CompValu testRVal = GenerateFromRVal (forStmt.testRVal);
if (!IsConstBoolExprTrue (testRVal)) {
testRVal.PushVal (this, forStmt.testRVal, tokenTypeBool);
ilGen.Emit (forStmt, OpCodes.Brfalse, curBreakTarg.label);
curBreakTarg.used = true;
}
}
/*
* Output loop body.
*/
GenerateStmt (forStmt.bodyStmt);
/*
* Here's where a 'continue' statement jumps to.
*/
if (curContTarg.used) {
ilGen.MarkLabel (curContTarg.label);
mightGetHere = true;
}
if (mightGetHere) {
/*
* After checking for excessive CPU time, output increment statement, if any.
*/
EmitCallCheckRun (forStmt, false);
if (forStmt.incrRVal != null) {
GenerateFromRVal (forStmt.incrRVal);
}
/*
* Unconditional branch back to beginning of loop.
*/
ilGen.Emit (forStmt, OpCodes.Br, loopLabel);
}
/*
* If test needs label, output label for it to jump to.
* Otherwise, clear mightGetHere as we know loop never
* falls out the bottom.
*/
mightGetHere = curBreakTarg.used;
if (mightGetHere) {
ilGen.MarkLabel (curBreakTarg.label);
}
curBreakTarg = oldBreakTarg;
curContTarg = oldContTarg;
}
private void GenerateStmtForEach (TokenStmtForEach forEachStmt)
{
if (!mightGetHere) return;
BreakContTarg oldBreakTarg = curBreakTarg;
BreakContTarg oldContTarg = curContTarg;
CompValu keyLVal = null;
CompValu valLVal = null;
CompValu arrayRVal = GenerateFromRVal (forEachStmt.arrayRVal);
if (forEachStmt.keyLVal != null) {
keyLVal = GenerateFromLVal (forEachStmt.keyLVal);
if (!(keyLVal.type is TokenTypeObject)) {
ErrorMsg (forEachStmt.arrayRVal, "must be object");
}
}
if (forEachStmt.valLVal != null) {
valLVal = GenerateFromLVal (forEachStmt.valLVal);
if (!(valLVal.type is TokenTypeObject)) {
ErrorMsg (forEachStmt.arrayRVal, "must be object");
}
}
if (!(arrayRVal.type is TokenTypeArray)) {
ErrorMsg (forEachStmt.arrayRVal, "must be an array");
}
curBreakTarg = new BreakContTarg (this, "foreachbreak_" + forEachStmt.Unique);
curContTarg = new BreakContTarg (this, "foreachcont_" + forEachStmt.Unique);
CompValuTemp indexVar = new CompValuTemp (new TokenTypeInt (forEachStmt), this);
ScriptMyLabel loopLabel = ilGen.DefineLabel ("foreachloop_" + forEachStmt.Unique);
// indexVar = 0
ilGen.Emit (forEachStmt, OpCodes.Ldc_I4_0);
indexVar.Pop (this, forEachStmt);
ilGen.MarkLabel (loopLabel);
// key = array.__pub_index (indexVar);
// if (key == null) goto curBreakTarg;
if (keyLVal != null) {
keyLVal.PopPre (this, forEachStmt.keyLVal);
arrayRVal.PushVal (this, forEachStmt.arrayRVal);
indexVar.PushVal (this, forEachStmt);
ilGen.Emit (forEachStmt, OpCodes.Call, xmrArrPubIndexMethod);
keyLVal.PopPost (this, forEachStmt.keyLVal);
keyLVal.PushVal (this, forEachStmt.keyLVal);
ilGen.Emit (forEachStmt, OpCodes.Brfalse, curBreakTarg.label);
curBreakTarg.used = true;
}
// val = array._pub_value (indexVar);
// if (val == null) goto curBreakTarg;
if (valLVal != null) {
valLVal.PopPre (this, forEachStmt.valLVal);
arrayRVal.PushVal (this, forEachStmt.arrayRVal);
indexVar.PushVal (this, forEachStmt);
ilGen.Emit (forEachStmt, OpCodes.Call, xmrArrPubValueMethod);
valLVal.PopPost (this, forEachStmt.valLVal);
if (keyLVal == null) {
valLVal.PushVal (this, forEachStmt.valLVal);
ilGen.Emit (forEachStmt, OpCodes.Brfalse, curBreakTarg.label);
curBreakTarg.used = true;
}
}
// indexVar ++;
indexVar.PushVal (this, forEachStmt);
ilGen.Emit (forEachStmt, OpCodes.Ldc_I4_1);
ilGen.Emit (forEachStmt, OpCodes.Add);
indexVar.Pop (this, forEachStmt);
// body statement
GenerateStmt (forEachStmt.bodyStmt);
// continue label
if (curContTarg.used) {
ilGen.MarkLabel (curContTarg.label);
mightGetHere = true;
}
// call CheckRun()
if (mightGetHere) {
EmitCallCheckRun (forEachStmt, false);
ilGen.Emit (forEachStmt, OpCodes.Br, loopLabel);
}
// break label
ilGen.MarkLabel (curBreakTarg.label);
mightGetHere = true;
curBreakTarg = oldBreakTarg;
curContTarg = oldContTarg;
}
/**
* @brief output code for an 'if' statement
* Braces are necessary because what may be one statement for trueStmt or elseStmt in
* the script may translate to more than one statement in the resultant C# code.
*/
private void GenerateStmtIf (TokenStmtIf ifStmt)
{
if (!mightGetHere) return;
bool constVal;
/*
* Test condition and see if constant test expression.
*/
CompValu testRVal = GenerateFromRVal (ifStmt.testRVal);
if (IsConstBoolExpr (testRVal, out constVal)) {
/*
* Constant, output just either the true or else part.
*/
if (constVal) {
GenerateStmt (ifStmt.trueStmt);
} else if (ifStmt.elseStmt != null) {
GenerateStmt (ifStmt.elseStmt);
}
} else if (ifStmt.elseStmt == null) {
/*
* This is an 'if' statement without an 'else' clause.
*/
testRVal.PushVal (this, ifStmt.testRVal, tokenTypeBool);
ScriptMyLabel doneLabel = ilGen.DefineLabel ("ifdone_" + ifStmt.Unique);
ilGen.Emit (ifStmt, OpCodes.Brfalse, doneLabel); // brfalse doneLabel
GenerateStmt (ifStmt.trueStmt); // generate true body code
ilGen.MarkLabel (doneLabel);
mightGetHere = true; // there's always a possibility of getting here
} else {
/*
* This is an 'if' statement with an 'else' clause.
*/
testRVal.PushVal (this, ifStmt.testRVal, tokenTypeBool);
ScriptMyLabel elseLabel = ilGen.DefineLabel ("ifelse_" + ifStmt.Unique);
ilGen.Emit (ifStmt, OpCodes.Brfalse, elseLabel); // brfalse elseLabel
GenerateStmt (ifStmt.trueStmt); // generate true body code
bool trueMightGetHere = mightGetHere; // save whether or not true falls through
ScriptMyLabel doneLabel = ilGen.DefineLabel ("ifdone_" + ifStmt.Unique);
ilGen.Emit (ifStmt, OpCodes.Br, doneLabel); // branch to done
ilGen.MarkLabel (elseLabel); // beginning of else code
mightGetHere = true; // the top of the else might be executed
GenerateStmt (ifStmt.elseStmt); // output else code
ilGen.MarkLabel (doneLabel); // where end of true clause code branches to
mightGetHere |= trueMightGetHere; // gets this far if either true or else falls through
}
}
/**
* @brief output code for a 'jump' statement
*/
private void GenerateStmtJump (TokenStmtJump jumpStmt)
{
if (!mightGetHere) return;
/*
* Make sure the target label is defined somewhere in the function.
*/
TokenStmtLabel stmtLabel;
if (!curDeclFunc.labels.TryGetValue (jumpStmt.label.val, out stmtLabel)) {
ErrorMsg (jumpStmt, "undefined label " + jumpStmt.label.val);
return;
}
if (!stmtLabel.labelTagged) {
stmtLabel.labelStruct = ilGen.DefineLabel ("jump_" + stmtLabel.name.val);
stmtLabel.labelTagged = true;
}
/*
* Emit instructions to do the jump.
*/
EmitJumpCode (stmtLabel.labelStruct, stmtLabel.block, jumpStmt);
}
/**
* @brief Emit code to jump to a label
* @param target = label being jumped to
* @param targetsBlock = { ... } the label is defined in
*/
private void EmitJumpCode (ScriptMyLabel target, TokenStmtBlock targetsBlock, Token errorAt)
{
/*
* Jumps never fall through.
*/
mightGetHere = false;
/*
* Find which block the target label is in. Must be in this or an outer block,
* no laterals allowed. And if we exit a try/catch block, use Leave instead of Br.
*
* jump lateral;
* {
* @lateral;
* }
*/
bool useLeave = false;
TokenStmtBlock stmtBlock;
Stack<TokenStmtTry> finallyBlocksCalled = new Stack<TokenStmtTry> ();
for (stmtBlock = curStmtBlock; stmtBlock != targetsBlock; stmtBlock = stmtBlock.outerStmtBlock) {
if (stmtBlock == null) {
ErrorMsg (errorAt, "no lateral jumps allowed");
return;
}
if (stmtBlock.isFinally) {
ErrorMsg (errorAt, "cannot jump out of finally");
return;
}
if (stmtBlock.isTry || stmtBlock.isCatch) useLeave = true;
if ((stmtBlock.tryStmt != null) && (stmtBlock.tryStmt.finallyStmt != null)) {
finallyBlocksCalled.Push (stmtBlock.tryStmt);
}
}
/*
* If popping through more than one finally block, we have to break it down for the stack
* capture and restore code, one finally block at a time.
*
* try {
* try {
* try {
* jump exit;
* } finally {
* llOwnerSay ("exiting inner");
* }
* } finally {
* llOwnerSay ("exiting middle");
* }
* } finally {
* llOwnerSay ("exiting outer");
* }
* @exit;
*
* try {
* try {
* try {
* jump intr2_exit; <<< gets its own tryNo call label so inner try knows where to restore to
* } finally {
* llOwnerSay ("exiting inner");
* }
* jump outtry2;
* @intr2_exit; jump intr1_exit; <<< gets its own tryNo call label so middle try knows where to restore to
* @outtry2;
* } finally {
* llOwnerSay ("exiting middle");
* }
* jump outtry1;
* @intr1_exit: jump exit; <<< gets its own tryNo call label so outer try knows where to restore to
* @outtry1;
* } finally {
* llOwnerSay ("exiting outer");
* }
* @exit;
*/
int level = 0;
while (finallyBlocksCalled.Count > 1) {
TokenStmtTry finallyBlock = finallyBlocksCalled.Pop ();
string intername = "intr" + (++ level) + "_" + target.name;
IntermediateLeave iLeave;
if (!finallyBlock.iLeaves.TryGetValue (intername, out iLeave)) {
iLeave = new IntermediateLeave ();
iLeave.jumpIntoLabel = ilGen.DefineLabel (intername);
iLeave.jumpAwayLabel = target;
finallyBlock.iLeaves.Add (intername, iLeave);
}
target = iLeave.jumpIntoLabel;
}
/*
* Finally output the branch/leave opcode.
* If using Leave, prefix with a call label in case the corresponding finally block
* calls CheckRun() and that CheckRun() captures the stack, it will have a point to
* restore to that will properly jump back into the finally block.
*/
if (useLeave) {
new CallLabel (this, errorAt);
ilGen.Emit (errorAt, OpCodes.Leave, target);
openCallLabel = null;
} else {
ilGen.Emit (errorAt, OpCodes.Br, target);
}
}
/**
* @brief output code for a jump target label statement.
* If there are any backward jumps to the label, do a CheckRun() also.
*/
private void GenerateStmtLabel (TokenStmtLabel labelStmt)
{
if (!labelStmt.labelTagged) {
labelStmt.labelStruct = ilGen.DefineLabel ("jump_" + labelStmt.name.val);
labelStmt.labelTagged = true;
}
ilGen.MarkLabel (labelStmt.labelStruct);
if (labelStmt.hasBkwdRefs) {
EmitCallCheckRun (labelStmt, false);
}
/*
* We are going to say that the label falls through.
* It would be nice if we could analyze all referencing
* goto's to see if all of them are not used but we are
* going to assume that if the script writer put a label
* somewhere, it is probably going to be used.
*/
mightGetHere = true;
}
/**
* @brief Generate code for a script-defined type's <typename>.$new(<argsig>) method.
* It is used to malloc the object and initialize it.
* It is defined as a script-defined type static method, so the object level
* method gets the XMRInstance pointer passed as arg 0, and the method is
* supposed to return the allocated and constructed XMRSDTypeClObj
* object pointer.
*/
private void GenerateStmtNewobj (TokenStmtNewobj newobjStmt)
{
/*
* First off, malloc a new empty XMRSDTypeClObj object
* then call the XMRSDTypeClObj()-level constructor.
* Store the result in local var $objptr.
*/
newobjStmt.objptrVar.location.PopPre (this, newobjStmt);
ilGen.Emit (newobjStmt, OpCodes.Ldarg_0);
ilGen.Emit (newobjStmt, OpCodes.Ldc_I4, curDeclFunc.sdtClass.sdTypeIndex);
ilGen.Emit (newobjStmt, OpCodes.Newobj, sdtClassConstructorInfo);
newobjStmt.objptrVar.location.PopPost (this, newobjStmt);
/*
* Now call the script-level constructor.
* Pass the object pointer in $objptr as it's 'this' argument.
* The rest of the args are the script-visible args and are just copied from $new() call.
*/
GenerateFromRValCall (newobjStmt.rValCall);
/*
* Put object pointer in retval so it gets returned to caller.
*/
newobjStmt.objptrVar.location.PushVal (this, newobjStmt);
ilGen.Emit (newobjStmt, OpCodes.Stloc, retValue);
/*
* Exit the function like a return statement.
* And thus we don't fall through.
*/
ilGen.Emit (newobjStmt, OpCodes.Leave, retLabel);
mightGetHere = false;
}
/**
* @brief output code for a return statement.
* @param retStmt = return statement token, including return value if any
*/
private void GenerateStmtRet (TokenStmtRet retStmt)
{
if (!mightGetHere) return;
for (TokenStmtBlock stmtBlock = curStmtBlock; stmtBlock != null; stmtBlock = stmtBlock.outerStmtBlock) {
if (stmtBlock.isFinally) {
ErrorMsg (retStmt, "cannot return out of finally");
return;
}
}
if (curDeclFunc.retType is TokenTypeVoid) {
if (retStmt.rVal != null) {
ErrorMsg (retStmt, "function returns void, no value allowed");
return;
}
} else {
if (retStmt.rVal == null) {
ErrorMsg (retStmt, "function requires return value type " + curDeclFunc.retType.ToString ());
return;
}
CompValu rVal = GenerateFromRVal (retStmt.rVal);
rVal.PushVal (this, retStmt.rVal, curDeclFunc.retType);
ilGen.Emit (retStmt, OpCodes.Stloc, retValue);
}
/*
* Use a OpCodes.Leave instruction to break out of any try { } blocks.
* All Leave's inside script-defined try { } need call labels (see GenerateStmtTry()).
*/
bool brokeOutOfTry = false;
for (TokenStmtBlock stmtBlock = curStmtBlock; stmtBlock != null; stmtBlock = stmtBlock.outerStmtBlock) {
if (stmtBlock.isTry) {
brokeOutOfTry = true;
break;
}
}
if (brokeOutOfTry) new CallLabel (this, retStmt);
ilGen.Emit (retStmt, OpCodes.Leave, retLabel);
if (brokeOutOfTry) openCallLabel = null;
/*
* 'return' statements never fall through.
*/
mightGetHere = false;
}
/**
* @brief the statement is just an expression, most likely an assignment or a ++ or -- thing.
*/
private void GenerateStmtRVal (TokenStmtRVal rValStmt)
{
if (!mightGetHere) return;
GenerateFromRVal (rValStmt.rVal);
}
/**
* @brief generate code for a 'state' statement that transitions state.
* It sets the new state by throwing a ScriptChangeStateException.
*/
private void GenerateStmtState (TokenStmtState stateStmt)
{
if (!mightGetHere) return;
int index = 0; // 'default' state
/*
* Set new state value by throwing an exception.
* These exceptions aren't catchable by script-level try { } catch { }.
*/
if ((stateStmt.state != null) && !stateIndices.TryGetValue (stateStmt.state.val, out index)) {
// The moron XEngine compiles scripts that reference undefined states.
// So rather than produce a compile-time error, we'll throw an exception at runtime.
// ErrorMsg (stateStmt, "undefined state " + stateStmt.state.val);
// throw new UndefinedStateException (stateStmt.state.val);
ilGen.Emit (stateStmt, OpCodes.Ldstr, stateStmt.state.val);
ilGen.Emit (stateStmt, OpCodes.Newobj, scriptUndefinedStateExceptionConstructorInfo);
} else {
ilGen.Emit (stateStmt, OpCodes.Ldc_I4, index); // new state's index
ilGen.Emit (stateStmt, OpCodes.Newobj, scriptChangeStateExceptionConstructorInfo);
}
ilGen.Emit (stateStmt, OpCodes.Throw);
/*
* 'state' statements never fall through.
*/
mightGetHere = false;
}
/**
* @brief output code for a 'switch' statement
*/
private void GenerateStmtSwitch (TokenStmtSwitch switchStmt)
{
if (!mightGetHere) return;
/*
* Output code to calculate index.
*/
CompValu testRVal = GenerateFromRVal (switchStmt.testRVal);
/*
* Generate code based on string or integer index.
*/
if ((testRVal.type is TokenTypeKey) || (testRVal.type is TokenTypeStr)) {
GenerateStmtSwitchStr (testRVal, switchStmt);
} else {
GenerateStmtSwitchInt (testRVal, switchStmt);
}
}
private void GenerateStmtSwitchInt (CompValu testRVal, TokenStmtSwitch switchStmt)
{
testRVal.PushVal (this, switchStmt.testRVal, tokenTypeInt);
BreakContTarg oldBreakTarg = curBreakTarg;
ScriptMyLabel defaultLabel = null;
TokenSwitchCase sortedCases = null;
TokenSwitchCase defaultCase = null;
curBreakTarg = new BreakContTarg (this, "switchbreak_" + switchStmt.Unique);
/*
* Build list of cases sorted by ascending values.
* There should not be any overlapping of values.
*/
for (TokenSwitchCase thisCase = switchStmt.cases; thisCase != null; thisCase = thisCase.nextCase) {
thisCase.label = ilGen.DefineLabel ("case_" + thisCase.Unique);
/*
* The default case if any, goes in its own separate slot.
*/
if (thisCase.rVal1 == null) {
if (defaultCase != null) {
ErrorMsg (thisCase, "only one default case allowed");
ErrorMsg (defaultCase, "...prior default case");
return;
}
defaultCase = thisCase;
defaultLabel = thisCase.label;
continue;
}
/*
* Evaluate case operands, they must be compile-time integer constants.
*/
CompValu rVal = GenerateFromRVal (thisCase.rVal1);
if (!IsConstIntExpr (rVal, out thisCase.val1)) {
ErrorMsg (thisCase.rVal1, "must be compile-time char or integer constant");
return;
}
thisCase.val2 = thisCase.val1;
if (thisCase.rVal2 != null) {
rVal = GenerateFromRVal (thisCase.rVal2);
if (!IsConstIntExpr (rVal, out thisCase.val2)) {
ErrorMsg (thisCase.rVal2, "must be compile-time char or integer constant");
return;
}
}
if (thisCase.val2 < thisCase.val1) {
ErrorMsg (thisCase.rVal2, "must be .ge. first value for the case");
return;
}
/*
* Insert into list, sorted by value.
* Note that both limits are inclusive.
*/
TokenSwitchCase lastCase = null;
TokenSwitchCase nextCase;
for (nextCase = sortedCases; nextCase != null; nextCase = nextCase.nextSortedCase) {
if (nextCase.val1 > thisCase.val2) break;
if (nextCase.val2 >= thisCase.val1) {
ErrorMsg (thisCase, "value used by previous case");
ErrorMsg (nextCase, "...previous case");
return;
}
lastCase = nextCase;
}
thisCase.nextSortedCase = nextCase;
if (lastCase == null) {
sortedCases = thisCase;
} else {
lastCase.nextSortedCase = thisCase;
}
}
if (defaultLabel == null) {
defaultLabel = ilGen.DefineLabel ("default_" + switchStmt.Unique);
}
/*
* Output code to jump to the case statement's labels based on integer index on stack.
* Note that each case still has the integer index on stack when jumped to.
*/
int offset = 0;
for (TokenSwitchCase thisCase = sortedCases; thisCase != null;) {
/*
* Scan through list of cases to find the maximum number of cases who's numvalues-to-case ratio
* is from 0.5 to 2.0. If such a group is found, use a CIL switch for them. If not, just use a
* compare-and-branch for the current case.
*/
int numCases = 0;
int numFound = 0;
int lowValue = thisCase.val1;
int numValues = 0;
for (TokenSwitchCase scanCase = thisCase; scanCase != null; scanCase = scanCase.nextSortedCase) {
int nVals = scanCase.val2 - thisCase.val1 + 1;
double ratio = (double)nVals / (double)(++ numCases);
if ((ratio >= 0.5) && (ratio <= 2.0)) {
numFound = numCases;
numValues = nVals;
}
}
if (numFound > 1) {
/*
* There is a group of case's, starting with thisCase, that fall within our criteria, ie,
* that have a nice density of meaningful jumps.
*
* So first generate an array of jumps to the default label (explicit or implicit).
*/
ScriptMyLabel[] labels = new ScriptMyLabel[numValues];
for (int i = 0; i < numValues; i ++) {
labels[i] = defaultLabel;
}
/*
* Next, for each case in that group, fill in the corresponding array entries to jump to
* that case's label.
*/
do {
for (int i = thisCase.val1; i <= thisCase.val2; i ++) {
labels[i-lowValue] = thisCase.label;
}
thisCase = thisCase.nextSortedCase;
} while (-- numFound > 0);
/*
* Subtract the low value and do the computed jump.
* The OpCodes.Switch falls through if out of range (unsigned compare).
*/
if (offset != lowValue) {
ilGen.Emit (switchStmt, OpCodes.Ldc_I4, lowValue - offset);
ilGen.Emit (switchStmt, OpCodes.Sub);
offset = lowValue;
}
ilGen.Emit (switchStmt, OpCodes.Dup);
ilGen.Emit (switchStmt, OpCodes.Switch, labels);
} else {
/*
* It's not economical to do with a computed jump, so output a subtract/compare/branch
* for thisCase.
*/
if (lowValue == thisCase.val2) {
ilGen.Emit (switchStmt, OpCodes.Dup);
ilGen.Emit (switchStmt, OpCodes.Ldc_I4, lowValue - offset);
ilGen.Emit (switchStmt, OpCodes.Beq, thisCase.label);
} else {
if (offset != lowValue) {
ilGen.Emit (switchStmt, OpCodes.Ldc_I4, lowValue - offset);
ilGen.Emit (switchStmt, OpCodes.Sub);
offset = lowValue;
}
ilGen.Emit (switchStmt, OpCodes.Dup);
ilGen.Emit (switchStmt, OpCodes.Ldc_I4, thisCase.val2 - offset);
ilGen.Emit (switchStmt, OpCodes.Ble_Un, thisCase.label);
}
thisCase = thisCase.nextSortedCase;
}
}
ilGen.Emit (switchStmt, OpCodes.Br, defaultLabel);
/*
* Output code for the cases themselves, in the order given by the programmer,
* so they fall through as programmer wants. This includes the default case, if any.
*
* Each label is jumped to with the index still on the stack. So pop it off in case
* the case body does a goto outside the switch or a return. If the case body might
* fall through to the next case or the bottom of the switch, push a zero so the stack
* matches in all cases.
*/
for (TokenSwitchCase thisCase = switchStmt.cases; thisCase != null; thisCase = thisCase.nextCase) {
ilGen.MarkLabel (thisCase.label); // the branch comes here
ilGen.Emit (thisCase, OpCodes.Pop); // pop the integer index off stack
mightGetHere = true; // it's possible to get here
for (TokenStmt stmt = thisCase.stmts; stmt != null; stmt = (TokenStmt)(stmt.nextToken)) {
GenerateStmt (stmt); // output the case/explicit default body
}
if (mightGetHere) {
ilGen.Emit (thisCase, OpCodes.Ldc_I4_0);
// in case we fall through, push a dummy integer index
}
}
/*
* If no explicit default case, output the default label here.
*/
if (defaultCase == null) {
ilGen.MarkLabel (defaultLabel);
mightGetHere = true;
}
/*
* If the last case of the switch falls through out the bottom,
* we have to pop the index still on the stack.
*/
if (mightGetHere) {
ilGen.Emit (switchStmt, OpCodes.Pop);
}
/*
* Output the 'break' statement target label.
* Note that the integer index is not on the stack at this point.
*/
if (curBreakTarg.used) {
ilGen.MarkLabel (curBreakTarg.label);
mightGetHere = true;
}
curBreakTarg = oldBreakTarg;
}
private void GenerateStmtSwitchStr (CompValu testRVal, TokenStmtSwitch switchStmt)
{
BreakContTarg oldBreakTarg = curBreakTarg;
ScriptMyLabel defaultLabel = null;
TokenSwitchCase caseTreeTop = null;
TokenSwitchCase defaultCase = null;
curBreakTarg = new BreakContTarg (this, "switchbreak_" + switchStmt.Unique);
/*
* Make sure value is in a temp so we don't compute it more than once.
*/
if (!(testRVal is CompValuTemp)) {
CompValuTemp temp = new CompValuTemp (testRVal.type, this);
testRVal.PushVal (this, switchStmt);
temp.Pop (this, switchStmt);
testRVal = temp;
}
/*
* Build tree of cases.
* There should not be any overlapping of values.
*/
for (TokenSwitchCase thisCase = switchStmt.cases; thisCase != null; thisCase = thisCase.nextCase) {
thisCase.label = ilGen.DefineLabel ("case");
/*
* The default case if any, goes in its own separate slot.
*/
if (thisCase.rVal1 == null) {
if (defaultCase != null) {
ErrorMsg (thisCase, "only one default case allowed");
ErrorMsg (defaultCase, "...prior default case");
return;
}
defaultCase = thisCase;
defaultLabel = thisCase.label;
continue;
}
/*
* Evaluate case operands, they must be compile-time string constants.
*/
CompValu rVal = GenerateFromRVal (thisCase.rVal1);
if (!IsConstStrExpr (rVal, out thisCase.str1)) {
ErrorMsg (thisCase.rVal1, "must be compile-time string constant");
continue;
}
thisCase.str2 = thisCase.str1;
if (thisCase.rVal2 != null) {
rVal = GenerateFromRVal (thisCase.rVal2);
if (!IsConstStrExpr (rVal, out thisCase.str2)) {
ErrorMsg (thisCase.rVal2, "must be compile-time string constant");
continue;
}
}
if (String.Compare (thisCase.str2, thisCase.str1, StringComparison.Ordinal) < 0) {
ErrorMsg (thisCase.rVal2, "must be .ge. first value for the case");
continue;
}
/*
* Insert into list, sorted by value.
* Note that both limits are inclusive.
*/
caseTreeTop = InsertCaseInTree (caseTreeTop, thisCase);
}
/*
* Balance tree so we end up generating code that does O(log2 n) comparisons.
*/
caseTreeTop = BalanceTree (caseTreeTop);
/*
* Output compare and branch instructions in a tree-like fashion so we do O(log2 n) comparisons.
*/
if (defaultLabel == null) {
defaultLabel = ilGen.DefineLabel ("default");
}
OutputStrCase (testRVal, caseTreeTop, defaultLabel);
/*
* Output code for the cases themselves, in the order given by the programmer,
* so they fall through as programmer wants. This includes the default case, if any.
*/
for (TokenSwitchCase thisCase = switchStmt.cases; thisCase != null; thisCase = thisCase.nextCase) {
ilGen.MarkLabel (thisCase.label); // the branch comes here
mightGetHere = true; // it's possible to get here
for (TokenStmt stmt = thisCase.stmts; stmt != null; stmt = (TokenStmt)(stmt.nextToken)) {
GenerateStmt (stmt); // output the case/explicit default body
}
}
/*
* If no explicit default case, output the default label here.
*/
if (defaultCase == null) {
ilGen.MarkLabel (defaultLabel);
mightGetHere = true;
}
/*
* Output the 'break' statement target label.
*/
if (curBreakTarg.used) {
ilGen.MarkLabel (curBreakTarg.label);
mightGetHere = true;
}
curBreakTarg = oldBreakTarg;
}
/**
* @brief Insert a case in a tree of cases
* @param r = root of existing cases to insert into
* @param n = new case being inserted
* @returns new root with new case inserted
*/
private TokenSwitchCase InsertCaseInTree (TokenSwitchCase r, TokenSwitchCase n)
{
if (r == null) return n;
TokenSwitchCase t = r;
while (true) {
if (String.Compare (n.str2, t.str1, StringComparison.Ordinal) < 0) {
if (t.lowerCase == null) {
t.lowerCase = n;
break;
}
t = t.lowerCase;
continue;
}
if (String.Compare (n.str1, t.str2, StringComparison.Ordinal) > 0) {
if (t.higherCase == null) {
t.higherCase = n;
break;
}
t = t.higherCase;
continue;
}
ErrorMsg (n, "duplicate case");
ErrorMsg (r, "...duplicate of");
break;
}
return r;
}
/**
* @brief Balance a tree so left & right halves contain same number within +-1
* @param r = root of tree to balance
* @returns new root
*/
private static TokenSwitchCase BalanceTree (TokenSwitchCase r)
{
if (r == null) return r;
int lc = CountTree (r.lowerCase);
int hc = CountTree (r.higherCase);
TokenSwitchCase n, x;
/*
* If lower side is heavy, move highest nodes from lower side to
* higher side until balanced.
*/
while (lc > hc + 1) {
x = ExtractHighest (r.lowerCase, out n);
n.lowerCase = x;
n.higherCase = r;
r.lowerCase = null;
r = n;
lc --;
hc ++;
}
/*
* If higher side is heavy, move lowest nodes from higher side to
* lower side until balanced.
*/
while (hc > lc + 1) {
x = ExtractLowest (r.higherCase, out n);
n.higherCase = x;
n.lowerCase = r;
r.higherCase = null;
r = n;
lc ++;
hc --;
}
/*
* Now balance each side because they can be lopsided individually.
*/
r.lowerCase = BalanceTree (r.lowerCase);
r.higherCase = BalanceTree (r.higherCase);
return r;
}
/**
* @brief Get number of nodes in a tree
* @param n = root of tree to count
* @returns number of nodes including root
*/
private static int CountTree (TokenSwitchCase n)
{
if (n == null) return 0;
return 1 + CountTree (n.lowerCase) + CountTree (n.higherCase);
}
// Extract highest node from a tree
// @param r = root of tree to extract highest from
// @returns new root after node has been extracted
// n = node that was extracted from tree
private static TokenSwitchCase ExtractHighest (TokenSwitchCase r, out TokenSwitchCase n)
{
if (r.higherCase == null) {
n = r;
return r.lowerCase;
}
r.higherCase = ExtractHighest (r.higherCase, out n);
return r;
}
// Extract lowest node from a tree
// @param r = root of tree to extract lowest from
// @returns new root after node has been extracted
// n = node that was extracted from tree
private static TokenSwitchCase ExtractLowest (TokenSwitchCase r, out TokenSwitchCase n)
{
if (r.lowerCase == null) {
n = r;
return r.higherCase;
}
r.lowerCase = ExtractLowest (r.lowerCase, out n);
return r;
}
/**
* Output code for string-style case of a switch/case to jump to the script code associated with the case.
* @param testRVal = value being switched on
* @param thisCase = case that the code is being output for
* @param defaultLabel = where the default clause is (or past all cases if none)
* Note:
* Outputs code for this case and the lowerCase and higherCases if any.
* If no lowerCase or higherCase, outputs a br to defaultLabel so this code never falls through.
*/
private void OutputStrCase (CompValu testRVal, TokenSwitchCase thisCase, ScriptMyLabel defaultLabel)
{
/*
* If nothing lower on tree and there is a single case value,
* just do one compare for equality.
*/
if ((thisCase.lowerCase == null) && (thisCase.higherCase == null) && (thisCase.str1 == thisCase.str2)) {
testRVal.PushVal (this, thisCase, tokenTypeStr);
ilGen.Emit (thisCase, OpCodes.Ldstr, thisCase.str1);
ilGen.Emit (thisCase, OpCodes.Ldc_I4, (int)StringComparison.Ordinal);
ilGen.Emit (thisCase, OpCodes.Call, stringCompareMethodInfo);
ilGen.Emit (thisCase, OpCodes.Brfalse, thisCase.label);
ilGen.Emit (thisCase, OpCodes.Br, defaultLabel);
return;
}
/*
* Determine where to jump if switch value is lower than lower case value.
*/
ScriptMyLabel lowerLabel = defaultLabel;
if (thisCase.lowerCase != null) {
lowerLabel = ilGen.DefineLabel ("lower");
}
/*
* If single case value, put comparison result in this temp.
*/
CompValuTemp cmpv1 = null;
if (thisCase.str1 == thisCase.str2) {
cmpv1 = new CompValuTemp (tokenTypeInt, this);
}
/*
* If switch value .lt. lower case value, jump to lower label.
* Maybe save comparison result in a temp.
*/
testRVal.PushVal (this, thisCase, tokenTypeStr);
ilGen.Emit (thisCase, OpCodes.Ldstr, thisCase.str1);
ilGen.Emit (thisCase, OpCodes.Ldc_I4, (int)StringComparison.Ordinal);
ilGen.Emit (thisCase, OpCodes.Call, stringCompareMethodInfo);
if (cmpv1 != null) {
ilGen.Emit (thisCase, OpCodes.Dup);
cmpv1.Pop (this, thisCase);
}
ilGen.Emit (thisCase, OpCodes.Ldc_I4_0);
ilGen.Emit (thisCase, OpCodes.Blt, lowerLabel);
/*
* If switch value .le. higher case value, jump to case code.
* Maybe get comparison from the temp.
*/
if (cmpv1 == null) {
testRVal.PushVal (this, thisCase, tokenTypeStr);
ilGen.Emit (thisCase, OpCodes.Ldstr, thisCase.str2);
ilGen.Emit (thisCase, OpCodes.Ldc_I4, (int)StringComparison.Ordinal);
ilGen.Emit (thisCase, OpCodes.Call, stringCompareMethodInfo);
} else {
cmpv1.PushVal (this, thisCase);
}
ilGen.Emit (thisCase, OpCodes.Ldc_I4_0);
ilGen.Emit (thisCase, OpCodes.Ble, thisCase.label);
/*
* Output code for higher comparison if any.
*/
if (thisCase.higherCase == null) {
ilGen.Emit (thisCase, OpCodes.Br, defaultLabel);
} else {
OutputStrCase (testRVal, thisCase.higherCase, defaultLabel);
}
/*
* Output code for lower comparison if any.
*/
if (thisCase.lowerCase != null) {
ilGen.MarkLabel (lowerLabel);
OutputStrCase (testRVal, thisCase.lowerCase, defaultLabel);
}
}
/**
* @brief output code for a throw statement.
* @param throwStmt = throw statement token, including value to be thrown
*/
private void GenerateStmtThrow (TokenStmtThrow throwStmt)
{
if (!mightGetHere) return;
/*
* 'throw' statements never fall through.
*/
mightGetHere = false;
/*
* Output code for either a throw or a rethrow.
*/
if (throwStmt.rVal == null) {
for (TokenStmtBlock blk = curStmtBlock; blk != null; blk = blk.outerStmtBlock) {
if (curStmtBlock.isCatch) {
ilGen.Emit (throwStmt, OpCodes.Rethrow);
return;
}
}
ErrorMsg (throwStmt, "rethrow allowed only in catch clause");
} else {
CompValu rVal = GenerateFromRVal (throwStmt.rVal);
rVal.PushVal (this, throwStmt.rVal, tokenTypeObj);
ilGen.Emit (throwStmt, OpCodes.Call, thrownExceptionWrapMethodInfo);
ilGen.Emit (throwStmt, OpCodes.Throw);
}
}
/**
* @brief output code for a try/catch/finally block
*/
private void GenerateStmtTry (TokenStmtTry tryStmt)
{
if (!mightGetHere) return;
/*
* Reducer should make sure we have exactly one of catch or finally.
*/
if ((tryStmt.catchStmt == null) && (tryStmt.finallyStmt == null)) {
throw new Exception ("must have a catch or a finally on try");
}
if ((tryStmt.catchStmt != null) && (tryStmt.finallyStmt != null)) {
throw new Exception ("can't have both catch and finally on same try");
}
/*
* Stack the call labels.
* Try blocks have their own series of call labels.
*/
ScriptMyLocal saveCallNo = actCallNo;
LinkedList<CallLabel> saveCallLabels = actCallLabels;
/*
* Generate code for either try { } catch { } or try { } finally { }.
*/
if (tryStmt.catchStmt != null) GenerateStmtTryCatch (tryStmt);
if (tryStmt.finallyStmt != null) GenerateStmtTryFinally (tryStmt);
/*
* Restore call labels.
*/
actCallNo = saveCallNo;
actCallLabels = saveCallLabels;
}
/**
* @brief output code for a try/catch block
*
* int __tryCallNo = -1; // call number within try { } subblock
* int __catCallNo = -1; // call number within catch { } subblock
* Exception __catThrown = null; // caught exception
* <oldCallLabel>: // the outside world jumps here to restore us no matter ...
* try { // ... where we actually were inside of try/catch
* if (__tryCallNo >= 0) goto tryCallSw; // maybe go do restore
* <try body using __tryCallNo> // execute script-defined code
* // ...stack capture WILL run catch { } subblock
* leave tryEnd; // exits
* tryThrow:<tryCallLabel>:
* throw new ScriptRestoreCatchException(__catThrown); // catch { } was running, jump to its beginning
* tryCallSw: // restoring...
* switch (__tryCallNo) back up into <try body> // not catching, jump back inside try
* } catch (Exception exc) {
* exc = ScriptRestoreCatchException.Unwrap(exc); // unwrap possible ScriptRestoreCatchException
* if (exc == null) goto catchRetro; // rethrow if IXMRUncatchable (eg, StackCaptureException)
* __catThrown = exc; // save what was thrown so restoring try { } will throw it again
* catchVar = exc; // set up script-visible variable
* __tryCallNo = tryThrow:<tryCallLabel>
* if (__catCallNo >= 0) goto catchCallSw; // if restoring, go check below
* <catch body using __catCallNo> // normal, execute script-defined code
* leave tryEnd; // all done, exit catch { }
* catchRetro:
* rethrow;
* catchCallSw:
* switch (__catCallNo) back up into <catch body> // restart catch { } code wherever it was
* }
* tryEnd:
*/
private void GenerateStmtTryCatch (TokenStmtTry tryStmt)
{
CompValuTemp tryCallNo = new CompValuTemp (tokenTypeInt, this);
CompValuTemp catCallNo = new CompValuTemp (tokenTypeInt, this);
CompValuTemp catThrown = new CompValuTemp (tokenTypeExc, this);
ScriptMyLabel tryCallSw = ilGen.DefineLabel ("__tryCallSw_" + tryStmt.Unique);
ScriptMyLabel catchRetro = ilGen.DefineLabel ("__catchRetro_" + tryStmt.Unique);
ScriptMyLabel catchCallSw = ilGen.DefineLabel ("__catchCallSw_" + tryStmt.Unique);
ScriptMyLabel tryEnd = ilGen.DefineLabel ("__tryEnd_" + tryStmt.Unique);
SetCallNo (tryStmt, tryCallNo, -1);
SetCallNo (tryStmt, catCallNo, -1);
ilGen.Emit (tryStmt, OpCodes.Ldnull);
catThrown.Pop (this, tryStmt);
new CallLabel (this, tryStmt); // <oldcalllabel>:
ilGen.BeginExceptionBlock (); // try {
openCallLabel = null;
if (DEBUG_TRYSTMT) {
ilGen.Emit (tryStmt, OpCodes.Ldstr, "enter try*: " + tryStmt.line + " callMode=");
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
PushXMRInst ();
ilGen.Emit (tryStmt, OpCodes.Ldfld, callModeFieldInfo);
ilGen.Emit (tryStmt, OpCodes.Box, typeof (int));
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
ilGen.Emit (tryStmt, OpCodes.Ldstr, " tryCallNo=");
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
tryCallNo.PushVal (this, tryStmt);
ilGen.Emit (tryStmt, OpCodes.Box, typeof (int));
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
ilGen.Emit (tryStmt, OpCodes.Ldstr, " catThrown.IsNull=");
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
catThrown.PushVal (this, tryStmt);
ilGen.Emit (tryStmt, OpCodes.Ldnull);
ilGen.Emit (tryStmt, OpCodes.Ceq);
ilGen.Emit (tryStmt, OpCodes.Box, typeof (int));
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
ilGen.Emit (tryStmt, OpCodes.Ldstr, " catCallNo=");
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
catCallNo.PushVal (this, tryStmt);
ilGen.Emit (tryStmt, OpCodes.Box, typeof (int));
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
ilGen.Emit (tryStmt, OpCodes.Ldstr, "\n");
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
}
GetCallNo (tryStmt, tryCallNo); // if (__tryCallNo >= 0) goto tryCallSw;
ilGen.Emit (tryStmt, OpCodes.Ldc_I4_0);
ilGen.Emit (tryStmt, OpCodes.Bge, tryCallSw);
actCallNo = tryCallNo.localBuilder; // set up __tryCallNo for call labels
actCallLabels = new LinkedList<CallLabel> ();
GenerateStmtBlock (tryStmt.tryStmt); // output the try block statement subblock
bool tryBlockFallsOutBottom = mightGetHere;
if (tryBlockFallsOutBottom) {
new CallLabel (this, tryStmt); // <tryCallLabel>:
ilGen.Emit (tryStmt, OpCodes.Leave, tryEnd); // leave tryEnd;
openCallLabel = null;
}
CallLabel tryThrow = new CallLabel (this, tryStmt); // tryThrow:<tryCallLabel>:
if (DEBUG_TRYSTMT) {
ilGen.Emit (tryStmt, OpCodes.Ldstr, "tryThrow*: " + tryStmt.line + " catThrown=");
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
catThrown.PushVal (this, tryStmt);
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
ilGen.Emit (tryStmt, OpCodes.Ldstr, "\n");
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
}
catThrown.PushVal (this, tryStmt); // throw new ScriptRestoreCatchException (__catThrown);
ilGen.Emit (tryStmt, OpCodes.Newobj, scriptRestoreCatchExceptionConstructorInfo);
ilGen.Emit (tryStmt, OpCodes.Throw);
openCallLabel = null;
ilGen.MarkLabel (tryCallSw); // tryCallSw:
if (DEBUG_TRYSTMT) {
ilGen.Emit (tryStmt, OpCodes.Ldstr, "tryCallSw*: " + tryStmt.line + " tryCallNo=");
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
tryCallNo.PushVal (this, tryStmt);
ilGen.Emit (tryStmt, OpCodes.Box, typeof (int));
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
ilGen.Emit (tryStmt, OpCodes.Ldstr, "\n");
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
}
OutputCallNoSwitchStmt (); // switch (tryCallNo) ...
CompValuLocalVar catchVarLocExc = null;
CompValuTemp catchVarLocStr = null;
if (tryStmt.catchVar.type.ToSysType () == typeof (Exception)) {
catchVarLocExc = new CompValuLocalVar (tryStmt.catchVar.type, tryStmt.catchVar.name.val, this);
} else if (tryStmt.catchVar.type.ToSysType () == typeof (String)) {
catchVarLocStr = new CompValuTemp (tryStmt.catchVar.type, this);
}
ScriptMyLocal excLocal = ilGen.DeclareLocal (typeof (String), "catchstr_" + tryStmt.Unique);
ilGen.BeginCatchBlock (typeof (Exception)); // start of the catch block that can catch any exception
if (DEBUG_TRYSTMT) {
ilGen.Emit (tryStmt.catchStmt, OpCodes.Ldstr, "enter catch*: " + tryStmt.line + " callMode=");
ilGen.Emit (tryStmt.catchStmt, OpCodes.Call, consoleWriteMethodInfo);
PushXMRInst ();
ilGen.Emit (tryStmt.catchStmt, OpCodes.Ldfld, callModeFieldInfo);
ilGen.Emit (tryStmt.catchStmt, OpCodes.Box, typeof (int));
ilGen.Emit (tryStmt.catchStmt, OpCodes.Call, consoleWriteMethodInfo);
ilGen.Emit (tryStmt.catchStmt, OpCodes.Ldstr, " catCallNo=");
ilGen.Emit (tryStmt.catchStmt, OpCodes.Call, consoleWriteMethodInfo);
catCallNo.PushVal (this, tryStmt);
ilGen.Emit (tryStmt.catchStmt, OpCodes.Box, typeof (int));
ilGen.Emit (tryStmt.catchStmt, OpCodes.Call, consoleWriteMethodInfo);
ilGen.Emit (tryStmt.catchStmt, OpCodes.Ldstr, " exc=");
ilGen.Emit (tryStmt.catchStmt, OpCodes.Call, consoleWriteMethodInfo);
ilGen.Emit (tryStmt.catchStmt, OpCodes.Dup);
ilGen.Emit (tryStmt.catchStmt, OpCodes.Call, consoleWriteMethodInfo);
ilGen.Emit (tryStmt.catchStmt, OpCodes.Ldstr, "\n");
ilGen.Emit (tryStmt.catchStmt, OpCodes.Call, consoleWriteMethodInfo);
}
ilGen.Emit (tryStmt.catchStmt, OpCodes.Call, scriptRestoreCatchExceptionUnwrap);
// exc = ScriptRestoreCatchException.Unwrap (exc);
ilGen.Emit (tryStmt.catchStmt, OpCodes.Dup); // rethrow if IXMRUncatchable (eg, StackCaptureException)
ilGen.Emit (tryStmt.catchStmt, OpCodes.Brfalse, catchRetro);
if (tryStmt.catchVar.type.ToSysType () == typeof (Exception)) {
tryStmt.catchVar.location = catchVarLocExc;
ilGen.Emit (tryStmt.catchStmt, OpCodes.Dup);
catThrown.Pop (this, tryStmt); // store exception object in catThrown
catchVarLocExc.Pop (this, tryStmt.catchVar.name); // also store in script-visible variable
} else if (tryStmt.catchVar.type.ToSysType () == typeof (String)) {
tryStmt.catchVar.location = catchVarLocStr;
ilGen.Emit (tryStmt.catchStmt, OpCodes.Dup);
catThrown.Pop (this, tryStmt); // store exception object in catThrown
ilGen.Emit (tryStmt.catchStmt, OpCodes.Call, catchExcToStrMethodInfo);
ilGen.Emit (tryStmt.catchStmt, OpCodes.Stloc, excLocal);
catchVarLocStr.PopPre (this, tryStmt.catchVar.name);
ilGen.Emit (tryStmt.catchStmt, OpCodes.Ldloc, excLocal);
catchVarLocStr.PopPost (this, tryStmt.catchVar.name, tokenTypeStr);
} else {
throw new Exception ("bad catch var type " + tryStmt.catchVar.type.ToString ());
}
SetCallNo (tryStmt, tryCallNo, tryThrow.index); // __tryCallNo = tryThrow so it knows to do 'throw catThrown' on restore
GetCallNo (tryStmt, catCallNo); // if (__catCallNo >= 0) goto catchCallSw;
ilGen.Emit (tryStmt.catchStmt, OpCodes.Ldc_I4_0);
ilGen.Emit (tryStmt.catchStmt, OpCodes.Bge, catchCallSw);
actCallNo = catCallNo.localBuilder; // set up __catCallNo for call labels
actCallLabels.Clear ();
mightGetHere = true; // if we can get to the 'try' assume we can get to the 'catch'
GenerateStmtBlock (tryStmt.catchStmt); // output catch clause statement subblock
if (mightGetHere) {
new CallLabel (this, tryStmt.catchStmt);
ilGen.Emit (tryStmt.catchStmt, OpCodes.Leave, tryEnd);
openCallLabel = null;
}
ilGen.MarkLabel (catchRetro); // not a script-visible exception, rethrow it
ilGen.Emit (tryStmt.catchStmt, OpCodes.Pop);
ilGen.Emit (tryStmt.catchStmt, OpCodes.Rethrow);
ilGen.MarkLabel (catchCallSw);
OutputCallNoSwitchStmt (); // restoring, jump back inside script-defined body
ilGen.EndExceptionBlock ();
ilGen.MarkLabel (tryEnd);
mightGetHere |= tryBlockFallsOutBottom; // also get here if try body falls out bottom
}
/**
* @brief output code for a try/finally block
*
* This is such a mess because there is hidden state for the finally { } that we have to recreate.
* The finally { } can be entered either via an exception being thrown in the try { } or a leave
* being executed in the try { } whose target is outside the try { } finally { }.
*
* For the thrown exception case, we slip in a try { } catch { } wrapper around the original try { }
* body. This will sense any thrown exception that would execute the finally { }. Then we have our
* try { } throw the exception on restore which gets the finally { } called and on its way again.
*
* For the leave case, we prefix all leave instructions with a call label and we explicitly chain
* all leaves through each try { } that has an associated finally { } that the leave would unwind
* through. This gets each try { } to simply jump to the correct leave instruction which immediately
* invokes the corresponding finally { } and then chains to the next leave instruction on out until
* it gets to its target.
*
* int __finCallNo = -1; // call number within finally { } subblock
* int __tryCallNo = -1; // call number within try { } subblock
* Exception __catThrown = null; // caught exception
* <oldCallLabel>: // the outside world jumps here to restore us no matter ...
* try { // ... where we actually were inside of try/finally
* try {
* if (__tryCallNo >= 0) goto tryCallSw; // maybe go do restore
* <try body using __tryCallNo> // execute script-defined code
* // ...stack capture WILL run catch/finally { } subblock
* leave tryEnd; // executes finally { } subblock and exits
* tryThrow:<tryCallLabel>:
* throw new ScriptRestoreCatchException(__catThrown); // catch { } was running, jump to its beginning
* tryCallSw: // restoring...
* switch (__tryCallNo) back up into <try body> // jump back inside try, ...
* // ... maybe to a leave if we were doing finally { } subblock
* } catch (Exception exc) { // in case we're getting to finally { } via a thrown exception:
* exc = ScriptRestoreCatchException.Unwrap(exc); // unwrap possible ScriptRestoreCatchException
* if (callMode == CallMode_SAVE) goto catchRetro; // don't touch anything if capturing stack
* __catThrown = exc; // save exception so try { } can throw it on restore
* __tryCallNo = tryThrow:<tryCallLabel>; // tell try { } to throw it on restore
* catchRetro:
* rethrow; // in any case, go on to finally { } subblock now
* }
* } finally {
* if (callMode == CallMode_SAVE) goto finEnd; // don't touch anything if capturing stack
* if (__finCallNo >= 0) goto finCallSw; // maybe go do restore
* <finally body using __finCallNo> // normal, execute script-defined code
* finEnd:
* endfinally // jump to leave/throw target or next outer finally { }
* finCallSw:
* switch (__finCallNo) back up into <finally body> // restoring, restart finally { } code wherever it was
* }
* tryEnd:
*/
private void GenerateStmtTryFinally (TokenStmtTry tryStmt)
{
CompValuTemp finCallNo = new CompValuTemp (tokenTypeInt, this);
CompValuTemp tryCallNo = new CompValuTemp (tokenTypeInt, this);
CompValuTemp catThrown = new CompValuTemp (tokenTypeExc, this);
ScriptMyLabel tryCallSw = ilGen.DefineLabel ( "__tryCallSw_" + tryStmt.Unique);
ScriptMyLabel catchRetro = ilGen.DefineLabel ( "__catchRetro_" + tryStmt.Unique);
ScriptMyLabel finCallSw = ilGen.DefineLabel ( "__finCallSw_" + tryStmt.Unique);
BreakContTarg finEnd = new BreakContTarg (this, "__finEnd_" + tryStmt.Unique);
ScriptMyLabel tryEnd = ilGen.DefineLabel ( "__tryEnd_" + tryStmt.Unique);
SetCallNo (tryStmt, finCallNo, -1);
SetCallNo (tryStmt, tryCallNo, -1);
ilGen.Emit (tryStmt, OpCodes.Ldnull);
catThrown.Pop (this, tryStmt);
new CallLabel (this, tryStmt); // <oldcalllabel>:
ilGen.BeginExceptionBlock (); // try {
ilGen.BeginExceptionBlock (); // try {
openCallLabel = null;
if (DEBUG_TRYSTMT) {
ilGen.Emit (tryStmt, OpCodes.Ldstr, "enter try*: " + tryStmt.line + " callMode=");
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
PushXMRInst ();
ilGen.Emit (tryStmt, OpCodes.Ldfld, callModeFieldInfo);
ilGen.Emit (tryStmt, OpCodes.Box, typeof (int));
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
ilGen.Emit (tryStmt, OpCodes.Ldstr, " tryCallNo=");
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
tryCallNo.PushVal (this, tryStmt);
ilGen.Emit (tryStmt, OpCodes.Box, typeof (int));
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
ilGen.Emit (tryStmt, OpCodes.Ldstr, " finCallNo=");
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
finCallNo.PushVal (this, tryStmt);
ilGen.Emit (tryStmt, OpCodes.Box, typeof (int));
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
ilGen.Emit (tryStmt, OpCodes.Ldstr, " catThrown.IsNull=");
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
catThrown.PushVal (this, tryStmt);
ilGen.Emit (tryStmt, OpCodes.Ldnull);
ilGen.Emit (tryStmt, OpCodes.Ceq);
ilGen.Emit (tryStmt, OpCodes.Box, typeof (int));
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
ilGen.Emit (tryStmt, OpCodes.Ldstr, "\n");
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
}
GetCallNo (tryStmt, tryCallNo); // if (__tryCallNo >= 0) goto tryCallSw;
ilGen.Emit (tryStmt, OpCodes.Ldc_I4_0);
ilGen.Emit (tryStmt, OpCodes.Bge, tryCallSw);
actCallNo = tryCallNo.localBuilder; // set up __tryCallNo for call labels
actCallLabels = new LinkedList<CallLabel> ();
GenerateStmtBlock (tryStmt.tryStmt); // output the try block statement subblock
if (mightGetHere) {
new CallLabel (this, tryStmt); // <newCallLabel>:
ilGen.Emit (tryStmt, OpCodes.Leave, tryEnd); // leave tryEnd;
openCallLabel = null;
}
foreach (IntermediateLeave iLeave in tryStmt.iLeaves.Values) {
ilGen.MarkLabel (iLeave.jumpIntoLabel); // intr2_exit:
new CallLabel (this, tryStmt); // tryCallNo = n;
ilGen.Emit (tryStmt, OpCodes.Leave, iLeave.jumpAwayLabel); // __callNo_n_: leave int1_exit;
openCallLabel = null;
}
CallLabel tryThrow = new CallLabel (this, tryStmt); // tryThrow:<tryCallLabel>:
if (DEBUG_TRYSTMT) {
ilGen.Emit (tryStmt, OpCodes.Ldstr, "tryThrow*: " + tryStmt.line + " catThrown=");
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
catThrown.PushVal (this, tryStmt);
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
ilGen.Emit (tryStmt, OpCodes.Ldstr, "\n");
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
}
catThrown.PushVal (this, tryStmt); // throw new ScriptRestoreCatchException (__catThrown);
ilGen.Emit (tryStmt, OpCodes.Newobj, scriptRestoreCatchExceptionConstructorInfo);
ilGen.Emit (tryStmt, OpCodes.Throw);
openCallLabel = null;
ilGen.MarkLabel (tryCallSw); // tryCallSw:
OutputCallNoSwitchStmt (); // switch (tryCallNo) ...
// }
ilGen.BeginCatchBlock (typeof (Exception)); // start of the catch block that can catch any exception
if (DEBUG_TRYSTMT) {
ilGen.Emit (tryStmt, OpCodes.Ldstr, "enter catch*: " + tryStmt.line + " callMode=");
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
PushXMRInst ();
ilGen.Emit (tryStmt, OpCodes.Ldfld, callModeFieldInfo);
ilGen.Emit (tryStmt, OpCodes.Box, typeof (int));
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
ilGen.Emit (tryStmt, OpCodes.Ldstr, " exc=");
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
ilGen.Emit (tryStmt, OpCodes.Dup);
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
ilGen.Emit (tryStmt, OpCodes.Ldstr, "\n");
ilGen.Emit (tryStmt, OpCodes.Call, consoleWriteMethodInfo);
}
ilGen.Emit (tryStmt, OpCodes.Call, scriptRestoreCatchExceptionUnwrap); // exc = ScriptRestoreCatchException.Unwrap (exc);
PushXMRInst (); // if (callMode == CallMode_SAVE) goto catchRetro;
ilGen.Emit (tryStmt, OpCodes.Ldfld, callModeFieldInfo);
ilGen.Emit (tryStmt, OpCodes.Ldc_I4, XMRInstAbstract.CallMode_SAVE);
ilGen.Emit (tryStmt, OpCodes.Beq, catchRetro);
catThrown.Pop (this, tryStmt); // __catThrown = exc;
SetCallNo (tryStmt, tryCallNo, tryThrow.index); // __tryCallNo = tryThrow:<tryCallLabel>;
ilGen.Emit (tryStmt, OpCodes.Rethrow);
ilGen.MarkLabel (catchRetro); // catchRetro:
ilGen.Emit (tryStmt, OpCodes.Pop);
ilGen.Emit (tryStmt, OpCodes.Rethrow); // rethrow;
ilGen.EndExceptionBlock (); // }
ilGen.BeginFinallyBlock (); // start of the finally block
PushXMRInst (); // if (callMode == CallMode_SAVE) goto finEnd;
ilGen.Emit (tryStmt, OpCodes.Ldfld, callModeFieldInfo);
ilGen.Emit (tryStmt, OpCodes.Ldc_I4, XMRInstAbstract.CallMode_SAVE);
ilGen.Emit (tryStmt, OpCodes.Beq, finEnd.label);
GetCallNo (tryStmt, finCallNo); // if (__finCallNo >= 0) goto finCallSw;
ilGen.Emit (tryStmt, OpCodes.Ldc_I4_0);
ilGen.Emit (tryStmt, OpCodes.Bge, finCallSw);
actCallNo = finCallNo.localBuilder; // set up __finCallNo for call labels
actCallLabels.Clear ();
mightGetHere = true; // if we can get to the 'try' assume we can get to the 'finally'
GenerateStmtBlock (tryStmt.finallyStmt); // output finally clause statement subblock
ilGen.MarkLabel (finEnd.label); // finEnd:
ilGen.Emit (tryStmt, OpCodes.Endfinally); // return out to next finally { } or catch { } or leave target
ilGen.MarkLabel (finCallSw); // restore mode, switch (finCallNo) ...
OutputCallNoSwitchStmt ();
ilGen.EndExceptionBlock ();
ilGen.MarkLabel (tryEnd);
mightGetHere |= finEnd.used; // get here if finally body falls through or has a break statement
}
/**
* @brief Generate code to initialize a variable to its default value.
*/
private void GenerateStmtVarIniDef (TokenStmtVarIniDef varIniDefStmt)
{
if (!mightGetHere) return;
CompValu left = GenerateFromLVal (varIniDefStmt.var);
left.PopPre (this, varIniDefStmt);
PushDefaultValue (left.type);
left.PopPost (this, varIniDefStmt);
}
/**
* @brief generate code for a 'while' statement including the loop body.
*/
private void GenerateStmtWhile (TokenStmtWhile whileStmt)
{
if (!mightGetHere) return;
BreakContTarg oldBreakTarg = curBreakTarg;
BreakContTarg oldContTarg = curContTarg;
ScriptMyLabel loopLabel = ilGen.DefineLabel ("whileloop_" + whileStmt.Unique);
curBreakTarg = new BreakContTarg (this, "whilebreak_" + whileStmt.Unique);
curContTarg = new BreakContTarg (this, "whilecont_" + whileStmt.Unique);
ilGen.MarkLabel (loopLabel); // loop:
CompValu testRVal = GenerateFromRVal (whileStmt.testRVal); // testRVal = while test expression
if (!IsConstBoolExprTrue (testRVal)) {
testRVal.PushVal (this, whileStmt.testRVal, tokenTypeBool); // if (!testRVal)
ilGen.Emit (whileStmt, OpCodes.Brfalse, curBreakTarg.label); // goto break
curBreakTarg.used = true;
}
GenerateStmt (whileStmt.bodyStmt); // while body statement
if (curContTarg.used) {
ilGen.MarkLabel (curContTarg.label); // cont:
mightGetHere = true;
}
if (mightGetHere) {
EmitCallCheckRun (whileStmt, false); // __sw.CheckRun()
ilGen.Emit (whileStmt, OpCodes.Br, loopLabel); // goto loop
}
mightGetHere = curBreakTarg.used;
if (mightGetHere) {
ilGen.MarkLabel (curBreakTarg.label); // done:
}
curBreakTarg = oldBreakTarg;
curContTarg = oldContTarg;
}
/**
* @brief process a local variable declaration statement, possibly with initialization expression.
* Note that the function header processing allocated stack space (CompValuTemp) for the
* variable and now all we do is write its initialization value.
*/
private void GenerateDeclVar (TokenDeclVar declVar)
{
/*
* Script gave us an initialization value, so just store init value in var like an assignment statement.
* If no init given, set it to its default value.
*/
CompValu local = declVar.location;
if (declVar.init != null) {
CompValu rVal = GenerateFromRVal (declVar.init, local.GetArgTypes ());
local.PopPre (this, declVar);
rVal.PushVal (this, declVar.init, declVar.type);
local.PopPost (this, declVar);
} else {
local.PopPre (this, declVar);
PushDefaultValue (declVar.type);
local.PopPost (this, declVar);
}
}
/**
* @brief Get the type and location of an L-value (eg, variable)
* @param lVal = L-value expression to evaluate
* @param argsig = null: it's a field/property
* else: select overload method that fits these arg types
*/
private CompValu GenerateFromLVal (TokenLVal lVal)
{
return GenerateFromLVal (lVal, null);
}
private CompValu GenerateFromLVal (TokenLVal lVal, TokenType[] argsig)
{
if (lVal is TokenLValArEle) return GenerateFromLValArEle ((TokenLValArEle)lVal);
if (lVal is TokenLValBaseField) return GenerateFromLValBaseField ((TokenLValBaseField)lVal, argsig);
if (lVal is TokenLValIField) return GenerateFromLValIField ((TokenLValIField)lVal, argsig);
if (lVal is TokenLValName) return GenerateFromLValName ((TokenLValName)lVal, argsig);
if (lVal is TokenLValSField) return GenerateFromLValSField ((TokenLValSField)lVal, argsig);
throw new Exception ("bad lval class");
}
/**
* @brief we have an L-value token that is an element within an array.
* @returns a CompValu giving the type and location of the element of the array.
*/
private CompValu GenerateFromLValArEle (TokenLValArEle lVal)
{
CompValu subCompValu;
/*
* Compute location of array itself.
*/
CompValu baseCompValu = GenerateFromRVal (lVal.baseRVal);
/*
* Maybe it is a fixed array access.
*/
string basetypestring = baseCompValu.type.ToString ();
if (basetypestring.EndsWith ("]")) {
TokenRVal subRVal = lVal.subRVal;
int nSubs = 1;
if (subRVal is TokenRValList) {
nSubs = ((TokenRValList)subRVal).nItems;
subRVal = ((TokenRValList)subRVal).rVal;
}
int rank = basetypestring.IndexOf (']') - basetypestring.IndexOf ('[');
if (nSubs != rank) {
ErrorMsg (lVal.baseRVal, "expect " + rank + " subscript" + ((rank == 1) ? "" : "s") + " but have " + nSubs);
}
CompValu[] subCompValus = new CompValu[rank];
int i;
for (i = 0; (subRVal != null) && (i < rank); i ++) {
subCompValus[i] = GenerateFromRVal (subRVal);
subRVal = (TokenRVal)subRVal.nextToken;
}
while (i < rank) subCompValus[i++] = new CompValuInteger (new TokenTypeInt (lVal.subRVal), 0);
return new CompValuFixArEl (this, baseCompValu, subCompValus);
}
/*
* Maybe it is accessing the $idxprop property of a script-defined class.
*/
if (baseCompValu.type is TokenTypeSDTypeClass) {
TokenName name = new TokenName (lVal, "$idxprop");
TokenTypeSDTypeClass sdtType = (TokenTypeSDTypeClass)baseCompValu.type;
TokenDeclSDTypeClass sdtDecl = sdtType.decl;
TokenDeclVar idxProp = FindThisMember (sdtDecl, name, null);
if (idxProp == null) {
ErrorMsg (lVal, "no index property in class " + sdtDecl.longName.val);
return new CompValuVoid (lVal);
}
if ((idxProp.sdtFlags & ScriptReduce.SDT_STATIC) != 0) {
ErrorMsg (lVal, "non-static reference to static member " + idxProp.name.val);
return new CompValuVoid (idxProp);
}
CheckAccess (idxProp, name);
TokenType[] argTypes = IdxPropArgTypes (idxProp);
CompValu[] compValus = IdxPropCompValus (lVal, argTypes.Length);
return new CompValuIdxProp (idxProp, baseCompValu, argTypes, compValus);
}
/*
* Maybe they are accessing $idxprop property of a script-defined interface.
*/
if (baseCompValu.type is TokenTypeSDTypeInterface) {
TokenName name = new TokenName (lVal, "$idxprop");
TokenTypeSDTypeInterface sdtType = (TokenTypeSDTypeInterface)baseCompValu.type;
TokenDeclVar idxProp = FindInterfaceMember (sdtType, name, null, ref baseCompValu);
if (idxProp == null) {
ErrorMsg (lVal, "no index property defined for interface " + sdtType.decl.longName.val);
return baseCompValu;
}
TokenType[] argTypes = IdxPropArgTypes (idxProp);
CompValu[] compValus = IdxPropCompValus (lVal, argTypes.Length);
return new CompValuIdxProp (idxProp, baseCompValu, argTypes, compValus);
}
/*
* Maybe it is extracting a character from a string.
*/
if ((baseCompValu.type is TokenTypeKey) || (baseCompValu.type is TokenTypeStr)) {
subCompValu = GenerateFromRVal (lVal.subRVal);
return new CompValuStrChr (new TokenTypeChar (lVal), baseCompValu, subCompValu);
}
/*
* Maybe it is extracting an element from a list.
*/
if (baseCompValu.type is TokenTypeList) {
subCompValu = GenerateFromRVal (lVal.subRVal);
return new CompValuListEl (new TokenTypeObject (lVal), baseCompValu, subCompValu);
}
/*
* Access should be to XMR_Array otherwise.
*/
if (!(baseCompValu.type is TokenTypeArray)) {
ErrorMsg (lVal, "taking subscript of non-array");
return baseCompValu;
}
subCompValu = GenerateFromRVal (lVal.subRVal);
return new CompValuArEle (new TokenTypeObject (lVal), baseCompValu, subCompValu);
}
/**
* @brief Get number and type of arguments required by an index property.
*/
private static TokenType[] IdxPropArgTypes (TokenDeclVar idxProp)
{
TokenType[] argTypes;
if (idxProp.getProp != null) {
int nArgs = idxProp.getProp.argDecl.varDict.Count;
argTypes = new TokenType[nArgs];
foreach (TokenDeclVar var in idxProp.getProp.argDecl.varDict) {
argTypes[var.vTableIndex] = var.type;
}
} else {
int nArgs = idxProp.setProp.argDecl.varDict.Count - 1;
argTypes = new TokenType[nArgs];
foreach (TokenDeclVar var in idxProp.setProp.argDecl.varDict) {
if (var.vTableIndex < nArgs) {
argTypes[var.vTableIndex] = var.type;
}
}
}
return argTypes;
}
/**
* @brief Get number and computed value of index property arguments.
* @param lVal = list of arguments
* @param nArgs = number of arguments required
* @returns null: argument count mismatch
* else: array of index property argument values
*/
private CompValu[] IdxPropCompValus (TokenLValArEle lVal, int nArgs)
{
TokenRVal subRVal = lVal.subRVal;
int nSubs = 1;
if (subRVal is TokenRValList) {
nSubs = ((TokenRValList)subRVal).nItems;
subRVal = ((TokenRValList)subRVal).rVal;
}
if (nSubs != nArgs) {
ErrorMsg (lVal, "index property requires " + nArgs + " subscript(s)");
return null;
}
CompValu[] subCompValus = new CompValu[nArgs];
for (int i = 0; i < nArgs; i ++) {
subCompValus[i] = GenerateFromRVal (subRVal);
subRVal = (TokenRVal)subRVal.nextToken;
}
return subCompValus;
}
/**
* @brief using 'base' within a script-defined instance method to refer to an instance field/method
* of the class being extended.
*/
private CompValu GenerateFromLValBaseField (TokenLValBaseField baseField, TokenType[] argsig)
{
string fieldName = baseField.fieldName.val;
TokenDeclSDType sdtDecl = curDeclFunc.sdtClass;
if ((sdtDecl == null) || ((curDeclFunc.sdtFlags & ScriptReduce.SDT_STATIC) != 0)) {
ErrorMsg (baseField, "cannot use 'base' outside instance method body");
return new CompValuVoid (baseField);
}
if (!IsSDTInstMethod ()) {
ErrorMsg (baseField, "cannot access instance member of base class from static method");
return new CompValuVoid (baseField);
}
TokenDeclVar declVar = FindThisMember (sdtDecl.extends, baseField.fieldName, argsig);
if (declVar != null) {
CheckAccess (declVar, baseField.fieldName);
TokenType baseType = declVar.sdtClass.MakeRefToken (baseField);
CompValu basePtr = new CompValuArg (baseType, 0);
return AccessInstanceMember (declVar, basePtr, baseField, true);
}
ErrorMsg (baseField, "no member " + fieldName + ArgSigString (argsig) + " rootward of " + sdtDecl.longName.val);
return new CompValuVoid (baseField);
}
/**
* @brief We have an L-value token that is an instance field/method within a struct.
* @returns a CompValu giving the type and location of the field/method in the struct.
*/
private CompValu GenerateFromLValIField (TokenLValIField lVal, TokenType[] argsig)
{
CompValu baseRVal = GenerateFromRVal (lVal.baseRVal);
string fieldName = lVal.fieldName.val + ArgSigString (argsig);
/*
* Maybe they are accessing an instance field, method or property of a script-defined class.
*/
if (baseRVal.type is TokenTypeSDTypeClass) {
TokenTypeSDTypeClass sdtType = (TokenTypeSDTypeClass)baseRVal.type;
TokenDeclSDTypeClass sdtDecl = sdtType.decl;
TokenDeclVar declVar = FindThisMember (sdtDecl, lVal.fieldName, argsig);
if (declVar != null) {
CheckAccess (declVar, lVal.fieldName);
return AccessInstanceMember (declVar, baseRVal, lVal, false);
}
ErrorMsg (lVal.fieldName, "no member " + fieldName + " in class " + sdtDecl.longName.val);
return new CompValuVoid (lVal.fieldName);
}
/*
* Maybe they are accessing a method or property of a script-defined interface.
*/
if (baseRVal.type is TokenTypeSDTypeInterface) {
TokenTypeSDTypeInterface sdtType = (TokenTypeSDTypeInterface)baseRVal.type;
TokenDeclVar declVar = FindInterfaceMember (sdtType, lVal.fieldName, argsig, ref baseRVal);
if (declVar != null) {
return new CompValuIntfMember (declVar, baseRVal);
}
ErrorMsg (lVal.fieldName, "no member " + fieldName + " in interface " + sdtType.decl.longName.val);
return new CompValuVoid (lVal.fieldName);
}
/*
* Since we only have a few built-in types with fields, just pound them out.
*/
if (baseRVal.type is TokenTypeArray) {
// no arguments, no parentheses, just the field name, returning integer
// but internally, it is a call to a method()
if (fieldName == "count") {
return new CompValuIntInstROProp (tokenTypeInt, baseRVal, arrayCountMethodInfo);
}
// no arguments but with the parentheses, returning void
if (fieldName == "clear()") {
return new CompValuIntInstMeth (XMR_Array.clearDelegate, baseRVal, arrayClearMethodInfo);
}
// single integer argument, returning an object
if (fieldName == "index(integer)") {
return new CompValuIntInstMeth (XMR_Array.indexDelegate, baseRVal, arrayIndexMethodInfo);
}
if (fieldName == "value(integer)") {
return new CompValuIntInstMeth (XMR_Array.valueDelegate, baseRVal, arrayValueMethodInfo);
}
}
if (baseRVal.type is TokenTypeRot) {
FieldInfo fi = null;
if (fieldName == "x") fi = rotationXFieldInfo;
if (fieldName == "y") fi = rotationYFieldInfo;
if (fieldName == "z") fi = rotationZFieldInfo;
if (fieldName == "s") fi = rotationSFieldInfo;
if (fi != null) {
return new CompValuField (new TokenTypeFloat (lVal), baseRVal, fi);
}
}
if (baseRVal.type is TokenTypeVec) {
FieldInfo fi = null;
if (fieldName == "x") fi = vectorXFieldInfo;
if (fieldName == "y") fi = vectorYFieldInfo;
if (fieldName == "z") fi = vectorZFieldInfo;
if (fi != null) {
return new CompValuField (new TokenTypeFloat (lVal), baseRVal, fi);
}
}
ErrorMsg (lVal, "type " + baseRVal.type.ToString () + " does not define member " + fieldName);
return baseRVal;
}
/**
* @brief We have an L-value token that is a function, method or variable name.
* @param lVal = name we are looking for
* @param argsig = null: just look for name as a variable
* else: look for name as a function/method being called with the given argument types
* eg, "(string,integer,list)"
* @returns a CompValu giving the type and location of the function, method or variable.
*/
private CompValu GenerateFromLValName (TokenLValName lVal, TokenType[] argsig)
{
/*
* Look in variable stack then look for built-in constants and functions.
*/
TokenDeclVar var = FindNamedVar (lVal, argsig);
if (var == null) {
ErrorMsg (lVal, "undefined constant/function/variable " + lVal.name.val + ArgSigString (argsig));
return new CompValuVoid (lVal);
}
/*
* Maybe it has an implied 'this.' on the front.
*/
if ((var.sdtClass != null) && ((var.sdtFlags & ScriptReduce.SDT_STATIC) == 0)) {
if (!IsSDTInstMethod ()) {
ErrorMsg (lVal, "cannot access instance member of class from static method");
return new CompValuVoid (lVal);
}
/*
* Don't allow something such as:
*
* class A {
* integer I;
* class B {
* Print ()
* {
* llOwnerSay ("I=" + (string)I); <- access to I not allowed inside class B.
* explicit reference required as we don't
* have a valid reference to class A.
* }
* }
* }
*
* But do allow something such as:
*
* class A {
* integer I;
* }
* class B : A {
* Print ()
* {
* llOwnerSay ("I=" + (string)I);
* }
* }
*/
for (TokenDeclSDType c = curDeclFunc.sdtClass; c != var.sdtClass; c = c.extends) {
if (c == null) {
// our arg0 points to an instance of curDeclFunc.sdtClass, not var.sdtClass
ErrorMsg (lVal, "cannot access instance member of outer class with implied 'this'");
break;
}
}
CompValu thisCompValu = new CompValuArg (var.sdtClass.MakeRefToken (lVal), 0);
return AccessInstanceMember (var, thisCompValu, lVal, false);
}
/*
* It's a local variable, static field, global, constant, etc.
*/
return var.location;
}
/**
* @brief Access a script-defined type's instance member
* @param declVar = which member (field,method,property) to access
* @param basePtr = points to particular object instance
* @param ignoreVirt = true: access declVar's method directly; else: maybe use vTable
* @returns where the field/method/property is located
*/
private CompValu AccessInstanceMember (TokenDeclVar declVar, CompValu basePtr, Token errorAt, bool ignoreVirt)
{
if ((declVar.sdtFlags & ScriptReduce.SDT_STATIC) != 0) {
ErrorMsg (errorAt, "non-static reference to static member " + declVar.name.val);
return new CompValuVoid (declVar);
}
return new CompValuInstMember (declVar, basePtr, ignoreVirt);
}
/**
* @brief we have an L-value token that is a static member within a struct.
* @returns a CompValu giving the type and location of the member in the struct.
*/
private CompValu GenerateFromLValSField (TokenLValSField lVal, TokenType[] argsig)
{
TokenType stType = lVal.baseType;
string fieldName = lVal.fieldName.val + ArgSigString (argsig);
/*
* Maybe they are accessing a static member of a script-defined class.
*/
if (stType is TokenTypeSDTypeClass) {
TokenTypeSDTypeClass sdtType = (TokenTypeSDTypeClass)stType;
TokenDeclVar declVar = FindThisMember (sdtType.decl, lVal.fieldName, argsig);
if (declVar != null) {
CheckAccess (declVar, lVal.fieldName);
if ((declVar.sdtFlags & ScriptReduce.SDT_STATIC) == 0) {
ErrorMsg (lVal.fieldName, "static reference to non-static member " + fieldName);
return new CompValuVoid (lVal.fieldName);
}
return declVar.location;
}
}
ErrorMsg (lVal.fieldName, "no member " + fieldName + " in " + stType.ToString ());
return new CompValuVoid (lVal.fieldName);
}
/**
* @brief generate code from an RVal expression and return its type and where the result is stored.
* For anything that has side-effects, statements are generated that perform the computation then
* the result it put in a temp var and the temp var name is returned.
* For anything without side-effects, they are returned as an equivalent sequence of Emits.
* @param rVal = rVal token to be evaluated
* @param argsig = null: not being used in an function/method context
* else: string giving argument types, eg, "(string,integer,list,vector)"
* that can be used to select among overloaded methods
* @returns resultant type and location
*/
private CompValu GenerateFromRVal (TokenRVal rVal)
{
return GenerateFromRVal (rVal, null);
}
private CompValu GenerateFromRVal (TokenRVal rVal, TokenType[] argsig)
{
errorMessageToken = rVal;
/*
* Maybe the expression can be converted to a constant.
*/
bool didOne;
do {
didOne = false;
rVal = rVal.TryComputeConstant (LookupBodyConstants, ref didOne);
} while (didOne);
/*
* Generate code for the computation and return resulting type and location.
*/
CompValu cVal = null;
if (rVal is TokenRValAsnPost) cVal = GenerateFromRValAsnPost ((TokenRValAsnPost)rVal);
if (rVal is TokenRValAsnPre) cVal = GenerateFromRValAsnPre ((TokenRValAsnPre)rVal);
if (rVal is TokenRValCall) cVal = GenerateFromRValCall ((TokenRValCall)rVal);
if (rVal is TokenRValCast) cVal = GenerateFromRValCast ((TokenRValCast)rVal);
if (rVal is TokenRValCondExpr) cVal = GenerateFromRValCondExpr ((TokenRValCondExpr)rVal);
if (rVal is TokenRValConst) cVal = GenerateFromRValConst ((TokenRValConst)rVal);
if (rVal is TokenRValInitDef) cVal = GenerateFromRValInitDef ((TokenRValInitDef)rVal);
if (rVal is TokenRValIsType) cVal = GenerateFromRValIsType ((TokenRValIsType)rVal);
if (rVal is TokenRValList) cVal = GenerateFromRValList ((TokenRValList)rVal);
if (rVal is TokenRValNewArIni) cVal = GenerateFromRValNewArIni ((TokenRValNewArIni)rVal);
if (rVal is TokenRValOpBin) cVal = GenerateFromRValOpBin ((TokenRValOpBin)rVal);
if (rVal is TokenRValOpUn) cVal = GenerateFromRValOpUn ((TokenRValOpUn)rVal);
if (rVal is TokenRValParen) cVal = GenerateFromRValParen ((TokenRValParen)rVal);
if (rVal is TokenRValRot) cVal = GenerateFromRValRot ((TokenRValRot)rVal);
if (rVal is TokenRValThis) cVal = GenerateFromRValThis ((TokenRValThis)rVal);
if (rVal is TokenRValUndef) cVal = GenerateFromRValUndef ((TokenRValUndef)rVal);
if (rVal is TokenRValVec) cVal = GenerateFromRValVec ((TokenRValVec)rVal);
if (rVal is TokenLVal) cVal = GenerateFromLVal ((TokenLVal)rVal, argsig);
if (cVal == null) throw new Exception ("bad rval class " + rVal.GetType ().ToString ());
/*
* Sanity check.
*/
if (!youveAnError) {
if (cVal.type == null) throw new Exception ("cVal has no type " + cVal.GetType ());
string cValType = cVal.type.ToString ();
string rValType = rVal.GetRValType (this, argsig).ToString ();
if (cValType == "bool") cValType = "integer";
if (rValType == "bool") rValType = "integer";
if (cValType != rValType) {
throw new Exception ("cVal.type " + cValType + " != rVal.type " + rValType +
" (" + rVal.GetType ().Name + " " + rVal.SrcLoc + ")");
}
}
return cVal;
}
/**
* @brief compute the result of a binary operator (eg, add, subtract, multiply, lessthan)
* @param token = binary operator token, includes the left and right operands
* @returns where the resultant R-value is as something that doesn't have side effects
*/
private CompValu GenerateFromRValOpBin (TokenRValOpBin token)
{
CompValu left, right;
string opcodeIndex = token.opcode.ToString ();
/*
* Comma operators are special, as they say to compute the left-hand value and
* discard it, then compute the right-hand argument and that is the result.
*/
if (opcodeIndex == ",") {
/*
* Compute left-hand operand but throw away result.
*/
GenerateFromRVal (token.rValLeft);
/*
* Compute right-hand operand and that is the value of the expression.
*/
return GenerateFromRVal (token.rValRight);
}
/*
* Simple overwriting assignments are their own special case,
* as we want to cast the R-value to the type of the L-value.
* And in the case of delegates, we want to use the arg signature
* of the delegate to select which overloaded method to use.
*/
if (opcodeIndex == "=") {
if (!(token.rValLeft is TokenLVal)) {
ErrorMsg (token, "invalid L-value for =");
return GenerateFromRVal (token.rValLeft);
}
left = GenerateFromLVal ((TokenLVal)token.rValLeft);
right = Trivialize (GenerateFromRVal (token.rValRight, left.GetArgTypes ()), token.rValRight);
left.PopPre (this, token.rValLeft);
right.PushVal (this, token.rValRight, left.type); // push (left.type)right
left.PopPost (this, token.rValLeft); // pop to left
return left;
}
/*
* There are String.Concat() methods available for 2, 3 and 4 operands.
* So see if we have a string concat op and optimize if so.
*/
if ((opcodeIndex == "+") ||
((opcodeIndex == "+=") &&
(token.rValLeft is TokenLVal) &&
(token.rValLeft.GetRValType (this, null) is TokenTypeStr))) {
/*
* We are adding something. Maybe it's a bunch of strings together.
*/
List<TokenRVal> scorvs = new List<TokenRVal> ();
if (StringConcatOperands (token.rValLeft, token.rValRight, scorvs, token.opcode)) {
/*
* Evaluate all the operands, right-to-left on purpose per LSL scripting.
*/
int i;
int n = scorvs.Count;
CompValu[] scocvs = new CompValu[n];
for (i = n; -- i >= 0;) {
scocvs[i] = GenerateFromRVal (scorvs[i]);
if (i > 0) scocvs[i] = Trivialize (scocvs[i], scorvs[i]);
}
/*
* Figure out where to put the result.
* A temp if '+', or back in original L-value if '+='.
*/
CompValu retcv;
if (opcodeIndex == "+") {
retcv = new CompValuTemp (new TokenTypeStr (token.opcode), this);
} else {
retcv = GenerateFromLVal ((TokenLVal)token.rValLeft);
}
retcv.PopPre (this, token);
/*
* Call the String.Concat() methods, passing operands in left-to-right order.
* Force a cast to string (retcv.type) for each operand.
*/
++ i; scocvs[i].PushVal (this, scorvs[i], retcv.type);
while (i + 3 < n) {
++ i; scocvs[i].PushVal (this, scorvs[i], retcv.type);
++ i; scocvs[i].PushVal (this, scorvs[i], retcv.type);
++ i; scocvs[i].PushVal (this, scorvs[i], retcv.type);
ilGen.Emit (scorvs[i], OpCodes.Call, stringConcat4MethodInfo);
}
if (i + 2 < n) {
++ i; scocvs[i].PushVal (this, scorvs[i], retcv.type);
++ i; scocvs[i].PushVal (this, scorvs[i], retcv.type);
ilGen.Emit (scorvs[i], OpCodes.Call, stringConcat3MethodInfo);
}
if (i + 1 < n) {
++ i; scocvs[i].PushVal (this, scorvs[i], retcv.type);
ilGen.Emit (scorvs[i], OpCodes.Call, stringConcat2MethodInfo);
}
/*
* Put the result where we want it and return where we put it.
*/
retcv.PopPost (this, token);
return retcv;
}
}
/*
* If "&&&", it is a short-circuiting AND.
* Compute left-hand operand and if true, compute right-hand operand.
*/
if (opcodeIndex == "&&&") {
bool leftVal, rightVal;
left = GenerateFromRVal (token.rValLeft);
if (!IsConstBoolExpr (left, out leftVal)) {
ScriptMyLabel falseLabel = ilGen.DefineLabel ("ssandfalse");
left.PushVal (this, tokenTypeBool);
ilGen.Emit (token, OpCodes.Brfalse, falseLabel);
right = GenerateFromRVal (token.rValRight);
if (!IsConstBoolExpr (right, out rightVal)) {
right.PushVal (this, tokenTypeBool);
goto donessand;
}
if (!rightVal) {
ilGen.MarkLabel (falseLabel);
return new CompValuInteger (new TokenTypeInt (token.rValLeft), 0);
}
ilGen.Emit (token, OpCodes.Ldc_I4_1);
donessand:
ScriptMyLabel doneLabel = ilGen.DefineLabel ("ssanddone");
ilGen.Emit (token, OpCodes.Br, doneLabel);
ilGen.MarkLabel (falseLabel);
ilGen.Emit (token, OpCodes.Ldc_I4_0);
ilGen.MarkLabel (doneLabel);
CompValuTemp retRVal = new CompValuTemp (new TokenTypeInt (token), this);
retRVal.Pop (this, token);
return retRVal;
}
if (!leftVal) {
return new CompValuInteger (new TokenTypeInt (token.rValLeft), 0);
}
right = GenerateFromRVal (token.rValRight);
if (!IsConstBoolExpr (right, out rightVal)) {
right.PushVal (this, tokenTypeBool);
CompValuTemp retRVal = new CompValuTemp (new TokenTypeInt (token), this);
retRVal.Pop (this, token);
return retRVal;
}
return new CompValuInteger (new TokenTypeInt (token), rightVal ? 1 : 0);
}
/*
* If "|||", it is a short-circuiting OR.
* Compute left-hand operand and if false, compute right-hand operand.
*/
if (opcodeIndex == "|||") {
bool leftVal, rightVal;
left = GenerateFromRVal (token.rValLeft);
if (!IsConstBoolExpr (left, out leftVal)) {
ScriptMyLabel trueLabel = ilGen.DefineLabel ("ssortrue");
left.PushVal (this, tokenTypeBool);
ilGen.Emit (token, OpCodes.Brtrue, trueLabel);
right = GenerateFromRVal (token.rValRight);
if (!IsConstBoolExpr (right, out rightVal)) {
right.PushVal (this, tokenTypeBool);
goto donessor;
}
if (rightVal) {
ilGen.MarkLabel (trueLabel);
return new CompValuInteger (new TokenTypeInt (token.rValLeft), 1);
}
ilGen.Emit (token, OpCodes.Ldc_I4_0);
donessor:
ScriptMyLabel doneLabel = ilGen.DefineLabel ("ssanddone");
ilGen.Emit (token, OpCodes.Br, doneLabel);
ilGen.MarkLabel (trueLabel);
ilGen.Emit (token, OpCodes.Ldc_I4_1);
ilGen.MarkLabel (doneLabel);
CompValuTemp retRVal = new CompValuTemp (new TokenTypeInt (token), this);
retRVal.Pop (this, token);
return retRVal;
}
if (leftVal) {
return new CompValuInteger (new TokenTypeInt (token.rValLeft), 1);
}
right = GenerateFromRVal (token.rValRight);
if (!IsConstBoolExpr (right, out rightVal)) {
right.PushVal (this, tokenTypeBool);
CompValuTemp retRVal = new CompValuTemp (new TokenTypeInt (token), this);
retRVal.Pop (this, token);
return retRVal;
}
return new CompValuInteger (new TokenTypeInt (token), rightVal ? 1 : 0);
}
/*
* Computation of some sort, compute right-hand operand value then left-hand value
* because LSL is supposed to be right-to-left evaluation.
*/
right = Trivialize (GenerateFromRVal (token.rValRight), token.rValRight);
/*
* If left is a script-defined class and there is a method with the operator's name,
* convert this to a call to that method with the right value as its single parameter.
* Except don't if the right value is 'undef' so they can always compare to undef.
*/
TokenType leftType = token.rValLeft.GetRValType (this, null);
if ((leftType is TokenTypeSDTypeClass) && !(right.type is TokenTypeUndef)) {
TokenTypeSDTypeClass sdtType = (TokenTypeSDTypeClass)leftType;
TokenDeclSDTypeClass sdtDecl = sdtType.decl;
TokenType[] argsig = new TokenType[] { right.type };
TokenName funcName = new TokenName (token.opcode, "$op" + opcodeIndex);
TokenDeclVar declFunc = FindThisMember (sdtDecl, funcName, argsig);
if (declFunc != null) {
CheckAccess (declFunc, funcName);
left = GenerateFromRVal (token.rValLeft);
CompValu method = AccessInstanceMember (declFunc, left, token, false);
CompValu[] argRVals = new CompValu[] { right };
return GenerateACall (method, argRVals, token);
}
}
/*
* Formulate key string for binOpStrings = (lefttype)(operator)(righttype)
*/
string leftIndex = leftType.ToString ();
string rightIndex = right.type.ToString ();
string key = leftIndex + opcodeIndex + rightIndex;
/*
* If that key exists in table, then the operation is defined between those types
* ... and it produces an R-value of type as given in the table.
*/
BinOpStr binOpStr;
if (BinOpStr.defined.TryGetValue (key, out binOpStr)) {
/*
* If table contained an explicit assignment type like +=, output the statement without
* casting the L-value, then return the L-value as the resultant value.
*
* Make sure we don't include comparisons (such as ==, >=, etc).
* Nothing like +=, -=, %=, etc, generate a boolean, only the comparisons.
*/
if ((binOpStr.outtype != typeof (bool)) && opcodeIndex.EndsWith ("=") && (opcodeIndex != "!=")) {
if (!(token.rValLeft is TokenLVal)) {
ErrorMsg (token.rValLeft, "invalid L-value");
return GenerateFromRVal (token.rValLeft);
}
left = GenerateFromLVal ((TokenLVal)token.rValLeft);
binOpStr.emitBO (this, token, left, right, left);
return left;
}
/*
* It's of the form left binop right.
* Compute left, perform operation then put result in a temp.
*/
left = GenerateFromRVal (token.rValLeft);
CompValu retRVal = new CompValuTemp (TokenType.FromSysType (token.opcode, binOpStr.outtype), this);
binOpStr.emitBO (this, token, left, right, retRVal);
return retRVal;
}
/*
* Nothing in the table, check for comparing object pointers because of the myriad of types possible.
* This will compare list pointers, null pointers, script-defined type pointers, array pointers, etc.
* It will show equal iff the memory addresses are equal and that is good enough.
*/
if (!leftType.ToSysType().IsValueType && !right.type.ToSysType().IsValueType && ((opcodeIndex == "==") || (opcodeIndex == "!="))) {
CompValuTemp retRVal = new CompValuTemp (new TokenTypeInt (token), this);
left = GenerateFromRVal (token.rValLeft);
left.PushVal (this, token.rValLeft);
right.PushVal (this, token.rValRight);
ilGen.Emit (token, OpCodes.Ceq);
if (opcodeIndex == "!=") {
ilGen.Emit (token, OpCodes.Ldc_I4_1);
ilGen.Emit (token, OpCodes.Xor);
}
retRVal.Pop (this, token);
return retRVal;
}
/*
* If the opcode ends with "=", it may be something like "+=".
* So look up the key as if we didn't have the "=" to tell us if the operation is legal.
* Also, the binary operation's output type must be the same as the L-value type.
* Likewise, integer += float not allowed because result is float, but float += integer is ok.
*/
if (opcodeIndex.EndsWith ("=")) {
key = leftIndex + opcodeIndex.Substring (0, opcodeIndex.Length - 1) + rightIndex;
if (BinOpStr.defined.TryGetValue (key, out binOpStr)) {
if (!(token.rValLeft is TokenLVal)) {
ErrorMsg (token, "invalid L-value for <op>=");
return GenerateFromRVal (token.rValLeft);
}
if (!binOpStr.rmwOK) {
ErrorMsg (token, "<op>= not allowed: " + leftIndex + " " + opcodeIndex + " " + rightIndex);
return new CompValuVoid (token);
}
/*
* Now we know for something like %= that left%right is legal for the types given.
*/
left = GenerateFromLVal ((TokenLVal)token.rValLeft);
if (binOpStr.outtype == leftType.ToSysType ()) {
binOpStr.emitBO (this, token, left, right, left);
} else {
CompValu temp = new CompValuTemp (TokenType.FromSysType (token, binOpStr.outtype), this);
binOpStr.emitBO (this, token, left, right, temp);
left.PopPre (this, token);
temp.PushVal (this, token, leftType);
left.PopPost (this, token);
}
return left;
}
}
/*
* Can't find it, oh well.
*/
ErrorMsg (token, "op not defined: " + leftIndex + " " + opcodeIndex + " " + rightIndex);
return new CompValuVoid (token);
}
/**
* @brief Queue the given operands to the end of the scos list.
* If it can be broken down into more string concat operands, do so.
* Otherwise, just push it as one operand.
* @param leftRVal = left-hand operand of a '+' operation
* @param rightRVal = right-hand operand of a '+' operation
* @param scos = left-to-right list of operands for the string concat so far
* @param addop = the add operator token (either '+' or '+=')
* @returns false: neither operand is a string, nothing added to scos
* true: scos = updated with leftRVal then rightRVal added onto the end, possibly broken down further
*/
private bool StringConcatOperands (TokenRVal leftRVal, TokenRVal rightRVal, List<TokenRVal> scos, TokenKw addop)
{
/*
* If neither operand is a string (eg, float+integer), then the result isn't going to be a string.
*/
TokenType leftType = leftRVal.GetRValType (this, null);
TokenType rightType = rightRVal.GetRValType (this, null);
if (!(leftType is TokenTypeStr) && !(rightType is TokenTypeStr)) return false;
/*
* Also, list+string => list so reject that too.
* Also, string+list => list so reject that too.
*/
if (leftType is TokenTypeList) return false;
if (rightType is TokenTypeList) return false;
/*
* Append values to the end of the list in left-to-right order.
* If value is formed from a something+something => string,
* push them as separate values, otherwise push as one value.
*/
StringConcatOperand (leftType, leftRVal, scos);
StringConcatOperand (rightType, rightRVal, scos);
/*
* Maybe constant strings can be concatted.
*/
try {
int len;
while (((len = scos.Count) >= 2) &&
((leftRVal = scos[len-2]) is TokenRValConst) &&
((rightRVal = scos[len-1]) is TokenRValConst)) {
object sum = addop.binOpConst (((TokenRValConst)leftRVal).val,
((TokenRValConst)rightRVal).val);
scos[len-2] = new TokenRValConst (addop, sum);
scos.RemoveAt (len - 1);
}
} catch {
}
/*
* We pushed some string stuff.
*/
return true;
}
/**
* @brief Queue the given operand to the end of the scos list.
* If it can be broken down into more string concat operands, do so.
* Otherwise, just push it as one operand.
* @param type = rVal's resultant type
* @param rVal = operand to examine
* @param scos = left-to-right list of operands for the string concat so far
* @returns with scos = updated with rVal added onto the end, possibly broken down further
*/
private void StringConcatOperand (TokenType type, TokenRVal rVal, List<TokenRVal> scos)
{
bool didOne;
do {
didOne = false;
rVal = rVal.TryComputeConstant (LookupBodyConstants, ref didOne);
} while (didOne);
if (!(type is TokenTypeStr)) goto pushasis;
if (!(rVal is TokenRValOpBin)) goto pushasis;
TokenRValOpBin rValOpBin = (TokenRValOpBin)rVal;
if (!(rValOpBin.opcode is TokenKwAdd)) goto pushasis;
if (StringConcatOperands (rValOpBin.rValLeft, rValOpBin.rValRight, scos, rValOpBin.opcode)) return;
pushasis:
scos.Add (rVal);
}
/**
* @brief compute the result of an unary operator
* @param token = unary operator token, includes the operand
* @returns where the resultant R-value is
*/
private CompValu GenerateFromRValOpUn (TokenRValOpUn token)
{
CompValu inRVal = GenerateFromRVal (token.rVal);
/*
* Script-defined types can define their own methods to handle unary operators.
*/
if (inRVal.type is TokenTypeSDTypeClass) {
TokenTypeSDTypeClass sdtType = (TokenTypeSDTypeClass)inRVal.type;
TokenDeclSDTypeClass sdtDecl = sdtType.decl;
TokenName funcName = new TokenName (token.opcode, "$op" + token.opcode.ToString ());
TokenDeclVar declFunc = FindThisMember (sdtDecl, funcName, zeroArgs);
if (declFunc != null) {
CheckAccess (declFunc, funcName);
CompValu method = AccessInstanceMember (declFunc, inRVal, token, false);
return GenerateACall (method, zeroCompValus, token);
}
}
/*
* Otherwise use the default.
*/
return UnOpGenerate (inRVal, token.opcode);
}
/**
* @brief postfix operator -- this returns the type and location of the resultant value
*/
private CompValu GenerateFromRValAsnPost (TokenRValAsnPost asnPost)
{
CompValu lVal = GenerateFromLVal (asnPost.lVal);
/*
* Make up a temp to save original value in.
*/
CompValuTemp result = new CompValuTemp (lVal.type, this);
/*
* Prepare to pop incremented value back into variable being incremented.
*/
lVal.PopPre (this, asnPost.lVal);
/*
* Copy original value to temp and leave value on stack.
*/
lVal.PushVal (this, asnPost.lVal);
ilGen.Emit (asnPost.lVal, OpCodes.Dup);
result.Pop (this, asnPost.lVal);
/*
* Perform the ++/--.
*/
if ((lVal.type is TokenTypeChar) || (lVal.type is TokenTypeInt)) {
ilGen.Emit (asnPost, OpCodes.Ldc_I4_1);
} else if (lVal.type is TokenTypeFloat) {
ilGen.Emit (asnPost, OpCodes.Ldc_R4, 1.0f);
} else {
lVal.PopPost (this, asnPost.lVal);
ErrorMsg (asnPost, "invalid type for " + asnPost.postfix.ToString ());
return lVal;
}
switch (asnPost.postfix.ToString ()) {
case "++": {
ilGen.Emit (asnPost, OpCodes.Add);
break;
}
case "--": {
ilGen.Emit (asnPost, OpCodes.Sub);
break;
}
default: throw new Exception ("unknown asnPost op");
}
/*
* Store new value in original variable.
*/
lVal.PopPost (this, asnPost.lVal);
return result;
}
/**
* @brief prefix operator -- this returns the type and location of the resultant value
*/
private CompValu GenerateFromRValAsnPre (TokenRValAsnPre asnPre)
{
CompValu lVal = GenerateFromLVal (asnPre.lVal);
/*
* Make up a temp to put result in.
*/
CompValuTemp result = new CompValuTemp (lVal.type, this);
/*
* Prepare to pop incremented value back into variable being incremented.
*/
lVal.PopPre (this, asnPre.lVal);
/*
* Push original value.
*/
lVal.PushVal (this, asnPre.lVal);
/*
* Perform the ++/--.
*/
if ((lVal.type is TokenTypeChar) || (lVal.type is TokenTypeInt)) {
ilGen.Emit (asnPre, OpCodes.Ldc_I4_1);
} else if (lVal.type is TokenTypeFloat) {
ilGen.Emit (asnPre, OpCodes.Ldc_R4, 1.0f);
} else {
lVal.PopPost (this, asnPre.lVal);
ErrorMsg (asnPre, "invalid type for " + asnPre.prefix.ToString ());
return lVal;
}
switch (asnPre.prefix.ToString ()) {
case "++": {
ilGen.Emit (asnPre, OpCodes.Add);
break;
}
case "--": {
ilGen.Emit (asnPre, OpCodes.Sub);
break;
}
default: throw new Exception ("unknown asnPre op");
}
/*
* Store new value in temp variable, keeping new value on stack.
*/
ilGen.Emit (asnPre.lVal, OpCodes.Dup);
result.Pop (this, asnPre.lVal);
/*
* Store new value in original variable.
*/
lVal.PopPost (this, asnPre.lVal);
return result;
}
/**
* @brief Generate code that calls a function or object's method.
* @returns where the call's return value is stored (a TokenTypeVoid if void)
*/
private CompValu GenerateFromRValCall (TokenRValCall call)
{
CompValu method;
CompValu[] argRVals;
int i, nargs;
TokenRVal arg;
TokenType[] argTypes;
/*
* Compute the values of all the function's call arguments.
* Save where the computation results are in the argRVals[] array.
* Might as well build the argument signature from the argument types, too.
*/
nargs = call.nArgs;
argRVals = new CompValu[nargs];
argTypes = new TokenType[nargs];
if (nargs > 0) {
i = 0;
for (arg = call.args; arg != null; arg = (TokenRVal)arg.nextToken) {
argRVals[i] = GenerateFromRVal (arg);
argTypes[i] = argRVals[i].type;
i ++;
}
}
/*
* Get function/method's entrypoint that matches the call argument types.
*/
method = GenerateFromRVal (call.meth, argTypes);
if (method == null) return null;
return GenerateACall (method, argRVals, call);
}
/**
* @brief Generate call to a function/method.
* @param method = function/method being called
* @param argVRVals = its call parameters (zero length if none)
* @param call = where in source code call is being made from (for error messages)
* @returns type and location of return value (CompValuVoid if none)
*/
private CompValu GenerateACall (CompValu method, CompValu[] argRVals, Token call)
{
CompValuTemp result;
int i, nArgs;
TokenType retType;
TokenType[] argTypes;
/*
* Must be some kind of callable.
*/
retType = method.GetRetType (); // TokenTypeVoid if void; null means a variable
if (retType == null) {
ErrorMsg (call, "must be a delegate, function or method");
return new CompValuVoid (call);
}
/*
* Get a location for return value.
*/
if (retType is TokenTypeVoid) {
result = new CompValuVoid (call);
} else {
result = new CompValuTemp (retType, this);
}
/*
* Make sure all arguments are trivial, ie, don't involve their own call labels.
* For any that aren't, output code to calculate the arg and put in a temporary.
*/
nArgs = argRVals.Length;
for (i = 0; i < nArgs; i ++) {
if (!argRVals[i].IsReadTrivial (this, call)) {
argRVals[i] = Trivialize (argRVals[i], call);
}
}
/*
* Inline functions know how to generate their own call.
*/
if (method is CompValuInline) {
CompValuInline inline = (CompValuInline)method;
inline.declInline.CodeGen (this, call, result, argRVals);
return result;
}
/*
* Push whatever the function/method needs as a this argument, if anything.
*/
method.CallPre (this, call);
/*
* Push the script-visible args, left-to-right.
*/
argTypes = method.GetArgTypes ();
for (i = 0; i < nArgs; i ++) {
if (argTypes == null) {
argRVals[i].PushVal (this, call);
} else {
argRVals[i].PushVal (this, call, argTypes[i]);
}
}
/*
* Now output call instruction.
*/
method.CallPost (this, call);
/*
* Deal with the return value (if any), by putting it in 'result'.
*/
result.Pop (this, call, retType);
return result;
}
/**
* @brief This is needed to avoid nesting call labels around non-trivial properties.
* It should be used for the second (and later) operands.
* Note that a 'call' is considered an operator, so all arguments of a call
* should be trivialized, but the method itself does not need to be.
*/
public CompValu Trivialize (CompValu operand, Token errorAt)
{
if (operand.IsReadTrivial (this, errorAt)) return operand;
CompValuTemp temp = new CompValuTemp (operand.type, this);
operand.PushVal (this, errorAt);
temp.Pop (this, errorAt);
return temp;
}
/**
* @brief Generate code that casts a value to a particular type.
* @returns where the result of the conversion is stored.
*/
private CompValu GenerateFromRValCast (TokenRValCast cast)
{
/*
* If casting to a delegate type, use the argment signature
* of the delegate to help select the function/method, eg,
* '(delegate string(integer))ToString'
* will select 'string ToString(integer x)'
* instaead of 'string ToString(float x)' or anything else
*/
TokenType[] argsig = null;
TokenType outType = cast.castTo;
if (outType is TokenTypeSDTypeDelegate) {
argsig = ((TokenTypeSDTypeDelegate)outType).decl.GetArgTypes ();
}
/*
* Generate the value that is being cast.
* If the value is already the requested type, just use it as is.
*/
CompValu inRVal = GenerateFromRVal (cast.rVal, argsig);
if (inRVal.type == outType) return inRVal;
/*
* Different type, generate casting code, putting the result in a temp of the output type.
*/
CompValu outRVal = new CompValuTemp (outType, this);
outRVal.PopPre (this, cast);
inRVal.PushVal (this, cast, outType, true);
outRVal.PopPost (this, cast);
return outRVal;
}
/**
* @brief Compute conditional expression value.
* @returns type and location of computed value.
*/
private CompValu GenerateFromRValCondExpr (TokenRValCondExpr rValCondExpr)
{
bool condVal;
CompValu condValu = GenerateFromRVal (rValCondExpr.condExpr);
if (IsConstBoolExpr (condValu, out condVal)) {
return GenerateFromRVal (condVal ? rValCondExpr.trueExpr : rValCondExpr.falseExpr);
}
ScriptMyLabel falseLabel = ilGen.DefineLabel ("condexfalse");
ScriptMyLabel doneLabel = ilGen.DefineLabel ("condexdone");
condValu.PushVal (this, rValCondExpr.condExpr, tokenTypeBool);
ilGen.Emit (rValCondExpr, OpCodes.Brfalse, falseLabel);
CompValu trueValu = GenerateFromRVal (rValCondExpr.trueExpr);
trueValu.PushVal (this, rValCondExpr.trueExpr);
ilGen.Emit (rValCondExpr, OpCodes.Br, doneLabel);
ilGen.MarkLabel (falseLabel);
CompValu falseValu = GenerateFromRVal (rValCondExpr.falseExpr);
falseValu.PushVal (this, rValCondExpr.falseExpr);
if (trueValu.type.GetType () != falseValu.type.GetType ()) {
ErrorMsg (rValCondExpr, "? operands " + trueValu.type.ToString () + " : " +
falseValu.type.ToString () + " must be of same type");
}
ilGen.MarkLabel (doneLabel);
CompValuTemp retRVal = new CompValuTemp (trueValu.type, this);
retRVal.Pop (this, rValCondExpr);
return retRVal;
}
/**
* @brief Constant in the script somewhere
* @returns where the constants value is stored
*/
private CompValu GenerateFromRValConst (TokenRValConst rValConst)
{
switch (rValConst.type) {
case TokenRValConstType.CHAR: {
return new CompValuChar (new TokenTypeChar (rValConst), (char)(rValConst.val));
}
case TokenRValConstType.FLOAT: {
return new CompValuFloat (new TokenTypeFloat (rValConst), (double)(rValConst.val));
}
case TokenRValConstType.INT: {
return new CompValuInteger (new TokenTypeInt (rValConst), (int)(rValConst.val));
}
case TokenRValConstType.KEY: {
return new CompValuString (new TokenTypeKey (rValConst), (string)(rValConst.val));
}
case TokenRValConstType.STRING: {
return new CompValuString (new TokenTypeStr (rValConst), (string)(rValConst.val));
}
}
throw new Exception ("unknown constant type " + rValConst.val.GetType ());
}
/**
* @brief generate a new list object
* @param rValList = an rVal to create it from
*/
private CompValu GenerateFromRValList (TokenRValList rValList)
{
/*
* Compute all element values and remember where we put them.
* Do it right-to-left as customary for LSL scripts.
*/
int i = 0;
TokenRVal lastRVal = null;
for (TokenRVal val = rValList.rVal; val != null; val = (TokenRVal)val.nextToken) {
i ++;
val.prevToken = lastRVal;
lastRVal = val;
}
CompValu[] vals = new CompValu[i];
for (TokenRVal val = lastRVal; val != null; val = (TokenRVal)val.prevToken) {
vals[--i] = GenerateFromRVal (val);
}
/*
* This is the temp that will hold the created list.
*/
CompValuTemp newList = new CompValuTemp (new TokenTypeList (rValList.rVal), this);
/*
* Create a temp object[] array to hold all the initial values.
*/
ilGen.Emit (rValList, OpCodes.Ldc_I4, rValList.nItems);
ilGen.Emit (rValList, OpCodes.Newarr, typeof (object));
/*
* Populate the array.
*/
i = 0;
for (TokenRVal val = rValList.rVal; val != null; val = (TokenRVal)val.nextToken) {
/*
* Get pointer to temp array object.
*/
ilGen.Emit (rValList, OpCodes.Dup);
/*
* Get index in that array.
*/
ilGen.Emit (rValList, OpCodes.Ldc_I4, i);
/*
* Store initialization value in array location.
* However, floats and ints need to be converted to LSL_Float and LSL_Integer,
* or things like llSetPayPrice() will puque when they try to cast the elements
* to LSL_Float or LSL_Integer. Likewise with string/LSL_String.
*
* Maybe it's already LSL-boxed so we don't do anything with it except make sure
* it is an object, not a struct.
*/
CompValu eRVal = vals[i++];
eRVal.PushVal (this, val);
if (eRVal.type.ToLSLWrapType () == null) {
if (eRVal.type is TokenTypeFloat) {
ilGen.Emit (val, OpCodes.Newobj, lslFloatConstructorInfo);
ilGen.Emit (val, OpCodes.Box, typeof (LSL_Float));
} else if (eRVal.type is TokenTypeInt) {
ilGen.Emit (val, OpCodes.Newobj, lslIntegerConstructorInfo);
ilGen.Emit (val, OpCodes.Box, typeof (LSL_Integer));
} else if ((eRVal.type is TokenTypeKey) || (eRVal.type is TokenTypeStr)) {
ilGen.Emit (val, OpCodes.Newobj, lslStringConstructorInfo);
ilGen.Emit (val, OpCodes.Box, typeof (LSL_String));
} else if (eRVal.type.ToSysType ().IsValueType) {
ilGen.Emit (val, OpCodes.Box, eRVal.type.ToSysType ());
}
} else if (eRVal.type.ToLSLWrapType ().IsValueType) {
// Convert the LSL value structs to an object of the LSL-boxed type
ilGen.Emit (val, OpCodes.Box, eRVal.type.ToLSLWrapType ());
}
ilGen.Emit (val, OpCodes.Stelem, typeof (object));
}
/*
* Create new list object from temp initial value array (whose ref is still on the stack).
*/
ilGen.Emit (rValList, OpCodes.Newobj, lslListConstructorInfo);
newList.Pop (this, rValList);
return newList;
}
/**
* @brief New array allocation with initializer expressions.
*/
private CompValu GenerateFromRValNewArIni (TokenRValNewArIni rValNewArIni)
{
return MallocAndInitArray (rValNewArIni.arrayType, rValNewArIni.valueList);
}
/**
* @brief Mallocate and initialize an array from its initialization list.
* @param arrayType = type of the array to be allocated and initialized
* @param values = initialization value list used to size and initialize the array.
* @returns memory location of the resultant initialized array.
*/
private CompValu MallocAndInitArray (TokenType arrayType, TokenList values)
{
TokenDeclSDTypeClass arrayDecl = ((TokenTypeSDTypeClass)arrayType).decl;
TokenType eleType = arrayDecl.arrayOfType;
int rank = arrayDecl.arrayOfRank;
// Get size of each of the dimensions by scanning the initialization value list
int[] dimSizes = new int[rank];
FillInDimSizes (dimSizes, 0, rank, values);
// Figure out where the array's $new() method is
TokenType[] newargsig = new TokenType[rank];
for (int k = 0; k < rank; k ++) {
newargsig[k] = tokenTypeInt;
}
TokenDeclVar newMeth = FindThisMember (arrayDecl, new TokenName (null, "$new"), newargsig);
// Output a call to malloc the array with all default values
// array = ArrayType.$new (dimSizes[0], dimSizes[1], ...)
CompValuTemp array = new CompValuTemp (arrayType, this);
PushXMRInst ();
for (int k = 0; k < rank; k ++) {
ilGen.Emit (values, OpCodes.Ldc_I4, dimSizes[k]);
}
ilGen.Emit (values, OpCodes.Call, newMeth.ilGen);
array.Pop (this, arrayType);
// Figure out where the array's Set() method is
TokenType[] setargsig = new TokenType[rank+1];
for (int k = 0; k < rank; k ++) {
setargsig[k] = tokenTypeInt;
}
setargsig[rank] = eleType;
TokenDeclVar setMeth = FindThisMember (arrayDecl, new TokenName (null, "Set"), setargsig);
// Fill in the array with the initializer values
FillInInitVals (array, setMeth, dimSizes, 0, rank, values, eleType);
// The array is our resultant value
return array;
}
/**
* @brief Compute an array's dimensions given its initialization value list
* @param dimSizes = filled in with array's dimensions
* @param dimNo = what dimension the 'values' list applies to
* @param rank = total number of dimensions of the array
* @param values = list of values to initialize the array's 'dimNo' dimension with
* @returns with dimSizes[dimNo..rank-1] filled in
*/
private static void FillInDimSizes (int[] dimSizes, int dimNo, int rank, TokenList values)
{
// the size of a dimension is the largest number of initializer elements at this level
// for dimNo 0, this is the number of elements in the top-level list
if (dimSizes[dimNo] < values.tl.Count) dimSizes[dimNo] = values.tl.Count;
// see if there is another dimension to calculate
if (++ dimNo < rank) {
// its size is the size of the largest initializer list at the next inner level
foreach (Token val in values.tl) {
if (val is TokenList) {
TokenList subvals = (TokenList)val;
FillInDimSizes (dimSizes, dimNo, rank, subvals);
}
}
}
}
/**
* @brief Output code to fill in array's initialization values
* @param array = array to be filled in
* @param setMeth = the array's Set() method
* @param subscripts = holds subscripts being built
* @param dimNo = which dimension the 'values' are for
* @param values = list of initialization values for dimension 'dimNo'
* @param rank = number of dimensions of 'array'
* @param values = list of values to initialize the array's 'dimNo' dimension with
* @param eleType = the element's type
* @returns with code emitted to initialize array's [subscripts[0], ..., subscripts[dimNo-1], *, *, ...]
* dimNo and up completely filled ---^
*/
private void FillInInitVals (CompValu array, TokenDeclVar setMeth, int[] subscripts, int dimNo, int rank, TokenList values, TokenType eleType)
{
subscripts[dimNo] = 0;
foreach (Token val in values.tl) {
CompValu initValue = null;
/*
* If it is a sublist, process it.
* If we don't have enough subscripts yet, hopefully that sublist will have enough.
* If we already have enough subscripts, then that sublist can be for an element of this supposedly jagged array.
*/
if (val is TokenList) {
TokenList sublist = (TokenList)val;
if (dimNo + 1 < rank) {
/*
* We don't have enough subscripts yet, hopefully the sublist has the rest.
*/
FillInInitVals (array, setMeth, subscripts, dimNo + 1, rank, sublist, eleType);
} else if ((eleType is TokenTypeSDTypeClass) && (((TokenTypeSDTypeClass)eleType).decl.arrayOfType == null)) {
/*
* If we aren't a jagged array either, we can't do anything with the sublist.
*/
ErrorMsg (val, "too many brace levels");
} else {
/*
* We are a jagged array, so malloc a subarray and initialize it with the sublist.
* Then we can use that subarray to fill this array's element.
*/
initValue = MallocAndInitArray (eleType, sublist);
}
}
/*
* If it is a value expression, then output code to compute the value.
*/
if (val is TokenRVal) {
if (dimNo + 1 < rank) {
ErrorMsg ((Token)val, "not enough brace levels");
} else {
initValue = GenerateFromRVal ((TokenRVal)val);
}
}
/*
* If there is an initValue, output "array.Set (subscript[0], subscript[1], ..., initValue)"
*/
if (initValue != null) {
array.PushVal (this, val);
for (int i = 0; i <= dimNo; i ++) {
ilGen.Emit (val, OpCodes.Ldc_I4, subscripts[i]);
}
initValue.PushVal (this, val, eleType);
ilGen.Emit (val, OpCodes.Call, setMeth.ilGen);
}
/*
* That subscript is processed one way or another, on to the next.
*/
subscripts[dimNo] ++;
}
}
/**
* @brief parenthesized expression
* @returns type and location of the result of the computation.
*/
private CompValu GenerateFromRValParen (TokenRValParen rValParen)
{
return GenerateFromRVal (rValParen.rVal);
}
/**
* @brief create a rotation object from the x,y,z,w value expressions.
*/
private CompValu GenerateFromRValRot (TokenRValRot rValRot)
{
CompValu xRVal, yRVal, zRVal, wRVal;
xRVal = Trivialize (GenerateFromRVal (rValRot.xRVal), rValRot);
yRVal = Trivialize (GenerateFromRVal (rValRot.yRVal), rValRot);
zRVal = Trivialize (GenerateFromRVal (rValRot.zRVal), rValRot);
wRVal = Trivialize (GenerateFromRVal (rValRot.wRVal), rValRot);
return new CompValuRot (new TokenTypeRot (rValRot), xRVal, yRVal, zRVal, wRVal);
}
/**
* @brief Using 'this' as a pointer to the current script-defined instance object.
* The value is located in arg #0 of the current instance method.
*/
private CompValu GenerateFromRValThis (TokenRValThis zhis)
{
if (!IsSDTInstMethod ()) {
ErrorMsg (zhis, "cannot access instance member of class from static method");
return new CompValuVoid (zhis);
}
return new CompValuArg (curDeclFunc.sdtClass.MakeRefToken (zhis), 0);
}
/**
* @brief 'undefined' constant.
* If this constant gets written to an array element, it will delete that element from the array.
* If the script retrieves an element by key that is not defined, it will get this value.
* This value can be stored in and retrieved from variables of type 'object' or script-defined classes.
* It is a runtime error to cast this value to any other type, eg,
* we don't allow list or string variables to be null pointers.
*/
private CompValu GenerateFromRValUndef (TokenRValUndef rValUndef)
{
return new CompValuNull (new TokenTypeUndef (rValUndef));
}
/**
* @brief create a vector object from the x,y,z value expressions.
*/
private CompValu GenerateFromRValVec (TokenRValVec rValVec)
{
CompValu xRVal, yRVal, zRVal;
xRVal = Trivialize (GenerateFromRVal (rValVec.xRVal), rValVec);
yRVal = Trivialize (GenerateFromRVal (rValVec.yRVal), rValVec);
zRVal = Trivialize (GenerateFromRVal (rValVec.zRVal), rValVec);
return new CompValuVec (new TokenTypeVec (rValVec), xRVal, yRVal, zRVal);
}
/**
* @brief Generate code to get the default initialization value for a variable.
*/
private CompValu GenerateFromRValInitDef (TokenRValInitDef rValInitDef)
{
TokenType type = rValInitDef.type;
if (type is TokenTypeChar) {
return new CompValuChar (type, (char)0);
}
if (type is TokenTypeRot) {
CompValuFloat x = new CompValuFloat (type, ScriptBaseClass.ZERO_ROTATION.x);
CompValuFloat y = new CompValuFloat (type, ScriptBaseClass.ZERO_ROTATION.y);
CompValuFloat z = new CompValuFloat (type, ScriptBaseClass.ZERO_ROTATION.z);
CompValuFloat s = new CompValuFloat (type, ScriptBaseClass.ZERO_ROTATION.s);
return new CompValuRot (type, x, y, z, s);
}
if ((type is TokenTypeKey) || (type is TokenTypeStr)) {
return new CompValuString (type, "");
}
if (type is TokenTypeVec) {
CompValuFloat x = new CompValuFloat (type, ScriptBaseClass.ZERO_VECTOR.x);
CompValuFloat y = new CompValuFloat (type, ScriptBaseClass.ZERO_VECTOR.y);
CompValuFloat z = new CompValuFloat (type, ScriptBaseClass.ZERO_VECTOR.z);
return new CompValuVec (type, x, y, z);
}
if (type is TokenTypeInt) {
return new CompValuInteger (type, 0);
}
if (type is TokenTypeFloat) {
return new CompValuFloat (type, 0);
}
if (type is TokenTypeVoid) {
return new CompValuVoid (type);
}
/*
* Default for 'object' type is 'undef'.
* Likewise for script-defined classes and interfaces.
*/
if ((type is TokenTypeObject) || (type is TokenTypeSDTypeClass) || (type is TokenTypeSDTypeDelegate) ||
(type is TokenTypeSDTypeInterface) || (type is TokenTypeExc)) {
return new CompValuNull (type);
}
/*
* array and list
*/
CompValuTemp temp = new CompValuTemp (type, this);
PushDefaultValue (type);
temp.Pop (this, rValInitDef, type);
return temp;
}
/**
* @brief Generate code to process an <rVal> is <type> expression, and produce a boolean value.
*/
private CompValu GenerateFromRValIsType (TokenRValIsType rValIsType)
{
/*
* Expression we want to know the type of.
*/
CompValu val = GenerateFromRVal (rValIsType.rValExp);
/*
* Pass it in to top-level type expression decoder.
*/
return GenerateFromTypeExp (val, rValIsType.typeExp);
}
/**
* @brief See if the type of the given value matches the type expression.
* @param val = where the value to be evaluated is stored
* @param typeExp = script tokens representing type expression
* @returns location where the boolean result is stored
*/
private CompValu GenerateFromTypeExp (CompValu val, TokenTypeExp typeExp)
{
if (typeExp is TokenTypeExpBinOp) {
CompValu left = GenerateFromTypeExp (val, ((TokenTypeExpBinOp)typeExp).leftOp);
CompValu right = GenerateFromTypeExp (val, ((TokenTypeExpBinOp)typeExp).rightOp);
CompValuTemp result = new CompValuTemp (tokenTypeBool, this);
Token op = ((TokenTypeExpBinOp)typeExp).binOp;
left.PushVal (this, ((TokenTypeExpBinOp)typeExp).leftOp);
right.PushVal (this, ((TokenTypeExpBinOp)typeExp).rightOp);
if (op is TokenKwAnd) {
ilGen.Emit (typeExp, OpCodes.And);
} else if (op is TokenKwOr) {
ilGen.Emit (typeExp, OpCodes.Or);
} else {
throw new Exception ("unknown TokenTypeExpBinOp " + op.GetType ());
}
result.Pop (this, typeExp);
return result;
}
if (typeExp is TokenTypeExpNot) {
CompValu interm = GenerateFromTypeExp (val, ((TokenTypeExpNot)typeExp).typeExp);
CompValuTemp result = new CompValuTemp (tokenTypeBool, this);
interm.PushVal (this, ((TokenTypeExpNot)typeExp).typeExp, tokenTypeBool);
ilGen.Emit (typeExp, OpCodes.Ldc_I4_1);
ilGen.Emit (typeExp, OpCodes.Xor);
result.Pop (this, typeExp);
return result;
}
if (typeExp is TokenTypeExpPar) {
return GenerateFromTypeExp (val, ((TokenTypeExpPar)typeExp).typeExp);
}
if (typeExp is TokenTypeExpType) {
CompValuTemp result = new CompValuTemp (tokenTypeBool, this);
val.PushVal (this, typeExp);
ilGen.Emit (typeExp, OpCodes.Isinst, ((TokenTypeExpType)typeExp).typeToken.ToSysType ());
ilGen.Emit (typeExp, OpCodes.Ldnull);
ilGen.Emit (typeExp, OpCodes.Ceq);
ilGen.Emit (typeExp, OpCodes.Ldc_I4_1);
ilGen.Emit (typeExp, OpCodes.Xor);
result.Pop (this, typeExp);
return result;
}
if (typeExp is TokenTypeExpUndef) {
CompValuTemp result = new CompValuTemp (tokenTypeBool, this);
val.PushVal (this, typeExp);
ilGen.Emit (typeExp, OpCodes.Ldnull);
ilGen.Emit (typeExp, OpCodes.Ceq);
result.Pop (this, typeExp);
return result;
}
throw new Exception ("unknown TokenTypeExp type " + typeExp.GetType ());
}
/**
* @brief Push the default (null) value for a particular variable
* @param var = variable to get the default value for
* @returns with value pushed on stack
*/
public void PushVarDefaultValue (TokenDeclVar var)
{
PushDefaultValue (var.type);
}
public void PushDefaultValue (TokenType type)
{
if (type is TokenTypeArray) {
PushXMRInst (); // instance
ilGen.Emit (type, OpCodes.Newobj, xmrArrayConstructorInfo);
return;
}
if (type is TokenTypeChar) {
ilGen.Emit (type, OpCodes.Ldc_I4_0);
return;
}
if (type is TokenTypeList) {
ilGen.Emit (type, OpCodes.Ldc_I4_0);
ilGen.Emit (type, OpCodes.Newarr, typeof (object));
ilGen.Emit (type, OpCodes.Newobj, lslListConstructorInfo);
return;
}
if (type is TokenTypeRot) {
// Mono is tOO stOOpid to allow: ilGen.Emit (OpCodes.Ldsfld, zeroRotationFieldInfo);
ilGen.Emit (type, OpCodes.Ldc_R8, ScriptBaseClass.ZERO_ROTATION.x);
ilGen.Emit (type, OpCodes.Ldc_R8, ScriptBaseClass.ZERO_ROTATION.y);
ilGen.Emit (type, OpCodes.Ldc_R8, ScriptBaseClass.ZERO_ROTATION.z);
ilGen.Emit (type, OpCodes.Ldc_R8, ScriptBaseClass.ZERO_ROTATION.s);
ilGen.Emit (type, OpCodes.Newobj, lslRotationConstructorInfo);
return;
}
if ((type is TokenTypeKey) || (type is TokenTypeStr)) {
ilGen.Emit (type, OpCodes.Ldstr, "");
return;
}
if (type is TokenTypeVec) {
// Mono is tOO stOOpid to allow: ilGen.Emit (OpCodes.Ldsfld, zeroVectorFieldInfo);
ilGen.Emit (type, OpCodes.Ldc_R8, ScriptBaseClass.ZERO_VECTOR.x);
ilGen.Emit (type, OpCodes.Ldc_R8, ScriptBaseClass.ZERO_VECTOR.y);
ilGen.Emit (type, OpCodes.Ldc_R8, ScriptBaseClass.ZERO_VECTOR.z);
ilGen.Emit (type, OpCodes.Newobj, lslVectorConstructorInfo);
return;
}
if (type is TokenTypeInt) {
ilGen.Emit (type, OpCodes.Ldc_I4_0);
return;
}
if (type is TokenTypeFloat) {
ilGen.Emit (type, OpCodes.Ldc_R4, 0.0f);
return;
}
/*
* Default for 'object' type is 'undef'.
* Likewise for script-defined classes and interfaces.
*/
if ((type is TokenTypeObject) || (type is TokenTypeSDTypeClass) || (type is TokenTypeSDTypeInterface) || (type is TokenTypeExc)) {
ilGen.Emit (type, OpCodes.Ldnull);
return;
}
/*
* Void is pushed as the default return value of a void function.
* So just push nothing as expected of void functions.
*/
if (type is TokenTypeVoid) {
return;
}
/*
* Default for 'delegate' type is 'undef'.
*/
if (type is TokenTypeSDTypeDelegate) {
ilGen.Emit (type, OpCodes.Ldnull);
return;
}
throw new Exception ("unknown type " + type.GetType ().ToString ());
}
/**
* @brief Determine if the expression has a constant boolean value
* and if so, if the value is true or false.
* @param expr = expression to evaluate
* @returns true: expression is contant and has boolean value true
* false: otherwise
*/
private bool IsConstBoolExprTrue (CompValu expr)
{
bool constVal;
return IsConstBoolExpr (expr, out constVal) && constVal;
}
private bool IsConstBoolExpr (CompValu expr, out bool constVal)
{
if (expr is CompValuChar) {
constVal = ((CompValuChar)expr).x != 0;
return true;
}
if (expr is CompValuFloat) {
constVal = ((CompValuFloat)expr).x != (double)0;
return true;
}
if (expr is CompValuInteger) {
constVal = ((CompValuInteger)expr).x != 0;
return true;
}
if (expr is CompValuString) {
string s = ((CompValuString)expr).x;
constVal = s != "";
if (constVal && (expr.type is TokenTypeKey)) {
constVal = s != ScriptBaseClass.NULL_KEY;
}
return true;
}
constVal = false;
return false;
}
/**
* @brief Determine if the expression has a constant integer value
* and if so, return the integer value.
* @param expr = expression to evaluate
* @returns true: expression is contant and has integer value
* false: otherwise
*/
private bool IsConstIntExpr (CompValu expr, out int constVal)
{
if (expr is CompValuChar) {
constVal = (int)((CompValuChar)expr).x;
return true;
}
if (expr is CompValuInteger) {
constVal = ((CompValuInteger)expr).x;
return true;
}
constVal = 0;
return false;
}
/**
* @brief Determine if the expression has a constant string value
* and if so, return the string value.
* @param expr = expression to evaluate
* @returns true: expression is contant and has string value
* false: otherwise
*/
private bool IsConstStrExpr (CompValu expr, out string constVal)
{
if (expr is CompValuString) {
constVal = ((CompValuString)expr).x;
return true;
}
constVal = "";
return false;
}
/**
* @brief create table of legal event handler prototypes.
* This is used to make sure script's event handler declrations are valid.
*/
private static VarDict CreateLegalEventHandlers ()
{
/*
* Get handler prototypes with full argument lists.
*/
VarDict leh = new InternalFuncDict (typeof (IEventHandlers), false);
/*
* We want the scripts to be able to declare their handlers with
* fewer arguments than the full argument lists. So define additional
* prototypes with fewer arguments.
*/
TokenDeclVar[] fullArgProtos = new TokenDeclVar[leh.Count];
int i = 0;
foreach (TokenDeclVar fap in leh) fullArgProtos[i++] = fap;
foreach (TokenDeclVar fap in fullArgProtos) {
TokenArgDecl fal = fap.argDecl;
int fullArgCount = fal.vars.Length;
for (i = 0; i < fullArgCount; i ++) {
TokenArgDecl shortArgList = new TokenArgDecl (null);
for (int j = 0; j < i; j ++) {
TokenDeclVar var = fal.vars[j];
shortArgList.AddArg (var.type, var.name);
}
TokenDeclVar shortArgProto = new TokenDeclVar (null, null, null);
shortArgProto.name = new TokenName (null, fap.GetSimpleName ());
shortArgProto.retType = fap.retType;
shortArgProto.argDecl = shortArgList;
leh.AddEntry (shortArgProto);
}
}
return leh;
}
/**
* @brief Emit a call to CheckRun(), (voluntary multitasking switch)
*/
public void EmitCallCheckRun (Token errorAt, bool stack)
{
if (curDeclFunc.IsFuncTrivial (this)) throw new Exception (curDeclFunc.fullName + " is supposed to be trivial");
new CallLabel (this, errorAt); // jump here when stack restored
PushXMRInst (); // instance
ilGen.Emit (errorAt, OpCodes.Call, stack ? checkRunStackMethInfo : checkRunQuickMethInfo);
openCallLabel = null;
}
/**
* @brief Emit code to push a callNo var on the stack.
*/
public void GetCallNo (Token errorAt, ScriptMyLocal callNoVar)
{
ilGen.Emit (errorAt, OpCodes.Ldloc, callNoVar);
//ilGen.Emit (errorAt, OpCodes.Ldloca, callNoVar);
//ilGen.Emit (errorAt, OpCodes.Volatile);
//ilGen.Emit (errorAt, OpCodes.Ldind_I4);
}
public void GetCallNo (Token errorAt, CompValu callNoVar)
{
callNoVar.PushVal (this, errorAt);
//callNoVar.PushRef (this, errorAt);
//ilGen.Emit (errorAt, OpCodes.Volatile);
//ilGen.Emit (errorAt, OpCodes.Ldind_I4);
}
/**
* @brief Emit code to set a callNo var to a given constant.
*/
public void SetCallNo (Token errorAt, ScriptMyLocal callNoVar, int val)
{
ilGen.Emit (errorAt, OpCodes.Ldc_I4, val);
ilGen.Emit (errorAt, OpCodes.Stloc, callNoVar);
//ilGen.Emit (errorAt, OpCodes.Ldloca, callNoVar);
//ilGen.Emit (errorAt, OpCodes.Ldc_I4, val);
//ilGen.Emit (errorAt, OpCodes.Volatile);
//ilGen.Emit (errorAt, OpCodes.Stind_I4);
}
public void SetCallNo (Token errorAt, CompValu callNoVar, int val)
{
callNoVar.PopPre (this, errorAt);
ilGen.Emit (errorAt, OpCodes.Ldc_I4, val);
callNoVar.PopPost (this, errorAt);
//callNoVar.PushRef (this, errorAt);
//ilGen.Emit (errorAt, OpCodes.Ldc_I4, val);
//ilGen.Emit (errorAt, OpCodes.Volatile);
//ilGen.Emit (errorAt, OpCodes.Stind_I4);
}
/**
* @brief handle a unary operator, such as -x.
*/
private CompValu UnOpGenerate (CompValu inRVal, Token opcode)
{
/*
* - Negate
*/
if (opcode is TokenKwSub) {
if (inRVal.type is TokenTypeFloat) {
CompValuTemp outRVal = new CompValuTemp (new TokenTypeFloat (opcode), this);
inRVal.PushVal (this, opcode, outRVal.type); // push value to negate, make sure not LSL-boxed
ilGen.Emit (opcode, OpCodes.Neg); // compute the negative
outRVal.Pop (this, opcode); // pop into result
return outRVal; // tell caller where we put it
}
if (inRVal.type is TokenTypeInt) {
CompValuTemp outRVal = new CompValuTemp (new TokenTypeInt (opcode), this);
inRVal.PushVal (this, opcode, outRVal.type); // push value to negate, make sure not LSL-boxed
ilGen.Emit (opcode, OpCodes.Neg); // compute the negative
outRVal.Pop (this, opcode); // pop into result
return outRVal; // tell caller where we put it
}
if (inRVal.type is TokenTypeRot) {
CompValuTemp outRVal = new CompValuTemp (inRVal.type, this);
inRVal.PushVal (this, opcode); // push rotation, then call negate routine
ilGen.Emit (opcode, OpCodes.Call, lslRotationNegateMethodInfo);
outRVal.Pop (this, opcode); // pop into result
return outRVal; // tell caller where we put it
}
if (inRVal.type is TokenTypeVec) {
CompValuTemp outRVal = new CompValuTemp (inRVal.type, this);
inRVal.PushVal (this, opcode); // push vector, then call negate routine
ilGen.Emit (opcode, OpCodes.Call, lslVectorNegateMethodInfo);
outRVal.Pop (this, opcode); // pop into result
return outRVal; // tell caller where we put it
}
ErrorMsg (opcode, "can't negate a " + inRVal.type.ToString ());
return inRVal;
}
/*
* ~ Complement (bitwise integer)
*/
if (opcode is TokenKwTilde) {
if (inRVal.type is TokenTypeInt) {
CompValuTemp outRVal = new CompValuTemp (new TokenTypeInt (opcode), this);
inRVal.PushVal (this, opcode, outRVal.type); // push value to negate, make sure not LSL-boxed
ilGen.Emit (opcode, OpCodes.Not); // compute the complement
outRVal.Pop (this, opcode); // pop into result
return outRVal; // tell caller where we put it
}
ErrorMsg (opcode, "can't complement a " + inRVal.type.ToString ());
return inRVal;
}
/*
* ! Not (boolean)
*
* We stuff the 0/1 result in an int because I've seen x+!y in scripts
* and we don't want to have to create tables to handle int+bool and
* everything like that.
*/
if (opcode is TokenKwExclam) {
CompValuTemp outRVal = new CompValuTemp (new TokenTypeInt (opcode), this);
inRVal.PushVal (this, opcode, tokenTypeBool); // anything converts to boolean
ilGen.Emit (opcode, OpCodes.Ldc_I4_1); // then XOR with 1 to flip it
ilGen.Emit (opcode, OpCodes.Xor);
outRVal.Pop (this, opcode); // pop into result
return outRVal; // tell caller where we put it
}
throw new Exception ("unhandled opcode " + opcode.ToString ());
}
/**
* @brief This is called while trying to compute the value of constant initializers.
* It is passed a name and that name is looked up in the constant tables.
*/
private TokenRVal LookupInitConstants (TokenRVal rVal, ref bool didOne)
{
/*
* If it is a static field of a script-defined type, look it up and hopefully we find a constant there.
*/
TokenDeclVar gblVar;
if (rVal is TokenLValSField) {
TokenLValSField lvsf = (TokenLValSField)rVal;
if (lvsf.baseType is TokenTypeSDTypeClass) {
TokenDeclSDTypeClass sdtClass = ((TokenTypeSDTypeClass)lvsf.baseType).decl;
gblVar = sdtClass.members.FindExact (lvsf.fieldName.val, null);
if (gblVar != null) {
if (gblVar.constant && (gblVar.init is TokenRValConst)) {
didOne = true;
return gblVar.init;
}
}
}
return rVal;
}
/*
* Only other thing we handle is stand-alone names.
*/
if (!(rVal is TokenLValName)) return rVal;
string name = ((TokenLValName)rVal).name.val;
/*
* If we are doing the initializations for a script-defined type,
* look for the constant among the fields for that type.
*/
if (currentSDTClass != null) {
gblVar = currentSDTClass.members.FindExact (name, null);
if (gblVar != null) {
if (gblVar.constant && (gblVar.init is TokenRValConst)) {
didOne = true;
return gblVar.init;
}
return rVal;
}
}
/*
* Look it up as a script-defined global variable.
* Then if the variable is defined as a constant and has a constant value,
* we are successful. If it is defined as something else, return failure.
*/
gblVar = tokenScript.variablesStack.FindExact (name, null);
if (gblVar != null) {
if (gblVar.constant && (gblVar.init is TokenRValConst)) {
didOne = true;
return gblVar.init;
}
return rVal;
}
/*
* Maybe it is a built-in symbolic constant.
*/
ScriptConst scriptConst = ScriptConst.Lookup (name);
if (scriptConst != null) {
rVal = CompValuConst2RValConst (scriptConst.rVal, rVal);
if (rVal is TokenRValConst) {
didOne = true;
return rVal;
}
}
/*
* Don't know what it is, return failure.
*/
return rVal;
}
/**
* @brief This is called while trying to compute the value of constant expressions.
* It is passed a name and that name is looked up in the constant tables.
*/
private TokenRVal LookupBodyConstants (TokenRVal rVal, ref bool didOne)
{
/*
* If it is a static field of a script-defined type, look it up and hopefully we find a constant there.
*/
TokenDeclVar gblVar;
if (rVal is TokenLValSField) {
TokenLValSField lvsf = (TokenLValSField)rVal;
if (lvsf.baseType is TokenTypeSDTypeClass) {
TokenDeclSDTypeClass sdtClass = ((TokenTypeSDTypeClass)lvsf.baseType).decl;
gblVar = sdtClass.members.FindExact (lvsf.fieldName.val, null);
if ((gblVar != null) && gblVar.constant && (gblVar.init is TokenRValConst)) {
didOne = true;
return gblVar.init;
}
}
return rVal;
}
/*
* Only other thing we handle is stand-alone names.
*/
if (!(rVal is TokenLValName)) return rVal;
string name = ((TokenLValName)rVal).name.val;
/*
* Scan through the variable stack and hopefully we find a constant there.
* But we stop as soon as we get a match because that's what the script is referring to.
*/
CompValu val;
for (VarDict vars = ((TokenLValName)rVal).stack; vars != null; vars = vars.outerVarDict) {
TokenDeclVar var = vars.FindExact (name, null);
if (var != null) {
val = var.location;
goto foundit;
}
TokenDeclSDTypeClass baseClass = vars.thisClass;
if (baseClass != null) {
while ((baseClass = baseClass.extends) != null) {
var = baseClass.members.FindExact (name, null);
if (var != null) {
val = var.location;
goto foundit;
}
}
}
}
/*
* Maybe it is a built-in symbolic constant.
*/
ScriptConst scriptConst = ScriptConst.Lookup (name);
if (scriptConst != null) {
val = scriptConst.rVal;
goto foundit;
}
/*
* Don't know what it is, return failure.
*/
return rVal;
/*
* Found a CompValu. If it's a simple constant, then use it.
* Otherwise tell caller we failed to simplify.
*/
foundit:
rVal = CompValuConst2RValConst (val, rVal);
if (rVal is TokenRValConst) {
didOne = true;
}
return rVal;
}
private static TokenRVal CompValuConst2RValConst (CompValu val, TokenRVal rVal)
{
if (val is CompValuChar) rVal = new TokenRValConst (rVal, ((CompValuChar)val).x);
if (val is CompValuFloat) rVal = new TokenRValConst (rVal, ((CompValuFloat)val).x);
if (val is CompValuInteger) rVal = new TokenRValConst (rVal, ((CompValuInteger)val).x);
if (val is CompValuString) rVal = new TokenRValConst (rVal, ((CompValuString)val).x);
return rVal;
}
/**
* @brief Generate code to push XMRInstanceSuperType pointer on stack.
*/
public void PushXMRInst ()
{
if (instancePointer == null) {
ilGen.Emit (null, OpCodes.Ldarg_0);
} else {
ilGen.Emit (null, OpCodes.Ldloc, instancePointer);
}
}
/**
* @returns true: Ldarg_0 gives XMRSDTypeClObj pointer
* - this is the case for instance methods
* false: Ldarg_0 gives XMR_Instance pointer
* - this is the case for both global functions and static methods
*/
public bool IsSDTInstMethod ()
{
return (curDeclFunc.sdtClass != null) &&
((curDeclFunc.sdtFlags & ScriptReduce.SDT_STATIC) == 0);
}
/**
* @brief Look for a simply named function or variable (not a field or method)
*/
public TokenDeclVar FindNamedVar (TokenLValName lValName, TokenType[] argsig)
{
/*
* Look in variable stack for the given name.
*/
for (VarDict vars = lValName.stack; vars != null; vars = vars.outerVarDict) {
// first look for it possibly with an argument signature
// so we pick the correct overloaded method
TokenDeclVar var = FindSingleMember (vars, lValName.name, argsig);
if (var != null) return var;
// if that fails, try it without the argument signature.
// delegates get entered like any other variable, ie,
// no signature on their name.
if (argsig != null) {
var = FindSingleMember (vars, lValName.name, null);
if (var != null) return var;
}
// if this is the frame for some class members, try searching base class members too
TokenDeclSDTypeClass baseClass = vars.thisClass;
if (baseClass != null) {
while ((baseClass = baseClass.extends) != null) {
var = FindSingleMember (baseClass.members, lValName.name, argsig);
if (var != null) return var;
if (argsig != null) {
var = FindSingleMember (baseClass.members, lValName.name, null);
if (var != null) return var;
}
}
}
}
/*
* If not found, try one of the built-in constants or functions.
*/
if (argsig == null) {
ScriptConst scriptConst = ScriptConst.Lookup (lValName.name.val);
if (scriptConst != null) {
TokenDeclVar var = new TokenDeclVar (lValName.name, null, tokenScript);
var.name = lValName.name;
var.type = scriptConst.rVal.type;
var.location = scriptConst.rVal;
return var;
}
} else {
TokenDeclVar inline = FindSingleMember (TokenDeclInline.inlineFunctions, lValName.name, argsig);
if (inline != null) return inline;
}
return null;
}
/**
* @brief Find a member of an interface.
* @param sdType = interface type
* @param name = name of member to find
* @param argsig = null: field/property; else: script-visible method argument types
* @param baseRVal = pointer to interface object
* @returns null: no such member
* else: pointer to member
* baseRVal = possibly modified to point to type-casted interface object
*/
private TokenDeclVar FindInterfaceMember (TokenTypeSDTypeInterface sdtType, TokenName name, TokenType[] argsig, ref CompValu baseRVal)
{
TokenDeclSDTypeInterface sdtDecl = sdtType.decl;
TokenDeclSDTypeInterface impl;
TokenDeclVar declVar = sdtDecl.FindIFaceMember (this, name, argsig, out impl);
if ((declVar != null) && (impl != sdtDecl)) {
/*
* Accessing a method or propterty of another interface that the primary interface says it implements.
* In this case, we have to cast from the primary interface to that secondary interface.
*
* interface IEnumerable {
* IEnumerator GetEnumerator ();
* }
* interface ICountable : IEnumerable {
* integer GetCount ();
* }
* class List : ICountable {
* public GetCount () : ICountable { ... }
* public GetEnumerator () : IEnumerable { ... }
* }
*
* ICountable aList = new List ();
* IEnumerator anEnumer = aList.GetEnumerator (); << we are here
* << baseRVal = aList
* << sdtDecl = ICountable
* << impl = IEnumerable
* << name = GetEnumerator
* << argsig = ()
* So we have to cast aList from ICountable to IEnumerable.
*/
// make type token for the secondary interface type
TokenType subIntfType = impl.MakeRefToken (name);
// make a temp variable of the secondary interface type
CompValuTemp castBase = new CompValuTemp (subIntfType, this);
// output code to cast from the primary interface to the secondary interface
// this is 2 basic steps:
// 1) cast from primary interface object -> class object
// ...gets it from interfaceObject.delegateArray[0].Target
// 2) cast from class object -> secondary interface object
// ...gets it from classObject.sdtcITable[interfaceIndex]
baseRVal.PushVal (this, name, subIntfType);
// save result of casting in temp
castBase.Pop (this, name);
// return temp reference
baseRVal = castBase;
}
return declVar;
}
/**
* @brief Find a member of a script-defined type class.
* @param sdtType = reference to class declaration
* @param name = name of member to find
* @param argsig = argument signature used to select among overloaded members
* @returns null: no such member found
* else: the member found
*/
public TokenDeclVar FindThisMember (TokenTypeSDTypeClass sdtType, TokenName name, TokenType[] argsig)
{
return FindThisMember (sdtType.decl, name, argsig);
}
public TokenDeclVar FindThisMember (TokenDeclSDTypeClass sdtDecl, TokenName name, TokenType[] argsig)
{
for (TokenDeclSDTypeClass sdtd = sdtDecl; sdtd != null; sdtd = sdtd.extends) {
TokenDeclVar declVar = FindSingleMember (sdtd.members, name, argsig);
if (declVar != null) return declVar;
}
return null;
}
/**
* @brief Look for a single member that matches the given name and argument signature
* @param where = which dictionary to look in
* @param name = basic name of the field or method, eg, "Printable"
* @param argsig = argument types the method is being called with, eg, "(string)"
* or null to find a field
* @returns null: no member found
* else: the member found
*/
public TokenDeclVar FindSingleMember (VarDict where, TokenName name, TokenType[] argsig)
{
TokenDeclVar[] members = where.FindCallables (name.val, argsig);
if (members == null) return null;
if (members.Length > 1) {
ErrorMsg (name, "more than one matching member");
for (int i = 0; i < members.Length; i ++) {
ErrorMsg (members[i], " " + members[i].argDecl.GetArgSig ());
}
}
return members[0];
}
/**
* @brief Find an exact function name and argument signature match.
* Also verify that the return value type is an exact match.
* @param where = which method dictionary to look in
* @param name = basic name of the method, eg, "Printable"
* @param ret = expected return value type
* @param argsig = argument types the method is being called with, eg, "(string)"
* @returns null: no exact match found
* else: the matching function
*/
private TokenDeclVar FindExactWithRet (VarDict where, TokenName name, TokenType ret, TokenType[] argsig)
{
TokenDeclVar func = where.FindExact (name.val, argsig);
if ((func != null) && (func.retType.ToString () != ret.ToString ())) {
ErrorMsg (name, "return type mismatch, have " + func.retType.ToString () + ", expect " + ret.ToString ());
}
if (func != null) CheckAccess (func, name);
return func;
}
/**
* @brief Check the private/protected/public access flags of a member.
*/
private void CheckAccess (TokenDeclVar var, Token errorAt)
{
TokenDeclSDType nested;
TokenDeclSDType definedBy = var.sdtClass;
TokenDeclSDType accessedBy = curDeclFunc.sdtClass;
/*******************************\
* Check member-level access *
\*******************************/
/*
* Note that if accessedBy is null, ie, accessing from global function (or event handlers),
* anything tagged as SDT_PRIVATE or SDT_PROTECTED will fail.
*/
/*
* Private means accessed by the class that defined the member or accessed by a nested class
* of the class that defined the member.
*/
if ((var.sdtFlags & ScriptReduce.SDT_PRIVATE) != 0) {
for (nested = accessedBy; nested != null; nested = nested.outerSDType) {
if (nested == definedBy) goto acc1ok;
}
ErrorMsg (errorAt, "private member " + var.fullName + " cannot be accessed by " + curDeclFunc.fullName);
return;
}
/*
* Protected means:
* If being accessed by an inner class, the inner class has access to it if the inner class derives
* from the declaring class. It also has access to it if an outer class derives from the declaring
* class.
*/
if ((var.sdtFlags & ScriptReduce.SDT_PROTECTED) != 0) {
for (nested = accessedBy; nested != null; nested = nested.outerSDType) {
for (TokenDeclSDType rootward = nested; rootward != null; rootward = rootward.extends) {
if (rootward == definedBy) goto acc1ok;
}
}
ErrorMsg (errorAt, "protected member " + var.fullName + " cannot be accessed by " + curDeclFunc.fullName);
return;
}
acc1ok:
/******************************\
* Check class-level access *
\******************************/
/*
* If being accessed by same or inner class than where defined, it is ok.
*
* class DefiningClass {
* varBeingAccessed;
* .
* .
* .
* class AccessingClass {
* functionDoingAccess() { }
* }
* .
* .
* .
* }
*/
nested = accessedBy;
while (true) {
if (nested == definedBy) return;
if (nested == null) break;
nested = (TokenDeclSDTypeClass)nested.outerSDType;
}
/*
* It is being accessed by an outer class than where defined,
* check for a 'private' or 'protected' class tag that blocks.
*/
do {
/*
* If the field's class is defined directly inside the accessing class,
* access is allowed regardless of class-level private or protected tags.
*
* class AccessingClass {
* functionDoingAccess() { }
* class DefiningClass {
* varBeingAccessed;
* }
* }
*/
if (definedBy.outerSDType == accessedBy) return;
/*
* If the field's class is defined two or more levels inside the accessing class,
* access is denied if the defining class is tagged private.
*
* class AccessingClass {
* functionDoingAccess() { }
* .
* .
* .
* class IntermediateClass {
* private class DefiningClass {
* varBeingAccessed;
* }
* }
* .
* .
* .
* }
*/
if ((definedBy.accessLevel & ScriptReduce.SDT_PRIVATE) != 0) {
ErrorMsg (errorAt, "member " + var.fullName + " cannot be accessed by " + curDeclFunc.fullName +
" because of private class " + definedBy.longName.val);
return;
}
/*
* Likewise, if DefiningClass is tagged protected, the AccessingClass must derive from the
* IntermediateClass or access is denied.
*/
if ((definedBy.accessLevel & ScriptReduce.SDT_PROTECTED) != 0) {
for (TokenDeclSDType extends = accessedBy; extends != definedBy.outerSDType; extends = extends.extends) {
if (extends == null) {
ErrorMsg (errorAt, "member " + var.fullName + " cannot be accessed by " + curDeclFunc.fullName +
" because of protected class " + definedBy.longName.val);
return;
}
}
}
/*
* Check next outer level.
*/
definedBy = definedBy.outerSDType;
} while (definedBy != null);
}
/**
* @brief Convert a list of argument types to printable string, eg, "(list,string,float,integer)"
* If given a null, return "" indicating it is a field not a method
*/
public static string ArgSigString (TokenType[] argsig)
{
if (argsig == null) return "";
StringBuilder sb = new StringBuilder ("(");
for (int i = 0; i < argsig.Length; i ++) {
if (i > 0) sb.Append (",");
sb.Append (argsig[i].ToString ());
}
sb.Append (")");
return sb.ToString ();
}
/**
* @brief output error message and remember that we did
*/
public void ErrorMsg (Token token, string message)
{
if ((token == null) || (token.emsg == null)) token = errorMessageToken;
if (!youveAnError || (token.file != lastErrorFile) || (token.line > lastErrorLine)) {
token.ErrorMsg (message);
youveAnError = true;
lastErrorFile = token.file;
lastErrorLine = token.line;
}
}
/**
* @brief Find a private static method.
* @param owner = class the method is part of
* @param name = name of method to find
* @param args = array of argument types
* @returns pointer to method
*/
public static MethodInfo GetStaticMethod (Type owner, string name, Type[] args)
{
MethodInfo mi = owner.GetMethod (name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, args, null);
if (mi == null) {
throw new Exception ("undefined method " + owner.ToString () + "." + name);
}
return mi;
}
// http://wiki.secondlife.com/wiki/Rotation 'negate a rotation' says just negate .s component
// but http://wiki.secondlife.com/wiki/LSL_Language_Test (lslangtest1.lsl) says negate all 4 values
public static LSL_Rotation LSLRotationNegate (LSL_Rotation r) { return new LSL_Rotation (-r.x,-r.y,-r.z,-r.s); }
public static LSL_Vector LSLVectorNegate (LSL_Vector v) { return -v; }
public static string CatchExcToStr (Exception exc) { return exc.ToString(); }
//public static void ConsoleWrite (string str) { Console.Write(str); }
/**
* @brief Defines an internal label that is used as a target for 'break' and 'continue' statements.
*/
private class BreakContTarg {
public bool used;
public ScriptMyLabel label;
public TokenStmtBlock block;
public BreakContTarg (ScriptCodeGen scg, string name) {
used = false; // assume it isn't referenced at all
label = scg.ilGen.DefineLabel (name); // label that the break/continue jumps to
block = scg.curStmtBlock; // { ... } that the break/continue label is in
}
}
}
/**
* @brief Marker interface indicates an exception that can't be caught by a script-level try/catch.
*/
public interface IXMRUncatchable { }
/**
* @brief Thrown by a script when it attempts to change to an undefined state.
* These can be detected at compile time but the moron XEngine compiles
* such things, so we compile them as runtime errors.
*/
[SerializableAttribute]
public class ScriptUndefinedStateException : Exception, ISerializable {
public string stateName;
public ScriptUndefinedStateException (string stateName) : base ("undefined state " + stateName) {
this.stateName = stateName;
}
protected ScriptUndefinedStateException (SerializationInfo info, StreamingContext context) : base (info, context)
{ }
}
/**
* @brief Created by a throw statement.
*/
[SerializableAttribute]
public class ScriptThrownException : Exception, ISerializable {
public object thrown;
/**
* @brief Called by a throw statement to wrap the object in a unique
* tag that capable of capturing a stack trace. Script can
* unwrap it by calling xmrExceptionThrownValue().
*/
public static Exception Wrap (object thrown)
{
return new ScriptThrownException (thrown);
}
private ScriptThrownException (object thrown) : base (thrown.ToString ())
{
this.thrown = thrown;
}
/**
* @brief Used by serialization/deserialization.
*/
protected ScriptThrownException (SerializationInfo info, StreamingContext context) : base (info, context)
{ }
}
/**
* @brief Thrown by a script when it attempts to change to a defined state.
*/
[SerializableAttribute]
public class ScriptChangeStateException : Exception, ISerializable, IXMRUncatchable {
public int newState;
public ScriptChangeStateException (int newState) {
this.newState = newState;
}
protected ScriptChangeStateException (SerializationInfo info, StreamingContext context) : base (info, context)
{ }
}
/**
* @brief We are restoring to the body of a catch { } so we need to
* wrap the original exception in an outer exception, so the
* system won't try to refill the stack trace.
*
* We don't mark this one serializable as it should never get
* serialized out. It only lives from the throw to the very
* beginning of the catch handler where it is promptly unwrapped.
* No CheckRun() call can possibly intervene.
*/
public class ScriptRestoreCatchException : Exception {
// old code uses these
private object e;
public ScriptRestoreCatchException (object e) {
this.e = e;
}
public static object Unwrap (object o)
{
if (o is IXMRUncatchable) return null;
if (o is ScriptRestoreCatchException) return ((ScriptRestoreCatchException)o).e;
return o;
}
// new code uses these
private Exception ee;
public ScriptRestoreCatchException (Exception ee) {
this.ee = ee;
}
public static Exception Unwrap (Exception oo)
{
if (oo is IXMRUncatchable) return null;
if (oo is ScriptRestoreCatchException) return ((ScriptRestoreCatchException)oo).ee;
return oo;
}
}
[SerializableAttribute]
public class ScriptBadCallNoException : Exception {
public ScriptBadCallNoException (int callNo) : base ("bad callNo " + callNo) { }
protected ScriptBadCallNoException (SerializationInfo info, StreamingContext context) : base (info, context)
{ }
}
public class CVVMismatchException : Exception {
public int oldcvv;
public int newcvv;
public CVVMismatchException (int oldcvv, int newcvv) : base ("object version is " + oldcvv.ToString () +
" but accept only " + newcvv.ToString ())
{
this.oldcvv = oldcvv;
this.newcvv = newcvv;
}
}
}
Reference in New Issue View Git Blame Copy Permalink