public static void Main(string[] args) { var services = new ServiceContainer(); var listener = new CmdLineListener { Quiet = Console.IsOutputRedirected }; var config = RekoConfigurationService.Load(services); var diagnosticSvc = new CmdLineDiagnosticsService(Console.Out); var fsSvc = new FileSystemServiceImpl(); var dcSvc = new DecompilerService(); services.AddService <IDecompilerService>(dcSvc); services.AddService <DecompilerEventListener>(listener); services.AddService <IConfigurationService>(config); services.AddService <ITypeLibraryLoaderService>(new TypeLibraryLoaderServiceImpl(services)); services.AddService <IDiagnosticsService>(diagnosticSvc); services.AddService <IFileSystemService>(fsSvc); services.AddService <IDecompiledFileService>(new DecompiledFileService(fsSvc)); services.AddService <ITestGenerationService>(new TestGenerationService(services)); var ldr = new Loader(services); var decompiler = new Decompiler(ldr, services); dcSvc.Decompiler = decompiler; var driver = new CmdLineDriver(services, ldr, decompiler, listener); driver.Execute(args); }
public void DecSvc_DecompilerProjectName() { IDecompilerService svc = new DecompilerService(); var loader = mr.StrictMock <ILoader>(); var host = mr.StrictMock <DecompilerHost>(); var arch = mr.StrictMock <IProcessorArchitecture>(); var platform = mr.StrictMock <Platform>(sc, arch); var fileName = "foo\\bar\\baz.exe"; var bytes = new byte[100]; var image = new LoadedImage(Address.Ptr32(0x1000), bytes); var imageMap = image.CreateImageMap(); var prog = new Program(image, imageMap, arch, platform); loader.Stub(l => l.LoadImageBytes(fileName, 0)).Return(bytes); loader.Stub(l => l.LoadExecutable(fileName, bytes, null)).Return(prog); loader.Replay(); var dec = new DecompilerDriver(loader, host, sc); mr.ReplayAll(); svc.Decompiler = dec; svc.Decompiler.Load(fileName); Assert.IsNotNull(svc.Decompiler.Project); Assert.AreEqual("baz.exe", svc.ProjectName, "Should have project name available."); mr.VerifyAll(); }
public void DecSvc_DecompilerProjectName() { IDecompilerService svc = new DecompilerService(); var loader = new Mock <ILoader>(); var host = new Mock <IDecompiledFileService>(); var arch = new Mock <IProcessorArchitecture>(); arch.Setup(a => a.Name).Returns("FakeArch"); var platform = new Mock <IPlatform>(); var fileName = OsPath.Relative("foo", "bar", "baz.exe"); var bytes = new byte[100]; var mem = new MemoryArea(Address.Ptr32(0x1000), bytes); var imageMap = new SegmentMap( mem.BaseAddress, new ImageSegment("code", mem, AccessMode.ReadWriteExecute)); var program = new Program(imageMap, arch.Object, platform.Object); sc.AddService <IDecompiledFileService>(host.Object); platform.Setup(p => p.CreateMetadata()).Returns(new TypeLibrary()); loader.Setup(l => l.LoadImageBytes(fileName, 0)).Returns(bytes); loader.Setup(l => l.LoadExecutable(fileName, bytes, null, null)).Returns(program); var dec = new Decompiler(loader.Object, sc); svc.Decompiler = dec; svc.Decompiler.Load(fileName); Assert.IsNotNull(svc.Decompiler.Project); Assert.AreEqual("baz.exe", svc.ProjectName, "Should have project name available."); }
public void DecSvc_DecompilerProjectName() { IDecompilerService svc = new DecompilerService(); var host = new Mock <IDecompiledFileService>(); var arch = new Mock <IProcessorArchitecture>(); arch.Setup(a => a.Name).Returns("FakeArch"); arch.Setup(a => a.MemoryGranularity).Returns(8); var platform = new Mock <IPlatform>(); var fileUri = ImageLocation.FromUri(OsPath.Relative("foo", "bar", "baz.exe")); var bytes = new byte[100]; var mem = new ByteMemoryArea(Address.Ptr32(0x1000), bytes); var imageMap = new SegmentMap( mem.BaseAddress, new ImageSegment("code", mem, AccessMode.ReadWriteExecute)); var program = new Program(imageMap, arch.Object, platform.Object); var project = new Project(ImageLocation.FromUri("foo/bar/baz.project")); project.AddProgram(fileUri, program); sc.AddService <IDecompiledFileService>(host.Object); //$REVIEW: we can probably remove the code below, it never is called // anymore. platform.Setup(p => p.CreateMetadata()).Returns(new TypeLibrary()); platform.Setup(p => p.Architecture).Returns(arch.Object); var dec = new Decompiler(project, sc); svc.Decompiler = dec; Assert.IsNotNull(svc.Decompiler.Project); Assert.AreEqual("baz.exe", svc.ProjectName, "Should have project name available."); }
private TripleObject BuildFromTriple(Instruction fromInstruction, string fromInstanceOwnerKey, MethodDefinition parentMethod) { var tripleObj = new TripleObject(); tripleObj.Instruction = fromInstruction; var fromObjectType = InstructionKeyService.GetFromObjectType(fromInstruction); tripleObj.ObjectType = fromObjectType; if (fromObjectType == ObjectType.Argument) { int fromArgumentIndex = (int)DecompilerService.GetPosition(fromInstruction); tripleObj.ObjectKey = InstructionKeyService.GetObjectKey(fromInstruction, fromObjectType, parentMethod, fromArgumentIndex); } else { tripleObj.ObjectKey = InstructionKeyService.GetObjectKey(fromInstruction, fromObjectType, parentMethod); } tripleObj.InstructionKey = InstructionKeyService.GetInstructionKey(fromInstruction, parentMethod); tripleObj.OwnerTypeCategory = InstructionKeyService.GetTypeCategory(fromInstruction); tripleObj.OwnerTypeKey = InstructionKeyService.GetTypeKey(fromInstruction); tripleObj.InheritsFromConcreteClass = InstructionKeyService.GetConcreteInheritance(fromInstruction); tripleObj.InstanceOwnerKey = fromInstanceOwnerKey; return(tripleObj); }
private void IndexInterfaceMethods(ModuleDefinition module) { var interfaceMethods = DecompilerService.GetInterfaceMethods(module); foreach (var method in interfaceMethods) { // index by a simplified generic signature if it is a generic interface method var genericSignature = SignatureKeyService.GetGenericMethodSignature(method); if (!string.IsNullOrEmpty(genericSignature)) { if (!InterfaceMethodsIndexedByGenericSignature.ContainsKey(genericSignature)) { InterfaceMethodsIndexedByGenericSignature.Add(genericSignature, method); } } // index by the standard method signature var methodSignature = SignatureKeyService.GetFullMethodSignature(method); if (!InterfaceMethodsIndexedByName.ContainsKey(methodSignature)) { InterfaceMethodsIndexedByName.Add(methodSignature, method); } InterfaceMethodsIndexedByTypeName.Add(method.DeclaringType.FullName, method); InterfaceMethodsList.Add(method); } }
private void IndexConcreteMethods(ModuleDefinition module) { var implementationMethods = DecompilerService.GetConcreteMethods(module); foreach (var method in implementationMethods) { if (ShouldSkip(method)) { continue; } var methodNameKey = SignatureKeyService.GetFullMethodSignature(method); if (!ImplementationMethodsIndexedByName.ContainsKey(methodNameKey)) { ImplementationMethodsIndexedByName.Add(methodNameKey, method); ImplementationMethodsList.Add(method); ImplementationMethodsIndexedByTypeName.Add(method.DeclaringType.FullName, method); } var genericSignature = SignatureKeyService.GetGenericMethodSignature(method); if (!string.IsNullOrEmpty(genericSignature)) { if (!ImplementationMethodsIndexedByGenericSignature.ContainsKey(genericSignature)) { ImplementationMethodsIndexedByGenericSignature.Add(genericSignature, method); } } } }
public void DecSvc_DecompilerProjectName() { IDecompilerService svc = new DecompilerService(); var loader = mr.StrictMock <ILoader>(); var host = mr.StrictMock <DecompilerHost>(); var arch = mr.StrictMock <IProcessorArchitecture>(); var platform = mr.StrictMock <IPlatform>(); var fileName = "foo\\bar\\baz.exe"; var bytes = new byte[100]; var mem = new MemoryArea(Address.Ptr32(0x1000), bytes); var imageMap = new ImageMap( mem.BaseAddress, new ImageSegment("code", mem, AccessMode.ReadWriteExecute)); var prog = new Program(imageMap, arch, platform); sc.AddService <DecompilerHost>(host); platform.Stub(p => p.CreateMetadata()).Return(new TypeLibrary()); loader.Stub(l => l.LoadImageBytes(fileName, 0)).Return(bytes); loader.Stub(l => l.LoadExecutable(fileName, bytes, null)).Return(prog); loader.Replay(); var dec = new DecompilerDriver(loader, sc); mr.ReplayAll(); svc.Decompiler = dec; svc.Decompiler.Load(fileName); Assert.IsNotNull(svc.Decompiler.Project); Assert.AreEqual("baz.exe", svc.ProjectName, "Should have project name available."); mr.VerifyAll(); }
private void DoCrossAssemblyWalk(MethodGraph methodGraph, string companyAssembliesPattern, ModuleDefinition module, string moduleMessagee) { var publicMethods = DecompilerService.GetPublicMethods(companyAssembliesPattern, module) .Where(x => !IsBlackListed(x)) .OrderBy(x => x.DeclaringType.Name) .ThenBy(x => x.Name) .ToList(); int methodCount = publicMethods.Count; var publicMethodsAnalyzed = new HashSet <string>(); _methodNodeLookup.Clear(); int methodCounter = 0; foreach (var publicMethod in publicMethods) { methodCounter++; _logOutput.LogAnalysis("Method " + methodCounter + " of " + methodCount + " : " + moduleMessagee + " -> " + publicMethod.Name); if ((publicMethod.IsGetter || publicMethod.IsSetter) && !IsNoteworthyProperty(publicMethod)) { continue; } var signature = SignatureKeyService.GetFullMethodSignature(publicMethod); if (_methodIndexer.HasMethod(signature)) { var unfilteredRootNodes = _methodIndexer.GetMethods(signature); var rootNodes = unfilteredRootNodes.Where(x => x.HasImplementation() && ( // if it is a public implementation of a different assembly, then'll we'll filter it out here (and analyze it that assembly) (x.ConcreteMethod.IsPublic && x.ConcreteMethod.Module.Name.Equals(module.Name)) // if it is a private implementation then analyze it now as we'll miss it when we analyze the public methods of the other assembly || !x.ConcreteMethod.DeclaringType.IsPublic ) ) .ToList(); foreach (var rootMethod in rootNodes) { if (!AlreadyProcessed(rootMethod.GetMethodDefinition())) { var publicMethodNode = GetMethodNode(methodGraph.GraphType, methodGraph.ApplicationName, rootMethod); var callTreeNode = new ExploreTreeNode() { FullSignature = signature }; CrossAssemblyWalk(methodGraph, publicMethodNode, rootMethod, 1, callTreeNode); CacheNode(rootMethod.GetMethodDefinition(), publicMethodNode); methodGraph.AddMethodNode(publicMethodNode); } } } } }
private void IndexAbstractMethods(ModuleDefinition module) { var abstractMethods = DecompilerService.GetAbstractMethods(module); foreach (var method in abstractMethods) { AbstractMethodsIndexedByName.Add(SignatureKeyService.GetFullMethodSignature(method), method); AbstractMethodsIndexedByTypeName.Add(method.DeclaringType.FullName, method); AbstractMethodsList.Add(method); } }
public IDocumentTabContent Deserialize(Guid guid, ISettingsSection section, IDocumentTabContentFactoryContext context) { if (guid != GUID_SerializedContent) { return(null); } var langGuid = section.Attribute <Guid?>("Language") ?? DecompilerConstants.LANGUAGE_CSHARP; var language = DecompilerService.FindOrDefault(langGuid); return(new DecompileDocumentTabContent(this, context.Nodes, language)); }
public void Setup() { form = new Mock <IMainForm>(); sc = new ServiceContainer(); uiSvc = AddService <IDecompilerShellUiService>(); sc.AddService <IDecompilerUIService>(uiSvc.Object); codeViewSvc = AddService <ICodeViewerService>(); memViewSvc = AddService <ILowLevelViewService>(); disasmViewSvc = AddService <IDisassemblyViewService>(); pbSvc = AddService <IProjectBrowserService>(); form.Setup(f => f.Show()); var arch = new X86ArchitectureFlat32(sc, "x86-protected-32"); var platform = new Mock <IPlatform>(); platform.Setup(p => p.CreateMetadata()).Returns(new TypeLibrary()); platform.Setup(p => p.Architecture).Returns(arch); var loadAddress = Address.Ptr32(0x100000); var bytes = new byte[4711]; var mem = new ByteMemoryArea(loadAddress, bytes); this.program = new Program { SegmentMap = new SegmentMap( mem.BaseAddress, new ImageSegment(".text", mem, AccessMode.ReadExecute)), Architecture = arch, Platform = platform.Object, }; var ldr = new Mock <ILoader>(); ldr.Setup(l => l.LoadExecutable( It.IsAny <string>(), It.IsAny <byte[]>(), It.IsAny <string>(), It.IsAny <Address>())).Returns(program); ldr.Setup(l => l.LoadImageBytes( It.IsAny <string>(), It.IsAny <int>())).Returns(bytes); sc.AddService <DecompilerEventListener>(new FakeDecompilerEventListener()); sc.AddService <IDecompiledFileService>(new FakeDecompiledFileService()); this.decSvc = new DecompilerService(); decSvc.Decompiler = new Decompiler(ldr.Object, sc); decSvc.Decompiler.Load("test.exe"); this.program = this.decSvc.Decompiler.Project.Programs.First(); sc.AddService <IDecompilerService>(decSvc); sc.AddService <IWorkerDialogService>(new FakeWorkerDialogService()); }
public AnalysisPhaseResult LoadApplication(string companyAssembliesPattern, ApplicationDetails application) { try { var assembliesFolder = AssemblyPathFinder.GetAssembliesFolder(application.FullFolderPath); if (assembliesFolder == null) { return(AnalysisPhaseResult.CouldNotFindBinFolder); } var companyAssembliesInFolder = AssemblyPathFinder.GetCompanyAssemblies(companyAssembliesPattern, assembliesFolder); if (!companyAssembliesInFolder.Any()) { return(AnalysisPhaseResult.NoCompanyDllsFound); } AnalysisScope.ApplicationAssemblies = companyAssembliesInFolder; EmptyIndexes(); foreach (var companyAssembly in companyAssembliesInFolder) { var module = DecompilerService.GetModuleDefinition(assembliesFolder, companyAssembly); _modulesToAnalyze.Add(module); } foreach (var module in _modulesToAnalyze) { if (!_assembliesProcessed.Contains(module.Assembly.FullName)) { _assembliesProcessed.Add(module.Assembly.FullName); _assignmentGraphIndexer.IndexTriples(module); _methodIndexer.Load(module); } } _delegateIndexer.Load(_modulesToAnalyze); _methodIndexer.BuildMethodObjects(application.CsProjName); _typeService.Load(_modulesToAnalyze); return(AnalysisPhaseResult.Success); } catch (Exception ex) { _logOutput.LogError("Failed analyzing application. ", ex); return(AnalysisPhaseResult.Failed); } }
public static string GetObjectKey(Instruction instruction, ObjectType objectType, MethodReference methodOfArgument, int?argumentIndex = null) { if (objectType == ObjectType.Argument && !argumentIndex.HasValue) { argumentIndex = (int)DecompilerService.GetPosition(instruction); } switch (objectType) { case ObjectType.Argument: return(methodOfArgument.GetKey() + ">>" + argumentIndex); case ObjectType.NilArgument: var nilArgMethodReference = (MethodReference)instruction.Operand; return(nilArgMethodReference.GetKey() + ">>0"); case ObjectType.Field: var fieldReference = (FieldReference)instruction.Operand; return(fieldReference.GetKey()); case ObjectType.LocalVariable: var stackPosition = DecompilerService.GetPosition(instruction); return(methodOfArgument.GetKey() + " StackPosition:" + stackPosition); case ObjectType.ReturnValue: return(methodOfArgument.GetKey() + ">>return"); case ObjectType.Method: var methodReference = (MethodReference)instruction.Operand; return(methodReference.GetKey() + ">>return"); case ObjectType.InlineString: return(instruction.Operand.ToString()); case ObjectType.InlineNumber: var number = DecompilerService.GetPosition(instruction); return(number.ToString()); case ObjectType.None: return(null); default: throw new ILParseException("Unsupported ObjectType: " + objectType); } }
public void Setup() { //$REVIEW: we can probably remove the code below, it never is called // anymore. form = new Mock <IMainForm>(); sc = new ServiceContainer(); uiSvc = AddService <IDecompilerShellUiService>(); sc.AddService <IDecompilerUIService>(uiSvc.Object); codeViewSvc = AddService <ICodeViewerService>(); memViewSvc = AddService <ILowLevelViewService>(); disasmViewSvc = AddService <IDisassemblyViewService>(); pbSvc = AddService <IProjectBrowserService>(); form.Setup(f => f.Show()); var arch = new X86ArchitectureFlat32(sc, "x86-protected-32", new Dictionary <string, object>()); var platform = new Mock <IPlatform>(); platform.Setup(p => p.CreateMetadata()).Returns(new TypeLibrary()); platform.Setup(p => p.Architecture).Returns(arch); var loadAddress = Address.Ptr32(0x100000); var bytes = new byte[4711]; var mem = new ByteMemoryArea(loadAddress, bytes); this.program = new Program { SegmentMap = new SegmentMap( mem.BaseAddress, new ImageSegment(".text", mem, AccessMode.ReadExecute)), Architecture = arch, Platform = platform.Object, }; var project = new Project(ImageLocation.FromUri("/home/bob/reko.project")); project.AddProgram(ImageLocation.FromUri("/home/bob/test.exe"), program); sc.AddService <DecompilerEventListener>(new FakeDecompilerEventListener()); sc.AddService <IDecompiledFileService>(new FakeDecompiledFileService()); this.decSvc = new DecompilerService(); decSvc.Decompiler = new Decompiler(project, sc); this.program = this.decSvc.Decompiler.Project.Programs.First(); sc.AddService <IDecompilerService>(decSvc); sc.AddService <IWorkerDialogService>(new FakeWorkerDialogService()); }
public void Setup() { mr = new MockRepository(); form = mr.StrictMock <IMainForm>(); sc = new ServiceContainer(); uiSvc = AddService <IDecompilerShellUiService>(); sc.AddService(typeof(IDecompilerUIService), uiSvc); codeViewSvc = AddService <ICodeViewerService>(); memViewSvc = AddService <ILowLevelViewService>(); disasmViewSvc = AddService <IDisassemblyViewService>(); pbSvc = AddService <IProjectBrowserService>(); form.Stub(f => f.Show()); var platform = mr.Stub <IPlatform>(); var loadAddress = Address.Ptr32(0x100000); var bytes = new byte[4711]; var arch = new X86ArchitectureFlat32(); var mem = new MemoryArea(loadAddress, bytes); Program prog = new Program { SegmentMap = new SegmentMap( mem.BaseAddress, new ImageSegment(".text", mem, AccessMode.ReadExecute)), Architecture = arch, Platform = platform, }; ILoader ldr = mr.StrictMock <ILoader>(); ldr.Stub(l => l.LoadExecutable(null, null, null)).IgnoreArguments().Return(prog); ldr.Stub(l => l.LoadImageBytes(null, 0)).IgnoreArguments().Return(bytes); ldr.Replay(); sc.AddService(typeof(DecompilerEventListener), new FakeDecompilerEventListener()); sc.AddService <DecompilerHost>(new FakeDecompilerHost()); this.decSvc = new DecompilerService(); decSvc.Decompiler = new DecompilerDriver(ldr, sc); decSvc.Decompiler.Load("test.exe"); program = decSvc.Decompiler.Project.Programs.First(); decSvc.Decompiler.ScanPrograms(); sc.AddService(typeof(IDecompilerService), decSvc); sc.AddService(typeof(IWorkerDialogService), new FakeWorkerDialogService()); }
private IDecompilerService CreateDecompiler(ServiceContainer sc) { var dcSvc = new DecompilerService(); dcSvc.Decompiler = new Decompiler(new Loader(sc), sc) { Project = new Project { Programs = { new Reko.Core.Program { DisassemblyDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) !, } } } }; return(dcSvc); }
public void Setup() { mr = new MockRepository(); form = mr.StrictMock <IMainForm>(); sc = new ServiceContainer(); uiSvc = AddService <IDecompilerShellUiService>(); sc.AddService(typeof(IDecompilerUIService), uiSvc); codeViewSvc = AddService <ICodeViewerService>(); memViewSvc = AddService <ILowLevelViewService>(); disasmViewSvc = AddService <IDisassemblyViewService>(); pbSvc = AddService <IProjectBrowserService>(); form.Stub(f => f.Show()); var loadAddress = Address.Ptr32(0x100000); var bytes = new byte[4711]; Program prog = new Program(); prog.Image = new LoadedImage(loadAddress, bytes); prog.ImageMap = prog.Image.CreateImageMap(); prog.Architecture = new IntelArchitecture(ProcessorMode.Protected32); ILoader ldr = mr.StrictMock <ILoader>(); ldr.Stub(l => l.LoadExecutable(null, null, null)).IgnoreArguments().Return(prog); ldr.Stub(l => l.LoadImageBytes(null, 0)).IgnoreArguments().Return(bytes); ldr.Replay(); sc.AddService(typeof(DecompilerEventListener), new FakeDecompilerEventListener()); this.decSvc = new DecompilerService(); decSvc.Decompiler = new DecompilerDriver(ldr, new FakeDecompilerHost(), sc); decSvc.Decompiler.Load("test.exe"); program = decSvc.Decompiler.Project.Programs.First(); decSvc.Decompiler.ScanPrograms(); sc.AddService(typeof(IDecompilerService), decSvc); sc.AddService(typeof(IWorkerDialogService), new FakeWorkerDialogService()); }
private void Load(ModuleDefinition module) { var concreteMethods = DecompilerService.GetConcreteMethods(module); foreach (var method in concreteMethods) { if (TypeService.ShouldSkipDelegateIndexing(method.DeclaringType)) { continue; } foreach (var instruction in method.Body.Instructions) { if (instruction.OpCode.OperandType == Mono.Cecil.Cil.OperandType.InlineMethod) { var calledMethod = (MethodReference)instruction.Operand; if (IsDelegateInvocation(calledMethod)) { IndexDelegateInvocation(instruction, calledMethod, method); } } } } }
public void DecSvc_EmptyDecompilerProjectName() { IDecompilerService svc = new DecompilerService(); Assert.IsEmpty(svc.ProjectName, "Shouldn't have project name available."); }
public void Run(ResolveResult symbol) { if (ProjectService.CurrentProject == null) { return; } string filePath = null; if (symbol is MemberResolveResult) { var s = (MemberResolveResult)symbol; DecompilerService.ReadMetadata(s.ResolvedMember.DeclaringType, out filePath); if (string.IsNullOrEmpty(filePath)) { return; } // jump to definition var info = ParserService.ParseFile(filePath); if (info == null) { return; } int line = 0, col = 0; foreach (var c in info.CompilationUnit.Classes) { if (s.ResolvedMember.EntityType == EntityType.Event) { foreach (var ev in c.Events) { if (s.ResolvedMember.FullyQualifiedName == ev.FullyQualifiedName && s.ResolvedMember.ReturnType.FullyQualifiedName == ev.ReturnType.FullyQualifiedName) { col = ev.Region.BeginColumn; line = ev.Region.BeginLine; } } if (col > 0 || line > 0) { break; } } if (s.ResolvedMember.EntityType == EntityType.Method) { foreach (var m1 in s.ResolvedMember.DeclaringType.Methods) { if (s.ResolvedMember.ReturnType.FullyQualifiedName != m1.ReturnType.FullyQualifiedName || s.ResolvedMember.FullyQualifiedName != m1.FullyQualifiedName) { continue; } foreach (var m in c.Methods) { if (m1.FullyQualifiedName == m.FullyQualifiedName && m1.ReturnType.FullyQualifiedName == m1.ReturnType.FullyQualifiedName && m1.Parameters.Count == m.Parameters.Count) { col = m.Region.BeginColumn; line = m.Region.BeginLine; break; } } if (col > 0 || line > 0) { break; } } if (col > 0 || line > 0) { break; } } if (s.ResolvedMember.EntityType == EntityType.Property) { foreach (var p in c.Properties) { if (s.ResolvedMember.FullyQualifiedName == p.FullyQualifiedName && s.ResolvedMember.ReturnType.FullyQualifiedName == p.ReturnType.FullyQualifiedName) { col = p.Region.BeginColumn; line = p.Region.BeginLine; break; } } if (col > 0 || line > 0) { break; } } } if (col > 0 || line > 0) { FileService.JumpToFilePosition(filePath, line, col); } else { FileService.OpenFile(filePath); } } if (symbol is TypeResolveResult) { var s = (TypeResolveResult)symbol; DecompilerService.ReadMetadata(s.ResolvedClass, out filePath); if (!string.IsNullOrEmpty(filePath)) { FileService.OpenFile(filePath); } } }
public virtual void ShowMembers(bool forceRefresh = false) { if (Nodes.Count > 0 && !forceRefresh) { return; } Nodes.Clear(); foreach (var ev in type.Events) { if (ev.AddMethod == null && ev.RemoveMethod == null) { continue; } if (ev.AddMethod != null && !ev.AddMethod.IsPublic && ev.RemoveMethod != null && !ev.RemoveMethod.IsPublic) { continue; } new PublicEventNode(ev.Name, ev, type).InsertSorted(this); } foreach (var property in type.Properties) { if (property.GetMethod == null && property.SetMethod == null) { continue; } if (property.GetMethod != null && !property.GetMethod.IsPublic && property.SetMethod != null && !property.SetMethod.IsPublic) { continue; } new PublicPropertyNode(property.Name, property, type).InsertSorted(this); } foreach (var method in type.Methods) { if (!method.IsPublic) { continue; } if (method.Name.StartsWith("get_") || method.Name.StartsWith("set_")) { continue; } StringBuilder sb = new StringBuilder(); if (!method.IsConstructor) { sb.Append(method.Name); } else { sb.Append(method.DeclaringType.Name); } sb.Append(DecompilerService.GetParameters(method)); new PublicMethodNode(sb.ToString(), method, type).InsertSorted(this); } }