6297 lines
230 KiB
C#
6297 lines
230 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 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;
|
|
|
|
/**
|
|
* Contains classes that disassemble or decompile an xmrobj file.
|
|
* See xmrengcomp.cx utility program.
|
|
*/
|
|
|
|
namespace OpenSim.Region.ScriptEngine.Yengine
|
|
{
|
|
|
|
/*
|
|
* Encapsulate object code for a method.
|
|
*/
|
|
public abstract class ObjectTokens
|
|
{
|
|
public ScriptObjCode scriptObjCode;
|
|
|
|
public ObjectTokens(ScriptObjCode scriptObjCode)
|
|
{
|
|
this.scriptObjCode = scriptObjCode;
|
|
}
|
|
|
|
public abstract void Close();
|
|
public abstract void BegMethod(DynamicMethod method);
|
|
public abstract void EndMethod();
|
|
public abstract void DefineLabel(int number, string name);
|
|
public abstract void DefineLocal(int number, string name, string type, Type syType);
|
|
public abstract void DefineMethod(string methName, Type retType, Type[] argTypes, string[] argNames);
|
|
public abstract void MarkLabel(int offset, int number);
|
|
public abstract void BegExcBlk(int offset);
|
|
public abstract void BegCatBlk(int offset, Type excType);
|
|
public abstract void BegFinBlk(int offset);
|
|
public abstract void EndExcBlk(int offset);
|
|
public abstract void EmitNull(int offset, OpCode opCode);
|
|
public abstract void EmitField(int offset, OpCode opCode, FieldInfo field);
|
|
public abstract void EmitLocal(int offset, OpCode opCode, int number);
|
|
public abstract void EmitType(int offset, OpCode opCode, Type type);
|
|
public abstract void EmitLabel(int offset, OpCode opCode, int number);
|
|
public abstract void EmitLabels(int offset, OpCode opCode, int[] numbers);
|
|
public abstract void EmitMethod(int offset, OpCode opCode, MethodInfo method);
|
|
public abstract void EmitCtor(int offset, OpCode opCode, ConstructorInfo ctor);
|
|
public abstract void EmitDouble(int offset, OpCode opCode, double value);
|
|
public abstract void EmitFloat(int offset, OpCode opCode, float value);
|
|
public abstract void EmitInteger(int offset, OpCode opCode, int value);
|
|
public abstract void EmitString(int offset, OpCode opCode, string value);
|
|
}
|
|
|
|
/******************\
|
|
* DISASSEMBLER *
|
|
\******************/
|
|
|
|
public class OTDisassemble: ObjectTokens
|
|
{
|
|
private static readonly int OPCSTRWIDTH = 12;
|
|
|
|
private Dictionary<int, string> labelNames;
|
|
private Dictionary<int, string> localNames;
|
|
private StringBuilder lbuf = new StringBuilder();
|
|
private TextWriter twout;
|
|
|
|
public OTDisassemble(ScriptObjCode scriptObjCode, TextWriter twout) : base(scriptObjCode)
|
|
{
|
|
this.twout = twout;
|
|
}
|
|
|
|
public override void Close()
|
|
{
|
|
twout.WriteLine("TheEnd.");
|
|
}
|
|
|
|
/**
|
|
* About to generate object code for this method.
|
|
*/
|
|
public override void BegMethod(DynamicMethod method)
|
|
{
|
|
labelNames = new Dictionary<int, string>();
|
|
localNames = new Dictionary<int, string>();
|
|
|
|
twout.WriteLine("");
|
|
|
|
lbuf.Append(method.ReturnType.Name);
|
|
lbuf.Append(' ');
|
|
lbuf.Append(method.Name);
|
|
|
|
ParameterInfo[] parms = method.GetParameters();
|
|
int nArgs = parms.Length;
|
|
lbuf.Append(" (");
|
|
for(int i = 0; i < nArgs; i++)
|
|
{
|
|
if(i > 0)
|
|
lbuf.Append(", ");
|
|
lbuf.Append(parms[i].ParameterType.Name);
|
|
}
|
|
lbuf.Append(')');
|
|
FlushLine();
|
|
|
|
lbuf.Append('{');
|
|
FlushLine();
|
|
}
|
|
|
|
/**
|
|
* Dump out reconstructed source for this method.
|
|
*/
|
|
public override void EndMethod()
|
|
{
|
|
lbuf.Append('}');
|
|
FlushLine();
|
|
}
|
|
|
|
/**
|
|
* Add instructions to stream.
|
|
*/
|
|
public override void DefineLabel(int number, string name)
|
|
{
|
|
labelNames[number] = name + "$" + number;
|
|
}
|
|
|
|
public override void DefineLocal(int number, string name, string type, Type syType)
|
|
{
|
|
localNames[number] = name + "$" + number;
|
|
|
|
lbuf.Append(" ");
|
|
lbuf.Append(type.PadRight(OPCSTRWIDTH - 1));
|
|
lbuf.Append(' ');
|
|
lbuf.Append(localNames[number]);
|
|
FlushLine();
|
|
}
|
|
|
|
public override void DefineMethod(string methName, Type retType, Type[] argTypes, string[] argNames)
|
|
{
|
|
}
|
|
|
|
public override void MarkLabel(int offset, int number)
|
|
{
|
|
LinePrefix(offset);
|
|
lbuf.Append(labelNames[number]);
|
|
lbuf.Append(":");
|
|
FlushLine();
|
|
}
|
|
|
|
public override void BegExcBlk(int offset)
|
|
{
|
|
LinePrefix(offset);
|
|
lbuf.Append(" BeginExceptionBlock");
|
|
FlushLine();
|
|
}
|
|
|
|
public override void BegCatBlk(int offset, Type excType)
|
|
{
|
|
LinePrefix(offset);
|
|
lbuf.Append(" BeginCatchBlock ");
|
|
lbuf.Append(excType.Name);
|
|
FlushLine();
|
|
}
|
|
|
|
public override void BegFinBlk(int offset)
|
|
{
|
|
LinePrefix(offset);
|
|
lbuf.Append(" BeginFinallyBlock");
|
|
FlushLine();
|
|
}
|
|
|
|
public override void EndExcBlk(int offset)
|
|
{
|
|
LinePrefix(offset);
|
|
lbuf.Append(" EndExceptionBlock");
|
|
FlushLine();
|
|
}
|
|
|
|
public override void EmitNull(int offset, OpCode opCode)
|
|
{
|
|
LinePrefix(offset, opCode);
|
|
FlushLine();
|
|
}
|
|
|
|
public override void EmitField(int offset, OpCode opCode, FieldInfo field)
|
|
{
|
|
LinePrefix(offset, opCode);
|
|
lbuf.Append(field.DeclaringType.Name);
|
|
lbuf.Append(':');
|
|
lbuf.Append(field.Name);
|
|
lbuf.Append(" -> ");
|
|
lbuf.Append(field.FieldType.Name);
|
|
lbuf.Append(" (field)");
|
|
FlushLine();
|
|
}
|
|
|
|
public override void EmitLocal(int offset, OpCode opCode, int number)
|
|
{
|
|
LinePrefix(offset, opCode);
|
|
lbuf.Append(localNames[number]);
|
|
lbuf.Append(" (local)");
|
|
FlushLine();
|
|
}
|
|
|
|
public override void EmitType(int offset, OpCode opCode, Type type)
|
|
{
|
|
LinePrefix(offset, opCode);
|
|
lbuf.Append(type.Name);
|
|
lbuf.Append(" (type)");
|
|
FlushLine();
|
|
}
|
|
|
|
public override void EmitLabel(int offset, OpCode opCode, int number)
|
|
{
|
|
LinePrefix(offset, opCode);
|
|
lbuf.Append(labelNames[number]);
|
|
lbuf.Append(" (label)");
|
|
FlushLine();
|
|
}
|
|
|
|
public override void EmitLabels(int offset, OpCode opCode, int[] numbers)
|
|
{
|
|
LinePrefix(offset, opCode);
|
|
|
|
int lineLen = lbuf.Length;
|
|
int nLabels = numbers.Length;
|
|
for(int i = 0; i < nLabels; i++)
|
|
{
|
|
if(i > 0)
|
|
{
|
|
lbuf.AppendLine();
|
|
lbuf.Append(",".PadLeft(lineLen));
|
|
}
|
|
lbuf.Append(labelNames[numbers[i]]);
|
|
}
|
|
|
|
FlushLine();
|
|
}
|
|
|
|
public override void EmitMethod(int offset, OpCode opCode, MethodInfo method)
|
|
{
|
|
LinePrefix(offset, opCode);
|
|
|
|
ParameterInfo[] parms = method.GetParameters();
|
|
int nArgs = parms.Length;
|
|
if(method.DeclaringType != null)
|
|
{
|
|
lbuf.Append(method.DeclaringType.Name);
|
|
lbuf.Append(':');
|
|
}
|
|
lbuf.Append(method.Name);
|
|
lbuf.Append('(');
|
|
for(int i = 0; i < nArgs; i++)
|
|
{
|
|
if(i > 0)
|
|
lbuf.Append(",");
|
|
lbuf.Append(parms[i].ParameterType.Name);
|
|
}
|
|
lbuf.Append(") -> ");
|
|
lbuf.Append(method.ReturnType.Name);
|
|
|
|
FlushLine();
|
|
}
|
|
|
|
public override void EmitCtor(int offset, OpCode opCode, ConstructorInfo ctor)
|
|
{
|
|
LinePrefix(offset, opCode);
|
|
|
|
ParameterInfo[] parms = ctor.GetParameters();
|
|
int nArgs = parms.Length;
|
|
lbuf.Append(ctor.DeclaringType.Name);
|
|
lbuf.Append(":(");
|
|
for(int i = 0; i < nArgs; i++)
|
|
{
|
|
if(i > 0)
|
|
lbuf.Append(",");
|
|
lbuf.Append(parms[i].ParameterType.Name);
|
|
}
|
|
lbuf.Append(")");
|
|
|
|
FlushLine();
|
|
}
|
|
|
|
public override void EmitDouble(int offset, OpCode opCode, double value)
|
|
{
|
|
LinePrefix(offset, opCode);
|
|
lbuf.Append(value.ToString());
|
|
lbuf.Append(" (double)");
|
|
FlushLine();
|
|
}
|
|
|
|
public override void EmitFloat(int offset, OpCode opCode, float value)
|
|
{
|
|
LinePrefix(offset, opCode);
|
|
lbuf.Append(value.ToString());
|
|
lbuf.Append(" (float)");
|
|
FlushLine();
|
|
}
|
|
|
|
public override void EmitInteger(int offset, OpCode opCode, int value)
|
|
{
|
|
LinePrefix(offset, opCode);
|
|
lbuf.Append(value.ToString());
|
|
lbuf.Append(" (int)");
|
|
FlushLine();
|
|
}
|
|
|
|
public override void EmitString(int offset, OpCode opCode, string value)
|
|
{
|
|
LinePrefix(offset, opCode);
|
|
lbuf.Append("\"");
|
|
lbuf.Append(value);
|
|
lbuf.Append("\" (string)");
|
|
FlushLine();
|
|
}
|
|
|
|
/**
|
|
* Put offset and opcode at beginning of line.
|
|
*/
|
|
private void LinePrefix(int offset, OpCode opCode)
|
|
{
|
|
LinePrefix(offset);
|
|
lbuf.Append(" ");
|
|
lbuf.Append(opCode.ToString().PadRight(OPCSTRWIDTH - 1));
|
|
lbuf.Append(' ');
|
|
}
|
|
|
|
private void LinePrefix(int offset)
|
|
{
|
|
lbuf.Append(" ");
|
|
lbuf.Append(offset.ToString("X4"));
|
|
lbuf.Append(" ");
|
|
}
|
|
|
|
/**
|
|
* Flush line buffer to output file.
|
|
*/
|
|
private void FlushLine()
|
|
{
|
|
if(lbuf.Length > 0)
|
|
{
|
|
twout.WriteLine(lbuf.ToString());
|
|
lbuf.Remove(0, lbuf.Length);
|
|
}
|
|
}
|
|
}
|
|
|
|
/****************\
|
|
* DECOMPILER *
|
|
\****************/
|
|
|
|
/**
|
|
* Note: The decompiler does not handle any xmroption extensions
|
|
* such as &&&, |||, ? operators and switch statements, as
|
|
* they do branches with a non-empty stack, which is way
|
|
* beyond this code's ability to analyze.
|
|
*/
|
|
|
|
public class OTDecompile: ObjectTokens
|
|
{
|
|
public const string _mainCallNo = "__mainCallNo$";
|
|
public const string _callLabel = "__call_";
|
|
public const string _callMode = "callMode";
|
|
public const string _checkRunQuick = "CheckRunQuick";
|
|
public const string _checkRunStack = "CheckRunStack";
|
|
public const string _cmRestore = "__cmRestore";
|
|
public const string _doBreak = "dobreak_";
|
|
public const string _doCont = "docont_";
|
|
public const string _doGblInit = "doGblInit";
|
|
public const string _doLoop = "doloop_";
|
|
public const string _ehArgs = "ehArgs";
|
|
public const string _forBreak = "forbreak_";
|
|
public const string _forCont = "forcont_";
|
|
public const string _forLoop = "forloop_";
|
|
public const string _globalvarinit = "$globalvarinit()";
|
|
public const string _heapTrackerPop = "Pop";
|
|
public const string _heapTrackerPush = "Push";
|
|
public const string _ifDone = "ifdone_";
|
|
public const string _ifElse = "ifelse_";
|
|
public const string _llAbstemp = "llAbstemp";
|
|
public const string _retlbl = "__retlbl";
|
|
public const string _retval = "__retval$";
|
|
public const string _whileBreak = "whilebreak_";
|
|
public const string _whileCont = "whilecont_";
|
|
public const string _whileLoop = "whileloop_";
|
|
public const string _xmrinst = "__xmrinst";
|
|
public const string _xmrinstlocal = "__xmrinst$";
|
|
|
|
private const string INDENT = " ";
|
|
private const string LABELINDENT = " ";
|
|
|
|
private static Dictionary<string, string> typeTranslator = InitTypeTranslator();
|
|
private static Dictionary<string, string> InitTypeTranslator()
|
|
{
|
|
Dictionary<string, string> d = new Dictionary<string, string>();
|
|
d["Boolean"] = "integer";
|
|
d["bool"] = "integer";
|
|
d["Double"] = "float";
|
|
d["double"] = "float";
|
|
d["Int32"] = "integer";
|
|
d["int"] = "integer";
|
|
d["htlist"] = "list";
|
|
d["htobject"] = "object";
|
|
d["htstring"] = "string";
|
|
d["lslfloat"] = "float";
|
|
d["lslint"] = "integer";
|
|
d["lsllist"] = "list";
|
|
d["lslrot"] = "rotation";
|
|
d["lslstr"] = "string";
|
|
d["lslvec"] = "vector";
|
|
d["Quaternion"] = "rotation";
|
|
d["String"] = "string";
|
|
d["Vector3"] = "vector";
|
|
return d;
|
|
}
|
|
|
|
private Dictionary<int, OTLocal> eharglist;
|
|
private Dictionary<int, OTLabel> labels;
|
|
private Dictionary<int, OTLocal> locals;
|
|
private Dictionary<string, string[]> methargnames;
|
|
private LinkedList<OTCilInstr> cilinstrs;
|
|
private OTStmtBlock topBlock;
|
|
private Stack<OTOpnd> opstack;
|
|
private Stack<OTStmtBegExcBlk> trystack;
|
|
private Stack<OTStmtBlock> blockstack;
|
|
|
|
private int dupNo;
|
|
private DynamicMethod method;
|
|
private string laststate;
|
|
private TextWriter twout;
|
|
|
|
public OTDecompile(ScriptObjCode scriptObjCode, TextWriter twout) : base(scriptObjCode)
|
|
{
|
|
this.twout = twout;
|
|
twout.Write("xmroption dollarsigns;");
|
|
methargnames = new Dictionary<string, string[]>();
|
|
}
|
|
|
|
public override void Close()
|
|
{
|
|
if(laststate != null)
|
|
{
|
|
twout.Write("\n}");
|
|
laststate = null;
|
|
}
|
|
twout.Write('\n');
|
|
}
|
|
|
|
/**
|
|
* About to generate object code for this method.
|
|
*/
|
|
public override void BegMethod(DynamicMethod method)
|
|
{
|
|
this.method = method;
|
|
|
|
eharglist = new Dictionary<int, OTLocal>();
|
|
labels = new Dictionary<int, OTLabel>();
|
|
locals = new Dictionary<int, OTLocal>();
|
|
cilinstrs = new LinkedList<OTCilInstr>();
|
|
opstack = new Stack<OTOpnd>();
|
|
trystack = new Stack<OTStmtBegExcBlk>();
|
|
blockstack = new Stack<OTStmtBlock>();
|
|
|
|
dupNo = 0;
|
|
}
|
|
|
|
/**
|
|
* Dump out reconstructed source for this method.
|
|
*/
|
|
public override void EndMethod()
|
|
{
|
|
/*
|
|
* Convert CIL code to primitive statements.
|
|
* There are a bunch of labels and internal code such as call stack save restore.
|
|
*/
|
|
topBlock = new OTStmtBlock();
|
|
blockstack.Push(topBlock);
|
|
for(LinkedListNode<OTCilInstr> link = cilinstrs.First; link != null; link = link.Next)
|
|
{
|
|
link.Value.BuildStatements(this, link);
|
|
}
|
|
|
|
/*
|
|
* Strip out stuff we don't want, such as references to callMode.
|
|
* This strips out stack frame capture and restore code.
|
|
*/
|
|
topBlock.StripStuff(null);
|
|
|
|
// including a possible final return statement
|
|
// - delete if void return value
|
|
// - delete if returning __retval cuz we converted all __retval assignments to return statements
|
|
if((topBlock.blkstmts.Last != null) && (topBlock.blkstmts.Last.Value is OTStmtRet))
|
|
{
|
|
OTStmtRet finalret = (OTStmtRet)topBlock.blkstmts.Last.Value;
|
|
if((finalret.value == null) ||
|
|
((finalret.value is OTOpndLocal) &&
|
|
((OTOpndLocal)finalret.value).local.name.StartsWith(_retval)))
|
|
{
|
|
topBlock.blkstmts.RemoveLast();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* At this point, all behind-the-scenes references are removed except
|
|
* that the do/for/if/while blocks are represented by OTStmtCont-style
|
|
* if/jumps. So try to convert them to the higher-level structures.
|
|
*/
|
|
topBlock.DetectDoForIfWhile(null);
|
|
|
|
/*
|
|
* Final strip to get rid of unneeded @forbreak_<suffix>; labels and the like.
|
|
*/
|
|
topBlock.StripStuff(null);
|
|
|
|
/*
|
|
* Build reference counts so we don't output unneeded declarations,
|
|
* especially temps and internal variables.
|
|
*/
|
|
foreach(OTLocal local in locals.Values)
|
|
{
|
|
local.nlclreads = 0;
|
|
local.nlclwrites = 0;
|
|
}
|
|
topBlock.CountRefs();
|
|
for(IEnumerator<int> localenum = locals.Keys.GetEnumerator(); localenum.MoveNext();)
|
|
{
|
|
OTLocal local = locals[localenum.Current];
|
|
if(((local.nlclreads | local.nlclwrites) == 0) || local.name.StartsWith(_xmrinstlocal))
|
|
{
|
|
locals.Remove(localenum.Current);
|
|
localenum = locals.Keys.GetEnumerator();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Strip the $n off of local vars that are not ambiguous.
|
|
* Make sure they don't mask globals and arguments as well.
|
|
*/
|
|
Dictionary<string, int> namecounts = new Dictionary<string, int>();
|
|
foreach(Dictionary<int, string> varnames in scriptObjCode.globalVarNames.Values)
|
|
{
|
|
foreach(string varname in varnames.Values)
|
|
{
|
|
int count;
|
|
if(!namecounts.TryGetValue(varname, out count))
|
|
count = 0;
|
|
namecounts[varname] = count + 1;
|
|
}
|
|
}
|
|
if(methargnames.ContainsKey(method.Name))
|
|
{
|
|
foreach(string argname in methargnames[method.Name])
|
|
{
|
|
int count;
|
|
if(!namecounts.TryGetValue(argname, out count))
|
|
count = 0;
|
|
namecounts[argname] = count + 1;
|
|
}
|
|
}
|
|
foreach(OTLocal local in locals.Values)
|
|
{
|
|
int i = local.name.LastIndexOf('$');
|
|
string name = local.name.Substring(0, i);
|
|
int count;
|
|
if(!namecounts.TryGetValue(name, out count))
|
|
count = 0;
|
|
namecounts[name] = count + 1;
|
|
}
|
|
foreach(OTLocal local in locals.Values)
|
|
{
|
|
int i = local.name.LastIndexOf('$');
|
|
string name = local.name.Substring(0, i);
|
|
int count = namecounts[name];
|
|
if(count == 1)
|
|
local.name = name;
|
|
}
|
|
|
|
/*
|
|
* Print out result.
|
|
*/
|
|
if(method.Name == _globalvarinit)
|
|
{
|
|
GlobalsDump();
|
|
}
|
|
else
|
|
{
|
|
MethodDump();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add instructions to stream.
|
|
*/
|
|
public override void DefineLabel(int number, string name)
|
|
{
|
|
labels.Add(number, new OTLabel(number, name));
|
|
}
|
|
public override void DefineLocal(int number, string name, string type, Type syType)
|
|
{
|
|
locals.Add(number, new OTLocal(number, name, type));
|
|
}
|
|
public override void DefineMethod(string methName, Type retType, Type[] argTypes, string[] argNames)
|
|
{
|
|
methargnames[methName] = argNames;
|
|
}
|
|
public override void MarkLabel(int offset, int number)
|
|
{
|
|
OTCilInstr label = labels[number];
|
|
label.offset = offset;
|
|
cilinstrs.AddLast(label);
|
|
}
|
|
public override void BegExcBlk(int offset)
|
|
{
|
|
cilinstrs.AddLast(new OTCilBegExcBlk(offset));
|
|
}
|
|
public override void BegCatBlk(int offset, Type excType)
|
|
{
|
|
cilinstrs.AddLast(new OTCilBegCatBlk(offset, excType));
|
|
}
|
|
public override void BegFinBlk(int offset)
|
|
{
|
|
cilinstrs.AddLast(new OTCilBegFinBlk(offset));
|
|
}
|
|
public override void EndExcBlk(int offset)
|
|
{
|
|
cilinstrs.AddLast(new OTCilEndExcBlk(offset));
|
|
}
|
|
public override void EmitNull(int offset, OpCode opCode)
|
|
{
|
|
cilinstrs.AddLast(new OTCilNull(offset, opCode));
|
|
}
|
|
public override void EmitField(int offset, OpCode opCode, FieldInfo field)
|
|
{
|
|
cilinstrs.AddLast(new OTCilField(offset, opCode, field));
|
|
}
|
|
public override void EmitLocal(int offset, OpCode opCode, int number)
|
|
{
|
|
cilinstrs.AddLast(new OTCilLocal(offset, opCode, locals[number]));
|
|
}
|
|
public override void EmitType(int offset, OpCode opCode, Type type)
|
|
{
|
|
cilinstrs.AddLast(new OTCilType(offset, opCode, type));
|
|
}
|
|
public override void EmitLabel(int offset, OpCode opCode, int number)
|
|
{
|
|
cilinstrs.AddLast(new OTCilLabel(offset, opCode, labels[number]));
|
|
}
|
|
public override void EmitLabels(int offset, OpCode opCode, int[] numbers)
|
|
{
|
|
OTLabel[] labelarray = new OTLabel[numbers.Length];
|
|
for(int i = 0; i < numbers.Length; i++)
|
|
{
|
|
labelarray[i] = labels[numbers[i]];
|
|
}
|
|
cilinstrs.AddLast(new OTCilLabels(offset, opCode, labelarray));
|
|
}
|
|
public override void EmitMethod(int offset, OpCode opCode, MethodInfo method)
|
|
{
|
|
cilinstrs.AddLast(new OTCilMethod(offset, opCode, method));
|
|
}
|
|
public override void EmitCtor(int offset, OpCode opCode, ConstructorInfo ctor)
|
|
{
|
|
cilinstrs.AddLast(new OTCilCtor(offset, opCode, ctor));
|
|
}
|
|
public override void EmitDouble(int offset, OpCode opCode, double value)
|
|
{
|
|
cilinstrs.AddLast(new OTCilDouble(offset, opCode, value));
|
|
}
|
|
public override void EmitFloat(int offset, OpCode opCode, float value)
|
|
{
|
|
cilinstrs.AddLast(new OTCilFloat(offset, opCode, value));
|
|
}
|
|
public override void EmitInteger(int offset, OpCode opCode, int value)
|
|
{
|
|
cilinstrs.AddLast(new OTCilInteger(offset, opCode, value));
|
|
}
|
|
public override void EmitString(int offset, OpCode opCode, string value)
|
|
{
|
|
cilinstrs.AddLast(new OTCilString(offset, opCode, value));
|
|
}
|
|
|
|
/**
|
|
* Add the given statement to the end of the currently open block.
|
|
*/
|
|
public void AddLastStmt(OTStmt stmt)
|
|
{
|
|
blockstack.Peek().blkstmts.AddLast(stmt);
|
|
}
|
|
|
|
/**
|
|
* Generate output for $globalvarinit() function.
|
|
* Also outputs declarations for global variables.
|
|
*/
|
|
private void GlobalsDump()
|
|
{
|
|
/*
|
|
* Scan $globalvarinit(). It should only have global var assignments in it.
|
|
* Also gather up list of variables it initializes.
|
|
*/
|
|
bool badinit = false;
|
|
Dictionary<string, string> inittypes = new Dictionary<string, string>();
|
|
foreach(OTStmt stmt in topBlock.blkstmts)
|
|
{
|
|
if(!(stmt is OTStmtStore))
|
|
{
|
|
badinit = true;
|
|
break;
|
|
}
|
|
OTStmtStore store = (OTStmtStore)stmt;
|
|
if(!(store.varwr is OTOpndGlobal))
|
|
{
|
|
badinit = true;
|
|
break;
|
|
}
|
|
OTOpndGlobal globalop = (OTOpndGlobal)store.varwr;
|
|
inittypes[globalop.PrintableString] = "";
|
|
}
|
|
|
|
/*
|
|
* Scan through list of all global variables in the script.
|
|
* Output declarations for those what don't have any init statement for them.
|
|
* Save the type for those that do have init statements.
|
|
*/
|
|
bool first = true;
|
|
foreach(string iartypename in scriptObjCode.globalVarNames.Keys)
|
|
{
|
|
Dictionary<int, string> varnames = scriptObjCode.globalVarNames[iartypename];
|
|
string typename = iartypename.ToLowerInvariant();
|
|
if(typename.StartsWith("iar"))
|
|
typename = typename.Substring(3);
|
|
if(typename.EndsWith("s"))
|
|
typename = typename.Substring(0, typename.Length - 1);
|
|
foreach(string varname in varnames.Values)
|
|
{
|
|
if(!badinit && inittypes.ContainsKey(varname))
|
|
{
|
|
inittypes[varname] = typename;
|
|
}
|
|
else
|
|
{
|
|
if(first)
|
|
twout.Write('\n');
|
|
twout.Write('\n' + typename + ' ' + varname + ';');
|
|
first = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If $globalvarinit() has anything bad in it, output it as a function.
|
|
* Otherwise, output it as a series of global declarations with init values.
|
|
*/
|
|
if(badinit)
|
|
{
|
|
MethodDump();
|
|
}
|
|
else
|
|
{
|
|
foreach(OTStmt stmt in topBlock.blkstmts)
|
|
{
|
|
OTStmtStore store = (OTStmtStore)stmt;
|
|
OTOpndGlobal globalop = (OTOpndGlobal)store.varwr;
|
|
string name = globalop.PrintableString;
|
|
if(first)
|
|
twout.Write('\n');
|
|
twout.Write('\n' + inittypes[name] + ' ');
|
|
store.PrintStmt(twout, "");
|
|
first = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generate output for other functions.
|
|
*/
|
|
private void MethodDump()
|
|
{
|
|
string indent;
|
|
|
|
/*
|
|
* Event handlers don't have an argument list as such in the original
|
|
* code. Instead they have a series of assignments from ehargs[] to
|
|
* local variables. So make those local variables look like they are
|
|
* an argument list.
|
|
*/
|
|
int i = method.Name.IndexOf(' ');
|
|
if(i >= 0)
|
|
{
|
|
|
|
/*
|
|
* Maybe we have to output the state name.
|
|
*/
|
|
string statename = method.Name.Substring(0, i);
|
|
string eventname = method.Name.Substring(++i);
|
|
|
|
if(laststate != statename)
|
|
{
|
|
if(laststate != null)
|
|
twout.Write("\n}");
|
|
if(statename == "default")
|
|
{
|
|
twout.Write("\n\ndefault {");
|
|
}
|
|
else
|
|
{
|
|
twout.Write("\n\nstate " + statename + " {");
|
|
}
|
|
laststate = statename;
|
|
}
|
|
else
|
|
{
|
|
twout.Write('\n');
|
|
}
|
|
|
|
/*
|
|
* Output event name and argument list.
|
|
* Remove from locals list so they don't print below.
|
|
*/
|
|
twout.Write('\n' + INDENT + eventname + " (");
|
|
MethodInfo meth = typeof(IEventHandlers).GetMethod(eventname);
|
|
i = 0;
|
|
foreach(ParameterInfo pi in meth.GetParameters())
|
|
{
|
|
// skip the first param cuz it's the XMRInstance arg
|
|
if(i > 0)
|
|
twout.Write(", ");
|
|
OTLocal local;
|
|
if(eharglist.TryGetValue(i, out local) && locals.ContainsKey(local.number))
|
|
{
|
|
twout.Write(local.DumpString());
|
|
locals.Remove(local.number);
|
|
}
|
|
else
|
|
{
|
|
// maybe the assignment was removed
|
|
// eg, because the local was write-only (not referenced)
|
|
// so substitute in placeholder that won't be referenced
|
|
twout.Write(AbbrType(pi.ParameterType) + " arg$" + (i + 1));
|
|
}
|
|
i++;
|
|
}
|
|
twout.Write(')');
|
|
|
|
/*
|
|
* Indent method body by 4 spaces.
|
|
*/
|
|
indent = INDENT;
|
|
}
|
|
else
|
|
{
|
|
|
|
/*
|
|
* Maybe need to close out previous state.
|
|
*/
|
|
if(laststate != null)
|
|
{
|
|
twout.Write("\n}");
|
|
laststate = null;
|
|
}
|
|
|
|
/*
|
|
* Output blank line and return type (if any).
|
|
*/
|
|
twout.Write("\n\n");
|
|
if(method.ReturnType != typeof(void))
|
|
{
|
|
twout.Write(AbbrType(method.ReturnType) + ' ');
|
|
}
|
|
|
|
/*
|
|
* Output method name and argument list.
|
|
*/
|
|
int j = method.Name.IndexOf('(');
|
|
if(j < 0)
|
|
{
|
|
twout.Write(method.Name);
|
|
}
|
|
else
|
|
{
|
|
twout.Write(method.Name.Substring(0, j) + " (");
|
|
bool first = true;
|
|
j = 0;
|
|
foreach(ParameterInfo pi in method.GetParameters())
|
|
{
|
|
if(j > 0)
|
|
{ // skip the XMRInstance arg$0 parameter
|
|
if(!first)
|
|
twout.Write(", ");
|
|
twout.Write(AbbrType(pi.ParameterType) + ' ' + MethArgName(j));
|
|
first = false;
|
|
}
|
|
j++;
|
|
}
|
|
twout.Write(')');
|
|
}
|
|
|
|
/*
|
|
* Don't indent method body at all.
|
|
*/
|
|
indent = "";
|
|
}
|
|
|
|
/*
|
|
* Output local variable declarations.
|
|
*/
|
|
twout.Write('\n' + indent + '{');
|
|
bool didOne = false;
|
|
foreach(OTLocal local in locals.Values)
|
|
{
|
|
twout.Write('\n' + indent + INDENT + local.DumpString() + "; // r:" + local.nlclreads + " w:" + local.nlclwrites);
|
|
didOne = true;
|
|
}
|
|
if(didOne)
|
|
twout.Write('\n');
|
|
|
|
/*
|
|
* Output statements.
|
|
*/
|
|
if(topBlock.blkstmts.Count == 0)
|
|
{
|
|
twout.Write(" }");
|
|
}
|
|
else
|
|
{
|
|
topBlock.PrintBodyAndEnd(twout, indent);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get abbreviated type string.
|
|
*/
|
|
public static string AbbrType(Type type)
|
|
{
|
|
if(type == null)
|
|
return "null";
|
|
return AbbrType(type.Name);
|
|
}
|
|
public static string AbbrType(string type)
|
|
{
|
|
if(type.StartsWith("OpenSim.Region.ScriptEngine.YEngine."))
|
|
{
|
|
type = type.Substring(38);
|
|
int i = type.IndexOf(',');
|
|
if(i > 0)
|
|
type = type.Substring(0, i);
|
|
}
|
|
if(typeTranslator.ContainsKey(type))
|
|
{
|
|
type = typeTranslator[type];
|
|
}
|
|
return type;
|
|
}
|
|
|
|
/**
|
|
* Get current method's argument name.
|
|
*/
|
|
public string MethArgName(int index)
|
|
{
|
|
string[] argnames;
|
|
if(methargnames.TryGetValue(method.Name, out argnames) && (index < argnames.Length))
|
|
{
|
|
return argnames[index];
|
|
}
|
|
return "arg$" + index;
|
|
}
|
|
|
|
/**
|
|
* Strip svperflvovs (float) cast from rotation/vector values.
|
|
*/
|
|
public static OTOpnd StripFloatCast(OTOpnd op)
|
|
{
|
|
if(op is OTOpndCast)
|
|
{
|
|
OTOpndCast opcast = (OTOpndCast)op;
|
|
if((opcast.type == typeof(double)) && (opcast.value is OTOpndInt))
|
|
{
|
|
return opcast.value;
|
|
}
|
|
}
|
|
return op;
|
|
}
|
|
|
|
/**
|
|
* Strip svperflvovs Brtrues so we don't end up with stuff like 'if (!! someint) ...'.
|
|
*/
|
|
public static OTOpnd StripBrtrue(OTOpnd op)
|
|
{
|
|
if(op is OTOpndUnOp)
|
|
{
|
|
OTOpndUnOp opunop = (OTOpndUnOp)op;
|
|
if(opunop.opCode == MyOp.Brtrue)
|
|
return opunop.value;
|
|
}
|
|
return op;
|
|
}
|
|
|
|
/*
|
|
* Local variable declaration.
|
|
*/
|
|
private class OTLocal
|
|
{
|
|
public int number;
|
|
public string name;
|
|
public string type;
|
|
|
|
public int nlclreads;
|
|
public int nlclwrites;
|
|
|
|
public OTLocal(int number, string name, string type)
|
|
{
|
|
this.number = number;
|
|
this.name = name.StartsWith("tmp$") ? name : name + "$" + number;
|
|
this.type = type;
|
|
}
|
|
|
|
public string DumpString()
|
|
{
|
|
return AbbrType(type) + ' ' + name;
|
|
}
|
|
}
|
|
|
|
/***********************************************\
|
|
* Tokens that are one-for-one with CIL code *
|
|
\***********************************************/
|
|
|
|
/*
|
|
* Part of instruction stream.
|
|
*/
|
|
public abstract class OTCilInstr
|
|
{
|
|
public int offset; // cil offset
|
|
|
|
public OTCilInstr(int offset)
|
|
{
|
|
this.offset = offset;
|
|
}
|
|
|
|
public abstract string DumpString();
|
|
public abstract void BuildStatements(OTDecompile decompile, LinkedListNode<OTCilInstr> link);
|
|
|
|
protected void CheckEmptyStack(OTDecompile decompile, string opMnemonic)
|
|
{
|
|
if(decompile.opstack.Count > 0)
|
|
{
|
|
Console.Error.WriteLine("CheckEmptyStack: " + decompile.method.Name + " 0x" + offset.ToString("X") + ": " +
|
|
opMnemonic + " stack depth " + decompile.opstack.Count);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Label mark point.
|
|
*/
|
|
private class OTLabel: OTCilInstr
|
|
{
|
|
public int number;
|
|
public string name;
|
|
|
|
public int lbljumps;
|
|
|
|
public OTLabel(int number, string name) : base(-1)
|
|
{
|
|
this.number = number;
|
|
this.name = name;
|
|
}
|
|
|
|
public string PrintableName
|
|
{
|
|
get
|
|
{
|
|
if(name.StartsWith(_doBreak))
|
|
return _doBreak + "$" + number;
|
|
if(name.StartsWith(_doCont))
|
|
return _doCont + "$" + number;
|
|
if(name.StartsWith(_forBreak))
|
|
return _forBreak + "$" + number;
|
|
if(name.StartsWith(_forCont))
|
|
return _forCont + "$" + number;
|
|
if(name.StartsWith(_whileBreak))
|
|
return _whileBreak + "$" + number;
|
|
if(name.StartsWith(_whileCont))
|
|
return _whileCont + "$" + number;
|
|
return name;
|
|
}
|
|
}
|
|
|
|
public override string DumpString()
|
|
{
|
|
return name + ":";
|
|
}
|
|
|
|
public override void BuildStatements(OTDecompile decompile, LinkedListNode<OTCilInstr> link)
|
|
{
|
|
OTStmtLabel.AddLast(decompile, this);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* 'try {'
|
|
*/
|
|
private class OTCilBegExcBlk: OTCilInstr
|
|
{
|
|
public LinkedList<OTCilBegCatBlk> catches = new LinkedList<OTCilBegCatBlk>();
|
|
|
|
public OTCilBegExcBlk(int offset) : base(offset)
|
|
{
|
|
}
|
|
|
|
public override string DumpString()
|
|
{
|
|
return "try {";
|
|
}
|
|
|
|
public override void BuildStatements(OTDecompile decompile, LinkedListNode<OTCilInstr> link)
|
|
{
|
|
CheckEmptyStack(decompile, "try");
|
|
|
|
// link the try itself onto outer block
|
|
OTStmtBegExcBlk trystmt = new OTStmtBegExcBlk();
|
|
decompile.AddLastStmt(trystmt);
|
|
|
|
// subsequent statements go to the try block
|
|
trystmt.tryblock = new OTStmtBlock();
|
|
decompile.trystack.Push(trystmt);
|
|
decompile.blockstack.Push(trystmt.tryblock);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* '} catch (...) {'
|
|
*/
|
|
private class OTCilBegCatBlk: OTCilInstr
|
|
{
|
|
public Type excType;
|
|
|
|
public OTCilBegCatBlk(int offset, Type excType) : base(offset)
|
|
{
|
|
this.excType = excType;
|
|
}
|
|
|
|
public override string DumpString()
|
|
{
|
|
return "} catch (" + AbbrType(excType) + ") {";
|
|
}
|
|
|
|
public override void BuildStatements(OTDecompile decompile, LinkedListNode<OTCilInstr> link)
|
|
{
|
|
CheckEmptyStack(decompile, "catch");
|
|
|
|
// link the catch itself onto the try statement
|
|
OTStmtBegExcBlk trystmt = decompile.trystack.Peek();
|
|
OTStmtBegCatBlk catstmt = new OTStmtBegCatBlk(excType);
|
|
trystmt.catches.AddLast(catstmt);
|
|
|
|
// start capturing statements into the catch block
|
|
catstmt.tryblock = trystmt;
|
|
catstmt.catchblock = new OTStmtBlock();
|
|
decompile.blockstack.Pop();
|
|
decompile.blockstack.Push(catstmt.catchblock);
|
|
|
|
// fill the stack slot with something for the exception argument
|
|
OTOpndDup dup = new OTOpndDup(++decompile.dupNo);
|
|
decompile.opstack.Push(dup);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* '} finally {'
|
|
*/
|
|
private class OTCilBegFinBlk: OTCilInstr
|
|
{
|
|
public OTCilBegFinBlk(int offset) : base(offset)
|
|
{
|
|
}
|
|
|
|
public override string DumpString()
|
|
{
|
|
return "} finally {";
|
|
}
|
|
|
|
public override void BuildStatements(OTDecompile decompile, LinkedListNode<OTCilInstr> link)
|
|
{
|
|
CheckEmptyStack(decompile, "finally");
|
|
|
|
// link the finally itself to the try statement
|
|
OTStmtBegExcBlk trystmt = decompile.trystack.Peek();
|
|
OTStmtBegFinBlk finstmt = new OTStmtBegFinBlk();
|
|
trystmt.finblock = finstmt;
|
|
|
|
// start capturing statements into the finally block
|
|
finstmt.tryblock = trystmt;
|
|
finstmt.finblock = new OTStmtBlock();
|
|
decompile.blockstack.Pop();
|
|
decompile.blockstack.Push(finstmt.finblock);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* '}' end of try
|
|
*/
|
|
private class OTCilEndExcBlk: OTCilInstr
|
|
{
|
|
public OTCilEndExcBlk(int offset) : base(offset)
|
|
{
|
|
}
|
|
|
|
public override string DumpString()
|
|
{
|
|
return "} // end try";
|
|
}
|
|
|
|
public override void BuildStatements(OTDecompile decompile, LinkedListNode<OTCilInstr> link)
|
|
{
|
|
CheckEmptyStack(decompile, "endtry");
|
|
|
|
// pop the try/catch/finally blocks from stacks
|
|
decompile.blockstack.Pop();
|
|
decompile.trystack.Pop();
|
|
|
|
// subsequent statements collect following the try
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Actual opcodes (instructions).
|
|
*/
|
|
private class OTCilNull: OTCilInstr
|
|
{
|
|
public MyOp opCode;
|
|
|
|
public OTCilNull(int offset, OpCode opCode) : base(offset)
|
|
{
|
|
this.opCode = MyOp.GetByName(opCode.Name);
|
|
}
|
|
|
|
public override string DumpString()
|
|
{
|
|
return opCode.ToString();
|
|
}
|
|
|
|
public override void BuildStatements(OTDecompile decompile, LinkedListNode<OTCilInstr> link)
|
|
{
|
|
switch(opCode.ToString())
|
|
{
|
|
case "conv.i1":
|
|
case "conv.i2":
|
|
case "conv.i4":
|
|
case "conv.i8":
|
|
{
|
|
OTOpnd value = decompile.opstack.Pop();
|
|
decompile.opstack.Push(new OTOpndCast(typeof(int), value));
|
|
break;
|
|
}
|
|
case "conv.r4":
|
|
case "conv.r8":
|
|
{
|
|
OTOpnd value = decompile.opstack.Pop();
|
|
decompile.opstack.Push(new OTOpndCast(typeof(double), value));
|
|
break;
|
|
}
|
|
case "dup":
|
|
{
|
|
OTOpnd value = decompile.opstack.Pop();
|
|
if(!(value is OTOpndDup))
|
|
{
|
|
OTOpndDup dup = new OTOpndDup(++decompile.dupNo);
|
|
OTStmtStore.AddLast(decompile, dup, value);
|
|
value = dup;
|
|
}
|
|
decompile.opstack.Push(value);
|
|
decompile.opstack.Push(value);
|
|
break;
|
|
}
|
|
case "endfinally":
|
|
break;
|
|
case "ldarg.0":
|
|
{
|
|
decompile.opstack.Push(new OTOpndArg(0, false, decompile));
|
|
break;
|
|
}
|
|
case "ldarg.1":
|
|
{
|
|
decompile.opstack.Push(new OTOpndArg(1, false, decompile));
|
|
break;
|
|
}
|
|
case "ldarg.2":
|
|
{
|
|
decompile.opstack.Push(new OTOpndArg(2, false, decompile));
|
|
break;
|
|
}
|
|
case "ldarg.3":
|
|
{
|
|
decompile.opstack.Push(new OTOpndArg(3, false, decompile));
|
|
break;
|
|
}
|
|
case "ldc.i4.0":
|
|
{
|
|
decompile.opstack.Push(new OTOpndInt(0));
|
|
break;
|
|
}
|
|
case "ldc.i4.1":
|
|
{
|
|
decompile.opstack.Push(new OTOpndInt(1));
|
|
break;
|
|
}
|
|
case "ldc.i4.2":
|
|
{
|
|
decompile.opstack.Push(new OTOpndInt(2));
|
|
break;
|
|
}
|
|
case "ldc.i4.3":
|
|
{
|
|
decompile.opstack.Push(new OTOpndInt(3));
|
|
break;
|
|
}
|
|
case "ldc.i4.4":
|
|
{
|
|
decompile.opstack.Push(new OTOpndInt(4));
|
|
break;
|
|
}
|
|
case "ldc.i4.5":
|
|
{
|
|
decompile.opstack.Push(new OTOpndInt(5));
|
|
break;
|
|
}
|
|
case "ldc.i4.6":
|
|
{
|
|
decompile.opstack.Push(new OTOpndInt(6));
|
|
break;
|
|
}
|
|
case "ldc.i4.7":
|
|
{
|
|
decompile.opstack.Push(new OTOpndInt(7));
|
|
break;
|
|
}
|
|
case "ldc.i4.8":
|
|
{
|
|
decompile.opstack.Push(new OTOpndInt(8));
|
|
break;
|
|
}
|
|
case "ldc.i4.m1":
|
|
{
|
|
decompile.opstack.Push(new OTOpndInt(-1));
|
|
break;
|
|
}
|
|
case "ldelem.i4":
|
|
case "ldelem.r4":
|
|
case "ldelem.r8":
|
|
case "ldelem.ref":
|
|
{
|
|
OTOpnd index = decompile.opstack.Pop();
|
|
OTOpnd array = decompile.opstack.Pop();
|
|
decompile.opstack.Push(OTOpndArrayElem.Make(array, index, false, decompile));
|
|
break;
|
|
}
|
|
case "ldnull":
|
|
{
|
|
decompile.opstack.Push(new OTOpndNull());
|
|
break;
|
|
}
|
|
case "neg":
|
|
case "not":
|
|
{
|
|
OTOpnd value = decompile.opstack.Pop();
|
|
decompile.opstack.Push(OTOpndUnOp.Make(opCode, value));
|
|
break;
|
|
}
|
|
case "pop":
|
|
{
|
|
OTStmtVoid.AddLast(decompile, decompile.opstack.Pop());
|
|
break;
|
|
}
|
|
case "ret":
|
|
{
|
|
OTOpnd value = null;
|
|
if(decompile.method.ReturnType != typeof(void))
|
|
{
|
|
value = decompile.opstack.Pop();
|
|
}
|
|
CheckEmptyStack(decompile);
|
|
decompile.AddLastStmt(new OTStmtRet(value));
|
|
break;
|
|
}
|
|
case "stelem.i4":
|
|
case "stelem.r8":
|
|
case "stelem.ref":
|
|
{
|
|
OTOpnd value = decompile.opstack.Pop();
|
|
OTOpnd index = decompile.opstack.Pop();
|
|
OTOpnd array = decompile.opstack.Pop();
|
|
OTStmtStore.AddLast(decompile, OTOpndArrayElem.Make(array, index, false, decompile), value);
|
|
break;
|
|
}
|
|
case "throw":
|
|
{
|
|
OTOpnd value = decompile.opstack.Pop();
|
|
CheckEmptyStack(decompile);
|
|
decompile.AddLastStmt(new OTStmtThrow(value, decompile));
|
|
break;
|
|
}
|
|
case "add":
|
|
case "and":
|
|
case "ceq":
|
|
case "cgt":
|
|
case "cgt.un":
|
|
case "clt":
|
|
case "clt.un":
|
|
case "div":
|
|
case "div.un":
|
|
case "mul":
|
|
case "or":
|
|
case "rem":
|
|
case "rem.un":
|
|
case "shl":
|
|
case "shr":
|
|
case "shr.un":
|
|
case "sub":
|
|
case "xor":
|
|
{
|
|
OTOpnd rite = decompile.opstack.Pop();
|
|
OTOpnd left = decompile.opstack.Pop();
|
|
decompile.opstack.Push(OTOpndBinOp.Make(left, opCode, rite));
|
|
break;
|
|
}
|
|
default:
|
|
throw new Exception("unknown opcode " + opCode.ToString());
|
|
}
|
|
}
|
|
|
|
protected void CheckEmptyStack(OTDecompile decompile)
|
|
{
|
|
CheckEmptyStack(decompile, opCode.ToString());
|
|
}
|
|
}
|
|
|
|
private class OTCilField: OTCilNull
|
|
{
|
|
public FieldInfo field;
|
|
|
|
public OTCilField(int offset, OpCode opCode, FieldInfo field) : base(offset, opCode)
|
|
{
|
|
this.field = field;
|
|
}
|
|
|
|
public override string DumpString()
|
|
{
|
|
return opCode.ToString() + ' ' + field.Name;
|
|
}
|
|
|
|
public override void BuildStatements(OTDecompile decompile, LinkedListNode<OTCilInstr> link)
|
|
{
|
|
switch(opCode.ToString())
|
|
{
|
|
case "ldfld":
|
|
{
|
|
OTOpnd obj = decompile.opstack.Pop();
|
|
decompile.opstack.Push(OTOpndField.Make(obj, field));
|
|
break;
|
|
}
|
|
case "ldsfld":
|
|
{
|
|
decompile.opstack.Push(new OTOpndSField(field));
|
|
break;
|
|
}
|
|
case "stfld":
|
|
{
|
|
OTOpnd val = decompile.opstack.Pop();
|
|
OTOpnd obj = decompile.opstack.Pop();
|
|
OTStmtStore.AddLast(decompile, OTOpndField.Make(obj, field), val);
|
|
break;
|
|
}
|
|
case "stsfld":
|
|
{
|
|
OTOpnd val = decompile.opstack.Pop();
|
|
OTStmtStore.AddLast(decompile, new OTOpndSField(field), val);
|
|
break;
|
|
}
|
|
default:
|
|
throw new Exception("unknown opcode " + opCode.ToString());
|
|
}
|
|
}
|
|
}
|
|
|
|
private class OTCilLocal: OTCilNull
|
|
{
|
|
public OTLocal local;
|
|
|
|
public OTCilLocal(int offset, OpCode opCode, OTLocal local) : base(offset, opCode)
|
|
{
|
|
this.local = local;
|
|
}
|
|
|
|
public override string DumpString()
|
|
{
|
|
return opCode.ToString() + ' ' + local.name;
|
|
}
|
|
|
|
public override void BuildStatements(OTDecompile decompile, LinkedListNode<OTCilInstr> link)
|
|
{
|
|
switch(opCode.ToString())
|
|
{
|
|
case "ldloc":
|
|
{
|
|
decompile.opstack.Push(new OTOpndLocal(local));
|
|
break;
|
|
}
|
|
case "ldloca":
|
|
{
|
|
decompile.opstack.Push(new OTOpndLocalRef(local));
|
|
break;
|
|
}
|
|
case "stloc":
|
|
{
|
|
OTOpnd val = decompile.opstack.Pop();
|
|
OTStmtStore.AddLast(decompile, new OTOpndLocal(local), val);
|
|
break;
|
|
}
|
|
default:
|
|
throw new Exception("unknown opcode " + opCode.ToString());
|
|
}
|
|
}
|
|
}
|
|
|
|
private class OTCilType: OTCilNull
|
|
{
|
|
public Type type;
|
|
|
|
public OTCilType(int offset, OpCode opCode, Type type) : base(offset, opCode)
|
|
{
|
|
this.type = type;
|
|
}
|
|
|
|
public override string DumpString()
|
|
{
|
|
return opCode.ToString() + ' ' + AbbrType(type);
|
|
}
|
|
|
|
public override void BuildStatements(OTDecompile decompile, LinkedListNode<OTCilInstr> link)
|
|
{
|
|
switch(opCode.ToString())
|
|
{
|
|
case "box":
|
|
{
|
|
break;
|
|
}
|
|
case "castclass":
|
|
case "unbox.any":
|
|
{
|
|
OTOpnd value = decompile.opstack.Pop();
|
|
decompile.opstack.Push(new OTOpndCast(type, value));
|
|
break;
|
|
}
|
|
case "ldelem":
|
|
{
|
|
OTOpnd index = decompile.opstack.Pop();
|
|
OTOpnd array = decompile.opstack.Pop();
|
|
decompile.opstack.Push(OTOpndArrayElem.Make(array, index, false, decompile));
|
|
break;
|
|
}
|
|
case "ldelema":
|
|
{
|
|
OTOpnd index = decompile.opstack.Pop();
|
|
OTOpnd array = decompile.opstack.Pop();
|
|
decompile.opstack.Push(OTOpndArrayElem.Make(array, index, true, decompile));
|
|
break;
|
|
}
|
|
case "newarr":
|
|
{
|
|
OTOpnd index = decompile.opstack.Pop();
|
|
decompile.opstack.Push(new OTOpndNewarr(type, index));
|
|
break;
|
|
}
|
|
case "stelem":
|
|
{
|
|
OTOpnd value = decompile.opstack.Pop();
|
|
OTOpnd index = decompile.opstack.Pop();
|
|
OTOpnd array = decompile.opstack.Pop();
|
|
OTStmtStore.AddLast(decompile, OTOpndArrayElem.Make(array, index, false, decompile), value);
|
|
break;
|
|
}
|
|
default:
|
|
throw new Exception("unknown opcode " + opCode.ToString());
|
|
}
|
|
}
|
|
}
|
|
|
|
private class OTCilLabel: OTCilNull
|
|
{
|
|
public OTLabel label;
|
|
|
|
public OTCilLabel(int offset, OpCode opCode, OTLabel label) : base(offset, opCode)
|
|
{
|
|
this.label = label;
|
|
}
|
|
|
|
public override string DumpString()
|
|
{
|
|
return opCode.ToString() + ' ' + label.name;
|
|
}
|
|
|
|
public override void BuildStatements(OTDecompile decompile, LinkedListNode<OTCilInstr> link)
|
|
{
|
|
switch(opCode.ToString())
|
|
{
|
|
|
|
/*
|
|
* We don't handle non-empty stack at branch points.
|
|
*
|
|
* So handle this case specially:
|
|
*
|
|
* dup
|
|
* ldc.i4.0
|
|
* bge.s llAbstemp << we are here
|
|
* neg
|
|
* llAbstemp:
|
|
*
|
|
* becomes:
|
|
*
|
|
* call llAbs
|
|
*/
|
|
case "bge.s":
|
|
{
|
|
OTOpnd rite = decompile.opstack.Pop(); // alleged zero
|
|
OTOpnd left = decompile.opstack.Pop(); // alleged dup
|
|
|
|
if((label.name == _llAbstemp) && (decompile.opstack.Count > 0))
|
|
{
|
|
LinkedListNode<OTCilInstr> linkneg = link.Next;
|
|
if((left is OTOpndDup) && (rite is OTOpndInt) &&
|
|
(linkneg != null) && (linkneg.Value is OTCilNull) &&
|
|
(((OTCilNull)linkneg.Value).opCode == MyOp.Neg))
|
|
{
|
|
OTOpndInt riteint = (OTOpndInt)rite;
|
|
LinkedListNode<OTCilInstr> linklbl = linkneg.Next;
|
|
if((riteint.value == 0) && (linklbl != null) && (linklbl.Value is OTLabel) &&
|
|
(((OTLabel)linklbl.Value) == label))
|
|
{
|
|
linkneg.List.Remove(linkneg);
|
|
linklbl.List.Remove(linklbl);
|
|
MethodInfo method = typeof(ScriptBaseClass).GetMethod("llAbs");
|
|
OTOpnd[] args = new OTOpnd[] { new OTOpndNull(), decompile.opstack.Pop() };
|
|
OTOpndCall.AddLast(decompile, method, args);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
CheckEmptyStack(decompile);
|
|
OTOpnd valu = OTOpndBinOp.Make(left, opCode, rite);
|
|
OTStmt jump = OTStmtJump.Make(label);
|
|
decompile.AddLastStmt(new OTStmtCond(valu, jump));
|
|
break;
|
|
}
|
|
|
|
case "beq":
|
|
case "bge":
|
|
case "bgt":
|
|
case "ble":
|
|
case "blt":
|
|
case "bne.un":
|
|
case "beq.s":
|
|
case "bgt.s":
|
|
case "ble.s":
|
|
case "blt.s":
|
|
case "bne.un.s":
|
|
{
|
|
OTOpnd rite = decompile.opstack.Pop();
|
|
OTOpnd left = decompile.opstack.Pop();
|
|
CheckEmptyStack(decompile);
|
|
OTOpnd valu = OTOpndBinOp.Make(left, opCode, rite);
|
|
OTStmt jump = OTStmtJump.Make(label);
|
|
decompile.AddLastStmt(new OTStmtCond(valu, jump));
|
|
break;
|
|
}
|
|
case "brfalse":
|
|
case "brfalse.s":
|
|
case "brtrue":
|
|
case "brtrue.s":
|
|
{
|
|
OTOpnd value = decompile.opstack.Pop();
|
|
CheckEmptyStack(decompile);
|
|
OTOpnd valu = OTOpndUnOp.Make(opCode, value);
|
|
OTStmt jump = OTStmtJump.Make(label);
|
|
decompile.AddLastStmt(new OTStmtCond(valu, jump));
|
|
break;
|
|
}
|
|
case "br":
|
|
case "br.s":
|
|
case "leave":
|
|
{
|
|
CheckEmptyStack(decompile);
|
|
OTStmt jump = OTStmtJump.Make(label);
|
|
decompile.AddLastStmt(jump);
|
|
break;
|
|
}
|
|
default:
|
|
throw new Exception("unknown opcode " + opCode.ToString());
|
|
}
|
|
}
|
|
}
|
|
|
|
private class OTCilLabels: OTCilNull
|
|
{
|
|
public OTLabel[] labels;
|
|
|
|
public OTCilLabels(int offset, OpCode opCode, OTLabel[] labels) : base(offset, opCode)
|
|
{
|
|
this.labels = labels;
|
|
}
|
|
|
|
public override string DumpString()
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.Append(opCode.ToString());
|
|
foreach(OTLabel label in labels)
|
|
{
|
|
sb.Append(' ');
|
|
sb.Append(label.name);
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
|
|
public override void BuildStatements(OTDecompile decompile, LinkedListNode<OTCilInstr> link)
|
|
{
|
|
switch(opCode.ToString())
|
|
{
|
|
case "switch":
|
|
{
|
|
OTOpnd value = decompile.opstack.Pop();
|
|
CheckEmptyStack(decompile);
|
|
decompile.AddLastStmt(new OTStmtSwitch(value, labels));
|
|
break;
|
|
}
|
|
default:
|
|
throw new Exception("unknown opcode " + opCode.ToString());
|
|
}
|
|
}
|
|
}
|
|
|
|
private class OTCilMethod: OTCilNull
|
|
{
|
|
public MethodInfo method;
|
|
|
|
public OTCilMethod(int offset, OpCode opCode, MethodInfo method) : base(offset, opCode)
|
|
{
|
|
this.method = method;
|
|
}
|
|
|
|
public override string DumpString()
|
|
{
|
|
return opCode.ToString() + ' ' + method.Name;
|
|
}
|
|
|
|
public override void BuildStatements(OTDecompile decompile, LinkedListNode<OTCilInstr> link)
|
|
{
|
|
switch(opCode.ToString())
|
|
{
|
|
case "call":
|
|
case "callvirt":
|
|
{
|
|
int nargs = method.GetParameters().Length;
|
|
if(!method.IsStatic)
|
|
nargs++;
|
|
OTOpnd[] args = new OTOpnd[nargs];
|
|
for(int i = nargs; --i >= 0;)
|
|
{
|
|
args[i] = decompile.opstack.Pop();
|
|
}
|
|
OTOpndCall.AddLast(decompile, method, args);
|
|
break;
|
|
}
|
|
default:
|
|
throw new Exception("unknown opcode " + opCode.ToString());
|
|
}
|
|
}
|
|
}
|
|
|
|
private class OTCilCtor: OTCilNull
|
|
{
|
|
public ConstructorInfo ctor;
|
|
|
|
public OTCilCtor(int offset, OpCode opCode, ConstructorInfo ctor) : base(offset, opCode)
|
|
{
|
|
this.ctor = ctor;
|
|
}
|
|
|
|
public override string DumpString()
|
|
{
|
|
return opCode.ToString() + ' ' + AbbrType(ctor.DeclaringType);
|
|
}
|
|
|
|
public override void BuildStatements(OTDecompile decompile, LinkedListNode<OTCilInstr> link)
|
|
{
|
|
switch(opCode.ToString())
|
|
{
|
|
case "newobj":
|
|
{
|
|
int nargs = ctor.GetParameters().Length;
|
|
OTOpnd[] args = new OTOpnd[nargs];
|
|
for(int i = nargs; --i >= 0;)
|
|
{
|
|
args[i] = decompile.opstack.Pop();
|
|
}
|
|
decompile.opstack.Push(OTOpndNewobj.Make(ctor, args));
|
|
break;
|
|
}
|
|
default:
|
|
throw new Exception("unknown opcode " + opCode.ToString());
|
|
}
|
|
}
|
|
}
|
|
|
|
private class OTCilDouble: OTCilNull
|
|
{
|
|
public double value;
|
|
|
|
public OTCilDouble(int offset, OpCode opCode, double value) : base(offset, opCode)
|
|
{
|
|
this.value = value;
|
|
}
|
|
|
|
public override string DumpString()
|
|
{
|
|
return opCode.ToString() + ' ' + value;
|
|
}
|
|
|
|
public override void BuildStatements(OTDecompile decompile, LinkedListNode<OTCilInstr> link)
|
|
{
|
|
switch(opCode.ToString())
|
|
{
|
|
case "ldc.r8":
|
|
{
|
|
decompile.opstack.Push(new OTOpndDouble(value));
|
|
break;
|
|
}
|
|
default:
|
|
throw new Exception("unknown opcode " + opCode.ToString());
|
|
}
|
|
}
|
|
}
|
|
|
|
private class OTCilFloat: OTCilNull
|
|
{
|
|
public float value;
|
|
|
|
public OTCilFloat(int offset, OpCode opCode, float value) : base(offset, opCode)
|
|
{
|
|
this.value = value;
|
|
}
|
|
|
|
public override string DumpString()
|
|
{
|
|
return opCode.ToString() + ' ' + value;
|
|
}
|
|
|
|
public override void BuildStatements(OTDecompile decompile, LinkedListNode<OTCilInstr> link)
|
|
{
|
|
switch(opCode.ToString())
|
|
{
|
|
case "ldc.r4":
|
|
{
|
|
decompile.opstack.Push(new OTOpndFloat(value));
|
|
break;
|
|
}
|
|
default:
|
|
throw new Exception("unknown opcode " + opCode.ToString());
|
|
}
|
|
}
|
|
}
|
|
|
|
private class OTCilInteger: OTCilNull
|
|
{
|
|
public int value;
|
|
|
|
public OTCilInteger(int offset, OpCode opCode, int value) : base(offset, opCode)
|
|
{
|
|
this.value = value;
|
|
}
|
|
|
|
public override string DumpString()
|
|
{
|
|
return opCode.ToString() + ' ' + value;
|
|
}
|
|
|
|
public override void BuildStatements(OTDecompile decompile, LinkedListNode<OTCilInstr> link)
|
|
{
|
|
switch(opCode.ToString())
|
|
{
|
|
case "ldarg":
|
|
case "ldarg.s":
|
|
{
|
|
decompile.opstack.Push(new OTOpndArg(value, false, decompile));
|
|
break;
|
|
}
|
|
case "ldarga":
|
|
case "ldarga.s":
|
|
{
|
|
decompile.opstack.Push(new OTOpndArg(value, true, decompile));
|
|
break;
|
|
}
|
|
case "ldc.i4":
|
|
case "ldc.i4.s":
|
|
{
|
|
decompile.opstack.Push(new OTOpndInt(value));
|
|
break;
|
|
}
|
|
case "starg":
|
|
{
|
|
OTOpnd val = decompile.opstack.Pop();
|
|
OTStmtStore.AddLast(decompile, new OTOpndArg(value, false, decompile), val);
|
|
break;
|
|
}
|
|
default:
|
|
throw new Exception("unknown opcode " + opCode.ToString());
|
|
}
|
|
}
|
|
}
|
|
|
|
private class OTCilString: OTCilNull
|
|
{
|
|
public string value;
|
|
|
|
public OTCilString(int offset, OpCode opCode, string value) : base(offset, opCode)
|
|
{
|
|
this.value = value;
|
|
}
|
|
|
|
public override string DumpString()
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.Append(opCode.ToString());
|
|
sb.Append(' ');
|
|
TokenDeclInline.PrintParamString(sb, value);
|
|
return sb.ToString();
|
|
}
|
|
|
|
public override void BuildStatements(OTDecompile decompile, LinkedListNode<OTCilInstr> link)
|
|
{
|
|
switch(opCode.ToString())
|
|
{
|
|
case "ldstr":
|
|
{
|
|
decompile.opstack.Push(new OTOpndString(value));
|
|
break;
|
|
}
|
|
default:
|
|
throw new Exception("unknown opcode " + opCode.ToString());
|
|
}
|
|
}
|
|
}
|
|
|
|
/***************************************\
|
|
* Tokens what are on operand stack. *
|
|
\***************************************/
|
|
|
|
public abstract class OTOpnd
|
|
{
|
|
|
|
/**
|
|
* See if it possibly has any side effects.
|
|
*/
|
|
public abstract bool HasSideEffects
|
|
{
|
|
get;
|
|
}
|
|
|
|
/**
|
|
* Increment reference counts.
|
|
*/
|
|
public virtual void CountRefs(bool writing)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* If this operand is a 'by reference' operand,
|
|
* return the corresponding 'by value' operand.
|
|
*/
|
|
public virtual OTOpnd GetNonByRefOpnd()
|
|
{
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* If this operand is same as oldopnd, replace it with newopnd.
|
|
*
|
|
* This default just does a shallow search which is ok if this operand does not have any sub-operands.
|
|
* But it must be overridden for a deep search if this operand has any sub-operands.
|
|
*/
|
|
public virtual OTOpnd ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd, ref bool rc)
|
|
{
|
|
if(SameAs(oldopnd))
|
|
{
|
|
rc = true;
|
|
return newopnd;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* See if the two operands are the same value.
|
|
* Note that calls might have side-effects so are never the same.
|
|
*/
|
|
public abstract bool SameAs(OTOpnd other);
|
|
|
|
/**
|
|
* Get a printable string representation of the operand.
|
|
*/
|
|
public abstract string PrintableString
|
|
{
|
|
get;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Argument variable.
|
|
*/
|
|
private class OTOpndArg: OTOpnd
|
|
{
|
|
public int index;
|
|
public bool byref;
|
|
|
|
private OTDecompile decompile;
|
|
|
|
public OTOpndArg(int index, bool byref, OTDecompile decompile)
|
|
{
|
|
this.index = index;
|
|
this.byref = byref;
|
|
this.decompile = decompile;
|
|
}
|
|
|
|
public override bool HasSideEffects
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public override OTOpnd GetNonByRefOpnd()
|
|
{
|
|
if(!byref)
|
|
return this;
|
|
return new OTOpndArg(index, false, decompile);
|
|
}
|
|
|
|
public override bool SameAs(OTOpnd other)
|
|
{
|
|
if(!(other is OTOpndArg))
|
|
return false;
|
|
return (((OTOpndArg)other).byref == byref) && (((OTOpndArg)other).index == index);
|
|
}
|
|
|
|
public override string PrintableString
|
|
{
|
|
get
|
|
{
|
|
string argname = decompile.MethArgName(index);
|
|
return byref ? ("ref " + argname) : argname;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Element of an array.
|
|
*/
|
|
private class OTOpndArrayElem: OTOpnd
|
|
{
|
|
public bool byref;
|
|
public OTOpnd array;
|
|
public OTOpnd index;
|
|
|
|
public static OTOpnd Make(OTOpnd array, OTOpnd index, bool byref, OTDecompile decompile)
|
|
{
|
|
/*
|
|
* arg$0.glblVars.iar<type>[<intconst>] is a reference to a global variable
|
|
* likewise so is __xmrinst.glblVars.iar<type>[<intconst>]
|
|
*/
|
|
if((array is OTOpndField) && (index is OTOpndInt))
|
|
{
|
|
|
|
/*
|
|
* arrayfield = (arg$0.glblVars).iar<type>
|
|
* arrayfieldobj = arg$0.glblVars
|
|
* iartypename = iar<type>
|
|
*/
|
|
OTOpndField arrayfield = (OTOpndField)array;
|
|
OTOpnd arrayfieldobj = arrayfield.obj;
|
|
string iartypename = arrayfield.field.Name;
|
|
|
|
/*
|
|
* See if they are what they are supposed to be.
|
|
*/
|
|
if((arrayfieldobj is OTOpndField) && iartypename.StartsWith("iar"))
|
|
{
|
|
|
|
/*
|
|
* arrayfieldobjfield = arg$0.glblVars
|
|
*/
|
|
OTOpndField arrayfieldobjfield = (OTOpndField)arrayfieldobj;
|
|
|
|
/*
|
|
* See if the parts are what they are supposed to be.
|
|
*/
|
|
if(IsArg0OrXMRInst(arrayfieldobjfield.obj) && (arrayfieldobjfield.field.Name == "glblVars"))
|
|
{
|
|
|
|
/*
|
|
* Everything matches up, make a global variable instead of an array reference.
|
|
*/
|
|
return new OTOpndGlobal(iartypename, ((OTOpndInt)index).value, byref, decompile.scriptObjCode);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Other array reference.
|
|
*/
|
|
OTOpndArrayElem it = new OTOpndArrayElem();
|
|
it.array = array;
|
|
it.index = index;
|
|
it.byref = byref;
|
|
return it;
|
|
}
|
|
|
|
private OTOpndArrayElem()
|
|
{
|
|
}
|
|
|
|
public override bool HasSideEffects
|
|
{
|
|
get
|
|
{
|
|
return array.HasSideEffects || index.HasSideEffects;
|
|
}
|
|
}
|
|
|
|
public override void CountRefs(bool writing)
|
|
{
|
|
array.CountRefs(false);
|
|
index.CountRefs(false);
|
|
}
|
|
|
|
public override OTOpnd GetNonByRefOpnd()
|
|
{
|
|
if(!byref)
|
|
return this;
|
|
OTOpndArrayElem it = new OTOpndArrayElem();
|
|
it.array = array;
|
|
it.index = index;
|
|
return it;
|
|
}
|
|
|
|
public override OTOpnd ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd, ref bool rc)
|
|
{
|
|
if(SameAs(oldopnd))
|
|
{
|
|
rc = true;
|
|
return newopnd;
|
|
}
|
|
array = array.ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
index = index.ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
return this;
|
|
}
|
|
|
|
public override bool SameAs(OTOpnd other)
|
|
{
|
|
if(!(other is OTOpndArrayElem))
|
|
return false;
|
|
OTOpndArrayElem otherae = (OTOpndArrayElem)other;
|
|
return array.SameAs(otherae.array) && index.SameAs(otherae.index);
|
|
}
|
|
|
|
public override string PrintableString
|
|
{
|
|
get
|
|
{
|
|
return (byref ? "ref " : "") + array.PrintableString + "[" + index.PrintableString + "]";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* See if the argument is a reference to arg$0 or __xmrinst
|
|
*/
|
|
public static bool IsArg0OrXMRInst(OTOpnd obj)
|
|
{
|
|
if(obj is OTOpndArg)
|
|
{
|
|
OTOpndArg objarg = (OTOpndArg)obj;
|
|
return objarg.index == 0;
|
|
}
|
|
if(obj is OTOpndLocal)
|
|
{
|
|
OTOpndLocal objlcl = (OTOpndLocal)obj;
|
|
return objlcl.local.name.StartsWith(_xmrinstlocal);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Binary operator.
|
|
*/
|
|
private class OTOpndBinOp: OTOpnd
|
|
{
|
|
public OTOpnd left;
|
|
public MyOp opCode;
|
|
public OTOpnd rite;
|
|
|
|
private static Dictionary<string, string> xor1ops = InitXor1Ops();
|
|
|
|
private static Dictionary<string, string> InitXor1Ops()
|
|
{
|
|
Dictionary<string, string> d = new Dictionary<string, string>();
|
|
d["ceq"] = "cne";
|
|
d["cge"] = "clt";
|
|
d["cgt"] = "cle";
|
|
d["cle"] = "cgt";
|
|
d["clt"] = "cge";
|
|
d["cne"] = "ceq";
|
|
return d;
|
|
}
|
|
|
|
public static OTOpnd Make(OTOpnd left, MyOp opCode, OTOpnd rite)
|
|
{
|
|
// ((x clt y) xor 1) => (x cge y) etc
|
|
string xor1op;
|
|
if((left is OTOpndBinOp) && xor1ops.TryGetValue(((OTOpndBinOp)left).opCode.name, out xor1op) &&
|
|
(opCode == MyOp.Xor) &&
|
|
(rite is OTOpndInt) && (((OTOpndInt)rite).value == 1))
|
|
{
|
|
opCode = MyOp.GetByName(xor1op);
|
|
}
|
|
|
|
// handle strcmp() cases (see OTOpndStrCmp)
|
|
if(left is OTOpndStrCmp)
|
|
{
|
|
OTOpnd strcmp = ((OTOpndStrCmp)left).MakeBinOp(opCode, rite);
|
|
if(strcmp != null)
|
|
return strcmp;
|
|
}
|
|
|
|
// nothing special, make as is
|
|
OTOpndBinOp it = new OTOpndBinOp();
|
|
it.left = left;
|
|
it.opCode = opCode;
|
|
it.rite = rite;
|
|
return it;
|
|
}
|
|
|
|
private OTOpndBinOp()
|
|
{
|
|
}
|
|
|
|
public override bool HasSideEffects
|
|
{
|
|
get
|
|
{
|
|
return left.HasSideEffects || rite.HasSideEffects;
|
|
}
|
|
}
|
|
|
|
public override void CountRefs(bool writing)
|
|
{
|
|
left.CountRefs(false);
|
|
rite.CountRefs(false);
|
|
}
|
|
|
|
public override OTOpnd ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd, ref bool rc)
|
|
{
|
|
if(SameAs(oldopnd))
|
|
{
|
|
rc = true;
|
|
return newopnd;
|
|
}
|
|
left = left.ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
rite = rite.ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
return this;
|
|
}
|
|
|
|
public override bool SameAs(OTOpnd other)
|
|
{
|
|
if(!(other is OTOpndBinOp))
|
|
return false;
|
|
OTOpndBinOp otherbo = (OTOpndBinOp)other;
|
|
return left.SameAs(otherbo.left) && (opCode.ToString() == otherbo.opCode.ToString()) && rite.SameAs(otherbo.rite);
|
|
}
|
|
|
|
public override string PrintableString
|
|
{
|
|
get
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
bool leftneedsparen = ItNeedsParentheses(left, true);
|
|
if(leftneedsparen)
|
|
sb.Append('(');
|
|
sb.Append(left.PrintableString);
|
|
if(leftneedsparen)
|
|
sb.Append(')');
|
|
|
|
sb.Append(' ');
|
|
sb.Append(opCode.source);
|
|
sb.Append(' ');
|
|
|
|
bool riteneedsparen = ItNeedsParentheses(rite, false);
|
|
if(riteneedsparen)
|
|
sb.Append('(');
|
|
sb.Append(rite.PrintableString);
|
|
if(riteneedsparen)
|
|
sb.Append(')');
|
|
|
|
return sb.ToString();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* See if source code representation requires parentheses around the given operand.
|
|
* @param it = the other operand to decide about
|
|
* @param itleft = true: 'it' is on the left of this operand (A $ B) # C
|
|
* false: 'it' is on the right of this operand A $ (B # C)
|
|
*/
|
|
private bool ItNeedsParentheses(OTOpnd it, bool itleft)
|
|
{
|
|
if(!(it is OTOpndBinOp))
|
|
return false;
|
|
string itop = ((OTOpndBinOp)it).opCode.source;
|
|
string myop = opCode.source;
|
|
|
|
// find them in table. higher number is for *, lower is for +.
|
|
int itpi, mypi;
|
|
if(!precedence.TryGetValue(itop, out itpi))
|
|
return true;
|
|
if(!precedence.TryGetValue(myop, out mypi))
|
|
return true;
|
|
int itpiabs = Math.Abs(itpi);
|
|
int mypiabs = Math.Abs(mypi);
|
|
|
|
// if its precedence is lower (eg +) than my precedence (eg *), it needs parentheses
|
|
if(itpiabs < mypiabs)
|
|
return true;
|
|
|
|
// if its precedence is higher (eg *) than my precedence (eg +), it doesn't needs parentheses
|
|
if(itpiabs > mypiabs)
|
|
return false;
|
|
|
|
// if (A $ B) # C, we can safely go without the parentheses
|
|
if(itleft)
|
|
return false;
|
|
|
|
// my it
|
|
// A $ (B # C) only works without parentheses for commutative $
|
|
// A - (B + C) and A - (B - C) require parentheses
|
|
// A + (B - C) does not
|
|
return mypi < 0; // neg: things like -, /, etc require parentheses
|
|
// pos: things like +, *, etc do not need parens
|
|
}
|
|
|
|
// see MMRScriptReduce.PrecedenceInit()
|
|
private static Dictionary<string, int> precedence = InitPrecedence();
|
|
private static Dictionary<string, int> InitPrecedence()
|
|
{
|
|
Dictionary<string, int> d = new Dictionary<string, int>();
|
|
d["|"] = 140;
|
|
d["^"] = 160;
|
|
d["&"] = 180;
|
|
d["<<"] = -260;
|
|
d[">>"] = -260;
|
|
d["+"] = 280;
|
|
d["-"] = -280;
|
|
d["*"] = 320;
|
|
d["/"] = -320;
|
|
d["%"] = -320;
|
|
return d;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call with or without return value.
|
|
*/
|
|
private class OTOpndCall: OTOpnd
|
|
{
|
|
private static Dictionary<string, MethodInfo> mathmeths = InitMathMeths();
|
|
private static Dictionary<string, MethodInfo> InitMathMeths()
|
|
{
|
|
Dictionary<string, MethodInfo> d = new Dictionary<string, MethodInfo>();
|
|
d["Acos"] = typeof(ScriptBaseClass).GetMethod("llAcos");
|
|
d["Asin"] = typeof(ScriptBaseClass).GetMethod("llAsin");
|
|
d["Atan"] = typeof(ScriptBaseClass).GetMethod("llAtan");
|
|
d["Cos"] = typeof(ScriptBaseClass).GetMethod("llCos");
|
|
d["Abs"] = typeof(ScriptBaseClass).GetMethod("llFabs");
|
|
d["Log"] = typeof(ScriptBaseClass).GetMethod("llLog");
|
|
d["Log10"] = typeof(ScriptBaseClass).GetMethod("llLog10");
|
|
d["Round"] = typeof(ScriptBaseClass).GetMethod("llRound");
|
|
d["Sin"] = typeof(ScriptBaseClass).GetMethod("llSin");
|
|
d["Sqrt"] = typeof(ScriptBaseClass).GetMethod("llSqrt");
|
|
d["Tan"] = typeof(ScriptBaseClass).GetMethod("llTan");
|
|
return d;
|
|
}
|
|
|
|
public MethodInfo method;
|
|
public OTOpnd[] args;
|
|
|
|
// pushes on stack for return-value functions
|
|
// pushes to end of instruction stream for return-void functions
|
|
public static void AddLast(OTDecompile decompile, MethodInfo method, OTOpnd[] args)
|
|
{
|
|
int nargs = args.Length;
|
|
|
|
// heap tracker push is just the single arg value as far as we're concerned
|
|
if((nargs == 1) && (method.Name == _heapTrackerPush) && method.DeclaringType.Name.StartsWith("HeapTracker"))
|
|
{
|
|
decompile.opstack.Push(args[0]);
|
|
return;
|
|
}
|
|
|
|
// heap tracker pop is just a store as far as we're concerned
|
|
if((nargs == 2) && (method.Name == _heapTrackerPop) && method.DeclaringType.Name.StartsWith("HeapTracker"))
|
|
{
|
|
OTStmtStore.AddLast(decompile, args[0], args[1]);
|
|
return;
|
|
}
|
|
|
|
// string.Compare() is its own thing cuz it has to decompile many ways
|
|
if((nargs == 2) && (method.DeclaringType == typeof(string)) && (method.Name == "Compare"))
|
|
{
|
|
decompile.opstack.Push(new OTOpndStrCmp(args[0], args[1]));
|
|
return;
|
|
}
|
|
|
|
// ObjectToString, etc, should appear as casts
|
|
if((nargs == 1) && (method.DeclaringType == typeof(TypeCast)) && method.Name.EndsWith("ToBool"))
|
|
{
|
|
MethodInfo meth = typeof(XMRInstAbstract).GetMethod("xmr" + method.Name);
|
|
AddLast(decompile, meth, new OTOpnd[] { new OTOpndNull(), args[0] });
|
|
return;
|
|
}
|
|
if((nargs == 1) && (method.DeclaringType == typeof(TypeCast)) && method.Name.EndsWith("ToFloat"))
|
|
{
|
|
decompile.opstack.Push(new OTOpndCast(typeof(double), args[0]));
|
|
return;
|
|
}
|
|
if((nargs == 1) && (method.DeclaringType == typeof(TypeCast)) && method.Name.EndsWith("ToInteger"))
|
|
{
|
|
decompile.opstack.Push(new OTOpndCast(typeof(int), args[0]));
|
|
return;
|
|
}
|
|
if((nargs == 1) && (method.DeclaringType == typeof(TypeCast)) && method.Name.EndsWith("ToList"))
|
|
{
|
|
decompile.opstack.Push(new OTOpndCast(typeof(LSL_List), args[0]));
|
|
return;
|
|
}
|
|
if((nargs == 1) && (method.DeclaringType == typeof(TypeCast)) && method.Name.EndsWith("ToRotation"))
|
|
{
|
|
decompile.opstack.Push(new OTOpndCast(typeof(LSL_Rotation), args[0]));
|
|
return;
|
|
}
|
|
if((nargs == 1) && (method.DeclaringType == typeof(TypeCast)) && method.Name.EndsWith("ToString"))
|
|
{
|
|
decompile.opstack.Push(new OTOpndCast(typeof(string), args[0]));
|
|
return;
|
|
}
|
|
if((nargs == 1) && (method.DeclaringType == typeof(TypeCast)) && method.Name.EndsWith("ToVector"))
|
|
{
|
|
decompile.opstack.Push(new OTOpndCast(typeof(LSL_Vector), args[0]));
|
|
return;
|
|
}
|
|
|
|
if((method.DeclaringType == typeof(XMRInstAbstract)) && (method.Name == "xmrHeapLeft"))
|
|
{
|
|
AddLast(decompile, typeof(ScriptBaseClass).GetMethod("llGetFreeMemory"), new OTOpnd[] { new OTOpndNull() });
|
|
return;
|
|
}
|
|
|
|
// pop to entry in the list/object/string array
|
|
if(PopToGlobalArray(decompile, method, args))
|
|
return;
|
|
|
|
// strip off event handler argument unwrapper calls
|
|
if((nargs == 1) && (method.DeclaringType == typeof(TypeCast)) && method.Name.StartsWith("EHArgUnwrap"))
|
|
{
|
|
decompile.opstack.Push(args[0]);
|
|
return;
|
|
}
|
|
|
|
// translate Math method to ll method
|
|
MethodInfo mathmeth;
|
|
if((method.DeclaringType == typeof(Math)) && mathmeths.TryGetValue(method.Name, out mathmeth))
|
|
{
|
|
AddLast(decompile, mathmeth, new OTOpnd[] { new OTOpndNull(), args[0] });
|
|
return;
|
|
}
|
|
if((method.DeclaringType == typeof(Math)) && (method.Name == "Atan2"))
|
|
{
|
|
AddLast(decompile, typeof(ScriptBaseClass).GetMethod("llAtan2"), new OTOpnd[] { new OTOpndNull(), args[0], args[1] });
|
|
return;
|
|
}
|
|
if((method.DeclaringType == typeof(Math)) && (method.Name == "Pow"))
|
|
{
|
|
AddLast(decompile, typeof(ScriptBaseClass).GetMethod("llPow"), new OTOpnd[] { new OTOpndNull(), args[0], args[1] });
|
|
return;
|
|
}
|
|
|
|
// string concat should be a bunch of adds
|
|
if((method.Name == "Concat") && (method.DeclaringType == typeof(string)))
|
|
{
|
|
int k = args.Length;
|
|
while(k > 1)
|
|
{
|
|
int j = 0;
|
|
int i;
|
|
for(i = 0; i + 2 <= k; i += 2)
|
|
{
|
|
args[j++] = OTOpndBinOp.Make(args[i + 0], MyOp.Add, args[i + 1]);
|
|
}
|
|
while(i < k)
|
|
args[j++] = args[i++];
|
|
k = j;
|
|
}
|
|
if(k > 0)
|
|
decompile.opstack.Push(args[0]);
|
|
return;
|
|
}
|
|
|
|
// bunch of calls for rotation and vector arithmetic
|
|
if((method.DeclaringType == typeof(BinOpStr)) && BinOpStrCall(decompile, method, args))
|
|
return;
|
|
if((method.DeclaringType == typeof(ScriptCodeGen)) && (method.Name == "LSLRotationNegate"))
|
|
{
|
|
decompile.opstack.Push(OTOpndUnOp.Make(MyOp.Neg, args[0]));
|
|
return;
|
|
}
|
|
if((method.DeclaringType == typeof(ScriptCodeGen)) && (method.Name == "LSLVectorNegate"))
|
|
{
|
|
decompile.opstack.Push(OTOpndUnOp.Make(MyOp.Neg, args[0]));
|
|
return;
|
|
}
|
|
|
|
// otherwise process it as a call
|
|
OTOpndCall call = new OTOpndCall();
|
|
call.method = method;
|
|
call.args = args;
|
|
if(method.ReturnType == typeof(void))
|
|
{
|
|
OTStmtVoid.AddLast(decompile, call);
|
|
}
|
|
else
|
|
{
|
|
decompile.opstack.Push(call);
|
|
}
|
|
}
|
|
|
|
public override bool HasSideEffects
|
|
{
|
|
get
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handle a call to XMRInstArrays.Pop<List,Object,String>
|
|
* by converting it to a store directly into the array.
|
|
*/
|
|
private static bool PopToGlobalArray(OTDecompile decompile, MethodInfo method, OTOpnd[] args)
|
|
{
|
|
if(method.DeclaringType != typeof(XMRInstArrays))
|
|
return false;
|
|
if(args.Length != 3)
|
|
return false;
|
|
|
|
string array = null;
|
|
if(method.Name == "PopList")
|
|
array = "iarLists";
|
|
if(method.Name == "PopObject")
|
|
array = "iarObjects";
|
|
if(method.Name == "PopString")
|
|
array = "iarStrings";
|
|
if(array == null)
|
|
return false;
|
|
|
|
// make token that points to the iar<whatever> array
|
|
FieldInfo field = typeof(XMRInstArrays).GetField(array);
|
|
OTOpnd arrayfield = OTOpndField.Make(args[0], field);
|
|
|
|
// make token that points to the element to be popped to
|
|
OTOpnd element = OTOpndArrayElem.Make(arrayfield, args[1], false, decompile);
|
|
|
|
// make a statement to store value in that element
|
|
OTStmtStore.AddLast(decompile, element, args[2]);
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* BinOpStr has a bunch of calls to do funky arithmetic.
|
|
* Instead of generating a call, put back the original source.
|
|
*/
|
|
private static bool BinOpStrCall(OTDecompile decompile, MethodInfo method, OTOpnd[] args)
|
|
{
|
|
switch(method.Name)
|
|
{
|
|
case "MethFloatAddList":
|
|
case "MethIntAddList":
|
|
case "MethKeyAddList":
|
|
case "MethListAddFloat":
|
|
case "MethListAddInt":
|
|
case "MethListAddKey":
|
|
case "MethListAddList":
|
|
case "MethListAddObj":
|
|
case "MethListAddRot":
|
|
case "MethListAddStr":
|
|
case "MethListAddVec":
|
|
case "MethObjAddList":
|
|
case "MethRotAddList":
|
|
case "MethRotAddRot":
|
|
case "MethStrAddList":
|
|
case "MethVecAddList":
|
|
case "MethVecAddVec":
|
|
{
|
|
decompile.opstack.Push(OTOpndBinOp.Make(args[0], MyOp.Add, args[1]));
|
|
return true;
|
|
}
|
|
|
|
case "MethListEqList":
|
|
case "MethRotEqRot":
|
|
case "MethVecEqVec":
|
|
{
|
|
decompile.opstack.Push(OTOpndBinOp.Make(args[0], MyOp.Ceq, args[1]));
|
|
return true;
|
|
}
|
|
|
|
case "MethListNeList":
|
|
case "MethRotNeRot":
|
|
case "MethVecNeVec":
|
|
{
|
|
decompile.opstack.Push(OTOpndBinOp.Make(args[0], MyOp.Cne, args[1]));
|
|
return true;
|
|
}
|
|
|
|
case "MethRotSubRot":
|
|
case "MethVecSubVec":
|
|
{
|
|
decompile.opstack.Push(OTOpndBinOp.Make(args[0], MyOp.Sub, args[1]));
|
|
return true;
|
|
}
|
|
|
|
case "MethFloatMulVec":
|
|
case "MethIntMulVec":
|
|
case "MethRotMulRot":
|
|
case "MethVecMulFloat":
|
|
case "MethVecMulInt":
|
|
case "MethVecMulRot":
|
|
case "MethVecMulVec":
|
|
{
|
|
decompile.opstack.Push(OTOpndBinOp.Make(args[0], MyOp.Mul, args[1]));
|
|
return true;
|
|
}
|
|
|
|
case "MethRotDivRot":
|
|
case "MethVecDivFloat":
|
|
case "MethVecDivInt":
|
|
case "MethVecDivRot":
|
|
{
|
|
decompile.opstack.Push(OTOpndBinOp.Make(args[0], MyOp.Div, args[1]));
|
|
return true;
|
|
}
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private OTOpndCall()
|
|
{
|
|
}
|
|
|
|
public override void CountRefs(bool writing)
|
|
{
|
|
foreach(OTOpnd arg in args)
|
|
{
|
|
arg.CountRefs(false);
|
|
}
|
|
}
|
|
|
|
public override OTOpnd ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd, ref bool rc)
|
|
{
|
|
for(int i = 0; i < args.Length; i++)
|
|
{
|
|
args[i] = args[i].ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
public override bool SameAs(OTOpnd other)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
public override string PrintableString
|
|
{
|
|
get
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
// GetByKey(a,i) => a[i]
|
|
if((method.DeclaringType == typeof(XMR_Array)) && (method.Name == "GetByKey") && (args.Length == 2))
|
|
{
|
|
sb.Append(args[0].PrintableString);
|
|
sb.Append('[');
|
|
sb.Append(args[1].PrintableString);
|
|
sb.Append(']');
|
|
return sb.ToString();
|
|
}
|
|
|
|
// SetByKey(a,i,v) => a[i] = v
|
|
if((method.DeclaringType == typeof(XMR_Array)) && (method.Name == "SetByKey") && (args.Length == 3))
|
|
{
|
|
sb.Append(args[0].PrintableString);
|
|
sb.Append('[');
|
|
sb.Append(args[1].PrintableString);
|
|
sb.Append("] = ");
|
|
sb.Append(args[2].PrintableString);
|
|
return sb.ToString();
|
|
}
|
|
|
|
// CompValuListEl.GetElementFromList accesses list elements like an array.
|
|
if((method.DeclaringType == typeof(CompValuListEl)) && (method.Name == "GetElementFromList"))
|
|
{
|
|
sb.Append(args[0].PrintableString);
|
|
sb.Append('[');
|
|
sb.Append(args[1].PrintableString);
|
|
sb.Append(']');
|
|
return sb.ToString();
|
|
}
|
|
|
|
// methods that are part of ScriptBaseClass are LSL functions such as llSay()
|
|
// so we want to skip outputting "arg$0," as it is the hidden "this" argument.
|
|
// and there are also XMRInstAbstract functions such as xmrEventDequeue().
|
|
int starti = 0;
|
|
if((method.DeclaringType == typeof(ScriptBaseClass)) && !method.IsStatic)
|
|
starti = 1;
|
|
if((method.DeclaringType == typeof(XMRInstAbstract)) && !method.IsStatic)
|
|
starti = 1;
|
|
|
|
// likewise, method that have null as the declaring type are script-defined
|
|
// dynamic methods which have a hidden "this" argument passed as "arg$0".
|
|
if(method.DeclaringType == null)
|
|
starti = 1;
|
|
|
|
// all others we want to show the type name (such as Math.Abs, String.Compare, etc)
|
|
if(starti == 0)
|
|
{
|
|
sb.Append(AbbrType(method.DeclaringType));
|
|
sb.Append('.');
|
|
}
|
|
|
|
// script-defined functions have the param types as part of their name
|
|
// so strip them off here so they don't clutter things up
|
|
int i = method.Name.IndexOf('(');
|
|
if(i < 0)
|
|
sb.Append(method.Name);
|
|
else
|
|
sb.Append(method.Name.Substring(0, i));
|
|
|
|
// now add the call arguments
|
|
sb.Append(" (");
|
|
bool first = true;
|
|
foreach(OTOpnd arg in args)
|
|
{
|
|
if(--starti < 0)
|
|
{
|
|
if(!first)
|
|
sb.Append(", ");
|
|
sb.Append(arg.PrintableString);
|
|
first = false;
|
|
}
|
|
}
|
|
sb.Append(')');
|
|
return sb.ToString();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Cast value to the given type.
|
|
*/
|
|
private class OTOpndCast: OTOpnd
|
|
{
|
|
public Type type;
|
|
public OTOpnd value;
|
|
|
|
public OTOpndCast(Type type, OTOpnd value)
|
|
{
|
|
this.type = type;
|
|
this.value = value;
|
|
}
|
|
|
|
public override bool HasSideEffects
|
|
{
|
|
get
|
|
{
|
|
return value.HasSideEffects;
|
|
}
|
|
}
|
|
|
|
public override void CountRefs(bool writing)
|
|
{
|
|
value.CountRefs(false);
|
|
}
|
|
|
|
public override OTOpnd ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd, ref bool rc)
|
|
{
|
|
if(SameAs(oldopnd))
|
|
{
|
|
rc = true;
|
|
return newopnd;
|
|
}
|
|
value = value.ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
return this;
|
|
}
|
|
|
|
public override bool SameAs(OTOpnd other)
|
|
{
|
|
if(!(other is OTOpndCast))
|
|
return false;
|
|
OTOpndCast othercast = (OTOpndCast)other;
|
|
return (type == othercast.type) && value.SameAs(othercast.value);
|
|
}
|
|
|
|
public override string PrintableString
|
|
{
|
|
get
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.Append('(');
|
|
sb.Append(AbbrType(type));
|
|
sb.Append(") ");
|
|
if(value is OTOpndBinOp)
|
|
sb.Append('(');
|
|
sb.Append(value.PrintableString);
|
|
if(value is OTOpndBinOp)
|
|
sb.Append(')');
|
|
return sb.ToString();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Duplicate stack value without re-performing computation.
|
|
* Semantics just like local var except it doesn't have a declaration.
|
|
*/
|
|
private class OTOpndDup: OTOpnd
|
|
{
|
|
public int index;
|
|
public int ndupreads;
|
|
|
|
public OTOpndDup(int index)
|
|
{
|
|
this.index = index;
|
|
}
|
|
|
|
public override bool HasSideEffects
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public override void CountRefs(bool writing)
|
|
{
|
|
if(!writing)
|
|
ndupreads++;
|
|
}
|
|
|
|
public override bool SameAs(OTOpnd other)
|
|
{
|
|
if(!(other is OTOpndDup))
|
|
return false;
|
|
return ((OTOpndDup)other).index == index;
|
|
}
|
|
|
|
public override string PrintableString
|
|
{
|
|
get
|
|
{
|
|
return "dup$" + index;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Field of an object.
|
|
*/
|
|
private class OTOpndField: OTOpnd
|
|
{
|
|
public OTOpnd obj;
|
|
public FieldInfo field;
|
|
|
|
public static OTOpnd Make(OTOpnd obj, FieldInfo field)
|
|
{
|
|
// LSL_Float.value => the object itself
|
|
if((field.DeclaringType == typeof(LSL_Float)) && (field.Name == "value"))
|
|
{
|
|
return obj;
|
|
}
|
|
|
|
// LSL_Integer.value => the object itself
|
|
if((field.DeclaringType == typeof(LSL_Integer)) && (field.Name == "value"))
|
|
{
|
|
return obj;
|
|
}
|
|
|
|
// LSL_String.m_string => the object itself
|
|
if((field.DeclaringType == typeof(LSL_String)) && (field.Name == "m_string"))
|
|
{
|
|
return obj;
|
|
}
|
|
|
|
// some other field, output code to access it
|
|
// sometimes the object comes as by reference (value types), so we might need to deref it first
|
|
OTOpndField it = new OTOpndField();
|
|
it.obj = obj.GetNonByRefOpnd();
|
|
it.field = field;
|
|
return it;
|
|
}
|
|
|
|
private OTOpndField()
|
|
{
|
|
}
|
|
|
|
public override bool HasSideEffects
|
|
{
|
|
get
|
|
{
|
|
return obj.HasSideEffects;
|
|
}
|
|
}
|
|
|
|
public override void CountRefs(bool writing)
|
|
{
|
|
// the field may be getting written to, but the object is being read
|
|
obj.CountRefs(false);
|
|
}
|
|
|
|
public override OTOpnd ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd, ref bool rc)
|
|
{
|
|
if(SameAs(oldopnd))
|
|
{
|
|
rc = true;
|
|
return newopnd;
|
|
}
|
|
obj = obj.ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
return this;
|
|
}
|
|
|
|
public override bool SameAs(OTOpnd other)
|
|
{
|
|
if(!(other is OTOpndField))
|
|
return false;
|
|
OTOpndField otherfield = (OTOpndField)other;
|
|
return (field.Name == otherfield.field.Name) && obj.SameAs(otherfield.obj);
|
|
}
|
|
|
|
public override string PrintableString
|
|
{
|
|
get
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
if(obj is OTOpndBinOp)
|
|
sb.Append('(');
|
|
sb.Append(obj.PrintableString);
|
|
if(obj is OTOpndBinOp)
|
|
sb.Append(')');
|
|
sb.Append('.');
|
|
sb.Append(field.Name);
|
|
return sb.ToString();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Script-level global variable.
|
|
*/
|
|
private class OTOpndGlobal: OTOpnd
|
|
{
|
|
public string iartypename;
|
|
public int iararrayidx;
|
|
public bool byref;
|
|
public ScriptObjCode scriptObjCode;
|
|
|
|
public OTOpndGlobal(string iartypename, int iararrayidx, bool byref, ScriptObjCode scriptObjCode)
|
|
{
|
|
this.iartypename = iartypename;
|
|
this.iararrayidx = iararrayidx;
|
|
this.byref = byref;
|
|
this.scriptObjCode = scriptObjCode;
|
|
}
|
|
|
|
public override bool HasSideEffects
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public override OTOpnd GetNonByRefOpnd()
|
|
{
|
|
if(!byref)
|
|
return this;
|
|
return new OTOpndGlobal(iartypename, iararrayidx, false, scriptObjCode);
|
|
}
|
|
|
|
public override bool SameAs(OTOpnd other)
|
|
{
|
|
if(!(other is OTOpndGlobal))
|
|
return false;
|
|
OTOpndGlobal otherglobal = (OTOpndGlobal)other;
|
|
return (iartypename == otherglobal.iartypename) && (iararrayidx == otherglobal.iararrayidx);
|
|
}
|
|
|
|
public override string PrintableString
|
|
{
|
|
get
|
|
{
|
|
return (byref ? "ref " : "") + scriptObjCode.globalVarNames[iartypename][iararrayidx];
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* List initialization.
|
|
*/
|
|
private class OTOpndListIni: OTOpnd
|
|
{
|
|
public OTOpnd[] values;
|
|
|
|
/**
|
|
* Try to detect list initialization building idiom:
|
|
* dup$<n> = newarr object[<m>] << link points here
|
|
* dup$<n>[0] = bla
|
|
* dup$<n>[1] = bla
|
|
* ...
|
|
* ... newobj list (dup$<n>) ...
|
|
*/
|
|
public static bool Detect(LinkedListNode<OTStmt> link)
|
|
{
|
|
if(link == null)
|
|
return false;
|
|
|
|
/*
|
|
* Check for 'dup$<n> = newarr object[<m>]' and get listsize from <m>.
|
|
*/
|
|
OTStmtStore store = (OTStmtStore)link.Value;
|
|
if(!(store.varwr is OTOpndDup))
|
|
return false;
|
|
if(!(store.value is OTOpndNewarr))
|
|
return false;
|
|
OTOpndDup storevar = (OTOpndDup)store.varwr;
|
|
OTOpndNewarr storeval = (OTOpndNewarr)store.value;
|
|
if(storeval.type != typeof(object))
|
|
return false;
|
|
if(!(storeval.index is OTOpndInt))
|
|
return false;
|
|
int listsize = ((OTOpndInt)storeval.index).value;
|
|
|
|
/*
|
|
* Good chance of having list initializer, malloc an object to hold it.
|
|
*/
|
|
OTOpndListIni it = new OTOpndListIni();
|
|
it.values = new OTOpnd[listsize];
|
|
|
|
/*
|
|
* There should be exactly listsize statements following that of the form:
|
|
* dup$<n>[<i>] = bla
|
|
* If so, save the bla values in the values[] array.
|
|
*/
|
|
LinkedListNode<OTStmt> vallink = link;
|
|
for(int i = 0; i < listsize; i++)
|
|
{
|
|
vallink = vallink.Next;
|
|
if(vallink == null)
|
|
return false;
|
|
if(!(vallink.Value is OTStmtStore))
|
|
return false;
|
|
OTStmtStore valstore = (OTStmtStore)vallink.Value;
|
|
if(!(valstore.varwr is OTOpndArrayElem))
|
|
return false;
|
|
OTOpndArrayElem varelem = (OTOpndArrayElem)valstore.varwr;
|
|
if(varelem.array != storevar)
|
|
return false;
|
|
if(!(varelem.index is OTOpndInt))
|
|
return false;
|
|
if(((OTOpndInt)varelem.index).value != i)
|
|
return false;
|
|
it.values[i] = valstore.value;
|
|
}
|
|
|
|
/*
|
|
* The next statement should have a 'newobj list (dup$<n>)' in it somewhere
|
|
* that we want to replace with 'it'.
|
|
*/
|
|
ConstructorInfo protoctor = typeof(LSL_List).GetConstructor(new Type[] { typeof(object[]) });
|
|
OTOpnd[] protoargs = new OTOpnd[] { storevar };
|
|
OTOpnd proto = OTOpndNewobj.Make(protoctor, protoargs);
|
|
|
|
vallink = vallink.Next;
|
|
bool rc = vallink.Value.ReplaceOperand(proto, it);
|
|
|
|
/*
|
|
* If successful, delete 'dup$n =' and all 'dup$n[i] =' statements.
|
|
*/
|
|
if(rc)
|
|
{
|
|
do
|
|
{
|
|
LinkedListNode<OTStmt> nextlink = link.Next;
|
|
link.List.Remove(link);
|
|
link = nextlink;
|
|
} while(link != vallink);
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
public override bool HasSideEffects
|
|
{
|
|
get
|
|
{
|
|
foreach(OTOpnd value in values)
|
|
{
|
|
if(value.HasSideEffects)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public override void CountRefs(bool writing)
|
|
{
|
|
foreach(OTOpnd value in values)
|
|
{
|
|
value.CountRefs(false);
|
|
}
|
|
}
|
|
|
|
public override OTOpnd ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd, ref bool rc)
|
|
{
|
|
if(SameAs(oldopnd))
|
|
{
|
|
rc = true;
|
|
return newopnd;
|
|
}
|
|
for(int i = 0; i < values.Length; i++)
|
|
{
|
|
values[i] = values[i].ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
public override bool SameAs(OTOpnd other)
|
|
{
|
|
if(!(other is OTOpndListIni))
|
|
return false;
|
|
OTOpndListIni otherli = (OTOpndListIni)other;
|
|
if(otherli.values.Length != values.Length)
|
|
return false;
|
|
for(int i = 0; i < values.Length; i++)
|
|
{
|
|
if(!values[i].SameAs(otherli.values[i]))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public override string PrintableString
|
|
{
|
|
get
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.Append('[');
|
|
for(int i = 0; i < values.Length; i++)
|
|
{
|
|
if(i > 0)
|
|
sb.Append(',');
|
|
sb.Append(' ');
|
|
sb.Append(values[i].PrintableString);
|
|
}
|
|
sb.Append(" ]");
|
|
return sb.ToString();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Local variable.
|
|
*/
|
|
private class OTOpndLocal: OTOpnd
|
|
{
|
|
public OTLocal local;
|
|
|
|
public OTOpndLocal(OTLocal local)
|
|
{
|
|
this.local = local;
|
|
}
|
|
|
|
public override bool HasSideEffects
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public override void CountRefs(bool writing)
|
|
{
|
|
if(writing)
|
|
local.nlclwrites++;
|
|
else
|
|
local.nlclreads++;
|
|
}
|
|
|
|
public override bool SameAs(OTOpnd other)
|
|
{
|
|
if(!(other is OTOpndLocal))
|
|
return false;
|
|
OTOpndLocal otherlocal = (OTOpndLocal)other;
|
|
return local == otherlocal.local;
|
|
}
|
|
|
|
public override string PrintableString
|
|
{
|
|
get
|
|
{
|
|
return local.name;
|
|
}
|
|
}
|
|
}
|
|
private class OTOpndLocalRef: OTOpnd
|
|
{
|
|
public OTLocal local;
|
|
|
|
public OTOpndLocalRef(OTLocal local)
|
|
{
|
|
this.local = local;
|
|
}
|
|
|
|
public override bool HasSideEffects
|
|
{
|
|
get
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public override void CountRefs(bool writing)
|
|
{
|
|
local.nlclreads++;
|
|
local.nlclwrites++;
|
|
}
|
|
|
|
public override OTOpnd GetNonByRefOpnd()
|
|
{
|
|
return new OTOpndLocal(local);
|
|
}
|
|
|
|
public override bool SameAs(OTOpnd other)
|
|
{
|
|
if(!(other is OTOpndLocal))
|
|
return false;
|
|
OTOpndLocal otherlocal = (OTOpndLocal)other;
|
|
return local == otherlocal.local;
|
|
}
|
|
|
|
public override string PrintableString
|
|
{
|
|
get
|
|
{
|
|
return "ref " + local.name;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* New C#-level array.
|
|
*/
|
|
private class OTOpndNewarr: OTOpnd
|
|
{
|
|
public Type type;
|
|
public OTOpnd index;
|
|
|
|
public OTOpndNewarr(Type type, OTOpnd index)
|
|
{
|
|
this.type = type;
|
|
this.index = index;
|
|
}
|
|
|
|
public override bool HasSideEffects
|
|
{
|
|
get
|
|
{
|
|
return index.HasSideEffects;
|
|
}
|
|
}
|
|
|
|
public override void CountRefs(bool writing)
|
|
{
|
|
index.CountRefs(false);
|
|
}
|
|
|
|
public override OTOpnd ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd, ref bool rc)
|
|
{
|
|
if(SameAs(oldopnd))
|
|
{
|
|
rc = true;
|
|
return newopnd;
|
|
}
|
|
index = index.ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
return this;
|
|
}
|
|
|
|
public override bool SameAs(OTOpnd other)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
public override string PrintableString
|
|
{
|
|
get
|
|
{
|
|
return "newarr " + type.Name + "[" + index.PrintableString + "]";
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* New C#-level object.
|
|
*/
|
|
private class OTOpndNewobj: OTOpnd
|
|
{
|
|
public ConstructorInfo ctor;
|
|
public OTOpnd[] args;
|
|
|
|
public static OTOpnd Make(ConstructorInfo ctor, OTOpnd[] args)
|
|
{
|
|
// newobj LSL_Float (x) => x
|
|
if((ctor.DeclaringType == typeof(LSL_Float)) && (args.Length == 1))
|
|
{
|
|
Type ptype = ctor.GetParameters()[0].ParameterType;
|
|
if(ptype == typeof(string))
|
|
{
|
|
return new OTOpndCast(typeof(double), args[0]);
|
|
}
|
|
return args[0];
|
|
}
|
|
|
|
// newobj LSL_Integer (x) => x
|
|
if((ctor.DeclaringType == typeof(LSL_Integer)) && (args.Length == 1))
|
|
{
|
|
Type ptype = ctor.GetParameters()[0].ParameterType;
|
|
if(ptype == typeof(string))
|
|
{
|
|
return new OTOpndCast(typeof(int), args[0]);
|
|
}
|
|
return args[0];
|
|
}
|
|
|
|
// newobj LSL_String (x) => x
|
|
if((ctor.DeclaringType == typeof(LSL_String)) && (args.Length == 1))
|
|
{
|
|
return args[0];
|
|
}
|
|
|
|
// newobj LSL_Rotation (x, y, z, w) => <x, y, z, w>
|
|
if((ctor.DeclaringType == typeof(LSL_Rotation)) && (args.Length == 4))
|
|
{
|
|
return new OTOpndRot(args[0], args[1], args[2], args[3]);
|
|
}
|
|
|
|
// newobj LSL_Vector (x, y, z) => <x, y, z>
|
|
if((ctor.DeclaringType == typeof(LSL_Vector)) && (args.Length == 3))
|
|
{
|
|
return new OTOpndVec(args[0], args[1], args[2]);
|
|
}
|
|
|
|
// newobj LSL_Rotation (string) => (rotation) string
|
|
if((ctor.DeclaringType == typeof(LSL_Rotation)) && (args.Length == 1))
|
|
{
|
|
return new OTOpndCast(typeof(LSL_Rotation), args[0]);
|
|
}
|
|
|
|
// newobj LSL_Vector (string) => (rotation) string
|
|
if((ctor.DeclaringType == typeof(LSL_Vector)) && (args.Length == 1))
|
|
{
|
|
return new OTOpndCast(typeof(LSL_Vector), args[0]);
|
|
}
|
|
|
|
// newobj LSL_List (newarr object[0]) => [ ]
|
|
if((ctor.DeclaringType == typeof(LSL_List)) && (args.Length == 1) && (args[0] is OTOpndNewarr))
|
|
{
|
|
OTOpndNewarr arg0 = (OTOpndNewarr)args[0];
|
|
if((arg0.type == typeof(object)) && (arg0.index is OTOpndInt) && (((OTOpndInt)arg0.index).value == 0))
|
|
{
|
|
OTOpndListIni listini = new OTOpndListIni();
|
|
listini.values = new OTOpnd[0];
|
|
return listini;
|
|
}
|
|
}
|
|
|
|
// something else, output as is
|
|
OTOpndNewobj it = new OTOpndNewobj();
|
|
it.ctor = ctor;
|
|
it.args = args;
|
|
return it;
|
|
}
|
|
|
|
private OTOpndNewobj()
|
|
{
|
|
}
|
|
|
|
public override bool HasSideEffects
|
|
{
|
|
get
|
|
{
|
|
foreach(OTOpnd arg in args)
|
|
{
|
|
if(arg.HasSideEffects)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public override void CountRefs(bool writing)
|
|
{
|
|
foreach(OTOpnd arg in args)
|
|
{
|
|
arg.CountRefs(false);
|
|
}
|
|
}
|
|
|
|
public override OTOpnd ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd, ref bool rc)
|
|
{
|
|
if(SameAs(oldopnd))
|
|
{
|
|
rc = true;
|
|
return newopnd;
|
|
}
|
|
for(int i = 0; i < args.Length; i++)
|
|
{
|
|
args[i] = args[i].ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
public override bool SameAs(OTOpnd other)
|
|
{
|
|
if(!(other is OTOpndNewobj))
|
|
return false;
|
|
OTOpndNewobj otherno = (OTOpndNewobj)other;
|
|
if(otherno.ctor.DeclaringType != ctor.DeclaringType)
|
|
return false;
|
|
if(otherno.args.Length != args.Length)
|
|
return false;
|
|
for(int i = 0; i < args.Length; i++)
|
|
{
|
|
if(!args[i].SameAs(otherno.args[i]))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public override string PrintableString
|
|
{
|
|
get
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.Append("newobj ");
|
|
sb.Append(ctor.DeclaringType.Name);
|
|
sb.Append(" (");
|
|
bool first = true;
|
|
foreach(OTOpnd arg in args)
|
|
{
|
|
if(!first)
|
|
sb.Append(", ");
|
|
sb.Append(arg.PrintableString);
|
|
first = false;
|
|
}
|
|
sb.Append(')');
|
|
return sb.ToString();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Rotation value.
|
|
*/
|
|
private class OTOpndRot: OTOpnd
|
|
{
|
|
private OTOpnd x, y, z, w;
|
|
|
|
public OTOpndRot(OTOpnd x, OTOpnd y, OTOpnd z, OTOpnd w)
|
|
{
|
|
this.x = StripFloatCast(x);
|
|
this.y = StripFloatCast(y);
|
|
this.z = StripFloatCast(z);
|
|
this.w = StripFloatCast(w);
|
|
}
|
|
|
|
public override bool HasSideEffects
|
|
{
|
|
get
|
|
{
|
|
return x.HasSideEffects || y.HasSideEffects || z.HasSideEffects || w.HasSideEffects;
|
|
}
|
|
}
|
|
|
|
public override void CountRefs(bool writing)
|
|
{
|
|
x.CountRefs(false);
|
|
y.CountRefs(false);
|
|
z.CountRefs(false);
|
|
w.CountRefs(false);
|
|
}
|
|
|
|
public override OTOpnd ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd, ref bool rc)
|
|
{
|
|
if(SameAs(oldopnd))
|
|
{
|
|
rc = true;
|
|
return newopnd;
|
|
}
|
|
x = x.ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
y = y.ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
z = z.ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
w = w.ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
return this;
|
|
}
|
|
|
|
public override bool SameAs(OTOpnd other)
|
|
{
|
|
if(!(other is OTOpndRot))
|
|
return false;
|
|
OTOpndRot otherv = (OTOpndRot)other;
|
|
return otherv.x.SameAs(x) && otherv.y.SameAs(y) && otherv.z.SameAs(z) && otherv.w.SameAs(w);
|
|
}
|
|
|
|
public override string PrintableString
|
|
{
|
|
get
|
|
{
|
|
return "<" + x.PrintableString + ", " + y.PrintableString + ", " + z.PrintableString + ", " + w.PrintableString + ">";
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Static field.
|
|
*/
|
|
private class OTOpndSField: OTOpnd
|
|
{
|
|
private FieldInfo field;
|
|
|
|
public OTOpndSField(FieldInfo field)
|
|
{
|
|
this.field = field;
|
|
}
|
|
|
|
public override bool HasSideEffects
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public override bool SameAs(OTOpnd other)
|
|
{
|
|
if(!(other is OTOpndSField))
|
|
return false;
|
|
OTOpndSField othersfield = (OTOpndSField)other;
|
|
return (field.Name == othersfield.field.Name) && (field.DeclaringType == othersfield.field.DeclaringType);
|
|
}
|
|
|
|
public override string PrintableString
|
|
{
|
|
get
|
|
{
|
|
if(field.DeclaringType == typeof(ScriptBaseClass))
|
|
return field.Name;
|
|
return field.DeclaringType.Name + "." + field.Name;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call to string.Compare().
|
|
* See use cases in BinOpStr:
|
|
* strcmp (a, b) ceq 0
|
|
* (strcmp (a, b) ceq 0) xor 1 => we translate to: strcmp (a, b) cne 0
|
|
* strcmp (a, b) clt 0
|
|
* strcmp (a, b) clt 1 // <=
|
|
* strcmp (a, b) cgt 0
|
|
* strcmp (a, b) cgt -1 // >=
|
|
* ...but then optimized by ScriptCollector if followed by br{false,true}:
|
|
* ceq + xor 1 + brtrue => bne.un
|
|
* ceq + xor 1 + brfalse => beq
|
|
* ceq + brtrue => beq
|
|
* ceq + brfalse => bne.un
|
|
* cgt + brtrue => bgt
|
|
* cgt + brfalse => ble
|
|
* clt + brtrue => blt
|
|
* clt + brfalse => bge
|
|
* So we end up with these cases:
|
|
* strcmp (a, b) ceq 0
|
|
* strcmp (a, b) cne 0
|
|
* strcmp (a, b) clt 0
|
|
* strcmp (a, b) clt 1
|
|
* strcmp (a, b) cgt 0
|
|
* strcmp (a, b) cgt -1
|
|
* strcmp (a, b) beq 0
|
|
* strcmp (a, b) bne.un 0
|
|
* strcmp (a, b) bgt 0
|
|
* strcmp (a, b) ble 0
|
|
* strcmp (a, b) bgt -1
|
|
* strcmp (a, b) ble -1
|
|
* strcmp (a, b) blt 0
|
|
* strcmp (a, b) bge 0
|
|
* strcmp (a, b) blt 1
|
|
* strcmp (a, b) bge 1
|
|
* ... so we pretty them up in OTOpndBinOp
|
|
*/
|
|
private class OTOpndStrCmp: OTOpnd
|
|
{
|
|
private static Dictionary<string, string> binops = InitBinops();
|
|
private static Dictionary<string, string> InitBinops()
|
|
{
|
|
Dictionary<string, string> d = new Dictionary<string, string>();
|
|
d["ceq 0"] = "ceq";
|
|
d["cne 0"] = "cne";
|
|
d["clt 0"] = "clt";
|
|
d["clt 1"] = "cle";
|
|
d["cgt 0"] = "cgt";
|
|
d["cgt -1"] = "cge";
|
|
d["beq 0"] = "ceq";
|
|
d["bne.un 0"] = "cne";
|
|
d["bgt 0"] = "cgt";
|
|
d["ble 0"] = "cle";
|
|
d["bgt -1"] = "cge";
|
|
d["ble -1"] = "clt";
|
|
d["blt 0"] = "clt";
|
|
d["bge 0"] = "cge";
|
|
d["blt 1"] = "cle";
|
|
d["bge 1"] = "cgt";
|
|
return d;
|
|
}
|
|
|
|
private OTOpnd arg0;
|
|
private OTOpnd arg1;
|
|
|
|
public OTOpndStrCmp(OTOpnd arg0, OTOpnd arg1)
|
|
{
|
|
this.arg0 = arg0;
|
|
this.arg1 = arg1;
|
|
}
|
|
|
|
/**
|
|
* Try to make something a script writer would recognize.
|
|
* If we can't, then we leave it as a call to xmrStringCompare().
|
|
* this = some strcmp(a,b)
|
|
* opCode = hopefully some cxx or bxx from above table
|
|
* rite = hopefully some constant from above table
|
|
*/
|
|
public OTOpnd MakeBinOp(MyOp opCode, OTOpnd rite)
|
|
{
|
|
if(!(rite is OTOpndInt))
|
|
return null;
|
|
int riteint = ((OTOpndInt)rite).value;
|
|
string key = opCode.name + ' ' + riteint;
|
|
string cxxopname;
|
|
if(!binops.TryGetValue(key, out cxxopname))
|
|
return null;
|
|
return OTOpndBinOp.Make(arg0, MyOp.GetByName(cxxopname), arg1);
|
|
}
|
|
public OTOpnd MakeUnOp(MyOp opCode)
|
|
{
|
|
if(opCode == MyOp.Brfalse)
|
|
return OTOpndBinOp.Make(arg0, MyOp.Ceq, arg1);
|
|
if(opCode == MyOp.Brtrue)
|
|
return OTOpndBinOp.Make(arg0, MyOp.Cne, arg1);
|
|
return null;
|
|
}
|
|
|
|
public override bool HasSideEffects
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public override void CountRefs(bool writing)
|
|
{
|
|
arg0.CountRefs(writing);
|
|
arg1.CountRefs(writing);
|
|
}
|
|
|
|
public override OTOpnd ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd, ref bool rc)
|
|
{
|
|
if(SameAs(oldopnd))
|
|
{
|
|
rc = true;
|
|
return newopnd;
|
|
}
|
|
arg0 = arg0.ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
arg1 = arg1.ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
return this;
|
|
}
|
|
|
|
public override bool SameAs(OTOpnd other)
|
|
{
|
|
if(!(other is OTOpndStrCmp))
|
|
return false;
|
|
return arg0.SameAs(((OTOpndStrCmp)other).arg0) && arg1.SameAs(((OTOpndStrCmp)other).arg1);
|
|
}
|
|
|
|
public override string PrintableString
|
|
{
|
|
get
|
|
{
|
|
return "xmrStringCompare (" + arg0.PrintableString + ", " + arg1.PrintableString + ")";
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Unary operator.
|
|
*/
|
|
private class OTOpndUnOp: OTOpnd
|
|
{
|
|
public MyOp opCode;
|
|
public OTOpnd value;
|
|
|
|
private static Dictionary<string, string> brfops = InitBrfOps();
|
|
private static Dictionary<string, string> InitBrfOps()
|
|
{
|
|
Dictionary<string, string> d = new Dictionary<string, string>();
|
|
d["beq"] = "cne";
|
|
d["bge"] = "clt";
|
|
d["bgt"] = "cle";
|
|
d["ble"] = "cgt";
|
|
d["blt"] = "cge";
|
|
d["bne.un"] = "ceq";
|
|
d["ceq"] = "cne";
|
|
d["cge"] = "clt";
|
|
d["cgt"] = "cle";
|
|
d["cle"] = "cgt";
|
|
d["clt"] = "cge";
|
|
d["cne"] = "ceq";
|
|
return d;
|
|
}
|
|
|
|
public static OTOpnd Make(MyOp opCode, OTOpnd value)
|
|
{
|
|
// (brfalse (brfalse (x))) => (brtrue (x))
|
|
if((opCode == MyOp.Brfalse) && (value is OTOpndUnOp) && (((OTOpndUnOp)value).opCode == MyOp.Brfalse))
|
|
{
|
|
((OTOpndUnOp)value).opCode = MyOp.Brtrue;
|
|
return value;
|
|
}
|
|
|
|
// (brfalse (brtrue (x))) => (brfalse (x))
|
|
if((opCode == MyOp.Brfalse) && (value is OTOpndUnOp) && (((OTOpndUnOp)value).opCode == MyOp.Brtrue))
|
|
{
|
|
((OTOpndUnOp)value).opCode = MyOp.Brfalse;
|
|
return value;
|
|
}
|
|
|
|
// (brtrue (brfalse (x))) => (brfalse (x))
|
|
if((opCode == MyOp.Brtrue) && (value is OTOpndUnOp) && (((OTOpndUnOp)value).opCode == MyOp.Brfalse))
|
|
{
|
|
return value;
|
|
}
|
|
|
|
// (brtrue (brtrue (x))) => (brtrue (x))
|
|
if((opCode == MyOp.Brtrue) && (value is OTOpndUnOp) && (((OTOpndUnOp)value).opCode == MyOp.Brtrue))
|
|
{
|
|
return value;
|
|
}
|
|
|
|
// (brfalse (x beq y)) => (x bne y) etc
|
|
string brfop;
|
|
if((opCode == MyOp.Brfalse) && (value is OTOpndBinOp) && brfops.TryGetValue(((OTOpndBinOp)value).opCode.name, out brfop))
|
|
{
|
|
((OTOpndBinOp)value).opCode = MyOp.GetByName(brfop);
|
|
return value;
|
|
}
|
|
|
|
// (brtrue (x beq y)) => (x beq y) etc
|
|
if((opCode == MyOp.Brtrue) && (value is OTOpndBinOp) && brfops.ContainsKey(((OTOpndBinOp)value).opCode.name))
|
|
{
|
|
return value;
|
|
}
|
|
|
|
// strcmp() can be a special case
|
|
if(value is OTOpndStrCmp)
|
|
{
|
|
OTOpnd strcmp = ((OTOpndStrCmp)value).MakeUnOp(opCode);
|
|
if(strcmp != null)
|
|
return strcmp;
|
|
}
|
|
|
|
// nothing special, save opcode and value
|
|
OTOpndUnOp it = new OTOpndUnOp();
|
|
it.opCode = opCode;
|
|
it.value = value;
|
|
return it;
|
|
}
|
|
|
|
private OTOpndUnOp()
|
|
{
|
|
}
|
|
|
|
public override bool HasSideEffects
|
|
{
|
|
get
|
|
{
|
|
return value.HasSideEffects;
|
|
}
|
|
}
|
|
|
|
public override void CountRefs(bool writing)
|
|
{
|
|
value.CountRefs(false);
|
|
}
|
|
|
|
public override OTOpnd ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd, ref bool rc)
|
|
{
|
|
if(SameAs(oldopnd))
|
|
{
|
|
rc = true;
|
|
return newopnd;
|
|
}
|
|
value = value.ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
return this;
|
|
}
|
|
|
|
public override bool SameAs(OTOpnd other)
|
|
{
|
|
if(!(other is OTOpndUnOp))
|
|
return false;
|
|
OTOpndUnOp otherop = (OTOpndUnOp)other;
|
|
return (opCode.ToString() == otherop.opCode.ToString()) && value.SameAs(otherop.value);
|
|
}
|
|
|
|
public override string PrintableString
|
|
{
|
|
get
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.Append(opCode.source);
|
|
sb.Append(' ');
|
|
if(value is OTOpndBinOp)
|
|
sb.Append('(');
|
|
sb.Append(value.PrintableString);
|
|
if(value is OTOpndBinOp)
|
|
sb.Append(')');
|
|
return sb.ToString();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Vector value.
|
|
*/
|
|
private class OTOpndVec: OTOpnd
|
|
{
|
|
private OTOpnd x, y, z;
|
|
|
|
public OTOpndVec(OTOpnd x, OTOpnd y, OTOpnd z)
|
|
{
|
|
this.x = StripFloatCast(x);
|
|
this.y = StripFloatCast(y);
|
|
this.z = StripFloatCast(z);
|
|
}
|
|
|
|
public override bool HasSideEffects
|
|
{
|
|
get
|
|
{
|
|
return x.HasSideEffects || y.HasSideEffects || z.HasSideEffects;
|
|
}
|
|
}
|
|
|
|
public override void CountRefs(bool writing)
|
|
{
|
|
x.CountRefs(false);
|
|
y.CountRefs(false);
|
|
z.CountRefs(false);
|
|
}
|
|
|
|
public override OTOpnd ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd, ref bool rc)
|
|
{
|
|
if(SameAs(oldopnd))
|
|
{
|
|
rc = true;
|
|
return newopnd;
|
|
}
|
|
x = x.ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
y = y.ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
z = z.ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
return this;
|
|
}
|
|
|
|
public override bool SameAs(OTOpnd other)
|
|
{
|
|
if(!(other is OTOpndVec))
|
|
return false;
|
|
OTOpndVec otherv = (OTOpndVec)other;
|
|
return otherv.x.SameAs(x) && otherv.y.SameAs(y) && otherv.z.SameAs(z);
|
|
}
|
|
|
|
public override string PrintableString
|
|
{
|
|
get
|
|
{
|
|
return "<" + x.PrintableString + ", " + y.PrintableString + ", " + z.PrintableString + ">";
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Constants.
|
|
*/
|
|
private class OTOpndDouble: OTOpnd
|
|
{
|
|
public double value;
|
|
public OTOpndDouble(double value)
|
|
{
|
|
this.value = value;
|
|
}
|
|
public override bool HasSideEffects
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
public override bool SameAs(OTOpnd other)
|
|
{
|
|
if(!(other is OTOpndDouble))
|
|
return false;
|
|
return ((OTOpndDouble)other).value == value;
|
|
}
|
|
public override string PrintableString
|
|
{
|
|
get
|
|
{
|
|
string s = value.ToString();
|
|
long i;
|
|
if(long.TryParse(s, out i))
|
|
{
|
|
s += ".0";
|
|
}
|
|
return s;
|
|
}
|
|
}
|
|
}
|
|
private class OTOpndFloat: OTOpnd
|
|
{
|
|
public float value;
|
|
public OTOpndFloat(float value)
|
|
{
|
|
this.value = value;
|
|
}
|
|
public override bool HasSideEffects
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
public override bool SameAs(OTOpnd other)
|
|
{
|
|
if(!(other is OTOpndFloat))
|
|
return false;
|
|
return ((OTOpndFloat)other).value == value;
|
|
}
|
|
public override string PrintableString
|
|
{
|
|
get
|
|
{
|
|
string s = value.ToString();
|
|
long i;
|
|
if(long.TryParse(s, out i))
|
|
{
|
|
s += ".0";
|
|
}
|
|
return s;
|
|
}
|
|
}
|
|
}
|
|
private class OTOpndInt: OTOpnd
|
|
{
|
|
public int value;
|
|
public OTOpndInt(int value)
|
|
{
|
|
this.value = value;
|
|
}
|
|
public override bool HasSideEffects
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
public override bool SameAs(OTOpnd other)
|
|
{
|
|
if(!(other is OTOpndInt))
|
|
return false;
|
|
return ((OTOpndInt)other).value == value;
|
|
}
|
|
public override string PrintableString
|
|
{
|
|
get
|
|
{
|
|
return value.ToString();
|
|
}
|
|
}
|
|
}
|
|
private class OTOpndNull: OTOpnd
|
|
{
|
|
public override bool HasSideEffects
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
public override bool SameAs(OTOpnd other)
|
|
{
|
|
return other is OTOpndNull;
|
|
}
|
|
public override string PrintableString
|
|
{
|
|
get
|
|
{
|
|
return "undef";
|
|
}
|
|
}
|
|
}
|
|
private class OTOpndString: OTOpnd
|
|
{
|
|
public string value;
|
|
public OTOpndString(string value)
|
|
{
|
|
this.value = value;
|
|
}
|
|
public override bool HasSideEffects
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
public override bool SameAs(OTOpnd other)
|
|
{
|
|
if(!(other is OTOpndString))
|
|
return false;
|
|
return ((OTOpndString)other).value == value;
|
|
}
|
|
public override string PrintableString
|
|
{
|
|
get
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
TokenDeclInline.PrintParamString(sb, value);
|
|
return sb.ToString();
|
|
}
|
|
}
|
|
}
|
|
|
|
/****************************************\
|
|
* Tokens what are in statement list. *
|
|
\****************************************/
|
|
|
|
public abstract class OTStmt
|
|
{
|
|
|
|
/**
|
|
* Increment reference counts.
|
|
*/
|
|
public abstract void CountRefs();
|
|
|
|
/**
|
|
* Strip out any of the behind-the-scenes code such as stack capture/restore.
|
|
* By default, there is no change.
|
|
*/
|
|
public virtual bool StripStuff(LinkedListNode<OTStmt> link)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Replace the oldopnd operand with the newopnd operand if it is present.
|
|
* Return whether or not it was found and replaced.
|
|
*/
|
|
public abstract bool ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd);
|
|
|
|
/**
|
|
* Detect and modify for do/for/if/while structures.
|
|
*/
|
|
public virtual bool DetectDoForIfWhile(LinkedListNode<OTStmt> link)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* If this statement is the old statement, replace it with the given new statement.
|
|
* Also search any sub-ordinate statements.
|
|
* **NOTE**: minimally implemented to replace a Jump with a Break or Continue
|
|
*/
|
|
public abstract OTStmt ReplaceStatement(OTStmt oldstmt, OTStmt newstmt);
|
|
|
|
/**
|
|
* Print the statement out on the given printer with the given indenting.
|
|
* The first line is already indented, subsequent lines must be indented as given.
|
|
* This method should leave the printer at the end of the line.
|
|
*/
|
|
public abstract void PrintStmt(TextWriter twout, string indent);
|
|
|
|
/**
|
|
* Strip all statements following this statement
|
|
* because this statement jumps somewhere.
|
|
*/
|
|
protected bool StripStuffForTerminal(LinkedListNode<OTStmt> link)
|
|
{
|
|
// strip all statements following jump until seeing some label
|
|
bool rc = false;
|
|
if(link != null)
|
|
{
|
|
LinkedListNode<OTStmt> nextlink;
|
|
while((nextlink = link.Next) != null)
|
|
{
|
|
if(nextlink.Value is OTStmtLabel)
|
|
break;
|
|
nextlink.List.Remove(nextlink);
|
|
rc = true;
|
|
}
|
|
}
|
|
return rc;
|
|
}
|
|
}
|
|
|
|
/**************************\
|
|
* Primitive statements *
|
|
\**************************/
|
|
|
|
/**
|
|
* Begin catch block (catch).
|
|
*/
|
|
private class OTStmtBegCatBlk: OTStmt
|
|
{
|
|
public OTStmtBegExcBlk tryblock;
|
|
public OTStmtBlock catchblock;
|
|
|
|
private Type excType;
|
|
|
|
public OTStmtBegCatBlk(Type excType)
|
|
{
|
|
this.excType = excType;
|
|
}
|
|
|
|
public override void CountRefs()
|
|
{
|
|
catchblock.CountRefs();
|
|
}
|
|
|
|
public override bool StripStuff(LinkedListNode<OTStmt> link)
|
|
{
|
|
return catchblock.StripStuff(null);
|
|
}
|
|
|
|
public override bool ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd)
|
|
{
|
|
return catchblock.ReplaceOperand(oldopnd, newopnd);
|
|
}
|
|
|
|
public override bool DetectDoForIfWhile(LinkedListNode<OTStmt> link)
|
|
{
|
|
return catchblock.DetectDoForIfWhile(link);
|
|
}
|
|
|
|
public override OTStmt ReplaceStatement(OTStmt oldstmt, OTStmt newstmt)
|
|
{
|
|
catchblock = (OTStmtBlock)catchblock.ReplaceStatement(oldstmt, newstmt);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Print out the catch block including its enclosed statements.
|
|
*/
|
|
public override void PrintStmt(TextWriter twout, string indent)
|
|
{
|
|
twout.Write("catch (" + excType.Name + ") ");
|
|
catchblock.PrintStmt(twout, indent);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Begin exception block (try).
|
|
*/
|
|
private class OTStmtBegExcBlk: OTStmt
|
|
{
|
|
|
|
// statements within the try { } not including any catch or finally
|
|
public OTStmtBlock tryblock;
|
|
|
|
// list of all catch { } blocks associated with this try { }
|
|
public LinkedList<OTStmtBegCatBlk> catches = new LinkedList<OTStmtBegCatBlk>();
|
|
|
|
// possible single finally { } associated with this try
|
|
public OTStmtBegFinBlk finblock; // might be null
|
|
|
|
public override void CountRefs()
|
|
{
|
|
tryblock.CountRefs();
|
|
foreach(OTStmtBegCatBlk catblock in catches)
|
|
{
|
|
catblock.CountRefs();
|
|
}
|
|
if(finblock != null)
|
|
finblock.CountRefs();
|
|
}
|
|
|
|
/**
|
|
* Strip behind-the-scenes info from all the sub-blocks.
|
|
*/
|
|
public override bool StripStuff(LinkedListNode<OTStmt> link)
|
|
{
|
|
// strip behind-the-scenes info from all the sub-blocks.
|
|
bool rc = tryblock.StripStuff(null);
|
|
foreach(OTStmtBegCatBlk catblk in catches)
|
|
{
|
|
rc |= catblk.StripStuff(null);
|
|
}
|
|
if(finblock != null)
|
|
rc |= finblock.StripStuff(null);
|
|
if(rc)
|
|
return true;
|
|
|
|
// change:
|
|
// try {
|
|
// ...
|
|
// }
|
|
// to:
|
|
// {
|
|
// ...
|
|
// }
|
|
// note that an empty catch () { } has meaning so can't be stripped
|
|
// empty finally { } blocks strips itself from the try
|
|
if((catches.Count == 0) && (finblock == null) && (link != null))
|
|
{
|
|
link.List.AddAfter(link, tryblock);
|
|
tryblock = null;
|
|
link.List.Remove(link);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public override bool ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd)
|
|
{
|
|
bool rc = tryblock.ReplaceOperand(oldopnd, newopnd);
|
|
foreach(OTStmtBegCatBlk catblk in catches)
|
|
{
|
|
rc |= catblk.ReplaceOperand(oldopnd, newopnd);
|
|
}
|
|
if(finblock != null)
|
|
rc |= finblock.ReplaceOperand(oldopnd, newopnd);
|
|
return rc;
|
|
}
|
|
|
|
public override bool DetectDoForIfWhile(LinkedListNode<OTStmt> link)
|
|
{
|
|
bool rc = tryblock.DetectDoForIfWhile(link);
|
|
foreach(OTStmtBegCatBlk catblk in catches)
|
|
{
|
|
rc |= catblk.DetectDoForIfWhile(link);
|
|
}
|
|
if(finblock != null)
|
|
rc |= finblock.DetectDoForIfWhile(link);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* Assume we will never try to replace the try block itself.
|
|
* But go through all our sub-ordinates statements.
|
|
*/
|
|
public override OTStmt ReplaceStatement(OTStmt oldstmt, OTStmt newstmt)
|
|
{
|
|
tryblock = (OTStmtBlock)tryblock.ReplaceStatement(oldstmt, newstmt);
|
|
for(LinkedListNode<OTStmtBegCatBlk> catlink = catches.First; catlink != null; catlink = catlink.Next)
|
|
{
|
|
catlink.Value = (OTStmtBegCatBlk)catlink.Value.ReplaceStatement(oldstmt, newstmt);
|
|
}
|
|
if(finblock != null)
|
|
finblock = (OTStmtBegFinBlk)finblock.ReplaceStatement(oldstmt, newstmt);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Print out the try block including its enclosed statements.
|
|
* And since the try is the only thing pushed to the outer block,
|
|
* we also print out all the catch and finally blocks.
|
|
*/
|
|
public override void PrintStmt(TextWriter twout, string indent)
|
|
{
|
|
twout.Write("try ");
|
|
tryblock.PrintStmt(twout, indent);
|
|
foreach(OTStmtBegCatBlk catblk in catches)
|
|
{
|
|
twout.Write(' ');
|
|
catblk.PrintStmt(twout, indent);
|
|
}
|
|
if(finblock != null)
|
|
{
|
|
twout.Write(' ');
|
|
finblock.PrintStmt(twout, indent);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Begin finally block (finally).
|
|
*/
|
|
private class OTStmtBegFinBlk: OTStmt
|
|
{
|
|
public OTStmtBegExcBlk tryblock;
|
|
public OTStmtBlock finblock;
|
|
|
|
public override void CountRefs()
|
|
{
|
|
finblock.CountRefs();
|
|
}
|
|
|
|
/**
|
|
* Strip behind-the-scene parts from the finally block.
|
|
*/
|
|
public override bool StripStuff(LinkedListNode<OTStmt> link)
|
|
{
|
|
// strip behind-the-scenes parts from finally block itself
|
|
if(finblock.StripStuff(null))
|
|
return true;
|
|
|
|
// if finblock is empty, delete the finally from the try
|
|
if(finblock.blkstmts.Count == 0)
|
|
{
|
|
tryblock.finblock = null;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public override bool ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd)
|
|
{
|
|
return finblock.ReplaceOperand(oldopnd, newopnd);
|
|
}
|
|
|
|
public override bool DetectDoForIfWhile(LinkedListNode<OTStmt> link)
|
|
{
|
|
return finblock.DetectDoForIfWhile(link);
|
|
}
|
|
|
|
/**
|
|
* Assume we will never try to replace the finally block itself.
|
|
* But go through all our sub-ordinates statements.
|
|
*/
|
|
public override OTStmt ReplaceStatement(OTStmt oldstmt, OTStmt newstmt)
|
|
{
|
|
finblock = (OTStmtBlock)finblock.ReplaceStatement(oldstmt, newstmt);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Print out the finally block including its enclosed statements.
|
|
*/
|
|
public override void PrintStmt(TextWriter twout, string indent)
|
|
{
|
|
twout.Write("finally ");
|
|
finblock.PrintStmt(twout, indent);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Simple if jump/break/continue statement.
|
|
*/
|
|
private class OTStmtCond: OTStmt
|
|
{
|
|
public OTOpnd valu;
|
|
public OTStmt stmt; // jump, break, continue only
|
|
|
|
public OTStmtCond(OTOpnd valu, OTStmt stmt)
|
|
{
|
|
this.valu = valu;
|
|
this.stmt = stmt;
|
|
}
|
|
|
|
public override void CountRefs()
|
|
{
|
|
valu.CountRefs(false);
|
|
stmt.CountRefs();
|
|
}
|
|
|
|
public override bool StripStuff(LinkedListNode<OTStmt> link)
|
|
{
|
|
// we assume that callMode is always CallMode_NORMAL, ie, not doing a stack capture or restore
|
|
// so the 'if (arg$0.callMode bne.un 0) ...' is deleted
|
|
// and the 'if (arg$0.callMode bne.un 1) ...' becomes unconditional
|
|
// it can also be __xmrinst.callMode instead of arg$0
|
|
if(valu is OTOpndBinOp)
|
|
{
|
|
OTOpndBinOp binop = (OTOpndBinOp)valu;
|
|
if((binop.left is OTOpndField) && (binop.opCode.ToString() == "bne.un") && (binop.rite is OTOpndInt))
|
|
{
|
|
OTOpndField leftfield = (OTOpndField)binop.left;
|
|
if(leftfield.field.Name == _callMode)
|
|
{
|
|
bool ok = false;
|
|
if(leftfield.obj is OTOpndArg)
|
|
{
|
|
ok = ((OTOpndArg)leftfield.obj).index == 0;
|
|
}
|
|
if(leftfield.obj is OTOpndLocal)
|
|
{
|
|
ok = ((OTOpndLocal)leftfield.obj).local.name.StartsWith(_xmrinstlocal);
|
|
}
|
|
if(ok)
|
|
{
|
|
OTOpndInt riteint = (OTOpndInt)binop.rite;
|
|
|
|
// delete 'if ((arg$0).callMode bne.un 0) ...'
|
|
if(riteint.value == XMRInstAbstract.CallMode_NORMAL)
|
|
{
|
|
link.List.Remove(link);
|
|
return true;
|
|
}
|
|
|
|
// make 'if ((arg$0).callMode bne.un 1) ...' unconditional
|
|
if(riteint.value == XMRInstAbstract.CallMode_SAVE)
|
|
{
|
|
link.Value = stmt;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// similarly we assume that doGblInit is always 0 to eliminate the code at beginning of default state_entry()
|
|
// so the 'if (brfalse __xmrinst.doGblInit) ...' is made unconditional
|
|
if(valu is OTOpndUnOp)
|
|
{
|
|
OTOpndUnOp unop = (OTOpndUnOp)valu;
|
|
if((unop.opCode == MyOp.Brfalse) && (unop.value is OTOpndField))
|
|
{
|
|
OTOpndField valuefield = (OTOpndField)unop.value;
|
|
if(valuefield.field.Name == _doGblInit)
|
|
{
|
|
bool ok = false;
|
|
if(valuefield.obj is OTOpndLocal)
|
|
{
|
|
ok = ((OTOpndLocal)valuefield.obj).local.name.StartsWith(_xmrinstlocal);
|
|
}
|
|
if(ok)
|
|
{
|
|
|
|
// make 'if (brfalse __xmrinst.doGblInit) ...' unconditional
|
|
link.Value = stmt;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public override bool ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd)
|
|
{
|
|
bool rc = stmt.ReplaceOperand(oldopnd, newopnd);
|
|
valu = valu.ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* Maybe this simple if statement is part of a script-level if/then/else statement.
|
|
*/
|
|
public override bool DetectDoForIfWhile(LinkedListNode<OTStmt> link)
|
|
{
|
|
return OTStmtIf.Detect(link);
|
|
}
|
|
|
|
/**
|
|
* Assume we won't replace the if statement itself.
|
|
* But search all our sub-ordinate statements.
|
|
*/
|
|
public override OTStmt ReplaceStatement(OTStmt oldstmt, OTStmt newstmt)
|
|
{
|
|
stmt = stmt.ReplaceStatement(oldstmt, newstmt);
|
|
return this;
|
|
}
|
|
|
|
public override void PrintStmt(TextWriter twout, string indent)
|
|
{
|
|
twout.Write("if (" + StripBrtrue(valu).PrintableString + ") ");
|
|
stmt.PrintStmt(twout, indent);
|
|
}
|
|
|
|
/**
|
|
* Scan forward for a given label definition.
|
|
* Put intervening statements in a statement block.
|
|
* @param link = start scanning after this statement
|
|
* @param label = look for this label definition
|
|
* @param block = where to return intervening statement block
|
|
* @returns null: label definition not found
|
|
* else: label definition statement
|
|
*/
|
|
private static LinkedListNode<OTStmt> ScanForLabel(LinkedListNode<OTStmt> link,
|
|
OTLabel label, out OTStmtBlock block)
|
|
{
|
|
block = new OTStmtBlock();
|
|
while((link = link.Next) != null)
|
|
{
|
|
if(link.Value is OTStmtLabel)
|
|
{
|
|
if(((OTStmtLabel)link.Value).label == label)
|
|
break;
|
|
}
|
|
block.blkstmts.AddLast(link.Value);
|
|
}
|
|
return link;
|
|
}
|
|
|
|
/**
|
|
* Strip statements after link up to and including donelink.
|
|
*/
|
|
private static void StripInterveningStatements(LinkedListNode<OTStmt> link, LinkedListNode<OTStmt> donelink)
|
|
{
|
|
LinkedListNode<OTStmt> striplink;
|
|
do
|
|
{
|
|
striplink = link.Next;
|
|
striplink.List.Remove(striplink);
|
|
} while(striplink != donelink);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Jump to a label.
|
|
*/
|
|
private class OTStmtJump: OTStmt
|
|
{
|
|
public OTLabel label;
|
|
|
|
public static OTStmt Make(OTLabel label)
|
|
{
|
|
// jumps to __retlbl are return statements
|
|
// note that is is safe to say it is a valueless return because
|
|
// valued returns are done with this construct:
|
|
// __retval = ....;
|
|
// jump __retlbl;
|
|
// and those __retval = statements have been changed to return statements already
|
|
if(label.name.StartsWith(_retlbl))
|
|
return new OTStmtRet(null);
|
|
|
|
// other jumps are really jumps
|
|
OTStmtJump it = new OTStmtJump();
|
|
it.label = label;
|
|
return it;
|
|
}
|
|
|
|
private OTStmtJump()
|
|
{
|
|
}
|
|
|
|
public override void CountRefs()
|
|
{
|
|
label.lbljumps++;
|
|
}
|
|
|
|
public override bool StripStuff(LinkedListNode<OTStmt> link)
|
|
{
|
|
if(link == null)
|
|
return false;
|
|
|
|
// strip statements following unconditional jump until next label
|
|
bool rc = StripStuffForTerminal(link);
|
|
|
|
// if we (now) have:
|
|
// jump label;
|
|
// @label;
|
|
// ... delete this jump
|
|
if(link.Next != null)
|
|
{
|
|
OTStmtLabel nextlabel = (OTStmtLabel)link.Next.Value;
|
|
if(nextlabel.label == label)
|
|
{
|
|
link.List.Remove(link);
|
|
rc = true;
|
|
}
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
public override bool ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* This is actually what ReplaceStatement() is currently used for.
|
|
* It replaces a jump with a break or a continue.
|
|
*/
|
|
public override OTStmt ReplaceStatement(OTStmt oldstmt, OTStmt newstmt)
|
|
{
|
|
if((oldstmt is OTStmtJump) && (((OTStmtJump)oldstmt).label == label))
|
|
return newstmt;
|
|
return this;
|
|
}
|
|
|
|
public override void PrintStmt(TextWriter twout, string indent)
|
|
{
|
|
twout.Write("jump " + label.PrintableName + ';');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Label definition point.
|
|
*/
|
|
private class OTStmtLabel: OTStmt
|
|
{
|
|
public OTLabel label;
|
|
|
|
private OTDecompile decompile;
|
|
|
|
public static void AddLast(OTDecompile decompile, OTLabel label)
|
|
{
|
|
OTStmtLabel it = new OTStmtLabel();
|
|
it.label = label;
|
|
it.decompile = decompile;
|
|
decompile.AddLastStmt(it);
|
|
}
|
|
|
|
private OTStmtLabel()
|
|
{
|
|
}
|
|
|
|
public override void CountRefs()
|
|
{
|
|
// don't increment label.lbljumps
|
|
// cuz we don't want the positioning
|
|
// to count as a reference, only jumps
|
|
// to the label should count
|
|
}
|
|
|
|
public override bool StripStuff(LinkedListNode<OTStmt> link)
|
|
{
|
|
// if label has nothing jumping to it, remove the label
|
|
if(link != null)
|
|
{
|
|
label.lbljumps = 0;
|
|
decompile.topBlock.CountRefs();
|
|
if(label.lbljumps == 0)
|
|
{
|
|
link.List.Remove(link);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public override bool ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
public override bool DetectDoForIfWhile(LinkedListNode<OTStmt> link)
|
|
{
|
|
if(OTStmtDo.Detect(link))
|
|
return true;
|
|
if(OTStmtFor.Detect(link, true))
|
|
return true;
|
|
if(OTStmtFor.Detect(link, false))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
public override OTStmt ReplaceStatement(OTStmt oldstmt, OTStmt newstmt)
|
|
{
|
|
return this;
|
|
}
|
|
|
|
public override void PrintStmt(TextWriter twout, string indent)
|
|
{
|
|
twout.Write("@" + label.PrintableName + ';');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return with or without value.
|
|
*/
|
|
private class OTStmtRet: OTStmt
|
|
{
|
|
public OTOpnd value; // might be null
|
|
|
|
public OTStmtRet(OTOpnd value)
|
|
{
|
|
this.value = value;
|
|
}
|
|
|
|
public override void CountRefs()
|
|
{
|
|
if(value != null)
|
|
value.CountRefs(false);
|
|
}
|
|
|
|
public override bool StripStuff(LinkedListNode<OTStmt> link)
|
|
{
|
|
return StripStuffForTerminal(link);
|
|
}
|
|
|
|
public override bool ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd)
|
|
{
|
|
bool rc = false;
|
|
if(value != null)
|
|
value = value.ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
return rc;
|
|
}
|
|
|
|
public override OTStmt ReplaceStatement(OTStmt oldstmt, OTStmt newstmt)
|
|
{
|
|
return this;
|
|
}
|
|
|
|
public override void PrintStmt(TextWriter twout, string indent)
|
|
{
|
|
if(value == null)
|
|
{
|
|
twout.Write("return;");
|
|
}
|
|
else
|
|
{
|
|
twout.Write("return " + value.PrintableString + ';');
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Store value in variable.
|
|
*/
|
|
private class OTStmtStore: OTStmt
|
|
{
|
|
public OTOpnd varwr;
|
|
public OTOpnd value;
|
|
|
|
private OTDecompile decompile;
|
|
|
|
public static void AddLast(OTDecompile decompile, OTOpnd varwr, OTOpnd value)
|
|
{
|
|
OTStmtStore it = new OTStmtStore(varwr, value, decompile);
|
|
decompile.AddLastStmt(it);
|
|
}
|
|
|
|
public OTStmtStore(OTOpnd varwr, OTOpnd value, OTDecompile decompile)
|
|
{
|
|
this.varwr = varwr;
|
|
this.value = value;
|
|
this.decompile = decompile;
|
|
}
|
|
|
|
public override void CountRefs()
|
|
{
|
|
varwr.CountRefs(true);
|
|
value.CountRefs(false);
|
|
}
|
|
|
|
public override bool StripStuff(LinkedListNode<OTStmt> link)
|
|
{
|
|
// strip out stores to __mainCallNo
|
|
if(varwr is OTOpndLocal)
|
|
{
|
|
OTOpndLocal local = (OTOpndLocal)varwr;
|
|
if(local.local.name.StartsWith(_mainCallNo))
|
|
{
|
|
link.List.Remove(link);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// strip out stores to local vars where the var is not read
|
|
// but convert the value to an OTStmtVoid in case it is a call
|
|
if(varwr is OTOpndLocal)
|
|
{
|
|
OTOpndLocal local = (OTOpndLocal)varwr;
|
|
local.local.nlclreads = 0;
|
|
decompile.topBlock.CountRefs();
|
|
if(local.local.nlclreads == 0)
|
|
{
|
|
OTStmt voidstmt = OTStmtVoid.Make(value);
|
|
if(voidstmt == null)
|
|
link.List.Remove(link);
|
|
else
|
|
link.Value = voidstmt;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// strip out bla = newobj HeapTrackerList (...);
|
|
if(value is OTOpndNewobj)
|
|
{
|
|
OTOpndNewobj valueno = (OTOpndNewobj)value;
|
|
if(valueno.ctor.DeclaringType == typeof(HeapTrackerList))
|
|
{
|
|
link.List.Remove(link);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// strip out bla = newobj HeapTrackerObject (...);
|
|
if(value is OTOpndNewobj)
|
|
{
|
|
OTOpndNewobj valueno = (OTOpndNewobj)value;
|
|
if(valueno.ctor.DeclaringType == typeof(HeapTrackerObject))
|
|
{
|
|
link.List.Remove(link);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// strip out bla = newobj HeapTrackerString (...);
|
|
if(value is OTOpndNewobj)
|
|
{
|
|
OTOpndNewobj valueno = (OTOpndNewobj)value;
|
|
if(valueno.ctor.DeclaringType == typeof(HeapTrackerString))
|
|
{
|
|
link.List.Remove(link);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// convert tmp$n = bla bla;
|
|
// .... tmp$n ....;
|
|
// to
|
|
// .... bla bla ....;
|
|
// gets rid of vast majority of temps
|
|
if(varwr is OTOpndLocal)
|
|
{
|
|
OTOpndLocal temp = (OTOpndLocal)varwr;
|
|
if(temp.local.name.StartsWith("tmp$"))
|
|
{
|
|
temp.local.nlclreads = 0;
|
|
temp.local.nlclwrites = 0;
|
|
decompile.topBlock.CountRefs();
|
|
if((temp.local.nlclreads == 1) && (temp.local.nlclwrites == 1) && (link.Next != null))
|
|
{
|
|
OTStmt nextstmt = link.Next.Value;
|
|
if(!(nextstmt is OTStmtBlock))
|
|
{
|
|
if(nextstmt.ReplaceOperand(varwr, value))
|
|
{
|
|
link.List.Remove(link);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// also try to convert:
|
|
// tmp$n = ... asdf ... << we are here (link)
|
|
// lcl = tmp$n; << nextstore
|
|
// ... qwer tmp$n ...
|
|
// ... no further references to tmp$n
|
|
// to:
|
|
// lcl = ... asdf ...
|
|
// ... qwer lcl ...
|
|
if((temp.local.nlclreads == 2) && (temp.local.nlclwrites == 1) &&
|
|
(link.Next != null) && (link.Next.Value is OTStmtStore))
|
|
{
|
|
OTStmtStore nextstore = (OTStmtStore)link.Next.Value;
|
|
if((nextstore.varwr is OTOpndLocal) && (nextstore.value is OTOpndLocal) && (link.Next.Next != null))
|
|
{
|
|
OTOpndLocal localopnd = (OTOpndLocal)nextstore.varwr;
|
|
OTOpndLocal tempopnd = (OTOpndLocal)nextstore.value;
|
|
if(tempopnd.local == temp.local)
|
|
{
|
|
OTStmt finalstmt = link.Next.Next.Value;
|
|
if(finalstmt.ReplaceOperand(tempopnd, localopnd))
|
|
{
|
|
nextstore.value = value;
|
|
link.List.Remove(link);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// convert:
|
|
// dup$n = ... asdf ... << we are here
|
|
// lcl = dup$n;
|
|
// ... qwer dup$n ...
|
|
// ... no further references to dup$n
|
|
// to:
|
|
// lcl = ... asdf ...
|
|
// ... qwer lcl ...
|
|
if((varwr is OTOpndDup) && (link != null))
|
|
{
|
|
OTOpndDup vardup = (OTOpndDup)varwr;
|
|
LinkedListNode<OTStmt> nextlink = link.Next;
|
|
vardup.ndupreads = 0;
|
|
decompile.topBlock.CountRefs();
|
|
if((vardup.ndupreads == 2) && (nextlink != null) && (nextlink.Value is OTStmtStore))
|
|
{
|
|
|
|
// point to the supposed lcl = dup$n statement
|
|
OTStmtStore nextstore = (OTStmtStore)nextlink.Value;
|
|
LinkedListNode<OTStmt> nextlink2 = nextlink.Next;
|
|
if((nextstore.varwr is OTOpndLocal) && (nextstore.value == vardup) && (nextlink2 != null))
|
|
{
|
|
|
|
// get the local var being written and point to the ... qwer dup$n ... statement
|
|
OTOpndLocal varlcl = (OTOpndLocal)nextstore.varwr;
|
|
OTStmt nextstmt2 = nextlink2.Value;
|
|
|
|
// try to replace dup$n in qwer with lcl
|
|
if(nextstmt2.ReplaceOperand(vardup, varlcl))
|
|
{
|
|
|
|
// successful, replace dup$n in asdf with lcl
|
|
// and delete the lcl = dup$n statement
|
|
varwr = varlcl;
|
|
nextlink.List.Remove(nextlink);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// convert:
|
|
// dup$n = ... asdf ... << we are here
|
|
// ... qwer dup$n ...
|
|
// ... no further references to dup$n
|
|
// to:
|
|
// ... qwer ... asdf ... ...
|
|
if((varwr is OTOpndDup) && (link != null))
|
|
{
|
|
OTOpndDup vardup = (OTOpndDup)varwr;
|
|
LinkedListNode<OTStmt> nextlink = link.Next;
|
|
vardup.ndupreads = 0;
|
|
decompile.topBlock.CountRefs();
|
|
if((vardup.ndupreads == 1) && (nextlink != null))
|
|
{
|
|
|
|
// point to the ... qwer dup$n ... statement
|
|
OTStmt nextstmt = nextlink.Value;
|
|
|
|
// try to replace dup$n in qwer with ... asdf ...
|
|
if(nextstmt.ReplaceOperand(vardup, value))
|
|
{
|
|
|
|
// successful, delete the dup$n = ... asdf ... statement
|
|
link.List.Remove(link);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// look for list initialization [ ... ]
|
|
if(OTOpndListIni.Detect(link))
|
|
return true;
|
|
|
|
// __xmrinst = (XMRInstAbstract) arg$0 indicates this is an event handler
|
|
// so strip it out and set the flag
|
|
if((varwr is OTOpndLocal) && (value is OTOpndCast))
|
|
{
|
|
OTOpndLocal lcl = (OTOpndLocal)varwr;
|
|
OTOpndCast cast = (OTOpndCast)value;
|
|
if(lcl.local.name.StartsWith(_xmrinstlocal) && (cast.value is OTOpndArg))
|
|
{
|
|
link.List.Remove(link);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// local = [ (optional cast) ] __xmrinst.ehArgs[n] is a definition of event handler arg #n
|
|
// if found, make it event handler arg list definition
|
|
OTOpnd valuenocast = value;
|
|
if(valuenocast is OTOpndCast)
|
|
valuenocast = ((OTOpndCast)value).value;
|
|
if((varwr is OTOpndLocal) && (valuenocast is OTOpndArrayElem))
|
|
{
|
|
OTOpndArrayElem array = (OTOpndArrayElem)valuenocast;
|
|
if((array.array is OTOpndField) && (array.index is OTOpndInt))
|
|
{
|
|
OTOpndField arrayfield = (OTOpndField)array.array;
|
|
if((arrayfield.obj is OTOpndLocal) &&
|
|
((OTOpndLocal)arrayfield.obj).local.name.StartsWith(_xmrinstlocal) &&
|
|
(arrayfield.field.Name == _ehArgs))
|
|
{
|
|
int index = ((OTOpndInt)array.index).value;
|
|
decompile.eharglist[index] = ((OTOpndLocal)varwr).local;
|
|
link.List.Remove(link);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// __retval$n = ...; => return ...;
|
|
if(varwr is OTOpndLocal)
|
|
{
|
|
OTOpndLocal lcl = (OTOpndLocal)varwr;
|
|
if(lcl.local.name.StartsWith(_retval))
|
|
{
|
|
link.Value = new OTStmtRet(value);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public override bool ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd)
|
|
{
|
|
bool rc = false;
|
|
if(value != null)
|
|
value = value.ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
return rc;
|
|
}
|
|
|
|
public override OTStmt ReplaceStatement(OTStmt oldstmt, OTStmt newstmt)
|
|
{
|
|
return this;
|
|
}
|
|
|
|
public override void PrintStmt(TextWriter twout, string indent)
|
|
{
|
|
// print x = x + 1 as x += 1, but don't print x = x < 3 as x <= 3
|
|
if(value is OTOpndBinOp)
|
|
{
|
|
OTOpndBinOp valuebo = (OTOpndBinOp)value;
|
|
if(varwr.SameAs(valuebo.left) && " add and div mul or rem shl shr sub xor ".Contains(' ' + valuebo.opCode.name + ' '))
|
|
{
|
|
twout.Write(varwr.PrintableString + ' ' + valuebo.opCode.source + "= " + valuebo.rite.PrintableString + ';');
|
|
return;
|
|
}
|
|
}
|
|
|
|
twout.Write(varwr.PrintableString + " = " + value.PrintableString + ';');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Dispatch to a table of labels.
|
|
*/
|
|
private class OTStmtSwitch: OTStmt
|
|
{
|
|
private OTOpnd index;
|
|
private OTLabel[] labels;
|
|
|
|
public OTStmtSwitch(OTOpnd index, OTLabel[] labels)
|
|
{
|
|
this.index = index;
|
|
this.labels = labels;
|
|
}
|
|
|
|
public override void CountRefs()
|
|
{
|
|
index.CountRefs(false);
|
|
foreach(OTLabel label in labels)
|
|
{
|
|
label.lbljumps++;
|
|
}
|
|
}
|
|
|
|
public override bool ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd)
|
|
{
|
|
bool rc = false;
|
|
if(index != null)
|
|
index = index.ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
return rc;
|
|
}
|
|
|
|
public override OTStmt ReplaceStatement(OTStmt oldstmt, OTStmt newstmt)
|
|
{
|
|
return this;
|
|
}
|
|
|
|
public override void PrintStmt(TextWriter twout, string indent)
|
|
{
|
|
twout.Write("switch (" + index.PrintableString + ") {\n");
|
|
for(int i = 0; i < labels.Length; i++)
|
|
{
|
|
twout.Write(indent + INDENT + "case " + i + ": jump " + labels[i].name + ";\n");
|
|
}
|
|
twout.Write(indent + '}');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Throw an exception.
|
|
*/
|
|
private class OTStmtThrow: OTStmt
|
|
{
|
|
private OTOpnd value;
|
|
private OTDecompile decompile;
|
|
|
|
public OTStmtThrow(OTOpnd value, OTDecompile decompile)
|
|
{
|
|
this.value = value;
|
|
this.decompile = decompile;
|
|
}
|
|
|
|
public override void CountRefs()
|
|
{
|
|
value.CountRefs(false);
|
|
}
|
|
|
|
public override bool StripStuff(LinkedListNode<OTStmt> link)
|
|
{
|
|
return StripStuffForTerminal(link);
|
|
}
|
|
|
|
public override bool ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd)
|
|
{
|
|
bool rc = false;
|
|
if(value != null)
|
|
value = value.ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
return rc;
|
|
}
|
|
|
|
public override OTStmt ReplaceStatement(OTStmt oldstmt, OTStmt newstmt)
|
|
{
|
|
return this;
|
|
}
|
|
|
|
public override void PrintStmt(TextWriter twout, string indent)
|
|
{
|
|
// throw newobj ScriptUndefinedStateException ("x") => state x
|
|
if(value is OTOpndNewobj)
|
|
{
|
|
OTOpndNewobj valueno = (OTOpndNewobj)value;
|
|
if((valueno.ctor.DeclaringType == typeof(ScriptUndefinedStateException)) &&
|
|
(valueno.args.Length == 1) && (valueno.args[0] is OTOpndString))
|
|
{
|
|
OTOpndString arg0 = (OTOpndString)valueno.args[0];
|
|
twout.Write("state " + arg0.value + "; /* throws undefined state exception */");
|
|
return;
|
|
}
|
|
}
|
|
|
|
// throw newobj ScriptChangeStateException (n) => state n
|
|
if(value is OTOpndNewobj)
|
|
{
|
|
OTOpndNewobj valueno = (OTOpndNewobj)value;
|
|
if((valueno.ctor.DeclaringType == typeof(ScriptChangeStateException)) &&
|
|
(valueno.args.Length == 1) && (valueno.args[0] is OTOpndInt))
|
|
{
|
|
OTOpndInt arg0 = (OTOpndInt)valueno.args[0];
|
|
twout.Write("state " + decompile.scriptObjCode.stateNames[arg0.value] + ';');
|
|
return;
|
|
}
|
|
}
|
|
|
|
// throwing something else, output as is
|
|
twout.Write("throw " + value.PrintableString + ';');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call with void return, or really anything that we discard the value of after computing it.
|
|
*/
|
|
private class OTStmtVoid: OTStmt
|
|
{
|
|
private OTOpnd value;
|
|
|
|
public static void AddLast(OTDecompile decompile, OTOpnd value)
|
|
{
|
|
OTStmt it = OTStmtVoid.Make(value);
|
|
if(it != null)
|
|
decompile.AddLastStmt(it);
|
|
}
|
|
|
|
public static OTStmt Make(OTOpnd value)
|
|
{
|
|
if(!value.HasSideEffects)
|
|
return null;
|
|
OTStmtVoid it = new OTStmtVoid();
|
|
it.value = value;
|
|
return it;
|
|
}
|
|
|
|
private OTStmtVoid()
|
|
{
|
|
}
|
|
|
|
public override void CountRefs()
|
|
{
|
|
value.CountRefs(false);
|
|
}
|
|
|
|
public override bool ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd)
|
|
{
|
|
bool rc = false;
|
|
value = value.ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
return rc;
|
|
}
|
|
|
|
public override bool StripStuff(LinkedListNode<OTStmt> link)
|
|
{
|
|
// strip out calls to CheckRunQuick() and CheckRunStack()
|
|
if(value is OTOpndCall)
|
|
{
|
|
OTOpndCall call = (OTOpndCall)value;
|
|
MethodInfo method = call.method;
|
|
if((method.Name == _checkRunQuick) || (method.Name == _checkRunStack))
|
|
{
|
|
link.List.Remove(link);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public override OTStmt ReplaceStatement(OTStmt oldstmt, OTStmt newstmt)
|
|
{
|
|
return this;
|
|
}
|
|
|
|
public override void PrintStmt(TextWriter twout, string indent)
|
|
{
|
|
twout.Write(value.PrintableString + ';');
|
|
}
|
|
}
|
|
|
|
/***************************\
|
|
* Structured statements *
|
|
\***************************/
|
|
|
|
/**
|
|
* Block of statements.
|
|
*/
|
|
private class OTStmtBlock: OTStmt
|
|
{
|
|
public LinkedList<OTStmt> blkstmts = new LinkedList<OTStmt>();
|
|
|
|
public override void CountRefs()
|
|
{
|
|
foreach(OTStmt stmt in blkstmts)
|
|
{
|
|
stmt.CountRefs();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Scrub out all references to behind-the-scenes parts and simplify.
|
|
*/
|
|
public override bool StripStuff(LinkedListNode<OTStmt> link)
|
|
{
|
|
// loop through all sub-statements to strip out behind-the-scenes references
|
|
bool rc = false;
|
|
loop:
|
|
for(LinkedListNode<OTStmt> stmtlink = blkstmts.First; stmtlink != null; stmtlink = stmtlink.Next)
|
|
{
|
|
if(stmtlink.Value.StripStuff(stmtlink))
|
|
{
|
|
rc = true;
|
|
goto loop;
|
|
}
|
|
}
|
|
if(rc)
|
|
return true;
|
|
|
|
// try to merge this block into outer block
|
|
// change:
|
|
// {
|
|
// ...
|
|
// { << link points here
|
|
// ...
|
|
// }
|
|
// ...
|
|
// }
|
|
// to:
|
|
// {
|
|
// ...
|
|
// ...
|
|
// ...
|
|
// }
|
|
if(link != null)
|
|
{
|
|
LinkedListNode<OTStmt> nextlink;
|
|
while((nextlink = blkstmts.Last) != null)
|
|
{
|
|
nextlink.List.Remove(nextlink);
|
|
link.List.AddAfter(link, nextlink);
|
|
}
|
|
link.List.Remove(link);
|
|
return true;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
public override bool ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd)
|
|
{
|
|
bool rc = false;
|
|
foreach(OTStmt stmt in blkstmts)
|
|
{
|
|
rc |= stmt.ReplaceOperand(oldopnd, newopnd);
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* Check each statement in the block to see if it starts a do/for/if/while statement.
|
|
*/
|
|
public override bool DetectDoForIfWhile(LinkedListNode<OTStmt> link)
|
|
{
|
|
bool rc = false;
|
|
loop:
|
|
for(link = blkstmts.First; link != null; link = link.Next)
|
|
{
|
|
if(link.Value.DetectDoForIfWhile(link))
|
|
{
|
|
rc = true;
|
|
goto loop;
|
|
}
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* Assume we will never try to replace the block itself.
|
|
* But go through all our sub-ordinates statements.
|
|
*/
|
|
public override OTStmt ReplaceStatement(OTStmt oldstmt, OTStmt newstmt)
|
|
{
|
|
for(LinkedListNode<OTStmt> childlink = blkstmts.First; childlink != null; childlink = childlink.Next)
|
|
{
|
|
childlink.Value = childlink.Value.ReplaceStatement(oldstmt, newstmt);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Print out the block including its enclosed statements.
|
|
*/
|
|
public override void PrintStmt(TextWriter twout, string indent)
|
|
{
|
|
switch(blkstmts.Count)
|
|
{
|
|
case 0:
|
|
{
|
|
twout.Write("{ }");
|
|
break;
|
|
}
|
|
////case 1: {
|
|
//// blkstmts.First.Value.PrintStmt (twout, indent);
|
|
//// break;
|
|
////}
|
|
default:
|
|
{
|
|
twout.Write('{');
|
|
PrintBodyAndEnd(twout, indent);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void PrintBodyAndEnd(TextWriter twout, string indent)
|
|
{
|
|
string newindent = indent + INDENT;
|
|
foreach(OTStmt stmt in blkstmts)
|
|
{
|
|
twout.Write('\n' + indent);
|
|
if(!(stmt is OTStmtLabel))
|
|
twout.Write(INDENT);
|
|
else
|
|
twout.Write(LABELINDENT);
|
|
stmt.PrintStmt(twout, newindent);
|
|
}
|
|
twout.Write('\n' + indent + '}');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 'do' statement.
|
|
*/
|
|
private class OTStmtDo: OTStmt
|
|
{
|
|
private OTOpnd dotest;
|
|
private OTStmtBlock dobody;
|
|
|
|
/**
|
|
* See if we have a do loop...
|
|
* @doloop_<suffix>; << link points here
|
|
* ... <dobody> ...
|
|
* [ if (dotest) ] jump doloop_<suffix>;
|
|
*/
|
|
public static bool Detect(LinkedListNode<OTStmt> link)
|
|
{
|
|
// see if we have label starting with 'doloop_'
|
|
OTLabel looplabel = ((OTStmtLabel)link.Value).label;
|
|
if(!looplabel.name.StartsWith(_doLoop))
|
|
return false;
|
|
|
|
// good chance we have a do loop
|
|
OTStmtDo it = new OTStmtDo();
|
|
|
|
// scan ahead looking for the terminating cond/jump loop
|
|
// also gather up the statements for the do body block
|
|
it.dobody = new OTStmtBlock();
|
|
LinkedListNode<OTStmt> nextlink;
|
|
for(nextlink = link.Next; nextlink != null; nextlink = nextlink.Next)
|
|
{
|
|
OTStmt nextstmt = nextlink.Value;
|
|
|
|
// add statement to do body
|
|
it.dobody.blkstmts.AddLast(nextlink.Value);
|
|
|
|
// check for something what jumps to loop label
|
|
// that gives us the end of the loop
|
|
OTStmt maybejump = nextstmt;
|
|
if(nextstmt is OTStmtCond)
|
|
{
|
|
maybejump = ((OTStmtCond)nextstmt).stmt;
|
|
}
|
|
if((maybejump is OTStmtJump) && (((OTStmtJump)maybejump).label == looplabel))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// make sure we found the jump back to the loop label
|
|
if(nextlink == null)
|
|
return false;
|
|
|
|
// remove all statements from caller's block including the continue label if any
|
|
// but leave the break label alone it will be removed later if unreferenced
|
|
// and leave the initial loop label intact for now
|
|
for(LinkedListNode<OTStmt> remlink = null; (remlink = link.Next) != null;)
|
|
{
|
|
link.List.Remove(remlink);
|
|
if(remlink == nextlink)
|
|
break;
|
|
}
|
|
|
|
// take test condition from last statement of body
|
|
// it should be an cond/jump or just a jump to the loop label
|
|
LinkedListNode<OTStmt> lastlink = it.dobody.blkstmts.Last;
|
|
OTStmt laststmt = lastlink.Value;
|
|
if(laststmt is OTStmtCond)
|
|
{
|
|
it.dotest = ((OTStmtCond)laststmt).valu;
|
|
}
|
|
else
|
|
{
|
|
it.dotest = new OTOpndInt(1);
|
|
}
|
|
lastlink.List.Remove(lastlink);
|
|
|
|
// finally replace the loop label with the whole do statement
|
|
link.Value = it;
|
|
|
|
// tell caller we made a change
|
|
return true;
|
|
}
|
|
|
|
public override void CountRefs()
|
|
{
|
|
if(dotest != null)
|
|
dotest.CountRefs(false);
|
|
if(dobody != null)
|
|
dobody.CountRefs();
|
|
}
|
|
|
|
public override bool ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd)
|
|
{
|
|
return dobody.ReplaceOperand(oldopnd, newopnd);
|
|
}
|
|
|
|
public override bool DetectDoForIfWhile(LinkedListNode<OTStmt> link)
|
|
{
|
|
return dobody.DetectDoForIfWhile(link);
|
|
}
|
|
|
|
/**
|
|
* Assume we won't replace the do statement itself.
|
|
* But search all our sub-ordinate statements.
|
|
*/
|
|
public override OTStmt ReplaceStatement(OTStmt oldstmt, OTStmt newstmt)
|
|
{
|
|
dobody = (OTStmtBlock)dobody.ReplaceStatement(oldstmt, newstmt);
|
|
return this;
|
|
}
|
|
|
|
public override void PrintStmt(TextWriter twout, string indent)
|
|
{
|
|
// output do body
|
|
twout.Write("do ");
|
|
dobody.PrintStmt(twout, indent);
|
|
|
|
// output while part
|
|
twout.Write(" while (" + StripBrtrue(dotest).PrintableString + ");");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 'for' or 'while' statement.
|
|
*/
|
|
private class OTStmtFor: OTStmt
|
|
{
|
|
private bool iswhile;
|
|
private OTOpnd fortest;
|
|
private OTStmtBlock forbody;
|
|
private OTStmt forinit;
|
|
private OTStmt forstep;
|
|
|
|
/**
|
|
* See if we have a for or while loop...
|
|
* <forinit>
|
|
* @forloop_<suffix>; << link points here
|
|
* [ if (<fortest>) jump forbreak_<suffix>; ]
|
|
* ... <forbody> ...
|
|
* jump forloop_<suffix>;
|
|
* [ @forbreak_<suffix>; ]
|
|
*/
|
|
public static bool Detect(LinkedListNode<OTStmt> link, bool iswhile)
|
|
{
|
|
string loopname = iswhile ? _whileLoop : _forLoop;
|
|
string breakname = iswhile ? _whileBreak : _forBreak;
|
|
|
|
// see if we have label starting with 'forloop_'
|
|
OTLabel looplabel = ((OTStmtLabel)link.Value).label;
|
|
if(!looplabel.name.StartsWith(loopname))
|
|
return false;
|
|
|
|
// good chance we have a for loop
|
|
OTStmtFor it = new OTStmtFor();
|
|
it.iswhile = iswhile;
|
|
|
|
// all labels end with this suffix
|
|
string suffix = looplabel.name.Substring(loopname.Length);
|
|
|
|
// scan ahead looking for the 'jump forloop_<suffix>;' statement
|
|
// also gather up the statements for the for body block
|
|
it.forbody = new OTStmtBlock();
|
|
LinkedListNode<OTStmt> lastlink;
|
|
for(lastlink = link; (lastlink = lastlink.Next) != null;)
|
|
{
|
|
|
|
// check for jump forloop that tells us where loop ends
|
|
if(lastlink.Value is OTStmtJump)
|
|
{
|
|
OTStmtJump lastjump = (OTStmtJump)lastlink.Value;
|
|
if(lastjump.label == looplabel)
|
|
break;
|
|
}
|
|
|
|
// add to body block
|
|
it.forbody.blkstmts.AddLast(lastlink.Value);
|
|
}
|
|
|
|
// make sure we found the 'jump forloop' where the for loop ends
|
|
if(lastlink == null)
|
|
return false;
|
|
|
|
// remove all statements from caller's block including final jump
|
|
// but leave the loop label in place
|
|
for(LinkedListNode<OTStmt> nextlink = null; (nextlink = link.Next) != null;)
|
|
{
|
|
link.List.Remove(nextlink);
|
|
if(nextlink == lastlink)
|
|
break;
|
|
}
|
|
|
|
// if statement before loop label is an assignment, use it for the init statement
|
|
if(!iswhile && (link.Previous != null) && (link.Previous.Value is OTStmtStore))
|
|
{
|
|
it.forinit = link.Previous.Value;
|
|
link.List.Remove(link.Previous);
|
|
}
|
|
|
|
// if first statement of for body is 'if (...) jump breaklabel' use it for the test value
|
|
if((it.forbody.blkstmts.First != null) && (it.forbody.blkstmts.First.Value is OTStmtCond))
|
|
{
|
|
OTStmtCond condstmt = (OTStmtCond)it.forbody.blkstmts.First.Value;
|
|
if((condstmt.stmt is OTStmtJump) && (((OTStmtJump)condstmt.stmt).label.name == breakname + suffix))
|
|
{
|
|
it.fortest = OTOpndUnOp.Make(MyOp.Brfalse, condstmt.valu);
|
|
it.forbody.blkstmts.RemoveFirst();
|
|
}
|
|
}
|
|
|
|
// if last statement of body is an assigment,
|
|
// use the assignment as the step statement
|
|
if(!iswhile && (it.forbody.blkstmts.Last != null) &&
|
|
(it.forbody.blkstmts.Last.Value is OTStmtStore))
|
|
{
|
|
LinkedListNode<OTStmt> storelink = it.forbody.blkstmts.Last;
|
|
storelink.List.Remove(storelink);
|
|
it.forstep = storelink.Value;
|
|
}
|
|
|
|
// finally replace the loop label with the whole for statement
|
|
link.Value = it;
|
|
|
|
// tell caller we made a change
|
|
return true;
|
|
}
|
|
|
|
public override void CountRefs()
|
|
{
|
|
if(fortest != null)
|
|
fortest.CountRefs(false);
|
|
if(forbody != null)
|
|
forbody.CountRefs();
|
|
if(forinit != null)
|
|
forinit.CountRefs();
|
|
if(forstep != null)
|
|
forstep.CountRefs();
|
|
}
|
|
|
|
public override bool ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd)
|
|
{
|
|
return forbody.ReplaceOperand(oldopnd, newopnd) |
|
|
((forinit != null) && forinit.ReplaceOperand(oldopnd, newopnd)) |
|
|
((forstep != null) && forstep.ReplaceOperand(oldopnd, newopnd));
|
|
}
|
|
|
|
public override bool DetectDoForIfWhile(LinkedListNode<OTStmt> link)
|
|
{
|
|
return forbody.DetectDoForIfWhile(link) |
|
|
((forinit != null) && forinit.DetectDoForIfWhile(link)) |
|
|
((forstep != null) && forstep.DetectDoForIfWhile(link));
|
|
}
|
|
|
|
/**
|
|
* Assume we won't replace the for statement itself.
|
|
* But search all our sub-ordinate statements.
|
|
*/
|
|
public override OTStmt ReplaceStatement(OTStmt oldstmt, OTStmt newstmt)
|
|
{
|
|
forbody = (OTStmtBlock)forbody.ReplaceStatement(oldstmt, newstmt);
|
|
if(forinit != null)
|
|
forinit = forinit.ReplaceStatement(oldstmt, newstmt);
|
|
if(forstep != null)
|
|
forstep = forstep.ReplaceStatement(oldstmt, newstmt);
|
|
return this;
|
|
}
|
|
|
|
public override void PrintStmt(TextWriter twout, string indent)
|
|
{
|
|
if(iswhile)
|
|
{
|
|
twout.Write("while (");
|
|
if(fortest == null)
|
|
{
|
|
twout.Write("TRUE");
|
|
}
|
|
else
|
|
{
|
|
twout.Write(StripBrtrue(fortest).PrintableString);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
twout.Write("for (");
|
|
if(forinit != null)
|
|
{
|
|
forinit.PrintStmt(twout, indent + INDENT);
|
|
}
|
|
else
|
|
{
|
|
twout.Write(';');
|
|
}
|
|
if(fortest != null)
|
|
{
|
|
twout.Write(' ' + StripBrtrue(fortest).PrintableString);
|
|
}
|
|
twout.Write(';');
|
|
if(forstep != null)
|
|
{
|
|
StringWriter sw = new StringWriter();
|
|
sw.Write(' ');
|
|
forstep.PrintStmt(sw, indent + INDENT);
|
|
StringBuilder sb = sw.GetStringBuilder();
|
|
int sl = sb.Length;
|
|
if((sl > 0) && (sb[sl - 1] == ';'))
|
|
sb.Remove(--sl, 1);
|
|
twout.Write(sb.ToString());
|
|
}
|
|
}
|
|
|
|
twout.Write(") ");
|
|
forbody.PrintStmt(twout, indent);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* if/then/else block.
|
|
*/
|
|
private class OTStmtIf: OTStmt
|
|
{
|
|
private OTOpnd testvalu;
|
|
private OTStmt thenstmt;
|
|
private OTStmt elsestmt; // might be null
|
|
|
|
/**
|
|
* Try to detect a structured if statement.
|
|
*
|
|
* if (condition) jump ifdone_<suffix>; << link points here
|
|
* ... then body ...
|
|
* @ifdone_<suffix>;
|
|
*
|
|
* if (condition) jump ifelse_<suffix>;
|
|
* ... then body ...
|
|
* jump ifdone_<suffix>; << optional if true body doesn't fall through
|
|
* @ifelse_<suffix>;
|
|
* ... else body ...
|
|
* @ifdone_<suffix>;
|
|
*/
|
|
public static bool Detect(LinkedListNode<OTStmt> link)
|
|
{
|
|
OTStmtCond condstmt = (OTStmtCond)link.Value;
|
|
if(!(condstmt.stmt is OTStmtJump))
|
|
return false;
|
|
|
|
OTStmtJump jumpstmt = (OTStmtJump)condstmt.stmt;
|
|
if(jumpstmt.label.name.StartsWith(_ifDone))
|
|
{
|
|
|
|
// then-only if
|
|
|
|
// skip forward to find the ifdone_<suffix> label
|
|
// also save the intervening statements for the then body
|
|
OTStmtBlock thenbody;
|
|
LinkedListNode<OTStmt> donelink = ScanForLabel(link, jumpstmt.label, out thenbody);
|
|
|
|
// make sure we found matching label
|
|
if(donelink == null)
|
|
return false;
|
|
|
|
// replace the jump ifdone_<suffix> with the <then body>
|
|
OTStmtIf it = new OTStmtIf();
|
|
it.thenstmt = thenbody;
|
|
|
|
// replace the test value with the opposite
|
|
it.testvalu = OTOpndUnOp.Make(MyOp.Brfalse, condstmt.valu);
|
|
condstmt.valu = null;
|
|
|
|
// strip out the true body statements from the main code including the ifdone_<suffix> label
|
|
StripInterveningStatements(link, donelink);
|
|
|
|
// replace the simple conditional with the if/then/else block
|
|
link.Value = it;
|
|
|
|
// tell caller we changed something
|
|
return true;
|
|
}
|
|
|
|
if(jumpstmt.label.name.StartsWith(_ifElse))
|
|
{
|
|
string suffix = jumpstmt.label.name.Substring(_ifElse.Length);
|
|
|
|
// if/then/else
|
|
OTStmtIf it = new OTStmtIf();
|
|
|
|
// skip forward to find the ifelse_<suffix> label
|
|
// also save the intervening statements for the true body
|
|
OTStmtBlock thenbody;
|
|
LinkedListNode<OTStmt> elselink = ScanForLabel(link, jumpstmt.label, out thenbody);
|
|
|
|
// make sure we found matching label
|
|
if(elselink != null)
|
|
{
|
|
|
|
// the last statement of the then body might be a jump ifdone_<suffix>
|
|
LinkedListNode<OTStmt> lastthenlink = thenbody.blkstmts.Last;
|
|
if((lastthenlink != null) && (lastthenlink.Value is OTStmtJump))
|
|
{
|
|
OTStmtJump jumpifdone = (OTStmtJump)lastthenlink.Value;
|
|
if(jumpifdone.label.name == _ifDone + suffix)
|
|
{
|
|
|
|
lastthenlink.List.Remove(lastthenlink);
|
|
|
|
// skip forward to find the ifdone_<suffix> label
|
|
// also save the intervening statements for the else body
|
|
OTStmtBlock elsebody;
|
|
LinkedListNode<OTStmt> donelink = ScanForLabel(elselink, jumpifdone.label, out elsebody);
|
|
if(donelink != null)
|
|
{
|
|
|
|
// replace the jump ifdone_<suffix> with the <true body>
|
|
it.thenstmt = thenbody;
|
|
|
|
// save the else body as well
|
|
it.elsestmt = elsebody;
|
|
|
|
// replace the test value with the opposite
|
|
it.testvalu = OTOpndUnOp.Make(MyOp.Brfalse, condstmt.valu);
|
|
condstmt.valu = null;
|
|
|
|
// strip out the true and else body statements from the main code including the ifdone_<suffix> label
|
|
StripInterveningStatements(link, donelink);
|
|
|
|
// replace the simple conditional with the if/then/else block
|
|
link.Value = it;
|
|
|
|
// tell caller we changed something
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// missing the jump _ifDone_<suffix>, so make it a simple if/then
|
|
// if (condition) jump ifelse_<suffix>; << link
|
|
// ... then body ... << encapsulated in block thenbody
|
|
// @ifelse_<suffix>; << elselink
|
|
// ... else body ... << still inline and leave it there
|
|
// @ifdone_<suffix>; << strip this out
|
|
|
|
// replace the jump ifelse_<suffix> with the <true body>
|
|
it.thenstmt = thenbody;
|
|
|
|
// replace the test value with the opposite
|
|
it.testvalu = OTOpndUnOp.Make(MyOp.Brfalse, condstmt.valu);
|
|
condstmt.valu = null;
|
|
|
|
// strip out the then body statements from the main code including the ifelse_<suffix> label
|
|
StripInterveningStatements(link, elselink);
|
|
|
|
// there's a dangling unused ifdone_<suffix> label ahead that has to be stripped
|
|
for(LinkedListNode<OTStmt> donelink = link; (donelink = donelink.Next) != null;)
|
|
{
|
|
if((donelink.Value is OTStmtLabel) && (((OTStmtLabel)donelink.Value).label.name == _ifDone + suffix))
|
|
{
|
|
donelink.List.Remove(donelink);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// replace the simple conditional with the if/then/else block
|
|
link.Value = it;
|
|
|
|
// tell caller we changed something
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private OTStmtIf()
|
|
{
|
|
}
|
|
|
|
public override void CountRefs()
|
|
{
|
|
if(testvalu != null)
|
|
testvalu.CountRefs(false);
|
|
if(thenstmt != null)
|
|
thenstmt.CountRefs();
|
|
if(elsestmt != null)
|
|
elsestmt.CountRefs();
|
|
}
|
|
|
|
public override bool ReplaceOperand(OTOpnd oldopnd, OTOpnd newopnd)
|
|
{
|
|
bool rc = thenstmt.ReplaceOperand(oldopnd, newopnd);
|
|
testvalu = testvalu.ReplaceOperand(oldopnd, newopnd, ref rc);
|
|
return rc;
|
|
}
|
|
|
|
public override bool DetectDoForIfWhile(LinkedListNode<OTStmt> link)
|
|
{
|
|
return ((thenstmt != null) && thenstmt.DetectDoForIfWhile(link)) |
|
|
((elsestmt != null) && elsestmt.DetectDoForIfWhile(link));
|
|
}
|
|
|
|
/**
|
|
* Assume we won't replace the if statement itself.
|
|
* But search all our sub-ordinate statements.
|
|
*/
|
|
public override OTStmt ReplaceStatement(OTStmt oldstmt, OTStmt newstmt)
|
|
{
|
|
thenstmt = thenstmt.ReplaceStatement(oldstmt, newstmt);
|
|
if(elsestmt != null)
|
|
elsestmt = elsestmt.ReplaceStatement(oldstmt, newstmt);
|
|
return this;
|
|
}
|
|
|
|
public override void PrintStmt(TextWriter twout, string indent)
|
|
{
|
|
twout.Write("if (" + StripBrtrue(testvalu).PrintableString + ") ");
|
|
OTStmt thenst = ReduceStmtBody(thenstmt, false);
|
|
thenst.PrintStmt(twout, indent);
|
|
if(elsestmt != null)
|
|
{
|
|
twout.Write('\n' + indent + "else ");
|
|
OTStmt elsest = ReduceStmtBody(elsestmt, true);
|
|
elsest.PrintStmt(twout, indent);
|
|
}
|
|
}
|
|
|
|
// strip block off a single jump so it prints inline instead of with braces around it
|
|
// also, if this is part of else, strip block for ifs to make else if statement
|
|
private static OTStmt ReduceStmtBody(OTStmt statement, bool stripif)
|
|
{
|
|
OTStmt onestmt = statement;
|
|
if((onestmt is OTStmtBlock) && (((OTStmtBlock)onestmt).blkstmts.Count == 1))
|
|
{
|
|
onestmt = ((OTStmtBlock)onestmt).blkstmts.First.Value;
|
|
if((onestmt is OTStmtJump) || (stripif && (onestmt is OTStmtIf)))
|
|
{
|
|
return onestmt;
|
|
}
|
|
}
|
|
return statement;
|
|
}
|
|
|
|
/**
|
|
* Scan forward for a given label definition.
|
|
* Put intervening statements in a statement block.
|
|
* @param link = start scanning after this statement
|
|
* @param label = look for this label definition
|
|
* @param block = where to return intervening statement block
|
|
* @returns null: label definition not found
|
|
* else: label definition statement
|
|
*/
|
|
private static LinkedListNode<OTStmt> ScanForLabel(LinkedListNode<OTStmt> link,
|
|
OTLabel label, out OTStmtBlock block)
|
|
{
|
|
block = new OTStmtBlock();
|
|
while((link = link.Next) != null)
|
|
{
|
|
if(link.Value is OTStmtLabel)
|
|
{
|
|
if(((OTStmtLabel)link.Value).label == label)
|
|
break;
|
|
}
|
|
block.blkstmts.AddLast(link.Value);
|
|
}
|
|
return link;
|
|
}
|
|
|
|
/**
|
|
* Strip statements after link up to and including donelink.
|
|
*/
|
|
private static void StripInterveningStatements(LinkedListNode<OTStmt> link, LinkedListNode<OTStmt> donelink)
|
|
{
|
|
LinkedListNode<OTStmt> striplink;
|
|
do
|
|
{
|
|
striplink = link.Next;
|
|
striplink.List.Remove(striplink);
|
|
} while(striplink != donelink);
|
|
}
|
|
}
|
|
|
|
private class MyOp
|
|
{
|
|
public int index;
|
|
public OpCode sysop;
|
|
public string name;
|
|
public string source;
|
|
|
|
private static Dictionary<string, MyOp> myopsbyname = new Dictionary<string, MyOp>();
|
|
private static int nextindex = 0;
|
|
|
|
public MyOp(OpCode sysop)
|
|
{
|
|
this.index = nextindex++;
|
|
this.sysop = sysop;
|
|
this.name = sysop.Name;
|
|
myopsbyname.Add(name, this);
|
|
}
|
|
|
|
public MyOp(OpCode sysop, string source)
|
|
{
|
|
this.index = nextindex++;
|
|
this.sysop = sysop;
|
|
this.name = sysop.Name;
|
|
this.source = source;
|
|
myopsbyname.Add(name, this);
|
|
}
|
|
|
|
public MyOp(string name)
|
|
{
|
|
this.index = nextindex++;
|
|
this.name = name;
|
|
myopsbyname.Add(name, this);
|
|
}
|
|
|
|
public MyOp(string name, string source)
|
|
{
|
|
this.index = nextindex++;
|
|
this.name = name;
|
|
this.source = source;
|
|
myopsbyname.Add(name, this);
|
|
}
|
|
|
|
public static MyOp GetByName(string name)
|
|
{
|
|
return myopsbyname[name];
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return name;
|
|
}
|
|
|
|
// these copied from OpCodes.cs
|
|
public static readonly MyOp Nop = new MyOp(OpCodes.Nop);
|
|
public static readonly MyOp Break = new MyOp(OpCodes.Break);
|
|
public static readonly MyOp Ldarg_0 = new MyOp(OpCodes.Ldarg_0);
|
|
public static readonly MyOp Ldarg_1 = new MyOp(OpCodes.Ldarg_1);
|
|
public static readonly MyOp Ldarg_2 = new MyOp(OpCodes.Ldarg_2);
|
|
public static readonly MyOp Ldarg_3 = new MyOp(OpCodes.Ldarg_3);
|
|
public static readonly MyOp Ldloc_0 = new MyOp(OpCodes.Ldloc_0);
|
|
public static readonly MyOp Ldloc_1 = new MyOp(OpCodes.Ldloc_1);
|
|
public static readonly MyOp Ldloc_2 = new MyOp(OpCodes.Ldloc_2);
|
|
public static readonly MyOp Ldloc_3 = new MyOp(OpCodes.Ldloc_3);
|
|
public static readonly MyOp Stloc_0 = new MyOp(OpCodes.Stloc_0);
|
|
public static readonly MyOp Stloc_1 = new MyOp(OpCodes.Stloc_1);
|
|
public static readonly MyOp Stloc_2 = new MyOp(OpCodes.Stloc_2);
|
|
public static readonly MyOp Stloc_3 = new MyOp(OpCodes.Stloc_3);
|
|
public static readonly MyOp Ldarg_S = new MyOp(OpCodes.Ldarg_S);
|
|
public static readonly MyOp Ldarga_S = new MyOp(OpCodes.Ldarga_S);
|
|
public static readonly MyOp Starg_S = new MyOp(OpCodes.Starg_S);
|
|
public static readonly MyOp Ldloc_S = new MyOp(OpCodes.Ldloc_S);
|
|
public static readonly MyOp Ldloca_S = new MyOp(OpCodes.Ldloca_S);
|
|
public static readonly MyOp Stloc_S = new MyOp(OpCodes.Stloc_S);
|
|
public static readonly MyOp Ldnull = new MyOp(OpCodes.Ldnull);
|
|
public static readonly MyOp Ldc_I4_M1 = new MyOp(OpCodes.Ldc_I4_M1);
|
|
public static readonly MyOp Ldc_I4_0 = new MyOp(OpCodes.Ldc_I4_0);
|
|
public static readonly MyOp Ldc_I4_1 = new MyOp(OpCodes.Ldc_I4_1);
|
|
public static readonly MyOp Ldc_I4_2 = new MyOp(OpCodes.Ldc_I4_2);
|
|
public static readonly MyOp Ldc_I4_3 = new MyOp(OpCodes.Ldc_I4_3);
|
|
public static readonly MyOp Ldc_I4_4 = new MyOp(OpCodes.Ldc_I4_4);
|
|
public static readonly MyOp Ldc_I4_5 = new MyOp(OpCodes.Ldc_I4_5);
|
|
public static readonly MyOp Ldc_I4_6 = new MyOp(OpCodes.Ldc_I4_6);
|
|
public static readonly MyOp Ldc_I4_7 = new MyOp(OpCodes.Ldc_I4_7);
|
|
public static readonly MyOp Ldc_I4_8 = new MyOp(OpCodes.Ldc_I4_8);
|
|
public static readonly MyOp Ldc_I4_S = new MyOp(OpCodes.Ldc_I4_S);
|
|
public static readonly MyOp Ldc_I4 = new MyOp(OpCodes.Ldc_I4);
|
|
public static readonly MyOp Ldc_I8 = new MyOp(OpCodes.Ldc_I8);
|
|
public static readonly MyOp Ldc_R4 = new MyOp(OpCodes.Ldc_R4);
|
|
public static readonly MyOp Ldc_R8 = new MyOp(OpCodes.Ldc_R8);
|
|
public static readonly MyOp Dup = new MyOp(OpCodes.Dup);
|
|
public static readonly MyOp Pop = new MyOp(OpCodes.Pop);
|
|
public static readonly MyOp Jmp = new MyOp(OpCodes.Jmp);
|
|
public static readonly MyOp Call = new MyOp(OpCodes.Call);
|
|
public static readonly MyOp Calli = new MyOp(OpCodes.Calli);
|
|
public static readonly MyOp Ret = new MyOp(OpCodes.Ret);
|
|
public static readonly MyOp Br_S = new MyOp(OpCodes.Br_S);
|
|
public static readonly MyOp Brfalse_S = new MyOp(OpCodes.Brfalse_S);
|
|
public static readonly MyOp Brtrue_S = new MyOp(OpCodes.Brtrue_S);
|
|
public static readonly MyOp Beq_S = new MyOp(OpCodes.Beq_S, "==");
|
|
public static readonly MyOp Bge_S = new MyOp(OpCodes.Bge_S, ">=");
|
|
public static readonly MyOp Bgt_S = new MyOp(OpCodes.Bgt_S, ">");
|
|
public static readonly MyOp Ble_S = new MyOp(OpCodes.Ble_S, "<=");
|
|
public static readonly MyOp Blt_S = new MyOp(OpCodes.Blt_S, "<");
|
|
public static readonly MyOp Bne_Un_S = new MyOp(OpCodes.Bne_Un_S, "!=");
|
|
public static readonly MyOp Bge_Un_S = new MyOp(OpCodes.Bge_Un_S);
|
|
public static readonly MyOp Bgt_Un_S = new MyOp(OpCodes.Bgt_Un_S);
|
|
public static readonly MyOp Ble_Un_S = new MyOp(OpCodes.Ble_Un_S);
|
|
public static readonly MyOp Blt_Un_S = new MyOp(OpCodes.Blt_Un_S);
|
|
public static readonly MyOp Br = new MyOp(OpCodes.Br);
|
|
public static readonly MyOp Brfalse = new MyOp(OpCodes.Brfalse, "!");
|
|
public static readonly MyOp Brtrue = new MyOp(OpCodes.Brtrue, "!!");
|
|
public static readonly MyOp Beq = new MyOp(OpCodes.Beq, "==");
|
|
public static readonly MyOp Bge = new MyOp(OpCodes.Bge, ">=");
|
|
public static readonly MyOp Bgt = new MyOp(OpCodes.Bgt, ">");
|
|
public static readonly MyOp Ble = new MyOp(OpCodes.Ble, "<=");
|
|
public static readonly MyOp Blt = new MyOp(OpCodes.Blt, "<");
|
|
public static readonly MyOp Bne_Un = new MyOp(OpCodes.Bne_Un, "!=");
|
|
public static readonly MyOp Bge_Un = new MyOp(OpCodes.Bge_Un);
|
|
public static readonly MyOp Bgt_Un = new MyOp(OpCodes.Bgt_Un);
|
|
public static readonly MyOp Ble_Un = new MyOp(OpCodes.Ble_Un);
|
|
public static readonly MyOp Blt_Un = new MyOp(OpCodes.Blt_Un);
|
|
public static readonly MyOp Switch = new MyOp(OpCodes.Switch);
|
|
public static readonly MyOp Ldind_I1 = new MyOp(OpCodes.Ldind_I1);
|
|
public static readonly MyOp Ldind_U1 = new MyOp(OpCodes.Ldind_U1);
|
|
public static readonly MyOp Ldind_I2 = new MyOp(OpCodes.Ldind_I2);
|
|
public static readonly MyOp Ldind_U2 = new MyOp(OpCodes.Ldind_U2);
|
|
public static readonly MyOp Ldind_I4 = new MyOp(OpCodes.Ldind_I4);
|
|
public static readonly MyOp Ldind_U4 = new MyOp(OpCodes.Ldind_U4);
|
|
public static readonly MyOp Ldind_I8 = new MyOp(OpCodes.Ldind_I8);
|
|
public static readonly MyOp Ldind_I = new MyOp(OpCodes.Ldind_I);
|
|
public static readonly MyOp Ldind_R4 = new MyOp(OpCodes.Ldind_R4);
|
|
public static readonly MyOp Ldind_R8 = new MyOp(OpCodes.Ldind_R8);
|
|
public static readonly MyOp Ldind_Ref = new MyOp(OpCodes.Ldind_Ref);
|
|
public static readonly MyOp Stind_Ref = new MyOp(OpCodes.Stind_Ref);
|
|
public static readonly MyOp Stind_I1 = new MyOp(OpCodes.Stind_I1);
|
|
public static readonly MyOp Stind_I2 = new MyOp(OpCodes.Stind_I2);
|
|
public static readonly MyOp Stind_I4 = new MyOp(OpCodes.Stind_I4);
|
|
public static readonly MyOp Stind_I8 = new MyOp(OpCodes.Stind_I8);
|
|
public static readonly MyOp Stind_R4 = new MyOp(OpCodes.Stind_R4);
|
|
public static readonly MyOp Stind_R8 = new MyOp(OpCodes.Stind_R8);
|
|
public static readonly MyOp Add = new MyOp(OpCodes.Add, "+");
|
|
public static readonly MyOp Sub = new MyOp(OpCodes.Sub, "-");
|
|
public static readonly MyOp Mul = new MyOp(OpCodes.Mul, "*");
|
|
public static readonly MyOp Div = new MyOp(OpCodes.Div, "/");
|
|
public static readonly MyOp Div_Un = new MyOp(OpCodes.Div_Un);
|
|
public static readonly MyOp Rem = new MyOp(OpCodes.Rem, "%");
|
|
public static readonly MyOp Rem_Un = new MyOp(OpCodes.Rem_Un);
|
|
public static readonly MyOp And = new MyOp(OpCodes.And, "&");
|
|
public static readonly MyOp Or = new MyOp(OpCodes.Or, "|");
|
|
public static readonly MyOp Xor = new MyOp(OpCodes.Xor, "^");
|
|
public static readonly MyOp Shl = new MyOp(OpCodes.Shl, "<<");
|
|
public static readonly MyOp Shr = new MyOp(OpCodes.Shr, ">>");
|
|
public static readonly MyOp Shr_Un = new MyOp(OpCodes.Shr_Un);
|
|
public static readonly MyOp Neg = new MyOp(OpCodes.Neg, "-");
|
|
public static readonly MyOp Not = new MyOp(OpCodes.Not, "~");
|
|
public static readonly MyOp Conv_I1 = new MyOp(OpCodes.Conv_I1);
|
|
public static readonly MyOp Conv_I2 = new MyOp(OpCodes.Conv_I2);
|
|
public static readonly MyOp Conv_I4 = new MyOp(OpCodes.Conv_I4);
|
|
public static readonly MyOp Conv_I8 = new MyOp(OpCodes.Conv_I8);
|
|
public static readonly MyOp Conv_R4 = new MyOp(OpCodes.Conv_R4);
|
|
public static readonly MyOp Conv_R8 = new MyOp(OpCodes.Conv_R8);
|
|
public static readonly MyOp Conv_U4 = new MyOp(OpCodes.Conv_U4);
|
|
public static readonly MyOp Conv_U8 = new MyOp(OpCodes.Conv_U8);
|
|
public static readonly MyOp Callvirt = new MyOp(OpCodes.Callvirt);
|
|
public static readonly MyOp Cpobj = new MyOp(OpCodes.Cpobj);
|
|
public static readonly MyOp Ldobj = new MyOp(OpCodes.Ldobj);
|
|
public static readonly MyOp Ldstr = new MyOp(OpCodes.Ldstr);
|
|
public static readonly MyOp Newobj = new MyOp(OpCodes.Newobj);
|
|
public static readonly MyOp Castclass = new MyOp(OpCodes.Castclass);
|
|
public static readonly MyOp Isinst = new MyOp(OpCodes.Isinst);
|
|
public static readonly MyOp Conv_R_Un = new MyOp(OpCodes.Conv_R_Un);
|
|
public static readonly MyOp Unbox = new MyOp(OpCodes.Unbox);
|
|
public static readonly MyOp Throw = new MyOp(OpCodes.Throw);
|
|
public static readonly MyOp Ldfld = new MyOp(OpCodes.Ldfld);
|
|
public static readonly MyOp Ldflda = new MyOp(OpCodes.Ldflda);
|
|
public static readonly MyOp Stfld = new MyOp(OpCodes.Stfld);
|
|
public static readonly MyOp Ldsfld = new MyOp(OpCodes.Ldsfld);
|
|
public static readonly MyOp Ldsflda = new MyOp(OpCodes.Ldsflda);
|
|
public static readonly MyOp Stsfld = new MyOp(OpCodes.Stsfld);
|
|
public static readonly MyOp Stobj = new MyOp(OpCodes.Stobj);
|
|
public static readonly MyOp Conv_Ovf_I1_Un = new MyOp(OpCodes.Conv_Ovf_I1_Un);
|
|
public static readonly MyOp Conv_Ovf_I2_Un = new MyOp(OpCodes.Conv_Ovf_I2_Un);
|
|
public static readonly MyOp Conv_Ovf_I4_Un = new MyOp(OpCodes.Conv_Ovf_I4_Un);
|
|
public static readonly MyOp Conv_Ovf_I8_Un = new MyOp(OpCodes.Conv_Ovf_I8_Un);
|
|
public static readonly MyOp Conv_Ovf_U1_Un = new MyOp(OpCodes.Conv_Ovf_U1_Un);
|
|
public static readonly MyOp Conv_Ovf_U2_Un = new MyOp(OpCodes.Conv_Ovf_U2_Un);
|
|
public static readonly MyOp Conv_Ovf_U4_Un = new MyOp(OpCodes.Conv_Ovf_U4_Un);
|
|
public static readonly MyOp Conv_Ovf_U8_Un = new MyOp(OpCodes.Conv_Ovf_U8_Un);
|
|
public static readonly MyOp Conv_Ovf_I_Un = new MyOp(OpCodes.Conv_Ovf_I_Un);
|
|
public static readonly MyOp Conv_Ovf_U_Un = new MyOp(OpCodes.Conv_Ovf_U_Un);
|
|
public static readonly MyOp Box = new MyOp(OpCodes.Box);
|
|
public static readonly MyOp Newarr = new MyOp(OpCodes.Newarr);
|
|
public static readonly MyOp Ldlen = new MyOp(OpCodes.Ldlen);
|
|
public static readonly MyOp Ldelema = new MyOp(OpCodes.Ldelema);
|
|
public static readonly MyOp Ldelem_I1 = new MyOp(OpCodes.Ldelem_I1);
|
|
public static readonly MyOp Ldelem_U1 = new MyOp(OpCodes.Ldelem_U1);
|
|
public static readonly MyOp Ldelem_I2 = new MyOp(OpCodes.Ldelem_I2);
|
|
public static readonly MyOp Ldelem_U2 = new MyOp(OpCodes.Ldelem_U2);
|
|
public static readonly MyOp Ldelem_I4 = new MyOp(OpCodes.Ldelem_I4);
|
|
public static readonly MyOp Ldelem_U4 = new MyOp(OpCodes.Ldelem_U4);
|
|
public static readonly MyOp Ldelem_I8 = new MyOp(OpCodes.Ldelem_I8);
|
|
public static readonly MyOp Ldelem_I = new MyOp(OpCodes.Ldelem_I);
|
|
public static readonly MyOp Ldelem_R4 = new MyOp(OpCodes.Ldelem_R4);
|
|
public static readonly MyOp Ldelem_R8 = new MyOp(OpCodes.Ldelem_R8);
|
|
public static readonly MyOp Ldelem_Ref = new MyOp(OpCodes.Ldelem_Ref);
|
|
public static readonly MyOp Stelem_I = new MyOp(OpCodes.Stelem_I);
|
|
public static readonly MyOp Stelem_I1 = new MyOp(OpCodes.Stelem_I1);
|
|
public static readonly MyOp Stelem_I2 = new MyOp(OpCodes.Stelem_I2);
|
|
public static readonly MyOp Stelem_I4 = new MyOp(OpCodes.Stelem_I4);
|
|
public static readonly MyOp Stelem_I8 = new MyOp(OpCodes.Stelem_I8);
|
|
public static readonly MyOp Stelem_R4 = new MyOp(OpCodes.Stelem_R4);
|
|
public static readonly MyOp Stelem_R8 = new MyOp(OpCodes.Stelem_R8);
|
|
public static readonly MyOp Stelem_Ref = new MyOp(OpCodes.Stelem_Ref);
|
|
public static readonly MyOp Ldelem = new MyOp(OpCodes.Ldelem);
|
|
public static readonly MyOp Stelem = new MyOp(OpCodes.Stelem);
|
|
public static readonly MyOp Unbox_Any = new MyOp(OpCodes.Unbox_Any);
|
|
public static readonly MyOp Conv_Ovf_I1 = new MyOp(OpCodes.Conv_Ovf_I1);
|
|
public static readonly MyOp Conv_Ovf_U1 = new MyOp(OpCodes.Conv_Ovf_U1);
|
|
public static readonly MyOp Conv_Ovf_I2 = new MyOp(OpCodes.Conv_Ovf_I2);
|
|
public static readonly MyOp Conv_Ovf_U2 = new MyOp(OpCodes.Conv_Ovf_U2);
|
|
public static readonly MyOp Conv_Ovf_I4 = new MyOp(OpCodes.Conv_Ovf_I4);
|
|
public static readonly MyOp Conv_Ovf_U4 = new MyOp(OpCodes.Conv_Ovf_U4);
|
|
public static readonly MyOp Conv_Ovf_I8 = new MyOp(OpCodes.Conv_Ovf_I8);
|
|
public static readonly MyOp Conv_Ovf_U8 = new MyOp(OpCodes.Conv_Ovf_U8);
|
|
public static readonly MyOp Refanyval = new MyOp(OpCodes.Refanyval);
|
|
public static readonly MyOp Ckfinite = new MyOp(OpCodes.Ckfinite);
|
|
public static readonly MyOp Mkrefany = new MyOp(OpCodes.Mkrefany);
|
|
public static readonly MyOp Ldtoken = new MyOp(OpCodes.Ldtoken);
|
|
public static readonly MyOp Conv_U2 = new MyOp(OpCodes.Conv_U2);
|
|
public static readonly MyOp Conv_U1 = new MyOp(OpCodes.Conv_U1);
|
|
public static readonly MyOp Conv_I = new MyOp(OpCodes.Conv_I);
|
|
public static readonly MyOp Conv_Ovf_I = new MyOp(OpCodes.Conv_Ovf_I);
|
|
public static readonly MyOp Conv_Ovf_U = new MyOp(OpCodes.Conv_Ovf_U);
|
|
public static readonly MyOp Add_Ovf = new MyOp(OpCodes.Add_Ovf);
|
|
public static readonly MyOp Add_Ovf_Un = new MyOp(OpCodes.Add_Ovf_Un);
|
|
public static readonly MyOp Mul_Ovf = new MyOp(OpCodes.Mul_Ovf);
|
|
public static readonly MyOp Mul_Ovf_Un = new MyOp(OpCodes.Mul_Ovf_Un);
|
|
public static readonly MyOp Sub_Ovf = new MyOp(OpCodes.Sub_Ovf);
|
|
public static readonly MyOp Sub_Ovf_Un = new MyOp(OpCodes.Sub_Ovf_Un);
|
|
public static readonly MyOp Endfinally = new MyOp(OpCodes.Endfinally);
|
|
public static readonly MyOp Leave = new MyOp(OpCodes.Leave);
|
|
public static readonly MyOp Leave_S = new MyOp(OpCodes.Leave_S);
|
|
public static readonly MyOp Stind_I = new MyOp(OpCodes.Stind_I);
|
|
public static readonly MyOp Conv_U = new MyOp(OpCodes.Conv_U);
|
|
public static readonly MyOp Prefix7 = new MyOp(OpCodes.Prefix7);
|
|
public static readonly MyOp Prefix6 = new MyOp(OpCodes.Prefix6);
|
|
public static readonly MyOp Prefix5 = new MyOp(OpCodes.Prefix5);
|
|
public static readonly MyOp Prefix4 = new MyOp(OpCodes.Prefix4);
|
|
public static readonly MyOp Prefix3 = new MyOp(OpCodes.Prefix3);
|
|
public static readonly MyOp Prefix2 = new MyOp(OpCodes.Prefix2);
|
|
public static readonly MyOp Prefix1 = new MyOp(OpCodes.Prefix1);
|
|
public static readonly MyOp Prefixref = new MyOp(OpCodes.Prefixref);
|
|
public static readonly MyOp Arglist = new MyOp(OpCodes.Arglist);
|
|
public static readonly MyOp Ceq = new MyOp(OpCodes.Ceq, "==");
|
|
public static readonly MyOp Cgt = new MyOp(OpCodes.Cgt, ">");
|
|
public static readonly MyOp Cgt_Un = new MyOp(OpCodes.Cgt_Un);
|
|
public static readonly MyOp Clt = new MyOp(OpCodes.Clt, "<");
|
|
public static readonly MyOp Clt_Un = new MyOp(OpCodes.Clt_Un);
|
|
public static readonly MyOp Ldftn = new MyOp(OpCodes.Ldftn);
|
|
public static readonly MyOp Ldvirtftn = new MyOp(OpCodes.Ldvirtftn);
|
|
public static readonly MyOp Ldarg = new MyOp(OpCodes.Ldarg);
|
|
public static readonly MyOp Ldarga = new MyOp(OpCodes.Ldarga);
|
|
public static readonly MyOp Starg = new MyOp(OpCodes.Starg);
|
|
public static readonly MyOp Ldloc = new MyOp(OpCodes.Ldloc);
|
|
public static readonly MyOp Ldloca = new MyOp(OpCodes.Ldloca);
|
|
public static readonly MyOp Stloc = new MyOp(OpCodes.Stloc);
|
|
public static readonly MyOp Localloc = new MyOp(OpCodes.Localloc);
|
|
public static readonly MyOp Endfilter = new MyOp(OpCodes.Endfilter);
|
|
public static readonly MyOp Unaligned = new MyOp(OpCodes.Unaligned);
|
|
public static readonly MyOp Volatile = new MyOp(OpCodes.Volatile);
|
|
public static readonly MyOp Tailcall = new MyOp(OpCodes.Tailcall);
|
|
public static readonly MyOp Initobj = new MyOp(OpCodes.Initobj);
|
|
public static readonly MyOp Constrained = new MyOp(OpCodes.Constrained);
|
|
public static readonly MyOp Cpblk = new MyOp(OpCodes.Cpblk);
|
|
public static readonly MyOp Initblk = new MyOp(OpCodes.Initblk);
|
|
public static readonly MyOp Rethrow = new MyOp(OpCodes.Rethrow);
|
|
public static readonly MyOp Sizeof = new MyOp(OpCodes.Sizeof);
|
|
public static readonly MyOp Refanytype = new MyOp(OpCodes.Refanytype);
|
|
public static readonly MyOp Readonly = new MyOp(OpCodes.Readonly);
|
|
|
|
// used internally
|
|
public static readonly MyOp Cge = new MyOp("cge", ">=");
|
|
public static readonly MyOp Cle = new MyOp("cle", "<=");
|
|
public static readonly MyOp Cne = new MyOp("cne", "!=");
|
|
}
|
|
}
|
|
}
|