private WorkItem DecompileSourceFile(DecompilerTypeSystem ts, IGrouping <string, TypeDefinitionHandle> src, string projectName, string conditional = null)
{
return(new WorkItem("Decompiling: " + src.Key, updateStatus =>
{
var path = Path.Combine(srcDir, projectName, src.Key);
CreateParentDirectory(path);
using (var w = new StringWriter())
{
if (conditional != null)
{
w.WriteLine("#if " + conditional);
}
CreateDecompiler(ts)
.DecompileTypes(src.ToArray())
.AcceptVisitor(new CSharpOutputVisitor(w, projectDecompiler.Settings.CSharpFormattingOptions));
if (conditional != null)
{
w.WriteLine("#endif");
}
string source = w.ToString();
if (formatOutput)
{
updateStatus("Formatting: " + src.Key);
source = FormatTask.Format(source, taskInterface.CancellationToken, true);
}
File.WriteAllText(path, source);
}
}));
}
public static string DecompileCSharp(string assemblyFileName, DecompilerSettings settings = null)
{
if (settings == null)
{
settings = new DecompilerSettings();
}
using (var file = new FileStream(assemblyFileName, FileMode.Open, FileAccess.Read)) {
var module = new PEFile(assemblyFileName, file, PEStreamOptions.PrefetchEntireImage);
var resolver = new UniversalAssemblyResolver(assemblyFileName, false,
module.Reader.DetectTargetFrameworkId(), PEStreamOptions.PrefetchMetadata);
resolver.AddSearchDirectory(Path.GetDirectoryName(typeof(Span <>).Assembly.Location));
var typeSystem = new DecompilerTypeSystem(module, resolver, settings);
CSharpDecompiler decompiler = new CSharpDecompiler(typeSystem, settings);
decompiler.AstTransforms.Insert(0, new RemoveEmbeddedAttributes());
decompiler.AstTransforms.Insert(0, new RemoveCompilerAttribute());
decompiler.AstTransforms.Insert(0, new RemoveNamespaceMy());
decompiler.AstTransforms.Add(new EscapeInvalidIdentifiers());
var syntaxTree = decompiler.DecompileWholeModuleAsSingleFile(sortTypes: true);
StringWriter output = new StringWriter();
var visitor = new CSharpOutputVisitor(output, FormattingOptionsFactory.CreateSharpDevelop());
syntaxTree.AcceptVisitor(visitor);
string fileName = Path.GetTempFileName();
File.WriteAllText(fileName, output.ToString());
return(fileName);
}
}
/// <summary>
/// Jumps to the specified reference.
/// </summary>
/// <returns>
/// Returns a task that will signal completion when the decompilation of the jump target has finished.
/// The task will be marked as canceled if the decompilation is canceled.
/// </returns>
public Task JumpToReferenceAsync(object reference)
{
decompilationTask = TaskHelper.CompletedTask;
switch (reference)
{
case Decompiler.Disassembler.OpCodeInfo opCode:
OpenLink(opCode.Link);
break;
case ValueTuple <PEFile, System.Reflection.Metadata.EntityHandle> unresolvedEntity:
var typeSystem = new DecompilerTypeSystem(unresolvedEntity.Item1, unresolvedEntity.Item1.GetAssemblyResolver(),
TypeSystemOptions.Default | TypeSystemOptions.Uncached);
reference = typeSystem.MainModule.ResolveEntity(unresolvedEntity.Item2);
goto default;
default:
ILSpyTreeNode treeNode = FindTreeNode(reference);
if (treeNode != null)
{
SelectNode(treeNode);
}
break;
}
return(decompilationTask);
}
public IEnumerable <ITypeDefinition> GetTypesInScope(CancellationToken ct)
{
if (IsLocal)
{
var typeSystem = new DecompilerTypeSystem(TypeScope.ParentModule.PEFile, TypeScope.ParentModule.PEFile.GetAssemblyResolver());
ITypeDefinition scope = typeScope;
if (memberAccessibility != Accessibility.Private && typeScope.DeclaringTypeDefinition != null)
{
scope = typeScope.DeclaringTypeDefinition;
}
foreach (var type in TreeTraversal.PreOrder(scope, t => t.NestedTypes))
{
yield return(type);
}
}
else
{
foreach (var module in GetModulesInScope(ct))
{
var typeSystem = new DecompilerTypeSystem(module, module.GetAssemblyResolver());
foreach (var type in typeSystem.MainModule.TypeDefinitions)
{
yield return(type);
}
}
}
}
public AssemblyLoader(AssemblyBrowserWidget widget, string fileName)
{
if (widget == null)
{
throw new ArgumentNullException(nameof(widget));
}
if (fileName == null)
{
throw new ArgumentNullException(nameof(fileName));
}
this.widget = widget;
FileName = fileName;
if (!File.Exists(fileName))
{
throw new ArgumentException("File doesn't exist.", nameof(fileName));
}
assemblyDefinitionTaskSource = new TaskCompletionSource <AssemblyDefinition>();
assemblyLoaderTask = Task.Run(() => {
try {
var assemblyDefinition = AssemblyDefinition.ReadAssembly(FileName, new ReaderParameters {
AssemblyResolver = this
});
assemblyDefinitionTaskSource.SetResult(assemblyDefinition);
DecompilerTypeSystem = new DecompilerTypeSystem(assemblyDefinition.MainModule);
var loadedAssembly = DecompilerTypeSystem.MainAssembly.UnresolvedAssembly;
return(Tuple.Create(assemblyDefinition, loadedAssembly));
}
catch (Exception e) {
LoggingService.LogError("Error while reading assembly " + FileName, e);
return(null);
}
});
}
private DecompilerTypeSystem AddModule(PEFile module, IAssemblyResolver resolver, List <WorkItem> items, ISet <string> sourceSet, ISet <string> resourceSet, ICollection <string> exclude = null, string conditional = null)
{
var projectDir = GetAssemblyTitle(module);
var sources = GetCodeFiles(module).ToList();
var resources = GetResourceFiles(module).ToList();
if (exclude != null)
{
sources.RemoveAll(src => exclude.Contains(src.Key));
resources.RemoveAll(res => exclude.Contains(res.path));
}
var ts = new DecompilerTypeSystem(module, resolver, decompilerSettings);
items.AddRange(sources
.Where(src => sourceSet.Add(src.Key))
.Select(src => DecompileSourceFile(ts, src, projectDir, conditional)));
if (conditional != null && resources.Any(res => !resourceSet.Contains(res.path)))
{
throw new Exception($"Conditional ({conditional}) resources not supported");
}
items.AddRange(resources
.Where(res => resourceSet.Add(res.path))
.Select(res => ExtractResource(res.path, res.r, projectDir)));
return(ts);
}
ISymbol GetParentEntity(DecompilerTypeSystem ts, CustomAttribute customAttribute)
{
var metadata = ts.MainModule.PEFile.Metadata;
switch (customAttribute.Parent.Kind)
{
case HandleKind.MethodDefinition:
case HandleKind.FieldDefinition:
case HandleKind.PropertyDefinition:
case HandleKind.EventDefinition:
case HandleKind.TypeDefinition:
return(ts.MainModule.ResolveEntity(customAttribute.Parent));
case HandleKind.AssemblyDefinition:
case HandleKind.ModuleDefinition:
return(ts.MainModule);
case HandleKind.GenericParameterConstraint:
var gpc = metadata.GetGenericParameterConstraint((GenericParameterConstraintHandle)customAttribute.Parent);
var gp = metadata.GetGenericParameter(gpc.Parameter);
return(ts.MainModule.ResolveEntity(gp.Parent));
case HandleKind.GenericParameter:
gp = metadata.GetGenericParameter((GenericParameterHandle)customAttribute.Parent);
return(ts.MainModule.ResolveEntity(gp.Parent));
default:
return(null);
}
}
CSharpDecompiler CreateDecompiler(DecompilerTypeSystem ts)
{
var decompiler = new CSharpDecompiler(ts, settings);
decompiler.AstTransforms.Add(new EscapeInvalidIdentifiers());
decompiler.AstTransforms.Add(new RemoveCLSCompliantAttribute());
return(decompiler);
}
internal TransformContext(DecompilerTypeSystem typeSystem, ITypeResolveContext decompilationContext, TypeSystemAstBuilder typeSystemAstBuilder, DecompilerSettings settings, CancellationToken cancellationToken)
{
this.TypeSystem = typeSystem;
this.decompilationContext = decompilationContext;
this.TypeSystemAstBuilder = typeSystemAstBuilder;
this.Settings = settings;
this.CancellationToken = cancellationToken;
}
IEnumerable <ISymbol> HandleCustomAttribute(ITypeDefinition attributeType, AnalyzerScope scope)
{
var genericContext = new GenericContext(); // type arguments do not matter for this analyzer.
foreach (var module in scope.GetAllModules())
{
var ts = new DecompilerTypeSystem(module, module.GetAssemblyResolver());
var referencedParameters = new HashSet <ParameterHandle>();
foreach (var h in module.Metadata.CustomAttributes)
{
var customAttribute = module.Metadata.GetCustomAttribute(h);
var attributeCtor = ts.MainModule.ResolveMethod(customAttribute.Constructor, genericContext);
if (attributeCtor.DeclaringTypeDefinition != null &&
attributeCtor.ParentModule.PEFile == attributeType.ParentModule.PEFile &&
attributeCtor.DeclaringTypeDefinition.MetadataToken == attributeType.MetadataToken)
{
if (customAttribute.Parent.Kind == HandleKind.Parameter)
{
referencedParameters.Add((ParameterHandle)customAttribute.Parent);
}
else
{
var parent = GetParentEntity(ts, customAttribute);
if (parent != null)
{
yield return(parent);
}
}
}
}
if (referencedParameters.Count > 0)
{
foreach (var h in module.Metadata.MethodDefinitions)
{
var md = module.Metadata.GetMethodDefinition(h);
foreach (var p in md.GetParameters())
{
if (referencedParameters.Contains(p))
{
var method = ts.MainModule.ResolveMethod(h, genericContext);
if (method != null)
{
if (method.IsAccessor)
{
yield return(method.AccessorOwner);
}
else
{
yield return(method);
}
}
break;
}
}
}
}
}
}
internal TransformContext(DecompilerTypeSystem typeSystem, DecompileRun decompileRun, ITypeResolveContext decompilationContext, TypeSystemAstBuilder typeSystemAstBuilder)
{
this.TypeSystem = typeSystem;
this.DecompileRun = decompileRun;
this.decompilationContext = decompilationContext;
this.TypeSystemAstBuilder = typeSystemAstBuilder;
this.CancellationToken = decompileRun.CancellationToken;
this.Settings = decompileRun.Settings;
}
public override void DecompileMethod(IMethod method, ITextOutput output, DecompilationOptions options)
{
base.DecompileMethod(method, output, options);
var module = method.ParentModule.PEFile;
var metadata = module.Metadata;
var methodDef = metadata.GetMethodDefinition((SRM.MethodDefinitionHandle)method.MetadataToken);
if (!methodDef.HasBody())
{
return;
}
IAssemblyResolver assemblyResolver = module.GetAssemblyResolver();
var typeSystem = new DecompilerTypeSystem(module, assemblyResolver);
var reader = new ILReader(typeSystem.MainModule);
reader.UseDebugSymbols = options.DecompilerSettings.UseDebugSymbols;
var methodBody = module.Reader.GetMethodBody(methodDef.RelativeVirtualAddress);
ILFunction il = reader.ReadIL((SRM.MethodDefinitionHandle)method.MetadataToken, methodBody, kind: ILFunctionKind.TopLevelFunction, cancellationToken: options.CancellationToken);
var decompiler = new CSharpDecompiler(typeSystem, options.DecompilerSettings)
{
CancellationToken = options.CancellationToken
};
ILTransformContext context = decompiler.CreateILTransformContext(il);
context.Stepper.StepLimit = options.StepLimit;
context.Stepper.IsDebug = options.IsDebug;
try
{
il.RunTransforms(transforms, context);
}
catch (StepLimitReachedException)
{
}
catch (Exception ex)
{
output.WriteLine(ex.ToString());
output.WriteLine();
output.WriteLine("ILAst after the crash:");
}
finally
{
// update stepper even if a transform crashed unexpectedly
if (options.StepLimit == int.MaxValue)
{
Stepper = context.Stepper;
OnStepperUpdated(new EventArgs());
}
}
(output as ISmartTextOutput)?.AddButton(Images.ViewCode, "Show Steps", delegate {
Docking.DockWorkspace.Instance.ShowToolPane(DebugStepsPaneModel.PaneContentId);
});
output.WriteLine();
il.WriteTo(output, DebugSteps.Options);
}
private CSharpDecompiler CreateDecompiler(DecompilerTypeSystem ts)
{
var decompiler = new CSharpDecompiler(ts, projectDecompiler.Settings)
{
CancellationToken = taskInterface.CancellationToken
};
decompiler.AstTransforms.Add(new EscapeInvalidIdentifiers());
decompiler.AstTransforms.Add(new RemoveCLSCompliantAttribute());
return(decompiler);
}
public override void DecompileMethod(MethodDefinition method, ITextOutput output, DecompilationOptions options)
{
base.DecompileMethod(method, output, options);
if (!method.HasBody)
{
return;
}
var typeSystem = new DecompilerTypeSystem(method.Module);
ILReader reader = new ILReader(typeSystem);
reader.WriteTypedIL(method.Body, output, options.CancellationToken);
}
public override string GetTooltip(MemberReference member)
{
var decompilerTypeSystem = new DecompilerTypeSystem(member.Module);
ISymbol symbol;
switch (member)
{
case MethodReference mr:
symbol = decompilerTypeSystem.Resolve(mr);
if (symbol == null)
{
return(base.GetTooltip(member));
}
break;
case PropertyReference pr:
symbol = decompilerTypeSystem.Resolve(pr);
if (symbol == null)
{
return(base.GetTooltip(member));
}
break;
case EventReference er:
symbol = decompilerTypeSystem.Resolve(er);
if (symbol == null)
{
return(base.GetTooltip(member));
}
break;
case FieldReference fr:
symbol = decompilerTypeSystem.Resolve(fr);
if (symbol == null)
{
return(base.GetTooltip(member));
}
break;
default:
return(base.GetTooltip(member));
}
var flags = ConversionFlags.All & ~ConversionFlags.ShowBody;
return(new CSharpAmbience()
{
ConversionFlags = flags
}.ConvertSymbol(symbol));
}
internal static void AddBaseTypes(SharpTreeNodeCollection children, PEFile module, ITypeDefinition typeDefinition)
{
TypeDefinitionHandle handle = (TypeDefinitionHandle)typeDefinition.MetadataToken;
DecompilerTypeSystem typeSystem = new DecompilerTypeSystem(module, module.GetAssemblyResolver(),
TypeSystemOptions.Default | TypeSystemOptions.Uncached);
var t = typeSystem.MainModule.ResolveEntity(handle) as ITypeDefinition;
foreach (var td in t.GetAllBaseTypeDefinitions().Reverse().Skip(1))
{
if (t.Kind != TypeKind.Interface || t.Kind == td.Kind)
{
children.Add(new BaseTypesEntryNode(td));
}
}
}
protected override void LoadChildren()
{
var module = LoadedAssembly.GetPEFileOrNull();
if (module == null)
{
// if we crashed on loading, then we don't have any children
return;
}
typeSystem = LoadedAssembly.GetTypeSystemOrNull(DecompilerTypeSystem.GetOptions(new DecompilationOptions().DecompilerSettings));
var assembly = (MetadataModule)typeSystem.MainModule;
var metadata = module.Metadata;
this.Children.Add(new Metadata.MetadataTreeNode(module, this));
Decompiler.DebugInfo.IDebugInfoProvider debugInfo = LoadedAssembly.GetDebugInfoOrNull();
if (debugInfo is Decompiler.PdbProvider.PortableDebugInfoProvider ppdb)
{
this.Children.Add(new Metadata.DebugMetadataTreeNode(module, ppdb.IsEmbedded, ppdb.Provider.GetMetadataReader(), this));
}
this.Children.Add(new ReferenceFolderTreeNode(module, this));
if (module.Resources.Any())
{
this.Children.Add(new ResourceListTreeNode(module));
}
foreach (NamespaceTreeNode ns in namespaces.Values)
{
ns.Children.Clear();
}
foreach (var type in assembly.TopLevelTypeDefinitions.OrderBy(t => t.ReflectionName, NaturalStringComparer.Instance))
{
var escapedNamespace = Language.EscapeName(type.Namespace);
if (!namespaces.TryGetValue(type.Namespace, out NamespaceTreeNode ns))
{
ns = new NamespaceTreeNode(escapedNamespace);
namespaces.Add(type.Namespace, ns);
}
TypeTreeNode node = new TypeTreeNode(type, this);
typeDict[(TypeDefinitionHandle)type.MetadataToken] = node;
ns.Children.Add(node);
}
foreach (NamespaceTreeNode ns in namespaces.Values.OrderBy(n => n.Name, NaturalStringComparer.Instance))
{
if (ns.Children.Count > 0)
{
this.Children.Add(ns);
}
}
}
IEnumerable<(string itemType, string fileName)> WriteAssemblyInfo(DecompilerTypeSystem ts, CancellationToken cancellationToken)
{
var decompiler = CreateDecompiler(ts);
decompiler.CancellationToken = cancellationToken;
decompiler.AstTransforms.Add(new RemoveCompilerGeneratedAssemblyAttributes());
SyntaxTree syntaxTree = decompiler.DecompileModuleAndAssemblyAttributes();
const string prop = "Properties";
if (directories.Add(prop))
Directory.CreateDirectory(Path.Combine(TargetDirectory, prop));
string assemblyInfo = Path.Combine(prop, "AssemblyInfo.cs");
using (StreamWriter w = new StreamWriter(Path.Combine(TargetDirectory, assemblyInfo)))
{
syntaxTree.AcceptVisitor(new CSharpOutputVisitor(w, Settings.CSharpFormattingOptions));
}
return new[] { ("Compile", assemblyInfo) };
public override void DecompileMethod(IMethod method, ITextOutput output, DecompilationOptions options)
{
base.DecompileMethod(method, output, options);
var module = method.ParentModule.PEFile;
var methodDef = module.Metadata.GetMethodDefinition((SRM.MethodDefinitionHandle)method.MetadataToken);
if (!methodDef.HasBody())
{
return;
}
var typeSystem = new DecompilerTypeSystem(module, module.GetAssemblyResolver());
ILReader reader = new ILReader(typeSystem.MainModule);
var methodBody = module.Reader.GetMethodBody(methodDef.RelativeVirtualAddress);
reader.WriteTypedIL((SRM.MethodDefinitionHandle)method.MetadataToken, methodBody, output, cancellationToken: options.CancellationToken);
}
IEnumerable <Tuple <string, string> > WriteCodeFilesInProject(Metadata.PEFile module, CancellationToken cancellationToken)
{
var metadata = module.Metadata;
var files = module.Metadata.GetTopLevelTypeDefinitions().Where(td => IncludeTypeWhenDecompilingProject(module, td)).GroupBy(
delegate(TypeDefinitionHandle h) {
var type = metadata.GetTypeDefinition(h);
string file = CleanUpFileName(metadata.GetString(type.Name)) + ".cs";
if (string.IsNullOrEmpty(metadata.GetString(type.Namespace)))
{
return(file);
}
else
{
string dir = CleanUpFileName(metadata.GetString(type.Namespace));
if (directories.Add(dir))
{
Directory.CreateDirectory(Path.Combine(targetDirectory, dir));
}
return(Path.Combine(dir, file));
}
}, StringComparer.OrdinalIgnoreCase).ToList();
int total = files.Count;
var progress = this.ProgressIndicator;
DecompilerTypeSystem ts = new DecompilerTypeSystem(module, AssemblyResolver, settings);
Parallel.ForEach(
files,
new ParallelOptions {
MaxDegreeOfParallelism = this.MaxDegreeOfParallelism,
CancellationToken = cancellationToken
},
delegate(IGrouping <string, TypeDefinitionHandle> file) {
using (StreamWriter w = new StreamWriter(Path.Combine(targetDirectory, file.Key))) {
try {
CSharpDecompiler decompiler = CreateDecompiler(ts);
decompiler.CancellationToken = cancellationToken;
var syntaxTree = decompiler.DecompileTypes(file.ToArray());
syntaxTree.AcceptVisitor(new CSharpOutputVisitor(w, settings.CSharpFormattingOptions));
} catch (Exception innerException) when(!(innerException is OperationCanceledException || innerException is DecompilerException))
{
throw new DecompilerException(module, $"Error decompiling for '{file.Key}'", innerException);
}
}
progress?.Report(new DecompilationProgress(total, file.Key));
});
return(files.Select(f => Tuple.Create("Compile", f.Key)).Concat(WriteAssemblyInfo(ts, cancellationToken)));
}
public override void DecompileMethod(MethodDefinition method, ITextOutput output, DecompilationOptions options)
{
base.DecompileMethod(method, output, options);
if (!method.HasBody)
{
return;
}
var typeSystem = new DecompilerTypeSystem(method.Module);
var specializingTypeSystem = typeSystem.GetSpecializingTypeSystem(new SimpleTypeResolveContext(typeSystem.Resolve(method)));
var reader = new ILReader(specializingTypeSystem);
reader.UseDebugSymbols = options.DecompilerSettings.UseDebugSymbols;
ILFunction il = reader.ReadIL(method.Body, options.CancellationToken);
ILTransformContext context = new ILTransformContext(il, typeSystem, options.DecompilerSettings)
{
CancellationToken = options.CancellationToken
};
context.Stepper.StepLimit = options.StepLimit;
context.Stepper.IsDebug = options.IsDebug;
try {
il.RunTransforms(transforms, context);
} catch (StepLimitReachedException) {
} catch (Exception ex) {
output.WriteLine(ex.ToString());
output.WriteLine();
output.WriteLine("ILAst after the crash:");
} finally {
// update stepper even if a transform crashed unexpectedly
if (options.StepLimit == int.MaxValue)
{
Stepper = context.Stepper;
OnStepperUpdated(new EventArgs());
}
}
(output as ISmartTextOutput)?.AddUIElement(OptionsCheckBox(nameof(writingOptions.UseFieldSugar)));
output.WriteLine();
(output as ISmartTextOutput)?.AddUIElement(OptionsCheckBox(nameof(writingOptions.UseLogicOperationSugar)));
output.WriteLine();
(output as ISmartTextOutput)?.AddButton(Images.ViewCode, "Show Steps", delegate {
DebugSteps.Show();
});
output.WriteLine();
il.WriteTo(output, writingOptions);
}
/// <summary>
/// Instianciates a CSharpDecompiler from a given assemblyfilename and applies decompilersettings
/// </summary>
/// <param name="assemblyFileName">path for assemblyfile to decompile</param>
/// <param name="settings">optional decompiler settings</param>
/// <returns>Instance of CSharpDecompiler</returns>
public CSharpDecompiler GetCSharpDecompiler(string assemblyFileName, DecompilerSettings settings = null)
{
if (settings == null)
{
settings = new DecompilerSettings();
}
using (var file = new FileStream(assemblyFileName, FileMode.Open, FileAccess.Read))
{
var module = new PEFile(assemblyFileName, file, PEStreamOptions.PrefetchEntireImage);
var resolver = new UniversalAssemblyResolver(assemblyFileName, false,
module.Reader.DetectTargetFrameworkId(), PEStreamOptions.PrefetchMetadata);
resolver.AddSearchDirectory(Path.GetDirectoryName(module.FullName));
var typeSystem = new DecompilerTypeSystem(module, resolver, settings);
var decompiler = new CSharpDecompiler(typeSystem, settings);
decompiler.DebugInfoProvider = DebugInfoLoader.LoadSymbols(module);
return(decompiler);
}
}
public static InterfaceInfo GetInterfaceInfo(DecompilerTypeSystem typeSystem, string typeName)
{
var type = DecompilerUtils.GetSelfDefinedWinmdToplevelTypes(typeSystem).Where(t => t.Kind == TypeKind.Interface && t.Name == typeName).Single();
InterfaceInfo ret = new InterfaceInfo()
{
Name = type.Name
};
List <string> protoTypes = new List <string>();
foreach (IMethod method in type.Methods)
{
protoTypes.Add(GetMethodPrototype(method));
}
ret.Methods = protoTypes.ToArray();
return(ret);
}
public static string DecompileCSharp(string assemblyFileName)
{
using (var module = ModuleDefinition.ReadModule(assemblyFileName)) {
var typeSystem = new DecompilerTypeSystem(module);
CSharpDecompiler decompiler = new CSharpDecompiler(typeSystem, new DecompilerSettings());
decompiler.AstTransforms.Insert(0, new RemoveCompilerAttribute());
decompiler.AstTransforms.Add(new EscapeInvalidIdentifiers());
var syntaxTree = decompiler.DecompileWholeModuleAsSingleFile();
StringWriter output = new StringWriter();
var visitor = new CSharpOutputVisitor(output, FormattingOptionsFactory.CreateSharpDevelop());
syntaxTree.AcceptVisitor(visitor);
string fileName = Path.GetTempFileName();
File.WriteAllText(fileName, output.ToString());
return(fileName);
}
}
IEnumerable <(string itemType, string fileName)> WriteAssemblyInfo(DecompilerTypeSystem ts, CancellationToken cancellationToken)
{
var decompiler = CreateDecompiler(ts);
decompiler.CancellationToken = cancellationToken;
decompiler.AstTransforms.Add(new RemoveCompilerGeneratedAssemblyAttributes());
SyntaxTree syntaxTree = decompiler.DecompileModuleAndAssemblyAttributes();
const string prop = "Properties";
if (Settings.ProduceSourceCode)
{
if (directories.Add(prop))
{
Directory.CreateDirectory(Path.Combine(TargetDirectory, prop));
}
}
string assemblyInfo = Path.Combine(prop, "AssemblyInfo.cs");
var checksumCalc = Settings.checksumCalc;
if (checksumCalc.Enabled)
{
var settings = Settings;
foreach (var node in syntaxTree.Children)
{
AttributeSection asection = node as AttributeSection;
if (asection == null)
{
continue;
}
foreach (var attr in asection.Attributes)
{
checksumCalc.AppendString(attr.ToString());
}
}
if (!Settings.ProduceSourceCode)
{
return(new[] { ("Compile", assemblyInfo) });
ITypeDefinition TryResolve(PEFile module, EntityHandle handle, IType type, bool mayRetry = true)
{
DecompilerTypeSystem typeSystem = new DecompilerTypeSystem(module, module.GetAssemblyResolver(),
TypeSystemOptions.Default | TypeSystemOptions.Uncached);
var t = typeSystem.MainModule.ResolveEntity(handle) as ITypeDefinition;
if (t != null)
{
showExpander = t.DirectBaseTypes.Any();
var other = t.ParentModule.PEFile.GetTypeSystemWithCurrentOptionsOrNull();
Debug.Assert(other != null);
t = other.FindType(t.FullTypeName).GetDefinition();
}
else
{
showExpander = mayRetry;
}
RaisePropertyChanged(nameof(Text));
RaisePropertyChanged(nameof(ShowExpander));
return(t);
}
public IEnumerable <ITypeDefinition> GetTypesInScope(CancellationToken ct)
{
if (IsLocal)
{
foreach (var type in TreeTraversal.PreOrder(typeScope, t => t.NestedTypes))
{
yield return(type);
}
}
else
{
foreach (var module in GetModulesInScope(ct))
{
var typeSystem = new DecompilerTypeSystem(module, module.GetAssemblyResolver());
foreach (var type in typeSystem.MainModule.TypeDefinitions)
{
yield return(type);
}
}
}
}
protected IEnumerable <AnalyzerTreeNode> FetchChildren(CancellationToken ct)
{
if (symbol is IEntity entity)
{
var module = entity.ParentModule.PEFile;
var ts = new DecompilerTypeSystem(module, module.GetAssemblyResolver());
var context = new AnalyzerContext()
{
CancellationToken = ct,
Language = Language,
AssemblyList = MainWindow.Instance.CurrentAssemblyList
};
foreach (var result in analyzer.Analyze(symbol, context))
{
yield return(SymbolTreeNodeFactory(result));
}
}
else
{
throw new NotSupportedException("Currently symbols that are not entities are not supported!");
}
}
static void Decompile(string assemblyFileName, TextWriter output, string typeName = null)
{
ModuleDefinition module = LoadModule(assemblyFileName);
var typeSystem = new DecompilerTypeSystem(module);
CSharpDecompiler decompiler = new CSharpDecompiler(typeSystem, new DecompilerSettings());
decompiler.AstTransforms.Add(new EscapeInvalidIdentifiers());
SyntaxTree syntaxTree;
if (typeName == null)
{
syntaxTree = decompiler.DecompileWholeModuleAsSingleFile();
}
else
{
syntaxTree = decompiler.DecompileTypes(module.GetTypes().Where(td => string.Equals(td.FullName, typeName, StringComparison.OrdinalIgnoreCase)));
}
var visitor = new CSharpOutputVisitor(output, FormattingOptionsFactory.CreateSharpDevelop());
syntaxTree.AcceptVisitor(visitor);
}
object GenerateTooltip(ReferenceSegment segment)
{
if (segment.Reference is ICSharpCode.Decompiler.Disassembler.OpCodeInfo code)
{
XmlDocumentationProvider docProvider = XmlDocLoader.MscorlibDocumentation;
if (docProvider != null)
{
string documentation = docProvider.GetDocumentation("F:System.Reflection.Emit.OpCodes." + code.EncodedName);
if (documentation != null)
{
XmlDocRenderer renderer = new XmlDocRenderer();
renderer.AppendText($"{code.Name} (0x{code.Code:x}) - ");
renderer.AddXmlDocumentation(documentation);
return(renderer.CreateTextBlock());
}
}
return($"{code.Name} (0x{code.Code:x})");
}
else if (segment.Reference is IEntity entity)
{
return(CreateTextBlockForEntity(entity));
}
else if (segment.Reference is ValueTuple <PEFile, System.Reflection.Metadata.EntityHandle> unresolvedEntity)
{
var typeSystem = new DecompilerTypeSystem(unresolvedEntity.Item1, unresolvedEntity.Item1.GetAssemblyResolver(), TypeSystemOptions.Default | TypeSystemOptions.Uncached);
try {
IEntity resolved = typeSystem.MainModule.ResolveEntity(unresolvedEntity.Item2);
if (resolved == null)
{
return(null);
}
return(CreateTextBlockForEntity(resolved));
} catch (BadImageFormatException) {
return(null);
}
}
return(null);
}
