Exemple #1
0
        TypeDefSettingsCommand(ModuleDef module, ITypeNode typeNode, TypeDefOptions options)
        {
            this.module      = module;
            this.typeNode    = typeNode;
            this.newOptions  = options;
            this.origOptions = new TypeDefOptions(typeNode.TypeDef);

            this.origParentNode       = (IDocumentTreeNodeData)typeNode.TreeNode.Parent.Data;
            this.origParentChildIndex = this.origParentNode.TreeNode.Children.IndexOf(typeNode.TreeNode);
            Debug.Assert(this.origParentChildIndex >= 0);
            if (this.origParentChildIndex < 0)
            {
                throw new InvalidOperationException();
            }

            this.nameChanged = origOptions.Name != newOptions.Name;
            if (this.origParentNode is INamespaceNode)
            {
                var modNode = (IModuleDocumentNode)this.origParentNode.TreeNode.Parent.Data;
                if (newOptions.Namespace != origOptions.Namespace)
                {
                    this.nsNodeCreator = new NamespaceNodeCreator(newOptions.Namespace, modNode);
                }
            }

            if (this.nameChanged || origOptions.Namespace != newOptions.Namespace)
            {
                this.typeRefInfos = RefFinder.FindTypeRefsToThisModule(module).Where(a => RefFinder.TypeEqualityComparerInstance.Equals(a, typeNode.TypeDef)).Select(a => new TypeRefInfo(a)).ToArray();
            }
        }
        RenameNamespaceCommand(string newName, INamespaceNode nsNode)
        {
            this.newName        = newName;
            this.origName       = nsNode.Name;
            this.nsNode         = nsNode;
            this.existingNsNode = (INamespaceNode)nsNode.TreeNode.Parent.DataChildren.FirstOrDefault(a => a is INamespaceNode && newName == ((INamespaceNode)a).Name);

            var module = nsNode.GetModule();

            Debug.Assert(module != null);
            if (module == null)
            {
                throw new InvalidOperationException();
            }

            this.origParentNode       = (IDocumentTreeNodeData)nsNode.TreeNode.Parent.Data;
            this.origParentChildIndex = this.origParentNode.TreeNode.Children.IndexOf(nsNode.TreeNode);
            Debug.Assert(this.origParentChildIndex >= 0);
            if (this.origParentChildIndex < 0)
            {
                throw new InvalidOperationException();
            }

            // Make sure the exact same namespace names are restored if we undo. The names are UTF8
            // strings, but not necessarily canonicalized if it's an obfuscated assembly.
            nsNode.TreeNode.EnsureChildrenLoaded();
            this.origChildren   = nsNode.TreeNode.DataChildren.Cast <ITypeNode>().ToArray();
            this.typeNamespaces = new UTF8String[nsNode.TreeNode.Children.Count];
            for (int i = 0; i < this.typeNamespaces.Length; i++)
            {
                this.typeNamespaces[i] = origChildren[i].TypeDef.Namespace;
            }

            this.typeRefInfos = GetTypeRefInfos(module, new[] { nsNode });
        }
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="node">Node</param>
 public DocumentTreeNodeActivatedEventArgs(IDocumentTreeNodeData node)
 {
     if (node == null)
     {
         throw new ArgumentNullException(nameof(node));
     }
     this.Node = node;
 }
Exemple #4
0
        IDocumentTreeNodeData[] GetChildren(IDocumentTreeNodeData node)
        {
            var n = node;

            return((IDocumentTreeNodeData[])execInThread(() => {
                n.TreeNode.EnsureChildrenLoaded();
                return n.TreeNode.DataChildren.OfType <IDocumentTreeNodeData>().ToArray();
            }));
        }
        public override DocumentTreeNodeFilterResult GetResult(IDocumentTreeNodeData node)
        {
            bool isMatch = (flags & VisibleMembersFlags.Other) != 0;

            if (!isMatch)
            {
                return(new DocumentTreeNodeFilterResult(FilterType.Hide, isMatch));
            }
            return(new DocumentTreeNodeFilterResult(FilterType.Visible, isMatch));
        }
        DocumentTabReferenceResult Create(IDocumentTreeNodeData node)
        {
            var content = documentTabContentFactoryService.CreateTabContent(new IDocumentTreeNodeData[] { node });

            if (content == null)
            {
                return(null);
            }
            return(new DocumentTabReferenceResult(content));
        }
