/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSimulator Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using OpenSim.Region.ScriptEngine.Shared.ScriptBase;
using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using System.Reflection.Emit;
using System.Text;
using LSL_Float = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLFloat;
using LSL_Integer = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLInteger;
using LSL_Key = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLString;
using LSL_List = OpenSim.Region.ScriptEngine.Shared.LSL_Types.list;
using LSL_Rotation = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Quaternion;
using LSL_String = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLString;
using LSL_Vector = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Vector3;
/**
* @brief Wrapper class for ILGenerator.
* It writes the object code to a file and can then make real ILGenerator calls
* based on the file's contents.
*/
namespace OpenSim.Region.ScriptEngine.Yengine
{
public enum ScriptObjWriterCode: byte
{
BegMethod, EndMethod, TheEnd,
DclLabel, DclLocal, DclMethod, MarkLabel,
EmitNull, EmitField, EmitLocal, EmitType, EmitLabel, EmitMethodExt,
EmitMethodInt, EmitCtor, EmitDouble, EmitFloat, EmitInteger, EmitString,
EmitLabels,
BegExcBlk, BegCatBlk, BegFinBlk, EndExcBlk
}
public class ScriptObjWriter: ScriptMyILGen
{
private static Dictionary<short, OpCode> opCodes = PopulateOpCodes();
private static Dictionary<string, Type> string2Type = PopulateS2T();
private static Dictionary<Type, string> type2String = PopulateT2S();
private static MethodInfo monoGetCurrentOffset = typeof(ILGenerator).GetMethod("Mono_GetCurrentOffset",
BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null,
new Type[] { typeof(ILGenerator) }, null);
private static readonly OpCode[] opCodesLdcI4M1P8 = new OpCode[] {
OpCodes.Ldc_I4_M1, OpCodes.Ldc_I4_0, OpCodes.Ldc_I4_1, OpCodes.Ldc_I4_2, OpCodes.Ldc_I4_3,
OpCodes.Ldc_I4_4, OpCodes.Ldc_I4_5, OpCodes.Ldc_I4_6, OpCodes.Ldc_I4_7, OpCodes.Ldc_I4_8
};
private BinaryWriter objFileWriter;
private string lastErrorAtFile = "";
private int lastErrorAtLine = 0;
private int lastErrorAtPosn = 0;
private Dictionary<Type, string> sdTypesRev = new Dictionary<Type, string>();
public int labelNumber = 0;
public int localNumber = 0;
private string _methName;
public string methName
{
get
{
return _methName;
}
}
public Type retType;
public Type[] argTypes;
/**
* @brief Begin function declaration
* @param sdTypes = script-defined types
* @param methName = name of the method being declared, eg, "Verify(array,list,string)"
* @param retType = its return value type
* @param argTypes[] = its argument types
* @param objFileWriter = file to write its object code to
*
* After calling this function, the following functions should be called:
* this.BegMethod ();
* this.<as required> ();
* this.EndMethod ();
*
* The design of this object is such that many constructors may be called,
* but once a BegMethod() is called for one of the objects, no method may
* called for any of the other objects until EndMethod() is called (or it
* would break up the object stream for that method). But we need to have
* many constructors possible so we get function headers at the beginning
* of the object file in case there are forward references to the functions.
*/
public ScriptObjWriter(TokenScript tokenScript, string methName, Type retType, Type[] argTypes, string[] argNames, BinaryWriter objFileWriter)
{
this._methName = methName;
this.retType = retType;
this.argTypes = argTypes;
this.objFileWriter = objFileWriter;
// Build list that translates system-defined types to script defined types.
foreach(TokenDeclSDType sdt in tokenScript.sdSrcTypesValues)
{
Type sys = sdt.GetSysType();
if(sys != null)
sdTypesRev[sys] = sdt.longName.val;
}
// This tells the reader to call 'new DynamicMethod()' to create
// the function header. Then any forward reference calls to this
// method will have a MethodInfo struct to call.
objFileWriter.Write((byte)ScriptObjWriterCode.DclMethod);
objFileWriter.Write(methName);
objFileWriter.Write(GetStrFromType(retType));
int nArgs = argTypes.Length;
objFileWriter.Write(nArgs);
for(int i = 0; i < nArgs; i++)
{
objFileWriter.Write(GetStrFromType(argTypes[i]));
objFileWriter.Write(argNames[i]);
}
}
/**
* @brief Begin outputting object code for the function
*/
public void BegMethod()
{
// This tells the reader to call methodInfo.GetILGenerator()
// so it can start writing CIL code for the method.
objFileWriter.Write((byte)ScriptObjWriterCode.BegMethod);
objFileWriter.Write(methName);
}
/**
* @brief End of object code for the function
*/
public void EndMethod()
{
// This tells the reader that all code for the method has
// been written and so it will typically call CreateDelegate()
// to finalize the method and create an entrypoint.
objFileWriter.Write((byte)ScriptObjWriterCode.EndMethod);
objFileWriter = null;
}
/**
* @brief Declare a local variable for use by the function
*/
public ScriptMyLocal DeclareLocal(Type type, string name)
{
ScriptMyLocal myLocal = new ScriptMyLocal();
myLocal.type = type;
myLocal.name = name;
myLocal.number = localNumber++;
myLocal.isReferenced = true; // so ScriptCollector won't optimize references away
return DeclareLocal(myLocal);
}
public ScriptMyLocal DeclareLocal(ScriptMyLocal myLocal)
{
objFileWriter.Write((byte)ScriptObjWriterCode.DclLocal);
objFileWriter.Write(myLocal.number);
objFileWriter.Write(myLocal.name);
objFileWriter.Write(GetStrFromType(myLocal.type));
return myLocal;
}
/**
* @brief Define a label for use by the function
*/
public ScriptMyLabel DefineLabel(string name)
{
ScriptMyLabel myLabel = new ScriptMyLabel();
myLabel.name = name;
myLabel.number = labelNumber++;
return DefineLabel(myLabel);
}
public ScriptMyLabel DefineLabel(ScriptMyLabel myLabel)
{
objFileWriter.Write((byte)ScriptObjWriterCode.DclLabel);
objFileWriter.Write(myLabel.number);
objFileWriter.Write(myLabel.name);
return myLabel;
}
/**
* @brief try/catch blocks.
*/
public void BeginExceptionBlock()
{
objFileWriter.Write((byte)ScriptObjWriterCode.BegExcBlk);
}
public void BeginCatchBlock(Type excType)
{
objFileWriter.Write((byte)ScriptObjWriterCode.BegCatBlk);
objFileWriter.Write(GetStrFromType(excType));
}
public void BeginFinallyBlock()
{
objFileWriter.Write((byte)ScriptObjWriterCode.BegFinBlk);
}
public void EndExceptionBlock()
{
objFileWriter.Write((byte)ScriptObjWriterCode.EndExcBlk);
}
public void Emit(Token errorAt, OpCode opcode)
{
objFileWriter.Write((byte)ScriptObjWriterCode.EmitNull);
WriteOpCode(errorAt, opcode);
}
public void Emit(Token errorAt, OpCode opcode, FieldInfo field)
{
objFileWriter.Write((byte)ScriptObjWriterCode.EmitField);
WriteOpCode(errorAt, opcode);
objFileWriter.Write(GetStrFromType(field.ReflectedType));
objFileWriter.Write(field.Name);
}
public void Emit(Token errorAt, OpCode opcode, ScriptMyLocal myLocal)
{
objFileWriter.Write((byte)ScriptObjWriterCode.EmitLocal);
WriteOpCode(errorAt, opcode);
objFileWriter.Write(myLocal.number);
}
public void Emit(Token errorAt, OpCode opcode, Type type)
{
objFileWriter.Write((byte)ScriptObjWriterCode.EmitType);
WriteOpCode(errorAt, opcode);
objFileWriter.Write(GetStrFromType(type));
}
public void Emit(Token errorAt, OpCode opcode, ScriptMyLabel myLabel)
{
objFileWriter.Write((byte)ScriptObjWriterCode.EmitLabel);
WriteOpCode(errorAt, opcode);
objFileWriter.Write(myLabel.number);
}
public void Emit(Token errorAt, OpCode opcode, ScriptMyLabel[] myLabels)
{
objFileWriter.Write((byte)ScriptObjWriterCode.EmitLabels);
WriteOpCode(errorAt, opcode);
int nLabels = myLabels.Length;
objFileWriter.Write(nLabels);
for(int i = 0; i < nLabels; i++)
{
objFileWriter.Write(myLabels[i].number);
}
}
public void Emit(Token errorAt, OpCode opcode, ScriptObjWriter method)
{
if(method == null)
throw new ArgumentNullException("method");
objFileWriter.Write((byte)ScriptObjWriterCode.EmitMethodInt);
WriteOpCode(errorAt, opcode);
objFileWriter.Write(method.methName);
}
public void Emit(Token errorAt, OpCode opcode, MethodInfo method)
{
objFileWriter.Write((byte)ScriptObjWriterCode.EmitMethodExt);
WriteOpCode(errorAt, opcode);
objFileWriter.Write(method.Name);
objFileWriter.Write(GetStrFromType(method.ReflectedType));
ParameterInfo[] parms = method.GetParameters();
int nArgs = parms.Length;
objFileWriter.Write(nArgs);
for(int i = 0; i < nArgs; i++)
{
objFileWriter.Write(GetStrFromType(parms[i].ParameterType));
}
}
public void Emit(Token errorAt, OpCode opcode, ConstructorInfo ctor)
{
objFileWriter.Write((byte)ScriptObjWriterCode.EmitCtor);
WriteOpCode(errorAt, opcode);
objFileWriter.Write(GetStrFromType(ctor.ReflectedType));
ParameterInfo[] parms = ctor.GetParameters();
int nArgs = parms.Length;
objFileWriter.Write(nArgs);
for(int i = 0; i < nArgs; i++)
{
objFileWriter.Write(GetStrFromType(parms[i].ParameterType));
}
}
public void Emit(Token errorAt, OpCode opcode, double value)
{
if(opcode != OpCodes.Ldc_R8)
{
throw new Exception("bad opcode " + opcode.ToString());
}
objFileWriter.Write((byte)ScriptObjWriterCode.EmitDouble);
WriteOpCode(errorAt, opcode);
objFileWriter.Write(value);
}
public void Emit(Token errorAt, OpCode opcode, float value)
{
if(opcode != OpCodes.Ldc_R4)
{
throw new Exception("bad opcode " + opcode.ToString());
}
objFileWriter.Write((byte)ScriptObjWriterCode.EmitFloat);
WriteOpCode(errorAt, opcode);
objFileWriter.Write(value);
}
public void Emit(Token errorAt, OpCode opcode, int value)
{
objFileWriter.Write((byte)ScriptObjWriterCode.EmitInteger);
WriteOpCode(errorAt, opcode);
objFileWriter.Write(value);
}
public void Emit(Token errorAt, OpCode opcode, string value)
{
objFileWriter.Write((byte)ScriptObjWriterCode.EmitString);
WriteOpCode(errorAt, opcode);
objFileWriter.Write(value);
}
/**
* @brief Declare that the target of a label is the next instruction.
*/
public void MarkLabel(ScriptMyLabel myLabel)
{
objFileWriter.Write((byte)ScriptObjWriterCode.MarkLabel);
objFileWriter.Write(myLabel.number);
}
/**
* @brief Write end-of-file marker to binary file.
*/
public static void TheEnd(BinaryWriter objFileWriter)
{
objFileWriter.Write((byte)ScriptObjWriterCode.TheEnd);
}
/**
* @brief Take an object file created by ScriptObjWriter() and convert it to a series of dynamic methods.
* @param sdTypes = script-defined types
* @param objReader = where to read object file from (as written by ScriptObjWriter above).
* @param scriptObjCode.EndMethod = called for each method defined at the end of the methods definition
* @param objectTokens = write disassemble/decompile data (or null if not wanted)
*/
public static void CreateObjCode(Dictionary<string, TokenDeclSDType> sdTypes, BinaryReader objReader,
ScriptObjCode scriptObjCode, ObjectTokens objectTokens)
{
Dictionary<string, DynamicMethod> methods = new Dictionary<string, DynamicMethod>();
DynamicMethod method = null;
ILGenerator ilGen = null;
Dictionary<int, Label> labels = new Dictionary<int, Label>();
Dictionary<int, LocalBuilder> locals = new Dictionary<int, LocalBuilder>();
Dictionary<int, string> labelNames = new Dictionary<int, string>();
Dictionary<int, string> localNames = new Dictionary<int, string>();
object[] ilGenArg = new object[1];
int offset = 0;
Dictionary<int, ScriptSrcLoc> srcLocs = null;
string srcFile = "";
int srcLine = 0;
int srcPosn = 0;
while(true)
{
// Get IL instruction offset at beginning of instruction.
offset = 0;
if((ilGen != null) && (monoGetCurrentOffset != null))
{
offset = (int)monoGetCurrentOffset.Invoke(null, ilGenArg);
}
// Read and decode next internal format code from input file (.xmrobj file).
ScriptObjWriterCode code = (ScriptObjWriterCode)objReader.ReadByte();
switch(code)
{
// Reached end-of-file so we are all done.
case ScriptObjWriterCode.TheEnd:
return;
// Beginning of method's contents.
// Method must have already been declared via DclMethod
// so all we need is its name to retrieve from methods[].
case ScriptObjWriterCode.BegMethod:
{
string methName = objReader.ReadString();
method = methods[methName];
ilGen = method.GetILGenerator();
ilGenArg[0] = ilGen;
labels.Clear();
locals.Clear();
labelNames.Clear();
localNames.Clear();
srcLocs = new Dictionary<int, ScriptSrcLoc>();
if(objectTokens != null)
objectTokens.BegMethod(method);
break;
}
// End of method's contents (ie, an OpCodes.Ret was probably just output).
// Call the callback to tell it the method is complete, and it can do whatever
// it wants with the method.
case ScriptObjWriterCode.EndMethod:
{
ilGen = null;
ilGenArg[0] = null;
scriptObjCode.EndMethod(method, srcLocs);
srcLocs = null;
if(objectTokens != null)
objectTokens.EndMethod();
break;
}
// Declare a label for branching to.
case ScriptObjWriterCode.DclLabel:
{
int number = objReader.ReadInt32();
string name = objReader.ReadString();
labels.Add(number, ilGen.DefineLabel());
labelNames.Add(number, name + "_" + number.ToString());
if(objectTokens != null)
objectTokens.DefineLabel(number, name);
break;
}
// Declare a local variable to store into.
case ScriptObjWriterCode.DclLocal:
{
int number = objReader.ReadInt32();
string name = objReader.ReadString();
string type = objReader.ReadString();
Type syType = GetTypeFromStr(sdTypes, type);
locals.Add(number, ilGen.DeclareLocal(syType));
localNames.Add(number, name + "_" + number.ToString());
if(objectTokens != null)
objectTokens.DefineLocal(number, name, type, syType);
break;
}
// Declare a method that will subsequently be defined.
// We create the DynamicMethod object at this point in case there
// are forward references from other method bodies.
case ScriptObjWriterCode.DclMethod:
{
string methName = objReader.ReadString();
Type retType = GetTypeFromStr(sdTypes, objReader.ReadString());
int nArgs = objReader.ReadInt32();
Type[] argTypes = new Type[nArgs];
string[] argNames = new string[nArgs];
for(int i = 0; i < nArgs; i++)
{
argTypes[i] = GetTypeFromStr(sdTypes, objReader.ReadString());
argNames[i] = objReader.ReadString();
}
methods.Add(methName, new DynamicMethod(methName, retType, argTypes));
if(objectTokens != null)
objectTokens.DefineMethod(methName, retType, argTypes, argNames);
break;
}
// Mark a previously declared label at this spot.
case ScriptObjWriterCode.MarkLabel:
{
int number = objReader.ReadInt32();
ilGen.MarkLabel(labels[number]);
if(objectTokens != null)
objectTokens.MarkLabel(offset, number);
break;
}
// Try/Catch blocks.
case ScriptObjWriterCode.BegExcBlk:
{
ilGen.BeginExceptionBlock();
if(objectTokens != null)
objectTokens.BegExcBlk(offset);
break;
}
case ScriptObjWriterCode.BegCatBlk:
{
Type excType = GetTypeFromStr(sdTypes, objReader.ReadString());
ilGen.BeginCatchBlock(excType);
if(objectTokens != null)
objectTokens.BegCatBlk(offset, excType);
break;
}
case ScriptObjWriterCode.BegFinBlk:
{
ilGen.BeginFinallyBlock();
if(objectTokens != null)
objectTokens.BegFinBlk(offset);
break;
}
case ScriptObjWriterCode.EndExcBlk:
{
ilGen.EndExceptionBlock();
if(objectTokens != null)
objectTokens.EndExcBlk(offset);
break;
}
// Emit an opcode with no operand.
case ScriptObjWriterCode.EmitNull:
{
OpCode opCode = ReadOpCode(objReader, ref srcFile, ref srcLine, ref srcPosn);
SaveSrcLoc(srcLocs, offset, srcFile, srcLine, srcPosn);
ilGen.Emit(opCode);
if(objectTokens != null)
objectTokens.EmitNull(offset, opCode);
break;
}
// Emit an opcode with a FieldInfo operand.
case ScriptObjWriterCode.EmitField:
{
OpCode opCode = ReadOpCode(objReader, ref srcFile, ref srcLine, ref srcPosn);
Type reflectedType = GetTypeFromStr(sdTypes, objReader.ReadString());
string fieldName = objReader.ReadString();
FieldInfo field = reflectedType.GetField(fieldName);
SaveSrcLoc(srcLocs, offset, srcFile, srcLine, srcPosn);
ilGen.Emit(opCode, field);
if(objectTokens != null)
objectTokens.EmitField(offset, opCode, field);
break;
}
// Emit an opcode with a LocalBuilder operand.
case ScriptObjWriterCode.EmitLocal:
{
OpCode opCode = ReadOpCode(objReader, ref srcFile, ref srcLine, ref srcPosn);
int number = objReader.ReadInt32();
SaveSrcLoc(srcLocs, offset, srcFile, srcLine, srcPosn);
ilGen.Emit(opCode, locals[number]);
if(objectTokens != null)
objectTokens.EmitLocal(offset, opCode, number);
break;
}
// Emit an opcode with a Type operand.
case ScriptObjWriterCode.EmitType:
{
OpCode opCode = ReadOpCode(objReader, ref srcFile, ref srcLine, ref srcPosn);
string name = objReader.ReadString();
Type type = GetTypeFromStr(sdTypes, name);
SaveSrcLoc(srcLocs, offset, srcFile, srcLine, srcPosn);
ilGen.Emit(opCode, type);
if(objectTokens != null)
objectTokens.EmitType(offset, opCode, type);
break;
}
// Emit an opcode with a Label operand.
case ScriptObjWriterCode.EmitLabel:
{
OpCode opCode = ReadOpCode(objReader, ref srcFile, ref srcLine, ref srcPosn);
int number = objReader.ReadInt32();
SaveSrcLoc(srcLocs, offset, srcFile, srcLine, srcPosn);
ilGen.Emit(opCode, labels[number]);
if(objectTokens != null)
objectTokens.EmitLabel(offset, opCode, number);
break;
}
// Emit an opcode with a Label array operand.
case ScriptObjWriterCode.EmitLabels:
{
OpCode opCode = ReadOpCode(objReader, ref srcFile, ref srcLine, ref srcPosn);
int nLabels = objReader.ReadInt32();
Label[] lbls = new Label[nLabels];
int[] nums = new int[nLabels];
for(int i = 0; i < nLabels; i++)
{
nums[i] = objReader.ReadInt32();
lbls[i] = labels[nums[i]];
}
SaveSrcLoc(srcLocs, offset, srcFile, srcLine, srcPosn);
ilGen.Emit(opCode, lbls);
if(objectTokens != null)
objectTokens.EmitLabels(offset, opCode, nums);
break;
}
// Emit an opcode with a MethodInfo operand (such as a call) of an external function.
case ScriptObjWriterCode.EmitMethodExt:
{
OpCode opCode = ReadOpCode(objReader, ref srcFile, ref srcLine, ref srcPosn);
string methName = objReader.ReadString();
Type methType = GetTypeFromStr(sdTypes, objReader.ReadString());
int nArgs = objReader.ReadInt32();
Type[] argTypes = new Type[nArgs];
for(int i = 0; i < nArgs; i++)
{
argTypes[i] = GetTypeFromStr(sdTypes, objReader.ReadString());
}
MethodInfo methInfo = methType.GetMethod(methName, argTypes);
SaveSrcLoc(srcLocs, offset, srcFile, srcLine, srcPosn);
ilGen.Emit(opCode, methInfo);
if(objectTokens != null)
objectTokens.EmitMethod(offset, opCode, methInfo);
break;
}
// Emit an opcode with a MethodInfo operand of an internal function
// (previously declared via DclMethod).
case ScriptObjWriterCode.EmitMethodInt:
{
OpCode opCode = ReadOpCode(objReader, ref srcFile, ref srcLine, ref srcPosn);
string methName = objReader.ReadString();
MethodInfo methInfo = methods[methName];
SaveSrcLoc(srcLocs, offset, srcFile, srcLine, srcPosn);
ilGen.Emit(opCode, methInfo);
if(objectTokens != null)
objectTokens.EmitMethod(offset, opCode, methInfo);
break;
}
// Emit an opcode with a ConstructorInfo operand.
case ScriptObjWriterCode.EmitCtor:
{
OpCode opCode = ReadOpCode(objReader, ref srcFile, ref srcLine, ref srcPosn);
Type ctorType = GetTypeFromStr(sdTypes, objReader.ReadString());
int nArgs = objReader.ReadInt32();
Type[] argTypes = new Type[nArgs];
for(int i = 0; i < nArgs; i++)
{
argTypes[i] = GetTypeFromStr(sdTypes, objReader.ReadString());
}
ConstructorInfo ctorInfo = ctorType.GetConstructor(argTypes);
SaveSrcLoc(srcLocs, offset, srcFile, srcLine, srcPosn);
ilGen.Emit(opCode, ctorInfo);
if(objectTokens != null)
objectTokens.EmitCtor(offset, opCode, ctorInfo);
break;
}
// Emit an opcode with a constant operand of various types.
case ScriptObjWriterCode.EmitDouble:
{
OpCode opCode = ReadOpCode(objReader, ref srcFile, ref srcLine, ref srcPosn);
double value = objReader.ReadDouble();
if(opCode != OpCodes.Ldc_R8)
{
throw new Exception("bad opcode " + opCode.ToString());
}
SaveSrcLoc(srcLocs, offset, srcFile, srcLine, srcPosn);
ilGen.Emit(opCode, value);
if(objectTokens != null)
objectTokens.EmitDouble(offset, opCode, value);
break;
}
case ScriptObjWriterCode.EmitFloat:
{
OpCode opCode = ReadOpCode(objReader, ref srcFile, ref srcLine, ref srcPosn);
float value = objReader.ReadSingle();
if(opCode != OpCodes.Ldc_R4)
{
throw new Exception("bad opcode " + opCode.ToString());
}
SaveSrcLoc(srcLocs, offset, srcFile, srcLine, srcPosn);
ilGen.Emit(opCode, value);
if(objectTokens != null)
objectTokens.EmitFloat(offset, opCode, value);
break;
}
case ScriptObjWriterCode.EmitInteger:
{
OpCode opCode = ReadOpCode(objReader, ref srcFile, ref srcLine, ref srcPosn);
int value = objReader.ReadInt32();
SaveSrcLoc(srcLocs, offset, srcFile, srcLine, srcPosn);
if(opCode == OpCodes.Ldc_I4)
{
if((value >= -1) && (value <= 8))
{
opCode = opCodesLdcI4M1P8[value + 1];
ilGen.Emit(opCode);
if(objectTokens != null)
objectTokens.EmitNull(offset, opCode);
break;
}
if((value >= 0) && (value <= 127))
{
opCode = OpCodes.Ldc_I4_S;
ilGen.Emit(OpCodes.Ldc_I4_S, (sbyte)value);
goto pemitint;
}
}
ilGen.Emit(opCode, value);
pemitint:
if(objectTokens != null)
objectTokens.EmitInteger(offset, opCode, value);
break;
}
case ScriptObjWriterCode.EmitString:
{
OpCode opCode = ReadOpCode(objReader, ref srcFile, ref srcLine, ref srcPosn);
string value = objReader.ReadString();
SaveSrcLoc(srcLocs, offset, srcFile, srcLine, srcPosn);
ilGen.Emit(opCode, value);
if(objectTokens != null)
objectTokens.EmitString(offset, opCode, value);
break;
}
// Who knows what?
default:
throw new Exception("bad ScriptObjWriterCode " + ((byte)code).ToString());
}
}
}
/**
* @brief Generate array to quickly translate OpCode.Value to full OpCode struct.
*/
private static Dictionary<short, OpCode> PopulateOpCodes()
{
Dictionary<short, OpCode> opCodeDict = new Dictionary<short, OpCode>();
FieldInfo[] fields = typeof(OpCodes).GetFields();
for(int i = 0; i < fields.Length; i++)
{
OpCode opcode = (OpCode)fields[i].GetValue(null);
opCodeDict.Add(opcode.Value, opcode);
}
return opCodeDict;
}
/**
* @brief Write opcode out to file.
*/
private void WriteOpCode(Token errorAt, OpCode opcode)
{
if(errorAt == null)
{
objFileWriter.Write("");
objFileWriter.Write(lastErrorAtLine);
objFileWriter.Write(lastErrorAtPosn);
}
else
{
if(errorAt.file != lastErrorAtFile)
{
objFileWriter.Write(errorAt.file);
lastErrorAtFile = errorAt.file;
}
else
{
objFileWriter.Write("");
}
objFileWriter.Write(errorAt.line);
objFileWriter.Write(errorAt.posn);
lastErrorAtLine = errorAt.line;
lastErrorAtPosn = errorAt.posn;
}
objFileWriter.Write(opcode.Value);
}
/**
* @brief Read opcode in from file.
*/
private static OpCode ReadOpCode(BinaryReader objReader, ref string srcFile, ref int srcLine, ref int srcPosn)
{
string f = objReader.ReadString();
if(f != "")
srcFile = f;
srcLine = objReader.ReadInt32();
srcPosn = objReader.ReadInt32();
short value = objReader.ReadInt16();
return opCodes[value];
}
/**
* @brief Save an IL_offset -> source location translation entry
* @param srcLocs = saved entries for the current function
* @param offset = offset in IL object code for next instruction
* @param src{File,Line,Posn} = location in source file corresponding to opcode
* @returns with entry added to srcLocs
*/
private static void SaveSrcLoc(Dictionary<int, ScriptSrcLoc> srcLocs, int offset, string srcFile, int srcLine, int srcPosn)
{
ScriptSrcLoc srcLoc = new ScriptSrcLoc();
srcLoc.file = srcFile;
srcLoc.line = srcLine;
srcLoc.posn = srcPosn;
srcLocs[offset] = srcLoc;
}
/**
* @brief Create type<->string conversions.
* Using Type.AssemblyQualifiedName is horribly inefficient
* and all our types should be known.
*/
private static Dictionary<string, Type> PopulateS2T()
{
Dictionary<string, Type> s2t = new Dictionary<string, Type>();
s2t.Add("badcallx", typeof(ScriptBadCallNoException));
s2t.Add("binopstr", typeof(BinOpStr));
s2t.Add("bool", typeof(bool));
s2t.Add("char", typeof(char));
s2t.Add("delegate", typeof(Delegate));
s2t.Add("delarr[]", typeof(Delegate[]));
s2t.Add("double", typeof(double));
s2t.Add("exceptn", typeof(Exception));
s2t.Add("float", typeof(float));
s2t.Add("htlist", typeof(HeapTrackerList));
s2t.Add("htobject", typeof(HeapTrackerObject));
s2t.Add("htstring", typeof(HeapTrackerString));
s2t.Add("inlfunc", typeof(CompValuInline));
s2t.Add("int", typeof(int));
s2t.Add("int*", typeof(int).MakeByRefType());
s2t.Add("intrlokd", typeof(System.Threading.Interlocked));
s2t.Add("lslfloat", typeof(LSL_Float));
s2t.Add("lslint", typeof(LSL_Integer));
s2t.Add("lsllist", typeof(LSL_List));
s2t.Add("lslrot", typeof(LSL_Rotation));
s2t.Add("lslstr", typeof(LSL_String));
s2t.Add("lslvec", typeof(LSL_Vector));
s2t.Add("math", typeof(Math));
s2t.Add("midround", typeof(MidpointRounding));
s2t.Add("object", typeof(object));
s2t.Add("object*", typeof(object).MakeByRefType());
s2t.Add("object[]", typeof(object[]));
s2t.Add("scrbase", typeof(ScriptBaseClass));
s2t.Add("scrcode", typeof(ScriptCodeGen));
s2t.Add("sdtclobj", typeof(XMRSDTypeClObj));
s2t.Add("string", typeof(string));
s2t.Add("typecast", typeof(TypeCast));
s2t.Add("undstatx", typeof(ScriptUndefinedStateException));
s2t.Add("void", typeof(void));
s2t.Add("xmrarray", typeof(XMR_Array));
s2t.Add("xmrinst", typeof(XMRInstAbstract));
return s2t;
}
private static Dictionary<Type, string> PopulateT2S()
{
Dictionary<string, Type> s2t = PopulateS2T();
Dictionary<Type, string> t2s = new Dictionary<Type, string>();
foreach(KeyValuePair<string, Type> kvp in s2t)
{
t2s.Add(kvp.Value, kvp.Key);
}
return t2s;
}
/**
* @brief Add to list of internally recognized types.
*/
public static void DefineInternalType(string name, Type type)
{
if(!string2Type.ContainsKey(name))
{
string2Type.Add(name, type);
type2String.Add(type, name);
}
}
private string GetStrFromType(Type t)
{
string s = GetStrFromTypeWork(t);
return s;
}
private string GetStrFromTypeWork(Type t)
{
string s;
// internal fixed types like int and xmrarray etc
if(type2String.TryGetValue(t, out s))
return s;
// script-defined types
if(sdTypesRev.TryGetValue(t, out s))
return "sdt$" + s;
// inline function types
s = TokenDeclSDTypeDelegate.TryGetInlineName(t);
if(s != null)
return s;
// last resort
return t.AssemblyQualifiedName;
}
private static Type GetTypeFromStr(Dictionary<string, TokenDeclSDType> sdTypes, string s)
{
Type t;
// internal fixed types like int and xmrarray etc
if(string2Type.TryGetValue(s, out t))
return t;
// script-defined types
if(s.StartsWith("sdt$"))
return sdTypes[s.Substring(4)].GetSysType();
// inline function types
t = TokenDeclSDTypeDelegate.TryGetInlineSysType(s);
if(t != null)
return t;
// last resort
return Type.GetType(s, true);
}
}
public class ScriptSrcLoc
{
public string file;
public int line;
public int posn;
}
}