public static AssemblyDefinition GetAssemblyDef(string assemblyPath)
{
if (assemblies.ContainsKey(assemblyPath))
return assemblies[assemblyPath];
var assemblyResolver = new DefaultAssemblyResolver();
var assemblyLocation = Path.GetDirectoryName(assemblyPath);
assemblyResolver.AddSearchDirectory(assemblyLocation);
var readerParameters = new ReaderParameters { AssemblyResolver = assemblyResolver };
var pdbName = Path.ChangeExtension(assemblyPath, "pdb");
if (File.Exists(pdbName))
{
var symbolReaderProvider = new PdbReaderProvider();
readerParameters.SymbolReaderProvider = symbolReaderProvider;
readerParameters.ReadSymbols = true;
}
var assemblyDef = AssemblyDefinition.ReadAssembly(assemblyPath, readerParameters);
assemblies.Add(assemblyPath,assemblyDef);
return assemblyDef;
}
public void LoadAsm(string f)
{
source = f;
var ar = new DefaultAssemblyResolver();
ar.AddSearchDirectory(Path.GetDirectoryName(f));
string[] searchDirs = new string[] { @"C:\Program Files\Reference Assemblies", @"C:\Program Files (x86)\Reference Assemblies" };
foreach (string sd in searchDirs) if (Directory.Exists(sd)) ar.AddSearchDirectory(sd);
ar.ResolveFailure += new AssemblyResolveEventHandler(ResolveFailure);
ReaderParameters rp = new ReaderParameters() { AssemblyResolver = ar };
assembly = AssemblyDefinition.ReadAssembly(source, rp);
LoadAssemblyTree();
}
static FodyAssemblyPostProcessor()
{
try
{
//Debug.Log( "Fody processor running" );
// Lock assemblies while they may be altered
EditorApplication.LockReloadAssemblies();
var assetPath = Path.GetFullPath(Application.dataPath);
// This will hold the paths to all the assemblies that will be processed
HashSet<string> assemblyPaths = new HashSet<string>();
// This will hold the search directories for the resolver
HashSet<string> assemblySearchDirectories = new HashSet<string>();
// Add all assemblies in the project to be processed, and add their directory to
// the resolver search directories.
foreach( System.Reflection.Assembly assembly in AppDomain.CurrentDomain.GetAssemblies() )
{
// Only process assemblies which are in the project
if( assembly.Location.Replace( '\\', '/' ).StartsWith( Application.dataPath.Substring( 0, Application.dataPath.Length - 7 ) ) &&
!Path.GetFullPath(assembly.Location).StartsWith(assetPath)) //but not in the assets folder
{
assemblyPaths.Add( assembly.Location );
}
// But always add the assembly folder to the search directories
assemblySearchDirectories.Add( Path.GetDirectoryName( assembly.Location ) );
}
// Create resolver
var assemblyResolver = new DefaultAssemblyResolver();
// Add all directories found in the project folder
foreach( String searchDirectory in assemblySearchDirectories )
{
assemblyResolver.AddSearchDirectory( searchDirectory );
}
// Add path to the Unity managed dlls
assemblyResolver.AddSearchDirectory( Path.GetDirectoryName( EditorApplication.applicationPath ) + "/Data/Managed" );
ProcessAssembliesIn(assemblyPaths, assemblyResolver);
// Unlock now that we're done
EditorApplication.UnlockReloadAssemblies();
}
catch( Exception e )
{
Debug.LogError( e );
}
//Debug.Log("Fody processor finished");
}
public static AssemblyDefinition Load(string fileName)
{
var resolver = new DefaultAssemblyResolver();
resolver.AddSearchDirectory(new FileInfo(fileName).DirectoryName);
var parameters = new ReaderParameters
{
SymbolReaderProvider = new PdbReaderProvider(),
ReadingMode = ReadingMode.Immediate,
AssemblyResolver = resolver
};
AssemblyDefinition assemblyDef;
try
{
assemblyDef = AssemblyDefinition.ReadAssembly(fileName, parameters);
}
catch (FileNotFoundException)
{
// Perhaps we have an MDB file (Mono), or there is no symbol file to load.
// Try MDB first!
parameters.SymbolReaderProvider = new MdbReaderProvider();
try
{
assemblyDef = AssemblyDefinition.ReadAssembly(fileName, parameters);
}
catch (FileNotFoundException)
{
parameters.SymbolReaderProvider = null;
assemblyDef = AssemblyDefinition.ReadAssembly(fileName, parameters);
}
}
return assemblyDef;
}
public static string GenerateBlackList(string librariesFolder, RuntimeClassRegistry usedClasses, string[] allAssemblies)
{
string text = "tmplink.xml";
usedClasses.SynchronizeClasses();
using (TextWriter textWriter = new StreamWriter(Path.Combine(librariesFolder, text)))
{
textWriter.WriteLine("<linker>");
textWriter.WriteLine("<assembly fullname=\"UnityEngine\">");
foreach (string current in usedClasses.GetAllManagedClassesAsString())
{
textWriter.WriteLine(string.Format("<type fullname=\"UnityEngine.{0}\" preserve=\"{1}\"/>", current, usedClasses.GetRetentionLevel(current)));
}
textWriter.WriteLine("</assembly>");
DefaultAssemblyResolver defaultAssemblyResolver = new DefaultAssemblyResolver();
defaultAssemblyResolver.AddSearchDirectory(librariesFolder);
for (int i = 0; i < allAssemblies.Length; i++)
{
string path = allAssemblies[i];
AssemblyDefinition assemblyDefinition = defaultAssemblyResolver.Resolve(Path.GetFileNameWithoutExtension(path), new ReaderParameters
{
AssemblyResolver = defaultAssemblyResolver
});
textWriter.WriteLine("<assembly fullname=\"{0}\">", assemblyDefinition.Name.Name);
MonoAssemblyStripping.GenerateBlackListTypeXML(textWriter, assemblyDefinition.MainModule.Types, usedClasses.GetAllManagedBaseClassesAsString());
textWriter.WriteLine("</assembly>");
}
textWriter.WriteLine("</linker>");
}
return text;
}
private static ModuleDefinition ResolveInterceptorModuleDefinition()
{
const string InterceptorAssemblyName = "StaticProxy.Interceptor";
AssemblyDefinition definition = ModuleWeaver.Instance.AssemblyResolver.Resolve(InterceptorAssemblyName);
if (definition == null)
{
// todo use an integration test to test this!
DirectoryInfo nugetPackagesDirectory = Directory.GetParent(ModuleWeaver.Instance.AddinDirectoryPath);
var assemblyResolver = new DefaultAssemblyResolver();
DirectoryInfo[] packageDirectores = nugetPackagesDirectory.GetDirectories();
foreach (DirectoryInfo packageDirectory in packageDirectores)
{
assemblyResolver.AddSearchDirectory(packageDirectory.FullName);
}
definition = assemblyResolver.Resolve(InterceptorAssemblyName);
if (definition == null)
{
throw new WeavingException("Can't find StaticProxy.Interceptor assembly. Make sure you've downloaded and installed the nuget package!");
}
}
return definition.MainModule;
}
//Adapted from: https://stackoverflow.com/questions/9262464/tool-to-show-assembly-dependencies
public static void PoC(IEnumerable<AssemblyDefinition> assemblies, TextWriter writer, IEnumerable<string> searchfolders)
{
var resolver = new DefaultAssemblyResolver();
searchfolders.ToList().ForEach(x => resolver.AddSearchDirectory(x));
//writer.WriteLine("digraph Dependencies {");
var loaded = assemblies
.SelectMany(a => a.Modules.Cast<ModuleDefinition>())
.SelectMany(m => m.AssemblyReferences.Cast<AssemblyNameReference>())
.Distinct()
.Select(asm => {
var dllname = asm.Name + ".dll";
//Console.WriteLine("Probing for {0}", dllname);
try { return AssemblyDefinition.ReadAssembly(dllname); }
catch { }
try { return resolver.Resolve(asm.FullName); }
catch { }
return null;
})
.Where(assembly => assembly != null)
.ToList();
//loaded.ForEach(a => a.MainModule.ReadSymbols());
loaded.Select(x => x.FullName).Distinct().OrderBy(x => x).ToList().ForEach(x => writer.WriteLine("{0}", x));
/*loaded.ForEach(a =>
{
foreach (var r in a.MainModule.AssemblyReferences.Cast<AssemblyNameReference>())
writer.WriteLine(@"""{0}"" -> ""{1}"";", r.Name, a.Name.Name);
} );*/
//writer.WriteLine("}");
}
private Program()
{
defaultResolver = new DefaultAssemblyResolver();
defaultResolver.AddSearchDirectory(@"..\..\..\..\..\Bin\Desktop\");
writer = new StringWriter();
indexWriter = new StreamWriter("index.md");
}
private static IAssemblyResolver AssemblyResolverFor(IEnumerable<string> assemblies)
{
var resolver = new DefaultAssemblyResolver();
foreach (var directory in assemblies.Select(a => Path.GetFullPath(Path.GetDirectoryName(a))).ToHashSet())
resolver.AddSearchDirectory(directory);
return resolver;
}
private AssemblyDefinition ReadAssembly(string assemblyPath, string searchDir)
{
var assemblyResolver = new DefaultAssemblyResolver();
assemblyResolver.AddSearchDirectory(searchDir);
return
AssemblyDefinition.ReadAssembly(assemblyPath, new ReaderParameters
{
AssemblyResolver = assemblyResolver,
ReadingMode = ReadingMode.Deferred
});
}
public static AssemblyDefinition LoadCecilAssembly(string fileName, bool immediateLoad = false, bool? readSymbols = null)
{
using (var t = new Tracer(Level.L5, myType, "LoadCecilAssembly"))
{
var pdbPath = Path.ChangeExtension(fileName, "pdb");
var tryReadSymbols = readSymbols ?? File.Exists(pdbPath);
var fileInfo = new FileInfo(fileName);
if (fileInfo.Length == 0)
{
t.Info("File {0} has zero byte length", fileName);
return null;
}
try
{
var readingMode = immediateLoad ? ReadingMode.Immediate : ReadingMode.Deferred;
var assemblyResolver = new DefaultAssemblyResolver();
assemblyResolver.AddSearchDirectory(fileInfo.Directory.FullName);
var readerParameters = new ReaderParameters { ReadSymbols = tryReadSymbols, ReadingMode = readingMode, AssemblyResolver = assemblyResolver };
var assemblyDef = AssemblyDefinition.ReadAssembly(fileName, readerParameters);
// Managed C++ assemblies are not supported by Mono Cecil
if (IsManagedCppAssembly(assemblyDef))
{
t.Info("File {0} is a managed C++ assembly", fileName);
return null;
}
return assemblyDef;
}
catch (BadImageFormatException) // Ignore invalid images
{
}
catch (IndexOutOfRangeException)
{
t.Info("File {0} is a managed C++ assembly", fileName);
}
catch (NullReferenceException) // ignore managed c++ targets
{
t.Info("File {0} is a managed C++ assembly", fileName);
}
catch (ArgumentOutOfRangeException)
{
t.Info("File {0} is a managed C++ assembly", fileName);
}
catch (Exception ex)
{
t.Error(Level.L1, "Could not read assembly {0}: {1}", fileName, ex);
}
return null;
}
}
public void Simple()
{
var path = Path.Combine(TestContext.CurrentContext.TestDirectory, "ScriptBuilder.Tests.dll");
var assemblyResolver = new DefaultAssemblyResolver();
assemblyResolver.AddSearchDirectory(TestContext.CurrentContext.TestDirectory);
var readerParameters = new ReaderParameters(ReadingMode.Deferred)
{
AssemblyResolver = assemblyResolver
};
var module = ModuleDefinition.ReadModule(path, readerParameters);
ObjectApprover.VerifyWithJson(SqlVarientReader.Read(module).ToList());
}
private static ReaderParameters CreateReaderParameters( IEnumerable<string> dirs )
{
var resolver = new DefaultAssemblyResolver();
foreach( var dir in dirs )
{
resolver.AddSearchDirectory( dir );
}
return new ReaderParameters
{
AssemblyResolver = resolver,
};
}
public static string GeneratePublicApi(Assembly assemby, Type[] includeTypes = null, bool shouldIncludeAssemblyAttributes = true)
{
var assemblyResolver = new DefaultAssemblyResolver();
var assemblyPath = assemby.Location;
assemblyResolver.AddSearchDirectory(Path.GetDirectoryName(assemblyPath));
var readSymbols = File.Exists(Path.ChangeExtension(assemblyPath, ".pdb"));
var asm = AssemblyDefinition.ReadAssembly(assemblyPath, new ReaderParameters(ReadingMode.Deferred)
{
ReadSymbols = readSymbols,
AssemblyResolver = assemblyResolver,
});
return CreatePublicApiForAssembly(asm, tr => includeTypes == null || includeTypes.Any(t => t.FullName == tr.FullName && t.Assembly.FullName == tr.Module.Assembly.FullName), shouldIncludeAssemblyAttributes);
}
public static void ApprovePublicApi(string assemblyPath)
{
var assemblyResolver = new DefaultAssemblyResolver();
assemblyResolver.AddSearchDirectory(Path.GetDirectoryName(assemblyPath));
var readSymbols = File.Exists(Path.ChangeExtension(assemblyPath, ".pdb"));
var asm = AssemblyDefinition.ReadAssembly(assemblyPath, new ReaderParameters(ReadingMode.Deferred)
{
ReadSymbols = readSymbols,
AssemblyResolver = assemblyResolver,
});
var publicApi = PublicApiGenerator.CreatePublicApiForAssembly(asm);
var writer = new ApprovalTextWriter(publicApi, "cs");
ApprovalTests.Approvals.Verify(writer, new UnitTestFrameworkNamer(), ApprovalTests.Approvals.GetReporter());
}
public ModuleWeaverTestHelper(string inputAssembly)
{
BeforeAssemblyPath = Path.GetFullPath(inputAssembly);
#if (!DEBUG)
BeforeAssemblyPath = BeforeAssemblyPath.Replace("Debug", "Release");
#endif
AfterAssemblyPath = BeforeAssemblyPath.Replace(".dll", "2.dll");
var oldPdb = BeforeAssemblyPath.Replace(".dll", ".pdb");
var newPdb = BeforeAssemblyPath.Replace(".dll", "2.pdb");
File.Copy(BeforeAssemblyPath, AfterAssemblyPath, true);
File.Copy(oldPdb, newPdb, true);
Errors = new List<string>();
var assemblyResolver = new MockAssemblyResolver
{
Directory = Path.GetDirectoryName(BeforeAssemblyPath)
};
using (var symbolStream = File.OpenRead(newPdb))
{
var resolver = new DefaultAssemblyResolver();
resolver.AddSearchDirectory(Directory.GetParent(BeforeAssemblyPath).FullName);
var readerParameters = new ReaderParameters
{
ReadSymbols = true,
SymbolStream = symbolStream,
SymbolReaderProvider = new PdbReaderProvider(),
AssemblyResolver = resolver
};
var moduleDefinition = ModuleDefinition.ReadModule(AfterAssemblyPath, readerParameters);
var weavingTask = new ModuleWeaver
{
ModuleDefinition = moduleDefinition,
AssemblyResolver = assemblyResolver,
LogError = s => Errors.Add(s)
};
weavingTask.Execute();
moduleDefinition.Write(AfterAssemblyPath);
}
Assembly = Assembly.LoadFile(AfterAssemblyPath);
}
public void approve_public_api()
{
var assemblyPath = typeof(StringHumanizeExtensions).Assembly.Location;
var assemblyResolver = new DefaultAssemblyResolver();
assemblyResolver.AddSearchDirectory(Path.GetDirectoryName(assemblyPath));
var readSymbols = File.Exists(Path.ChangeExtension(assemblyPath, ".pdb"));
var asm = AssemblyDefinition.ReadAssembly(assemblyPath, new ReaderParameters(ReadingMode.Deferred)
{
ReadSymbols = readSymbols,
AssemblyResolver = assemblyResolver
});
var publicApi = PublicApiGenerator.CreatePublicApiForAssembly(asm);
Approvals.Verify(publicApi);
}
public static void ApprovePublicApi(string assemblyPath)
{
var assemblyResolver = new DefaultAssemblyResolver();
assemblyResolver.AddSearchDirectory(Path.GetDirectoryName(assemblyPath));
var readSymbols = File.Exists(Path.ChangeExtension(assemblyPath, ".pdb"));
var asm = AssemblyDefinition.ReadAssembly(assemblyPath, new ReaderParameters(ReadingMode.Deferred)
{
ReadSymbols = readSymbols,
AssemblyResolver = assemblyResolver,
});
var publicApi = PublicApiGenerator.CreatePublicApiForAssembly(asm);
publicApi.ShouldMatchApproved(c => c
.WithFileExtension(".cs")
.UseCallerLocation());
}
/// <summary>
/// Returns the code for a specific algorithm.
/// </summary>
/// <returns>The algorithm code.</returns>
/// <param name="algorithmType">Algorithm type.</param>
public static MethodDeclaration GetMethodCode(Type algorithmType, out AstBuilder astBuilder, string methodName)
{
var resolver = new DefaultAssemblyResolver();
resolver.AddSearchDirectory(new FileInfo(Assembly.GetExecutingAssembly().Location).Directory.FullName);
var parameters = new ReaderParameters
{
AssemblyResolver = resolver,
};
// Load Tychaia.ProceduralGeneration into Mono.Cecil.
var module = AssemblyDefinition.ReadAssembly(
Assembly.GetExecutingAssembly().Location,
parameters).MainModule;
// Now we have a reference to the method we want to decompile.
TypeDefinition cecilType;
MethodDefinition processCell;
FindMethodName(module, algorithmType, methodName, out processCell, out cecilType);
var decompilerSettings = new DecompilerSettings();
astBuilder =
new AstBuilder(new DecompilerContext(module) { CurrentType = cecilType, Settings = decompilerSettings });
astBuilder.AddMethod(processCell);
try
{
astBuilder.RunTransformations();
}
catch (AssemblyResolutionException ex)
{
throw new Exception(
"Unable to decompile algorithm source code for " + algorithmType.FullName + ".",
ex);
}
astBuilder.CompilationUnit.AcceptVisitor(new InsertParenthesesVisitor
{
InsertParenthesesForReadability = true
});
// Return.
return
astBuilder.CompilationUnit.Members.Where(v => v is MethodDeclaration).Cast<MethodDeclaration>().First();
}
private static ReflectionModel BuildReflectionModel(IEnumerable<string> paths)
{
var assemblyPaths = FilterFilesOnExtension(paths, ".dll").ToArray();
var definitions = new List<AssemblyDefinition>();
var resolver = new DefaultAssemblyResolver();
foreach (var assemblyPath in assemblyPaths)
{
resolver.AddSearchDirectory(Path.GetDirectoryName(assemblyPath));
}
var parameters = new ReaderParameters {
AssemblyResolver = resolver,
};
foreach (var assemblyPath in assemblyPaths)
{
definitions.Add(AssemblyDefinition.ReadAssembly(assemblyPath, parameters));
}
return ReflectionModelBuilder.Build(definitions);
}
public static string GenerateBlackList(string librariesFolder, RuntimeClassRegistry usedClasses, string[] allAssemblies)
{
string str = "tmplink.xml";
usedClasses.SynchronizeClasses();
using (TextWriter writer = new StreamWriter(Path.Combine(librariesFolder, str)))
{
writer.WriteLine("<linker>");
writer.WriteLine("<assembly fullname=\"UnityEngine\">");
foreach (string str2 in usedClasses.GetAllManagedClassesAsString())
{
writer.WriteLine(string.Format("<type fullname=\"UnityEngine.{0}\" preserve=\"{1}\"/>", str2, usedClasses.GetRetentionLevel(str2)));
}
writer.WriteLine("</assembly>");
DefaultAssemblyResolver resolver = new DefaultAssemblyResolver();
resolver.AddSearchDirectory(librariesFolder);
foreach (string str3 in allAssemblies)
{
ReaderParameters parameters = new ReaderParameters {
AssemblyResolver = resolver
};
AssemblyDefinition definition = resolver.Resolve(Path.GetFileNameWithoutExtension(str3), parameters);
writer.WriteLine("<assembly fullname=\"{0}\">", definition.Name.Name);
if (definition.Name.Name.StartsWith("UnityEngine."))
{
foreach (string str4 in usedClasses.GetAllManagedClassesAsString())
{
writer.WriteLine(string.Format("<type fullname=\"UnityEngine.{0}\" preserve=\"{1}\"/>", str4, usedClasses.GetRetentionLevel(str4)));
}
}
GenerateBlackListTypeXML(writer, definition.MainModule.Types, usedClasses.GetAllManagedBaseClassesAsString());
writer.WriteLine("</assembly>");
}
writer.WriteLine("</linker>");
}
return str;
}
private static ReflectionModel BuildReflectionModel(IDictionary<string, IDocumentationMetadata> paths)
{
var items = FilterFilesOnExtension(paths, ".dll");
var definitions = new Dictionary<AssemblyDefinition, IDocumentationMetadata>();
var resolver = new DefaultAssemblyResolver();
foreach (var item in items)
{
resolver.AddSearchDirectory(Path.GetDirectoryName(item.Key));
}
var parameters = new ReaderParameters
{
AssemblyResolver = resolver,
};
foreach (var item in items)
{
var definition = AssemblyDefinition.ReadAssembly(item.Key, parameters);
definitions.Add(definition, item.Value);
}
return ReflectionModelBuilder.Build(definitions);
}
static int Main (string [] args)
{
int input;
string output;
switch (args.Length) {
case 0:
Console.WriteLine ("Usage: detect-sc input-dir [input-dir [...]] [output-dir]");
return 1;
case 1:
output = args [0];
input = 1;
break;
default:
input = args.Length - 1;
output = args [input];
break;
}
foreach (string assembly in PlatformCode.Assemblies) {
Console.Write ("{0}.dll:", assembly);
string fullpath = null;
for (int i = 0; i < input; i++) {
fullpath = Path.Combine (args [i], assembly) + ".dll";
if (File.Exists (fullpath))
break;
fullpath = null;
}
if (fullpath == null) {
Console.WriteLine (" NOT FOUND!", assembly);
continue;
}
var resolver = new DefaultAssemblyResolver ();
resolver.AddSearchDirectory (args [0]);
AssemblyDefinition ad = AssemblyDefinition.ReadAssembly (fullpath, new ReaderParameters { AssemblyResolver = resolver });
ProcessAssembly (ad);
string outfile = Path.Combine (output, assembly) + ".auto.sc";
using (StreamWriter sw = new StreamWriter (outfile)) {
sw.WriteLine ("# [SecurityCritical] needed to execute code inside '{0}'.", ad.Name.FullName);
sw.WriteLine ("# {0} methods needs to be decorated.", methods.Count);
sw.WriteLine ();
Console.Write (" {0} methods", methods.Count);
foreach (KeyValuePair<string, string> kvp in methods) {
sw.WriteLine ("# {0}", kvp.Value);
sw.WriteLine ("+SC-M: {0}", kvp.Key);
sw.WriteLine ();
}
}
methods.Clear ();
Console.WriteLine (".");
}
return 0;
}
private ReaderParameters GetReaderParameters()
{
var assemblyResolver = new DefaultAssemblyResolver();
var assemblyLocation = Path.GetDirectoryName(_assemblyLocation);
assemblyResolver.AddSearchDirectory(assemblyLocation);
var readerParameters = new ReaderParameters { AssemblyResolver = assemblyResolver };
if (!File.Exists(PdbName)) return readerParameters;
var symbolReaderProvider = new PdbReaderProvider();
readerParameters.SymbolReaderProvider = symbolReaderProvider;
readerParameters.ReadSymbols = _mode == PatchMode.Debug;
readerParameters.ReadingMode = ReadingMode.Deferred;
return readerParameters;
}
static void Check (string filename)
{
var resolver = new DefaultAssemblyResolver ();
resolver.AddSearchDirectory (RuntimePath);
resolver.AddSearchDirectory (SdkClientPath);
AssemblyDefinition assembly = AssemblyDefinition.ReadAssembly (filename, new ReaderParameters { AssemblyResolver = resolver });
foreach (ModuleDefinition module in assembly.Modules) {
foreach (TypeDefinition type in module.GetAllTypes ()) {
foreach (MethodDefinition md in type.Methods) {
Check (assembly, md);
}
}
}
Console.WriteLine ("# Assembly: {0} [{1} items]", assembly, internals.Count);
internals.Sort ();
foreach (string s in internals)
Console.WriteLine (s);
Console.WriteLine ();
internals.Clear ();
}
private DefaultAssemblyResolver GetAssemblyResolver()
{
var assemblyResolver = new DefaultAssemblyResolver();
// Fix for having path to bin directory when running ASP.NET app.
var extraSearchDir = Path.GetDirectoryName(new Uri(GetType().Assembly.CodeBase).AbsolutePath);
assemblyResolver.AddSearchDirectory(extraSearchDir);
return assemblyResolver;
}
private void scan_Click(object sender, EventArgs e)
{
nodeTypeDefs.Clear();
nodeTreeNodes.Clear();
treeView1.Nodes.Clear();
DefaultAssemblyResolver asmResolver = new DefaultAssemblyResolver();
ReaderParameters readPars = new ReaderParameters(ReadingMode.Deferred);
readPars.AssemblyResolver = asmResolver;
//temp
asmResolver.AddSearchDirectory(Path.GetDirectoryName(_browsePath));
AssemblyDefinition assem = AssemblyDefinition.ReadAssembly(_browsePath, readPars);
var types = assem.MainModule.Types;
var nameSpace = assem.MainModule.Types;
TreeNode node = new TreeNode();
foreach (TypeDefinition type in types)
{
if (nodeTreeNodes.TryGetValue(type.Namespace, out node))
{
node.Nodes.Add(type.Name);
}
else
{
node = new TreeNode(type.Namespace);
node.Nodes.Add(type.Name);
}
nodeTreeNodes[type.Namespace] = node;
nodeTypeDefs.Add(type.FullName, type);
}
List<string> keys = new List<string>(nodeTreeNodes.Keys);
foreach (string key in keys)
{
if (nodeTreeNodes.TryGetValue(key, out node))
treeView1.Nodes.Add(node);
}
EnableDecompileWidget(true);
lbCountAll.Text = Path.GetFileName(_browsePath) + " have " + nodeTypeDefs.Count + " types";
}
public static AssemblyDefinition[] ToDefinitions(IEnumerable <string> assemblyLocations)
{
if (assemblyLocations == null || !assemblyLocations.Any())
{
return(new AssemblyDefinition[0]);
}
assemblyLocations = assemblyLocations.Select(x =>
{
if (!File.Exists(x))
{
return(x);
}
var path = Path.GetDirectoryName(x);
var asmInfo = Path.Combine(path, "__AssemblyInfo__.ini");
if (!File.Exists(asmInfo))
{
return(x);
}
var content = File.ReadAllText(asmInfo, System.Text.Encoding.Unicode);
var idx = content.LastIndexOf("\0file:///");
if (idx < 0)
{
return(x);
}
var end = content.IndexOf('\0', idx + 9);
if (end < 0)
{
return(x);
}
var location = content.Substring(idx + 9, end - idx - 9).Replace('/', '\\');
if (File.Exists(location))
{
return(location);
}
return(x);
}).ToList();
#if COREFX
var resolver = ICSharpCode.Decompiler.UniversalAssemblyResolver
.LoadMainModule(assemblyLocations.First(), inMemory: true).AssemblyResolver
as ICSharpCode.Decompiler.UniversalAssemblyResolver;
#else
var resolver = new Mono.Cecil.DefaultAssemblyResolver();
#endif
foreach (var assembly in assemblyLocations)
{
resolver.AddSearchDirectory(Path.GetDirectoryName(assembly));
}
var assemblyDefinitions = new List <AssemblyDefinition>();
foreach (var assembly in assemblyLocations)
{
assemblyDefinitions.Add(Mono.Cecil.AssemblyDefinition.ReadAssembly(
assembly, new Mono.Cecil.ReaderParameters
{
AssemblyResolver = resolver,
InMemory = true
}));
}
return(assemblyDefinitions.ToArray());
}
private static AssemblyDefinition LoadAssembly(string path)
{
var resolver = new DefaultAssemblyResolver();
resolver.AddSearchDirectory(Path.GetDirectoryName(path));
return AssemblyDefinition.ReadAssembly(path, new ReaderParameters {AssemblyResolver = resolver});
}
internal static Dictionary<string, AssemblyTuple> smethod_1(IEnumerable<AssemblyFileInfo> coreAssemblyFiles)
{
Dictionary<string, AssemblyTuple> dictionary = new Dictionary<string, AssemblyTuple>();
DefaultAssemblyResolver defaultAssemblyResolver = new DefaultAssemblyResolver();
foreach (string current in BfCache.list_0)
{
if (Directory.Exists(current))
{
defaultAssemblyResolver.AddSearchDirectory(current);
}
}
foreach (AssemblyFileInfo current2 in coreAssemblyFiles)
{
if (current2.Name == "Search Directory")
{
defaultAssemblyResolver.AddSearchDirectory(current2.Path);
}
else
{
string directoryName = Path.GetDirectoryName(current2.Path);
defaultAssemblyResolver.AddSearchDirectory(directoryName);
}
}
foreach (AssemblyFileInfo current2 in coreAssemblyFiles)
{
if (!(current2.Name == "Search Directory"))
{
AssemblyDefinition assembly;
try
{
assembly = AssemblyFactory.GetAssembly(current2.Path);
}
catch (ImageFormatException)
{
throw new NitriqException("NotManagedAssembly", "The assembly \"" + current2.Name + "\" is not a managed assembly");
}
if (!dictionary.ContainsKey(assembly.Name.FullName))
{
AssemblyTuple assemblyTuple = new AssemblyTuple(assembly);
assemblyTuple.IsCoreAssembly = true;
assemblyTuple.Directory = Path.GetDirectoryName(current2.Path);
dictionary.Add(assembly.Name.FullName, assemblyTuple);
}
}
}
List<AssemblyTuple> list = new List<AssemblyTuple>(dictionary.Values);
foreach (AssemblyTuple current3 in list)
{
foreach (ModuleDefinition moduleDefinition in current3.Assembly.Modules)
{
foreach (AssemblyNameReference assemblyNameReference in moduleDefinition.AssemblyReferences)
{
AssemblyDefinition assemblyDefinition;
try
{
assemblyDefinition = defaultAssemblyResolver.Resolve(assemblyNameReference);
}
catch (FileNotFoundException)
{
throw new NitriqException("CantResolve", "Nitriq couldn't resolve the below assembly, consider adding a search directory where this assembly can be found \r\n\r\n" + assemblyNameReference.FullName);
}
string fullName = assemblyNameReference.FullName;
string fullName2 = assemblyDefinition.Name.FullName;
if (fullName2 == fullName)
{
if (!dictionary.ContainsKey(fullName))
{
dictionary.Add(fullName, new AssemblyTuple(assemblyDefinition)
{
Directory = "",
IsCoreAssembly = false
});
}
}
else if (dictionary.ContainsKey(fullName) || dictionary.ContainsKey(fullName2))
{
if (!dictionary.ContainsKey(fullName))
{
dictionary.Add(fullName, dictionary[fullName2]);
}
if (!dictionary.ContainsKey(fullName2))
{
dictionary.Add(fullName2, dictionary[fullName]);
}
}
else
{
AssemblyTuple assemblyTuple2 = new AssemblyTuple(assemblyDefinition);
assemblyTuple2.Directory = "";
assemblyTuple2.IsCoreAssembly = false;
dictionary.Add(fullName, assemblyTuple2);
dictionary.Add(fullName2, assemblyTuple2);
}
}
}
}
return dictionary;
}
/// <summary>
/// Patches the file.
/// </summary>
/// <param name="file">The file.</param>
public bool PatchFile(string file)
{
file = Path.Combine(Environment.CurrentDirectory, file);
var fileTime = new FileTime(file);
//var fileTimeInteropBuilder = new FileTime(Assembly.GetExecutingAssembly().Location);
string checkFile = Path.GetFullPath(file) + ".check";
//string checkInteropBuilderFile = "InteropBuild.check";
// If checkFile and checkInteropBuilderFile up-to-date, then nothing to do
if (fileTime.CheckFileUpToDate(checkFile))
{
Log("Nothing to do. SharpDX patch was already applied for assembly [{0}]", file);
return false;
}
// Copy PDB from input assembly to output assembly if any
var readerParameters = new ReaderParameters();
var resolver = new DefaultAssemblyResolver();
readerParameters.AssemblyResolver = resolver;
var writerParameters = new WriterParameters();
var pdbName = Path.ChangeExtension(file, "pdb");
if (File.Exists(pdbName))
{
var symbolReaderProvider = new PdbReaderProvider();
readerParameters.SymbolReaderProvider = symbolReaderProvider;
readerParameters.ReadSymbols = true;
writerParameters.WriteSymbols = true;
}
// Read Assembly
assembly = AssemblyDefinition.ReadAssembly(file, readerParameters);
resolver.AddSearchDirectory(Path.GetDirectoryName(file));
// Query the target framework in order to resolve correct assemblies and type forwarding
var targetFrameworkAttr = assembly.CustomAttributes.FirstOrDefault(
attribute => attribute.Constructor.FullName.Contains("System.Runtime.Versioning.TargetFrameworkAttribute"));
if(targetFrameworkAttr != null && targetFrameworkAttr.ConstructorArguments.Count > 0 &&
targetFrameworkAttr.ConstructorArguments[0].Value != null)
{
var targetFramework = new FrameworkName(targetFrameworkAttr.ConstructorArguments[0].Value.ToString());
var netcoreAssemblyPath = string.Format(@"Reference Assemblies\Microsoft\Framework\{0}\v{1}",
targetFramework.Identifier,
targetFramework.Version);
netcoreAssemblyPath = Path.Combine(ProgramFilesx86(), netcoreAssemblyPath);
if(Directory.Exists(netcoreAssemblyPath))
{
resolver.AddSearchDirectory(netcoreAssemblyPath);
}
}
// Import void* and int32
voidType = assembly.MainModule.TypeSystem.Void.Resolve();
voidPointerType = new PointerType(assembly.MainModule.Import(voidType));
intType = assembly.MainModule.Import( assembly.MainModule.TypeSystem.Int32.Resolve());
// Remove CompilationRelaxationsAttribute
for (int i = 0; i < assembly.CustomAttributes.Count; i++)
{
var customAttribute = assembly.CustomAttributes[i];
if (customAttribute.AttributeType.FullName == typeof(CompilationRelaxationsAttribute).FullName)
{
assembly.CustomAttributes.RemoveAt(i);
i--;
}
}
Log("SharpDX interop patch for assembly [{0}]", file);
foreach (var type in assembly.MainModule.Types)
PatchType(type);
// Remove All Interop classes
foreach (var type in classToRemoveList)
assembly.MainModule.Types.Remove(type);
var outputFilePath = file;
assembly.Write(outputFilePath, writerParameters);
fileTime = new FileTime(file);
// Update Check file
fileTime.UpdateCheckFile(checkFile);
//fileTimeInteropBuilder.UpdateCheckFile(checkInteropBuilderFile);
Log("SharpDX patch done for assembly [{0}]", file);
return true;
}
