public NodeDecompiler(Func<Func<object>, object> execInThread, ITextOutput output, ILanguage language, DecompilationContext decompilationContext, IDecompileNodeContext decompileNodeContext = null)
{
this.execInThread = execInThread;
this.output = output;
this.language = language;
this.decompilationContext = decompilationContext;
this.decompileNodeContext = decompileNodeContext;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="type">Type</param>
/// <param name="output">Output</param>
/// <param name="ctx">Context</param>
public DecompilePartialType(TypeDef type, ITextOutput output, DecompilationContext ctx)
: base(output, ctx) {
if (type == null)
throw new ArgumentNullException();
this.Type = type;
this.AddPartialKeyword = true;
this.UseUsingDeclarations = true;
this.definitions = new HashSet<IMemberDef>();
this.interfacesToRemove = new List<ITypeDefOrRef>();
}
public ProjectModuleOptions(ModuleDef module, ILanguage language, DecompilationContext decompilationContext) {
if (language == null || decompilationContext == null || module == null)
throw new ArgumentNullException();
this.Module = module;
this.Language = language;
this.DecompilationContext = decompilationContext;
this.ProjectGuid = Guid.NewGuid();
this.UnpackResources = true;
this.CreateResX = true;
this.DecompileXaml = true;
}
public virtual void DecompileNamespace(string @namespace, IEnumerable<TypeDef> types, ITextOutput output, DecompilationContext ctx) {
this.WriteCommentLine(output, string.IsNullOrEmpty(@namespace) ? string.Empty : IdentifierEscaper.Escape(@namespace));
this.WriteCommentLine(output, string.Empty);
this.WriteCommentLine(output, Languages_Resources.Decompile_Namespace_Types);
this.WriteCommentLine(output, string.Empty);
foreach (var type in types) {
this.WriteCommentBegin(output, true);
output.WriteReference(IdentifierEscaper.Escape(type.Name), type, TextTokenKind.Comment);
this.WriteCommentEnd(output, true);
output.WriteLine();
}
}
public virtual void Decompile(MethodDef method, ITextOutput output, DecompilationContext ctx) {
this.WriteCommentLine(output, TypeToString(method.DeclaringType, true) + "." + method.Name);
}
void DecompileInternal(ModuleDef mod, ITextOutput output, DecompilationContext ctx) {
this.WriteCommentLine(output, mod.Location);
this.WriteCommentLine(output, mod.Name);
}
ReflectionDisassembler CreateReflectionDisassembler(ITextOutput output, DecompilationContext ctx, IMemberDef member)
{
return CreateReflectionDisassembler(output, ctx, member.Module);
}
public override void Decompile(MethodDef method, ITextOutput output, DecompilationContext ctx) {
WriteCommentLineDeclaringType(output, method);
var state = CreateAstBuilder(ctx, langSettings.Settings, currentType: method.DeclaringType, isSingleMember: true);
try {
if (method.IsConstructor && !method.IsStatic && !method.DeclaringType.IsValueType) {
// also fields and other ctors so that the field initializers can be shown as such
AddFieldsAndCtors(state.AstBuilder, method.DeclaringType, method.IsStatic);
RunTransformsAndGenerateCode(ref state, output, ctx, new SelectCtorTransform(method));
}
else {
state.AstBuilder.AddMethod(method);
RunTransformsAndGenerateCode(ref state, output, ctx);
}
}
finally {
state.Dispose();
}
}
public BuilderState(DecompilationContext ctx, BuilderCache cache)
{
this.ctx = ctx;
this.cache = cache;
this.State = cache.AllocateAstBuilderState();
}
BuilderState CreateAstBuilder(DecompilationContext ctx, DecompilerSettings settings, ModuleDef currentModule = null, TypeDef currentType = null, bool isSingleMember = false) {
if (currentModule == null)
currentModule = currentType.Module;
if (isSingleMember) {
settings = settings.Clone();
settings.UsingDeclarations = false;
}
var cache = ctx.GetOrCreate<BuilderCache>();
var state = new BuilderState(ctx, cache);
state.AstBuilder.Context.CurrentModule = currentModule;
state.AstBuilder.Context.CancellationToken = ctx.CancellationToken;
state.AstBuilder.Context.CurrentType = currentType;
state.AstBuilder.Context.Settings = settings;
return state;
}
public virtual void Decompile(EventDef ev, ITextOutput output, DecompilationContext ctx) {
this.WriteCommentLine(output, TypeToString(ev.DeclaringType, true) + "." + ev.Name);
}
void RunTransformsAndGenerateCode(ref BuilderState state, ITextOutput output, DecompilationContext ctx, IAstTransform additionalTransform = null) {
var astBuilder = state.AstBuilder;
astBuilder.RunTransformations(transformAbortCondition);
if (additionalTransform != null) {
additionalTransform.Run(astBuilder.SyntaxTree);
}
AddXmlDocumentation(ref state, langSettings.Settings, astBuilder);
astBuilder.GenerateCode(output);
}
public override void Decompile(ModuleDef mod, ITextOutput output, DecompilationContext ctx) {
WriteModule(mod, output, ctx);
using (ctx.DisableAssemblyLoad()) {
var state = CreateAstBuilder(ctx, langSettings.Settings, currentModule: mod);
try {
state.AstBuilder.AddAssembly(mod, true, false, true);
RunTransformsAndGenerateCode(ref state, output, ctx);
}
finally {
state.Dispose();
}
}
}
public override void Decompile(TypeDef type, ITextOutput output, DecompilationContext ctx) {
var state = CreateAstBuilder(ctx, langSettings.Settings, currentType: type);
try {
state.AstBuilder.AddType(type);
RunTransformsAndGenerateCode(ref state, output, ctx);
}
finally {
state.Dispose();
}
}
public override void Decompile(EventDef ev, ITextOutput output, DecompilationContext ctx) {
WriteCommentLineDeclaringType(output, ev);
var state = CreateAstBuilder(ctx, langSettings.Settings, currentType: ev.DeclaringType, isSingleMember: true);
try {
state.AstBuilder.AddEvent(ev);
RunTransformsAndGenerateCode(ref state, output, ctx);
}
finally {
state.Dispose();
}
}
public override void Decompile(FieldDef field, ITextOutput output, DecompilationContext ctx) {
WriteCommentLineDeclaringType(output, field);
var state = CreateAstBuilder(ctx, langSettings.Settings, currentType: field.DeclaringType, isSingleMember: true);
try {
if (field.IsLiteral) {
state.AstBuilder.AddField(field);
}
else {
// also decompile ctors so that the field initializer can be shown
AddFieldsAndCtors(state.AstBuilder, field.DeclaringType, field.IsStatic);
}
RunTransformsAndGenerateCode(ref state, output, ctx, new SelectFieldTransform(field));
}
finally {
state.Dispose();
}
}
public virtual void Decompile(PropertyDef property, ITextOutput output, DecompilationContext ctx) {
this.WriteCommentLine(output, TypeToString(property.DeclaringType, true) + "." + property.Name);
}
public WinFormsProjectFile(TypeDef type, string filename, DecompilationContext decompilationContext, ILanguage language)
: base(type, filename, decompilationContext, language) {
this.SubType = "Form";
}
public virtual void Decompile(FieldDef field, ITextOutput output, DecompilationContext ctx) {
this.WriteCommentLine(output, TypeToString(field.DeclaringType, true) + "." + field.Name);
}
protected void WriteModule(ModuleDef mod, ITextOutput output, DecompilationContext ctx) {
DecompileInternal(mod, output, ctx);
output.WriteLine();
if (mod.Types.Count > 0) {
this.WriteCommentBegin(output, true);
output.Write(Languages_Resources.Decompile_GlobalType + " ", TextTokenKind.Comment);
output.WriteReference(IdentifierEscaper.Escape(mod.GlobalType.FullName), mod.GlobalType, TextTokenKind.Comment);
output.WriteLine();
}
this.PrintEntryPoint(mod, output);
this.WriteCommentLine(output, Languages_Resources.Decompile_Architecture + " " + GetPlatformDisplayName(mod));
if (!mod.IsILOnly) {
this.WriteCommentLine(output, Languages_Resources.Decompile_ThisAssemblyContainsUnmanagedCode);
}
string runtimeName = GetRuntimeDisplayName(mod);
if (runtimeName != null) {
this.WriteCommentLine(output, Languages_Resources.Decompile_Runtime + " " + runtimeName);
}
var peImage = TryGetPEImage(mod);
if (peImage != null) {
this.WriteCommentBegin(output, true);
uint ts = peImage.ImageNTHeaders.FileHeader.TimeDateStamp;
var date = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddSeconds(ts);
var dateString = date.ToString(CultureInfo.CurrentUICulture.DateTimeFormat);
output.Write(string.Format(Languages_Resources.Decompile_Timestamp, ts, dateString), TextTokenKind.Comment);
this.WriteCommentEnd(output, true);
output.WriteLine();
}
output.WriteLine();
}
public virtual void Decompile(TypeDef type, ITextOutput output, DecompilationContext ctx) {
this.WriteCommentLine(output, TypeToString(type, true));
}
public AssemblyInfoProjectFile(ModuleDef module, string filename, DecompilationContext decompilationContext, ILanguage language) {
this.module = module;
this.filename = filename;
this.decompilationContext = decompilationContext;
this.language = language;
}
protected void WriteAssembly(AssemblyDef asm, ITextOutput output, DecompilationContext ctx) {
DecompileInternal(asm, output, ctx);
output.WriteLine();
this.PrintEntryPoint(asm.ManifestModule, output);
var peImage = TryGetPEImage(asm.ManifestModule);
if (peImage != null) {
this.WriteCommentBegin(output, true);
uint ts = peImage.ImageNTHeaders.FileHeader.TimeDateStamp;
var date = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddSeconds(ts);
var dateString = date.ToString(CultureInfo.CurrentUICulture.DateTimeFormat);
output.Write(string.Format(Languages_Resources.Decompile_Timestamp, ts, dateString), TextTokenKind.Comment);
this.WriteCommentEnd(output, true);
output.WriteLine();
}
output.WriteLine();
}
ReflectionDisassembler CreateReflectionDisassembler(ITextOutput output, DecompilationContext ctx, ModuleDef ownerModule)
{
var disOpts = new DisassemblerOptions(ctx.CancellationToken, ownerModule);
if (langSettings.Settings.ShowILComments)
disOpts.GetOpCodeDocumentation = ILLanguageHelper.GetOpCodeDocumentation;
if (langSettings.Settings.ShowXmlDocumentation)
disOpts.GetXmlDocComments = GetXmlDocComments;
disOpts.CreateInstructionBytesReader = m => InstructionBytesReader.Create(m, ctx.IsBodyModified != null && ctx.IsBodyModified(m));
disOpts.ShowTokenAndRvaComments = langSettings.Settings.ShowTokenAndRvaComments;
disOpts.ShowILBytes = langSettings.Settings.ShowILBytes;
disOpts.SortMembers = langSettings.Settings.SortMembers;
return new ReflectionDisassembler(output, detectControlStructure, disOpts);
}
public virtual void Decompile(AssemblyDef asm, ITextOutput output, DecompilationContext ctx) {
DecompileInternal(asm, output, ctx);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="module">Type</param>
/// <param name="output">Output</param>
/// <param name="ctx">Context</param>
public DecompileAssemblyInfo(ModuleDef module, ITextOutput output, DecompilationContext ctx)
: base(output, ctx) {
if (module == null)
throw new ArgumentNullException();
this.Module = module;
}
public void Execute(ExportToProjectVM vm)
{
vm.ProgressMinimum = 0;
vm.ProgressMaximum = 1;
vm.TotalProgress = 0;
vm.IsIndeterminate = false;
Task.Factory.StartNew(() => {
AppCulture.InitializeCulture();
var decompilationContext = new DecompilationContext {
CancellationToken = cancellationTokenSource.Token,
GetDisableAssemblyLoad = () => owner.fileTreeView.FileManager.DisableAssemblyLoad(),
};
var options = new ProjectCreatorOptions(vm.Directory, cancellationTokenSource.Token);
options.ProjectVersion = vm.ProjectVersion;
if (vm.CreateSolution)
options.SolutionFilename = vm.SolutionFilename;
options.Logger = this;
options.ProgressListener = this;
bool hasProjectGuid = vm.ProjectGuid.Value != null;
string guidFormat = null;
int guidNum = 0;
if (hasProjectGuid) {
string guidStr = vm.ProjectGuid.Value.ToString();
guidNum = int.Parse(guidStr.Substring(36 - 8, 8), NumberStyles.HexNumber);
guidFormat = guidStr.Substring(0, 36 - 8) + "{0:X8}";
}
foreach (var module in modules.OrderBy(a => a.Location, StringComparer.InvariantCultureIgnoreCase)) {
var projOpts = new ProjectModuleOptions(module, vm.Language, decompilationContext) {
DontReferenceStdLib = vm.DontReferenceStdLib,
UnpackResources = vm.UnpackResources,
CreateResX = vm.CreateResX,
DecompileXaml = vm.DecompileXaml,
ProjectGuid = hasProjectGuid ? new Guid(string.Format(guidFormat, guidNum++)) : Guid.NewGuid(),
};
if (bamlDecompiler != null) {
var o = BamlDecompilerOptions.Create(vm.Language);
projOpts.DecompileBaml = (a, b, c, d) => bamlDecompiler.Decompile(a, b, c, o, d);
}
options.ProjectModules.Add(projOpts);
}
var creator = new MSBuildProjectCreator(options);
creator.Create();
if (vm.CreateSolution)
fileToOpen = creator.SolutionFilename;
else
fileToOpen = creator.ProjectFilenames.FirstOrDefault();
}, cancellationTokenSource.Token)
.ContinueWith(t => {
var ex = t.Exception;
if (ex != null)
Error(string.Format(dnSpy_Resources.ErrorExceptionOccurred, ex));
EmtpyErrorList();
vm.OnExportComplete();
if (!vm.ExportErrors) {
dlg.Close();
if (vm.OpenProject)
OpenProject();
}
}, CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.FromCurrentSynchronizationContext());
}
public virtual void Decompile(ModuleDef mod, ITextOutput output, DecompilationContext ctx) {
DecompileInternal(mod, output, ctx);
}
public TypeProjectFile(TypeDef type, string filename, DecompilationContext decompilationContext, ILanguage language) {
this.type = type;
this.filename = filename;
this.decompilationContext = decompilationContext;
this.language = language;
}
void DecompileInternal(AssemblyDef asm, ITextOutput output, DecompilationContext ctx) {
this.WriteCommentLine(output, asm.ManifestModule.Location);
if (asm.IsContentTypeWindowsRuntime)
this.WriteCommentLine(output, asm.Name + " [WinRT]");
else
this.WriteCommentLine(output, asm.FullName);
}
