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 static string Disassemble <T>(this T member)
where T : class, IMemberDefinition
{
var writer = new PlainTextOutput();
var dasm = new ReflectionDisassembler(writer);
if (typeof(T) == typeof(EventDefinition))
{
dasm.DisassembleEvent(member as EventDefinition);
}
else if (typeof(T) == typeof(FieldDefinition))
{
dasm.DisassembleField(member as FieldDefinition);
}
else if (typeof(T) == typeof(PropertyDefinition))
{
dasm.DisassembleProperty(member as PropertyDefinition);
}
else if (typeof(T) == typeof(MethodDefinition))
{
dasm.DisassembleMethod(member as MethodDefinition);
}
else if (typeof(T) == typeof(TypeDefinition))
{
dasm.DisassembleType(member as TypeDefinition);
}
else
{
throw new NotImplementedException($"the type {typeof(T).FullName} cannot be disassembled.");
}
return(writer.ToString());
}
public static int Disassemble(ITextOutput output, WringOptions opts)
{
var files = opts.Files.Select(Path.GetFullPath).ToArray();
var dis = new ReflectionDisassembler(output, true, CancellationToken.None);
var resolver = new DefaultAssemblyResolver();
var dirs = files.Select(Path.GetDirectoryName).Distinct().ToArray();
Array.ForEach(dirs, resolver.AddSearchDirectory);
var rparm = new ReaderParameters
{
AssemblyResolver = resolver,
ReadSymbols = true
};
foreach (var file in files)
{
var ass = AssemblyDefinition.ReadAssembly(file, rparm);
output.WriteLine();
output.WriteLine($"{ass.FullName} ({file})");
output.WriteLine();
dis.WriteAssemblyHeader(ass);
output.WriteLine();
foreach (var module in ass.Modules)
{
dis.WriteModuleHeader(module);
output.WriteLine();
dis.WriteAssemblyReferences(module);
output.WriteLine();
dis.WriteModuleContents(module);
}
}
return(0);
}
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 static string Disassemble(string sourceFileName, string outputFile, AssemblerOptions asmOptions)
{
if (asmOptions.HasFlag(AssemblerOptions.UseOwnDisassembler))
{
using (ModuleDefinition module = ModuleDefinition.ReadModule(sourceFileName))
using (var writer = new StreamWriter(outputFile)) {
module.Name = Path.GetFileNameWithoutExtension(outputFile);
var output = new PlainTextOutput(writer);
ReflectionDisassembler rd = new ReflectionDisassembler(output, CancellationToken.None);
rd.DetectControlStructure = false;
rd.WriteAssemblyReferences(module);
if (module.Assembly != null)
{
rd.WriteAssemblyHeader(module.Assembly);
}
output.WriteLine();
rd.WriteModuleHeader(module, skipMVID: true);
output.WriteLine();
rd.WriteModuleContents(module);
}
return(outputFile);
}
string ildasmPath = SdkUtility.GetSdkPath("ildasm.exe");
ProcessStartInfo info = new ProcessStartInfo(ildasmPath);
info.Arguments = $"/nobar /utf8 /out=\"{outputFile}\" \"{sourceFileName}\"";
info.RedirectStandardError = true;
info.RedirectStandardOutput = true;
info.UseShellExecute = false;
Process process = Process.Start(info);
var outputTask = process.StandardOutput.ReadToEndAsync();
var errorTask = process.StandardError.ReadToEndAsync();
Task.WaitAll(outputTask, errorTask);
process.WaitForExit();
Console.WriteLine("output: " + outputTask.Result);
Console.WriteLine("errors: " + errorTask.Result);
// Unlike the .imagebase directive (which is a fixed value when compiling with /deterministic),
// the image base comment still varies... ildasm putting a random number here?
string il = File.ReadAllText(outputFile);
il = Regex.Replace(il, @"^// Image base: 0x[0-9A-F]+\r?\n", "", RegexOptions.Multiline);
// and while we're at it, also remove the MVID
il = Regex.Replace(il, @"^// MVID: \{[0-9A-F-]+\}\r?\n", "", RegexOptions.Multiline);
// and the ildasm version info (varies from system to system)
il = Regex.Replace(il, @"^// +Microsoft .* Disassembler\. +Version.*\r?\n", "", RegexOptions.Multiline);
// copyright header "All rights reserved" is dependent on system language
il = Regex.Replace(il, @"^// +Copyright .* Microsoft.*\r?\n", "", RegexOptions.Multiline);
// filename may contain full path
il = Regex.Replace(il, @"^// WARNING: Created Win32 resource file.*\r?\n", "", RegexOptions.Multiline);
File.WriteAllText(outputFile, il);
return(outputFile);
}
public void Decompile(Stream assemblyStream, TextWriter codeWriter)
{
var assembly = AssemblyDefinition.ReadAssembly(assemblyStream);
//#if DEBUG
//assembly.Write(@"d:\Temp\assembly\" + System.DateTime.Now.Ticks + "-il.dll");
//#endif
var output = new CustomizableIndentPlainTextOutput(codeWriter)
{
IndentationString = " "
};
var disassembler = new ReflectionDisassembler(output, false, CancellationToken.None);
foreach (TypeDefinition td in assembly.MainModule.Types)
{
// Skip a large helper class generated by Peachpie
if (td.Name == Pchp.Core.Context.ScriptInfo.ScriptTypeName)
{
continue;
}
disassembler.DisassembleType(td);
output.WriteLine();
}
}
public override void DecompileField(FieldDefinition field, ITextOutput output, DecompilationOptions options)
{
var dis = new ReflectionDisassembler(output, detectControlStructure, options.CancellationToken);
dis.DisassembleField(field);
NotifyDecompilationFinished(dis);
}
public static bool Write(IDecompilerOutput output, IMemberRef member) {
var method = member as IMethod;
if (method != null && method.IsMethod) {
method.WriteMethodTo(output);
return true;
}
var field = member as IField;
if (field != null && field.IsField) {
field.WriteFieldTo(output);
return true;
}
var prop = member as PropertyDef;
if (prop != null) {
var dis = new ReflectionDisassembler(output, false, new DisassemblerOptions(new System.Threading.CancellationToken(), null));
dis.DisassembleProperty(prop, false);
return true;
}
var evt = member as EventDef;
if (evt != null) {
var dis = new ReflectionDisassembler(output, false, new DisassemblerOptions(new System.Threading.CancellationToken(), null));
dis.DisassembleEvent(evt, false);
return true;
}
var type = member as ITypeDefOrRef;
if (type != null) {
type.WriteTo(output, ILNameSyntax.TypeName);
return true;
}
return false;
}
public static async Task <string> Disassemble(string sourceFileName, string outputFile, AssemblerOptions asmOptions)
{
if (asmOptions.HasFlag(AssemblerOptions.UseOwnDisassembler))
{
using (var peFileStream = new FileStream(sourceFileName, FileMode.Open, FileAccess.Read))
using (var peFile = new PEFile(sourceFileName, peFileStream))
using (var writer = new StringWriter())
{
var metadata = peFile.Metadata;
var output = new PlainTextOutput(writer);
ReflectionDisassembler rd = new ReflectionDisassembler(output, CancellationToken.None);
rd.AssemblyResolver = new UniversalAssemblyResolver(sourceFileName, true, null);
rd.DetectControlStructure = false;
rd.WriteAssemblyReferences(metadata);
if (metadata.IsAssembly)
{
rd.WriteAssemblyHeader(peFile);
}
output.WriteLine();
rd.WriteModuleHeader(peFile, skipMVID: true);
output.WriteLine();
rd.WriteModuleContents(peFile);
File.WriteAllText(outputFile, ReplacePrivImplDetails(writer.ToString()));
}
return(outputFile);
}
string ildasmPath = Path.Combine(
Path.GetDirectoryName(typeof(Tester).Assembly.Location),
"ildasm.exe");
var command = Cli.Wrap(ildasmPath)
.WithArguments($"/utf8 /out=\"{outputFile}\" \"{sourceFileName}\"")
.WithValidation(CommandResultValidation.None);
var result = await command.ExecuteBufferedAsync().ConfigureAwait(false);
Console.WriteLine("output: " + result.StandardOutput);
Console.WriteLine("errors: " + result.StandardError);
Assert.AreEqual(0, result.ExitCode, "ildasm failed");
// Unlike the .imagebase directive (which is a fixed value when compiling with /deterministic),
// the image base comment still varies... ildasm putting a random number here?
string il = File.ReadAllText(outputFile);
il = Regex.Replace(il, @"^// Image base: 0x[0-9A-F]+\r?\n", "", RegexOptions.Multiline);
// and while we're at it, also remove the MVID
il = Regex.Replace(il, @"^// MVID: \{[0-9A-F-]+\}\r?\n", "", RegexOptions.Multiline);
// and the ildasm version info (varies from system to system)
il = Regex.Replace(il, @"^// +Microsoft .* Disassembler\. +Version.*\r?\n", "", RegexOptions.Multiline);
// copyright header "All rights reserved" is dependent on system language
il = Regex.Replace(il, @"^// +Copyright .* Microsoft.*\r?\n", "", RegexOptions.Multiline);
// filename may contain full path
il = Regex.Replace(il, @"^// WARNING: Created Win32 resource file.*\r?\n", "", RegexOptions.Multiline);
il = ReplacePrivImplDetails(il);
File.WriteAllText(outputFile, il);
return(outputFile);
}
public override void DecompileAssembly(DnSpyFileList dnSpyFileList, DnSpyFile file, ITextOutput output, DecompilationOptions options, DecompileAssemblyFlags flags = DecompileAssemblyFlags.AssemblyAndModule)
{
bool decompileAsm = (flags & DecompileAssemblyFlags.Assembly) != 0;
bool decompileMod = (flags & DecompileAssemblyFlags.Module) != 0;
output.WriteLine("// " + file.Filename, TextTokenType.Comment);
if (decompileMod || decompileAsm)
{
PrintEntryPoint(file, output);
}
output.WriteLine();
ReflectionDisassembler rd = CreateReflectionDisassembler(output, options, file.ModuleDef);
if (decompileMod && options.FullDecompilation)
{
rd.WriteAssemblyReferences(file.ModuleDef);
}
if (decompileAsm && file.AssemblyDef != null)
{
rd.WriteAssemblyHeader(file.AssemblyDef);
}
if (decompileMod)
{
output.WriteLine();
rd.WriteModuleHeader(file.ModuleDef);
if (options.FullDecompilation)
{
output.WriteLine();
output.WriteLine();
rd.WriteModuleContents(file.ModuleDef);
}
}
}
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options)
{
if (options.AssemblyFileNameOnTop)
{
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, options.DecompilerSettings);
if (options.FullDecompilation)
{
output.WriteLine();
output.WriteLine();
rd.WriteModuleContents(assembly.ModuleDefinition);
}
}
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 static string ToMSIL(AssemblyDefinition assemblyDefinition)
{
var output = new StringWriter();
var disassembler = new ReflectionDisassembler(new PlainTextOutput(output), false, new CancellationToken());
disassembler.WriteModuleContents(assemblyDefinition.MainModule);
return(output.ToString());
}
public static string ToMSIL(PropertyDefinition propertyDefinition)
{
var output = new StringWriter();
var disassembler = new ReflectionDisassembler(new PlainTextOutput(output), false, new CancellationToken());
disassembler.DisassembleProperty(propertyDefinition);
return(output.ToString());
}
int ShowIL(string assemblyFileName, TextWriter output)
{
var module = new PEFile(assemblyFileName);
output.WriteLine($"// IL code: {module.Name}");
var disassembler = new ReflectionDisassembler(new PlainTextOutput(output), CancellationToken.None);
disassembler.WriteModuleContents(module);
return(0);
}
public override void Decompile(AssemblyDef asm, IDecompilerOutput output, DecompilationContext ctx)
{
output.WriteLine("// " + asm.ManifestModule.Location, BoxedTextColor.Comment);
PrintEntryPoint(asm.ManifestModule, output);
output.WriteLine();
ReflectionDisassembler rd = CreateReflectionDisassembler(output, ctx, asm.ManifestModule);
rd.WriteAssemblyHeader(asm);
}
public static List <ReferenceSegment> Disassemble(TextEditor data, Action <ReflectionDisassembler> setData)
{
var source = new CancellationTokenSource();
var output = new ColoredCSharpFormatter(data);
var disassembler = new ReflectionDisassembler(output, source.Token);
setData(disassembler);
output.SetDocumentData();
return(output.ReferencedSegments);
}
public void Decompile(Stream assemblyStream, TextWriter codeWriter)
{
var assembly = AssemblyDefinition.ReadAssembly(assemblyStream);
var output = new CustomizableIndentPlainTextOutput(codeWriter) {
IndentationString = " "
};
var disassembler = new ReflectionDisassembler(output, false, new CancellationToken());
disassembler.WriteModuleContents(assembly.MainModule);
}
private void Disassemble(Stream peStream)
{
using (var assembly = AssemblyDefinition.ReadAssembly(peStream)) {
var output = new PlainTextOutput();
var disassembler = new ReflectionDisassembler(output, false, CancellationToken.None);
disassembler.WriteModuleContents(assembly.MainModule);
Disassembled(new DisassembledMesssage {
IL = output.ToString()
});
}
}
public override void Decompile(ModuleDef mod, IDecompilerOutput output, DecompilationContext ctx)
{
output.WriteLine("// " + mod.Location, BoxedTextColor.Comment);
PrintEntryPoint(mod, output);
output.WriteLine();
ReflectionDisassembler rd = CreateReflectionDisassembler(output, ctx, mod);
output.WriteLine();
rd.WriteModuleHeader(mod);
}
public string DumpIL()
{
TextWriter ilWriter = new StringWriter();
var assemblyDefinition = AssemblyDefinition.ReadAssembly(this.dllStream);
var ilOutput = new PlainTextOutput(ilWriter);
var reflectionDisassembler = new ReflectionDisassembler(ilOutput, false, CancellationToken.None);
reflectionDisassembler.WriteModuleContents(assemblyDefinition.MainModule);
this.engine.UpdateLog("Dynamic assembly disassembled to IL.");
return(ilWriter.ToString());
}
public void Decompile(Stream assemblyStream, TextWriter codeWriter)
{
var assembly = AssemblyDefinition.ReadAssembly(assemblyStream);
var output = new CustomizableIndentPlainTextOutput(codeWriter)
{
IndentationString = " "
};
var disassembler = new ReflectionDisassembler(output, false, CancellationToken.None);
disassembler.WriteModuleContents(assembly.MainModule);
}
public void Decompile(Stream assemblyStream, TextWriter codeWriter)
{
var assembly = AssemblyDefinition.ReadAssembly(assemblyStream);
//#if DEBUG
//assembly.Write(@"d:\Temp\assembly\" + System.DateTime.Now.Ticks + "-il.dll");
//#endif
var output = new SpaceIndentingPlainTextOutput(codeWriter);
var disassembler = new ReflectionDisassembler(output, CancellationToken.None);
disassembler.WriteModuleContents(assembly.MainModule);
}
private void DecompileDllToIl(string dllFile, string ilPath)
{
var writer = File.CreateText(ilPath);
var output = new SpaceIndentingPlainTextOutput(writer);
var disassembler = new ReflectionDisassembler(output, CancellationToken.None)
{
ShowSequencePoints = true
};
var assemblyFile = new PEFile(dllFile);
disassembler.WriteModuleContents(assemblyFile);
writer.Close();
}
static void ShowIL(string assemblyFileName, TextWriter output, string[] referencePaths)
{
CSharpDecompiler decompiler = GetDecompiler(assemblyFileName, referencePaths);
ITextOutput textOutput = new PlainTextOutput();
ReflectionDisassembler disassembler = new ReflectionDisassembler(textOutput, CancellationToken.None);
disassembler.DisassembleNamespace(decompiler.TypeSystem.MainModule.RootNamespace.Name,
decompiler.TypeSystem.MainModule.PEFile,
decompiler.TypeSystem.MainModule.TypeDefinitions.Select(x => (TypeDefinitionHandle)x.MetadataToken));
output.WriteLine($"// IL code: {decompiler.TypeSystem.MainModule.AssemblyName}");
output.WriteLine(textOutput.ToString());
}
private static void GetAssemblyILCode(ReflectionDisassembler disassembler, string assemblyPath, MetadataModule module, ITextOutput output)
{
output.WriteLine("// " + assemblyPath);
output.WriteLine();
var peFile = module.PEFile;
var metadata = peFile.Metadata;
disassembler.WriteAssemblyReferences(metadata);
if (metadata.IsAssembly)
{
disassembler.WriteAssemblyHeader(peFile);
}
output.WriteLine();
disassembler.WriteModuleHeader(peFile);
}
public override void DecompileModule(ModuleDefinition module, ITextOutput output, DecompilationOptions options)
{
output.WriteLine("// " + module.Name);
output.WriteLine();
ReflectionDisassembler rd = new ReflectionDisassembler(output, detectControlStructure, options.CancellationToken);
rd.WriteModuleHeader(module);
if (options.FullDecompilation)
{
output.WriteLine();
output.WriteLine();
rd.WriteModuleContents(module);
}
OnDecompilationFinished(null);
}
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 CodeViewData Run(IDnlibDef item, CancellationToken token) {
try {
var output = new CodeViewOutput();
var disassembler = new ReflectionDisassembler(output, true, token);
DoDisassemble(item, output, disassembler);
return output.GetResult();
}
catch {
// Retry if ILStructure failed.
var output = new CodeViewOutput();
output.WriteComment("// ILStructure failed!");
output.WriteLine();
var disassembler = new ReflectionDisassembler(output, false, token);
DoDisassemble(item, output, disassembler);
return output.GetResult();
}
}
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 static bool Write(ITextOutput output, IMemberRef member)
{
var method = member as IMethod;
if (method != null && method.IsMethod)
{
method.WriteMethodTo(output);
return(true);
}
var field = member as IField;
if (field != null && field.IsField)
{
field.WriteFieldTo(output);
return(true);
}
var prop = member as PropertyDef;
if (prop != null)
{
var dis = new ReflectionDisassembler(output, false, new DisassemblerOptions(new System.Threading.CancellationToken(), null));
dis.DisassembleProperty(prop, false);
return(true);
}
var evt = member as EventDef;
if (evt != null)
{
var dis = new ReflectionDisassembler(output, false, new DisassemblerOptions(new System.Threading.CancellationToken(), null));
dis.DisassembleEvent(evt, false);
return(true);
}
var type = member as ITypeDefOrRef;
if (type != null)
{
type.WriteTo(output, ILNameSyntax.TypeName);
return(true);
}
return(false);
}
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 static string Disassemble(string sourceFileName, string outputFile, AssemblerOptions asmOptions)
{
if (asmOptions.HasFlag(AssemblerOptions.UseOwnDisassembler))
{
using (ModuleDefinition module = ModuleDefinition.ReadModule(sourceFileName))
using (var writer = new StreamWriter(outputFile)) {
module.Name = Path.GetFileNameWithoutExtension(outputFile);
var output = new PlainTextOutput(writer);
ReflectionDisassembler rd = new ReflectionDisassembler(output, CancellationToken.None);
rd.DetectControlStructure = false;
rd.WriteAssemblyReferences(module);
if (module.Assembly != null)
{
rd.WriteAssemblyHeader(module.Assembly);
}
output.WriteLine();
rd.WriteModuleHeader(module);
output.WriteLine();
rd.WriteModuleContents(module);
}
return(outputFile);
}
string ildasmPath = SdkUtility.GetSdkPath("ildasm.exe");
ProcessStartInfo info = new ProcessStartInfo(ildasmPath);
info.Arguments = $"/out=\"{outputFile}\" \"{sourceFileName}\"";
info.RedirectStandardError = true;
info.RedirectStandardOutput = true;
info.UseShellExecute = false;
Process process = Process.Start(info);
var outputTask = process.StandardOutput.ReadToEndAsync();
var errorTask = process.StandardError.ReadToEndAsync();
Task.WaitAll(outputTask, errorTask);
process.WaitForExit();
Console.WriteLine("output: " + outputTask.Result);
Console.WriteLine("errors: " + errorTask.Result);
return(outputFile);
}
private static ReflectionDisassembler CreateDisassembler(string assemblyPath, MetadataModule module, ITextOutput textOutput)
{
var dis = new ReflectionDisassembler(textOutput, CancellationToken.None)
{
DetectControlStructure = true,
ShowSequencePoints = false,
ShowMetadataTokens = true,
ExpandMemberDefinitions = true,
};
var resolver = new UniversalAssemblyResolver(assemblyPath,
throwOnError: true,
targetFramework: module.PEFile.Reader.DetectTargetFrameworkId());
dis.AssemblyResolver = resolver;
dis.DebugInfo = null;
return(dis);
}
public CodeViewData Run(IDnlibDef item, CancellationToken token)
{
try {
var output = new CodeViewOutput();
var disassembler = new ReflectionDisassembler(output, true, token);
DoDisassemble(item, output, disassembler);
return(output.GetResult());
}
catch {
// Retry if ILStructure failed.
var output = new CodeViewOutput();
output.WriteComment("// ILStructure failed!");
output.WriteLine();
var disassembler = new ReflectionDisassembler(output, false, token);
DoDisassemble(item, output, disassembler);
return(output.GetResult());
}
}
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();
ReflectionDisassembler rd = new ReflectionDisassembler(output, detectControlStructure, options.CancellationToken);
if (options.FullDecompilation)
rd.WriteAssemblyReferences(assembly.AssemblyDefinition.MainModule);
rd.WriteAssemblyHeader(assembly.AssemblyDefinition);
output.WriteLine();
if (options.FullDecompilation) {
foreach (var m in assembly.AssemblyDefinition.Modules)
DecompileModule(m, output, options);
}
OnDecompilationFinished(null);
}
public override void DecompileModule(ModuleDefinition module, ITextOutput output, DecompilationOptions options)
{
output.WriteLine("// " + module.Name);
output.WriteLine();
ReflectionDisassembler rd = new ReflectionDisassembler(output, detectControlStructure, options.CancellationToken);
rd.WriteModuleHeader(module);
if (options.FullDecompilation)
{
output.WriteLine();
output.WriteLine();
rd.WriteModuleContents(module);
}
OnDecompilationFinished(null);
}
//wicky.patch.start
public override void DecompileAssembly(AssemblyDefinition assembly, ITextOutput output, DecompilationOptions options)
{
output.WriteLine("// " + assembly.MainModule.FullyQualifiedName);
output.WriteLine();
ReflectionDisassembler rd = new ReflectionDisassembler(output, detectControlStructure, options.CancellationToken);
if (options.FullDecompilation)
rd.WriteAssemblyReferences(assembly.MainModule);
rd.WriteAssemblyHeader(assembly);
output.WriteLine();
rd.WriteModuleHeader(assembly.MainModule);
if (options.FullDecompilation) {
output.WriteLine();
output.WriteLine();
rd.WriteModuleContents(assembly.MainModule);
}
}
public override void DecompileType(TypeDef type, ITextOutput output, DecompilationOptions options)
{
var dis = new ReflectionDisassembler(output, detectControlStructure, options.CancellationToken);
dis.DisassembleType(type);
}
public override void DecompileField(FieldDefinition field, ITextOutput output, DecompilationOptions options)
{
var dis = new ReflectionDisassembler(output, detectControlStructure, options.CancellationToken);
dis.DisassembleField(field);
}
public static List<ReferenceSegment> Disassemble (TextEditorData data, Action<ReflectionDisassembler> setData)
{
var source = new CancellationTokenSource ();
var output = new ColoredCSharpFormatter (data.Document);
var disassembler = new ReflectionDisassembler (output, true, source.Token);
setData (disassembler);
output.SetDocumentData ();
return output.ReferencedSegments;
}
public override void DecompileMethod(MethodDefinition method, ITextOutput output, DecompilationOptions options)
{
var dis = new ReflectionDisassembler(output, detectControlStructure, options.CancellationToken);
dis.DisassembleMethod(method);
NotifyDecompilationFinished(dis);
}
