/// <summary>
/// Write human readable output.
/// </summary>
public override void WriteTo(ITextOutput output)
{
output.Write("BasicBlock{");
output.WriteLine();
output.Indent();
foreach (var child in GetChildren())
{
child.WriteTo(output);
output.WriteLine();
}
output.Unindent();
output.Write("}");
output.WriteLine();
}
public override void WriteTo(ITextOutput output)
{
output.WriteLine("");
output.Write("loop (");
if (this.Condition != null)
{
this.Condition.WriteTo(output);
}
output.WriteLine(") {");
output.Indent();
this.BodyBlock.WriteTo(output);
output.Unindent();
output.WriteLine("}");
}
static void WriteMethod(MethodDefinition def, ITextOutput output)
{
if (def.IsConstructor && def.IsStatic)
{
return;
}
if (def.DeclaringType != null && def.DeclaringType.IsInterface)
{
return;
}
var info = InfoUtil.Info(def);
if (def.IsConstructor)
{
output.Write(def.DeclaringType.Name + "::" + def.DeclaringType.Name);
}
else
{
output.Write(info.ReturnTypeName);
output.Write(" ");
output.Write(def.DeclaringType.Name + "::" + info.Name);
}
output.Write("(");
WriteParameters(def, output, false);
output.Write(")");
if (def.IsGetter)
{
output.Write(" const");
}
output.WriteLine();
output.WriteLine("{");
if (!def.IsConstructor)
{
output.Indent();
if (def.ReturnType.MetadataType != MetadataType.Void)
{
output.Write("return ");
}
output.Write("d_ptr->");
output.Write(info.Name);
output.Write("(");
WriteParameterNames(def, output);
output.WriteLine(");");
output.Unindent();
}
output.WriteLine("}");
}
public override void WriteTo(ITextOutput output)
{
output.Write("catch ");
output.WriteReference(ExceptionType.FullName, ExceptionType);
if (ExceptionVariable != null)
{
output.Write(' ');
output.Write(ExceptionVariable.Name);
}
output.WriteLine(" {");
output.Indent();
base.WriteTo(output);
output.Unindent();
output.WriteLine("}");
}
static void WriteFieldMethodBody(FieldDefinition def, ITextOutput output, bool isRead)
{
if (!isRead)
{
output.WriteLine("{");
output.WriteLine("}");
}
else
{
output.WriteLine("{");
output.Indent();
string value = Util.GetDefaultValue(def.FieldType);
output.WriteLine("return " + value + ";");
output.Unindent();
output.WriteLine("}");
}
}
public List <int> Values; // null for the default case
public override void WriteTo(ITextOutput output)
{
if (this.Values != null)
{
foreach (int i in this.Values)
{
output.WriteLine("case {0}:", i);
}
}
else
{
output.WriteLine("default:");
}
output.Indent();
base.WriteTo(output);
output.Unindent();
}
public override void WriteTo(ITextOutput output)
{
output.Write("fixed (");
for (int i = 0; i < this.Initializers.Count; i++)
{
if (i > 0)
{
output.Write(", ");
}
this.Initializers[i].WriteTo(output);
}
output.WriteLine(") {");
output.Indent();
this.BodyBlock.WriteTo(output);
output.Unindent();
output.WriteLine("}");
}
/// <summary>
/// Write human readable output.
/// </summary>
public override void WriteTo(ITextOutput output, FormattingOptions format)
{
if (Values != null)
{
foreach (var i in Values)
{
output.WriteLine("case {0}:", i);
}
}
else
{
output.WriteLine("default:");
}
output.Indent();
base.WriteTo(output, format);
output.Unindent();
}
static void WriteFields(TypeDefinition def, ITextOutput output)
{
if (def.Fields.Count() > 0)
{
output.WriteLine("public:");
output.Indent();
foreach (var f in def.Fields)
{
var info = InfoUtil.Info(f);
output.Write(info.FieldTypeName);
output.Write(" ");
output.Write(f.Name);
output.WriteLine(";");
}
output.Unindent();
output.WriteLine();
}
}
public override void WriteTo(ITextOutput output, ILAstWritingOptions options)
{
WriteILRange(output, options);
output.Write("using");
if (IsAsync)
{
output.Write(".async");
}
output.Write(" (");
Variable.WriteTo(output);
output.Write(" = ");
ResourceExpression.WriteTo(output, options);
output.WriteLine(") {");
output.Indent();
Body.WriteTo(output, options);
output.Unindent();
output.WriteLine();
output.Write("}");
}
public static bool WriteNodes <T>(this IList <T> nodes, ITextOutput output, int start, int count, bool endingSemiColon, bool withBrackets) where T : ILNode
{
// Generic method to print a list of nodes
if (nodes.Count == 0 || count == 0)
{
return(false);
}
else if ((nodes.Count - start) == 1 || count == 1)
{
nodes[start].WriteTo(output);
if (endingSemiColon)
{
output.Write(';');
}
return(false);
}
else
{
if (withBrackets)
{
output.Write('{');
}
output.WriteLine();
output.Indent();
for (; start < count; start++)
{
ILNode n = nodes[start];
n.WriteTo(output);
if (endingSemiColon && n is ILExpression)
{
output.Write(';');
}
output.WriteLine();
}
output.Unindent();
if (withBrackets)
{
output.Write('}');
}
return(true); // we did a writeline, atleast one
}
}
public override void WriteTo(ITextOutput output, ILAstWritingOptions options)
{
output.Write("switch (");
value.WriteTo(output, options);
output.Write(") ");
output.MarkFoldStart("{...}");
output.WriteLine("{");
output.Indent();
output.Write("default: ");
defaultBody.WriteTo(output, options);
output.WriteLine();
foreach (var section in this.Sections)
{
section.WriteTo(output, options);
output.WriteLine();
}
output.Unindent();
output.Write('}');
output.MarkFoldEnd();
}
public static void WriteEventTypeInclude(TypeDefinition def, ITextOutput output)
{
output.WriteLine("class QUANTKIT_EXPORT EventType");
output.WriteLine("{");
output.WriteLine("public:");
output.Indent();
if (eventList == null)
{
BuildEventTypeTable(def.Module);
}
foreach (var f in Helper.eventList)
{
output.Write("static const unsigned char ");
output.Write(f.Name);
output.Write(" = ");
output.Write(f.Constant.ToString());
output.WriteLine(";");
}
output.Unindent();
output.WriteLine("};");
}
public List <int> Values; // null for the default case
public override void WriteTo(ITextOutput output, MemberMapping memberMapping)
{
if (this.Values != null)
{
foreach (int i in this.Values)
{
output.Write("case", TextTokenKind.Keyword);
output.WriteSpace();
output.Write(string.Format("{0}", i), TextTokenKind.Number);
output.WriteLine(":", TextTokenKind.Operator);
}
}
else
{
output.Write("default", TextTokenKind.Keyword);
output.WriteLine(":", TextTokenKind.Operator);
}
output.Indent();
base.WriteTo(output, memberMapping);
output.Unindent();
}
public override void WriteTo(ITextOutput output, ILAstWritingOptions options)
{
WriteILRange(output, options);
output.Write("Block ");
output.WriteLocalReference(Label, this, isDefinition: true);
if (Kind != BlockKind.ControlFlow)
{
output.Write($" ({Kind})");
}
if (Parent is BlockContainer)
{
output.Write(" (incoming: {0})", IncomingEdgeCount);
}
output.Write(' ');
output.MarkFoldStart("{...}");
output.WriteLine("{");
output.Indent();
int index = 0;
foreach (var inst in Instructions)
{
if (options.ShowChildIndexInBlock)
{
output.Write("[" + index + "] ");
index++;
}
inst.WriteTo(output, options);
output.WriteLine();
}
if (finalInstruction.OpCode != OpCode.Nop)
{
output.Write("final: ");
finalInstruction.WriteTo(output, options);
output.WriteLine();
}
output.Unindent();
output.Write("}");
output.MarkFoldEnd();
}
public override void WriteTo(ITextOutput output, ILAstWritingOptions options)
{
WriteILRange(output, options);
output.Write("switch");
if (IsLifted)
{
output.Write(".lifted");
}
output.Write(" (");
value.WriteTo(output, options);
output.Write(") ");
output.MarkFoldStart("{...}");
output.WriteLine("{");
output.Indent();
foreach (var section in this.Sections)
{
section.WriteTo(output, options);
output.WriteLine();
}
output.Unindent();
output.Write('}');
output.MarkFoldEnd();
}
private void PrintMethod(CompiledMethod cmethod, ITextOutput output, DecompilationOptions options)
{
if ((cmethod != null) && (cmethod.RLBody != null))
{
var body = cmethod.RLBody;
var basicBlocks = BasicBlock.Find(body);
foreach (var block in basicBlocks)
{
output.Write(string.Format("D_{0:X4}:", block.Entry.Index));
output.WriteLine();
output.Indent();
foreach (var ins in block.Instructions)
{
if (ShowHasSeqPoint)
{
if (ins.SequencePoint != null)
output.Write(ins.SequencePoint.IsSpecial ? "!" : "~");
}
output.Write(ins.ToString());
output.WriteLine();
}
output.Unindent();
}
if (body.Exceptions.Any())
{
output.WriteLine();
output.Write("Exception handlers:");
output.WriteLine();
output.Indent();
foreach (var handler in body.Exceptions)
{
output.Write(string.Format("{0:x4}-{1:x4}", handler.TryStart.Index, handler.TryEnd.Index));
output.WriteLine();
output.Indent();
foreach (var c in handler.Catches)
{
output.Write(string.Format("{0} => {1:x4}", c.Type, c.Instruction.Index));
output.WriteLine();
}
if (handler.CatchAll != null)
{
output.Write(string.Format("{0} => {1:x4}", "<any>", handler.CatchAll.Index));
output.WriteLine();
}
output.Unindent();
}
output.Unindent();
}
}
else
{
output.Write("Method not found in dex");
output.WriteLine();
}
}
void DisassembleMethodInternal(MethodDefinition method)
{
// .method public hidebysig specialname
// instance default class [mscorlib]System.IO.TextWriter get_BaseWriter () cil managed
//
//emit flags
WriteEnum(method.Attributes & MethodAttributes.MemberAccessMask, methodVisibility);
WriteFlags(method.Attributes & ~MethodAttributes.MemberAccessMask, methodAttributeFlags);
output.WriteLine();
output.Indent();
if (method.HasThis)
{
output.Write("instance ");
}
//call convention
WriteEnum(method.CallingConvention & (MethodCallingConvention)0x1f, callingConvention);
//return type
method.ReturnType.WriteTo(output);
output.Write(' ');
output.Write(DisassemblerHelpers.Escape(method.Name));
WriteTypeParameters(output, method);
//( params )
output.Write(" (");
if (method.HasParameters)
{
output.WriteLine();
output.Indent();
WriteParameters(method.Parameters);
output.Unindent();
}
output.Write(") ");
//cil managed
WriteEnum(method.ImplAttributes & MethodImplAttributes.CodeTypeMask, methodCodeType);
if ((method.ImplAttributes & MethodImplAttributes.ManagedMask) == MethodImplAttributes.Managed)
{
output.Write("managed ");
}
else
{
output.Write("unmanaged ");
}
WriteFlags(method.ImplAttributes & ~(MethodImplAttributes.CodeTypeMask | MethodImplAttributes.ManagedMask), methodImpl);
output.Unindent();
if (method.HasBody || method.HasCustomAttributes)
{
OpenBlock(defaultCollapsed: isInType);
WriteAttributes(method.CustomAttributes);
if (method.HasBody)
{
// create IL code mappings - used in debugger
MemberMapping methodMapping = method.CreateCodeMapping(this.CodeMappings);
methodBodyDisassembler.Disassemble(method.Body, methodMapping);
}
CloseBlock("End of method " + method.DeclaringType.Name + "." + method.Name);
}
else
{
output.WriteLine();
}
}
public override void WriteTo(ITextOutput output, ILAstWritingOptions options)
{
WriteILRange(output, options);
output.Write(OpCode);
if (Method != null)
{
output.Write(' ');
Method.WriteTo(output);
}
if (IsExpressionTree)
{
output.Write(".ET");
}
if (DelegateType != null)
{
output.Write("[");
DelegateType.WriteTo(output);
output.Write("]");
}
output.WriteLine(" {");
output.Indent();
if (IsAsync)
{
output.WriteLine(".async");
}
if (IsIterator)
{
output.WriteLine(".iterator");
}
output.MarkFoldStart(Variables.Count + " variable(s)", true);
foreach (var variable in Variables)
{
variable.WriteDefinitionTo(output);
output.WriteLine();
}
output.MarkFoldEnd();
output.WriteLine();
foreach (string warning in Warnings)
{
output.WriteLine("//" + warning);
}
body.WriteTo(output, options);
output.WriteLine();
if (options.ShowILRanges)
{
var unusedILRanges = FindUnusedILRanges();
if (!unusedILRanges.IsEmpty)
{
output.Write("// Unused IL Ranges: ");
output.Write(string.Join(", ", unusedILRanges.Intervals.Select(
range => $"[{range.Start:x4}..{range.InclusiveEnd:x4}]")));
output.WriteLine();
}
}
output.Unindent();
output.WriteLine("}");
}
public void Disassemble(MethodBody body, MemberMapping methodMapping)
{
// start writing IL code
MethodDefinition method = body.Method;
output.WriteLine("// Method begins at RVA 0x{0:x4}", method.RVA);
output.WriteLine("// Code size {0} (0x{0:x})", body.CodeSize);
output.WriteLine(".maxstack {0}", body.MaxStackSize);
if (method.DeclaringType.Module.Assembly.EntryPoint == method)
{
output.WriteLine(".entrypoint");
}
if (method.Body.HasVariables)
{
output.Write(".locals ");
if (method.Body.InitLocals)
{
output.Write("init ");
}
output.WriteLine("(");
output.Indent();
foreach (var v in method.Body.Variables)
{
output.WriteDefinition("[" + v.Index + "] ", v);
v.VariableType.WriteTo(output);
if (!string.IsNullOrEmpty(v.Name))
{
output.Write(' ');
output.Write(DisassemblerHelpers.Escape(v.Name));
}
if (v.Index + 1 < method.Body.Variables.Count)
{
output.Write(',');
}
output.WriteLine();
}
output.Unindent();
output.WriteLine(")");
}
output.WriteLine();
if (detectControlStructure && body.Instructions.Count > 0)
{
Instruction inst = body.Instructions[0];
HashSet <int> branchTargets = GetBranchTargets(body.Instructions);
WriteStructureBody(new ILStructure(body), branchTargets, ref inst, methodMapping, method.Body.CodeSize);
}
else
{
foreach (var inst in method.Body.Instructions)
{
inst.WriteTo(output);
if (methodMapping != null)
{
// add IL code mappings - used in debugger
methodMapping.MemberCodeMappings.Add(
new SourceCodeMapping()
{
SourceCodeLine = output.CurrentLine,
ILInstructionOffset = new ILRange {
From = inst.Offset, To = inst.Next == null ? method.Body.CodeSize : inst.Next.Offset
},
MemberMapping = methodMapping
});
}
output.WriteLine();
}
if (method.Body.HasExceptionHandlers)
{
output.WriteLine();
foreach (var eh in method.Body.ExceptionHandlers)
{
eh.WriteTo(output);
output.WriteLine();
}
}
}
}
public static void WriteClass(TypeDefinition def, ITextOutput output)
{
if (def.IsInterface || Helper.isClassAsEnum(def))
{
return;
}
output.WriteLine("#include <QuantKit/" + def.Name + ".h>");
output.WriteLine();
WriteIncludeBody(def, output);
var info = InfoUtil.Info(def);
bool isFinalClass = info != null && !info.HasDerivedClass;
if (!CppLanguage.IsNeedWriteHxx(def))
{
if (info.BaseTypeInModule != null)
{
output.WriteLine("#include \"" + info.BaseTypeInModule.Name + CppLanguage.HxxFileExtension + "\"");
}
var tevent = Util.GetTypeDefinition(def.Module, "Event");
if (tevent == def || Util.isInhertFrom(def, tevent))
{
if (!CppLanguage.IsNeedWriteHxx(def))
{
output.WriteLine("#include <QuantKit/EventType.h>");
}
}
Hxx.WriteClassBody(def, output);
}
else
{
output.WriteLine("#include \"" + def.Name + CppLanguage.HxxFileExtension + "\"");
}
//output.WriteLine("#include <QuantKit/" + def.Name + CppLanguage.HxxFileExtension + ">");
//output.WriteLine();
//WriteIncludeBody(def, output);
output.WriteLine();
output.WriteLine("using namespace QuantKit;");
//output.WriteLine("using namespace QuantKit::Internal;");
output.WriteLine();
//WriteNamespaceStart(def.Namespace, output);
//output.WriteLine("namespace Internal {");
//output.WriteLine();
Cxx.WritePrivateClassBody(def, output);
//output.WriteLine("} // namespace Internal");
output.WriteLine();
output.WriteLine("// Pubic API ");
output.WriteLine();
WriteProxyClassBody(def, output);
if (!def.IsInterface && !Helper.isClassAsEnum(def))
{
output.WriteLine();
output.WriteLine("QDataStream& " + def.Name + "::operator<<(QDataStream &stream, const " + def.Name + " &" + def.Name.ToLower() + ")");
output.WriteLine("{");
output.Indent();
output.WriteLine("return stream << " + def.Name.ToLower() + ".toString();");
output.Unindent();
output.WriteLine("}");
}
output.WriteLine();
//WriteNamespaceEnd(def.Namespace, output);
}
void EndKeywordBlock(ITextOutput output)
{
output.Unindent();
output.WriteRightBrace();
output.WriteLine();
}
public override void Unindent()
{
output.Unindent();
}
public override void WriteTo(ITextOutput output)
{
if (Code.isExpression())
{
WriteExpression(output);
}
else
{
switch (Code)
{
case GMCode.Constant: // primitive c# type
WriteOperand(output);
break;
case GMCode.Var: // should be ILVariable
if (Arguments.Count > 0)
{
WriteArgument(output, 0, false);
}
else
{
output.Write("stack");
}
output.Write(".");
WriteOperand(output, false); // generic, string name
if (Arguments.Count > 1) // its an array
{
output.Write('[');
WriteArgument(output, 1, false);
output.Write(']');
}
break;
case GMCode.Call:
output.Write(Operand.ToString());
WriteCommaArguments(output);
break;
case GMCode.Pop:
if (Operand == null)
{
output.Write(POPDefaultString);
}
else
{
output.Write("Pop(");
WriteOperand(output, false); // generic, string name
output.Write(" = ");
output.Write(POPDefaultString);
output.Write(")");
}
break;
case GMCode.Assign:
WriteArgumentOrPop(output, 0, false);
output.Write(" = ");
WriteArgumentOrPop(output, 1, true);
break;
case GMCode.Popz:
output.Write("Popz");
break;
case GMCode.Push:
output.Write("Push ");
if (Operand != null)
{
output.Write("(Operand=");
WriteOperand(output, true);
output.Write(")");
}
if (Arguments.Count > 0)
{
output.Write("(Arguments=");
WriteArgumentOrPop(output, 0);
output.Write(")");
}
break;
case GMCode.Dup:
output.Write("Dup ");
output.Write(Operand.ToString());
break;
case GMCode.B: // this is where the magic happens...woooooooooo
output.Write("goto ");
WriteOperand(output);
break;
case GMCode.Bf:
if (Arguments.Count > 0)
{
output.Write("Push(");
Arguments[0].WriteTo(output);
output.Write(")");
}
output.Write("Branch IfFalse ");
WriteOperand(output);
break;
case GMCode.Bt:
if (Arguments.Count > 0)
{
output.Write("Push(");
Arguments[0].WriteTo(output);
output.Write(")");
}
output.Write("BranchIfTrue ");
WriteOperand(output);
break;
case GMCode.Pushenv:
output.Write("PushEnviroment(");
WriteArgumentOrPop(output, 0, false);
output.Write(") : ");
WriteOperand(output, false);
break;
case GMCode.Popenv:
output.Write("PopEnviroment ");
WriteOperand(output);
break;
case GMCode.Exit: // exit without
output.Write("return; // exit");
return;
case GMCode.Ret:
output.Write("return ");
WriteArgumentOrPop(output, 0);
break;
case GMCode.LoopOrSwitchBreak:
output.Write("break");
break;
case GMCode.LoopContinue:
output.Write("continue");
break;
case GMCode.DefaultCase:
output.Write("default: goto ");
WriteOperand(output);
break;
case GMCode.Case:
output.Write("case ");
WriteArgumentOrPop(output, 0);
output.Write(": goto ");
WriteOperand(output);
break;
case GMCode.Switch: // debug print of the created switch statement
output.Write("switch(");
WriteArgument(output, 0);
output.Write(") {");
output.WriteLine();
output.Indent();
for (int i = 1; i < Arguments.Count; i++)
{
WriteArgument(output, i);
output.Write(';');
output.WriteLine();
}
output.Unindent();
output.Write("}");
output.WriteLine();
break;
default:
throw new Exception("Not Implmented! ugh");
}
}
}
public void Disassemble(MethodDef method, MemberMapping debugSymbols)
{
// start writing IL code
CilBody body = method.Body;
uint codeSize = (uint)body.GetCodeSize();
uint rva = (uint)method.RVA;
long offset = method.Module.ToFileOffset(rva);
if (options.ShowTokenAndRvaComments)
{
output.WriteLine(string.Format("// Header Size: {0} {1}", method.Body.HeaderSize, method.Body.HeaderSize == 1 ? "byte" : "bytes"), TextTokenType.Comment);
output.WriteLine(string.Format("// Code Size: {0} (0x{0:X}) {1}", codeSize, codeSize == 1 ? "byte" : "bytes"), TextTokenType.Comment);
if (body.LocalVarSigTok != 0)
{
output.WriteLine(string.Format("// LocalVarSig Token: 0x{0:X8} RID: {1}", body.LocalVarSigTok, body.LocalVarSigTok & 0xFFFFFF), TextTokenType.Comment);
}
}
output.Write(".maxstack", TextTokenType.ILDirective);
output.WriteSpace();
output.WriteLine(string.Format("{0}", body.MaxStack), TextTokenType.Number);
if (method.DeclaringType.Module.EntryPoint == method)
{
output.WriteLine(".entrypoint", TextTokenType.ILDirective);
}
if (method.Body.HasVariables)
{
output.Write(".locals", TextTokenType.ILDirective);
output.WriteSpace();
if (method.Body.InitLocals)
{
output.Write("init", TextTokenType.Keyword);
output.WriteSpace();
}
output.WriteLine("(", TextTokenType.Operator);
output.Indent();
foreach (var v in method.Body.Variables)
{
output.Write('[', TextTokenType.Operator);
output.WriteDefinition(v.Index.ToString(), v, TextTokenType.Number);
output.Write(']', TextTokenType.Operator);
output.WriteSpace();
v.Type.WriteTo(output);
if (!string.IsNullOrEmpty(v.Name))
{
output.WriteSpace();
output.Write(DisassemblerHelpers.Escape(v.Name), TextTokenType.Local);
}
if (v.Index + 1 < method.Body.Variables.Count)
{
output.Write(',', TextTokenType.Operator);
}
output.WriteLine();
}
output.Unindent();
output.WriteLine(")", TextTokenType.Operator);
}
output.WriteLine();
uint baseRva = rva == 0 ? 0 : rva + method.Body.HeaderSize;
long baseOffs = baseRva == 0 ? 0 : method.Module.ToFileOffset(baseRva);
using (var byteReader = !options.ShowILBytes || options.CreateInstructionBytesReader == null ? null : options.CreateInstructionBytesReader(method)) {
if (detectControlStructure && body.Instructions.Count > 0)
{
int index = 0;
HashSet <uint> branchTargets = GetBranchTargets(body.Instructions);
WriteStructureBody(body, new ILStructure(body), branchTargets, ref index, debugSymbols, method.Body.GetCodeSize(), baseRva, baseOffs, byteReader, method);
}
else
{
var instructions = method.Body.Instructions;
for (int i = 0; i < instructions.Count; i++)
{
var inst = instructions[i];
var startLocation = output.Location;
inst.WriteTo(output, options, baseRva, baseOffs, byteReader, method);
if (debugSymbols != null)
{
// add IL code mappings - used in debugger
var next = i + 1 < instructions.Count ? instructions[i + 1] : null;
debugSymbols.MemberCodeMappings.Add(
new SourceCodeMapping()
{
StartLocation = output.Location,
EndLocation = output.Location,
ILInstructionOffset = new ILRange(inst.Offset, next == null ? (uint)method.Body.GetCodeSize() : next.Offset),
MemberMapping = debugSymbols
});
}
output.WriteLine();
}
if (method.Body.HasExceptionHandlers)
{
output.WriteLine();
foreach (var eh in method.Body.ExceptionHandlers)
{
eh.WriteTo(output, method);
output.WriteLine();
}
}
}
}
}
public static void ShowUnResolvedFieldAndMethod(ModuleDefinition module, ITextOutput output)
{
Dictionary <TypeDefinition, Tuple <List <FieldDefinition>, List <MethodDefinition> > > rdict = new Dictionary <TypeDefinition, Tuple <List <FieldDefinition>, List <MethodDefinition> > >();
foreach (var t in module.Types)
{
if (t.IsEnum)
{
continue;
}
if (t.Namespace != "SmartQuant")
{
continue;
}
if (t.Name == "CurrencyId" || t.Name == "EventType" || t.Name == "DataObjectType" || t.Name == "AccountDataField")
{
continue;
}
List <FieldDefinition> flist = new List <FieldDefinition>();
List <MethodDefinition> mlist = new List <MethodDefinition>();
foreach (var f in t.Fields)
{
var modifiers = Util.ConvertModifiers(f);
if (modifiers.HasFlag(Modifiers.Const))
{
continue;
}
if (!f.Name.StartsWith("m_"))
{
flist.Add(f);
//output.WriteLine("fieldRenameList.Add(Tuple.Create(\"" + t.Name + "\", \"" + f.Name + "\", \"" + f.Name + "\"));");
}
}
foreach (var m in t.Methods)
{
if (m.Name.StartsWith("method_") || m.Name.StartsWith("vmethod_"))
{
mlist.Add(m);
//output.WriteLine("methodRenameList.Add(Tuple.Create(\"" + t.Name + "\", \"" + m.Name + "\", \"" + m.Name + "\"));");
}
}
if (flist.Count() > 0 || mlist.Count() > 0)
{
rdict.Add(t, Tuple.Create(flist, mlist));
}
}
foreach (var t in rdict)
{
output.WriteLine("{ \"" + t.Key.FullName + "\", Tuple.Create( new Dictionary<string, string>(){");
output.Indent();
output.Indent();
output.WriteLine("// field ");
foreach (var f in t.Value.Item1)
{
output.WriteLine("{\"" + f.Name + "\",\"" + f.Name + "\"},");
}
output.Unindent();
output.WriteLine("},new Dictionary<string,string>(){");
output.Indent();
output.WriteLine("// method ");
foreach (var m in t.Value.Item2)
{
output.WriteLine("{\"" + m.Name + "\",\"" + m.Name + "\"},");
}
output.WriteLine("})");
output.Unindent();
output.Unindent();
output.WriteLine("},");
}
}
public void Unindent()
{
output.Unindent();
}
public static void WriteCurrencyIdCode(TypeDefinition def, ITextOutput output)
{
output.WriteLine("#include <QuantKit/CurrencyId.h>");
output.WriteLine();
output.WriteLine("#include <boost/multi_index_container.hpp>");
output.WriteLine("#include <boost/multi_index/hashed_index.hpp>");
output.WriteLine("#include <boost/multi_index/ordered_index.hpp>");
output.WriteLine("#include <boost/multi_index/member.hpp>");
output.WriteLine("#include <boost/multi_index/tag.hpp>");
output.WriteLine();
output.WriteLine("#include \"qt_boost.h\"");
output.WriteLine();
output.WriteLine("namepsace QuantKit {");
output.WriteLine();
output.WriteLine("class CurrencyItem {");
output.WriteLine("public:");
output.Indent();
output.WriteLine("QString name;");
output.WriteLine("unsigned char code;");
output.WriteLine("CurrencyItem(const QString& currency, unsigned char id) : name(currency), code(id) {}");
output.Unindent();
output.Write("};");
output.WriteLine();
output.WriteLine("struct by_name{};");
output.WriteLine("struct by_code{};");
output.WriteLine();
output.WriteLine("typedef boost::multi_index::multi_index_container<\n CurrencyItem,\n boost::multi_index::indexed_by<\n boost::multi_index::hashed_unique<\n boost::multi_index::tag<by_name>,\n boost::multi_index::member<\n CurrencyItem, QString, &CurrencyItem::name\n >\n >,\n boost::multi_index::hashed_unique<\n boost::multi_index::tag<by_code>,\n boost::multi_index::member<\n CurrencyItem, unsigned char, &CurrencyItem::code\n >\n >\n >\n> CurrencyIdContainer;");
output.WriteLine("\ntypedef CurrencyIdContainer::index<by_name>::type CurrencyId_by_name;\ntypedef CurrencyIdContainer::index<by_code>::type CurrencyId_by_code;\n");
output.WriteLine("static CurrencyIdContainer currencyIds = {");
output.Indent();
List <FieldDefinition> constList = new List <FieldDefinition>();
foreach (var f in def.Fields)
{
var modifiers = Util.ConvertModifiers(f);
if (modifiers.HasFlag(Modifiers.Const) && f.Constant != null)
{
constList.Add(f);
}
}
for (int i = 0; i < constList.Count(); ++i)
{
var f = constList[i];
output.Write("{\"");
output.Write(f.Name);
output.Write("\", ");
output.Write(f.Constant.ToString());
if (i < constList.Count() - 1)
{
output.WriteLine("},");
}
else
{
output.WriteLine("}");
}
}
output.Unindent();
output.WriteLine("};");
output.WriteLine("\nstatic QString nullstring = QString();\n\nunsigned char CurrencyId::GetId(const QString& name)\n{\n CurrencyId_by_name& index = currencyIds.get<by_name>();\n CurrencyId_by_name::iterator it = index.find(name);\n if (it != index.end())\n return it->code;\n else\n return 0;\n}\n\nconst QString& CurrencyId::GetName(unsigned char id)\n{\n CurrencyId_by_code& index = currencyIds.get<by_code>();\n CurrencyId_by_code::iterator it = index.find(id);\n if (it != index.end())\n return it->name;\n else\n return nullstring;\n}\n\n} // namespace QuantKit");
}
private static void FallbackFormatting(ITextOutput output, CompiledMethod cmethod)
{
var body = cmethod.DexMethod.Body;
body.UpdateInstructionOffsets();
var targetInstructions = body.Instructions.Select(x => x.Operand).OfType<Instruction>().ToList();
targetInstructions.AddRange(body.Exceptions.Select(x => x.TryStart));
targetInstructions.AddRange(body.Exceptions.Select(x => x.TryEnd));
targetInstructions.AddRange(body.Exceptions.SelectMany(x => x.Catches, (h, y) => y.Instruction));
targetInstructions.AddRange(body.Exceptions.Select(x => x.CatchAll));
foreach (var ins in body.Instructions)
{
if (targetInstructions.Contains(ins) || (ins.Offset == 0))
{
output.Write(string.Format("D_{0:X4}:", ins.Offset));
output.WriteLine();
}
output.Indent();
output.Write(ins.ToString());
output.WriteLine();
output.Unindent();
}
if (body.Exceptions.Any())
{
output.WriteLine();
output.Write("Exception handlers:");
output.WriteLine();
output.Indent();
foreach (var handler in body.Exceptions)
{
output.Write(string.Format("{0:x4}-{1:x4}", handler.TryStart.Offset, handler.TryEnd.Offset));
output.WriteLine();
output.Indent();
foreach (var c in handler.Catches)
{
output.Write(string.Format("{0} => {1:x4}", c.Type, c.Instruction.Offset));
output.WriteLine();
}
if (handler.CatchAll != null)
{
output.Write(string.Format("{0} => {1:x4}", "<any>", handler.CatchAll.Offset));
output.WriteLine();
}
output.Unindent();
}
output.Unindent();
}
}
void EndKeywordBlock(ITextOutput output)
{
output.Unindent();
output.WriteRightBrace();
output.WriteLine();
}
public void Unindent()
{
_inner.Unindent();
}
private void DisassembleMethodInternal(MethodDefinition method)
{
// .method public hidebysig specialname
// instance default class [mscorlib]System.IO.TextWriter get_BaseWriter () cil managed
//
//emit flags
WriteEnum(method.Attributes & MethodAttributes.MemberAccessMask, _methodVisibility);
WriteFlags(method.Attributes & ~MethodAttributes.MemberAccessMask, _methodAttributeFlags);
if (method.IsCompilerControlled)
{
_output.Write("privatescope ");
}
if ((method.Attributes & MethodAttributes.PInvokeImpl) == MethodAttributes.PInvokeImpl)
{
_output.Write("pinvokeimpl");
if (method.HasPInvokeInfo && method.PInvokeInfo != null)
{
var info = method.PInvokeInfo;
_output.Write("(\"" + TextWriterTokenWriter.ConvertString(info.Module.Name) + "\"");
if (!string.IsNullOrEmpty(info.EntryPoint) && info.EntryPoint != method.Name)
{
_output.Write(" as \"" + TextWriterTokenWriter.ConvertString(info.EntryPoint) + "\"");
}
if (info.IsNoMangle)
{
_output.Write(" nomangle");
}
if (info.IsCharSetAnsi)
{
_output.Write(" ansi");
}
else if (info.IsCharSetAuto)
{
_output.Write(" autochar");
}
else if (info.IsCharSetUnicode)
{
_output.Write(" unicode");
}
if (info.SupportsLastError)
{
_output.Write(" lasterr");
}
if (info.IsCallConvCdecl)
{
_output.Write(" cdecl");
}
else if (info.IsCallConvFastcall)
{
_output.Write(" fastcall");
}
else if (info.IsCallConvStdCall)
{
_output.Write(" stdcall");
}
else if (info.IsCallConvThiscall)
{
_output.Write(" thiscall");
}
else if (info.IsCallConvWinapi)
{
_output.Write(" winapi");
}
_output.Write(')');
}
_output.Write(' ');
}
_output.WriteLine();
_output.Indent();
if (method.ExplicitThis)
{
_output.Write("instance explicit ");
}
else if (method.HasThis)
{
_output.Write("instance ");
}
//call convention
// ReSharper disable once BitwiseOperatorOnEnumWithoutFlags
WriteEnum(method.CallingConvention & (MethodCallingConvention)0x1f, _callingConvention);
//return type
method.ReturnType.WriteTo(_output);
_output.Write(' ');
if (method.MethodReturnType.HasMarshalInfo)
{
WriteMarshalInfo(method.MethodReturnType.MarshalInfo);
}
_output.Write(method.IsCompilerControlled
? DisassemblerHelpers.Escape(method.Name + "$PST" + method.MetadataToken.ToInt32().ToString("X8"))
: DisassemblerHelpers.Escape(method.Name));
WriteTypeParameters(_output, method);
//( params )
_output.Write(" (");
if (method.HasParameters)
{
_output.WriteLine();
_output.Indent();
WriteParameters(method.Parameters);
_output.Unindent();
}
_output.Write(") ");
//cil managed
WriteEnum(method.ImplAttributes & MethodImplAttributes.CodeTypeMask, _methodCodeType);
_output.Write((method.ImplAttributes & MethodImplAttributes.ManagedMask) == MethodImplAttributes.Managed
? "managed "
: "unmanaged ");
WriteFlags(method.ImplAttributes & ~(MethodImplAttributes.CodeTypeMask | MethodImplAttributes.ManagedMask), _methodImpl);
_output.Unindent();
OpenBlock(defaultCollapsed: _isInType);
WriteAttributes(method.CustomAttributes);
if (method.HasOverrides)
{
foreach (var methodOverride in method.Overrides)
{
_output.Write(".override method ");
methodOverride.WriteTo(_output);
_output.WriteLine();
}
}
WriteParameterAttributes(0, method.MethodReturnType, method.MethodReturnType);
foreach (var p in method.Parameters)
{
WriteParameterAttributes(p.Index + 1, p, p);
}
WriteSecurityDeclarations(method);
if (method.HasBody)
{
// create IL code mappings - used in debugger
_methodBodyDisassembler.Disassemble(method.Body);
}
CloseBlock("end of method " + DisassemblerHelpers.Escape(method.DeclaringType.Name) + "::" + DisassemblerHelpers.Escape(method.Name));
}
public void Disassemble(MethodBody body)
{
// start writing IL code
var method = body.Method;
_output.WriteLine("// Method begins at RVA 0x{0:x4}", method.RVA);
_output.WriteLine("// Code size {0} (0x{0:x})", body.CodeSize);
_output.WriteLine(".maxstack {0}", body.MaxStackSize);
if (method.DeclaringType.Module.Assembly != null && method.DeclaringType.Module.Assembly.EntryPoint == method)
{
_output.WriteLine(".entrypoint");
}
if (method.Body.HasVariables)
{
_output.Write(".locals ");
if (method.Body.InitLocals)
{
_output.Write("init ");
}
_output.WriteLine("(");
_output.Indent();
foreach (var v in method.Body.Variables)
{
_output.WriteDefinition("[" + v.Index + "] ", v);
v.VariableType.WriteTo(_output);
if (!string.IsNullOrEmpty(v.ToString()))
{
_output.Write(' ');
_output.Write(DisassemblerHelpers.Escape(v.ToString()));
}
if (v.Index + 1 < method.Body.Variables.Count)
{
_output.Write(',');
}
_output.WriteLine();
}
_output.Unindent();
_output.WriteLine(")");
}
_output.WriteLine();
if (_detectControlStructure && body.Instructions.Count > 0)
{
var inst = body.Instructions[0];
var branchTargets = GetBranchTargets(body.Instructions);
WriteStructureBody(new ILStructure(body), branchTargets, ref inst);
}
else
{
foreach (var inst in method.Body.Instructions)
{
inst.WriteTo(_output);
_output.WriteLine();
}
if (method.Body.HasExceptionHandlers)
{
_output.WriteLine();
foreach (var eh in method.Body.ExceptionHandlers)
{
eh.WriteTo(_output);
_output.WriteLine();
}
}
}
}