Exemple #7
0
 void DecompileNode(IDecompileNodeContext context, IDocumentTreeNodeData node)
 {
     foreach (var d in decompileNodes)
     {
         if (d.Decompile(context, node))
         {
             return;
         }
     }
     Debug.Fail("Missing decompiler");
 }
Exemple #8
0
        CreateTypeDefCommand(IList <TypeDef> ownerList, IDocumentTreeNodeData ownerNode, TypeDefOptions options)
        {
            this.ownerList = ownerList;
            var modNode = ownerNode.GetModuleNode();

            Debug.Assert(modNode != null);
            if (modNode == null)
            {
                throw new InvalidOperationException();
            }
            this.nsNodeCreator = new NamespaceNodeCreator(options.Namespace, modNode);
            this.typeNode      = modNode.Context.DocumentTreeView.Create(options.CreateTypeDef(modNode.Document.ModuleDef));
        }
Exemple #9
0
		PropertyDefSettingsCommand(IPropertyNode propNode, PropertyDefOptions options) {
			this.propNode = propNode;
			this.newOptions = options;
			this.origOptions = new PropertyDefOptions(propNode.PropertyDef);

			this.origParentNode = (IDocumentTreeNodeData)propNode.TreeNode.Parent.Data;
			this.origParentChildIndex = this.origParentNode.TreeNode.Children.IndexOf(propNode.TreeNode);
			Debug.Assert(this.origParentChildIndex >= 0);
			if (this.origParentChildIndex < 0)
				throw new InvalidOperationException();

			this.nameChanged = origOptions.Name != newOptions.Name;
		}
Exemple #10
0
        void DecompileUnknown(IDocumentTreeNodeData node)
        {
            var decompileSelf = node as IDecompileSelf;

            if (decompileSelf != null && decompileNodeContext != null)
            {
                if (decompileSelf.Decompile(decompileNodeContext))
                {
                    return;
                }
            }
            decompiler.WriteCommentLine(output, NameUtilities.CleanName(node.ToString(decompiler)));
        }
Exemple #11
0
        public static SerializedPath Create(IDocumentTreeNodeData node)
        {
            var path = new SerializedPath();

            while (node != null && node.TreeNode.Parent != null)
            {
                path.Names.Add(node.NodePathName);
                var parent = node.TreeNode.Parent;
                node = parent.Data as IDocumentTreeNodeData;
            }
            path.Names.Reverse();

            return(path);
        }
        public bool Decompile(IDecompileNodeContext context, IDocumentTreeNodeData node)
        {
            var msgNode = node as SomeMessageNode;

            if (msgNode == null)
            {
                return(false);
            }

            context.Decompiler.WriteCommentLine(context.Output, "The secret message has been decrypted.");
            context.Decompiler.WriteCommentLine(context.Output, string.Format("The message is: {0}", msgNode.Message));
            context.ContentTypeString = ContentTypes.PlainText;
            return(true);
        }
Exemple #13
0
        public bool RaiseNodeActivated(IDocumentTreeNodeData node)
        {
            if (node == null)
            {
                throw new ArgumentNullException(nameof(node));
            }
            if (NodeActivated == null)
            {
                return(false);
            }
            var e = new DocumentTreeNodeActivatedEventArgs(node);

            NodeActivated(this, e);
            return(e.Handled);
        }
Exemple #14
0
        static NodeType GetNodeType(IDocumentTreeNodeData node)
        {
            NodeType nodeType;
            var      type = node.GetType();

            lock (lockObj) {
                if (toNodeType.TryGetValue(type, out nodeType))
                {
                    return(nodeType);
                }

                nodeType = GetNodeTypeSlow(node);
                toNodeType.Add(type, nodeType);
            }
            return(nodeType);
        }
