1560 lines
77 KiB
C#
1560 lines
77 KiB
C#
/*
|
|
* 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.Text;
|
|
using System.Text.RegularExpressions;
|
|
|
|
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;
|
|
|
|
namespace OpenSim.Region.ScriptEngine.XMREngine {
|
|
|
|
/**
|
|
* @brief This class is used to catalog the code emit routines based on a key string
|
|
* The key string has the two types (eg, "integer", "rotation") and the operator (eg, "*", "!=")
|
|
*/
|
|
public delegate void BinOpStrEmitBO (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result);
|
|
public class BinOpStr {
|
|
public static readonly Dictionary<string, BinOpStr> defined = DefineBinOps ();
|
|
|
|
public Type outtype; // type of result of computation
|
|
public BinOpStrEmitBO emitBO; // how to compute result
|
|
public bool rmwOK; // is the <operator>= form valid?
|
|
|
|
public BinOpStr (Type outtype, BinOpStrEmitBO emitBO)
|
|
{
|
|
this.outtype = outtype;
|
|
this.emitBO = emitBO;
|
|
this.rmwOK = false;
|
|
}
|
|
|
|
public BinOpStr (Type outtype, BinOpStrEmitBO emitBO, bool rmwOK)
|
|
{
|
|
this.outtype = outtype;
|
|
this.emitBO = emitBO;
|
|
this.rmwOK = rmwOK;
|
|
}
|
|
|
|
private static TokenTypeBool tokenTypeBool = new TokenTypeBool (null);
|
|
private static TokenTypeChar tokenTypeChar = new TokenTypeChar (null);
|
|
private static TokenTypeFloat tokenTypeFloat = new TokenTypeFloat (null);
|
|
private static TokenTypeInt tokenTypeInt = new TokenTypeInt (null);
|
|
private static TokenTypeList tokenTypeList = new TokenTypeList (null);
|
|
private static TokenTypeRot tokenTypeRot = new TokenTypeRot (null);
|
|
private static TokenTypeStr tokenTypeStr = new TokenTypeStr (null);
|
|
private static TokenTypeVec tokenTypeVec = new TokenTypeVec (null);
|
|
|
|
private static MethodInfo stringAddStringMethInfo = ScriptCodeGen.GetStaticMethod (typeof (string), "Concat", new Type[] { typeof (string), typeof (string) });
|
|
private static MethodInfo stringCmpStringMethInfo = ScriptCodeGen.GetStaticMethod (typeof (string), "Compare", new Type[] { typeof (string), typeof (string) });
|
|
|
|
private static MethodInfo infoMethListAddFloat = GetBinOpsMethod ("MethListAddFloat", new Type[] { typeof (LSL_List), typeof (double) });
|
|
private static MethodInfo infoMethListAddInt = GetBinOpsMethod ("MethListAddInt", new Type[] { typeof (LSL_List), typeof (int) });
|
|
private static MethodInfo infoMethListAddKey = GetBinOpsMethod ("MethListAddKey", new Type[] { typeof (LSL_List), typeof (string) });
|
|
private static MethodInfo infoMethListAddRot = GetBinOpsMethod ("MethListAddRot", new Type[] { typeof (LSL_List), typeof (LSL_Rotation) });
|
|
private static MethodInfo infoMethListAddStr = GetBinOpsMethod ("MethListAddStr", new Type[] { typeof (LSL_List), typeof (string) });
|
|
private static MethodInfo infoMethListAddVec = GetBinOpsMethod ("MethListAddVec", new Type[] { typeof (LSL_List), typeof (LSL_Vector) });
|
|
private static MethodInfo infoMethListAddList = GetBinOpsMethod ("MethListAddList", new Type[] { typeof (LSL_List), typeof (LSL_List) });
|
|
private static MethodInfo infoMethFloatAddList = GetBinOpsMethod ("MethFloatAddList", new Type[] { typeof (double), typeof (LSL_List) });
|
|
private static MethodInfo infoMethIntAddList = GetBinOpsMethod ("MethIntAddList", new Type[] { typeof (int), typeof (LSL_List) });
|
|
private static MethodInfo infoMethKeyAddList = GetBinOpsMethod ("MethKeyAddList", new Type[] { typeof (string), typeof (LSL_List) });
|
|
private static MethodInfo infoMethRotAddList = GetBinOpsMethod ("MethRotAddList", new Type[] { typeof (LSL_Rotation), typeof (LSL_List) });
|
|
private static MethodInfo infoMethStrAddList = GetBinOpsMethod ("MethStrAddList", new Type[] { typeof (string), typeof (LSL_List) });
|
|
private static MethodInfo infoMethVecAddList = GetBinOpsMethod ("MethVecAddList", new Type[] { typeof (LSL_Vector), typeof (LSL_List) });
|
|
private static MethodInfo infoMethListEqList = GetBinOpsMethod ("MethListEqList", new Type[] { typeof (LSL_List), typeof (LSL_List) });
|
|
private static MethodInfo infoMethListNeList = GetBinOpsMethod ("MethListNeList", new Type[] { typeof (LSL_List), typeof (LSL_List) });
|
|
private static MethodInfo infoMethRotEqRot = GetBinOpsMethod ("MethRotEqRot", new Type[] { typeof (LSL_Rotation), typeof (LSL_Rotation) });
|
|
private static MethodInfo infoMethRotNeRot = GetBinOpsMethod ("MethRotNeRot", new Type[] { typeof (LSL_Rotation), typeof (LSL_Rotation) });
|
|
private static MethodInfo infoMethRotAddRot = GetBinOpsMethod ("MethRotAddRot", new Type[] { typeof (LSL_Rotation), typeof (LSL_Rotation) });
|
|
private static MethodInfo infoMethRotSubRot = GetBinOpsMethod ("MethRotSubRot", new Type[] { typeof (LSL_Rotation), typeof (LSL_Rotation) });
|
|
private static MethodInfo infoMethRotMulRot = GetBinOpsMethod ("MethRotMulRot", new Type[] { typeof (LSL_Rotation), typeof (LSL_Rotation) });
|
|
private static MethodInfo infoMethRotDivRot = GetBinOpsMethod ("MethRotDivRot", new Type[] { typeof (LSL_Rotation), typeof (LSL_Rotation) });
|
|
private static MethodInfo infoMethVecEqVec = GetBinOpsMethod ("MethVecEqVec", new Type[] { typeof (LSL_Vector), typeof (LSL_Vector) });
|
|
private static MethodInfo infoMethVecNeVec = GetBinOpsMethod ("MethVecNeVec", new Type[] { typeof (LSL_Vector), typeof (LSL_Vector) });
|
|
private static MethodInfo infoMethVecAddVec = GetBinOpsMethod ("MethVecAddVec", new Type[] { typeof (LSL_Vector), typeof (LSL_Vector) });
|
|
private static MethodInfo infoMethVecSubVec = GetBinOpsMethod ("MethVecSubVec", new Type[] { typeof (LSL_Vector), typeof (LSL_Vector) });
|
|
private static MethodInfo infoMethVecMulVec = GetBinOpsMethod ("MethVecMulVec", new Type[] { typeof (LSL_Vector), typeof (LSL_Vector) });
|
|
private static MethodInfo infoMethVecModVec = GetBinOpsMethod ("MethVecModVec", new Type[] { typeof (LSL_Vector), typeof (LSL_Vector) });
|
|
private static MethodInfo infoMethVecMulFloat = GetBinOpsMethod ("MethVecMulFloat", new Type[] { typeof (LSL_Vector), typeof (double) });
|
|
private static MethodInfo infoMethFloatMulVec = GetBinOpsMethod ("MethFloatMulVec", new Type[] { typeof (double), typeof (LSL_Vector) });
|
|
private static MethodInfo infoMethVecDivFloat = GetBinOpsMethod ("MethVecDivFloat", new Type[] { typeof (LSL_Vector), typeof (double) });
|
|
private static MethodInfo infoMethVecMulInt = GetBinOpsMethod ("MethVecMulInt", new Type[] { typeof (LSL_Vector), typeof (int) });
|
|
private static MethodInfo infoMethIntMulVec = GetBinOpsMethod ("MethIntMulVec", new Type[] { typeof (int), typeof (LSL_Vector) });
|
|
private static MethodInfo infoMethVecDivInt = GetBinOpsMethod ("MethVecDivInt", new Type[] { typeof (LSL_Vector), typeof (int) });
|
|
private static MethodInfo infoMethVecMulRot = GetBinOpsMethod ("MethVecMulRot", new Type[] { typeof (LSL_Vector), typeof (LSL_Rotation) });
|
|
private static MethodInfo infoMethVecDivRot = GetBinOpsMethod ("MethVecDivRot", new Type[] { typeof (LSL_Vector), typeof (LSL_Rotation) });
|
|
|
|
private static MethodInfo GetBinOpsMethod (string name, Type[] types)
|
|
{
|
|
return ScriptCodeGen.GetStaticMethod (typeof (BinOpStr), name, types);
|
|
}
|
|
|
|
/**
|
|
* @brief Create a dictionary for processing binary operators.
|
|
* This tells us, for a given type, an operator and another type,
|
|
* is the operation permitted, and if so, what is the type of the result?
|
|
* The key is <lefttype><opcode><righttype>,
|
|
* where <lefttype> and <righttype> are strings returned by (TokenType...).ToString()
|
|
* and <opcode> is string returned by (TokenKw...).ToString()
|
|
* The value is a BinOpStr struct giving the resultant type and a method to generate the code.
|
|
*/
|
|
private static Dictionary<string, BinOpStr> DefineBinOps ()
|
|
{
|
|
Dictionary<string, BinOpStr> bos = new Dictionary<string, BinOpStr> ();
|
|
|
|
string[] booltypes = new string[] { "bool", "char", "float", "integer", "key", "list", "string" };
|
|
|
|
/*
|
|
* Get the && and || all out of the way...
|
|
* Simply cast their left and right operands to boolean then process.
|
|
*/
|
|
for (int i = 0; i < booltypes.Length; i ++) {
|
|
for (int j = 0; j < booltypes.Length; j ++) {
|
|
bos.Add (booltypes[i] + "&&" + booltypes[j],
|
|
new BinOpStr (typeof (bool), BinOpStrAndAnd));
|
|
bos.Add (booltypes[i] + "||" + booltypes[j],
|
|
new BinOpStr (typeof (bool), BinOpStrOrOr));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Pound through all the other combinations we support.
|
|
*/
|
|
|
|
// boolean : somethingelse
|
|
DefineBinOpsBoolX (bos, "bool");
|
|
DefineBinOpsBoolX (bos, "char");
|
|
DefineBinOpsBoolX (bos, "float");
|
|
DefineBinOpsBoolX (bos, "integer");
|
|
DefineBinOpsBoolX (bos, "key");
|
|
DefineBinOpsBoolX (bos, "list");
|
|
DefineBinOpsBoolX (bos, "string");
|
|
|
|
// stuff with chars
|
|
DefineBinOpsChar (bos);
|
|
|
|
// somethingelse : boolean
|
|
DefineBinOpsXBool (bos, "char");
|
|
DefineBinOpsXBool (bos, "float");
|
|
DefineBinOpsXBool (bos, "integer");
|
|
DefineBinOpsXBool (bos, "key");
|
|
DefineBinOpsXBool (bos, "list");
|
|
DefineBinOpsXBool (bos, "string");
|
|
|
|
// float : somethingelse
|
|
DefineBinOpsFloatX (bos, "float");
|
|
DefineBinOpsFloatX (bos, "integer");
|
|
|
|
// integer : float
|
|
DefineBinOpsXFloat (bos, "integer");
|
|
|
|
// anything else with integers
|
|
DefineBinOpsInteger (bos);
|
|
|
|
// key : somethingelse
|
|
DefineBinOpsKeyX (bos, "key");
|
|
DefineBinOpsKeyX (bos, "string");
|
|
|
|
// string : key
|
|
DefineBinOpsXKey (bos, "string");
|
|
|
|
// things with lists
|
|
DefineBinOpsList (bos);
|
|
|
|
// things with rotations
|
|
DefineBinOpsRotation (bos);
|
|
|
|
// things with strings
|
|
DefineBinOpsString (bos);
|
|
|
|
// things with vectors
|
|
DefineBinOpsVector (bos);
|
|
|
|
// Contrary to some beliefs, scripts do things like string+integer and integer+string
|
|
bos.Add ("bool+string", new BinOpStr (typeof (string), BinOpStrStrAddStr));
|
|
bos.Add ("char+string", new BinOpStr (typeof (string), BinOpStrStrAddStr));
|
|
bos.Add ("float+string", new BinOpStr (typeof (string), BinOpStrStrAddStr));
|
|
bos.Add ("integer+string", new BinOpStr (typeof (string), BinOpStrStrAddStr));
|
|
bos.Add ("string+bool", new BinOpStr (typeof (string), BinOpStrStrAddStr, true));
|
|
bos.Add ("string+char", new BinOpStr (typeof (string), BinOpStrStrAddStr, true));
|
|
bos.Add ("string+float", new BinOpStr (typeof (string), BinOpStrStrAddStr, true));
|
|
bos.Add ("string+integer", new BinOpStr (typeof (string), BinOpStrStrAddStr, true));
|
|
|
|
// Now for our final slight-of-hand, we're going to scan through all those.
|
|
// And wherever we see an 'integer' in the key, we are going to make another
|
|
// entry with 'bool', as we want to accept a bool as having a value of 0 or 1.
|
|
// This lets us do things like 3.5 * (x > 0).
|
|
|
|
Dictionary<string, BinOpStr> bos2 = new Dictionary<string, BinOpStr> ();
|
|
foreach (KeyValuePair<string, BinOpStr> kvp in bos) {
|
|
string key = kvp.Key;
|
|
BinOpStr val = kvp.Value;
|
|
bos2.Add (key, val);
|
|
}
|
|
Regex wordReg = new Regex("\\w+");
|
|
Regex opReg = new Regex("\\W+");
|
|
foreach (KeyValuePair<string, BinOpStr> kvp in bos) {
|
|
string key = kvp.Key;
|
|
BinOpStr val = kvp.Value;
|
|
MatchCollection matches = wordReg.Matches(key);
|
|
if (matches.Count != 2)
|
|
continue;
|
|
Match opM = opReg.Match(key);
|
|
if (!opM.Success)
|
|
continue;
|
|
string left = matches[0].Value;
|
|
string right = matches[1].Value;
|
|
string op = opM.Value;
|
|
string key2;
|
|
if (left == "integer" && right == "integer")
|
|
{
|
|
key2 = "bool"+op+"bool";
|
|
if (!bos2.ContainsKey (key2)) bos2.Add (key2, val);
|
|
key2 = "bool"+op+"integer";
|
|
if (!bos2.ContainsKey (key2)) bos2.Add (key2, val);
|
|
key2 = "integer"+op+"bool";
|
|
if (!bos2.ContainsKey (key2)) bos2.Add (key2, val);
|
|
}
|
|
else
|
|
{
|
|
key2 = key.Replace("integer", "bool");
|
|
if (!bos2.ContainsKey (key2)) bos2.Add (key2, val);
|
|
}
|
|
}
|
|
return bos2;
|
|
}
|
|
|
|
private static void DefineBinOpsBoolX (Dictionary<string, BinOpStr> bos, string x)
|
|
{
|
|
bos.Add ("bool|" + x, new BinOpStr (typeof (int), BinOpStrBoolOrX));
|
|
bos.Add ("bool^" + x, new BinOpStr (typeof (int), BinOpStrBoolXorX));
|
|
bos.Add ("bool&" + x, new BinOpStr (typeof (int), BinOpStrBoolAndX));
|
|
bos.Add ("bool==" + x, new BinOpStr (typeof (bool), BinOpStrBoolEqX));
|
|
bos.Add ("bool!=" + x, new BinOpStr (typeof (bool), BinOpStrBoolNeX));
|
|
}
|
|
|
|
private static void DefineBinOpsXBool (Dictionary<string, BinOpStr> bos, string x)
|
|
{
|
|
bos.Add (x + "|bool", new BinOpStr (typeof (int), BinOpStrBoolOrX));
|
|
bos.Add (x + "^bool", new BinOpStr (typeof (int), BinOpStrBoolXorX));
|
|
bos.Add (x + "&bool", new BinOpStr (typeof (int), BinOpStrBoolAndX));
|
|
bos.Add (x + "==bool", new BinOpStr (typeof (bool), BinOpStrBoolEqX));
|
|
bos.Add (x + "!=bool", new BinOpStr (typeof (bool), BinOpStrBoolNeX));
|
|
}
|
|
|
|
private static void DefineBinOpsFloatX (Dictionary<string, BinOpStr> bos, string x)
|
|
{
|
|
bos.Add ("float==" + x, new BinOpStr (typeof (bool), BinOpStrFloatEqX));
|
|
bos.Add ("float!=" + x, new BinOpStr (typeof (bool), BinOpStrFloatNeX));
|
|
bos.Add ("float<" + x, new BinOpStr (typeof (bool), BinOpStrFloatLtX));
|
|
bos.Add ("float<=" + x, new BinOpStr (typeof (bool), BinOpStrFloatLeX));
|
|
bos.Add ("float>" + x, new BinOpStr (typeof (bool), BinOpStrFloatGtX));
|
|
bos.Add ("float>=" + x, new BinOpStr (typeof (bool), BinOpStrFloatGeX));
|
|
bos.Add ("float+" + x, new BinOpStr (typeof (double), BinOpStrFloatAddX, true));
|
|
bos.Add ("float-" + x, new BinOpStr (typeof (double), BinOpStrFloatSubX, true));
|
|
bos.Add ("float*" + x, new BinOpStr (typeof (double), BinOpStrFloatMulX, true));
|
|
bos.Add ("float/" + x, new BinOpStr (typeof (double), BinOpStrFloatDivX, true));
|
|
bos.Add ("float%" + x, new BinOpStr (typeof (double), BinOpStrFloatModX, true));
|
|
}
|
|
|
|
private static void DefineBinOpsXFloat (Dictionary<string, BinOpStr> bos, string x)
|
|
{
|
|
bos.Add (x + "==float", new BinOpStr (typeof (bool), BinOpStrXEqFloat));
|
|
bos.Add (x + "!=float", new BinOpStr (typeof (bool), BinOpStrXNeFloat));
|
|
bos.Add (x + "<float", new BinOpStr (typeof (bool), BinOpStrXLtFloat));
|
|
bos.Add (x + "<=float", new BinOpStr (typeof (bool), BinOpStrXLeFloat));
|
|
bos.Add (x + ">float", new BinOpStr (typeof (bool), BinOpStrXGtFloat));
|
|
bos.Add (x + ">=float", new BinOpStr (typeof (bool), BinOpStrXGeFloat));
|
|
bos.Add (x + "+float", new BinOpStr (typeof (double), BinOpStrXAddFloat, true));
|
|
bos.Add (x + "-float", new BinOpStr (typeof (double), BinOpStrXSubFloat, true));
|
|
bos.Add (x + "*float", new BinOpStr (typeof (double), BinOpStrXMulFloat, true));
|
|
bos.Add (x + "/float", new BinOpStr (typeof (double), BinOpStrXDivFloat, true));
|
|
bos.Add (x + "%float", new BinOpStr (typeof (double), BinOpStrXModFloat, true));
|
|
}
|
|
|
|
private static void DefineBinOpsChar (Dictionary<string, BinOpStr> bos)
|
|
{
|
|
bos.Add ("char==char", new BinOpStr (typeof (bool), BinOpStrCharEqChar));
|
|
bos.Add ("char!=char", new BinOpStr (typeof (bool), BinOpStrCharNeChar));
|
|
bos.Add ("char<char", new BinOpStr (typeof (bool), BinOpStrCharLtChar));
|
|
bos.Add ("char<=char", new BinOpStr (typeof (bool), BinOpStrCharLeChar));
|
|
bos.Add ("char>char", new BinOpStr (typeof (bool), BinOpStrCharGtChar));
|
|
bos.Add ("char>=char", new BinOpStr (typeof (bool), BinOpStrCharGeChar));
|
|
bos.Add ("char+integer", new BinOpStr (typeof (char), BinOpStrCharAddInt, true));
|
|
bos.Add ("char-integer", new BinOpStr (typeof (char), BinOpStrCharSubInt, true));
|
|
bos.Add ("char-char", new BinOpStr (typeof (int), BinOpStrCharSubChar));
|
|
}
|
|
|
|
private static void DefineBinOpsInteger (Dictionary<string, BinOpStr> bos)
|
|
{
|
|
bos.Add ("integer==integer", new BinOpStr (typeof (bool), BinOpStrIntEqInt));
|
|
bos.Add ("integer!=integer", new BinOpStr (typeof (bool), BinOpStrIntNeInt));
|
|
bos.Add ("integer<integer", new BinOpStr (typeof (bool), BinOpStrIntLtInt));
|
|
bos.Add ("integer<=integer", new BinOpStr (typeof (bool), BinOpStrIntLeInt));
|
|
bos.Add ("integer>integer", new BinOpStr (typeof (bool), BinOpStrIntGtInt));
|
|
bos.Add ("integer>=integer", new BinOpStr (typeof (bool), BinOpStrIntGeInt));
|
|
bos.Add ("integer|integer", new BinOpStr (typeof (int), BinOpStrIntOrInt, true));
|
|
bos.Add ("integer^integer", new BinOpStr (typeof (int), BinOpStrIntXorInt, true));
|
|
bos.Add ("integer&integer", new BinOpStr (typeof (int), BinOpStrIntAndInt, true));
|
|
bos.Add ("integer+integer", new BinOpStr (typeof (int), BinOpStrIntAddInt, true));
|
|
bos.Add ("integer-integer", new BinOpStr (typeof (int), BinOpStrIntSubInt, true));
|
|
bos.Add ("integer*integer", new BinOpStr (typeof (int), BinOpStrIntMulInt, true));
|
|
bos.Add ("integer/integer", new BinOpStr (typeof (int), BinOpStrIntDivInt, true));
|
|
bos.Add ("integer%integer", new BinOpStr (typeof (int), BinOpStrIntModInt, true));
|
|
bos.Add ("integer<<integer", new BinOpStr (typeof (int), BinOpStrIntShlInt, true));
|
|
bos.Add ("integer>>integer", new BinOpStr (typeof (int), BinOpStrIntShrInt, true));
|
|
}
|
|
|
|
private static void DefineBinOpsKeyX (Dictionary<string, BinOpStr> bos, string x)
|
|
{
|
|
bos.Add ("key==" + x, new BinOpStr (typeof (bool), BinOpStrKeyEqX));
|
|
bos.Add ("key!=" + x, new BinOpStr (typeof (bool), BinOpStrKeyNeX));
|
|
}
|
|
|
|
private static void DefineBinOpsXKey (Dictionary<string, BinOpStr> bos, string x)
|
|
{
|
|
bos.Add (x + "==key", new BinOpStr (typeof (bool), BinOpStrKeyEqX));
|
|
bos.Add (x + "!=key", new BinOpStr (typeof (bool), BinOpStrKeyNeX));
|
|
}
|
|
|
|
private static void DefineBinOpsList (Dictionary<string, BinOpStr> bos)
|
|
{
|
|
bos.Add ("list+float", new BinOpStr (typeof (LSL_List), BinOpStrListAddFloat, true));
|
|
bos.Add ("list+integer", new BinOpStr (typeof (LSL_List), BinOpStrListAddInt, true));
|
|
bos.Add ("list+key", new BinOpStr (typeof (LSL_List), BinOpStrListAddKey, true));
|
|
bos.Add ("list+list", new BinOpStr (typeof (LSL_List), BinOpStrListAddList, true));
|
|
bos.Add ("list+rotation", new BinOpStr (typeof (LSL_List), BinOpStrListAddRot, true));
|
|
bos.Add ("list+string", new BinOpStr (typeof (LSL_List), BinOpStrListAddStr, true));
|
|
bos.Add ("list+vector", new BinOpStr (typeof (LSL_List), BinOpStrListAddVec, true));
|
|
|
|
bos.Add ("float+list", new BinOpStr (typeof (LSL_List), BinOpStrFloatAddList));
|
|
bos.Add ("integer+list", new BinOpStr (typeof (LSL_List), BinOpStrIntAddList));
|
|
bos.Add ("key+list", new BinOpStr (typeof (LSL_List), BinOpStrKeyAddList));
|
|
bos.Add ("rotation+list", new BinOpStr (typeof (LSL_List), BinOpStrRotAddList));
|
|
bos.Add ("string+list", new BinOpStr (typeof (LSL_List), BinOpStrStrAddList));
|
|
bos.Add ("vector+list", new BinOpStr (typeof (LSL_List), BinOpStrVecAddList));
|
|
|
|
bos.Add ("list==list", new BinOpStr (typeof (bool), BinOpStrListEqList));
|
|
bos.Add ("list!=list", new BinOpStr (typeof (int), BinOpStrListNeList));
|
|
}
|
|
|
|
// all operations allowed by LSL_Rotation definition
|
|
private static void DefineBinOpsRotation (Dictionary<string, BinOpStr> bos)
|
|
{
|
|
bos.Add ("rotation==rotation", new BinOpStr (typeof (bool), BinOpStrRotEqRot));
|
|
bos.Add ("rotation!=rotation", new BinOpStr (typeof (bool), BinOpStrRotNeRot));
|
|
bos.Add ("rotation+rotation", new BinOpStr (typeof (LSL_Rotation), BinOpStrRotAddRot, true));
|
|
bos.Add ("rotation-rotation", new BinOpStr (typeof (LSL_Rotation), BinOpStrRotSubRot, true));
|
|
bos.Add ("rotation*rotation", new BinOpStr (typeof (LSL_Rotation), BinOpStrRotMulRot, true));
|
|
bos.Add ("rotation/rotation", new BinOpStr (typeof (LSL_Rotation), BinOpStrRotDivRot, true));
|
|
}
|
|
|
|
private static void DefineBinOpsString (Dictionary<string, BinOpStr> bos)
|
|
{
|
|
bos.Add ("string==string", new BinOpStr (typeof (bool), BinOpStrStrEqStr));
|
|
bos.Add ("string!=string", new BinOpStr (typeof (bool), BinOpStrStrNeStr));
|
|
bos.Add ("string<string", new BinOpStr (typeof (bool), BinOpStrStrLtStr));
|
|
bos.Add ("string<=string", new BinOpStr (typeof (bool), BinOpStrStrLeStr));
|
|
bos.Add ("string>string", new BinOpStr (typeof (bool), BinOpStrStrGtStr));
|
|
bos.Add ("string>=string", new BinOpStr (typeof (bool), BinOpStrStrGeStr));
|
|
bos.Add ("string+string", new BinOpStr (typeof (string), BinOpStrStrAddStr, true));
|
|
}
|
|
|
|
// all operations allowed by LSL_Vector definition
|
|
private static void DefineBinOpsVector (Dictionary<string, BinOpStr> bos)
|
|
{
|
|
bos.Add ("vector==vector", new BinOpStr (typeof (bool), BinOpStrVecEqVec));
|
|
bos.Add ("vector!=vector", new BinOpStr (typeof (bool), BinOpStrVecNeVec));
|
|
bos.Add ("vector+vector", new BinOpStr (typeof (LSL_Vector), BinOpStrVecAddVec, true));
|
|
bos.Add ("vector-vector", new BinOpStr (typeof (LSL_Vector), BinOpStrVecSubVec, true));
|
|
bos.Add ("vector*vector", new BinOpStr (typeof (double), BinOpStrVecMulVec));
|
|
bos.Add ("vector%vector", new BinOpStr (typeof (LSL_Vector), BinOpStrVecModVec, true));
|
|
|
|
bos.Add ("vector*float", new BinOpStr (typeof (LSL_Vector), BinOpStrVecMulFloat, true));
|
|
bos.Add ("float*vector", new BinOpStr (typeof (LSL_Vector), BinOpStrFloatMulVec));
|
|
bos.Add ("vector/float", new BinOpStr (typeof (LSL_Vector), BinOpStrVecDivFloat, true));
|
|
|
|
bos.Add ("vector*integer", new BinOpStr (typeof (LSL_Vector), BinOpStrVecMulInt, true));
|
|
bos.Add ("integer*vector", new BinOpStr (typeof (LSL_Vector), BinOpStrIntMulVec));
|
|
bos.Add ("vector/integer", new BinOpStr (typeof (LSL_Vector), BinOpStrVecDivInt, true));
|
|
|
|
bos.Add ("vector*rotation", new BinOpStr (typeof (LSL_Vector), BinOpStrVecMulRot, true));
|
|
bos.Add ("vector/rotation", new BinOpStr (typeof (LSL_Vector), BinOpStrVecDivRot, true));
|
|
}
|
|
|
|
/**
|
|
* @brief These methods actually emit the code to perform the arithmetic.
|
|
* @param scg = what script we are compiling
|
|
* @param left = left-hand operand location in memory (type as given by BinOpStr entry)
|
|
* @param right = right-hand operand location in memory (type as given by BinOpStr entry)
|
|
* @param result = result location in memory (type as given by BinOpStr entry)
|
|
*/
|
|
private static void BinOpStrAndAnd (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeBool);
|
|
right.PushVal (scg, errorAt, tokenTypeBool);
|
|
scg.ilGen.Emit (errorAt, OpCodes.And);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrOrOr (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeBool);
|
|
right.PushVal (scg, errorAt, tokenTypeBool);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Or);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrBoolOrX (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeInt);
|
|
right.PushVal (scg, errorAt, tokenTypeInt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Or);
|
|
result.PopPost (scg, errorAt, tokenTypeInt);
|
|
}
|
|
|
|
private static void BinOpStrBoolXorX (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeInt);
|
|
right.PushVal (scg, errorAt, tokenTypeInt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Xor);
|
|
result.PopPost (scg, errorAt, tokenTypeInt);
|
|
}
|
|
|
|
private static void BinOpStrBoolAndX (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeInt);
|
|
right.PushVal (scg, errorAt, tokenTypeInt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.And);
|
|
result.PopPost (scg, errorAt, tokenTypeInt);
|
|
}
|
|
|
|
private static void BinOpStrBoolEqX (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeBool);
|
|
right.PushVal (scg, errorAt, tokenTypeBool);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ceq);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrBoolNeX (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeBool);
|
|
right.PushVal (scg, errorAt, tokenTypeBool);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Xor);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrFloatEqX (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeFloat);
|
|
right.PushVal (scg, errorAt, tokenTypeFloat);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ceq);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrFloatNeX (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeFloat);
|
|
right.PushVal (scg, errorAt, tokenTypeFloat);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ceq);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4_1);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Xor);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrFloatLtX (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeFloat);
|
|
right.PushVal (scg, errorAt, tokenTypeFloat);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Clt);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrFloatLeX (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeFloat);
|
|
right.PushVal (scg, errorAt, tokenTypeFloat);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Cgt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4_1);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Xor);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrFloatGtX (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeFloat);
|
|
right.PushVal (scg, errorAt, tokenTypeFloat);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Cgt);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrFloatGeX (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeFloat);
|
|
right.PushVal (scg, errorAt, tokenTypeFloat);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Clt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4_1);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Xor);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrFloatAddX (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeFloat);
|
|
right.PushVal (scg, errorAt, tokenTypeFloat);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Add);
|
|
result.PopPost (scg, errorAt, tokenTypeFloat);
|
|
}
|
|
|
|
private static void BinOpStrFloatSubX (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeFloat);
|
|
right.PushVal (scg, errorAt, tokenTypeFloat);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Sub);
|
|
result.PopPost (scg, errorAt, tokenTypeFloat);
|
|
}
|
|
|
|
private static void BinOpStrFloatMulX (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeFloat);
|
|
right.PushVal (scg, errorAt, tokenTypeFloat);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Mul);
|
|
result.PopPost (scg, errorAt, tokenTypeFloat);
|
|
}
|
|
|
|
private static void BinOpStrFloatDivX (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeFloat);
|
|
right.PushVal (scg, errorAt, tokenTypeFloat);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Div);
|
|
result.PopPost (scg, errorAt, tokenTypeFloat);
|
|
}
|
|
|
|
private static void BinOpStrFloatModX (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeFloat);
|
|
right.PushVal (scg, errorAt, tokenTypeFloat);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Rem);
|
|
result.PopPost (scg, errorAt, tokenTypeFloat);
|
|
}
|
|
|
|
private static void BinOpStrXEqFloat (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeFloat);
|
|
right.PushVal (scg, errorAt, tokenTypeFloat);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ceq);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrXNeFloat (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeFloat);
|
|
right.PushVal (scg, errorAt, tokenTypeFloat);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ceq);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4_1);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Xor);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrXLtFloat (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeFloat);
|
|
right.PushVal (scg, errorAt, tokenTypeFloat);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Clt);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrXLeFloat (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeFloat);
|
|
right.PushVal (scg, errorAt, tokenTypeFloat);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Cgt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4_1);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Xor);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrXGtFloat (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeFloat);
|
|
right.PushVal (scg, errorAt, tokenTypeFloat);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Cgt);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrXGeFloat (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeFloat);
|
|
right.PushVal (scg, errorAt, tokenTypeFloat);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Clt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4_1);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Xor);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrXAddFloat (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeFloat);
|
|
right.PushVal (scg, errorAt, tokenTypeFloat);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Add);
|
|
result.PopPost (scg, errorAt, tokenTypeFloat);
|
|
}
|
|
|
|
private static void BinOpStrXSubFloat (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeFloat);
|
|
right.PushVal (scg, errorAt, tokenTypeFloat);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Sub);
|
|
result.PopPost (scg, errorAt, tokenTypeFloat);
|
|
}
|
|
|
|
private static void BinOpStrXMulFloat (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeFloat);
|
|
right.PushVal (scg, errorAt, tokenTypeFloat);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Mul);
|
|
result.PopPost (scg, errorAt, tokenTypeFloat);
|
|
}
|
|
|
|
private static void BinOpStrXDivFloat (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeFloat);
|
|
right.PushVal (scg, errorAt, tokenTypeFloat);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Div);
|
|
result.PopPost (scg, errorAt, tokenTypeFloat);
|
|
}
|
|
|
|
private static void BinOpStrXModFloat (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeFloat);
|
|
right.PushVal (scg, errorAt, tokenTypeFloat);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Rem);
|
|
result.PopPost (scg, errorAt, tokenTypeFloat);
|
|
}
|
|
|
|
private static void BinOpStrCharEqChar (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeChar);
|
|
right.PushVal (scg, errorAt, tokenTypeChar);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ceq);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrCharNeChar (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeChar);
|
|
right.PushVal (scg, errorAt, tokenTypeChar);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ceq);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4_1);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Xor);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrCharLtChar (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeChar);
|
|
right.PushVal (scg, errorAt, tokenTypeChar);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Clt);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrCharLeChar (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeChar);
|
|
right.PushVal (scg, errorAt, tokenTypeChar);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Cgt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4_1);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Xor);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrCharGtChar (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeChar);
|
|
right.PushVal (scg, errorAt, tokenTypeChar);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Cgt);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrCharGeChar (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeChar);
|
|
right.PushVal (scg, errorAt, tokenTypeChar);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Clt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4_1);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Xor);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrCharAddInt (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeChar);
|
|
right.PushVal (scg, errorAt, tokenTypeInt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Add);
|
|
result.PopPost (scg, errorAt, tokenTypeChar);
|
|
}
|
|
|
|
private static void BinOpStrCharSubInt (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeChar);
|
|
right.PushVal (scg, errorAt, tokenTypeInt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Sub);
|
|
result.PopPost (scg, errorAt, tokenTypeChar);
|
|
}
|
|
|
|
private static void BinOpStrCharSubChar (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeChar);
|
|
right.PushVal (scg, errorAt, tokenTypeChar);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Sub);
|
|
result.PopPost (scg, errorAt, tokenTypeInt);
|
|
}
|
|
|
|
private static void BinOpStrIntEqInt (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeInt);
|
|
right.PushVal (scg, errorAt, tokenTypeInt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ceq);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrIntNeInt (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeInt);
|
|
right.PushVal (scg, errorAt, tokenTypeInt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ceq);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4_1);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Xor);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrIntLtInt (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeInt);
|
|
right.PushVal (scg, errorAt, tokenTypeInt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Clt);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrIntLeInt (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeInt);
|
|
right.PushVal (scg, errorAt, tokenTypeInt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Cgt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4_1);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Xor);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrIntGtInt (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeInt);
|
|
right.PushVal (scg, errorAt, tokenTypeInt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Cgt);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrIntGeInt (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeInt);
|
|
right.PushVal (scg, errorAt, tokenTypeInt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Clt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4_1);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Xor);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrIntOrInt (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeInt);
|
|
right.PushVal (scg, errorAt, tokenTypeInt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Or);
|
|
result.PopPost (scg, errorAt, tokenTypeInt);
|
|
}
|
|
|
|
private static void BinOpStrIntXorInt (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeInt);
|
|
right.PushVal (scg, errorAt, tokenTypeInt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Xor);
|
|
result.PopPost (scg, errorAt, tokenTypeInt);
|
|
}
|
|
|
|
private static void BinOpStrIntAndInt (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeInt);
|
|
right.PushVal (scg, errorAt, tokenTypeInt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.And);
|
|
result.PopPost (scg, errorAt, tokenTypeInt);
|
|
}
|
|
|
|
private static void BinOpStrIntAddInt (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeInt);
|
|
right.PushVal (scg, errorAt, tokenTypeInt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Add);
|
|
result.PopPost (scg, errorAt, tokenTypeInt);
|
|
}
|
|
|
|
private static void BinOpStrIntSubInt (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeInt);
|
|
right.PushVal (scg, errorAt, tokenTypeInt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Sub);
|
|
result.PopPost (scg, errorAt, tokenTypeInt);
|
|
}
|
|
|
|
private static void BinOpStrIntMulInt (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeInt);
|
|
right.PushVal (scg, errorAt, tokenTypeInt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Mul);
|
|
result.PopPost (scg, errorAt, tokenTypeInt);
|
|
}
|
|
|
|
private static void BinOpStrIntDivInt (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
// note that we must allow 0x800000/-1 -> 0x80000000 for lslangtest1.lsl
|
|
// so sign-extend the operands to 64-bit then divide and truncate result
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeInt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Conv_I8);
|
|
right.PushVal (scg, errorAt, tokenTypeInt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Conv_I8);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Div);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Conv_I4);
|
|
result.PopPost (scg, errorAt, tokenTypeInt);
|
|
}
|
|
|
|
private static void BinOpStrIntModInt (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
// note that we must allow 0x800000%-1 -> 0 for lslangtest1.lsl
|
|
// so sign-extend the operands to 64-bit then mod and truncate result
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeInt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Conv_I8);
|
|
right.PushVal (scg, errorAt, tokenTypeInt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Conv_I8);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Rem);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Conv_I4);
|
|
result.PopPost (scg, errorAt, tokenTypeInt);
|
|
}
|
|
|
|
private static void BinOpStrIntShlInt (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeInt);
|
|
right.PushVal (scg, errorAt, tokenTypeInt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Shl);
|
|
result.PopPost (scg, errorAt, tokenTypeInt);
|
|
}
|
|
|
|
private static void BinOpStrIntShrInt (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeInt);
|
|
right.PushVal (scg, errorAt, tokenTypeInt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Shr);
|
|
result.PopPost (scg, errorAt, tokenTypeInt);
|
|
}
|
|
|
|
private static void BinOpStrKeyEqX (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeStr);
|
|
right.PushVal (scg, errorAt, tokenTypeStr);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, stringCmpStringMethInfo);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4_0);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ceq);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrKeyNeX (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeStr);
|
|
right.PushVal (scg, errorAt, tokenTypeStr);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, stringCmpStringMethInfo);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4_0);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ceq);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4_1);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Xor);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrListAddFloat (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeList);
|
|
right.PushVal (scg, errorAt, tokenTypeFloat);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethListAddFloat);
|
|
result.PopPost (scg, errorAt, tokenTypeList);
|
|
}
|
|
|
|
private static void BinOpStrListAddInt (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeList);
|
|
right.PushVal (scg, errorAt, tokenTypeInt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethListAddInt);
|
|
result.PopPost (scg, errorAt, tokenTypeList);
|
|
}
|
|
|
|
private static void BinOpStrListAddKey (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeList);
|
|
right.PushVal (scg, errorAt, tokenTypeStr);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethListAddKey);
|
|
result.PopPost (scg, errorAt, tokenTypeList);
|
|
}
|
|
|
|
private static void BinOpStrListAddList (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeList);
|
|
right.PushVal (scg, errorAt, tokenTypeList);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethListAddList);
|
|
result.PopPost (scg, errorAt, tokenTypeList);
|
|
}
|
|
|
|
private static void BinOpStrListAddRot (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeList);
|
|
right.PushVal (scg, errorAt, tokenTypeRot);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethListAddRot);
|
|
result.PopPost (scg, errorAt, tokenTypeList);
|
|
}
|
|
|
|
private static void BinOpStrListAddStr (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeList);
|
|
right.PushVal (scg, errorAt, tokenTypeStr);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethListAddStr);
|
|
result.PopPost (scg, errorAt, tokenTypeList);
|
|
}
|
|
|
|
private static void BinOpStrListAddVec (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeList);
|
|
right.PushVal (scg, errorAt, tokenTypeVec);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethListAddVec);
|
|
result.PopPost (scg, errorAt, tokenTypeList);
|
|
}
|
|
|
|
private static void BinOpStrFloatAddList (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeFloat);
|
|
right.PushVal (scg, errorAt, tokenTypeList);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethFloatAddList);
|
|
result.PopPost (scg, errorAt, tokenTypeList);
|
|
}
|
|
|
|
private static void BinOpStrIntAddList (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeInt);
|
|
right.PushVal (scg, errorAt, tokenTypeList);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethIntAddList);
|
|
result.PopPost (scg, errorAt, tokenTypeList);
|
|
}
|
|
|
|
private static void BinOpStrKeyAddList (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeStr);
|
|
right.PushVal (scg, errorAt, tokenTypeList);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethKeyAddList);
|
|
result.PopPost (scg, errorAt, tokenTypeList);
|
|
}
|
|
|
|
private static void BinOpStrRotAddList (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeRot);
|
|
right.PushVal (scg, errorAt, tokenTypeList);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethRotAddList);
|
|
result.PopPost (scg, errorAt, tokenTypeList);
|
|
}
|
|
|
|
private static void BinOpStrStrAddList (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeStr);
|
|
right.PushVal (scg, errorAt, tokenTypeList);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethStrAddList);
|
|
result.PopPost (scg, errorAt, tokenTypeList);
|
|
}
|
|
|
|
private static void BinOpStrVecAddList (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeVec);
|
|
right.PushVal (scg, errorAt, tokenTypeList);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethVecAddList);
|
|
result.PopPost (scg, errorAt, tokenTypeList);
|
|
}
|
|
|
|
private static void BinOpStrListEqList (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeList);
|
|
right.PushVal (scg, errorAt, tokenTypeList);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethListEqList);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrListNeList (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeList);
|
|
right.PushVal (scg, errorAt, tokenTypeList);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethListNeList);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrRotEqRot (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeRot);
|
|
right.PushVal (scg, errorAt, tokenTypeRot);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethRotEqRot);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrRotNeRot (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeRot);
|
|
right.PushVal (scg, errorAt, tokenTypeRot);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethRotNeRot);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrRotAddRot (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeRot);
|
|
right.PushVal (scg, errorAt, tokenTypeRot);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethRotAddRot);
|
|
result.PopPost (scg, errorAt, tokenTypeRot);
|
|
}
|
|
|
|
private static void BinOpStrRotSubRot (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeRot);
|
|
right.PushVal (scg, errorAt, tokenTypeRot);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethRotSubRot);
|
|
result.PopPost (scg, errorAt, tokenTypeRot);
|
|
}
|
|
|
|
private static void BinOpStrRotMulRot (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeRot);
|
|
right.PushVal (scg, errorAt, tokenTypeRot);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethRotMulRot);
|
|
result.PopPost (scg, errorAt, tokenTypeRot);
|
|
}
|
|
|
|
private static void BinOpStrRotDivRot (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeRot);
|
|
right.PushVal (scg, errorAt, tokenTypeRot);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethRotDivRot);
|
|
result.PopPost (scg, errorAt, tokenTypeRot);
|
|
}
|
|
|
|
private static void BinOpStrStrEqStr (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeStr);
|
|
right.PushVal (scg, errorAt, tokenTypeStr);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, stringCmpStringMethInfo);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4_0);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ceq);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrStrNeStr (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeStr);
|
|
right.PushVal (scg, errorAt, tokenTypeStr);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, stringCmpStringMethInfo);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4_0);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ceq);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4_1);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Xor);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrStrLtStr (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeStr);
|
|
right.PushVal (scg, errorAt, tokenTypeStr);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, stringCmpStringMethInfo);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4_0);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Clt);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrStrLeStr (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeStr);
|
|
right.PushVal (scg, errorAt, tokenTypeStr);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, stringCmpStringMethInfo);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4_1);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Clt);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrStrGtStr (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeStr);
|
|
right.PushVal (scg, errorAt, tokenTypeStr);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, stringCmpStringMethInfo);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4_0);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Cgt);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrStrGeStr (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeStr);
|
|
right.PushVal (scg, errorAt, tokenTypeStr);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, stringCmpStringMethInfo);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Ldc_I4_M1);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Cgt);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
// Called by many type combinations so both operands need to be cast to strings
|
|
private static void BinOpStrStrAddStr (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeStr);
|
|
right.PushVal (scg, errorAt, tokenTypeStr);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, stringAddStringMethInfo);
|
|
result.PopPost (scg, errorAt, tokenTypeStr);
|
|
}
|
|
|
|
private static void BinOpStrVecEqVec (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeVec);
|
|
right.PushVal (scg, errorAt, tokenTypeVec);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethVecEqVec);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrVecNeVec (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeVec);
|
|
right.PushVal (scg, errorAt, tokenTypeVec);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethVecNeVec);
|
|
result.PopPost (scg, errorAt, tokenTypeBool);
|
|
}
|
|
|
|
private static void BinOpStrVecAddVec (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeVec);
|
|
right.PushVal (scg, errorAt, tokenTypeVec);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethVecAddVec);
|
|
result.PopPost (scg, errorAt, tokenTypeVec);
|
|
}
|
|
|
|
private static void BinOpStrVecSubVec (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeVec);
|
|
right.PushVal (scg, errorAt, tokenTypeVec);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethVecSubVec);
|
|
result.PopPost (scg, errorAt, tokenTypeVec);
|
|
}
|
|
|
|
private static void BinOpStrVecMulVec (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeVec);
|
|
right.PushVal (scg, errorAt, tokenTypeVec);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethVecMulVec);
|
|
result.PopPost (scg, errorAt, tokenTypeFloat);
|
|
}
|
|
|
|
private static void BinOpStrVecModVec (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeVec);
|
|
right.PushVal (scg, errorAt, tokenTypeVec);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethVecModVec);
|
|
result.PopPost (scg, errorAt, tokenTypeVec);
|
|
}
|
|
|
|
private static void BinOpStrVecMulFloat (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeVec);
|
|
right.PushVal (scg, errorAt, tokenTypeFloat);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethVecMulFloat);
|
|
result.PopPost (scg, errorAt, tokenTypeVec);
|
|
}
|
|
|
|
private static void BinOpStrFloatMulVec (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeFloat);
|
|
right.PushVal (scg, errorAt, tokenTypeVec);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethFloatMulVec);
|
|
result.PopPost (scg, errorAt, tokenTypeVec);
|
|
}
|
|
|
|
private static void BinOpStrVecDivFloat (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeVec);
|
|
right.PushVal (scg, errorAt, tokenTypeFloat);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethVecDivFloat);
|
|
result.PopPost (scg, errorAt, tokenTypeVec);
|
|
}
|
|
|
|
private static void BinOpStrVecMulInt (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeVec);
|
|
right.PushVal (scg, errorAt, tokenTypeInt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethVecMulInt);
|
|
result.PopPost (scg, errorAt, tokenTypeVec);
|
|
}
|
|
|
|
private static void BinOpStrIntMulVec (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeInt);
|
|
right.PushVal (scg, errorAt, tokenTypeVec);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethIntMulVec);
|
|
result.PopPost (scg, errorAt, tokenTypeVec);
|
|
}
|
|
|
|
private static void BinOpStrVecDivInt (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeVec);
|
|
right.PushVal (scg, errorAt, tokenTypeInt);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethVecDivInt);
|
|
result.PopPost (scg, errorAt, tokenTypeVec);
|
|
}
|
|
|
|
private static void BinOpStrVecMulRot (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeVec);
|
|
right.PushVal (scg, errorAt, tokenTypeRot);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethVecMulRot);
|
|
result.PopPost (scg, errorAt, tokenTypeVec);
|
|
}
|
|
|
|
private static void BinOpStrVecDivRot (ScriptCodeGen scg, Token errorAt, CompValu left, CompValu right, CompValu result)
|
|
{
|
|
result.PopPre (scg, errorAt);
|
|
left.PushVal (scg, errorAt, tokenTypeVec);
|
|
right.PushVal (scg, errorAt, tokenTypeRot);
|
|
scg.ilGen.Emit (errorAt, OpCodes.Call, infoMethVecDivRot);
|
|
result.PopPost (scg, errorAt, tokenTypeVec);
|
|
}
|
|
|
|
/**
|
|
* @brief These methods are called at runtime as helpers.
|
|
* Needed to pick up functionality defined by overloaded operators of LSL_ types.
|
|
* They need to be marked public or runtime says they are inaccessible.
|
|
*/
|
|
public static LSL_List MethListAddFloat (LSL_List left, double right)
|
|
{
|
|
return MethListAddObj (left, new LSL_Float (right));
|
|
}
|
|
public static LSL_List MethListAddInt (LSL_List left, int right)
|
|
{
|
|
return MethListAddObj (left, new LSL_Integer (right));
|
|
}
|
|
public static LSL_List MethListAddKey (LSL_List left, string right)
|
|
{
|
|
return MethListAddObj (left, new LSL_Key (right));
|
|
}
|
|
public static LSL_List MethListAddRot (LSL_List left, LSL_Rotation right)
|
|
{
|
|
return MethListAddObj (left, right);
|
|
}
|
|
public static LSL_List MethListAddStr (LSL_List left, string right)
|
|
{
|
|
return MethListAddObj (left, new LSL_String (right));
|
|
}
|
|
public static LSL_List MethListAddVec (LSL_List left, LSL_Vector right)
|
|
{
|
|
return MethListAddObj (left, right);
|
|
}
|
|
public static LSL_List MethListAddObj (LSL_List left, object right)
|
|
{
|
|
int oldlen = left.Length;
|
|
object[] newarr = new object[oldlen+1];
|
|
Array.Copy (left.Data, newarr, oldlen);
|
|
newarr[oldlen] = right;
|
|
return new LSL_List (newarr);
|
|
}
|
|
|
|
public static LSL_List MethListAddList (LSL_List left, LSL_List right)
|
|
{
|
|
int leftlen = left.Length;
|
|
int ritelen = right.Length;
|
|
object[] newarr = new object[leftlen+ritelen];
|
|
Array.Copy (left.Data, newarr, leftlen);
|
|
Array.Copy (right.Data, 0, newarr, leftlen, ritelen);
|
|
return new LSL_List (newarr);
|
|
}
|
|
|
|
public static LSL_List MethFloatAddList (double left, LSL_List right)
|
|
{
|
|
return MethObjAddList (new LSL_Float (left), right);
|
|
}
|
|
public static LSL_List MethIntAddList (int left, LSL_List right)
|
|
{
|
|
return MethObjAddList (new LSL_Integer (left), right);
|
|
}
|
|
public static LSL_List MethKeyAddList (string left, LSL_List right)
|
|
{
|
|
return MethObjAddList (new LSL_Key (left), right);
|
|
}
|
|
public static LSL_List MethRotAddList (LSL_Rotation left, LSL_List right)
|
|
{
|
|
return MethObjAddList (left, right);
|
|
}
|
|
public static LSL_List MethStrAddList (string left, LSL_List right)
|
|
{
|
|
return MethObjAddList (new LSL_String (left), right);
|
|
}
|
|
public static LSL_List MethVecAddList (LSL_Vector left, LSL_List right)
|
|
{
|
|
return MethObjAddList (left, right);
|
|
}
|
|
public static LSL_List MethObjAddList (object left, LSL_List right)
|
|
{
|
|
int oldlen = right.Length;
|
|
object[] newarr = new object[oldlen+1];
|
|
newarr[0] = left;
|
|
Array.Copy (right.Data, 0, newarr, 1, oldlen);
|
|
return new LSL_List (newarr);
|
|
}
|
|
|
|
public static bool MethListEqList (LSL_List left, LSL_List right)
|
|
{
|
|
return left == right;
|
|
}
|
|
|
|
// According to http://wiki.secondlife.com/wiki/LlGetListLength
|
|
// jackassed LSL allows 'somelist != []' to get the length of a list
|
|
public static int MethListNeList (LSL_List left, LSL_List right)
|
|
{
|
|
int leftlen = left.Length;
|
|
int ritelen = right.Length;
|
|
return leftlen - ritelen;
|
|
}
|
|
|
|
public static bool MethRotEqRot (LSL_Rotation left, LSL_Rotation right)
|
|
{
|
|
return left == right;
|
|
}
|
|
|
|
public static bool MethRotNeRot (LSL_Rotation left, LSL_Rotation right)
|
|
{
|
|
return left != right;
|
|
}
|
|
|
|
public static LSL_Rotation MethRotAddRot (LSL_Rotation left, LSL_Rotation right)
|
|
{
|
|
return left + right;
|
|
}
|
|
|
|
public static LSL_Rotation MethRotSubRot (LSL_Rotation left, LSL_Rotation right)
|
|
{
|
|
return left - right;
|
|
}
|
|
|
|
public static LSL_Rotation MethRotMulRot (LSL_Rotation left, LSL_Rotation right)
|
|
{
|
|
return left * right;
|
|
}
|
|
|
|
public static LSL_Rotation MethRotDivRot (LSL_Rotation left, LSL_Rotation right)
|
|
{
|
|
return left / right;
|
|
}
|
|
|
|
public static bool MethVecEqVec (LSL_Vector left, LSL_Vector right)
|
|
{
|
|
return left == right;
|
|
}
|
|
|
|
public static bool MethVecNeVec (LSL_Vector left, LSL_Vector right)
|
|
{
|
|
return left != right;
|
|
}
|
|
|
|
public static LSL_Vector MethVecAddVec (LSL_Vector left, LSL_Vector right)
|
|
{
|
|
return left + right;
|
|
}
|
|
|
|
public static LSL_Vector MethVecSubVec (LSL_Vector left, LSL_Vector right)
|
|
{
|
|
return left - right;
|
|
}
|
|
|
|
public static double MethVecMulVec (LSL_Vector left, LSL_Vector right)
|
|
{
|
|
return (double)(left * right).value;
|
|
}
|
|
|
|
public static LSL_Vector MethVecModVec (LSL_Vector left, LSL_Vector right)
|
|
{
|
|
return left % right;
|
|
}
|
|
|
|
public static LSL_Vector MethVecMulFloat (LSL_Vector left, double right)
|
|
{
|
|
return left * right;
|
|
}
|
|
|
|
public static LSL_Vector MethFloatMulVec (double left, LSL_Vector right)
|
|
{
|
|
return left * right;
|
|
}
|
|
|
|
public static LSL_Vector MethVecDivFloat (LSL_Vector left, double right)
|
|
{
|
|
return left / right;
|
|
}
|
|
|
|
public static LSL_Vector MethVecMulInt (LSL_Vector left, int right)
|
|
{
|
|
return left * right;
|
|
}
|
|
|
|
public static LSL_Vector MethIntMulVec (int left, LSL_Vector right)
|
|
{
|
|
return left * right;
|
|
}
|
|
|
|
public static LSL_Vector MethVecDivInt (LSL_Vector left, int right)
|
|
{
|
|
return left / right;
|
|
}
|
|
|
|
public static LSL_Vector MethVecMulRot (LSL_Vector left, LSL_Rotation right)
|
|
{
|
|
return left * right;
|
|
}
|
|
|
|
public static LSL_Vector MethVecDivRot (LSL_Vector left, LSL_Rotation right)
|
|
{
|
|
return left / right;
|
|
}
|
|
}
|
|
}
|