public override void DecompileAssembly(AssemblyDefinition assembly, string fileName, ITextOutput output, DecompilationOptions options)
{
output.WriteLine("// " + fileName);
output.WriteLine();
new ReflectionDisassembler(output, detectControlStructure, options.CancellationToken).WriteAssemblyHeader(assembly);
}
public override void Decompile(Language language, ITextOutput output, DecompilationOptions options)
{
EnsureLazyChildren();
base.Decompile(language, output, options);
if (stringTableEntries.Count != 0) {
ISmartTextOutput smartOutput = output as ISmartTextOutput;
if (null != smartOutput) {
smartOutput.AddUIElement(
delegate {
return new ResourceStringTable(stringTableEntries,
new System.Windows.Size(MainWindow.Instance.mainPane.ActualWidth - 45,
MainWindow.Instance.mainPane.ActualHeight));
}
);
}
output.WriteLine();
output.WriteLine();
}
if (otherEntries.Count != 0) {
ISmartTextOutput smartOutput = output as ISmartTextOutput;
if (null != smartOutput) {
smartOutput.AddUIElement(
delegate {
return new ResourceObjectTable(otherEntries,
new System.Windows.Size(MainWindow.Instance.mainPane.ActualWidth - 45,
MainWindow.Instance.mainPane.ActualHeight));
}
);
}
output.WriteLine();
}
}
public override void DecompileMethod(MethodDefinition method, ITextOutput output, DecompilationOptions options)
{
if (!method.HasBody) {
return;
}
ILAstBuilder astBuilder = new ILAstBuilder();
ILBlock ilMethod = new ILBlock();
ilMethod.Body = astBuilder.Build(method, inlineVariables);
if (abortBeforeStep != null) {
DecompilerContext context = new DecompilerContext(method.Module) { CurrentType = method.DeclaringType, CurrentMethod = method };
new ILAstOptimizer().Optimize(context, ilMethod, abortBeforeStep.Value);
}
var allVariables = ilMethod.GetSelfAndChildrenRecursive<ILExpression>().Select(e => e.Operand as ILVariable)
.Where(v => v != null && !v.IsParameter).Distinct();
foreach (ILVariable v in allVariables) {
output.WriteDefinition(v.Name, v);
if (v.Type != null) {
output.Write(" : ");
if (v.IsPinned)
output.Write("pinned ");
v.Type.WriteTo(output, ILNameSyntax.ShortTypeName);
}
output.WriteLine();
}
output.WriteLine();
foreach (ILNode node in ilMethod.Body) {
node.WriteTo(output);
output.WriteLine();
}
}
public override void DecompileMethod(ilspy::Mono.Cecil.MethodDefinition method, ITextOutput output, DecompilationOptions options)
{
var xMethod = GetXMethodDefinition(method);
var ilMethod = xMethod as XBuilder.ILMethodDefinition;
CompiledMethod cmethod;
if (ilMethod == null || !ilMethod.OriginalMethod.HasBody)
{
output.Write("");
output.WriteLine("// not an il method or method without body.");
return;
}
var methodSource = new MethodSource(xMethod, ilMethod.OriginalMethod);
var target = (DexTargetPackage) AssemblyCompiler.TargetPackage;
var dMethod = (MethodDefinition)xMethod.GetReference(target);
DexMethodBodyCompiler.TranslateToRL(AssemblyCompiler, target, methodSource, dMethod, GenerateSetNextInstructionCode, out cmethod);
var rlBody = cmethod.RLBody;
// Optimize RL code
string lastApplied = RLTransformations.Transform(target.DexFile, rlBody, StopOptimizationAfter == -1?int.MaxValue:StopOptimizationAfter);
if(lastApplied != null)
output.WriteLine("// Stop after " + lastApplied);
PrintMethod(cmethod, output, options);
}
public override void DecompileMethod(MethodDef method, ITextOutput output, DecompilationOptions options)
{
WriteComment(output, "Method: ");
output.WriteDefinition(IdentifierEscaper.Escape(method.FullName), method, TextTokenType.Comment, false);
output.WriteLine();
if (!method.HasBody) {
return;
}
StartKeywordBlock(output, ".body", method);
ILAstBuilder astBuilder = new ILAstBuilder();
ILBlock ilMethod = new ILBlock();
DecompilerContext context = new DecompilerContext(method.Module) { CurrentType = method.DeclaringType, CurrentMethod = method };
ilMethod.Body = astBuilder.Build(method, inlineVariables, context);
if (abortBeforeStep != null) {
new ILAstOptimizer().Optimize(context, ilMethod, abortBeforeStep.Value);
}
if (context.CurrentMethodIsAsync) {
output.Write("async", TextTokenType.Keyword);
output.Write('/', TextTokenType.Operator);
output.WriteLine("await", TextTokenType.Keyword);
}
var allVariables = ilMethod.GetSelfAndChildrenRecursive<ILExpression>().Select(e => e.Operand as ILVariable)
.Where(v => v != null && !v.IsParameter).Distinct();
foreach (ILVariable v in allVariables) {
output.WriteDefinition(IdentifierEscaper.Escape(v.Name), v, v.IsParameter ? TextTokenType.Parameter : TextTokenType.Local);
if (v.Type != null) {
output.WriteSpace();
output.Write(':', TextTokenType.Operator);
output.WriteSpace();
if (v.IsPinned) {
output.Write("pinned", TextTokenType.Keyword);
output.WriteSpace();
}
v.Type.WriteTo(output, ILNameSyntax.ShortTypeName);
}
if (v.IsGenerated) {
output.WriteSpace();
output.Write('[', TextTokenType.Operator);
output.Write("generated", TextTokenType.Keyword);
output.Write(']', TextTokenType.Operator);
}
output.WriteLine();
}
var memberMapping = new MemberMapping(method);
foreach (ILNode node in ilMethod.Body) {
node.WriteTo(output, memberMapping);
if (!node.WritesNewLine)
output.WriteLine();
}
output.AddDebugSymbols(memberMapping);
EndKeywordBlock(output);
}
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options)
{
if (options.FullDecompilation && options.SaveAsProjectDirectory != null) {
HashSet<string> directories = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
var files = WriteCodeFilesInProject(assembly.AssemblyDefinition, options, directories).ToList();
files.AddRange(WriteResourceFilesInProject(assembly, options, directories));
WriteProjectFile(new TextOutputWriter(output), files, assembly.AssemblyDefinition.MainModule);
} else {
base.DecompileAssembly(assembly, output, options);
output.WriteLine();
ModuleDefinition mainModule = assembly.AssemblyDefinition.MainModule;
if (mainModule.EntryPoint != null) {
output.Write("' Entry point: ");
output.WriteReference(mainModule.EntryPoint.DeclaringType.FullName + "." + mainModule.EntryPoint.Name, mainModule.EntryPoint);
output.WriteLine();
}
switch (mainModule.Architecture) {
case TargetArchitecture.I386:
if ((mainModule.Attributes & ModuleAttributes.Required32Bit) == ModuleAttributes.Required32Bit)
WriteCommentLine(output, "Architecture: x86");
else
WriteCommentLine(output, "Architecture: AnyCPU");
break;
case TargetArchitecture.AMD64:
WriteCommentLine(output, "Architecture: x64");
break;
case TargetArchitecture.IA64:
WriteCommentLine(output, "Architecture: Itanium-64");
break;
}
if ((mainModule.Attributes & ModuleAttributes.ILOnly) == 0) {
WriteCommentLine(output, "This assembly contains unmanaged code.");
}
switch (mainModule.Runtime) {
case TargetRuntime.Net_1_0:
WriteCommentLine(output, "Runtime: .NET 1.0");
break;
case TargetRuntime.Net_1_1:
WriteCommentLine(output, "Runtime: .NET 1.1");
break;
case TargetRuntime.Net_2_0:
WriteCommentLine(output, "Runtime: .NET 2.0");
break;
case TargetRuntime.Net_4_0:
WriteCommentLine(output, "Runtime: .NET 4.0");
break;
}
output.WriteLine();
// don't automatically load additional assemblies when an assembly node is selected in the tree view
using (options.FullDecompilation ? null : LoadedAssembly.DisableAssemblyLoad()) {
AstBuilder codeDomBuilder = CreateAstBuilder(options, currentModule: assembly.AssemblyDefinition.MainModule);
codeDomBuilder.AddAssembly(assembly.AssemblyDefinition, onlyAssemblyLevel: !options.FullDecompilation);
RunTransformsAndGenerateCode(codeDomBuilder, output, options);
}
}
OnDecompilationFinished(null);
}
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options)
{
if (options.FullDecompilation && options.SaveAsProjectDirectory != null) {
var decompiler = new VBProjectDecompiler();
decompiler.Decompile(this, assembly, output, options);
} else {
base.DecompileAssembly(assembly, output, options);
output.WriteLine();
ModuleDefinition mainModule = assembly.ModuleDefinition;
if (mainModule.EntryPoint != null) {
output.Write("' Entry point: ");
output.WriteReference(mainModule.EntryPoint.DeclaringType.FullName + "." + mainModule.EntryPoint.Name, mainModule.EntryPoint);
output.WriteLine();
}
WriteCommentLine(output, "Architecture: " + CSharpLanguage.GetPlatformDisplayName(mainModule));
if ((mainModule.Attributes & ModuleAttributes.ILOnly) == 0) {
WriteCommentLine(output, "This assembly contains unmanaged code.");
}
switch (mainModule.Runtime) {
case TargetRuntime.Net_1_0:
WriteCommentLine(output, "Runtime: .NET 1.0");
break;
case TargetRuntime.Net_1_1:
WriteCommentLine(output, "Runtime: .NET 1.1");
break;
case TargetRuntime.Net_2_0:
WriteCommentLine(output, "Runtime: .NET 2.0");
break;
case TargetRuntime.Net_4_0:
if (assembly.IsNet45())
{
WriteCommentLine(output, "Runtime: .NET 4.5");
}
else
{
WriteCommentLine(output, "Runtime: .NET 4.0");
}
break;
}
output.WriteLine();
// don't automatically load additional assemblies when an assembly node is selected in the tree view
using (options.FullDecompilation ? null : LoadedAssembly.DisableAssemblyLoad()) {
AstBuilder codeDomBuilder = CreateAstBuilder(options, currentModule: assembly.ModuleDefinition);
codeDomBuilder.AddAssembly(assembly.ModuleDefinition, onlyAssemblyLevel: !options.FullDecompilation);
RunTransformsAndGenerateCode(codeDomBuilder, output, options, assembly.ModuleDefinition);
}
}
}
public AssemblyCompiler AssemblyCompiler { get { return compiler.AssemblyCompiler; } }
public MapFileLookup MapFile { get { return compiler.MapFile; } }
public static bool GenerateSetNextInstructionCode
{
get { return compiler.GenerateSetNextInstructionCode; }
set { compiler.GenerateSetNextInstructionCode = value; }
}
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options)
{
compiler.CompileIfRequired(assembly.AssemblyDefinition);
public override void Decompile(Language language, ITextOutput output, DecompilationOptions options) {
App.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action(EnsureChildrenFiltered));
foreach (ResourceTreeNode child in this.Children) {
child.Decompile(language, output);
output.WriteLine();
}
}
void DoDisassemble(IDnlibDef item, ITextOutput output, ReflectionDisassembler disassembler) {
if (item is ModuleDef) {
var module = (ModuleDef)item;
disassembler.WriteAssemblyReferences(module);
if (module.Assembly != null)
disassembler.WriteAssemblyHeader(module.Assembly);
output.WriteLine();
disassembler.WriteModuleHeader(module);
}
else if (item is TypeDef) {
disassembler.DisassembleType((TypeDef)item);
}
else if (item is MethodDef) {
disassembler.DisassembleMethod((MethodDef)item);
}
else if (item is FieldDef) {
disassembler.DisassembleField((FieldDef)item);
}
else if (item is PropertyDef) {
disassembler.DisassembleProperty((PropertyDef)item);
}
else if (item is EventDef) {
disassembler.DisassembleEvent((EventDef)item);
}
}
public override void DecompileProperty(PropertyDefinition property, ITextOutput output, DecompilationOptions options)
{
ReflectionDisassembler rd = new ReflectionDisassembler(output, detectControlStructure, options.CancellationToken);
rd.DisassembleProperty(property);
if (property.GetMethod != null) {
output.WriteLine();
rd.DisassembleMethod(property.GetMethod);
}
if (property.SetMethod != null) {
output.WriteLine();
rd.DisassembleMethod(property.SetMethod);
}
foreach (var m in property.OtherMethods) {
output.WriteLine();
rd.DisassembleMethod(m);
}
}
public override void DecompileType(TypeDefinition type, ITextOutput output, DecompilationOptions options)
{
var xType = GetXTypeDefinition(type);
output.WriteLine("class " + type.Name);
output.WriteLine("{");
foreach (var field in xType.Fields)
{
if (!field.IsReachable)
continue;
output.WriteLine("\t{0} {1};", field.FieldType.Name, field.Name);
}
output.WriteLine();
foreach (var method in xType.Methods)
{
var ilMethod = method as XBuilder.ILMethodDefinition;
if (ilMethod != null && !ilMethod.OriginalMethod.IsReachable)
continue;
output.Write("\t{0} {1}(", method.ReturnType.Name, method.Name);
List<string> parms = method.Parameters.Select(p => string.Format("{0}{1} {2}",
KindToStringAndSpace(p.Kind),
p.ParameterType.Name,
p.Name))
.ToList();
if (method.NeedsGenericInstanceTypeParameter)
parms.Add("Type[] git");
if (method.NeedsGenericInstanceMethodParameter)
parms.Add("Type[] gim");
output.Write(string.Join(", ", parms));
output.WriteLine(")");
output.WriteLine("\t{");
DecompileMethod(method, output, 2);
output.WriteLine("\t}");
output.WriteLine();
}
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();
}
}
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options)
{
output.WriteLine("// " + assembly.FileName);
output.WriteLine();
ReflectionDisassembler rd = new ReflectionDisassembler(output, detectControlStructure, options.CancellationToken);
//if (options.FullDecompilation)
// rd.WriteAssemblyReferences(assembly.ModuleDefinition);
if (assembly.AssemblyDefinition != null)
rd.WriteAssemblyHeader(assembly.AssemblyDefinition);
output.WriteLine();
rd.WriteModuleHeader(assembly.ModuleDefinition);
if (options.FullDecompilation) {
output.WriteLine();
output.WriteLine();
rd.WriteModuleContents(assembly.ModuleDefinition);
}
}
public override void Decompile(Language language, ITextOutput output, DecompilationOptions options)
{
language.WriteCommentLine(output, string.Format("{0} ({1}, {2})", r.Name, r.ResourceType, r.Attributes));
ISmartTextOutput smartOutput = output as ISmartTextOutput;
if (smartOutput != null && r is EmbeddedResource) {
smartOutput.AddButton(Images.Save, "Save", delegate { Save(null); });
output.WriteLine();
}
}
private void Run(ConsoleOptions options, ITextOutput output)
{
var stopWatch = new Stopwatch();
stopWatch.Start();
var crapRunner = GetContainer().Resolve<CrapRunner>();
crapRunner.Run(options.codeCoverage, options.codeMetrics, options.crapThreshold);
crapRunner.WriteOutput(output);
if (options.HasXmlOutput)
crapRunner.WriteXmlOutput(options.xml, output);
stopWatch.Stop();
output.WriteLine(string.Format("Took {0:0.00}s to execute", stopWatch.Elapsed.TotalSeconds));
}
// There are several methods available to override; in this sample, we deal with methods only
public override void DecompileMethod(MethodDefinition method, ITextOutput output, DecompilationOptions options)
{
if (method.Body != null) {
output.WriteLine("Size of method: {0} bytes", method.Body.CodeSize);
ISmartTextOutput smartOutput = output as ISmartTextOutput;
if (smartOutput != null) {
// when writing to the text view (but not when writing to a file), we can even add UI elements such as buttons:
smartOutput.AddButton(null, "Click me!", (sender, e) => (sender as Button).Content = "I was clicked!");
smartOutput.WriteLine();
}
// ICSharpCode.Decompiler.Ast.AstBuilder can be used to decompile to C#
AstBuilder b = new AstBuilder(new DecompilerContext(method.Module) {
Settings = options.DecompilerSettings,
CurrentType = method.DeclaringType
});
b.AddMethod(method);
b.RunTransformations();
output.WriteLine("Decompiled AST has {0} nodes", b.CompilationUnit.DescendantsAndSelf.Count());
}
}
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 override void Decompile(Language language, ITextOutput output, DecompilationOptions options)
{
EnsureLazyChildren();
base.Decompile(language, output, options);
if (stringTableEntries.Count != 0)
{
ISmartTextOutput smartOutput = output as ISmartTextOutput;
if (null != smartOutput)
{
smartOutput.AddUIElement(
delegate {
return(new ResourceStringTable(stringTableEntries,
new System.Windows.Size(MainWindow.Instance.mainPane.ActualWidth - 45,
MainWindow.Instance.mainPane.ActualHeight)));
}
);
}
output.WriteLine();
output.WriteLine();
}
if (otherEntries.Count != 0)
{
ISmartTextOutput smartOutput = output as ISmartTextOutput;
if (null != smartOutput)
{
smartOutput.AddUIElement(
delegate {
return(new ResourceObjectTable(otherEntries,
new System.Windows.Size(MainWindow.Instance.mainPane.ActualWidth - 45,
MainWindow.Instance.mainPane.ActualHeight)));
}
);
}
output.WriteLine();
}
}
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options, DecompileAssemblyFlags flags = DecompileAssemblyFlags.AssemblyAndModule)
{
bool decompileAsm = (flags & DecompileAssemblyFlags.Assembly) != 0;
bool decompileMod = (flags & DecompileAssemblyFlags.Module) != 0;
output.WriteLine("// " + assembly.FileName, TextTokenType.Comment);
if (decompileMod || decompileAsm)
PrintEntryPoint(assembly, output);
output.WriteLine();
ReflectionDisassembler rd = CreateReflectionDisassembler(output, options, assembly.ModuleDefinition);
if (decompileMod && options.FullDecompilation)
rd.WriteAssemblyReferences(assembly.ModuleDefinition as ModuleDefMD);
if (decompileAsm && assembly.AssemblyDefinition != null)
rd.WriteAssemblyHeader(assembly.AssemblyDefinition);
if (decompileMod) {
output.WriteLine();
rd.WriteModuleHeader(assembly.ModuleDefinition);
if (options.FullDecompilation) {
output.WriteLine();
output.WriteLine();
rd.WriteModuleContents(assembly.ModuleDefinition);
}
}
}
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 override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options)
{
output.WriteLine("// " + assembly.FileName);
output.WriteLine();
ReflectionDisassembler rd = new ReflectionDisassembler(output, detectControlStructure, options.CancellationToken);
if (options.FullDecompilation)
{
rd.WriteAssemblyReferences(assembly.ModuleDefinition);
}
if (assembly.AssemblyDefinition != null)
{
rd.WriteAssemblyHeader(assembly.AssemblyDefinition);
}
output.WriteLine();
rd.WriteModuleHeader(assembly.ModuleDefinition);
if (options.FullDecompilation)
{
output.WriteLine();
output.WriteLine();
rd.WriteModuleContents(assembly.ModuleDefinition);
}
}
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options)
{
output.WriteLine("// " + assembly.FileName);
output.WriteLine();
var dis = CreateDisassembler(output, options);
if (options.FullDecompilation)
{
dis.WriteAssemblyReferences(assembly.ModuleDefinition);
}
if (assembly.AssemblyDefinition != null)
{
dis.WriteAssemblyHeader(assembly.AssemblyDefinition);
}
output.WriteLine();
dis.WriteModuleHeader(assembly.ModuleDefinition);
if (options.FullDecompilation)
{
output.WriteLine();
output.WriteLine();
dis.WriteModuleContents(assembly.ModuleDefinition);
}
}
void DecompileNodes(DecompilationContext context, ITextOutput textOutput)
{
var nodes = context.TreeNodes;
for (int i = 0; i < nodes.Length; i++)
{
if (i > 0)
{
textOutput.WriteLine();
}
context.Options.CancellationToken.ThrowIfCancellationRequested();
nodes[i].Decompile(context.Language, textOutput, context.Options);
}
}
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options)
{
if (options.FullDecompilation && options.SaveAsProjectDirectory != null)
{
HashSet <string> directories = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
var files = WriteCodeFilesInProject(assembly.ModuleDefinition, options, directories).ToList();
files.AddRange(WriteResourceFilesInProject(assembly, options, directories));
WriteProjectFile(new TextOutputWriter(output), files, assembly.ModuleDefinition);
}
else
{
base.DecompileAssembly(assembly, output, options);
output.WriteLine();
ModuleDef mainModule = assembly.ModuleDefinition;
if (mainModule.EntryPoint != null)
{
output.Write("' Entry point: ");
output.WriteReference(mainModule.EntryPoint.DeclaringType.FullName + "." + mainModule.EntryPoint.Name, mainModule.EntryPoint);
output.WriteLine();
}
WriteCommentLine(output, "Architecture: " + CSharpLanguage.GetPlatformDisplayName(mainModule));
if (!mainModule.IsILOnly)
{
WriteCommentLine(output, "This assembly contains unmanaged code.");
}
output.WriteLine("// Runtime: " + mainModule.RuntimeVersion);
output.WriteLine();
// don't automatically load additional assemblies when an assembly node is selected in the tree view
using (options.FullDecompilation ? null : LoadedAssembly.DisableAssemblyLoad()) {
AstBuilder codeDomBuilder = CreateAstBuilder(options, currentModule: assembly.ModuleDefinition);
codeDomBuilder.AddAssembly(assembly.ModuleDefinition, onlyAssemblyLevel: !options.FullDecompilation);
RunTransformsAndGenerateCode(codeDomBuilder, output, options, assembly.ModuleDefinition);
}
}
}
protected void WriteHiddenStart(ITextOutput output, MemberMapping memberMapping, IEnumerable <ILRange> extraIlRanges = null)
{
var location = output.Location;
output.WriteLeftBrace();
var ilr = new List <ILRange>(ILRanges);
if (extraIlRanges != null)
{
ilr.AddRange(extraIlRanges);
}
UpdateMemberMapping(memberMapping, location, output.Location, ilr);
output.WriteLine();
output.Indent();
}
bool FormatExceptions(App.ExceptionData[] exceptions, ITextOutput output)
{
if (exceptions.Length == 0)
{
return(false);
}
bool first = true;
foreach (var item in exceptions)
{
if (first)
{
first = false;
}
else
{
output.WriteLine("-------------------------------------------------");
}
output.WriteLine("Error(s) loading plugin: " + item.PluginName);
if (item.Exception is System.Reflection.ReflectionTypeLoadException)
{
var e = (System.Reflection.ReflectionTypeLoadException)item.Exception;
foreach (var ex in e.LoaderExceptions)
{
output.WriteLine(ex.ToString());
output.WriteLine();
}
}
else
{
output.WriteLine(item.Exception.ToString());
}
}
return(true);
}
static void WriteFieldAsMethod(FieldDefinition field, ITextOutput output, bool isGetter)
{
var info = InfoUtil.Info(field);
if (isGetter)
{
bool isValueType;
string type = Util.TypeString(field.FieldType, out isValueType);
output.Write(type);
output.Write(" ");
output.Write(info.GetterMethodName);
output.WriteLine("() const");
}
else
{
bool isValueType;
string type = Util.TypeString(field.FieldType, out isValueType);
output.Write("void ");
output.Write(info.SetterMethodName);
output.Write("(");
output.Write(type);
output.WriteLine(" value)");
}
}
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 r in module.AssemblyReferences)
{
new AssemblyReferenceTreeNode(r, parentAssembly).Decompile(language, output, options);
}
foreach (var r in module.ModuleReferences)
{
language.WriteCommentLine(output, r.Name);
}
}
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options)
{
if (options.FullDecompilation && options.SaveAsProjectDirectory != null)
{
HashSet <string> directories = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
var files = WriteCodeFilesInProject(assembly.ModuleDefinition, options, directories).ToList();
files.AddRange(WriteResourceFilesInProject(assembly, options, directories));
WriteProjectFile(new TextOutputWriter(output), files, assembly.ModuleDefinition, options, assembly.ProjectGuid);
}
else
{
base.DecompileAssembly(assembly, output, options);
output.WriteLine();
ModuleDefinition mainModule = assembly.ModuleDefinition;
if (mainModule.Types.Count > 0)
{
output.Write("// Global type: ");
output.WriteReference(mainModule.Types[0].FullName, mainModule.Types[0]);
output.WriteLine();
}
if (mainModule.EntryPoint != null)
{
output.Write("// Entry point: ");
output.WriteReference(mainModule.EntryPoint.DeclaringType.FullName + "." + mainModule.EntryPoint.Name, mainModule.EntryPoint);
output.WriteLine();
}
output.WriteLine("// Architecture: " + GetPlatformDisplayName(mainModule));
if ((mainModule.Attributes & ModuleAttributes.ILOnly) == 0)
{
output.WriteLine("// This assembly contains unmanaged code.");
}
string runtimeName = GetRuntimeDisplayName(mainModule);
if (runtimeName != null)
{
output.WriteLine("// Runtime: " + runtimeName);
}
output.WriteLine();
// don't automatically load additional assemblies when an assembly node is selected in the tree view
using (options.FullDecompilation ? null : LoadedAssembly.DisableAssemblyLoad())
{
AstBuilder codeDomBuilder = CreateAstBuilder(options, currentModule: assembly.ModuleDefinition);
codeDomBuilder.AddAssembly(assembly.ModuleDefinition, onlyAssemblyLevel: !options.FullDecompilation);
codeDomBuilder.RunTransformations(transformAbortCondition);
codeDomBuilder.GenerateCode(output);
}
}
}
static void WriteAddCppMethod(TypeDefinition def, ITextOutput output)
{
if (def.IsInterface)
{
return;
}
output.WriteLine("~" + def.Name + "();");
output.WriteLine();
output.WriteLine(def.Name + " &operator=(const " + def.Name + " &other);");
output.Unindent();
output.WriteLine("#ifdef Q_COMPILER_RVALUE_REFS");
output.Indent();
output.WriteLine("inline " + def.Name + " &operator=(" + def.Name + " &&other) { qSwap(d_ptr, other.d_ptr); return *this; }");
//output.WriteLine(def.Name + " &operator=(" + def.Name + " &&other) { swap(other); return *this; }");
output.Unindent();
output.WriteLine("#endif");
output.Indent();
//output.WriteLine("void swap(" + def.Name + " &other) { d_ptr.swap(other.d_ptr); }");
output.WriteLine("inline void swap(" + def.Name + " &other) { qSwap(d_ptr, other.d_ptr); }");
output.WriteLine("inline bool operator==(const " + def.Name + " &other) const { return d_ptr == other.d_ptr; }");
output.WriteLine("inline bool operator!=(const " + def.Name + " &other) const { return !(this->operator==(other)); }");
}
public void WriteHeader(ITextOutput output)
{
var cols = tablesStreamVM.TableInfo.Columns;
output.Write("RID\tToken\tOffset", TextTokenType.Comment);
for (int i = 0; i < cols.Count; i++)
{
output.Write('\t', TextTokenType.Comment);
output.Write(tablesStreamVM.GetColumnName(i), TextTokenType.Comment);
}
if (tablesStreamVM.HasInfo)
{
output.Write('\t', TextTokenType.Comment);
output.Write(tablesStreamVM.InfoName, TextTokenType.Comment);
}
output.WriteLine();
}
public override void DecompileEvent(EventDefinition ev, ITextOutput output, DecompilationOptions options)
{
ReflectionDisassembler rd = new ReflectionDisassembler(output, detectControlStructure, options.CancellationToken);
rd.DisassembleEvent(ev);
if (ev.AddMethod != null) {
output.WriteLine();
rd.DisassembleMethod(ev.AddMethod);
}
if (ev.RemoveMethod != null) {
output.WriteLine();
rd.DisassembleMethod(ev.RemoveMethod);
}
foreach (var m in ev.OtherMethods) {
output.WriteLine();
rd.DisassembleMethod(m);
}
}
public void WriteHeader(ITextOutput output)
{
var cols = tablesStreamVM.TableInfo.Columns;
output.Write(string.Format("{0}\t{1}\t{2}", dnSpy_AsmEditor_Resources.RowIdentifier, dnSpy_AsmEditor_Resources.Token, dnSpy_AsmEditor_Resources.Offset), TextTokenKind.Comment);
for (int i = 0; i < cols.Count; i++)
{
output.Write("\t", TextTokenKind.Comment);
output.Write(tablesStreamVM.GetColumnName(i), TextTokenKind.Comment);
}
if (tablesStreamVM.HasInfo)
{
output.Write("\t", TextTokenKind.Comment);
output.Write(tablesStreamVM.InfoName, TextTokenKind.Comment);
}
output.WriteLine();
}
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 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();
}
public override void Decompile(Language language, ITextOutput output, DecompilationOptions options)
{
base.Decompile(language, output, options);
if (filteredEntries.Count == 0)
{
return;
}
ISmartTextOutput smartOutput = output as ISmartTextOutput;
if (null != smartOutput)
{
smartOutput.AddUIElement(
delegate {
return(new ResourceStringTable(filteredEntries));
}
);
}
output.WriteLine();
}
protected override void WriteInstruction(ITextOutput output, Instruction instruction)
{
int index = sequencePoints.BinarySearch(instruction.Offset, seq => seq.Offset);
if (index >= 0)
{
var info = sequencePoints[index];
var highlightingOutput = output as ISmartTextOutput;
if (!info.IsHidden)
{
for (int line = info.StartLine; line <= info.EndLine; line++)
{
if (highlightingOutput != null)
{
string text = codeLines[line - 1];
int startColumn = 1;
int endColumn = text.Length + 1;
if (line == info.StartLine)
{
startColumn = info.StartColumn;
}
if (line == info.EndLine)
{
endColumn = info.EndColumn;
}
WriteHighlightedCommentLine(highlightingOutput, text, startColumn - 1, endColumn - 1, info.StartLine == info.EndLine);
}
else
{
WriteCommentLine(output, codeLines[line - 1]);
}
}
}
else
{
output.Write("// ");
highlightingOutput?.BeginSpan(gray);
output.WriteLine("(no C# code)");
highlightingOutput?.EndSpan();
}
}
base.WriteInstruction(output, instruction);
}
public override void Decompile(Language language, ITextOutput output, DecompilationOptions options)
{
void HandleException(Exception ex, string message)
{
language.WriteCommentLine(output, message);
output.WriteLine();
output.MarkFoldStart("Exception details", true);
output.Write(ex.ToString());
output.MarkFoldEnd();
}
try
{
LoadedAssembly.WaitUntilLoaded(); // necessary so that load errors are passed on to the caller
}
catch (AggregateException ex)
{
language.WriteCommentLine(output, LoadedAssembly.FileName);
switch (ex.InnerException)
{
case BadImageFormatException badImage:
HandleException(badImage, "This file does not contain a managed assembly.");
return;
case FileNotFoundException fileNotFound:
HandleException(fileNotFound, "The file was not found.");
return;
case DirectoryNotFoundException dirNotFound:
HandleException(dirNotFound, "The directory was not found.");
return;
case PEFileNotSupportedException notSupported:
HandleException(notSupported, notSupported.Message);
return;
default:
throw;
}
}
language.DecompileAssembly(LoadedAssembly, output, options);
}
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();
}
public void Resolve(ITextOutput outputWriter)
{
Position currentPosition = GetStartPoint();
_currentDirection = Direction.Right;
while (true)
{
bool wasMovePossible = Move(ref currentPosition);
if (currentPosition == GetFinishPoint())
{
outputWriter.WriteLine("YEAH");
break;
}
if (!wasMovePossible)
{
ChangeDirection(currentPosition);
}
else
{
_moveCounter++;
}
#region Debug
if (_moveCounter == 100)
{
}
//temporary to test
if (_moveCounter > 300)
{
break;
}
#endregion
}
PrintPath(PathType.Orginal, outputWriter);
//PrintPath(PathType.Optimized, outputWriter);
}
public override void DecompileMethod(IMethod method, ITextOutput output, DecompilationOptions options)
{
PEFile module = method.ParentModule.PEFile;
R2RReaderCacheEntry r2rReaderCacheEntry = GetReader(module.GetLoadedAssembly(), module);
if (r2rReaderCacheEntry.r2rReader == null)
{
WriteCommentLine(output, r2rReaderCacheEntry.failureReason);
}
else
{
R2RReader reader = r2rReaderCacheEntry.r2rReader;
int bitness = -1;
if (reader.Machine == Machine.Amd64)
{
bitness = 64;
}
else
{
Debug.Assert(reader.Machine == Machine.I386);
bitness = 32;
}
foreach (var m in reader.R2RMethods)
{
if (m.MethodHandle == method.MetadataToken)
{
// TODO: Indexing
foreach (RuntimeFunction runtimeFunction in m.RuntimeFunctions)
{
WriteCommentLine(output, m.SignatureString);
byte[] code = new byte[runtimeFunction.Size];
for (int i = 0; i < runtimeFunction.Size; i++)
{
code[i] = reader.Image[reader.GetOffset(runtimeFunction.StartAddress) + i];
}
Disassemble(output, code, bitness, (ulong)runtimeFunction.StartAddress);
output.WriteLine();
}
}
}
}
}
void DecompileNodes(DecompilationContext context, ITextOutput textOutput)
{
// reset debug information
DebugInformation.CodeMappings = null;
var nodes = context.TreeNodes;
for (int i = 0; i < nodes.Length; i++)
{
if (i > 0)
{
textOutput.WriteLine();
}
context.Options.CancellationToken.ThrowIfCancellationRequested();
nodes[i].Decompile(context.Language, textOutput, context.Options);
}
OnDecompilationFinished(textOutput);
}
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options, DecompileAssemblyFlags flags = DecompileAssemblyFlags.AssemblyAndModule)
{
if (options.FullDecompilation && options.SaveAsProjectDirectory != null) {
HashSet<string> directories = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
var files = WriteCodeFilesInProject(assembly.ModuleDefinition, options, directories).ToList();
files.AddRange(WriteResourceFilesInProject(assembly, options, directories));
WriteProjectFile(new TextOutputWriter(output), files, assembly, options);
} else {
bool decompileAsm = (flags & DecompileAssemblyFlags.Assembly) != 0;
bool decompileMod = (flags & DecompileAssemblyFlags.Module) != 0;
base.DecompileAssembly(assembly, output, options, flags);
output.WriteLine();
ModuleDef mainModule = assembly.ModuleDefinition;
if (decompileMod && mainModule.Types.Count > 0) {
output.Write("' Global type: ", TextTokenType.Comment);
output.WriteReference(IdentifierEscaper.Escape(mainModule.GlobalType.FullName), mainModule.GlobalType, TextTokenType.Comment);
output.WriteLine();
}
if (decompileMod || decompileAsm)
PrintEntryPoint(assembly, output);
if (decompileMod) {
WriteCommentLine(output, "Architecture: " + CSharpLanguage.GetPlatformDisplayName(mainModule));
if (!mainModule.IsILOnly) {
WriteCommentLine(output, "This assembly contains unmanaged code.");
}
string runtimeName = ICSharpCode.ILSpy.CSharpLanguage.GetRuntimeDisplayName(mainModule);
if (runtimeName != null) {
WriteCommentLine(output, "Runtime: " + runtimeName);
}
}
if (decompileMod || decompileAsm)
output.WriteLine();
// don't automatically load additional assemblies when an assembly node is selected in the tree view
using (options.FullDecompilation ? null : LoadedAssembly.DisableAssemblyLoad()) {
AstBuilder codeDomBuilder = CreateAstBuilder(options, currentModule: assembly.ModuleDefinition);
codeDomBuilder.AddAssembly(assembly.ModuleDefinition, !options.FullDecompilation, decompileAsm, decompileMod);
RunTransformsAndGenerateCode(codeDomBuilder, output, options, assembly.ModuleDefinition);
}
}
}
public void Write(ITextOutput output, MetaDataTableRecordVM mdVM)
{
var cols = tablesStreamVM.TableInfo.Columns;
output.Write(mdVM.RidString, TextTokenKind.Comment);
output.Write("\t", TextTokenKind.Comment);
output.Write(mdVM.TokenString, TextTokenKind.Comment);
output.Write("\t", TextTokenKind.Comment);
output.Write(mdVM.OffsetString, TextTokenKind.Comment);
for (int j = 0; j < cols.Count; j++)
{
output.Write("\t", TextTokenKind.Comment);
output.Write(mdVM.GetField(j).DataFieldVM.StringValue, TextTokenKind.Comment);
}
if (tablesStreamVM.HasInfo)
{
output.Write("\t", TextTokenKind.Comment);
output.Write(mdVM.Info, TextTokenKind.Comment);
}
output.WriteLine();
}
protected void PrintEntryPoint(LoadedAssembly assembly, ITextOutput output)
{
var ep = GetEntryPoint(assembly.ModuleDefinition);
if (ep is uint)
{
WriteCommentLine(output, string.Format("Native Entry point: 0x{0:x8}", (uint)ep));
}
else if (ep is MethodDef)
{
var epMethod = (MethodDef)ep;
WriteComment(output, "Entry point: ");
if (epMethod.DeclaringType != null)
{
output.WriteReference(IdentifierEscaper.Escape(epMethod.DeclaringType.FullName), epMethod.DeclaringType, TextTokenType.Comment);
output.Write('.', TextTokenType.Comment);
}
output.WriteReference(IdentifierEscaper.Escape(epMethod.Name), epMethod, TextTokenType.Comment);
output.WriteLine();
}
}
public List <ILExpression> Values; // null for the default case
public override void WriteTo(ITextOutput output)
{
if (this.Values != null)
{
foreach (var i in this.Values)
{
output.Write("case ");
i.WriteTo(output);
output.Write(": ");
}
}
else
{
output.Write("default: ");
}
// make sure there is a writeline
if (!base.Body.WriteNodes(output, true, false))
{
output.WriteLine();
}
}
public override void Decompile(Language language, ITextOutput output)
{
var smartOutput = output as ISmartTextOutput;
if (smartOutput != null)
{
language.WriteComment(output, string.Empty);
output.WriteOffsetComment(this);
smartOutput.AddUIElement(() => {
return(new Image {
Source = ImageSource,
});
});
output.Write(" = ", TextTokenType.Comment);
output.WriteDefinition(UIUtils.CleanUpName(Name), this, TextTokenType.Comment);
output.WriteLine();
return;
}
base.Decompile(language, output);
}
public override void WriteShort(ITextOutput output, ILanguage language, bool showOffset)
{
var smartOutput = output as ISmartTextOutput;
if (smartOutput != null)
{
language.WriteCommentBegin(output, true);
output.WriteOffsetComment(this, showOffset);
smartOutput.AddUIElement(() => {
return(new System.Windows.Controls.Image {
Source = imageSource,
});
});
output.Write(" = ", TextTokenKind.Comment);
output.WriteDefinition(NameUtils.CleanName(Name), this, TextTokenKind.Comment);
language.WriteCommentEnd(output, true);
output.WriteLine();
return;
}
base.WriteShort(output, language, showOffset);
}
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();
}
bool FormatExceptions(App.ExceptionData[] exceptions, ITextOutput output)
{
if (exceptions.Length == 0) return false;
bool first = true;
foreach (var item in exceptions) {
if (first)
first = false;
else
output.WriteLine("-------------------------------------------------");
output.WriteLine("Error(s) loading plugin: " + item.PluginName);
if (item.Exception is System.Reflection.ReflectionTypeLoadException) {
var e = (System.Reflection.ReflectionTypeLoadException)item.Exception;
foreach (var ex in e.LoaderExceptions) {
output.WriteLine(ex.ToString());
output.WriteLine();
}
} else
output.WriteLine(item.Exception.ToString());
}
return true;
}
public override void DecompileType(TypeDef type, ITextOutput output, DecompilationOptions options)
{
WriteCommentLine(output, string.Format("Type: {0}", type.FullName));
if (type.BaseType != null) {
WriteComment(output, string.Format("Base type: "));
output.WriteReference(IdentifierEscaper.Escape(type.BaseType.FullName), type.BaseType, TextTokenType.Comment);
output.WriteLine();
}
foreach (var nested in type.NestedTypes) {
DecompileType(nested, output, options);
output.WriteLine();
}
foreach (var field in type.Fields) {
DecompileField(field, output, options);
output.WriteLine();
}
foreach (var property in type.Properties) {
DecompileProperty(property, output, options);
output.WriteLine();
}
foreach (var @event in type.Events) {
DecompileEvent(@event, output, options);
output.WriteLine();
}
foreach (var method in type.Methods) {
DecompileMethod(method, output, options);
output.WriteLine();
}
}
void EndKeywordBlock(ITextOutput output)
{
output.Unindent();
output.WriteRightBrace();
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();
}
public override void DecompileProperty(PropertyDef property, ITextOutput output, DecompilationOptions options)
{
ReflectionDisassembler rd = CreateReflectionDisassembler(output, options, property);
rd.DisassembleProperty(property);
if (property.GetMethod != null) {
output.WriteLine();
rd.DisassembleMethod(property.GetMethod);
}
if (property.SetMethod != null) {
output.WriteLine();
rd.DisassembleMethod(property.SetMethod);
}
foreach (var m in property.OtherMethods) {
output.WriteLine();
rd.DisassembleMethod(m);
}
}
public override void DecompileEvent(EventDef ev, ITextOutput output, DecompilationOptions options)
{
ReflectionDisassembler rd = CreateReflectionDisassembler(output, options, ev);
rd.DisassembleEvent(ev);
if (ev.AddMethod != null) {
output.WriteLine();
rd.DisassembleMethod(ev.AddMethod);
}
if (ev.RemoveMethod != null) {
output.WriteLine();
rd.DisassembleMethod(ev.RemoveMethod);
}
foreach (var m in ev.OtherMethods) {
output.WriteLine();
rd.DisassembleMethod(m);
}
}
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options, DecompileAssemblyFlags flags = DecompileAssemblyFlags.AssemblyAndModule)
{
bool decompileAsm = (flags & DecompileAssemblyFlags.Assembly) != 0;
bool decompileMod = (flags & DecompileAssemblyFlags.Module) != 0;
output.WriteLine("// " + assembly.FileName, TextTokenType.Comment);
if (decompileMod || decompileAsm)
PrintEntryPoint(assembly, output);
output.WriteLine();
ReflectionDisassembler rd = CreateReflectionDisassembler(output, options, assembly.ModuleDefinition);
if (decompileMod && options.FullDecompilation)
rd.WriteAssemblyReferences(assembly.ModuleDefinition as ModuleDefMD);
if (decompileAsm && assembly.AssemblyDefinition != null)
rd.WriteAssemblyHeader(assembly.AssemblyDefinition);
if (decompileMod) {
output.WriteLine();
rd.WriteModuleHeader(assembly.ModuleDefinition);
if (options.FullDecompilation) {
output.WriteLine();
output.WriteLine();
rd.WriteModuleContents(assembly.ModuleDefinition);
}
}
}
public virtual void WriteCommentLine(ITextOutput output, string comment)
{
output.WriteLine("// " + comment);
}
protected override void DecompileFields(Language language, ITextOutput output)
{
var cols = tablesStreamVM.TableInfo.Columns;
language.WriteCommentLine(output, string.Empty);
language.WriteComment(output, string.Empty);
output.Write("RID\tToken\tOffset", TextTokenType.Comment);
for (int i = 0; i < cols.Count; i++) {
output.Write('\t', TextTokenType.Comment);
output.Write(tablesStreamVM.GetColumnName(i), TextTokenType.Comment);
}
if (tablesStreamVM.HasInfo) {
output.Write('\t', TextTokenType.Comment);
output.Write(tablesStreamVM.InfoName, TextTokenType.Comment);
}
output.WriteLine();
for (int i = 0; i < (int)tablesStreamVM.Rows; i++) {
var obj = tablesStreamVM.Get(i);
language.WriteComment(output, string.Empty);
output.Write(obj.RidString, TextTokenType.Comment);
output.Write('\t', TextTokenType.Comment);
output.Write(obj.TokenString, TextTokenType.Comment);
output.Write('\t', TextTokenType.Comment);
output.Write(obj.OffsetString, TextTokenType.Comment);
for (int j = 0; j < cols.Count; j++) {
output.Write('\t', TextTokenType.Comment);
output.Write(obj.GetField(j).DataFieldVM.StringValue, TextTokenType.Comment);
}
if (tablesStreamVM.HasInfo) {
output.Write('\t', TextTokenType.Comment);
output.Write(obj.Info, TextTokenType.Comment);
}
output.WriteLine();
}
}
public override void Decompile(Language language, ITextOutput output, DecompilationOptions options)
{
language.WriteCommentLine(output, "List: " + assemblyList.ListName);
output.WriteLine();
foreach (AssemblyTreeNode asm in this.Children) {
language.WriteCommentLine(output, new string('-', 60));
output.WriteLine();
asm.Decompile(language, output, options);
}
}