Exemple #15
0
        EventDefSettingsCommand(IEventNode eventNode, EventDefOptions options)
        {
            this.eventNode   = eventNode;
            this.newOptions  = options;
            this.origOptions = new EventDefOptions(eventNode.EventDef);

            this.origParentNode       = (IDocumentTreeNodeData)eventNode.TreeNode.Parent.Data;
            this.origParentChildIndex = this.origParentNode.TreeNode.Children.IndexOf(eventNode.TreeNode);
            Debug.Assert(this.origParentChildIndex >= 0);
            if (this.origParentChildIndex < 0)
            {
                throw new InvalidOperationException();
            }

            this.nameChanged = origOptions.Name != newOptions.Name;
        }
Exemple #16
0
        MethodDefSettingsCommand(IMethodNode methodNode, MethodDefOptions options)
        {
            this.methodNode  = methodNode;
            this.newOptions  = options;
            this.origOptions = new MethodDefOptions(methodNode.MethodDef);

            this.origParentNode       = (IDocumentTreeNodeData)methodNode.TreeNode.Parent.Data;
            this.origParentChildIndex = this.origParentNode.TreeNode.Children.IndexOf(methodNode.TreeNode);
            Debug.Assert(this.origParentChildIndex >= 0);
            if (this.origParentChildIndex < 0)
            {
                throw new InvalidOperationException();
            }

            this.nameChanged = origOptions.Name != newOptions.Name;
            if (this.nameChanged)
            {
                this.memberRefInfos = RefFinder.FindMemberRefsToThisModule(methodNode.GetModule()).Where(a => RefFinder.MethodEqualityComparerInstance.Equals(a, methodNode.MethodDef)).Select(a => new Field.MemberRefInfo(a)).ToArray();
            }
        }
Exemple #17
0
        static void Filter(IDocumentTreeNodeData node)
        {
            if (node == null)
            {
                return;
            }
            var res = node.GetFilterType(node.Context.Filter);

            switch (res)
            {
            case FilterType.Default:
            case FilterType.Visible:
                node.FilterVersion     = node.Context.FilterVersion;
                node.TreeNode.IsHidden = false;
                var fnode = node as DocumentTreeNodeData;
                if (fnode != null && fnode.refilter && node.TreeNode.Children.Count > 0)
                {
                    node.OnEnsureChildrenLoaded();
                }
                break;

            case FilterType.Hide:
                node.TreeNode.IsHidden = true;
                break;

            case FilterType.CheckChildren:
                node.FilterVersion = node.Context.FilterVersion;
                node.TreeNode.EnsureChildrenLoaded();
                node.TreeNode.IsHidden = node.TreeNode.Children.All(a => a.IsHidden);
                break;

            default:
                Debug.Fail($"Invalid type: {res}");
                goto case FilterType.Default;
            }
        }
 public virtual DocumentTreeNodeFilterResult GetResult(IDocumentTreeNodeData node) => new DocumentTreeNodeFilterResult(FilterType.Hide, false);
 public virtual DocumentTreeNodeFilterResult GetResult(IDocumentTreeNodeData node) => new DocumentTreeNodeFilterResult();
Exemple #20
0
        static NodeType GetNodeTypeSlow(IDocumentTreeNodeData node)
        {
            if (node is IAssemblyDocumentNode)
            {
                return(NodeType.Assembly);
            }
            if (node is IModuleDocumentNode)
            {
                return(NodeType.Module);
            }
            if (node is ITypeNode)
            {
                return(NodeType.Type);
            }
            if (node is IMethodNode)
            {
                return(NodeType.Method);
            }
            if (node is IFieldNode)
            {
                return(NodeType.Field);
            }
            if (node is IPropertyNode)
            {
                return(NodeType.Property);
            }
            if (node is IEventNode)
            {
                return(NodeType.Event);
            }
            if (node is IAssemblyReferenceNode)
            {
                return(NodeType.AssemblyRef);
            }
            if (node is IBaseTypeFolderNode)
            {
                return(NodeType.BaseTypeFolder);
            }
            if (node is IBaseTypeNode)
            {
                return(NodeType.BaseType);
            }
            if (node is IDerivedTypeNode)
            {
                return(NodeType.DerivedType);
            }
            if (node is IDerivedTypesFolderNode)
            {
                return(NodeType.DerivedTypesFolder);
            }
            if (node is IModuleReferenceNode)
            {
                return(NodeType.ModuleRef);
            }
            if (node is INamespaceNode)
            {
                return(NodeType.Namespace);
            }
            if (node is IPEDocumentNode)
            {
                return(NodeType.PEFile);
            }
            if (node is IReferencesFolderNode)
            {
                return(NodeType.ReferencesFolder);
            }
            if (node is IResourcesFolderNode)
            {
                return(NodeType.ResourcesFolder);
            }
            if (node is IResourceNode)
            {
                return(NodeType.Resource);
            }
            if (node is IResourceElementNode)
            {
                return(NodeType.ResourceElement);
            }
            if (node is IResourceElementSetNode)
            {
                return(NodeType.ResourceElementSet);
            }
            if (node is IUnknownDocumentNode)
            {
                return(NodeType.UnknownFile);
            }
            if (node is IMessageNode)
            {
                return(NodeType.Message);
            }

            return(NodeType.Unknown);
        }
