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);
}
}
