public PropertyTreeNode(PropertyDefinition property)
{
if (property == null)
{
throw new ArgumentNullException(nameof(property));
}
this.PropertyDefinition = property;
using (LoadedAssembly.DisableAssemblyLoad()) {
this.isIndexer = property.IsIndexer();
}
if (property.GetMethod != null)
{
this.Children.Add(new MethodTreeNode(property.GetMethod));
}
if (property.SetMethod != null)
{
this.Children.Add(new MethodTreeNode(property.SetMethod));
}
if (property.HasOtherMethods)
{
foreach (var m in property.OtherMethods)
{
this.Children.Add(new MethodTreeNode(m));
}
}
}
public PropertyTreeNode(PropertyDefinition property)
{
if (property == null)
{
throw new ArgumentNullException("property");
}
this.property = property;
using (LoadedAssembly.DisableAssemblyLoad()) {
this.isIndexer = property.IsIndexer();
}
if (property.GetMethod != null)
{
this.Children.Add(new MethodTreeNode(property.GetMethod));
}
if (property.SetMethod != null)
{
this.Children.Add(new MethodTreeNode(property.SetMethod));
}
if (property.HasOtherMethods)
{
foreach (var m in property.OtherMethods)
{
this.Children.Add(new MethodTreeNode(m));
}
}
this.Foreground = IsPublicAPI ? NodeBrushes.Normal : NodeBrushes.Private;
}
IEnumerable <PEFile> GetReferencingModules(PEFile self, CancellationToken ct)
{
yield return(self);
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, typeScope.Name, typeScope.Namespace))
{
yield return(module);
}
}
}
private IEnumerable <AssemblyDefinition> GetReferencingAssemblies(AssemblyDefinition asm, CancellationToken ct)
{
yield return(asm);
IEnumerable <LoadedAssembly> assemblies = MainWindow.Instance.CurrentAssemblyList.GetAssemblies().Where(assy => assy.GetAssemblyDefinitionOrNull() != null);
foreach (var assembly in assemblies)
{
ct.ThrowIfCancellationRequested();
bool found = false;
var module = assembly.GetModuleDefinitionOrNull();
if (module == null)
{
continue;
}
var resolver = assembly.GetAssemblyResolver();
foreach (var reference in module.AssemblyReferences)
{
using (LoadedAssembly.DisableAssemblyLoad()) {
if (resolver.Resolve(reference) == asm)
{
found = true;
break;
}
}
}
if (found && AssemblyReferencesScopeType(module.Assembly))
{
yield return(module.Assembly);
}
}
}
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();
ModuleDefinition mainModule = assembly.ModuleDefinition;
if (mainModule.Types.Count > 0)
{
output.Write("// Global type: ");
output.WriteReference(mainModule.Types[0].FullName, mainModule.Types[0]);
output.WriteLine();
}
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:
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);
}
}
}
IEnumerable <PEFile> GetReferencingModules(PEFile self, CancellationToken ct)
{
yield return(self);
string reflectionTypeScopeName = typeScope.Name;
if (typeScope.TypeParameterCount > 0)
{
reflectionTypeScopeName += "`" + typeScope.TypeParameterCount;
}
var toWalkFiles = new Stack <PEFile>();
var checkedFiles = new HashSet <PEFile>();
toWalkFiles.Push(self);
checkedFiles.Add(self);
do
{
PEFile curFile = toWalkFiles.Pop();
foreach (var assembly in AssemblyList.GetAssemblies())
{
ct.ThrowIfCancellationRequested();
bool found = false;
var module = assembly.GetPEFileOrNull();
if (module == null || !module.IsAssembly)
{
continue;
}
if (checkedFiles.Contains(module))
{
continue;
}
var resolver = assembly.GetAssemblyResolver();
foreach (var reference in module.AssemblyReferences)
{
using (LoadedAssembly.DisableAssemblyLoad(AssemblyList))
{
if (resolver.Resolve(reference) == curFile)
{
found = true;
break;
}
}
}
if (found && checkedFiles.Add(module))
{
if (ModuleReferencesScopeType(module.Metadata, reflectionTypeScopeName, typeScope.Namespace))
{
yield return(module);
}
if (ModuleForwardsScopeType(module.Metadata, reflectionTypeScopeName, typeScope.Namespace))
{
toWalkFiles.Push(module);
}
}
}
} while (toWalkFiles.Count > 0);
}
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 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 DecompileModule(ModuleDefinition module, ITextOutput output, DecompilationOptions options)
{
WriteModuleAttributes(module, output, options);
// don't automatically load additional assemblies when an assembly node is selected in the tree view
output.WriteLine();
using (options.FullDecompilation ? null : LoadedAssembly.DisableAssemblyLoad())
{
AstBuilder codeDomBuilder = CreateAstBuilder(options, currentModule: module);
codeDomBuilder.AddModule(module, onlyModuleLevel: !options.FullDecompilation);
RunTransformsAndGenerateCode(codeDomBuilder, output, options, module);
}
}
IEnumerable<Tuple<string, string>> WriteAssemblyInfo(ModuleDefinition module, DecompilationOptions options, HashSet<string> directories)
{
// don't automatically load additional assemblies when an assembly node is selected in the tree view
using (LoadedAssembly.DisableAssemblyLoad())
{
AstBuilder codeDomBuilder = CreateAstBuilder(options, currentModule: module);
codeDomBuilder.AddAssembly(module, onlyAssemblyLevel: true);
codeDomBuilder.RunTransformations(transformAbortCondition);
string prop = "Properties";
if (directories.Add("Properties"))
Directory.CreateDirectory(Path.Combine(options.SaveAsProjectDirectory, prop));
string assemblyInfo = Path.Combine(prop, "AssemblyInfo" + this.FileExtension);
using (StreamWriter w = new StreamWriter(Path.Combine(options.SaveAsProjectDirectory, assemblyInfo)))
codeDomBuilder.GenerateCode(new PlainTextOutput(w));
return new Tuple<string, string>[] { Tuple.Create("Compile", assemblyInfo) };
}
}
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 nsList = new List <TNamespace>();
var dict = new Dictionary <string, TNamespace>();
ParserFilesInProject(assembly.ModuleDefinition, options, directories, nsList);
var default_key = "NULL";
var default_ns = new TNamespace();
default_ns.name = default_key;
dict.Add(default_ns.name, default_ns);
foreach (var ns in nsList)
{
string key;
if (ns.name == null)
{
key = default_key;
}
else
{
key = ns.name;
}
if (dict.ContainsKey(key))
{
var mns = dict[key];
foreach (var c in ns.classes)
{
mns.classes.Add(c);
}
}
else
{
dict[ns.name] = ns;
}
}
ModuleTransform(dict["SmartQuant"]);
WriteFilesInProject(assembly.ModuleDefinition, options, directories, dict["SmartQuant"]);
}
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();
}
output.WriteLine("// Architecture: " + GetPlatformDisplayName(mainModule));
if ((mainModule.Attributes & ModuleAttributes.ILOnly) == 0)
{
output.WriteLine("// This assembly contains unmanaged code.");
}
switch (mainModule.Runtime)
{
case TargetRuntime.Net_1_0:
output.WriteLine("// Runtime: .NET 1.0");
break;
case TargetRuntime.Net_1_1:
output.WriteLine("// Runtime: .NET 1.1");
break;
case TargetRuntime.Net_2_0:
output.WriteLine("// Runtime: .NET 2.0");
break;
case TargetRuntime.Net_4_0:
output.WriteLine("// 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);
codeDomBuilder.RunTransformations(transformAbortCondition);
GenerateCode(codeDomBuilder, output);
}
}
}
