public override TreeViewNodeFilterResult GetFilterResult(LoadedAssembly asm, AssemblyFilterType type) {
if (type == AssemblyFilterType.NonNetFile)
return new TreeViewNodeFilterResult(FilterResult.Hidden, false);
if (type == AssemblyFilterType.Assembly) {
if (assembly == null || asm.AssemblyDefinition != assembly)
return new TreeViewNodeFilterResult(FilterResult.Hidden, false);
return new TreeViewNodeFilterResult(FilterResult.Match, false);
}
if (type == AssemblyFilterType.NetModule) {
if (asm.AssemblyDefinition != assembly)
return new TreeViewNodeFilterResult(FilterResult.Hidden, false);
if (assembly == null || assembly.ManifestModule != module) {
if (asm.ModuleDefinition != module)
return new TreeViewNodeFilterResult(FilterResult.Hidden, false);
return new TreeViewNodeFilterResult(FilterResult.Match, false);
}
else
return new TreeViewNodeFilterResult(FilterResult.Match, asm.ModuleDefinition != assembly.ManifestModule);
}
Debug.Fail("Invalid AssemblyFilterType value");
return new TreeViewNodeFilterResult(FilterResult.Hidden, false);
}
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options)
{
output.WriteLine("// " + assembly.FileName);
output.WriteLine();
new ReflectionDisassembler(output, detectControlStructure, options.CancellationToken).WriteAssemblyHeader(assembly.AssemblyDefinition);
}
public override TreeViewNodeFilterResult GetFilterResult(LoadedAssembly asm, AssemblyFilterType type) {
if (asm.AssemblyDefinition != allowedAsm)
return new TreeViewNodeFilterResult(FilterResult.Hidden, false);
if (allowedAsm == null && asm.ModuleDefinition != allowedMod)
return new TreeViewNodeFilterResult(FilterResult.Hidden, false);
return base.GetFilterResult(asm, type);
}
static void Execute(ILSpyTreeNode[] nodes)
{
if (!AddNetModuleToAssemblyCommand.CanExecute(nodes))
return;
var dialog = new System.Windows.Forms.OpenFileDialog() {
Filter = ".NET NetModules (*.netmodule)|*.netmodule|All files (*.*)|*.*",
RestoreDirectory = true,
};
if (dialog.ShowDialog() != System.Windows.Forms.DialogResult.OK)
return;
if (string.IsNullOrEmpty(dialog.FileName))
return;
var asm = new LoadedAssembly(MainWindow.Instance.CurrentAssemblyList, dialog.FileName);
if (asm.ModuleDefinition == null || asm.AssemblyDefinition != null) {
MainWindow.Instance.ShowMessageBox(string.Format("{0} is not a NetModule", asm.FileName), System.Windows.MessageBoxButton.OK);
asm.TheLoadedFile.Dispose();
return;
}
var cmd = new AddExistingNetModuleToAssemblyCommand((AssemblyTreeNode)nodes[0], asm);
UndoCommandManager.Instance.Add(cmd);
MainWindow.Instance.JumpToReference(cmd.modNode);
}
public string WriteResourceToFile(LoadedAssembly assembly, string fileName, Stream stream, DecompilationOptions options)
{
var document = BamlResourceEntryNode.LoadIntoDocument(assembly.GetAssemblyResolver(), assembly.AssemblyDefinition, stream);
fileName = Path.ChangeExtension(fileName, ".xaml");
document.Save(Path.Combine(options.SaveAsProjectDirectory, fileName));
return fileName;
}
public virtual void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options)
{
WriteCommentLine(output, assembly.FileName);
if (assembly.AssemblyDefinition != null) {
if (assembly.AssemblyDefinition.IsContentTypeWindowsRuntime) {
WriteCommentLine(output, assembly.AssemblyDefinition.Name + " [WinRT]");
} else {
WriteCommentLine(output, assembly.AssemblyDefinition.FullName);
}
} else {
WriteCommentLine(output, assembly.ModuleDefinition.Name);
}
}
public override TreeViewNodeFilterResult GetFilterResult(LoadedAssembly asm, AssemblyFilterType type) {
VisibleMembersFlags thisFlag, visibleFlags;
switch (type) {
case AssemblyFilterType.Assembly:
thisFlag = VisibleMembersFlags.AssemblyDef;
visibleFlags = thisFlag | VisibleMembersFlags.ModuleDef |
VisibleMembersFlags.Namespace | VisibleMembersFlags.AnyTypeDef |
VisibleMembersFlags.FieldDef | VisibleMembersFlags.MethodDef |
VisibleMembersFlags.InstanceConstructor | VisibleMembersFlags.PropertyDef |
VisibleMembersFlags.EventDef | VisibleMembersFlags.AssemblyRef |
VisibleMembersFlags.BaseTypes | VisibleMembersFlags.DerivedTypes |
VisibleMembersFlags.ModuleRef | VisibleMembersFlags.ResourceList |
VisibleMembersFlags.MethodBody | VisibleMembersFlags.ParamDefs |
VisibleMembersFlags.ParamDef | VisibleMembersFlags.Locals |
VisibleMembersFlags.Local | VisibleMembersFlags.Resource |
VisibleMembersFlags.ResourceElement | VisibleMembersFlags.PE |
VisibleMembersFlags.Hex;
break;
case AssemblyFilterType.NetModule:
thisFlag = VisibleMembersFlags.ModuleDef;
visibleFlags = thisFlag |
VisibleMembersFlags.Namespace | VisibleMembersFlags.AnyTypeDef |
VisibleMembersFlags.FieldDef | VisibleMembersFlags.MethodDef |
VisibleMembersFlags.InstanceConstructor | VisibleMembersFlags.PropertyDef |
VisibleMembersFlags.EventDef | VisibleMembersFlags.AssemblyRef |
VisibleMembersFlags.BaseTypes | VisibleMembersFlags.DerivedTypes |
VisibleMembersFlags.ModuleRef | VisibleMembersFlags.ResourceList |
VisibleMembersFlags.MethodBody | VisibleMembersFlags.ParamDefs |
VisibleMembersFlags.ParamDef | VisibleMembersFlags.Locals |
VisibleMembersFlags.Local | VisibleMembersFlags.Resource |
VisibleMembersFlags.ResourceElement | VisibleMembersFlags.PE |
VisibleMembersFlags.Hex;
break;
case AssemblyFilterType.NonNetFile:
default:
thisFlag = VisibleMembersFlags.NonNetFile;
visibleFlags = thisFlag | VisibleMembersFlags.PE | VisibleMembersFlags.Hex;
break;
}
bool isMatch = (flags & thisFlag) != 0;
if ((flags & visibleFlags) == 0)
return new TreeViewNodeFilterResult(FilterResult.Hidden, isMatch);
if (isMatch)
return new TreeViewNodeFilterResult(FilterResult.Match, isMatch); // Make sure it's not hidden
return new TreeViewNodeFilterResult(null, isMatch);
}
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 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);
}
}
void Search(LoadedAssembly ownerModule, TypeDef type, FieldDef field)
{
var res = filter.GetFilterResult(field);
if (res.FilterResult == FilterResult.Hidden)
{
return;
}
if (res.IsMatch && IsMatch(field.Name, field))
{
onMatch(new SearchResult {
Language = language,
Object = field,
NameObject = field,
TypeImageInfo = FieldTreeNode.GetImageInfo(field, BackgroundType.Search),
LocationObject = type,
LocationImageInfo = TypeTreeNode.GetImageInfo(type, BackgroundType.Search),
LoadedAssembly = ownerModule,
});
}
}
/// <summary>
/// Replace the assembly object model from a crafted stream, without disk I/O
/// Returns null if it is not already loaded.
/// </summary>
public LoadedAssembly HotReplaceAssembly(string file, Stream stream)
{
App.Current.Dispatcher.VerifyAccess();
file = Path.GetFullPath(file);
var target = this.assemblies.FirstOrDefault(asm => file.Equals(asm.FileName, StringComparison.OrdinalIgnoreCase));
if (target == null)
{
return(null);
}
var index = this.assemblies.IndexOf(target);
var newAsm = new LoadedAssembly(this, file, stream);
lock (assemblies)
{
this.assemblies.Remove(target);
this.assemblies.Insert(index, newAsm);
}
return(newAsm);
}
/// <summary>
/// Opens an assembly from disk.
/// Returns the existing assembly node if it is already loaded.
/// </summary>
public LoadedAssembly OpenAssembly(string file, bool isAutoLoaded = false)
{
App.Current.Dispatcher.VerifyAccess();
file = Path.GetFullPath(file);
foreach (LoadedAssembly asm in this.assemblies)
{
if (file.Equals(asm.FileName, StringComparison.OrdinalIgnoreCase))
{
return(asm);
}
}
var newAsm = new LoadedAssembly(this, file);
newAsm.IsAutoLoaded = isAutoLoaded;
lock (assemblies) {
this.assemblies.Add(newAsm);
}
return(newAsm);
}
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 virtual void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options, DecompileAssemblyFlags flags = DecompileAssemblyFlags.AssemblyAndModule)
{
bool decompileAsm = (flags & DecompileAssemblyFlags.Assembly) != 0;
bool decompileMod = (flags & DecompileAssemblyFlags.Module) != 0;
WriteCommentLine(output, assembly.FileName);
if (decompileAsm && assembly.AssemblyDefinition != null)
{
if (assembly.AssemblyDefinition.IsContentTypeWindowsRuntime)
{
WriteCommentLine(output, assembly.AssemblyDefinition.Name + " [WinRT]");
}
else
{
WriteCommentLine(output, assembly.AssemblyDefinition.FullName);
}
}
else if (decompileMod)
{
WriteCommentLine(output, assembly.ModuleDefinition.Name);
}
}
public virtual void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options)
{
WriteCommentLine(output, assembly.FileName);
var asm = assembly.GetAssemblyDefinitionOrNull();
if (asm != null)
{
var name = asm.Name;
if (name.IsWindowsRuntime)
{
WriteCommentLine(output, name.Name + " [WinRT]");
}
else
{
WriteCommentLine(output, name.FullName);
}
}
else
{
WriteCommentLine(output, assembly.GetModuleDefinitionAsync().Result.Name);
}
}
void Search(LoadedAssembly ownerModule, TypeDef type, EventDef evt)
{
var res = filter.GetFilterResult(evt);
if (res.FilterResult == FilterResult.Hidden)
{
return;
}
if (res.IsMatch && IsMatch(evt.Name, evt))
{
onMatch(new SearchResult {
Language = language,
Object = evt,
NameObject = evt,
TypeImageInfo = EventTreeNode.GetImageInfo(evt, BackgroundType.Search),
LocationObject = type,
LocationImageInfo = TypeTreeNode.GetImageInfo(type, BackgroundType.Search),
LoadedAssembly = ownerModule,
});
}
}
void Search(LoadedAssembly ownerModule, TypeDef type, PropertyDef prop)
{
var res = filter.GetFilterResult(prop);
if (res.FilterResult == FilterResult.Hidden)
{
return;
}
if (res.IsMatch && IsMatch(prop.Name, prop))
{
onMatch(new SearchResult {
Language = language,
Object = prop,
NameObject = prop,
TypeImageInfo = PropertyTreeNode.GetImageInfo(prop, BackgroundType.Search),
LocationObject = type,
LocationImageInfo = TypeTreeNode.GetImageInfo(type, BackgroundType.Search),
LoadedAssembly = ownerModule,
});
}
}
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);
}
void SearchMembers(LoadedAssembly ownerModule, TypeDef type)
{
foreach (var method in type.Methods)
{
Search(ownerModule, type, method);
}
cancellationToken.ThrowIfCancellationRequested();
foreach (var field in type.Fields)
{
Search(ownerModule, type, field);
}
cancellationToken.ThrowIfCancellationRequested();
foreach (var prop in type.Properties)
{
Search(ownerModule, type, prop);
}
cancellationToken.ThrowIfCancellationRequested();
foreach (var evt in type.Events)
{
Search(ownerModule, type, evt);
}
}
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();
}
output.WriteLine("// Architecture: " + GetPlatformDisplayName(mainModule));
if (!mainModule.IsILOnly)
{
output.WriteLine("// 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);
codeDomBuilder.RunTransformations(transformAbortCondition);
codeDomBuilder.GenerateCode(output);
}
}
}
public override ProjectId DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options)
{
output.WriteLine("// " + assembly.FileName);
output.WriteLine();
var module = assembly.GetPEFileOrNull();
var metadata = module.Metadata;
var dis = CreateDisassembler(output, options);
if (options.FullDecompilation && options.SaveAsProjectDirectory != null)
{
throw new NotSupportedException($"Language '{Name}' does not support exporting assemblies as projects!");
}
// don't automatically load additional assemblies when an assembly node is selected in the tree view
using (options.FullDecompilation ? null : LoadedAssembly.DisableAssemblyLoad(assembly.AssemblyList))
{
dis.AssemblyResolver = module.GetAssemblyResolver();
dis.DebugInfo = module.GetDebugInfoOrNull();
if (options.FullDecompilation)
{
dis.WriteAssemblyReferences(metadata);
}
if (metadata.IsAssembly)
{
dis.WriteAssemblyHeader(module);
}
output.WriteLine();
dis.WriteModuleHeader(module);
if (options.FullDecompilation)
{
output.WriteLine();
output.WriteLine();
dis.WriteModuleContents(module);
}
}
return(null);
}
public virtual ProjectId DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options)
{
WriteCommentLine(output, assembly.FileName);
var asm = assembly.GetPEFileOrNull();
if (asm == null)
{
return(null);
}
if (options.FullDecompilation && options.SaveAsProjectDirectory != null)
{
throw new NotSupportedException($"Language '{Name}' does not support exporting assemblies as projects!");
}
var metadata = asm.Metadata;
if (metadata.IsAssembly)
{
var name = metadata.GetAssemblyDefinition();
if ((name.Flags & System.Reflection.AssemblyFlags.WindowsRuntime) != 0)
{
WriteCommentLine(output, metadata.GetString(name.Name) + " [WinRT]");
}
else if (metadata.TryGetFullAssemblyName(out string assemblyName))
{
WriteCommentLine(output, assemblyName);
}
else
{
WriteCommentLine(output, "ERR: Could not read assembly name");
}
}
else
{
WriteCommentLine(output, metadata.GetString(metadata.GetModuleDefinition().Name));
}
return(null);
}
LoadedAssembly DelayLoadAssembly(LoadedAssembly newAsm, int index, bool canDispose)
{
System.Diagnostics.Debug.Assert(!string.IsNullOrWhiteSpace(newAsm.FileName));
bool startThread;
lock (delayLoadedAsms) {
Tuple <LoadedAssembly, int> info;
if (delayLoadedAsms.TryGetValue(newAsm.FileName, out info))
{
if (canDispose)
{
newAsm.TheLoadedFile.Dispose();
}
return(info.Item1);
}
delayLoadedAsms.Add(newAsm.FileName, Tuple.Create(newAsm, index));
startThread = delayLoadedAsms.Count == 1;
}
if (startThread)
{
App.Current.Dispatcher.BeginInvoke(DispatcherPriority.Loaded, new Action(() => DelayLoadAssemblyMainThread()));
}
return(newAsm);
}
void Search(LoadedAssembly ownerModule, TypeDef type)
{
var res = filter.GetFilterResult(type);
if (res.FilterResult == FilterResult.Hidden)
{
return;
}
if (res.IsMatch && (IsMatch(type.FullName, type) || IsMatch(type.Name, type)))
{
onMatch(new SearchResult {
Language = language,
Object = type,
NameObject = type,
TypeImageInfo = TypeTreeNode.GetImageInfo(type, BackgroundType.Search),
LocationObject = type.DeclaringType,
LocationImageInfo = TypeTreeNode.GetImageInfo(type.DeclaringType, BackgroundType.Search),
LoadedAssembly = ownerModule,
});
}
SearchMembers(ownerModule, type);
}
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 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 WriteProject(LoadedAssembly loadedAssembly, Language language, string targetDirectory, CancellationToken ct)
{
targetDirectory = Path.Combine(targetDirectory, loadedAssembly.ShortName);
string projectFileName = Path.Combine(targetDirectory, loadedAssembly.ShortName + language.ProjectFileExtension);
if (!Directory.Exists(targetDirectory))
{
try {
Directory.CreateDirectory(targetDirectory);
} catch (Exception e) {
statusOutput.Add($"Failed to create a directory '{targetDirectory}':{Environment.NewLine}{e}");
return;
}
}
try {
using (var projectFileWriter = new StreamWriter(projectFileName)) {
var projectFileOutput = new PlainTextOutput(projectFileWriter);
var options = new DecompilationOptions()
{
FullDecompilation = true,
CancellationToken = ct,
SaveAsProjectDirectory = targetDirectory
};
var projectInfo = language.DecompileAssembly(loadedAssembly, projectFileOutput, options);
if (projectInfo != null)
{
projects.Add(new ProjectItem(projectFileName, projectInfo.PlatformName, projectInfo.Guid, projectInfo.TypeGuid));
}
}
} catch (Exception e) when(!(e is OperationCanceledException))
{
statusOutput.Add($"Failed to decompile the assembly '{loadedAssembly.FileName}':{Environment.NewLine}{e}");
}
}
DebugProcessVM CreateDebugProcessVM(LoadedAssembly asm = null)
{
// Re-use the previous one if it's the same file
if (lastDebugProcessVM != null && asm != null) {
if (StringComparer.OrdinalIgnoreCase.Equals(lastDebugProcessVM.Filename, asm.FileName))
return lastDebugProcessVM.Clone();
}
var vm = new DebugProcessVM();
if (asm != null)
vm.Filename = asm.FileName;
vm.BreakProcessType = DebuggerSettings.Instance.BreakProcessType;
return vm;
}
public ILSpyWholeProjectDecompiler(LoadedAssembly assembly, DecompilationOptions options)
{
this.assembly = assembly;
this.options = options;
base.Settings = options.DecompilerSettings;
}
public static void NotifyModifiedAssembly(LoadedAssembly asm)
{
MainWindow.Instance.ModuleModified(asm);
}
public LoadedAssembly(LoadedAssembly bundle, string fileName, Task <Stream?>?stream, IAssemblyResolver?assemblyResolver = null)
: this(bundle.assemblyList, fileName, stream, assemblyResolver)
{
this.ParentBundle = bundle;
}
/// <summary>
/// 1) try to find exact match by tfm + full asm name in loaded assemblies
/// 2) try to find match in search paths
/// 3) if a.deps.json is found: search %USERPROFILE%/.nuget/packages/* as well
/// 4) look in /dotnet/shared/{runtime-pack}/{closest-version}
/// 5) if the version is retargetable or all zeros or ones, search C:\Windows\Microsoft.NET\Framework64\v4.0.30319
/// 6) For "mscorlib.dll" we use the exact same assembly with which ILSpy runs
/// 7) Search the GAC
/// 8) search C:\Windows\Microsoft.NET\Framework64\v4.0.30319
/// 9) try to find match by asm name (no tfm/version) in loaded assemblies
/// </summary>
LoadedAssembly LookupReferencedAssemblyInternal(IAssemblyReference fullName, bool isWinRT, string tfm)
{
string key = tfm + ";" + (isWinRT ? fullName.Name : fullName.FullName);
string file;
LoadedAssembly asm;
lock (loadingAssemblies)
{
foreach (LoadedAssembly loaded in assemblyList.GetAssemblies())
{
var module = loaded.GetPEFileOrNull();
var reader = module?.Metadata;
if (reader == null || !reader.IsAssembly)
{
continue;
}
var asmDef = reader.GetAssemblyDefinition();
var asmDefName = loaded.GetTargetFrameworkIdAsync().Result + ";" + (isWinRT ? reader.GetString(asmDef.Name) : reader.GetFullAssemblyName());
if (key.Equals(asmDefName, StringComparison.OrdinalIgnoreCase))
{
LoadedAssemblyReferencesInfo.AddMessageOnce(fullName.FullName, MessageKind.Info, "Success - Found in Assembly List");
return(loaded);
}
}
if (universalResolver == null)
{
universalResolver = new MyUniversalResolver(this);
}
file = universalResolver.FindAssemblyFile(fullName);
foreach (LoadedAssembly loaded in assemblyList.GetAssemblies())
{
if (loaded.FileName.Equals(file, StringComparison.OrdinalIgnoreCase))
{
return(loaded);
}
}
if (file != null && loadingAssemblies.TryGetValue(file, out asm))
{
return(asm);
}
if (assemblyLoadDisableCount > 0)
{
return(null);
}
if (file != null)
{
LoadedAssemblyReferencesInfo.AddMessage(fullName.ToString(), MessageKind.Info, "Success - Loading from: " + file);
asm = new LoadedAssembly(assemblyList, file)
{
IsAutoLoaded = true
};
}
else
{
var candidates = new List <(LoadedAssembly assembly, Version version)>();
foreach (LoadedAssembly loaded in assemblyList.GetAssemblies())
{
var module = loaded.GetPEFileOrNull();
var reader = module?.Metadata;
if (reader == null || !reader.IsAssembly)
{
continue;
}
var asmDef = reader.GetAssemblyDefinition();
var asmDefName = reader.GetString(asmDef.Name);
if (fullName.Name.Equals(asmDefName, StringComparison.OrdinalIgnoreCase))
{
candidates.Add((loaded, asmDef.Version));
}
}
if (candidates.Count == 0)
{
LoadedAssemblyReferencesInfo.AddMessageOnce(fullName.ToString(), MessageKind.Error, "Could not find reference: " + fullName);
return(null);
}
candidates.SortBy(c => c.version);
var bestCandidate = candidates.FirstOrDefault(c => c.version >= fullName.Version).assembly ?? candidates.Last().assembly;
LoadedAssemblyReferencesInfo.AddMessageOnce(fullName.ToString(), MessageKind.Info, "Success - Found in Assembly List with different TFM or version: " + bestCandidate.fileName);
return(bestCandidate);
}
loadingAssemblies.Add(file, asm);
}
App.Current.Dispatcher.BeginInvoke((Action) delegate() {
lock (assemblyList.assemblies)
{
assemblyList.assemblies.Add(asm);
}
lock (loadingAssemblies)
{
loadingAssemblies.Remove(file);
}
}, DispatcherPriority.Normal);
return(asm);
}
public MyAssemblyResolver(LoadedAssembly parent)
{
this.parent = parent;
}
public virtual void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options)
{
WriteCommentLine(output, assembly.FileName);
WriteCommentLine(output, assembly.AssemblyDefinition.FullName);
}
LoadedAssembly DelayLoadAssembly(LoadedAssembly newAsm, int index, bool canDispose)
{
System.Diagnostics.Debug.Assert(!string.IsNullOrWhiteSpace(newAsm.FileName));
bool startThread;
lock (delayLoadedAsms) {
Tuple<LoadedAssembly, int> info;
if (delayLoadedAsms.TryGetValue(newAsm.FileName, out info)) {
if (canDispose)
newAsm.TheLoadedFile.Dispose();
return info.Item1;
}
delayLoadedAsms.Add(newAsm.FileName, Tuple.Create(newAsm, index));
startThread = delayLoadedAsms.Count == 1;
}
if (startThread)
App.Current.Dispatcher.BeginInvoke(DispatcherPriority.Loaded, new Action(() => DelayLoadAssemblyMainThread()));
return newAsm;
}
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options)
{
var module = assembly.GetPEFileOrNull();
if (options.FullDecompilation && options.SaveAsProjectDirectory != null)
{
var decompiler = new ILSpyWholeProjectDecompiler(assembly, options);
decompiler.DecompileProject(module, options.SaveAsProjectDirectory, new TextOutputWriter(output), options.CancellationToken);
}
else
{
AddReferenceAssemblyWarningMessage(module, output);
AddReferenceWarningMessage(module, output);
output.WriteLine();
base.DecompileAssembly(assembly, output, options);
// don't automatically load additional assemblies when an assembly node is selected in the tree view
using (options.FullDecompilation ? null : LoadedAssembly.DisableAssemblyLoad()) {
IAssemblyResolver assemblyResolver = assembly.GetAssemblyResolver();
var typeSystem = new DecompilerTypeSystem(module, assemblyResolver, options.DecompilerSettings);
var globalType = typeSystem.MainModule.TypeDefinitions.FirstOrDefault();
if (globalType != null)
{
output.Write("// Global type: ");
output.WriteReference(globalType, globalType.FullName);
output.WriteLine();
}
var metadata = module.Metadata;
var corHeader = module.Reader.PEHeaders.CorHeader;
var entrypointHandle = MetadataTokenHelpers.EntityHandleOrNil(corHeader.EntryPointTokenOrRelativeVirtualAddress);
if (!entrypointHandle.IsNil && entrypointHandle.Kind == HandleKind.MethodDefinition)
{
var entrypoint = typeSystem.MainModule.ResolveMethod(entrypointHandle, new Decompiler.TypeSystem.GenericContext());
if (entrypoint != null)
{
output.Write("// Entry point: ");
output.WriteReference(entrypoint, entrypoint.DeclaringType.FullName + "." + entrypoint.Name);
output.WriteLine();
}
}
output.WriteLine("// Architecture: " + GetPlatformDisplayName(module));
if ((corHeader.Flags & System.Reflection.PortableExecutable.CorFlags.ILOnly) == 0)
{
output.WriteLine("// This assembly contains unmanaged code.");
}
string runtimeName = GetRuntimeDisplayName(module);
if (runtimeName != null)
{
output.WriteLine("// Runtime: " + runtimeName);
}
var debugInfo = assembly.GetDebugInfoOrNull();
if (debugInfo != null)
{
output.WriteLine("// Debug info: " + debugInfo.Description);
}
output.WriteLine();
CSharpDecompiler decompiler = new CSharpDecompiler(typeSystem, options.DecompilerSettings);
decompiler.CancellationToken = options.CancellationToken;
SyntaxTree st;
if (options.FullDecompilation)
{
st = decompiler.DecompileWholeModuleAsSingleFile();
}
else
{
st = decompiler.DecompileModuleAndAssemblyAttributes();
}
WriteCode(output, options.DecompilerSettings, st, decompiler.TypeSystem);
}
}
}
internal LoadedAssembly OpenAssemblyInternal(string file, bool canAdd, bool isAutoLoaded, bool delay)
{
file = Path.GetFullPath(file);
lock (assemblies) {
var asm = FindAssemblyByFileName_NoLock(file);
if (asm != null)
return asm;
var newAsm = new LoadedAssembly(this, file);
newAsm.IsAutoLoaded = isAutoLoaded;
return ForceAddAssemblyToList(newAsm, canAdd, delay, -1, true);
}
}
void AddToList(LoadedAssembly newAsm, int index)
{
if (index >= 0 && index < assemblies.Count)
assemblies.Insert(index, newAsm);
else
assemblies.Add(newAsm);
}
internal void Insert_NoLock(int index, LoadedAssembly asm)
{
assemblies.Insert(index, asm);
}
internal int IndexOf_NoLock(LoadedAssembly asm)
{
return assemblies.IndexOf(asm);
}
/// <summary>
/// Opens an assembly from disk.
/// Returns the existing assembly node if it is already loaded.
/// </summary>
public LoadedAssembly OpenAssembly(string file)
{
App.Current.Dispatcher.VerifyAccess();
file = Path.GetFullPath(file);
foreach (LoadedAssembly asm in this.assemblies) {
if (file.Equals(asm.FileName, StringComparison.OrdinalIgnoreCase))
return asm;
}
var newAsm = new LoadedAssembly(this, file);
lock (assemblies) {
this.assemblies.Add(newAsm);
}
return newAsm;
}
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();
}
output.WriteLine("// Architecture: " + GetPlatformDisplayName(mainModule));
if ((mainModule.Attributes & ModuleAttributes.ILOnly) == 0) {
output.WriteLine("// This assembly contains unmanaged code.");
}
switch (mainModule.Runtime) {
case TargetRuntime.Net_1_0:
output.WriteLine("// Runtime: .NET 1.0");
break;
case TargetRuntime.Net_1_1:
output.WriteLine("// Runtime: .NET 1.1");
break;
case TargetRuntime.Net_2_0:
output.WriteLine("// Runtime: .NET 2.0");
break;
case TargetRuntime.Net_4_0:
output.WriteLine("// 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);
codeDomBuilder.RunTransformations(transformAbortCondition);
codeDomBuilder.GenerateCode(output);
}
}
}
public ILSpyWholeProjectDecompiler(LoadedAssembly assembly, DecompilationOptions options)
: base(options.DecompilerSettings, assembly.GetAssemblyResolver(), assembly.GetAssemblyReferenceClassifier(), assembly.GetDebugInfoOrNull())
{
this.assembly = assembly;
this.options = options;
}
IEnumerable<Tuple<string, string>> WriteResourceFilesInProject(LoadedAssembly assembly, DecompilationOptions options, HashSet<string> directories)
{
//AppDomain bamlDecompilerAppDomain = null;
//try {
foreach (EmbeddedResource r in assembly.AssemblyDefinition.MainModule.Resources.OfType<EmbeddedResource>()) {
string fileName;
Stream s = r.GetResourceStream();
s.Position = 0;
if (r.Name.EndsWith(".g.resources", StringComparison.OrdinalIgnoreCase)) {
IEnumerable<DictionaryEntry> rs = null;
try {
rs = new ResourceSet(s).Cast<DictionaryEntry>();
}
catch (ArgumentException) {
}
if (rs != null && rs.All(e => e.Value is Stream)) {
foreach (var pair in rs) {
fileName = Path.Combine(((string)pair.Key).Split('/').Select(p => TextView.DecompilerTextView.CleanUpName(p)).ToArray());
string dirName = Path.GetDirectoryName(fileName);
if (!string.IsNullOrEmpty(dirName) && directories.Add(dirName)) {
Directory.CreateDirectory(Path.Combine(options.SaveAsProjectDirectory, dirName));
}
Stream entryStream = (Stream)pair.Value;
entryStream.Position = 0;
if (fileName.EndsWith(".baml", StringComparison.OrdinalIgnoreCase)) {
MemoryStream ms = new MemoryStream();
entryStream.CopyTo(ms);
// TODO implement extension point
// var decompiler = Baml.BamlResourceEntryNode.CreateBamlDecompilerInAppDomain(ref bamlDecompilerAppDomain, assembly.FileName);
// string xaml = null;
// try {
// xaml = decompiler.DecompileBaml(ms, assembly.FileName, new ConnectMethodDecompiler(assembly), new AssemblyResolver(assembly));
// }
// catch (XamlXmlWriterException) { } // ignore XAML writer exceptions
// if (xaml != null) {
// File.WriteAllText(Path.Combine(options.SaveAsProjectDirectory, Path.ChangeExtension(fileName, ".xaml")), xaml);
// yield return Tuple.Create("Page", Path.ChangeExtension(fileName, ".xaml"));
// continue;
// }
}
using (FileStream fs = new FileStream(Path.Combine(options.SaveAsProjectDirectory, fileName), FileMode.Create, FileAccess.Write)) {
entryStream.CopyTo(fs);
}
yield return Tuple.Create("Resource", fileName);
}
continue;
}
}
fileName = GetFileNameForResource(r.Name, directories);
using (FileStream fs = new FileStream(Path.Combine(options.SaveAsProjectDirectory, fileName), FileMode.Create, FileAccess.Write)) {
s.CopyTo(fs);
}
yield return Tuple.Create("EmbeddedResource", fileName);
}
//}
//finally {
// if (bamlDecompilerAppDomain != null)
// AppDomain.Unload(bamlDecompilerAppDomain);
//}
}
public override TreeViewNodeFilterResult GetFilterResult(string ns, LoadedAssembly owner) {
if (owner.ModuleDefinition != module)
return new TreeViewNodeFilterResult(FilterResult.Hidden, false);
return new TreeViewNodeFilterResult(FilterResult.Match, false);
}
LoadedAssembly LookupReferencedAssemblyInternal(Decompiler.Metadata.IAssemblyReference fullName, bool isWinRT)
{
string GetName(Decompiler.Metadata.IAssemblyReference name) => isWinRT ? name.Name : name.FullName;
string file;
LoadedAssembly asm;
lock (loadingAssemblies) {
foreach (LoadedAssembly loaded in assemblyList.GetAssemblies())
{
var reader = loaded.GetPEFileOrNull()?.Metadata;
if (reader == null || !reader.IsAssembly)
{
continue;
}
var asmDef = reader.GetAssemblyDefinition();
var asmDefName = isWinRT ? reader.GetString(asmDef.Name) : reader.GetFullAssemblyName();
if (GetName(fullName).Equals(asmDefName, StringComparison.OrdinalIgnoreCase))
{
LoadedAssemblyReferencesInfo.AddMessageOnce(fullName.FullName, MessageKind.Info, "Success - Found in Assembly List");
return(loaded);
}
}
var resolver = new MyUniversalResolver(this);
file = resolver.FindAssemblyFile(fullName);
foreach (LoadedAssembly loaded in assemblyList.GetAssemblies())
{
if (loaded.FileName.Equals(file, StringComparison.OrdinalIgnoreCase))
{
return(loaded);
}
}
if (file != null && loadingAssemblies.TryGetValue(file, out asm))
{
return(asm);
}
if (assemblyLoadDisableCount > 0)
{
return(null);
}
if (file != null)
{
LoadedAssemblyReferencesInfo.AddMessage(fullName.ToString(), MessageKind.Info, "Success - Loading from: " + file);
asm = new LoadedAssembly(assemblyList, file)
{
IsAutoLoaded = true
};
}
else
{
LoadedAssemblyReferencesInfo.AddMessageOnce(fullName.ToString(), MessageKind.Error, "Could not find reference: " + fullName);
return(null);
}
loadingAssemblies.Add(file, asm);
}
App.Current.Dispatcher.BeginInvoke((Action) delegate() {
lock (assemblyList.assemblies) {
assemblyList.assemblies.Add(asm);
}
lock (loadingAssemblies) {
loadingAssemblies.Remove(file);
}
});
return(asm);
}
public override bool HandleModelUpdated(LoadedAssembly asm)
{
this.Children.RemoveAll(
delegate(SharpTreeNode n) {
AnalyzerTreeNode an = n as AnalyzerTreeNode;
return an == null || !an.HandleModelUpdated(asm);
});
return true;
}
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);
}
}
}
static void DumpNetModule(ProjectInfo info, List<ProjectInfo> projectFiles)
{
var fileName = info.AssemblyFileName;
if (string.IsNullOrEmpty(fileName))
throw new Exception(".NET module filename is empty or null");
var asmList = new AssemblyList("dnspc.exe", false);
asmList.UseGAC = !noGac;
asmList.AddSearchPath(Path.GetDirectoryName(fileName));
foreach (var path in asmPaths)
asmList.AddSearchPath(path);
var lasm = new LoadedAssembly(asmList, fileName);
var opts = new DecompilationOptions {
FullDecompilation = true,
CancellationToken = new CancellationToken(),
};
TextWriter writer = null;
try {
var lang = GetLanguage();
if (useStdout)
writer = System.Console.Out;
else {
var baseDir = GetProjectDir(lang, fileName);
Directory.CreateDirectory(baseDir);
writer = new StreamWriter(info.ProjectFileName, false, Encoding.UTF8);
opts.SaveAsProjectDirectory = baseDir;
opts.DontReferenceStdLib = noCorlibRef;
opts.ProjectFiles = projectFiles;
opts.ProjectGuid = info.ProjectGuid;
opts.DontShowCreateMethodBodyExceptions = dontMaskErr;
Console.WriteLine("Saving {0} to {1}", fileName, baseDir);
}
lang.DecompileAssembly(lasm, new PlainTextOutput(writer), opts);
}
finally {
if (!useStdout && writer != null)
writer.Dispose();
}
}
public override ProjectId DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options)
{
var module = assembly.GetPEFileOrNull();
if (module == null)
{
return(null);
}
if (options.FullDecompilation && options.SaveAsProjectDirectory != null)
{
if (!WholeProjectDecompiler.CanUseSdkStyleProjectFormat(module))
{
options.DecompilerSettings.UseSdkStyleProjectFormat = false;
}
var decompiler = new ILSpyWholeProjectDecompiler(assembly, options);
return(decompiler.DecompileProject(module, options.SaveAsProjectDirectory, new TextOutputWriter(output), options.CancellationToken));
}
else
{
AddReferenceAssemblyWarningMessage(module, output);
AddReferenceWarningMessage(module, output);
output.WriteLine();
base.DecompileAssembly(assembly, output, options);
// don't automatically load additional assemblies when an assembly node is selected in the tree view
IAssemblyResolver assemblyResolver = assembly.GetAssemblyResolver(loadOnDemand: options.FullDecompilation);
var typeSystem = new DecompilerTypeSystem(module, assemblyResolver, options.DecompilerSettings);
var globalType = typeSystem.MainModule.TypeDefinitions.FirstOrDefault();
if (globalType != null)
{
output.Write("// Global type: ");
output.WriteReference(globalType, globalType.FullName);
output.WriteLine();
}
var metadata = module.Metadata;
var corHeader = module.Reader.PEHeaders.CorHeader;
var entrypointHandle = MetadataTokenHelpers.EntityHandleOrNil(corHeader.EntryPointTokenOrRelativeVirtualAddress);
if (!entrypointHandle.IsNil && entrypointHandle.Kind == HandleKind.MethodDefinition)
{
var entrypoint = typeSystem.MainModule.ResolveMethod(entrypointHandle, new Decompiler.TypeSystem.GenericContext());
if (entrypoint != null)
{
output.Write("// Entry point: ");
output.WriteReference(entrypoint, entrypoint.DeclaringType.FullName + "." + entrypoint.Name);
output.WriteLine();
}
}
output.WriteLine("// Architecture: " + GetPlatformDisplayName(module));
if ((corHeader.Flags & System.Reflection.PortableExecutable.CorFlags.ILOnly) == 0)
{
output.WriteLine("// This assembly contains unmanaged code.");
}
string runtimeName = GetRuntimeDisplayName(module);
if (runtimeName != null)
{
output.WriteLine("// Runtime: " + runtimeName);
}
if ((corHeader.Flags & System.Reflection.PortableExecutable.CorFlags.StrongNameSigned) != 0)
{
output.WriteLine("// This assembly is signed with a strong name key.");
}
if (module.Reader.ReadDebugDirectory().Any(d => d.Type == DebugDirectoryEntryType.Reproducible))
{
output.WriteLine("// This assembly was compiled using the /deterministic option.");
}
if (metadata.IsAssembly)
{
var asm = metadata.GetAssemblyDefinition();
if (asm.HashAlgorithm != AssemblyHashAlgorithm.None)
{
output.WriteLine("// Hash algorithm: " + asm.HashAlgorithm.ToString().ToUpper());
}
if (!asm.PublicKey.IsNil)
{
output.Write("// Public key: ");
var reader = metadata.GetBlobReader(asm.PublicKey);
while (reader.RemainingBytes > 0)
{
output.Write(reader.ReadByte().ToString("x2"));
}
output.WriteLine();
}
}
var debugInfo = assembly.GetDebugInfoOrNull();
if (debugInfo != null)
{
output.WriteLine("// Debug info: " + debugInfo.Description);
}
output.WriteLine();
CSharpDecompiler decompiler = new CSharpDecompiler(typeSystem, options.DecompilerSettings);
decompiler.CancellationToken = options.CancellationToken;
if (options.EscapeInvalidIdentifiers)
{
decompiler.AstTransforms.Add(new EscapeInvalidIdentifiers());
}
SyntaxTree st;
if (options.FullDecompilation)
{
st = decompiler.DecompileWholeModuleAsSingleFile();
}
else
{
st = decompiler.DecompileModuleAndAssemblyAttributes();
}
WriteCode(output, options.DecompilerSettings, st, decompiler.TypeSystem);
return(null);
}
}
public MyAssemblyResolver(LoadedAssembly parent)
{
this.parent = parent;
}
IEnumerable <Tuple <string, string> > WriteResourceFilesInProject(LoadedAssembly assembly, DecompilationOptions options, HashSet <string> directories)
{
//AppDomain bamlDecompilerAppDomain = null;
//try {
foreach (EmbeddedResource r in assembly.AssemblyDefinition.MainModule.Resources.OfType <EmbeddedResource>())
{
string fileName;
Stream s = r.GetResourceStream();
s.Position = 0;
if (r.Name.EndsWith(".g.resources", StringComparison.OrdinalIgnoreCase))
{
IEnumerable <DictionaryEntry> rs = null;
try {
rs = new ResourceSet(s).Cast <DictionaryEntry>();
}
catch (ArgumentException) {
}
if (rs != null && rs.All(e => e.Value is Stream))
{
foreach (var pair in rs)
{
fileName = Path.Combine(((string)pair.Key).Split('/').Select(p => TextView.DecompilerTextView.CleanUpName(p)).ToArray());
string dirName = Path.GetDirectoryName(fileName);
if (!string.IsNullOrEmpty(dirName) && directories.Add(dirName))
{
Directory.CreateDirectory(Path.Combine(options.SaveAsProjectDirectory, dirName));
}
Stream entryStream = (Stream)pair.Value;
entryStream.Position = 0;
if (fileName.EndsWith(".baml", StringComparison.OrdinalIgnoreCase))
{
// MemoryStream ms = new MemoryStream();
// entryStream.CopyTo(ms);
// TODO implement extension point
// var decompiler = Baml.BamlResourceEntryNode.CreateBamlDecompilerInAppDomain(ref bamlDecompilerAppDomain, assembly.FileName);
// string xaml = null;
// try {
// xaml = decompiler.DecompileBaml(ms, assembly.FileName, new ConnectMethodDecompiler(assembly), new AssemblyResolver(assembly));
// }
// catch (XamlXmlWriterException) { } // ignore XAML writer exceptions
// if (xaml != null) {
// File.WriteAllText(Path.Combine(options.SaveAsProjectDirectory, Path.ChangeExtension(fileName, ".xaml")), xaml);
// yield return Tuple.Create("Page", Path.ChangeExtension(fileName, ".xaml"));
// continue;
// }
}
using (FileStream fs = new FileStream(Path.Combine(options.SaveAsProjectDirectory, fileName), FileMode.Create, FileAccess.Write)) {
entryStream.CopyTo(fs);
}
yield return(Tuple.Create("Resource", fileName));
}
continue;
}
}
fileName = GetFileNameForResource(r.Name, directories);
using (FileStream fs = new FileStream(Path.Combine(options.SaveAsProjectDirectory, fileName), FileMode.Create, FileAccess.Write)) {
s.CopyTo(fs);
}
yield return(Tuple.Create("EmbeddedResource", fileName));
}
//}
//finally {
// if (bamlDecompilerAppDomain != null)
// AppDomain.Unload(bamlDecompilerAppDomain);
//}
}
public RunningSearch(LoadedAssembly[] assemblies, string searchTerm, int searchMode, Language language)
{
this.dispatcher = Dispatcher.CurrentDispatcher;
this.assemblies = assemblies;
this.searchTerm = searchTerm.Split(new char[] {' '}, StringSplitOptions.RemoveEmptyEntries);
this.language = language;
this.searchMode = searchMode;
this.Results.Add(new SearchResult { Name = "Searching..." });
}
public void Unload(LoadedAssembly assembly)
{
App.Current.Dispatcher.VerifyAccess();
lock (assemblies) {
assemblies.Remove(assembly);
}
}
public void Unload(LoadedAssembly assembly)
{
if (App.Current != null)
App.Current.Dispatcher.VerifyAccess();
lock (assemblies) {
assemblies.Remove(assembly);
assembly.Dispose();
}
RequestGC();
}
public MyUniversalResolver(LoadedAssembly assembly)
: base(assembly.FileName, false, assembly.GetTargetFrameworkIdAsync().Result, PEStreamOptions.PrefetchEntireImage, DecompilerSettingsPanel.CurrentDecompilerSettings.ApplyWindowsRuntimeProjections ? MetadataReaderOptions.ApplyWindowsRuntimeProjections : MetadataReaderOptions.None)
{
}
internal LoadedAssembly AddAssembly(LoadedAssembly newAsm, bool canAdd, bool delay, bool canDispose = true)
{
lock (assemblies) {
var asm = FindAssemblyByFileName_NoLock(newAsm.FileName);
if (asm != null) {
if (canDispose)
newAsm.TheLoadedFile.Dispose();
return asm;
}
return ForceAddAssemblyToList(newAsm, canAdd, delay, -1, canDispose);
}
}
LoadedAssembly LookupReferencedModuleInternal(PEFile mainModule, string moduleName)
{
string file;
LoadedAssembly asm;
lock (loadingAssemblies)
{
foreach (LoadedAssembly loaded in assemblyList.GetAssemblies())
{
var reader = loaded.GetPEFileOrNull()?.Metadata;
if (reader == null || reader.IsAssembly)
{
continue;
}
var moduleDef = reader.GetModuleDefinition();
if (moduleName.Equals(reader.GetString(moduleDef.Name), StringComparison.OrdinalIgnoreCase))
{
LoadedAssemblyReferencesInfo.AddMessageOnce(moduleName, MessageKind.Info, "Success - Found in Assembly List");
return(loaded);
}
}
file = Path.Combine(Path.GetDirectoryName(mainModule.FileName), moduleName);
if (!File.Exists(file))
{
return(null);
}
foreach (LoadedAssembly loaded in assemblyList.GetAssemblies())
{
if (loaded.FileName.Equals(file, StringComparison.OrdinalIgnoreCase))
{
return(loaded);
}
}
if (file != null && loadingAssemblies.TryGetValue(file, out asm))
{
return(asm);
}
if (assemblyLoadDisableCount > 0)
{
return(null);
}
if (file != null)
{
LoadedAssemblyReferencesInfo.AddMessage(moduleName, MessageKind.Info, "Success - Loading from: " + file);
asm = new LoadedAssembly(assemblyList, file)
{
IsAutoLoaded = true
};
}
else
{
LoadedAssemblyReferencesInfo.AddMessageOnce(moduleName, MessageKind.Error, "Could not find reference: " + moduleName);
return(null);
}
loadingAssemblies.Add(file, asm);
}
App.Current.Dispatcher.BeginInvoke((Action) delegate() {
lock (assemblyList.assemblies)
{
assemblyList.assemblies.Add(asm);
}
lock (loadingAssemblies)
{
loadingAssemblies.Remove(file);
}
});
return(asm);
}
internal LoadedAssembly ForceAddAssemblyToList(LoadedAssembly newAsm, bool canAdd, bool delay, int index, bool canDispose)
{
if (!canAdd)
return newAsm;
// Happens when we start dnSpy (try with many tabs) and try to exit while it's still
// decompiling and the decompiler resolves a reference.
if (App.Current == null && MainWindow.Instance != null)
return newAsm;
if (App.Current == null)
delay = false;
else if (!App.Current.CheckAccess())
delay = true;
// Sometimes the treeview will completely mess up if we immediately add the asm.
// Wait a little while for the treeview to finish its things before we add it.
if (delay)
return DelayLoadAssembly(newAsm, index, canDispose);
AddToList(newAsm, index);
return newAsm;
}