Exemple #21
0
        public void Decompile(IDocumentTreeNodeData node)
        {
            var nodeType = GetNodeType(node);

            switch (nodeType)
            {
            case NodeType.Unknown:
                DecompileUnknown(node);
                break;

            case NodeType.Assembly:
                decompiler.Decompile(((IAssemblyDocumentNode)node).Document.AssemblyDef, output, decompilationContext);
                break;

            case NodeType.Module:
                decompiler.Decompile(((IModuleDocumentNode)node).Document.ModuleDef, output, decompilationContext);
                break;

            case NodeType.Type:
                decompiler.Decompile(((ITypeNode)node).TypeDef, output, decompilationContext);
                break;

            case NodeType.Method:
                decompiler.Decompile(((IMethodNode)node).MethodDef, output, decompilationContext);
                break;

            case NodeType.Field:
                decompiler.Decompile(((IFieldNode)node).FieldDef, output, decompilationContext);
                break;

            case NodeType.Property:
                decompiler.Decompile(((IPropertyNode)node).PropertyDef, output, decompilationContext);
                break;

            case NodeType.Event:
                decompiler.Decompile(((IEventNode)node).EventDef, output, decompilationContext);
                break;

            case NodeType.AssemblyRef:
                Decompile((IAssemblyReferenceNode)node);
                break;

            case NodeType.BaseTypeFolder:
                Decompile((IBaseTypeFolderNode)node);
                break;

            case NodeType.BaseType:
                Decompile((IBaseTypeNode)node);
                break;

            case NodeType.DerivedType:
                Decompile((IDerivedTypeNode)node);
                break;

            case NodeType.DerivedTypesFolder:
                Decompile((IDerivedTypesFolderNode)node);
                break;

            case NodeType.ModuleRef:
                Decompile((IModuleReferenceNode)node);
                break;

            case NodeType.Namespace:
                Decompile((INamespaceNode)node);
                break;

            case NodeType.PEFile:
                Decompile((IPEDocumentNode)node);
                break;

            case NodeType.ReferencesFolder:
                Decompile((IReferencesFolderNode)node);
                break;

            case NodeType.ResourcesFolder:
                Decompile((IResourcesFolderNode)node);
                break;

            case NodeType.Resource:
                Decompile((IResourceNode)node);
                break;

            case NodeType.ResourceElement:
                Decompile((IResourceElementNode)node);
                break;

            case NodeType.ResourceElementSet:
                Decompile((IResourceElementSetNode)node);
                break;

            case NodeType.UnknownFile:
                Decompile((IUnknownDocumentNode)node);
                break;

            case NodeType.Message:
                Decompile((IMessageNode)node);
                break;

            default:
                Debug.Fail(string.Format("Unknown NodeType: {0}", nodeType));
                goto case NodeType.Unknown;
            }
        }
 public virtual DocumentTreeNodeFilterResult GetResult(IDocumentTreeNodeData node) => this.filter.GetResult(node);
 public bool Decompile(IDecompileNodeContext context, IDocumentTreeNodeData node)
 {
     new NodeDecompiler(a => context.UIThread(() => a()), context.Output, context.Decompiler, context.DecompilationContext, context).Decompile(node);
     return(true);
 }