public override bool HandleModelUpdated(DnSpyFile asm)
{
this.LazyLoading = true;
threading.Cancel();
this.Children.Clear();
return(true);
}
public override TreeViewNodeFilterResult GetFilterResult(DnSpyFile file, AssemblyFilterType type) {
if (type == AssemblyFilterType.NonNetFile)
return new TreeViewNodeFilterResult(FilterResult.Hidden, false);
if (type == AssemblyFilterType.Assembly) {
if (assembly == null || file.AssemblyDef != assembly)
return new TreeViewNodeFilterResult(FilterResult.Hidden, false);
return new TreeViewNodeFilterResult(FilterResult.Match, false);
}
if (type == AssemblyFilterType.NetModule) {
if (file.AssemblyDef != assembly)
return new TreeViewNodeFilterResult(FilterResult.Hidden, false);
if (assembly == null || assembly.ManifestModule != module) {
if (file.ModuleDef != module)
return new TreeViewNodeFilterResult(FilterResult.Hidden, false);
return new TreeViewNodeFilterResult(FilterResult.Match, false);
}
else
return new TreeViewNodeFilterResult(FilterResult.Match, file.ModuleDef != assembly.ManifestModule);
}
Debug.Fail("Invalid AssemblyFilterType value");
return new TreeViewNodeFilterResult(FilterResult.Hidden, false);
}
public IUndoObject GetUndoObject(DnSpyFile file)
{
var uo = file.GetOrCreateAnnotation <Type, UndoObject>(typeof(UndoObject));
uo.Value = file;
return(uo);
}
void Search(DnSpyFile ownerModule, string ns, List <TypeDef> types)
{
var res = filter.GetFilterResult(ns, ownerModule);
if (res.FilterResult == FilterResult.Hidden)
{
return;
}
if (res.IsMatch && IsMatch(ns, ns))
{
onMatch(new SearchResult {
Language = language,
Object = ns,
NameObject = new NamespaceSearchResult(ns),
TypeImageInfo = GetImage("Namespace"),
LocationObject = ownerModule.ModuleDef,
LocationImageInfo = GetImage("AssemblyModule"),
DnSpyFile = ownerModule,
});
}
foreach (var type in types)
{
cancellationToken.ThrowIfCancellationRequested();
Search(ownerModule, ns, type);
}
}
void SearchNonNetFile(DnSpyFile nonNetFile)
{
if (nonNetFile == null)
{
return;
}
var res = filter.GetFilterResult(nonNetFile, AssemblyFilterType.NonNetFile);
if (res.FilterResult == FilterResult.Hidden)
{
return;
}
if (res.IsMatch && IsMatch(nonNetFile.ShortName, nonNetFile))
{
onMatch(new SearchResult {
Language = language,
Object = nonNetFile,
NameObject = nonNetFile,
TypeImageInfo = GetImage("AssemblyWarning"),
LocationObject = null,
LocationImageInfo = new ImageInfo(),
DnSpyFile = nonNetFile,
});
}
}
void Search(DnSpyFile ownerModule, string nsOwner, 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 = new NamespaceSearchResult(nsOwner),
LocationImageInfo = GetImage("Namespace"),
DnSpyFile = ownerModule,
});
}
SearchMembers(ownerModule, type);
foreach (var subType in type.GetTypes())
{
cancellationToken.ThrowIfCancellationRequested();
Search(ownerModule, subType);
}
}
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);
}
}
}
void UpdateResolver(ModuleDef module)
{
if (module != null)
{
module.Context = DnSpyFile.CreateModuleContext(myAssemblyResolver);
}
}
public DnSpyFile FindModule(DnSpyFile asm, string moduleFilename)
{
App.Current.Dispatcher.VerifyAccess();
foreach (AssemblyTreeNode node in this.Children)
{
if (node.DnSpyFile != asm)
{
continue;
}
if (!node.IsDotNetFile || node.IsNetModule)
{
continue;
}
node.EnsureChildrenFiltered();
foreach (var asmNode in node.Children.OfType <AssemblyTreeNode>())
{
if (string.IsNullOrWhiteSpace(asmNode.DnSpyFile.Filename))
{
continue;
}
if (asmNode.DnSpyFile.Filename.Equals(moduleFilename, StringComparison.OrdinalIgnoreCase))
{
return(asmNode.DnSpyFile);
}
}
}
return(null);
}
public override TreeViewNodeFilterResult GetFilterResult(DnSpyFile file, AssemblyFilterType type) {
if (file.AssemblyDef != allowedAsm)
return new TreeViewNodeFilterResult(FilterResult.Hidden, false);
if (allowedAsm == null && file.ModuleDef != allowedMod)
return new TreeViewNodeFilterResult(FilterResult.Hidden, false);
return base.GetFilterResult(file, type);
}
public override TreeViewNodeFilterResult GetFilterResult(string ns, DnSpyFile owner)
{
if (owner.ModuleDef != module)
{
return(new TreeViewNodeFilterResult(FilterResult.Hidden, false));
}
return(new TreeViewNodeFilterResult(FilterResult.Match, false));
}
public override TreeViewNodeFilterResult GetFilterResult(DnSpyFile file, AssemblyFilterType type)
{
if (file.ModuleDef != allowedModule)
{
return(new TreeViewNodeFilterResult(FilterResult.Hidden, false));
}
return(base.GetFilterResult(file, type));
}
public override bool HandleModelUpdated(DnSpyFile asm)
{
this.Children.RemoveAll(
delegate(SharpTreeNode n) {
AnalyzerTreeNode an = n as AnalyzerTreeNode;
return(an == null || !an.HandleModelUpdated(asm));
});
return(true);
}
public void UnregisterCached(DnSpyFile asm)
{
var cachedInfo = cachedAsmTreeNodes[asm];
if (cachedInfo.Counter-- == 1)
{
cachedAsmTreeNodes.Remove(asm);
}
}
public override TreeViewNodeFilterResult GetFilterResult(DnSpyFile file, 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));
}
internal AssemblyTreeNode(DnSpyFile dnSpyFile) {
if (dnSpyFile == null)
throw new ArgumentNullException("assembly");
this.dnSpyFile = dnSpyFile;
this.LazyLoading = true;
OnAssemblyLoaded();
}
void SearchBody(DnSpyFile ownerModule, TypeDef type, MethodDef method)
{
bool loadedBody;
SearchBody(ownerModule, type, method, out loadedBody);
if (loadedBody)
{
ICSharpCode.ILSpy.TreeNodes.Analyzer.Helpers.FreeMethodBody(method);
}
}
AssemblyTreeNode CreateAssemblyTreeNode(DnSpyFile file) {
CachedAssemblyTreeNode cachedInfo;
if (cachedAsmTreeNodes.TryGetValue(file, out cachedInfo)) {
var asmNode = cachedInfo.AssemblyTreeNode;
Debug.Assert(asmNode.Parent == null);
if (asmNode.Parent != null)
throw new InvalidOperationException();
return asmNode;
}
return new AssemblyTreeNode(file);
}
void SearchModAsmReferences(DnSpyFile module)
{
var res = filter.GetFilterResult((ReferenceFolderTreeNode)null);
if (res.FilterResult == FilterResult.Hidden)
{
return;
}
foreach (var asmRef in module.ModuleDef.GetAssemblyRefs())
{
res = filter.GetFilterResult(asmRef);
if (res.FilterResult == FilterResult.Hidden)
{
continue;
}
if (res.IsMatch && IsMatch(asmRef.FullName, asmRef))
{
onMatch(new SearchResult {
Language = language,
Object = asmRef,
NameObject = asmRef,
TypeImageInfo = GetImage("AssemblyReference"),
LocationObject = module.ModuleDef,
LocationImageInfo = GetImage("AssemblyModule"),
DnSpyFile = module,
});
}
}
foreach (var modRef in module.ModuleDef.GetModuleRefs())
{
res = filter.GetFilterResult(modRef);
if (res.FilterResult == FilterResult.Hidden)
{
continue;
}
if (res.IsMatch && IsMatch(modRef.FullName, modRef))
{
onMatch(new SearchResult {
Language = language,
Object = modRef,
NameObject = modRef,
TypeImageInfo = GetImage("ModuleReference"),
LocationObject = module.ModuleDef,
LocationImageInfo = GetImage("AssemblyModule"),
DnSpyFile = module,
});
}
}
}
internal AssemblyTreeNode(DnSpyFile dnSpyFile)
{
if (dnSpyFile == null)
{
throw new ArgumentNullException("assembly");
}
this.dnSpyFile = dnSpyFile;
this.LazyLoading = true;
OnAssemblyLoaded();
}
FileTabReferenceResult CreateMemberRefResult(IFileTabManager fileTabManager, object @ref)
{
var resolvedRef = ResolveMemberDef(@ref as IMemberRef);
if (!IsSupportedReference(resolvedRef))
{
return(null);
}
var newRef = GetReference(@ref);
var node = fileTabManager.FileTreeView.FindNode(newRef);
if (node == null)
{
// If it's eg. a TypeDef, its assembly has been removed from the file list or it
// was never inserted because adding an assembly had been temporarily disabled.
// Add the assembly to the list again. Next time the user clicks on the link,
// FindNode() above will succeed.
var def = @ref as IMemberDef;
if (def != null)
{
DnSpyFile file = null;
var mod = def.Module;
if (mod != null && mod.Assembly != null)
{
file = DnSpyDotNetFile.CreateAssembly(DnSpyFileInfo.CreateFile(mod.Location), mod, false);
}
else if (mod != null)
{
file = DnSpyDotNetFile.CreateModule(DnSpyFileInfo.CreateFile(mod.Location), mod, false);
}
if (file != null)
{
var existingFile = fileTabManager.FileTreeView.FileManager.GetOrAdd(file);
if (existingFile != file)
{
fileTabManager.FileTreeView.FileManager.ForceAdd(file, true, null);
}
}
}
return(null);
}
var content = decompileFileTabContentFactory.Create(new IFileTreeNodeData[] { node });
return(new FileTabReferenceResult(content, null, a => {
if (a.Success && !a.HasMovedCaret)
{
GoToReference(content, resolvedRef);
a.HasMovedCaret = true;
}
}));
}
void Search(DnSpyFile ownerModule, TypeDef type, MethodDef method)
{
var res = filter.GetFilterResult(method);
if (res.FilterResult == FilterResult.Hidden)
{
return;
}
ImplMap im;
if (res.IsMatch && (IsMatch(method.Name, method) || ((im = method.ImplMap) != null && (IsMatch(im.Name, im) || IsMatch(im.Module == null ? null : im.Module.Name, null)))))
{
onMatch(new SearchResult {
Language = language,
Object = method,
NameObject = method,
TypeImageInfo = MethodTreeNode.GetImageInfo(method, BackgroundType.Search),
LocationObject = type,
LocationImageInfo = TypeTreeNode.GetImageInfo(type, BackgroundType.Search),
DnSpyFile = ownerModule,
});
return;
}
res = filter.GetFilterResultParamDefs(method);
if (res.FilterResult != FilterResult.Hidden)
{
foreach (var pd in method.ParamDefs)
{
res = filter.GetFilterResult(method, pd);
if (res.FilterResult == FilterResult.Hidden)
{
continue;
}
if (res.IsMatch && IsMatch(pd.Name, pd))
{
onMatch(new SearchResult {
Language = language,
Object = method,
NameObject = method,
TypeImageInfo = MethodTreeNode.GetImageInfo(method, BackgroundType.Search),
LocationObject = type,
LocationImageInfo = TypeTreeNode.GetImageInfo(type, BackgroundType.Search),
DnSpyFile = ownerModule,
});
return;
}
}
}
SearchBody(ownerModule, type, method);
}
public static bool GoToIL(DnSpyFile file, uint token, uint ilOffset, bool newTab) {
if (file == null)
return false;
var md = file.ModuleDef.ResolveToken(token) as MethodDef;
if (md == null)
return false;
if (newTab)
MainWindow.Instance.OpenNewEmptyTab();
return JumpToStatement(md, ilOffset, null);
}
public override void DecompileAssembly(DnSpyFileList dnSpyFileList, DnSpyFile file, ITextOutput output, DecompilationOptions options, DecompileAssemblyFlags flags = DecompileAssemblyFlags.AssemblyAndModule)
{
if (options.FullDecompilation && options.SaveAsProjectDirectory != null)
{
HashSet <string> directories = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
var files = WriteCodeFilesInProject(dnSpyFileList, file.ModuleDef, options, directories).ToList();
files.AddRange(WriteResourceFilesInProject(file, options, directories));
WriteProjectFile(dnSpyFileList, new TextOutputWriter(output), files, file, options);
}
else
{
bool decompileAsm = (flags & DecompileAssemblyFlags.Assembly) != 0;
bool decompileMod = (flags & DecompileAssemblyFlags.Module) != 0;
base.DecompileAssembly(dnSpyFileList, file, output, options, flags);
output.WriteLine();
ModuleDef mainModule = file.ModuleDef;
if (decompileMod && mainModule.Types.Count > 0)
{
output.Write("' Global type: ", TextTokenType.Comment);
output.WriteReference(IdentifierEscaper.Escape(mainModule.GlobalType.FullName), mainModule.GlobalType, TextTokenType.Comment);
output.WriteLine();
}
if (decompileMod || decompileAsm)
{
PrintEntryPoint(file, output);
}
if (decompileMod)
{
WriteCommentLine(output, "Architecture: " + CSharpLanguage.GetPlatformDisplayName(mainModule));
if (!mainModule.IsILOnly)
{
WriteCommentLine(output, "This assembly contains unmanaged code.");
}
string runtimeName = ICSharpCode.ILSpy.CSharpLanguage.GetRuntimeDisplayName(mainModule);
if (runtimeName != null)
{
WriteCommentLine(output, "Runtime: " + runtimeName);
}
}
if (decompileMod || decompileAsm)
{
output.WriteLine();
}
// don't automatically load additional assemblies when an assembly node is selected in the tree view
using (options.FullDecompilation ? null : dnSpyFileList.DisableAssemblyLoad()) {
AstBuilder codeDomBuilder = CreateAstBuilder(options, currentModule: file.ModuleDef);
codeDomBuilder.AddAssembly(file.ModuleDef, !options.FullDecompilation, decompileAsm, decompileMod);
RunTransformsAndGenerateCode(codeDomBuilder, output, options, file.ModuleDef);
}
}
}
public override bool HandleModelUpdated(DnSpyFile asm) {
if (this.Member.Module == null)
return false; // remove this node
if ((this.Member is IField || this.Member is IMethod || this.Member is PropertyDef || this.Member is EventDef) &&
this.Member.DeclaringType == null)
return false;
this.Children.RemoveAll(
delegate (SharpTreeNode n) {
AnalyzerTreeNode an = n as AnalyzerTreeNode;
return an == null || !an.HandleModelUpdated(asm);
});
return true;
}
public override TreeViewNodeFilterResult GetFilterResult(DnSpyFile file, 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);
}
AssemblyTreeNode CreateAssemblyTreeNode(DnSpyFile file)
{
CachedAssemblyTreeNode cachedInfo;
if (cachedAsmTreeNodes.TryGetValue(file, out cachedInfo))
{
var asmNode = cachedInfo.AssemblyTreeNode;
Debug.Assert(asmNode.Parent == null);
if (asmNode.Parent != null)
{
throw new InvalidOperationException();
}
return(asmNode);
}
return(new AssemblyTreeNode(file));
}
public AssemblyTreeNode FindAssemblyNode(DnSpyFile asm)
{
if (asm == null)
{
return(null);
}
App.Current.Dispatcher.VerifyAccess();
foreach (AssemblyTreeNode node in this.Children)
{
if (node.DnSpyFile == asm)
{
return(node);
}
}
return(null);
}
public void RegisterCached(DnSpyFile file, AssemblyTreeNode asmNode)
{
CachedAssemblyTreeNode cachedInfo;
if (!cachedAsmTreeNodes.TryGetValue(file, out cachedInfo))
{
cachedAsmTreeNodes.Add(file, cachedInfo = new CachedAssemblyTreeNode(asmNode));
}
else
{
Debug.Assert(cachedInfo.AssemblyTreeNode == asmNode);
if (cachedInfo.AssemblyTreeNode != asmNode)
{
throw new InvalidOperationException();
}
}
cachedInfo.Counter++;
}
public override bool HandleModelUpdated(DnSpyFile asm)
{
if (this.Member.Module == null)
{
return(false); // remove this node
}
if ((this.Member is IField || this.Member is IMethod || this.Member is PropertyDef || this.Member is EventDef) &&
this.Member.DeclaringType == null)
{
return(false);
}
this.Children.RemoveAll(
delegate(SharpTreeNode n) {
AnalyzerTreeNode an = n as AnalyzerTreeNode;
return(an == null || !an.HandleModelUpdated(asm));
});
return(true);
}
void SearchResourceElementTreeNode(DnSpyFile module, ResourceTreeNode resTreeNode, ResourceElementTreeNode resElNode)
{
var res = filter.GetFilterResult(resElNode);
if (res.FilterResult == FilterResult.Hidden)
{
return;
}
if (res.IsMatch)
{
bool m = IsMatch(resElNode.Name, resElNode);
if (!m)
{
var builtin = resElNode.ResourceElement.ResourceData as BuiltInResourceData;
if (builtin != null)
{
var val = builtin.Data;
if (builtin.Code == ResourceTypeCode.TimeSpan)
{
val = ((TimeSpan)val).Ticks;
}
m = IsMatch(val as string, val);
}
}
if (!m)
{
m = IsMatch(resElNode.GetStringContents(), null);
}
if (m)
{
onMatch(new SearchResult {
Language = language,
Object = resElNode,
NameObject = resElNode,
TypeImageInfo = GetImage(resElNode.IconName),
LocationObject = resTreeNode,
LocationImageInfo = GetImage(resTreeNode.IconName),
DnSpyFile = module,
});
}
}
}
static void Execute(Lazy <IUndoCommandManager> undoCommandManager, IAppWindow appWindow, IFileTreeNodeData[] nodes)
{
if (!AddNetModuleToAssemblyCommand.CanExecute(nodes))
{
return;
}
var dialog = new System.Windows.Forms.OpenFileDialog()
{
Filter = PickFilenameConstants.NetModuleFilter,
RestoreDirectory = true,
};
if (dialog.ShowDialog() != System.Windows.Forms.DialogResult.OK)
{
return;
}
if (string.IsNullOrEmpty(dialog.FileName))
{
return;
}
var fm = appWindow.FileTreeView.FileManager;
var file = DnSpyFile.CreateDnSpyFileFromFile(DnSpyFileInfo.CreateFile(dialog.FileName), dialog.FileName, fm.Settings.UseMemoryMappedIO, fm.Settings.LoadPDBFiles, fm.AssemblyResolver, true);
if (file.ModuleDef == null || file.AssemblyDef != null || !(file is IDnSpyDotNetFile))
{
Shared.App.MsgBox.Instance.Show(string.Format(dnSpy_AsmEditor_Resources.Error_NotNetModule, file.Filename), MsgBoxButton.OK);
var id = file as IDisposable;
if (id != null)
{
id.Dispose();
}
return;
}
var node = (IDnSpyFileNode)nodes[0];
var newModNode = node.Context.FileTreeView.CreateModule((IDnSpyDotNetFile)file);
var cmd = new AddExistingNetModuleToAssemblyCommand(undoCommandManager.Value, node, newModNode);
undoCommandManager.Value.Add(cmd);
appWindow.FileTabManager.FollowReference(cmd.modNode);
}
void SearchModule(DnSpyFile module)
{
if (module == null)
{
return;
}
var mod = module.ModuleDef;
if (mod == null)
{
SearchNonNetFile(module);
return;
}
var res = filter.GetFilterResult(module, AssemblyFilterType.NetModule);
if (res.FilterResult == FilterResult.Hidden)
{
return;
}
if (res.IsMatch && IsMatch(mod.FullName, module))
{
onMatch(new SearchResult {
Language = language,
Object = module,
NameObject = mod,
TypeImageInfo = GetImage("AssemblyModule"),
LocationObject = mod.Assembly != null ? mod.Assembly : null,
LocationImageInfo = mod.Assembly != null ? GetAssemblyImage(mod.Assembly.ManifestModule) : new ImageInfo(),
DnSpyFile = module,
});
}
SearchModAsmReferences(module);
SearchResources(module);
foreach (var kv in GetNamespaces(mod))
{
cancellationToken.ThrowIfCancellationRequested();
Search(module, kv.Key, kv.Value);
}
}
public static bool GoToIL(DnSpyFile file, uint token, uint ilOffset, bool newTab)
{
if (file == null)
{
return(false);
}
var md = file.ModuleDef.ResolveToken(token) as MethodDef;
if (md == null)
{
return(false);
}
if (newTab)
{
MainWindow.Instance.OpenNewEmptyTab();
}
return(JumpToStatement(md, ilOffset, null));
}
public override void DecompileAssembly(DnSpyFileList dnSpyFileList, DnSpyFile file, ITextOutput output, DecompilationOptions options, DecompileAssemblyFlags flags = DecompileAssemblyFlags.AssemblyAndModule) {
if (options.FullDecompilation && options.SaveAsProjectDirectory != null) {
HashSet<string> directories = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
var files = WriteCodeFilesInProject(dnSpyFileList, file.ModuleDef, options, directories).ToList();
files.AddRange(WriteResourceFilesInProject(file, options, directories));
WriteProjectFile(dnSpyFileList, new TextOutputWriter(output), files, file, options);
}
else {
bool decompileAsm = (flags & DecompileAssemblyFlags.Assembly) != 0;
bool decompileMod = (flags & DecompileAssemblyFlags.Module) != 0;
base.DecompileAssembly(dnSpyFileList, file, output, options, flags);
output.WriteLine();
ModuleDef mainModule = file.ModuleDef;
if (decompileMod && mainModule.Types.Count > 0) {
output.Write("' Global type: ", TextTokenType.Comment);
output.WriteReference(IdentifierEscaper.Escape(mainModule.GlobalType.FullName), mainModule.GlobalType, TextTokenType.Comment);
output.WriteLine();
}
if (decompileMod || decompileAsm)
PrintEntryPoint(file, output);
if (decompileMod) {
WriteCommentLine(output, "Architecture: " + CSharpLanguage.GetPlatformDisplayName(mainModule));
if (!mainModule.IsILOnly) {
WriteCommentLine(output, "This assembly contains unmanaged code.");
}
string runtimeName = ICSharpCode.ILSpy.CSharpLanguage.GetRuntimeDisplayName(mainModule);
if (runtimeName != null) {
WriteCommentLine(output, "Runtime: " + runtimeName);
}
}
if (decompileMod || decompileAsm)
output.WriteLine();
// don't automatically load additional assemblies when an assembly node is selected in the tree view
using (options.FullDecompilation ? null : dnSpyFileList.DisableAssemblyLoad()) {
AstBuilder codeDomBuilder = CreateAstBuilder(options, currentModule: file.ModuleDef);
codeDomBuilder.AddAssembly(file.ModuleDef, !options.FullDecompilation, decompileAsm, decompileMod);
RunTransformsAndGenerateCode(codeDomBuilder, output, options, file.ModuleDef);
}
}
}
internal static void GoToFile(DnSpyFile file, bool newTab)
{
if (file == null)
{
return;
}
var mod = file.ModuleDef;
if (mod == null)
{
return;
}
// The file could've been added lazily to the list so add a short delay before we select it
MainWindow.Instance.Dispatcher.BeginInvoke(DispatcherPriority.Background, new Action(() => {
if (newTab)
{
MainWindow.Instance.OpenNewEmptyTab();
}
MainWindow.Instance.JumpToReference(mod);
}));
}
protected void PrintEntryPoint(DnSpyFile assembly, ITextOutput output)
{
var ep = GetEntryPoint(assembly.ModuleDef);
if (ep is uint)
{
WriteCommentLine(output, string.Format("Native Entry point: 0x{0:x8}", (uint)ep));
}
else if (ep is MethodDef)
{
var epMethod = (MethodDef)ep;
WriteComment(output, "Entry point: ");
if (epMethod.DeclaringType != null)
{
output.WriteReference(IdentifierEscaper.Escape(epMethod.DeclaringType.FullName), epMethod.DeclaringType, TextTokenType.Comment);
output.Write('.', TextTokenType.Comment);
}
output.WriteReference(IdentifierEscaper.Escape(epMethod.Name), epMethod, TextTokenType.Comment);
output.WriteLine();
}
}
public override TreeViewNodeFilterResult GetFilterResult(string ns, DnSpyFile owner)
{
var visibleFlags = VisibleMembersFlags.Namespace | VisibleMembersFlags.AnyTypeDef |
VisibleMembersFlags.FieldDef | VisibleMembersFlags.MethodDef |
VisibleMembersFlags.InstanceConstructor | VisibleMembersFlags.PropertyDef |
VisibleMembersFlags.EventDef | VisibleMembersFlags.BaseTypes |
VisibleMembersFlags.DerivedTypes | VisibleMembersFlags.MethodBody |
VisibleMembersFlags.ParamDefs | VisibleMembersFlags.ParamDef |
VisibleMembersFlags.Locals | VisibleMembersFlags.Local;
bool isMatch = (flags & VisibleMembersFlags.Namespace) != 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(FilterResult.Recurse, isMatch));
}
public void Remove(DnSpyFile file, bool canDispose) {
options.Dispatcher.VerifyAccess();
lock (lockObj) {
files.Remove(file);
// No need to Dispose() it. The GC will take care of it
}
if (canDispose)
CallGC();
}
void AddToList_NoLock(DnSpyFile newFile, int index) {
var key = newFile.Key;
if ((uint)index < (uint)files.Count)
files.Insert(index, newFile);
else
files.Add(newFile);
}
DnSpyFile DelayLoadFile_NoLock(DnSpyFile newFile, int index, bool canDispose) {
bool startThread;
lock (delayLoadedFiles) {
var key = newFile.Key;
Tuple<DnSpyFile, int> info;
if (delayLoadedFiles.TryGetValue(key, out info)) {
if (canDispose && info.Item1 != newFile)
newFile.Dispose();
return info.Item1;
}
delayLoadedFiles.Add(key, Tuple.Create(newFile, index));
startThread = delayLoadedFiles.Count == 1;
}
if (startThread)
options.Dispatcher.BeginInvoke(DispatcherPrio.Loaded, () => DelayLoadFileMainThread());
return newFile;
}
public void RegisterCached(DnSpyFile file, AssemblyTreeNode asmNode) {
CachedAssemblyTreeNode cachedInfo;
if (!cachedAsmTreeNodes.TryGetValue(file, out cachedInfo))
cachedAsmTreeNodes.Add(file, cachedInfo = new CachedAssemblyTreeNode(asmNode));
else {
Debug.Assert(cachedInfo.AssemblyTreeNode == asmNode);
if (cachedInfo.AssemblyTreeNode != asmNode)
throw new InvalidOperationException();
}
cachedInfo.Counter++;
}
DnSpyFile ForceAddFileToList_NoLock(DnSpyFile newFile, bool canAdd, bool delayLoad, int index, bool canDispose) {
if (!canAdd)
return newFile;
delayLoad |= !options.Dispatcher.CheckAccess();
// Sometimes the treeview will completely mess up if we immediately add the file.
// Wait a little while for the treeview to finish its things before we add it.
if (delayLoad)
return DelayLoadFile_NoLock(newFile, index, canDispose);
AddToList_NoLock(newFile, index);
return newFile;
}
void Search(DnSpyFile ownerModule, TypeDef type, FieldDef field) {
var res = filter.GetFilterResult(field);
if (res.FilterResult == FilterResult.Hidden)
return;
ImplMap im;
if (res.IsMatch && (IsMatch(field.Name, field) || ((im = field.ImplMap) != null && (IsMatch(im.Name, im) || IsMatch(im.Module == null ? null : im.Module.Name, null))))) {
onMatch(new SearchResult {
Language = language,
Object = field,
NameObject = field,
TypeImageInfo = FieldTreeNode.GetImageInfo(field, BackgroundType.Search),
LocationObject = type,
LocationImageInfo = TypeTreeNode.GetImageInfo(type, BackgroundType.Search),
DnSpyFile = ownerModule,
});
}
}
public virtual TreeViewNodeFilterResult GetFilterResult(string ns, DnSpyFile owner) {
return new TreeViewNodeFilterResult(FilterResult.Hidden, false);
}
void Search(DnSpyFile 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),
DnSpyFile = ownerModule,
});
}
}
void Search(DnSpyFile 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),
DnSpyFile = ownerModule,
});
}
}
public static void NotifyModifiedAssembly(DnSpyFile asm) {
MainWindow.Instance.ModuleModified(asm);
}
public override bool HandleModelUpdated(DnSpyFile asm) {
this.Children.RemoveAll(
delegate (SharpTreeNode n) {
AnalyzerTreeNode an = n as AnalyzerTreeNode;
return an == null || !an.HandleModelUpdated(asm);
});
return true;
}
public DnSpyFile FindModule(DnSpyFile asm, string moduleFilename) {
App.Current.Dispatcher.VerifyAccess();
foreach (AssemblyTreeNode node in this.Children) {
if (node.DnSpyFile != asm)
continue;
if (!node.IsDotNetFile || node.IsNetModule)
continue;
node.EnsureChildrenFiltered();
foreach (var asmNode in node.Children.OfType<AssemblyTreeNode>()) {
if (string.IsNullOrWhiteSpace(asmNode.DnSpyFile.Filename))
continue;
if (asmNode.DnSpyFile.Filename.Equals(moduleFilename, StringComparison.OrdinalIgnoreCase))
return asmNode.DnSpyFile;
}
}
return null;
}
public AssemblyTreeNode FindAssemblyNode(DnSpyFile asm) {
if (asm == null)
return null;
App.Current.Dispatcher.VerifyAccess();
foreach (AssemblyTreeNode node in this.Children) {
if (node.DnSpyFile == asm)
return node;
}
return null;
}
public void UnregisterCached(DnSpyFile asm) {
var cachedInfo = cachedAsmTreeNodes[asm];
if (cachedInfo.Counter-- == 1)
cachedAsmTreeNodes.Remove(asm);
}
internal int IndexOf_NoLock(DnSpyFile file) {
return files.IndexOf(file);
}
public DnSpyFile Add(DnSpyFile file) {
options.Dispatcher.VerifyAccess();
lock (lockObj) {
var key = file.Key;
var existingFile = FindByKey_NoLock(key);
if (existingFile != null)
return existingFile;
AddToList_NoLock(file, -1);
return file;
}
}
internal void Insert_NoLock(int index, DnSpyFile file) {
files.Insert(index, file);
}
internal DnSpyFile AddFile(DnSpyFile newFile, bool canAdd, bool delayLoad, bool canDispose = true) {
lock (lockObj) {
var file = FindByKey_NoLock(newFile.Key);
if (file != null) {
if (canDispose && newFile != file)
newFile.Dispose();
return file;
}
return ForceAddFileToList_NoLock(newFile, canAdd, delayLoad, -1, canDispose);
}
}
public virtual TreeViewNodeFilterResult GetFilterResult(DnSpyFile file, AssemblyFilterType type) {
return new TreeViewNodeFilterResult(FilterResult.Hidden, false);
}
internal DnSpyFile ForceAddFileToList(DnSpyFile newFile, bool canAdd, bool delayLoad, int index, bool canDispose) {
lock (lockObj)
return ForceAddFileToList_NoLock(newFile, canAdd, delayLoad, index, canDispose);
}
void SearchBody(DnSpyFile ownerModule, TypeDef type, MethodDef method, out bool loadedBody) {
loadedBody = false;
CilBody body;
var res = filter.GetFilterResultLocals(method);
if (res.FilterResult != FilterResult.Hidden) {
body = method.Body;
if (body == null)
return; // Return immediately. All code here depends on a non-null body
loadedBody = true;
foreach (var local in body.Variables) {
res = filter.GetFilterResult(method, local);
if (res.FilterResult == FilterResult.Hidden)
continue;
if (res.IsMatch && IsMatch(local.Name, local)) {
onMatch(new SearchResult {
Language = language,
Object = method,
NameObject = method,
TypeImageInfo = MethodTreeNode.GetImageInfo(method, BackgroundType.Search),
LocationObject = type,
LocationImageInfo = TypeTreeNode.GetImageInfo(type, BackgroundType.Search),
DnSpyFile = ownerModule,
});
return;
}
}
}
res = filter.GetFilterResultBody(method);
if (res.FilterResult == FilterResult.Hidden)
return;
if (!res.IsMatch)
return;
body = method.Body;
if (body == null)
return; // Return immediately. All code here depends on a non-null body
loadedBody = true;
foreach (var instr in body.Instructions) {
object operand;
// Only check numbers and strings. Don't pass in any type of operand to IsMatch()
switch (instr.OpCode.Code) {
case Code.Ldc_I4_M1: operand = -1; break;
case Code.Ldc_I4_0: operand = 0; break;
case Code.Ldc_I4_1: operand = 1; break;
case Code.Ldc_I4_2: operand = 2; break;
case Code.Ldc_I4_3: operand = 3; break;
case Code.Ldc_I4_4: operand = 4; break;
case Code.Ldc_I4_5: operand = 5; break;
case Code.Ldc_I4_6: operand = 6; break;
case Code.Ldc_I4_7: operand = 7; break;
case Code.Ldc_I4_8: operand = 8; break;
case Code.Ldc_I4:
case Code.Ldc_I4_S:
case Code.Ldc_R4:
case Code.Ldc_R8:
case Code.Ldstr: operand = instr.Operand; break;
default: operand = null; break;
}
if (operand != null && IsMatch(null, operand)) {
onMatch(new SearchResult {
Language = language,
Object = method,
NameObject = method,
TypeImageInfo = MethodTreeNode.GetImageInfo(method, BackgroundType.Search),
LocationObject = type,
LocationImageInfo = TypeTreeNode.GetImageInfo(type, BackgroundType.Search),
DnSpyFile = ownerModule,
});
break;
}
}
}
public override TreeViewNodeFilterResult GetFilterResult(string ns, DnSpyFile owner) {
if (owner.ModuleDef != module)
return new TreeViewNodeFilterResult(FilterResult.Hidden, false);
return new TreeViewNodeFilterResult(FilterResult.Match, false);
}
