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);
}
public AssemblyTreeNodeCreator(LoadedAssembly asm)
: this(asm, null, false)
{
}
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));
}
AssemblyTreeNodeCreator(LoadedAssembly asm, AssemblyTreeNode asmNode, bool restoreIndex)
{
this.asmNode = asmNode ?? new AssemblyTreeNode(asm);
this.restoreIndex = restoreIndex;
MainWindow.Instance.AssemblyListTreeNode.RegisterCached(asm, this.asmNode);
}
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();
}
