public override void WriteTo(ITextOutput output, FormattingOptions format)
{
output.Write("Block{");
output.WriteLine();
if (EntryGoto != null)
{
output.Indent();
output.Write("// Entry Goto");
output.WriteLine();
EntryGoto.WriteTo(output, format);
output.Unindent();
}
if (Body != null)
{
output.Indent();
output.Write("// Body");
output.WriteLine();
foreach (AstNode child in Body)
{
child.WriteTo(output, format);
output.WriteLine();
}
output.Unindent();
}
output.Write("}");
output.WriteLine();
}
private void DisassembleLocalsBlock(MethodBody body)
{
if (body.HasVariables)
{
output.Write(".locals ");
if (body.InitLocals)
{
output.Write("init ");
}
output.WriteLine("(");
output.Indent();
foreach (var v in body.Variables)
{
output.WriteDefinition("[" + v.Index + "] ", v);
v.VariableType.WriteTo(output);
if (v.Index + 1 < body.Variables.Count)
{
output.Write(',');
}
output.WriteLine();
}
output.Unindent();
output.WriteLine(")");
}
}
public override void WriteTo(ITextOutput output)
{
output.WriteLine(".try {");
output.Indent();
TryBlock.WriteTo(output);
output.Unindent();
output.WriteLine("}");
foreach (CatchBlock block in CatchBlocks)
{
block.WriteTo(output);
}
if (FaultBlock != null)
{
output.WriteLine("fault {");
output.Indent();
FaultBlock.WriteTo(output);
output.Unindent();
output.WriteLine("}");
}
if (FinallyBlock != null)
{
output.WriteLine("finally {");
output.Indent();
FinallyBlock.WriteTo(output);
output.Unindent();
output.WriteLine("}");
}
}
public override void WriteTo(ITextOutput output, ILAstWritingOptions options)
{
WriteILRange(output, options);
output.Write("deconstruct ");
output.MarkFoldStart("{...}");
output.WriteLine("{");
output.Indent();
output.WriteLine("init:");
output.Indent();
foreach (var inst in this.Init)
{
inst.WriteTo(output, options);
output.WriteLine();
}
output.Unindent();
output.WriteLine("pattern:");
output.Indent();
pattern.WriteTo(output, options);
output.Unindent();
output.WriteLine();
output.Write("conversions: ");
conversions.WriteTo(output, options);
output.WriteLine();
output.Write("assignments: ");
assignments.WriteTo(output, options);
output.Unindent();
output.WriteLine();
output.Write('}');
output.MarkFoldEnd();
}
static void WriteFieldMethodBody(FieldDefinition def, ITextOutput output, bool isRead)
{
var info = InfoUtil.Info(def);
if (!isRead)
{
output.WriteLine("{");
output.Indent();
output.Write("d_ptr->");
output.Write(info.GetterMethodName);
output.WriteLine("(value);");
output.Unindent();
output.WriteLine("}");
}
else
{
output.WriteLine("{");
output.Indent();
string value = Util.GetDefaultValue(def.FieldType);
output.WriteLine("return d_ptr->");
output.Write(info.SetterMethodName);
output.WriteLine("()");
output.Unindent();
output.WriteLine("}");
}
}
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 DisassembleLocalsBlock(MethodDefinitionHandle method, MethodBodyBlock body)
{
if (body.LocalSignature.IsNil)
{
return;
}
output.Write(".locals");
WriteMetadataToken(body.LocalSignature, spaceBefore: true);
if (body.LocalVariablesInitialized)
{
output.Write(" init");
}
var blob = metadata.GetStandaloneSignature(body.LocalSignature);
var signature = ImmutableArray <Action <ILNameSyntax> > .Empty;
try
{
if (blob.GetKind() == StandaloneSignatureKind.LocalVariables)
{
signature = blob.DecodeLocalSignature(signatureDecoder, genericContext);
}
else
{
output.Write(" /* wrong signature kind */");
}
}
catch (BadImageFormatException ex)
{
output.Write($" /* {ex.Message} */");
}
output.Write(' ');
output.WriteLine("(");
output.Indent();
int index = 0;
foreach (var v in signature)
{
output.WriteLocalReference("[" + index + "]", "loc_" + index, isDefinition: true);
output.Write(' ');
v(ILNameSyntax.TypeName);
if (DebugInfo != null && DebugInfo.TryGetName(method, index, out var name))
{
output.Write(" " + DisassemblerHelpers.Escape(name));
}
if (index + 1 < signature.Length)
{
output.Write(',');
}
output.WriteLine();
index++;
}
output.Unindent();
output.WriteLine(")");
}
public void Disassemble(MethodBody body)
{
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);
output.Write(' ');
output.Write(DisassemblerHelpers.Escape(v.Name));
output.WriteLine();
}
output.Unindent();
output.WriteLine(")");
}
output.WriteLine();
if (detectControlStructure && body.Instructions.Count > 0)
{
Instruction inst = body.Instructions[0];
WriteStructureBody(new ILStructure(body), ref inst);
}
else
{
foreach (var inst in method.Body.Instructions)
{
inst.WriteTo(output);
output.WriteLine();
}
output.WriteLine();
foreach (var eh in method.Body.ExceptionHandlers)
{
eh.WriteTo(output);
output.WriteLine();
}
}
}
public void OpenBrace(BraceStyle style, out TextPosition?start, out TextPosition?end)
{
if (braceLevelWithinType >= 0 || nodeStack.Peek() is TypeDeclaration)
{
braceLevelWithinType++;
}
output.WriteLine();
start = output.Location;
output.WriteLeftBrace();
end = output.Location;
output.WriteLine();
output.Indent();
}
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();
}
}
public void OpenBrace(BraceStyle style)
{
if (braceLevelWithinType >= 0 || nodeStack.Peek() is TypeDeclaration)
{
braceLevelWithinType++;
}
if (nodeStack.OfType <BlockStatement>().Count() <= 1 || FoldBraces)
{
output.MarkFoldStart(defaultCollapsed: braceLevelWithinType == 1);
}
output.WriteLine();
output.WriteLine("{");
output.Indent();
}
static void WriteCtor(MethodDefinition m, ITextOutput output)
{
if (m.IsConstructor && m.IsStatic)
{
return;
}
if (m.DeclaringType != null && m.DeclaringType.IsInterface)
{
return;
}
var info = InfoUtil.Info(m);
WriteMethodHead(m, output, true);
output.WriteLine();
var clist = info.CtorInitBody;
if (clist.Count() > 0)
{
output.Indent();
foreach (var s in clist)
{
output.WriteLine(s);
}
output.Unindent();
}
output.WriteLine("{");
// special process getTypeId
if (info.Name == "getTypeId")
{
output.Indent();
string rvalue;
if (m.Name == "get_TypeId")
{
rvalue = "EventType::" + m.DeclaringType.Name;
}
output.Unindent();
}
else
{
output.Indent();
foreach (var s in info.MethodBody)
{
output.WriteLine(s);
}
output.Unindent();
}
output.WriteLine("}");
}
public override void WriteTo(ITextOutput output, ILAstWritingOptions options)
{
ILRange.WriteTo(output, options);
output.Write("Block ");
output.WriteDefinition(Label, this);
if (Parent is BlockContainer)
{
output.Write(" (incoming: {0})", IncomingEdgeCount);
}
output.Write(' ');
output.MarkFoldStart("{...}");
output.WriteLine("{");
output.Indent();
foreach (var inst in Instructions)
{
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();
}
static void WriteEnumBody(ClassInfo info, ITextOutput output)
{
output.WriteLine("enum " + info.Name + " : unsigned char");
output.WriteLine("{");
output.Indent();
var members = info.Declaration.Descendants.OfType <EnumMemberDeclaration>().ToList();
for (int i = 0; i < members.Count(); ++i)
{
var item = members[i];
var text = item.GetText();
var split = text.Split('=');
output.Write(split[0]);
if (split.Count() >= 2)
{
output.Write(" = ");
output.Write(split[1]);
}
if (i != members.Count() - 1)
{
output.WriteLine(",");
}
else
{
output.WriteLine();
}
}
output.Unindent();
output.WriteLine("};");
}
public static void WriteCurrencyIdInclude(TypeDefinition def, ITextOutput output)
{
output.WriteLine("class QUANTKIT_EXPORT CurrencyId");
output.WriteLine("{");
output.WriteLine("public:");
output.Indent();
output.WriteLine("/*");
output.WriteLine("* return 0 means not found");
output.WriteLine("*/");
output.WriteLine("static unsigned char GetId(const QString &name);");
output.WriteLine();
output.WriteLine("/*");
output.WriteLine("* return QString().isEmpty() == true means not found");
output.WriteLine("*/");
output.WriteLine("static const QString& GetName(unsigned char id);");
output.WriteLine();
foreach (var f in def.Fields)
{
if (f.Constant != null)
{
output.Write("static const unsigned char ");
output.Write(f.Name);
output.Write(" = ");
output.Write(f.Constant.ToString());
output.WriteLine(";");
}
}
output.Unindent();
output.WriteLine("};");
}
void DisassembleRecord(BamlContext ctx, BamlRecord record)
{
if (BamlNode.IsFooter(record))
{
while (scopeStack.Count > 0 && !BamlNode.IsMatch(scopeStack.Peek(), record))
{
scopeStack.Pop();
output.Unindent();
}
if (scopeStack.Count > 0)
{
scopeStack.Pop();
output.Unindent();
}
}
output.WriteDefinition(record.Type.ToString(), BamlToolTipReference.Create(GetRecordReference(record)), TextTokenKind.Keyword, true);
Action <BamlContext, BamlRecord> handler;
if (handlerMap.TryGetValue(record.Type, out handler))
{
output.Write(" [", TextTokenKind.Text);
handler(ctx, record);
output.Write("]", TextTokenKind.Text);
}
output.WriteLine();
if (BamlNode.IsHeader(record))
{
scopeStack.Push(record);
output.Indent();
}
}
public override void WriteTo(ITextOutput output, ILAstWritingOptions options)
{
output.WriteDefinition("BlockContainer", this);
output.Write(' ');
output.MarkFoldStart("{...}");
output.WriteLine("{");
output.Indent();
foreach (var inst in Blocks)
{
if (inst.Parent == this)
{
inst.WriteTo(output, options);
}
else
{
output.Write("stale reference to ");
output.WriteReference(inst.Label, inst, isLocal: true);
}
output.WriteLine();
output.WriteLine();
}
output.Unindent();
output.Write("}");
output.MarkFoldEnd();
}
static void WriteEqualFunction(TypeDefinition def, ITextOutput output)
{
output.WriteLine("bool " + def.Name + "::operator==(const " + def.Name + " &other) const");
output.WriteLine("{");
output.Indent();
output.WriteLine("if(d && other.d)");
output.Indent();
output.WriteLine("return (*d == *other.d);");
output.Unindent();
output.WriteLine("else");
output.Indent();
output.WriteLine("return (d==other.d)");
output.Unindent();
output.Unindent();
output.WriteLine("}");
}
public override void WriteTo(ITextOutput output)
{
if (IsFilter)
{
output.Write("filter ");
output.Write(ExceptionVariable.Name);
}
else if (ExceptionType != null)
{
output.Write("catch ");
output.WriteReference(ExceptionType.FullName, ExceptionType);
if (ExceptionVariable != null)
{
output.Write(' ');
output.Write(ExceptionVariable.Name);
}
}
else
{
output.Write("handler ");
output.Write(ExceptionVariable.Name);
}
output.WriteLine(" {");
output.Indent();
base.WriteTo(output);
output.Unindent();
output.WriteLine("}");
}
public override void Decompile(Language language, ITextOutput output, DecompilationOptions options)
{
var loaded = parentAssembly.LoadedAssembly.LoadedAssemblyReferencesInfo.TryGetInfo(r.FullName, out var info);
if (r.IsWindowsRuntime)
{
language.WriteCommentLine(output, r.FullName + " [WinRT]" + (!loaded ? " (unresolved)" : ""));
}
else
{
language.WriteCommentLine(output, r.FullName + (!loaded ? " (unresolved)" : ""));
}
if (loaded)
{
output.Indent();
language.WriteCommentLine(output, "Assembly reference loading information:");
if (info.HasErrors)
{
language.WriteCommentLine(output, "There were some problems during assembly reference load, see below for more information!");
}
foreach (var item in info.Messages)
{
language.WriteCommentLine(output, $"{item.Item1}: {item.Item2}");
}
output.Unindent();
output.WriteLine();
}
}
public override void Decompile(Language language, ITextOutput output, DecompilationOptions options)
{
language.WriteCommentLine(output, $"Detected Target-Framework-Id: {parentAssembly.LoadedAssembly.GetTargetFrameworkIdAsync().Result}");
App.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action(EnsureLazyChildren));
output.WriteLine();
language.WriteCommentLine(output, "Referenced assemblies (in metadata order):");
// Show metadata order of references
foreach (var node in this.Children.OfType <ILSpyTreeNode>())
{
node.Decompile(language, output, options);
}
output.WriteLine();
output.WriteLine();
// Show full assembly load log:
language.WriteCommentLine(output, "Assembly load log including transitive references:");
var info = parentAssembly.LoadedAssembly.LoadedAssemblyReferencesInfo;
foreach (var asm in info.Entries)
{
language.WriteCommentLine(output, asm.FullName);
output.Indent();
foreach (var item in asm.Messages)
{
language.WriteCommentLine(output, $"{item.Item1}: {item.Item2}");
}
output.Unindent();
output.WriteLine();
}
}
static void WriteCtor(MethodDefinition def, ITextOutput output)
{
if (def.IsConstructor && def.IsStatic)
{
return;
}
if (!def.IsConstructor)
{
return;
}
if (def.DeclaringType != null && def.DeclaringType.IsInterface)
{
return;
}
output.Write(def.DeclaringType.Name + "::" + def.DeclaringType.Name);
output.Write("(");
WriteParameters(def, output, false);
output.Write(")");
output.WriteLine();
output.Indent();
output.Write(": d_ptr(new " + def.DeclaringType.Name + "Private");
if (def.Parameters.Count() > 0)
{
output.Write("(");
WriteParameterNames(def, output);
output.Write(")");
}
output.WriteLine(")");
output.Unindent();
output.WriteLine("{");
output.WriteLine("}");
}
public void OpenBrace(BraceStyle style, out TextLocation?start, out TextLocation?end)
{
if (braceLevelWithinType >= 0 || nodeStack.Peek() is TypeDeclaration)
{
braceLevelWithinType++;
}
if (nodeStack.OfType <BlockStatement>().Count() <= 1)
{
output.MarkFoldStart(defaultCollapsed: braceLevelWithinType == 1);
}
output.WriteLine();
start = output.Location;
output.WriteLeftBrace();
end = output.Location;
output.WriteLine();
output.Indent();
}
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();
}
}
static void WriteCopyConstructor(TypeDefinition def, ITextOutput output)
{
output.WriteLine(def.Name + "::" + def.Name + " (const " + def.Name + " &other)");
output.Indent();
output.WriteLine(": d(other.d)");
output.Unindent();
output.WriteLine("{");
output.WriteLine("}");
}
public override void WriteTo(ITextOutput output)
{
output.Write("filter ");
output.WriteLine(" {");
output.Indent();
base.WriteTo(output);
output.Unindent();
output.WriteLine("}");
}
public override void WriteTo(ITextOutput output)
{
output.Write("if (");
Condition.WriteTo(output);
output.WriteLine(") {");
output.Indent();
TrueBlock.WriteTo(output);
output.Unindent();
output.Write("}");
if (FalseBlock != null)
{
output.WriteLine(" else {");
output.Indent();
FalseBlock.WriteTo(output);
output.Unindent();
output.WriteLine("}");
}
}
public override void WriteTo(ITextOutput output)
{
output.Write("catch ");
output.WriteReference(ExceptionType.FullName, ExceptionType);
output.WriteLine(" {");
output.Indent();
base.WriteTo(output);
output.Unindent();
output.WriteLine("}");
}
static void WriteAssignConstructor(TypeDefinition def, ITextOutput output)
{
output.WriteLine(def.Name + "::" + def.Name + " &operator=(const " + def.Name + " &other)");
output.WriteLine("{");
output.Indent();
output.WriteLine("d = other.d;");
output.WriteLine("return *this;");
output.Unindent();
output.WriteLine("}");
}
void StartKeywordBlock(ITextOutput output, string keyword, IMemberDef member)
{
output.Write(keyword, TextTokenKind.Keyword);
output.WriteSpace();
output.WriteDefinition(IdentifierEscaper.Escape(member.Name), member, TextTokenKindUtils.GetTextTokenType(member), false);
output.WriteSpace();
output.WriteLeftBrace();
output.WriteLine();
output.Indent();
}
/*static void BuildIncludeList(TypeDefinition def, out List<string> externalList, out List<string> moduleClassList, out List<string> moduleEnumOrInterfaceList)
* {
* List<string> elist = new List<string>();
* List<string> mlist = new List<string>();
* List<string> clist = new List<string>();
* bool hasBaseType = def.BaseType != null && def.BaseType.Name != "Object";
* if (hasBaseType)
* mlist.Add(def.BaseType.Name); // basetype must be include file
* if (def.HasInterfaces)
* {
* foreach (var i in def.Interfaces)
* {
* if (i.Module == def.Module)
* mlist.Add(i.Name);
* else
* elist.Add(i.Name);
* }
* }
* foreach (var m in def.Methods)
* {
* Util.AddInclude(def.Namespace, m.ReturnType, elist, clist, mlist);
* foreach (var p in m.Parameters)
* Util.AddInclude(def.Namespace, p.ParameterType, elist, clist, mlist);
* //special for currencyId
* foreach (var p in m.Parameters)
* {
* if (p.Name == "currencyId" && p.HasConstant && p.Constant != null)
* mlist.Add("CurrencyId");
* }
* }
* foreach (var f in def.Fields)
* {
* Util.AddInclude(def.Namespace, f.FieldType, elist, clist, mlist);
* }
*
* externalList = elist.Distinct<string>().ToList();
* moduleClassList = clist.Distinct<string>().ToList();
* moduleEnumOrInterfaceList = mlist.Distinct<string>().ToList();
* }
*
* static void WriteIncludeBody(TypeDefinition def, TypeDeclaration decl, ITextOutput output)
* {
* List<string> externalList;
* List<string> moduleEnumOrInterfaceList;
* List<string> classList;
*
* BuildIncludeList(def, out externalList, out classList, out moduleEnumOrInterfaceList);
*
* foreach (var m in classList)
* {
* if (m != def.Name)
* {
* output.WriteLine("#include <QuantKit/" + m + ".h>");
* }
* }
*
* var tevent = Util.GetTypeDefinition(def.Module, "Event");
* if (tevent == def || Util.isInhertFrom(def, tevent))
* {
* if (classList.Count() > 0)
* output.WriteLine();
* output.WriteLine("#include <QuantKit/EventType.h>");
* }
* }*/
/*static void process_getTypeId(MethodDefinition m, ITextOutput output)
* {
* var decl = Util.getMethodDeclaration(m);
* var rlist = decl.Descendants.OfType<ReturnStatement>().ToList();
* if (rlist.Count() > 0)
* {
* var pexpr = rlist[0].Descendants.OfType<PrimitiveExpression>().ToList();
* if (pexpr.Count() > 0)
* {
* var v = pexpr[0].Value;
* output.Indent();
*
* output.Unindent();
* }
*
* }
*
* }*/
static void WriteMethod(MethodDefinition m, ITextOutput output)
{
if (m.IsConstructor && m.IsStatic)
{
return;
}
if (m.DeclaringType != null && m.DeclaringType.IsInterface)
{
return;
}
var info = InfoUtil.Info(m);
WriteMethodHead(m, output, true);
if (m.IsGetter)
{
output.Write(" const");
}
output.WriteLine();
output.WriteLine("{");
// special process getTypeId
if (info.Name == "getTypeId")
{
output.Indent();
string rvalue;
if (m.Name == "get_TypeId")
{
rvalue = "EventType::" + m.DeclaringType.Name;
}
output.Unindent();
}
else
{
//output.Indent();
foreach (var s in info.MethodBody)
{
output.WriteLine(s);
}
//output.Unindent();
}
/*if (m.ReturnType.MetadataType != MetadataType.Void)
* {
* output.Indent();
* string rvalue;
* if (m.Name == "get_TypeId")
* rvalue = "EventType::" + m.DeclaringType.Name;
* else
* rvalue = Util.GetDefaultValue(m.ReturnType);
* output.WriteLine("return " + rvalue + ";");
* output.Unindent();
* }*/
output.WriteLine("}");
}
void StartKeywordBlock(ITextOutput output, string keyword, IMemberDef member)
{
output.Write(keyword, TextTokenType.Keyword);
output.WriteSpace();
output.WriteDefinition(IdentifierEscaper.Escape(member.Name), member, TextTokenHelper.GetTextTokenType(member), false);
output.WriteSpace();
output.WriteLeftBrace();
output.WriteLine();
output.Indent();
}
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();
}
}
