// Adds the assemblies that are initially loaded with the // component inspector code public static void AddCurrentAssemblies() { foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies()) { // Don't add the current assembly if (!(LocalPrefs.Get(LocalPrefs.DEV) != null)) { if (assembly.Equals(Assembly.GetCallingAssembly())) { continue; } } // Skip the dynamically created assembly used by the // internal dynamic classes if (assembly.GetName().Name.Equals(AssemblySupport.DUMMY_ASSY_NAME)) { continue; } try { AssemblyTreeNode node = AddAssy(assembly, null); // Don't allow close since these are always loaded // automatically node.NoClose = true; } catch (Exception ex) { TraceUtil.WriteLineWarning(null, "Error adding local assembly: " + assembly + ": " + ex); } } }
internal static void OpenFile(String fileName) { // Keep track if the assembly was actually loaded, if // not then it must already be loaded, so handle adding // it to the tree. _assyLoadedNode = null; LoadAssembly(fileName); if (_assyLoadedNode == null) { Assembly assy = Assembly.LoadFrom(fileName); if (assy.Equals(Assembly.GetExecutingAssembly())) { throw new Exception("You may not inspect the Component Inspector"); } // Already loaded _assyLoadedNode = FindAssemblyNode(assy); if (_assyLoadedNode == null) { AssemblyTreeNode node = AddAssy(assy, null); RememberAssembly(assy, null, null); _assyLoadedNode = node; } } // Make sure this node is presented and selected SelectAssyTab(); _assyLoadedNode.PointToNode(); }
public ModuleState(CorModuleDefFile corModuleDefFile, AssemblyTreeNode moduleNode, HashSet <uint> modifiedTypes, HashSet <uint> loadClassHash) { this.CorModuleDefFile = corModuleDefFile; this.ModuleNode = moduleNode; this.ModifiedTypes = modifiedTypes; this.LoadClassHash = loadClassHash; }
public void Execute(SharpTreeNode[] selectedNodes) { if (!CurrentDebugger.IsDebugging) { AssemblyTreeNode n = selectedNodes[0] as AssemblyTreeNode; var settings = ILSpySettings.Load(); XElement e = settings["DebuggerSettings"]; var askForArguments = (bool?)e.Attribute("askForArguments"); if (askForArguments.HasValue && askForArguments.Value) { var window = new ExecuteProcessWindow { Owner = MainWindow.Instance, SelectedExecutable = n.LoadedAssembly.FileName }; if (window.ShowDialog() == true) { string fileName = window.SelectedExecutable; // execute the process this.StartExecutable(fileName, window.WorkingDirectory, window.Arguments); } } else { this.StartExecutable(n.LoadedAssembly.FileName, null, null); } } }
void HandleCommandLineArgumentsAfterShowList(CommandLineArguments args) { if (args.NavigateTo != null) { bool found = false; if (args.NavigateTo.StartsWith("N:", StringComparison.Ordinal)) { string namespaceName = args.NavigateTo.Substring(2); foreach (LoadedAssembly asm in commandLineLoadedAssemblies) { AssemblyTreeNode asmNode = assemblyListTreeNode.FindAssemblyNode(asm); if (asmNode != null) { NamespaceTreeNode nsNode = asmNode.FindNamespaceNode(namespaceName); if (nsNode != null) { found = true; SelectNode(nsNode); break; } } } } else { foreach (LoadedAssembly asm in commandLineLoadedAssemblies) { ModuleDefinition def = asm.GetModuleDefinitionOrNull(); if (def != null) { MemberReference mr = XmlDocKeyProvider.FindMemberByKey(def, args.NavigateTo); if (mr != null) { found = true; JumpToReference(mr); break; } } } } if (!found) { AvalonEditTextOutput output = new AvalonEditTextOutput(); output.Write(string.Format("Cannot find '{0}' in command line specified assemblies.", args.NavigateTo)); decompilerTextView.ShowText(output); } } else if (commandLineLoadedAssemblies.Count == 1) { // NavigateTo == null and an assembly was given on the command-line: // Select the newly loaded assembly JumpToReference(commandLineLoadedAssemblies[0].GetModuleDefinitionOrNull()); } if (args.Search != null) { SearchPane.Instance.SearchTerm = args.Search; SearchPane.Instance.Show(); } commandLineLoadedAssemblies.Clear(); // clear references once we don't need them anymore }
public void Execute(TextViewContext context) { if (context.SelectedTreeNodes == null) { return; } if (!CurrentDebugger.IsDebugging) { AssemblyTreeNode n = context.SelectedTreeNodes[0] as AssemblyTreeNode; if (DebuggerSettings.Instance.AskForArguments) { var window = new ExecuteProcessWindow { Owner = MainWindow.Instance, SelectedExecutable = n.LoadedAssembly.FileName }; if (window.ShowDialog() == true) { string fileName = window.SelectedExecutable; // execute the process this.StartExecutable(fileName, window.WorkingDirectory, window.Arguments); } } else { this.StartExecutable(n.LoadedAssembly.FileName, null, null); } } }
public void Execute(TextViewContext context) { if (context.SelectedTreeNodes == null) { return; } AssemblyTreeNode node = (AssemblyTreeNode)context.SelectedTreeNodes[0]; AssemblyDefinition asm = AssemblyDefinition.ReadAssembly(node.LoadedAssembly.FileName); ModuleDefinition module = asm.MainModule; string assemblyPath = Path.GetDirectoryName(node.LoadedAssembly.FileName); foreach (var resource in module.Resources) { if (!resource.Name.StartsWith("costura.") && !resource.Name.EndsWith(".dll.compressed")) { continue; } string fileName = assemblyPath + "/" + resource.Name.Substring(8, resource.Name.LastIndexOf(".compressed") - 8); if (File.Exists(fileName)) { // Assembly has already been decompressed and saved in the local path, just load it. MainWindow.Instance.CurrentAssemblyList.OpenAssembly(fileName); } else { EmbeddedResource er = resource as EmbeddedResource; MemoryStream memoryStream = DecompressEmbeddedAssembly(er.GetResourceStream()); WriteAssemblyToFile(memoryStream, fileName); OpenAssemblyFromStream(memoryStream, fileName); } } }
public void Execute(TextViewContext context) { if (context.SelectedTreeNodes == null) { return; } AssemblyTreeNode node = (AssemblyTreeNode)context.SelectedTreeNodes[0]; AssemblyDefinition asm = AssemblyDefinition.ReadAssembly(node.LoadedAssembly.FileName); ModuleDefinition module = asm.MainModule; foreach (var type in module.Types) { if (type.FullName == "<Module>") { foreach (var method in type.Methods) { if (method.Name == ".cctor") { ClearAttachCallFromMethod(method); } } } } SaveFileDialog dlg = new SaveFileDialog(); dlg.FileName = node.LoadedAssembly.FileName; dlg.Filter = "Assembly|*.dll;*.exe"; if (dlg.ShowDialog() == DialogResult.OK) { asm.MainModule.Write(dlg.FileName); module.Write(dlg.FileName); } }
void SearchAssemblyInternal(AssemblyTreeNode asmNode) { if (asmNode == null) return; var res = filter.GetFilterResult(asmNode.LoadedAssembly, AssemblyFilterType.Assembly); if (res.FilterResult == FilterResult.Hidden) return; if (res.IsMatch && IsMatch(asmNode.LoadedAssembly.AssemblyDefinition.FullName, asmNode.LoadedAssembly)) { onMatch(new SearchResult { Language = language, Object = asmNode, NameObject = asmNode.LoadedAssembly.AssemblyDefinition, TypeImageInfo = GetAssemblyImage(asmNode.LoadedAssembly.ModuleDefinition), LocationObject = null, LocationImageInfo = new ImageInfo(), LoadedAssembly = asmNode.LoadedAssembly, }); } Debug.Assert(!asmNode.LazyLoading); if (asmNode.LazyLoading) throw new InvalidOperationException("Assembly's children haven't been loaded yet. Load them in the UI thread."); foreach (AssemblyTreeNode modNode in asmNode.Children) { cancellationToken.ThrowIfCancellationRequested(); SearchModule(modNode.LoadedAssembly); } }
internal static void CloseAssembly(AssemblyTreeNode node) { CloseAssembly(node.Assembly); if (node.TypeLib != null) { node.TypeLib.Close(); } }
public void Dispose() { if (asmNode != null) { MainWindow.Instance.AssemblyListTreeNode.UnregisterCached(asmNode.LoadedAssembly); } asmNode = null; }
public void Dispose() { if (asmNode != null) { MainWindow.Instance.DnSpyFileListTreeNode.UnregisterCached(asmNode.DnSpyFile); } asmNode = null; }
internal static bool HasPENode(AssemblyTreeNode node) { if (node == null) { return(false); } // Currently only nodes loaded from files on disk have a PE node return(node.DnSpyFile.PEImage != null && node.DnSpyFile.LoadedFromFile); }
public DebugMetadataTreeNode(PEFile module, bool isEmbedded, MetadataReader provider, AssemblyTreeNode assemblyTreeNode) { this.module = module; this.provider = provider; this.assemblyTreeNode = assemblyTreeNode; this.isEmbedded = isEmbedded; this.Text = "Debug Metadata (" + (isEmbedded ? "Embedded" : "From portable PDB") + ")"; this.LazyLoading = true; }
RemoveNetModuleFromAssemblyCommand(AssemblyTreeNode modNode) { this.asmNode = (AssemblyTreeNode)modNode.Parent; Debug.Assert(this.asmNode != null); this.modNode = modNode; this.removeIndex = asmNode.Children.IndexOf(modNode); Debug.Assert(this.removeIndex > 0); Debug.Assert(asmNode.DnSpyFile.AssemblyDef != null && asmNode.DnSpyFile.AssemblyDef.Modules.IndexOf(modNode.DnSpyFile.ModuleDef) == this.removeIndex); }
public TreeViewUpdater(CorModuleDefFile cmdf, AssemblyTreeNode node, HashSet <uint> modifiedTypes, HashSet <uint> loadedClassTokens) { Debug.Assert(node.DnSpyFile == cmdf); this.CorModuleDefFile = cmdf; this.ModuleNode = node; this.modifiedTypes = new HashSet <uint>(modifiedTypes); this.loadedClassTokens = loadedClassTokens; this.checkedTypes = new HashSet <TypeDef>(); this.modNode = node; }
public void Execute(TextViewContext context) { if (context.SelectedTreeNodes == null) { return; } AssemblyTreeNode n = context.SelectedTreeNodes[0] as AssemblyTreeNode; DebuggerPlugin.Start(n.LoadedAssembly.FileName); }
RemoveNetModuleFromAssemblyCommand(AssemblyTreeNode modNode) { this.asmNode = (AssemblyTreeNode)modNode.Parent; Debug.Assert(this.asmNode != null); this.modNode = modNode; this.removeIndex = asmNode.Children.IndexOf(modNode); Debug.Assert(this.removeIndex > 0); Debug.Assert(asmNode.LoadedAssembly.AssemblyDefinition != null && asmNode.LoadedAssembly.AssemblyDefinition.Modules.IndexOf(modNode.LoadedAssembly.ModuleDefinition) == this.removeIndex); }
AssemblySettingsCommand(AssemblyTreeNode asmNode, AssemblyOptions newOptions) { this.asmNode = asmNode; this.newOptions = newOptions; this.origOptions = new AssemblyOptions(asmNode.DnSpyFile.AssemblyDef); if (newOptions.Name != origOptions.Name) { this.assemblyRefInfos = RefFinder.FindAssemblyRefsToThisModule(asmNode.DnSpyFile.ModuleDef).Where(a => AssemblyNameComparer.NameAndPublicKeyTokenOnly.Equals(a, asmNode.DnSpyFile.AssemblyDef)).Select(a => new AssemblyRefInfo(a)).ToArray(); } }
protected AddNetModuleToAssemblyCommand(AssemblyTreeNode asmNode, AssemblyTreeNode modNode, bool modNodeWasCreated) { if (asmNode.Parent is AssemblyTreeNode) { asmNode = (AssemblyTreeNode)asmNode.Parent; } Debug.Assert(!(asmNode.Parent is AssemblyTreeNode)); Debug.Assert(asmNode.IsAssembly); this.asmNode = asmNode; this.modNode = modNode; this.modNodeWasCreated = modNodeWasCreated; }
public bool IsVisible(SharpTreeNode[] selectedNodes) { return(selectedNodes.All( delegate(SharpTreeNode n) { AssemblyTreeNode a = n as AssemblyTreeNode; if (a == null) { return false; } AssemblyDefinition asm = a.LoadedAssembly.AssemblyDefinition; return asm != null && asm.EntryPoint != null; })); }
public bool IsVisible(TextViewContext context) { return(context.SelectedTreeNodes != null && context.SelectedTreeNodes.All( delegate(SharpTreeNode n) { AssemblyTreeNode a = n as AssemblyTreeNode; if (a == null) { return false; } AssemblyDefinition asm = a.LoadedAssembly.AssemblyDefinition; return asm != null && asm.EntryPoint != null; })); }
static IEnumerable <AssemblyTreeNode> GetAssemblyNodes(AssemblyTreeNode node) { if (!node.IsAssembly || node.Children.Count == 0) { yield return(node); } else { foreach (AssemblyTreeNode child in node.Children) { yield return(child); } } }
void HandleCommandLineArgumentsAfterShowList(CommandLineArguments args) { if (args.NavigateTo != null) { bool found = false; if (args.NavigateTo.StartsWith("N:", StringComparison.Ordinal)) { string namespaceName = args.NavigateTo.Substring(2); foreach (LoadedAssembly asm in commandLineLoadedAssemblies) { AssemblyTreeNode asmNode = assemblyListTreeNode.FindAssemblyNode(asm); if (asmNode != null) { NamespaceTreeNode nsNode = asmNode.FindNamespaceNode(namespaceName); if (nsNode != null) { found = true; SelectNode(nsNode); break; } } } } else { foreach (LoadedAssembly asm in commandLineLoadedAssemblies) { AssemblyDefinition def = asm.AssemblyDefinition; if (def != null) { MemberReference mr = XmlDocKeyProvider.FindMemberByKey(def.MainModule, args.NavigateTo); if (mr != null) { found = true; JumpToReference(mr); break; } } } } if (!found) { AvalonEditTextOutput output = new AvalonEditTextOutput(); output.Write("Cannot find " + args.NavigateTo); decompilerTextView.ShowText(output); } } commandLineLoadedAssemblies.Clear(); // clear references once we don't need them anymore }
internal static AssemblyTreeNode FindAssemblyTreeNode(Assembly assy) { foreach (TreeNode node in _assyRootNode.LogicalNodes) { if (node is AssemblyTreeNode) { AssemblyTreeNode atNode = (AssemblyTreeNode)node; if (assy.Equals(atNode.Assembly)) { return(atNode); } } } return(null); }
IEnumerable <TypeTreeNode> GetDefaultModuleTypes() { // Load assembly metadata var loadedAssembly = LoadAssembly(); var assemblyDefinition = GetAssemblyDefinition(loadedAssembly); var mainModule = assemblyDefinition.MainModule; var assemblyTreeNode = new AssemblyTreeNode(loadedAssembly); return(mainModule.Types.Where(t => t.Name != "<Module>") .OrderBy(t => t.FullName) .Select(type => new TypeTreeNode(type, assemblyTreeNode))); }
public new bool IsVisible(TextViewContext context) { return(DebuggerService.CurrentDebugger != null && !DebuggerService.CurrentDebugger.IsDebugging && context.SelectedTreeNodes != null && context.SelectedTreeNodes.Length > 0 && context.SelectedTreeNodes.All( delegate(SharpTreeNode n) { AssemblyTreeNode a = n as AssemblyTreeNode; if (a == null) { return false; } AssemblyDef asm = a.LoadedAssembly.AssemblyDefinition; return asm != null && asm.ManifestModule != null && (asm.ManifestModule.ManagedEntryPoint != null || asm.ManifestModule.NativeEntryPoint != 0); })); }
public void Execute(SharpTreeNode[] selectedNodes) { AssemblyTreeNode node = (AssemblyTreeNode)selectedNodes[0]; AssemblyDefinition asm = node.LoadedAssembly.AssemblyDefinition as AssemblyDefinition; if (asm != null) { SaveFileDialog dlg = new SaveFileDialog(); dlg.FileName = node.LoadedAssembly.FileName; dlg.Filter = "Assembly|*.dll;*.exe"; if (dlg.ShowDialog(MainWindow.Instance) == true) { asm.MainModule.Write(dlg.FileName); } } }
/// <summary> /// Returns the ancestor of type AssemblyTreeNode of the given node /// </summary> /// <param name="node"></param> /// <returns></returns> public static AssemblyTreeNode GetAssemblyNode(SharpTreeNode node) { AssemblyTreeNode moduleNode = null; SharpTreeNode currentNode = node; while (moduleNode == null) { if (currentNode.Parent == null) { break; } currentNode = currentNode.Parent; moduleNode = currentNode as AssemblyTreeNode; } return(moduleNode); }
public NamespaceTreeNodeCreator(string ns, AssemblyTreeNode asmNode) { Debug.Assert(asmNode.IsModule); if (!asmNode.IsModule) { throw new InvalidOperationException(); } this.asmNode = asmNode; this.nsNode = asmNode.FindNamespaceNode(ns); if (this.nsNode == null) { this.nsNode = new NamespaceTreeNode(ns); this.nsNodeCreated = true; } }
static int Main(string[] args) { if (args.Length != 2) { Console.WriteLine("usage: decompiler [dll] [output path]"); return 2; } var assemblies = new AssemblyList("global"); var assembly = assemblies.OpenAssembly(args[0]); assembly.WaitUntilLoaded(); var root = new AssemblyTreeNode(assembly); root.Decompile(new CSharpLanguage(), new PlainTextOutput(), new DecompilationOptions { SaveAsProjectDirectory = args[1], FullDecompilation = true, DecompilerSettings = new DecompilerSettings { YieldReturn = false } }); return 0; }
public TypeTreeNode(TypeDefinition type, AssemblyTreeNode parentAssemblyNode) { if (parentAssemblyNode == null) throw new ArgumentNullException("parentAssemblyNode"); if (type == null) throw new ArgumentNullException("type"); this.type = type; this.parentAssemblyNode = parentAssemblyNode; }
private static TreeNode GetNamespaceNode(AssemblyTreeNode asmNode, TypedefEntry iClass) { var names = Types.GetNamespaceChain(iClass.Name); TreeNode parentNode = asmNode; for (var i = 0; i < names.Length - 1; ++i) { var nextNode = FindNamespaceNode(parentNode.Nodes, names[i]); if (nextNode == null) { nextNode = new NamespaceTreeNode(asmNode.Assembly, names[i]) { NamespacePath = string.Join(".", names, 0, i + 1) }; parentNode.Nodes.Add(nextNode); } parentNode = nextNode; } return parentNode; }
void OnReportOpened(object sender, EventArgs e) { BeginUpdate(); var report = serviceContainer.getService<IReportService>().Report; foreach (var assembly in report.Assemblies) { var asmNode = new AssemblyTreeNode(assembly); Nodes.Add(asmNode); foreach (var dType in assembly.Types) { var namespaceNode = GetNamespaceNode(asmNode, dType); var classNode = new ClassTreeNode(dType); namespaceNode.Nodes.Add(classNode); var props = new Dictionary<string, PropertyTreeNode>(); foreach (var md in dType.Methods) { if (!Methods.IsSpecial(md.Flags)) { AddMethodTreeNode(classNode, md); continue; } //has special meaning var mdSpecial = Methods.GetMdSpecial(md.Name); if (mdSpecial == MdSpecial.Unknown) { AddMethodTreeNode(classNode, md); continue; } var propName = Methods.GetMdSpecialName(md.Name); PropertyTreeNode propertyNode; if (!props.TryGetValue(propName, out propertyNode)) { propertyNode = new PropertyTreeNode(propName); props[propName] = propertyNode; classNode.Nodes.Add(propertyNode); } var mdNode = new MethodTreeNode(md) { //MethodName = mdSpecial.ToString().ToLowerInvariant() }; switch (mdSpecial) { case MdSpecial.Get: mdNode.ImageIndex = ImageSelector.ForPropertyGet(md); mdNode.SelectedImageIndex = ImageSelector.ForPropertyGet(md); propertyNode.Getter = mdNode; break; case MdSpecial.Remove: mdNode.ImageIndex = ImageSelector.ForEventRemove(md); mdNode.SelectedImageIndex = ImageSelector.ForEventRemove(md); propertyNode.Getter = mdNode; break; case MdSpecial.Set: mdNode.ImageIndex = ImageSelector.ForPropertySet(md); mdNode.SelectedImageIndex = ImageSelector.ForPropertySet(md); propertyNode.Setter = mdNode; break; case MdSpecial.Add: mdNode.ImageIndex = ImageSelector.ForEventAdd(md); mdNode.SelectedImageIndex = ImageSelector.ForEventAdd(md); propertyNode.Setter = mdNode; break; } } foreach (var kv in props) { if (kv.Value.Getter != null) kv.Value.Nodes.Add(kv.Value.Getter); if (kv.Value.Setter != null) kv.Value.Nodes.Add(kv.Value.Setter); } } asmNode.UpdateCoverageInfo(); } EndUpdate(); }
void onReportOpened(object sender, EventArgs e) { BeginUpdate(); ICoverageReport report = serviceContainer.GetService<ICoverageReportService>().Report; foreach (IAssembly assembly in report.GetAssemblies()) { AssemblyTreeNode asmNode = new AssemblyTreeNode(assembly); Nodes.Add(asmNode); foreach (IClass dType in assembly.GetTypes()) { TreeNode namespaceNode = GetNamespaceNode(asmNode, dType); ClassTreeNode classNode = new ClassTreeNode(dType); namespaceNode.Nodes.Add(classNode); Dictionary<string, PropertyTreeNode> props = new Dictionary<string, PropertyTreeNode>(); foreach (IMethod md in dType.GetMethods()) { if (!Methods.isSpecial(md.Flags)) { AddMethodTreeNode(classNode, md); continue; } //has special meaning MdSpecial mdSpecial = Methods.getMdSpecial(md.Name); if (mdSpecial == MdSpecial.Unknown) { AddMethodTreeNode(classNode, md); continue; } string propName = Methods.getMdSpecialName(md.Name); PropertyTreeNode propertyNode; if (!props.TryGetValue(propName, out propertyNode)) { propertyNode = new PropertyTreeNode(propName); props[propName] = propertyNode; classNode.Nodes.Add(propertyNode); } MethodTreeNode mdNode = new MethodTreeNode(md); mdNode.MethodName = mdSpecial.ToString().ToLowerInvariant(); switch (mdSpecial) { case MdSpecial.Get: mdNode.ImageIndex = ImageSelector.forPropertyGet(md); mdNode.SelectedImageIndex = ImageSelector.forPropertyGet(md); propertyNode.Getter = mdNode; break; case MdSpecial.Remove: mdNode.ImageIndex = ImageSelector.forEventRemove(md); mdNode.SelectedImageIndex = ImageSelector.forEventRemove(md); propertyNode.Getter = mdNode; break; case MdSpecial.Set: mdNode.ImageIndex = ImageSelector.forPropertySet(md); mdNode.SelectedImageIndex = ImageSelector.forPropertySet(md); propertyNode.Setter = mdNode; break; case MdSpecial.Add: mdNode.ImageIndex = ImageSelector.forEventAdd(md); mdNode.SelectedImageIndex = ImageSelector.forEventAdd(md); propertyNode.Setter = mdNode; break; } } foreach (KeyValuePair<string, PropertyTreeNode> kv in props) { if (kv.Value.Getter != null) kv.Value.Nodes.Add(kv.Value.Getter); if (kv.Value.Setter != null) kv.Value.Nodes.Add(kv.Value.Setter); } } asmNode.UpdateCoverageInfo(); } EndUpdate(); }