IEnumerable<SharpTreeNode> FindReferences(LoadedAssembly asm, CancellationToken ct) { string name = analyzedField.Name; string declTypeName = analyzedField.DeclaringType.FullName; foreach (TypeDefinition type in TreeTraversal.PreOrder(asm.AssemblyDefinition.MainModule.Types, t => t.NestedTypes)) { ct.ThrowIfCancellationRequested(); foreach (MethodDefinition method in type.Methods) { ct.ThrowIfCancellationRequested(); bool found = false; if (!method.HasBody) continue; foreach (Instruction instr in method.Body.Instructions) { if (CanBeReference(instr.OpCode.Code)) { FieldReference fr = instr.Operand as FieldReference; if (fr != null && fr.Name == name && fr.DeclaringType.FullName == declTypeName && fr.Resolve() == analyzedField) { found = true; break; } } } if (found) yield return new AnalyzedMethodTreeNode(method); } } }
public override bool HandleModelUpdated(LoadedAssembly asm) { this.LazyLoading = true; threading.Cancel(); this.Children.Clear(); return true; }
IEnumerable<SharpTreeNode> FindReferences(LoadedAssembly asm, CancellationToken ct) { string asmName = asm.AssemblyDefinition.Name.Name; string name = analyzedProperty.Name; string declTypeName = analyzedProperty.DeclaringType.FullName; foreach (TypeDefinition type in TreeTraversal.PreOrder(asm.AssemblyDefinition.MainModule.Types, t => t.NestedTypes)) { ct.ThrowIfCancellationRequested(); SharpTreeNode newNode = null; try { if (!TypesHierarchyHelpers.IsBaseType(analyzedProperty.DeclaringType, type, resolveTypeArguments: false)) continue; foreach (PropertyDefinition property in type.Properties) { ct.ThrowIfCancellationRequested(); if (TypesHierarchyHelpers.IsBaseProperty(analyzedProperty, property)) { MethodDefinition anyAccessor = property.GetMethod ?? property.SetMethod; bool hidesParent = !anyAccessor.IsVirtual ^ anyAccessor.IsNewSlot; newNode = new AnalyzedPropertyTreeNode(property, hidesParent ? "(hides) " : ""); } } } catch (ReferenceResolvingException) { // ignore this type definition. } if (newNode != null) yield return newNode; } }
IEnumerable<SharpTreeNode> FindReferences(LoadedAssembly asm, CancellationToken ct) { string asmName = asm.AssemblyDefinition.Name.Name; string name = analyzedMethod.Name; string declTypeName = analyzedMethod.DeclaringType.FullName; foreach (TypeDefinition type in TreeTraversal.PreOrder(asm.AssemblyDefinition.MainModule.Types, t => t.NestedTypes)) { ct.ThrowIfCancellationRequested(); SharpTreeNode newNode = null; try { if (!TypesHierarchyHelpers.IsBaseType(analyzedMethod.DeclaringType, type, resolveTypeArguments: false)) continue; foreach (MethodDefinition method in type.Methods) { ct.ThrowIfCancellationRequested(); if (TypesHierarchyHelpers.IsBaseMethod(analyzedMethod, method)) { bool hidesParent = !method.IsVirtual ^ method.IsNewSlot; newNode = new AnalyzedMethodTreeNode(method, hidesParent ? "(hides) " : ""); } } } catch (ReferenceResolvingException) { // ignore this type definition. maybe add a notification about such cases. } if (newNode != null) yield return newNode; } }
public override TreeViewNodeFilterResult GetFilterResult(LoadedAssembly asm, AssemblyFilterType type) { if (type == AssemblyFilterType.NonNetFile) return new TreeViewNodeFilterResult(FilterResult.Hidden, false); if (type == AssemblyFilterType.Assembly) { if (assembly == null || asm.AssemblyDefinition != assembly) return new TreeViewNodeFilterResult(FilterResult.Hidden, false); return new TreeViewNodeFilterResult(null, false); } if (type == AssemblyFilterType.NetModule) { if (asm.AssemblyDefinition != assembly) return new TreeViewNodeFilterResult(FilterResult.Hidden, false); if (assembly == null || assembly.ManifestModule != module) { if (asm.ModuleDefinition != module) return new TreeViewNodeFilterResult(FilterResult.Hidden, false); return new TreeViewNodeFilterResult(null, false); } else return new TreeViewNodeFilterResult(null, asm.ModuleDefinition != assembly.ManifestModule); } Debug.Fail("Invalid AssemblyFilterType value"); return new TreeViewNodeFilterResult(FilterResult.Hidden, false); }
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options) { if (options.FullDecompilation && options.SaveAsProjectDirectory != null) { HashSet<string> directories = new HashSet<string>(StringComparer.OrdinalIgnoreCase); var files = WriteCodeFilesInProject(assembly.AssemblyDefinition, options, directories).ToList(); files.AddRange(WriteResourceFilesInProject(assembly, options, directories)); WriteProjectFile(new TextOutputWriter(output), files, assembly.AssemblyDefinition.MainModule); } else { base.DecompileAssembly(assembly, output, options); output.WriteLine(); ModuleDefinition mainModule = assembly.AssemblyDefinition.MainModule; if (mainModule.EntryPoint != null) { output.Write("' Entry point: "); output.WriteReference(mainModule.EntryPoint.DeclaringType.FullName + "." + mainModule.EntryPoint.Name, mainModule.EntryPoint); output.WriteLine(); } switch (mainModule.Architecture) { case TargetArchitecture.I386: if ((mainModule.Attributes & ModuleAttributes.Required32Bit) == ModuleAttributes.Required32Bit) WriteCommentLine(output, "Architecture: x86"); else WriteCommentLine(output, "Architecture: AnyCPU"); break; case TargetArchitecture.AMD64: WriteCommentLine(output, "Architecture: x64"); break; case TargetArchitecture.IA64: WriteCommentLine(output, "Architecture: Itanium-64"); break; } if ((mainModule.Attributes & ModuleAttributes.ILOnly) == 0) { WriteCommentLine(output, "This assembly contains unmanaged code."); } switch (mainModule.Runtime) { case TargetRuntime.Net_1_0: WriteCommentLine(output, "Runtime: .NET 1.0"); break; case TargetRuntime.Net_1_1: WriteCommentLine(output, "Runtime: .NET 1.1"); break; case TargetRuntime.Net_2_0: WriteCommentLine(output, "Runtime: .NET 2.0"); break; case TargetRuntime.Net_4_0: WriteCommentLine(output, "Runtime: .NET 4.0"); break; } output.WriteLine(); // don't automatically load additional assemblies when an assembly node is selected in the tree view using (options.FullDecompilation ? null : LoadedAssembly.DisableAssemblyLoad()) { AstBuilder codeDomBuilder = CreateAstBuilder(options, currentModule: assembly.AssemblyDefinition.MainModule); codeDomBuilder.AddAssembly(assembly.AssemblyDefinition, onlyAssemblyLevel: !options.FullDecompilation); RunTransformsAndGenerateCode(codeDomBuilder, output, options); } } OnDecompilationFinished(null); }
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options) { if (options.FullDecompilation && options.SaveAsProjectDirectory != null) { //Checks if must create a solution if (options.CreateSolution) { //Solution directory var solutionDir = options.SaveAsProjectDirectory; //List of the project names and their guid List<Tuple<string, string>> projects = new List<Tuple<string, string>>(); //For each module foreach (var module in assembly.AssemblyDefinition.Modules) { //Creates the project and the various files var projectDir = Path.Combine(solutionDir, TextView.DecompilerTextView.CleanUpName(Path.GetFileNameWithoutExtension(module.Name))); Directory.CreateDirectory(projectDir); options.SaveAsProjectDirectory = projectDir; HashSet<string> directories = new HashSet<string>(StringComparer.OrdinalIgnoreCase); var files = WriteCodeFilesInProject(module, options, directories).ToList(); files.AddRange(WriteResourceFilesInProject(module, options, directories)); using (var writer = new StreamWriter(Path.Combine(projectDir, Path.GetFileName(projectDir) + this.ProjectFileExtension), false, System.Text.Encoding.UTF8)) projects.Add(Tuple.Create( Path.GetFileName(projectDir), "{" + WriteProjectFile(writer, files, module, options).ToString().ToUpperInvariant() + "}" )); } //Writes the solution WriteSolutionFile(new TextOutputWriter(output), Enumerable.Reverse(projects)); } else { HashSet<string> directories = new HashSet<string>(StringComparer.OrdinalIgnoreCase); var files = assembly.AssemblyDefinition.Modules.SelectMany(m => WriteCodeFilesInProject(m, options, directories)).ToList(); files.AddRange(assembly.AssemblyDefinition.Modules.SelectMany(m => WriteResourceFilesInProject(m, options, directories))); WriteProjectFile(new TextOutputWriter(output), files, assembly.AssemblyDefinition.MainModule, options); } } else { base.DecompileAssembly(assembly, output, options); output.WriteLine(); WriteCommentLine(output, "Main module:"); WriteModuleAttributes(assembly.AssemblyDefinition.MainModule, output, options); output.WriteLine(); // don't automatically load additional assemblies when an assembly node is selected in the tree view using (options.FullDecompilation ? null : LoadedAssembly.DisableAssemblyLoad()) { AstBuilder codeDomBuilder = CreateAstBuilder(options, currentModule: assembly.AssemblyDefinition.MainModule); codeDomBuilder.AddAssembly(assembly.AssemblyDefinition, onlyAssemblyLevel: !options.FullDecompilation); RunTransformsAndGenerateCode(codeDomBuilder, output, options, assembly.AssemblyDefinition.MainModule); } } OnDecompilationFinished(null); }
public AssemblyTreeNode(LoadedAssembly assembly) { if (assembly == null) throw new ArgumentNullException("assembly"); this.assembly = assembly; assembly.ContinueWhenLoaded(OnAssemblyLoaded, TaskScheduler.FromCurrentSynchronizationContext()); this.LazyLoading = true; }
public override bool HandleModelUpdated(LoadedAssembly 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(LoadedAssembly asm, 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; 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; break; case AssemblyFilterType.NonNetFile: default: thisFlag = VisibleMembersFlags.NonNetFile; visibleFlags = thisFlag; 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); }
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options) { if (options.FullDecompilation && options.SaveAsProjectDirectory != null) { var decompiler = new VBProjectDecompiler(); decompiler.Decompile(this, assembly, output, options); } else { base.DecompileAssembly(assembly, output, options); output.WriteLine(); ModuleDefinition mainModule = assembly.ModuleDefinition; if (mainModule.EntryPoint != null) { output.Write("' Entry point: "); output.WriteReference(mainModule.EntryPoint.DeclaringType.FullName + "." + mainModule.EntryPoint.Name, mainModule.EntryPoint); output.WriteLine(); } WriteCommentLine(output, "Architecture: " + CSharpLanguage.GetPlatformDisplayName(mainModule)); if ((mainModule.Attributes & ModuleAttributes.ILOnly) == 0) { WriteCommentLine(output, "This assembly contains unmanaged code."); } switch (mainModule.Runtime) { case TargetRuntime.Net_1_0: WriteCommentLine(output, "Runtime: .NET 1.0"); break; case TargetRuntime.Net_1_1: WriteCommentLine(output, "Runtime: .NET 1.1"); break; case TargetRuntime.Net_2_0: WriteCommentLine(output, "Runtime: .NET 2.0"); break; case TargetRuntime.Net_4_0: if (assembly.IsNet45()) { WriteCommentLine(output, "Runtime: .NET 4.5"); } else { WriteCommentLine(output, "Runtime: .NET 4.0"); } break; } output.WriteLine(); // don't automatically load additional assemblies when an assembly node is selected in the tree view using (options.FullDecompilation ? null : LoadedAssembly.DisableAssemblyLoad()) { AstBuilder codeDomBuilder = CreateAstBuilder(options, currentModule: assembly.ModuleDefinition); codeDomBuilder.AddAssembly(assembly.ModuleDefinition, onlyAssemblyLevel: !options.FullDecompilation); RunTransformsAndGenerateCode(codeDomBuilder, output, options, assembly.ModuleDefinition); } } }
public override void DecompileAssembly(LoadedAssembly assembly, 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(assembly.ModuleDefinition, options, directories).ToList(); files.AddRange(WriteResourceFilesInProject(assembly, options, directories)); WriteProjectFile(new TextOutputWriter(output), files, assembly, options); } else { bool decompileAsm = (flags & DecompileAssemblyFlags.Assembly) != 0; bool decompileMod = (flags & DecompileAssemblyFlags.Module) != 0; base.DecompileAssembly(assembly, output, options, flags); output.WriteLine(); ModuleDef mainModule = assembly.ModuleDefinition; 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(assembly, 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 : LoadedAssembly.DisableAssemblyLoad()) { AstBuilder codeDomBuilder = CreateAstBuilder(options, currentModule: assembly.ModuleDefinition); codeDomBuilder.AddAssembly(assembly.ModuleDefinition, !options.FullDecompilation, decompileAsm, decompileMod); RunTransformsAndGenerateCode(codeDomBuilder, output, options, assembly.ModuleDefinition); } } }
public override void Decompile(Language language, ITextOutput output, DecompilationOptions options) { void HandleException(Exception ex, string message) { language.WriteCommentLine(output, message); output.WriteLine(); output.MarkFoldStart("Exception details", true); output.Write(ex.ToString()); output.MarkFoldEnd(); } try { LoadedAssembly.WaitUntilLoaded(); // necessary so that load errors are passed on to the caller } catch (AggregateException ex) { language.WriteCommentLine(output, LoadedAssembly.FileName); switch (ex.InnerException) { case BadImageFormatException badImage: HandleException(badImage, "This file does not contain a managed assembly."); return; case FileNotFoundException fileNotFound: HandleException(fileNotFound, "The file was not found."); return; case DirectoryNotFoundException dirNotFound: HandleException(dirNotFound, "The directory was not found."); return; case PEFileNotSupportedException notSupported: HandleException(notSupported, notSupported.Message); return; default: throw; } } language.DecompileAssembly(LoadedAssembly, output, options); }
/// <summary> /// Find all the tasks which are available from the loaded assemblies /// </summary> /// <param name="NameToTask">Mapping from task name to information about how to serialize it</param> /// <param name="bPublicTasksOnly">Whether to include just public tasks, or all the tasks in any loaded assemblies</param> static bool FindAvailableTasks(Dictionary <string, ScriptTask> NameToTask, bool bPublicTasksOnly) { Assembly[] LoadedAssemblies = AppDomain.CurrentDomain.GetAssemblies(); if (bPublicTasksOnly) { LoadedAssemblies = LoadedAssemblies.Where(x => IsPublicAssembly(new FileReference(x.Location))).ToArray(); } foreach (Assembly LoadedAssembly in LoadedAssemblies) { Type[] Types; try { Types = LoadedAssembly.GetTypes(); } catch (ReflectionTypeLoadException ex) { LogWarning("Exception {0} while trying to get types from assembly {1}", ex, LoadedAssembly); continue; } foreach (Type Type in Types) { foreach (TaskElementAttribute ElementAttribute in Type.GetCustomAttributes <TaskElementAttribute>()) { if (!Type.IsSubclassOf(typeof(CustomTask))) { CommandUtils.LogError("Class '{0}' has TaskElementAttribute, but is not derived from 'Task'", Type.Name); return(false); } if (NameToTask.ContainsKey(ElementAttribute.Name)) { CommandUtils.LogError("Found multiple handlers for task elements called '{0}'", ElementAttribute.Name); return(false); } NameToTask.Add(ElementAttribute.Name, new ScriptTask(ElementAttribute.Name, Type, ElementAttribute.ParametersType)); } } } return(true); }
public override TreeViewNodeFilterResult GetFilterResult(LoadedAssembly asm, AssemblyFilterType type) { if (type == AssemblyFilterType.NonNetFile) { return(new TreeViewNodeFilterResult(FilterResult.Hidden, false)); } if (type == AssemblyFilterType.Assembly) { if (assembly == null || asm.AssemblyDefinition != assembly) { return(new TreeViewNodeFilterResult(FilterResult.Hidden, false)); } return(new TreeViewNodeFilterResult(null, false)); } if (type == AssemblyFilterType.NetModule) { if (asm.AssemblyDefinition != assembly) { return(new TreeViewNodeFilterResult(FilterResult.Hidden, false)); } if (assembly == null || assembly.ManifestModule != module) { if (asm.ModuleDefinition != module) { return(new TreeViewNodeFilterResult(FilterResult.Hidden, false)); } return(new TreeViewNodeFilterResult(null, false)); } else { return(new TreeViewNodeFilterResult(null, asm.ModuleDefinition != assembly.ManifestModule)); } } Debug.Fail("Invalid AssemblyFilterType value"); return(new TreeViewNodeFilterResult(FilterResult.Hidden, false)); }
IEnumerable<SharpTreeNode> FindReferences(LoadedAssembly asm, CancellationToken ct) { string asmName = asm.AssemblyDefinition.Name.Name; string name = analyzedEvent.Name; string declTypeName = analyzedEvent.DeclaringType.FullName; foreach (TypeDefinition type in TreeTraversal.PreOrder(asm.AssemblyDefinition.MainModule.Types, t => t.NestedTypes)) { ct.ThrowIfCancellationRequested(); if (!TypesHierarchyHelpers.IsBaseType(analyzedEvent.DeclaringType, type, resolveTypeArguments: false)) continue; foreach (EventDefinition eventDef in type.Events) { ct.ThrowIfCancellationRequested(); if (TypesHierarchyHelpers.IsBaseEvent(analyzedEvent, eventDef)) { MethodDefinition anyAccessor = eventDef.AddMethod ?? eventDef.RemoveMethod; bool hidesParent = !anyAccessor.IsVirtual ^ anyAccessor.IsNewSlot; yield return new AnalyzedEventTreeNode(eventDef, hidesParent ? "(hides) " : ""); } } } }
void Search(LoadedAssembly 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.ModuleDefinition, LocationImageInfo = GetImage("AssemblyModule"), LoadedAssembly = ownerModule, }); } foreach (var type in types) { cancellationToken.ThrowIfCancellationRequested(); Search(ownerModule, ns, type); } }
public override ProjectId DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options) { PEFile module = assembly.GetPEFileOrNull(); R2RReaderCacheEntry r2rReaderCacheEntry = GetReader(assembly, module); if (r2rReaderCacheEntry.r2rReader == null) { WriteCommentLine(output, r2rReaderCacheEntry.failureReason); } else { R2RReader reader = r2rReaderCacheEntry.r2rReader; WriteCommentLine(output, "TODO - display ready to run information"); // TODO: display other header information foreach (var method in reader.R2RMethods) { WriteCommentLine(output, method.SignatureString); } } return(base.DecompileAssembly(assembly, output, options)); }
IEnumerable <SharpTreeNode> FindReferences(LoadedAssembly asm, CancellationToken ct) { string asmName = asm.AssemblyDefinition.Name.Name; string name = analyzedProperty.Name; string declTypeName = analyzedProperty.DeclaringType.FullName; foreach (TypeDefinition type in TreeTraversal.PreOrder(asm.AssemblyDefinition.MainModule.Types, t => t.NestedTypes)) { ct.ThrowIfCancellationRequested(); SharpTreeNode newNode = null; try { if (!TypesHierarchyHelpers.IsBaseType(analyzedProperty.DeclaringType, type, resolveTypeArguments: false)) { continue; } foreach (PropertyDefinition property in type.Properties) { ct.ThrowIfCancellationRequested(); if (TypesHierarchyHelpers.IsBaseProperty(analyzedProperty, property)) { MethodDefinition anyAccessor = property.GetMethod ?? property.SetMethod; bool hidesParent = !anyAccessor.IsVirtual ^ anyAccessor.IsNewSlot; newNode = new AnalyzedPropertyTreeNode(property, hidesParent ? "(hides) " : ""); } } } catch (ReferenceResolvingException) { // ignore this type definition. } if (newNode != null) { yield return(newNode); } } }
private ReadyToRunReaderCacheEntry GetReader(LoadedAssembly assembly, PEFile module) { ReadyToRunReaderCacheEntry result; lock (readyToRunReaders) { if (!readyToRunReaders.TryGetValue(module, out result)) { result = new ReadyToRunReaderCacheEntry(); try { result.readyToRunReader = new ReadyToRunReader(new ReadyToRunAssemblyResolver(assembly), module.Metadata, module.Reader, module.FileName); if (result.readyToRunReader.Machine != Machine.Amd64 && result.readyToRunReader.Machine != Machine.I386) { result.failureReason = $"Architecture {result.readyToRunReader.Machine} is not currently supported."; result.readyToRunReader = null; } } catch (BadImageFormatException e) { result.failureReason = e.Message; } readyToRunReaders.Add(module, result); } } return(result); }
/// <summary> /// Creates a service wrapper>. /// </summary> /// <typeparam name="T">The source service type as defined in the within the unit test assembly.</typeparam> /// <param name="baseAddress">The base address to use for the created client.</param> /// <returns>The new <see cref="ServiceWrapper"/>.</returns> public ServiceWrapper CreateServiceWrapper <T>(string baseAddress) { Covenant.Requires <ArgumentNullException>(!string.IsNullOrEmpty(baseAddress)); const string controllerSuffix = "Controller"; var sourceType = typeof(T); var clientTypeName = sourceType.Name; if (clientTypeName.EndsWith(controllerSuffix)) { clientTypeName = clientTypeName.Substring(0, clientTypeName.Length - controllerSuffix.Length); } var targetType = LoadedAssembly.GetType($"{DefaultNamespace}.{clientTypeName}Client"); if (targetType == null) { throw new TypeLoadException($"Cannot find type: {DefaultNamespace}.{sourceType.Name}"); } return(new ServiceWrapper(targetType, baseAddress, this)); }
IEnumerable<SharpTreeNode> FindReferences(LoadedAssembly asm, CancellationToken ct) { string asmName = asm.AssemblyDefinition.Name.Name; string name = analyzedMethod.Name; string declTypeName = analyzedMethod.DeclaringType.FullName; foreach (TypeDefinition type in TreeTraversal.PreOrder(asm.AssemblyDefinition.MainModule.Types, t => t.NestedTypes)) { ct.ThrowIfCancellationRequested(); if (!IsDerived(type, analyzedMethod.DeclaringType)) continue; foreach (MethodDefinition method in type.Methods) { ct.ThrowIfCancellationRequested(); if (HasCompatibleSpecification(method) && !method.IsNewSlot && DoesOverrideCorrectMethod(method)) { yield return new AnalyzedMethodTreeNode(method); } } } }
private void Window_DragEnter(object sender, DragEventArgs e) { var @do = e.Data as DataObject; if (@do.ContainsFileDropList()) { if ((from f in GetOnlyFilePath(@do.GetFileDropList().Cast <string>()) select LoadedAssembly.IsLoadable(f)).Count((@this) => @this == true) > 0) { e.Effects = DragDropEffects.Copy; } else { e.Effects = DragDropEffects.None; } } else { e.Effects = DragDropEffects.None; } e.Handled = true; }
public async Task <object> RetrieveAllAssemblies(IProgress <string> progress, CancellationToken cancelToken) { LocalizationAppDomain appDomain = await CreateAppDomain(__Document.PathToBinaries); List <ImportResult> results = new List <ImportResult>(); foreach (var assembly in __Document.Assemblies) { progress.Report(StringUtils.String("LoadingAssembly_0", assembly.Assembly.AssemblyFile)); LoadedAssembly loadedAssembly = await Task.Run <LoadedAssembly>(() => { return(appDomain.LoadAssembly( System.IO.Path.Combine(__Document.PathToBinaries, assembly.Assembly.DefaultResourceFile))); }); var progressString = StringUtils.String("ImportingFromAssembly_0", assembly.Assembly.AssemblyFile); var progressReporter = new ProgressPercentageReporter(progress, progressString); var lines = await ExtractTranslationLines(loadedAssembly); lines = lines.Where(LinesFilter).ToList(); ImportResult importResult = await __Document.ImportApi.ImportStrings( progressReporter, cancelToken, assembly.Assembly.AssemblyFile, lines); results.Add(importResult); } progress.Report(StringUtils.String("Import_Finishing")); await DisposeAppDomain(appDomain); __Document.UpdateTranslatedCultures(); return(results); }
private IEnumerable <SharpTreeNode> FindReferences(LoadedAssembly asm, CancellationToken ct) { string asmName = asm.AssemblyDefinition.Name.Name; string name = analyzedMethod.Name; string declTypeName = analyzedMethod.DeclaringType.FullName; foreach (TypeDefinition type in TreeTraversal.PreOrder(asm.AssemblyDefinition.MainModule.Types, t => t.NestedTypes)) { ct.ThrowIfCancellationRequested(); SharpTreeNode newNode = null; try { if (!TypesHierarchyHelpers.IsBaseType(analyzedMethod.DeclaringType, type, resolveTypeArguments: false)) { continue; } foreach (MethodDefinition method in type.Methods) { ct.ThrowIfCancellationRequested(); if (TypesHierarchyHelpers.IsBaseMethod(analyzedMethod, method)) { bool hidesParent = !method.IsVirtual ^ method.IsNewSlot; newNode = new AnalyzedMethodTreeNode(method, hidesParent ? "(hides) " : ""); } } } catch (ReferenceResolvingException) { // ignore this type definition. maybe add a notification about such cases. } if (newNode != null) { yield return(newNode); } } }
IEnumerable <PEFile> GetReferencingModules(PEFile self, CancellationToken ct) { yield return(self); string reflectionTypeScopeName = typeScope.Name; if (typeScope.TypeParameterCount > 0) { reflectionTypeScopeName += "`" + typeScope.TypeParameterCount; } foreach (var assembly in AssemblyList.GetAssemblies()) { ct.ThrowIfCancellationRequested(); bool found = false; var module = assembly.GetPEFileOrNull(); if (module == null || !module.IsAssembly) { continue; } var resolver = assembly.GetAssemblyResolver(); foreach (var reference in module.AssemblyReferences) { using (LoadedAssembly.DisableAssemblyLoad()) { if (resolver.Resolve(reference) == self) { found = true; break; } } } if (found && ModuleReferencesScopeType(module.Metadata, reflectionTypeScopeName, typeScope.Namespace)) { yield return(module); } } }
private Dictionary <string, LoadedAssembly> LoadAssemblies(bool ignoreDuplicateAssemblies = false) { var assemblies = new Dictionary <string, LoadedAssembly>(); var exceptions = new List <Exception>(); foreach (var assemblyData in _assemblies) { try { var loadedAssemly = new LoadedAssembly(assemblyData); var name = loadedAssemly.Assembly.Name; if (assemblies.ContainsKey(name)) { throw new InvalidOperationException($"The assembly '{name}' has already been added."); } assemblies.Add(name, loadedAssemly); } catch (Exception ex) { exceptions.Add(ex); } } if (exceptions.Count > 0) { try { HandleAssemblyLoadingExceptions(ignoreDuplicateAssemblies, exceptions); } catch (Exception) { DisposeAssemblies(assemblies); throw; } } return(assemblies); }
void Search(LoadedAssembly 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"), LoadedAssembly = ownerModule, }); } SearchMembers(ownerModule, type); foreach (var subType in type.GetTypes()) { cancellationToken.ThrowIfCancellationRequested(); Search(ownerModule, subType); } }
protected override void LoadChildren() { if (Parent is AssemblyTreeNode || assembly.AssemblyDefinition == null) { LoadModuleChildren(assembly.PEImage, assembly.ModuleDefinition); } else { // Add all modules in this assembly foreach (var mod in assembly.AssemblyDefinition.Modules) { if (mod == assembly.ModuleDefinition) { this.Children.Add(new AssemblyTreeNode(assembly)); } else { var loadAsm = new LoadedAssembly(AssemblyList, mod); loadAsm.IsAutoLoaded = assembly.IsAutoLoaded; this.Children.Add(new AssemblyTreeNode(loadAsm)); } } } }
static void Execute(ILSpyTreeNode[] nodes) { if (!AddNetModuleToAssemblyCommand.CanExecute(nodes)) { return; } var dialog = new System.Windows.Forms.OpenFileDialog() { Filter = ".NET NetModules (*.netmodule)|*.netmodule|All files (*.*)|*.*", RestoreDirectory = true, }; if (dialog.ShowDialog() != System.Windows.Forms.DialogResult.OK) { return; } if (string.IsNullOrEmpty(dialog.FileName)) { return; } var asm = new LoadedAssembly(MainWindow.Instance.CurrentAssemblyList, dialog.FileName); if (asm.ModuleDefinition == null || asm.AssemblyDefinition != null) { MainWindow.Instance.ShowMessageBox(string.Format("{0} is not a NetModule", asm.FileName), System.Windows.MessageBoxButton.OK); asm.TheLoadedFile.Dispose(); return; } var cmd = new AddExistingNetModuleToAssemblyCommand((AssemblyTreeNode)nodes[0], asm); UndoCommandManager.Instance.Add(cmd); MainWindow.Instance.JumpToReference(cmd.modNode); }
void LoadChildrenForPEFile(PEFile module) { typeSystem = LoadedAssembly.GetTypeSystemOrNull(DecompilerTypeSystem.GetOptions(new DecompilationOptions().DecompilerSettings)); var assembly = (MetadataModule)typeSystem.MainModule; this.Children.Add(new Metadata.MetadataTreeNode(module, this)); Decompiler.DebugInfo.IDebugInfoProvider debugInfo = LoadedAssembly.GetDebugInfoOrNull(); if (debugInfo is Decompiler.PdbProvider.PortableDebugInfoProvider ppdb && ppdb.GetMetadataReader() is System.Reflection.Metadata.MetadataReader reader) { this.Children.Add(new Metadata.DebugMetadataTreeNode(module, ppdb.IsEmbedded, reader, this)); } this.Children.Add(new ReferenceFolderTreeNode(module, this)); if (module.Resources.Any()) this.Children.Add(new ResourceListTreeNode(module)); foreach (NamespaceTreeNode ns in namespaces.Values) { ns.Children.Clear(); } foreach (var type in assembly.TopLevelTypeDefinitions.OrderBy(t => t.ReflectionName, NaturalStringComparer.Instance)) { var escapedNamespace = Language.EscapeName(type.Namespace); if (!namespaces.TryGetValue(type.Namespace, out NamespaceTreeNode ns)) { ns = new NamespaceTreeNode(escapedNamespace); namespaces.Add(type.Namespace, ns); } TypeTreeNode node = new TypeTreeNode(type, this); typeDict[(TypeDefinitionHandle)type.MetadataToken] = node; ns.Children.Add(node); } foreach (NamespaceTreeNode ns in namespaces.Values.OrderBy(n => n.Name, NaturalStringComparer.Instance)) { if (ns.Children.Count > 0) this.Children.Add(ns); } }
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options) { if (options.FullDecompilation && options.SaveAsProjectDirectory != null) { HashSet <string> directories = new HashSet <string>(StringComparer.OrdinalIgnoreCase); var files = WriteCodeFilesInProject(assembly.ModuleDefinition, options, directories).ToList(); files.AddRange(WriteResourceFilesInProject(assembly, options, directories)); WriteProjectFile(new TextOutputWriter(output), files, assembly.ModuleDefinition); } else { base.DecompileAssembly(assembly, output, options); output.WriteLine(); ModuleDef mainModule = assembly.ModuleDefinition; if (mainModule.EntryPoint != null) { output.Write("' Entry point: "); output.WriteReference(mainModule.EntryPoint.DeclaringType.FullName + "." + mainModule.EntryPoint.Name, mainModule.EntryPoint); output.WriteLine(); } WriteCommentLine(output, "Architecture: " + CSharpLanguage.GetPlatformDisplayName(mainModule)); if (!mainModule.IsILOnly) { WriteCommentLine(output, "This assembly contains unmanaged code."); } output.WriteLine("// Runtime: " + mainModule.RuntimeVersion); output.WriteLine(); // don't automatically load additional assemblies when an assembly node is selected in the tree view using (options.FullDecompilation ? null : LoadedAssembly.DisableAssemblyLoad()) { AstBuilder codeDomBuilder = CreateAstBuilder(options, currentModule: assembly.ModuleDefinition); codeDomBuilder.AddAssembly(assembly.ModuleDefinition, onlyAssemblyLevel: !options.FullDecompilation); RunTransformsAndGenerateCode(codeDomBuilder, output, options, assembly.ModuleDefinition); } } }
public void UnregisterCached(LoadedAssembly asm) { var cachedInfo = cachedAsmTreeNodes[asm]; if (cachedInfo.Counter-- == 1) cachedAsmTreeNodes.Remove(asm); }
public void RegisterCached(LoadedAssembly asm, AssemblyTreeNode asmNode) { CachedAssemblyTreeNode cachedInfo; if (!cachedAsmTreeNodes.TryGetValue(asm, out cachedInfo)) cachedAsmTreeNodes.Add(asm, cachedInfo = new CachedAssemblyTreeNode(asmNode)); else { Debug.Assert(cachedInfo.AssemblyTreeNode == asmNode); if (cachedInfo.AssemblyTreeNode != asmNode) throw new InvalidOperationException(); } cachedInfo.Counter++; }
public LoadedAssembly FindModule(LoadedAssembly asm, string moduleFilename) { App.Current.Dispatcher.VerifyAccess(); foreach (AssemblyTreeNode node in this.Children) { if (node.LoadedAssembly != asm) continue; if (node.IsNetModule) continue; node.EnsureChildrenFiltered(); foreach (var asmNode in node.Children.OfType<AssemblyTreeNode>()) { if (string.IsNullOrWhiteSpace(asmNode.LoadedAssembly.FileName)) continue; if (asmNode.LoadedAssembly.FileName.Equals(moduleFilename, StringComparison.OrdinalIgnoreCase)) return asmNode.LoadedAssembly; } } return null; }
public MetadataReader FindAssembly(MetadataReader metadataReader, AssemblyReferenceHandle assemblyReferenceHandle, string parentFile) { LoadedAssembly loadedAssembly = this.loadedAssembly.LookupReferencedAssembly(new Decompiler.Metadata.AssemblyReference(metadataReader, assemblyReferenceHandle)); return(loadedAssembly?.GetPEFileOrNull()?.Metadata); }
public abstract bool HandleModelUpdated(LoadedAssembly asm);
void SaveToCache(string cacheFileName, DateTime lastWriteTime, LoadedAssembly asm) { if (cacheFileName == null) return; LoggingService.Debug("Serializing to " + cacheFileName); try { Directory.CreateDirectory(DomPersistencePath); using (FileStream fs = new FileStream(cacheFileName, FileMode.Create, FileAccess.Write)) { using (BinaryWriter writer = new BinaryWriterWith7BitEncodedInts(fs)) { writer.Write(lastWriteTime.Ticks); FastSerializer s = new FastSerializer(); s.Serialize(writer, asm); } } } catch (IOException ex) { LoggingService.Warn(ex); // Can happen if two SD instances are trying to access the file at the same time. // We'll just let one of them win, and instance that got the exception won't write to the cache at all. // Similarly, we also ignore the other kinds of IO exceptions. } catch (UnauthorizedAccessException ex) { LoggingService.Warn(ex); } }
public AssemblyTreeNodeCreator(LoadedAssembly asm) : this(asm, null, false) { }
protected override void LoadChildren() { ModuleDef moduleDefinition = assembly.ModuleDefinition; if (moduleDefinition == null) { // if we crashed on loading, then we don't have any children return; } if (Parent is AssemblyTreeNode || assembly.AssemblyDefinition == null) { LoadModuleChildren(moduleDefinition); } else { // Add all modules in this assembly foreach (var mod in assembly.AssemblyDefinition.Modules) { if (mod == assembly.ModuleDefinition) this.Children.Add(new AssemblyTreeNode(assembly)); else { var loadAsm = new LoadedAssembly(AssemblyList, mod); loadAsm.IsAutoLoaded = assembly.IsAutoLoaded; this.Children.Add(new AssemblyTreeNode(loadAsm)); } } } }
public void MarkAsSaved(LoadedAssembly asm) { asm.IsDirty = false; asm.SavedCommand = GetNewSavedCommand(asm); }
bool IsModifiedCounter(LoadedAssembly asm, int counter) { return(asm.SavedCommand != 0 && asm.SavedCommand != counter); }
public bool IsModified(LoadedAssembly asm) { return(asm.IsDirty && IsModifiedCounter(asm, currentCommandCounter)); }
AssemblyTreeNode CreateAssemblyTreeNode(LoadedAssembly asm) { CachedAssemblyTreeNode cachedInfo; if (cachedAsmTreeNodes.TryGetValue(asm, out cachedInfo)) { var asmNode = cachedInfo.AssemblyTreeNode; Debug.Assert(asmNode.Parent == null); if (asmNode.Parent != null) throw new InvalidOperationException(); return asmNode; } return new AssemblyTreeNode(asm); }
LoadedAssembly LoadAssembly(FileName fileName, CancellationToken cancellationToken, bool includeInternalMembers) { DateTime lastWriteTime = File.GetLastWriteTimeUtc(fileName); string cacheFileName = GetCacheFileName(fileName); LoadedAssembly pc = TryReadFromCache(cacheFileName, lastWriteTime); if (pc != null) { if (!includeInternalMembers || includeInternalMembers == pc.HasInternalMembers) return pc; } //LoggingService.Debug("Loading " + fileName); cancellationToken.ThrowIfCancellationRequested(); var param = new ReaderParameters(); param.AssemblyResolver = new DummyAssemblyResolver(); ModuleDefinition module = ModuleDefinition.ReadModule(fileName, param); CecilLoader l = new CecilLoader(); l.IncludeInternalMembers = includeInternalMembers; string xmlDocFile = FindXmlDocumentation(fileName, module.Runtime); if (xmlDocFile != null) { try { l.DocumentationProvider = new XmlDocumentationProvider(xmlDocFile); } catch (XmlException ex) { LoggingService.Warn("Ignoring error while reading xml doc from " + xmlDocFile, ex); } catch (IOException ex) { LoggingService.Warn("Ignoring error while reading xml doc from " + xmlDocFile, ex); } catch (UnauthorizedAccessException ex) { LoggingService.Warn("Ignoring error while reading xml doc from " + xmlDocFile, ex); } } l.CancellationToken = cancellationToken; var references = module.AssemblyReferences .Select(anr => new DomAssemblyName(anr.FullName)); pc = new LoadedAssembly(l.LoadModule(module), lastWriteTime, includeInternalMembers, references); SaveToCacheAsync(cacheFileName, lastWriteTime, pc).FireAndForget(); //SaveToCache(cacheFileName, lastWriteTime, pc); return pc; }
public ILSpyAssemblyWrapper(LoadedAssembly loadedAssembly) { LoadedAssembly = loadedAssembly; }
Task SaveToCacheAsync(string cacheFileName, DateTime lastWriteTime, LoadedAssembly asm) { if (cacheFileName == null) return Task.FromResult<object>(null); // Call SaveToCache on a background task: var shutdownService = SD.ShutdownService; var task = IOTaskScheduler.Factory.StartNew(delegate { SaveToCache(cacheFileName, lastWriteTime, asm); }, shutdownService.ShutdownToken); shutdownService.AddBackgroundTask(task); return task; }
AssemblyTreeNodeCreator(LoadedAssembly asm, AssemblyTreeNode asmNode, bool restoreIndex) { this.asmNode = asmNode ?? new AssemblyTreeNode(asm); this.restoreIndex = restoreIndex; MainWindow.Instance.AssemblyListTreeNode.RegisterCached(asm, this.asmNode); }
public AssemblyTreeNode(LoadedAssembly assembly) : this(assembly, null) { }
public override TreeViewNodeFilterResult GetFilterResult(string ns, LoadedAssembly 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); }
int GetNewSavedCommand(LoadedAssembly asm) { for (int i = undoCommands.Count - 1; i >= 0; i--) { var group = undoCommands[i]; if (group.ModifiedAssemblies.Contains(asm)) return group.CommandCounter; } if (undoCommands.Count > 0) return undoCommands[0].PrevCommandCounter; return currentCommandCounter; }
IEnumerable <Tuple <string, string> > WriteResourceFilesInProject(LoadedAssembly assembly, DecompilationOptions options, HashSet <string> directories) { //AppDomain bamlDecompilerAppDomain = null; //try { foreach (EmbeddedResource r in assembly.ModuleDefinition.Resources.OfType <EmbeddedResource>()) { string fileName; Stream s = r.GetResourceStream(); s.Position = 0; if (r.Name.EndsWith(".g.resources", StringComparison.OrdinalIgnoreCase)) { IEnumerable <DictionaryEntry> rs = null; try { rs = new ResourceSet(s).Cast <DictionaryEntry>(); } catch (ArgumentException) { } if (rs != null && rs.All(e => e.Value is Stream)) { foreach (var pair in rs) { fileName = Path.Combine(((string)pair.Key).Split('/').Select(p => TextView.DecompilerTextView.CleanUpName(p)).ToArray()); string dirName = Path.GetDirectoryName(fileName); if (!string.IsNullOrEmpty(dirName) && directories.Add(dirName)) { Directory.CreateDirectory(Path.Combine(options.SaveAsProjectDirectory, dirName)); } Stream entryStream = (Stream)pair.Value; entryStream.Position = 0; if (fileName.EndsWith(".baml", StringComparison.OrdinalIgnoreCase)) { //MemoryStream ms = new MemoryStream(); //entryStream.CopyTo(ms); // TODO implement extension point // var decompiler = Baml.BamlResourceEntryNode.CreateBamlDecompilerInAppDomain(ref bamlDecompilerAppDomain, assembly.FileName); // string xaml = null; // try { // xaml = decompiler.DecompileBaml(ms, assembly.FileName, new ConnectMethodDecompiler(assembly), new AssemblyResolver(assembly)); // } // catch (XamlXmlWriterException) { } // ignore XAML writer exceptions // if (xaml != null) { // File.WriteAllText(Path.Combine(options.SaveAsProjectDirectory, Path.ChangeExtension(fileName, ".xaml")), xaml); // yield return Tuple.Create("Page", Path.ChangeExtension(fileName, ".xaml")); // continue; // } } using (FileStream fs = new FileStream(Path.Combine(options.SaveAsProjectDirectory, fileName), FileMode.Create, FileAccess.Write)) { entryStream.CopyTo(fs); } yield return(Tuple.Create("Resource", fileName)); } continue; } } fileName = GetFileNameForResource(r.Name, directories); using (FileStream fs = new FileStream(Path.Combine(options.SaveAsProjectDirectory, fileName), FileMode.Create, FileAccess.Write)) { s.CopyTo(fs); } yield return(Tuple.Create("EmbeddedResource", fileName)); } //} //finally { // if (bamlDecompilerAppDomain != null) // AppDomain.Unload(bamlDecompilerAppDomain); //} }
public AssemblyTreeNode FindAssemblyNode(LoadedAssembly asm) { if (asm == null) return null; App.Current.Dispatcher.VerifyAccess(); foreach (AssemblyTreeNode node in this.Children) { if (node.LoadedAssembly == asm) return node; } return null; }
static bool MarkAsSaved(SaveMultiModuleVM vm, LoadedAssembly[] asms) { bool setNewFileName = false; bool allSaved = true; foreach (var asm in asms) { if (!vm.WasSaved(asm.ModuleDefinition)) allSaved = false; else { UndoCommandManager.Instance.MarkAsSaved(asm); if (string.IsNullOrEmpty(asm.FileName)) { var filename = vm.GetSavedFileName(asm.ModuleDefinition); if (!string.IsNullOrWhiteSpace(filename)) { asm.ModuleDefinition.Location = filename; asm.FileName = filename; setNewFileName = true; var asmNode = MainWindow.Instance.FindTreeNode(asm.ModuleDefinition) as AssemblyTreeNode; Debug.Assert(asmNode != null); if (asmNode != null) { asmNode.OnFileNameChanged(); Utils.NotifyModifiedAssembly(asm); } } } } } if (setNewFileName) MainWindow.Instance.CurrentAssemblyList.RefreshSave(); return allSaved; }
IEnumerable<SharpTreeNode> FindReferences(LoadedAssembly[] assemblies, CancellationToken ct) { // use parallelism only on the assembly level (avoid locks within Cecil) return assemblies.AsParallel().WithCancellation(ct).SelectMany((LoadedAssembly asm) => FindReferences(asm, ct)); }
public static void NotifyModifiedAssembly(LoadedAssembly asm) { MainWindow.Instance.ModuleModified(asm); }
IEnumerable<Tuple<string, string>> WriteResourceFilesInProject(LoadedAssembly assembly, DecompilationOptions options, HashSet<string> directories) { //AppDomain bamlDecompilerAppDomain = null; //try { foreach (EmbeddedResource r in assembly.AssemblyDefinition.MainModule.Resources.OfType<EmbeddedResource>()) { string fileName; Stream s = r.GetResourceStream(); s.Position = 0; if (r.Name.EndsWith(".g.resources", StringComparison.OrdinalIgnoreCase)) { IEnumerable<DictionaryEntry> rs = null; try { rs = new ResourceSet(s).Cast<DictionaryEntry>(); } catch (ArgumentException) { } if (rs != null && rs.All(e => e.Value is Stream)) { foreach (var pair in rs) { fileName = Path.Combine(((string)pair.Key).Split('/').Select(p => TextView.DecompilerTextView.CleanUpName(p)).ToArray()); string dirName = Path.GetDirectoryName(fileName); if (!string.IsNullOrEmpty(dirName) && directories.Add(dirName)) { Directory.CreateDirectory(Path.Combine(options.SaveAsProjectDirectory, dirName)); } Stream entryStream = (Stream)pair.Value; entryStream.Position = 0; if (fileName.EndsWith(".baml", StringComparison.OrdinalIgnoreCase)) { MemoryStream ms = new MemoryStream(); entryStream.CopyTo(ms); // TODO implement extension point // var decompiler = Baml.BamlResourceEntryNode.CreateBamlDecompilerInAppDomain(ref bamlDecompilerAppDomain, assembly.FileName); // string xaml = null; // try { // xaml = decompiler.DecompileBaml(ms, assembly.FileName, new ConnectMethodDecompiler(assembly), new AssemblyResolver(assembly)); // } // catch (XamlXmlWriterException) { } // ignore XAML writer exceptions // if (xaml != null) { // File.WriteAllText(Path.Combine(options.SaveAsProjectDirectory, Path.ChangeExtension(fileName, ".xaml")), xaml); // yield return Tuple.Create("Page", Path.ChangeExtension(fileName, ".xaml")); // continue; // } } using (FileStream fs = new FileStream(Path.Combine(options.SaveAsProjectDirectory, fileName), FileMode.Create, FileAccess.Write)) { entryStream.CopyTo(fs); } yield return Tuple.Create("Resource", fileName); } continue; } } fileName = GetFileNameForResource(r.Name, directories); using (FileStream fs = new FileStream(Path.Combine(options.SaveAsProjectDirectory, fileName), FileMode.Create, FileAccess.Write)) { s.CopyTo(fs); } yield return Tuple.Create("EmbeddedResource", fileName); } //} //finally { // if (bamlDecompilerAppDomain != null) // AppDomain.Unload(bamlDecompilerAppDomain); //} }
public ReadyToRunAssemblyResolver(LoadedAssembly loadedAssembly) { assemblyResolver = loadedAssembly.GetAssemblyResolver(); }