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 MemberReference GetMemberReference(IAssemblyResolver resolver)
{
if (resolver == null)
throw new ArgumentNullException("resolver");
if (memberReference != null)
return memberReference;
// reload from filename
ReaderParameters readerParameters = new ReaderParameters();
// Use new assembly resolver instance so that the AssemblyDefinitions can be garbage-collected
// once the code is decompiled.
readerParameters.AssemblyResolver = resolver;
string typeName;
if (GetAssemblyAndType(FileName.ToString(), out assemblyFile, out typeName)) {
ModuleDefinition module = ModuleDefinition.ReadModule(assemblyFile, readerParameters);
TypeDefinition typeDefinition = module.GetType(typeName);
if (typeDefinition == null)
throw new InvalidOperationException("Could not find type");
memberReference = typeDefinition;
}
return memberReference;
}
/// <summary>
/// Reads the assembly from the given path, or else loads it from cache.
/// </summary>
/// <param name="path">The patch to read the assembly from.</param>
/// <param name="readSymbols">Whether or not to read symbols.</param>
/// <returns></returns>
public AssemblyDefinition ReadAssembly(string path, bool readSymbols = false)
{
var fileInfo = new FileInfo(path);
fileInfo.Refresh();
if (_cache.ContainsKey(path)) {
if (DoesCacheMatch(fileInfo, _cache[path].Metadata)) {
return _cache[path].Assembly;
}
}
var defAssemblyResolver = new ExpandedAssemblyResolver();
defAssemblyResolver.AddSearchDirectory(Path.GetDirectoryName(path));
var rdrParams = new ReaderParameters() {
AssemblyResolver = defAssemblyResolver,
ReadSymbols = readSymbols
};
var read = AssemblyDefinition.ReadAssembly(path, rdrParams);
var assemblyResolver = read.MainModule.AssemblyResolver as BaseAssemblyResolver;
//Cecil doesn't add the assembly's original directory as a search path by default.
var dir = Path.GetDirectoryName(path);
var entry = new AssemblyCacheEntry() {
Assembly = read,
Metadata = new FileMetadata() {
Length = fileInfo.Length,
LastWriteTime = fileInfo.LastWriteTimeUtc,
CreationTime = fileInfo.CreationTimeUtc
},
Path = path
};
_cache[path] = entry;
return read;
}
public AssemblyDefinition Resolve(string fullName, ReaderParameters parameters)
{
if (string.IsNullOrEmpty(fullName))
throw new ArgumentException("fullName is null or empty");
return Resolve(AssemblyNameReference.Parse(fullName), parameters);
}
static void Main(string[] args)
{
try
{
var path = args.Length >= 1 ? args[0] : "Ibasa.dll";
var symbolReader = new Mono.Cecil.Pdb.PdbReaderProvider();
var readerParameters = new ReaderParameters()
{
SymbolReaderProvider = symbolReader,
ReadSymbols = true,
};
var writerParameters = new WriterParameters()
{
WriteSymbols = true,
};
AssemblyDefinition assembly = AssemblyDefinition.ReadAssembly(path, readerParameters);
Console.WriteLine("Loaded {0}.", path);
GenerateMemoryType(assembly.MainModule);
Console.WriteLine("Saving new dll.");
assembly.Write(path, writerParameters);
}
catch (Exception e)
{
Console.WriteLine("InteropBuilder failed with: {0}", e);
}
}
public virtual void ReadModule()
{
string symbolsPath;
if (pdbFound)
{
symbolsPath = pdbPath;
}
else
{
symbolsPath = mdbPath;
}
var tempAssembly = $"{AssemblyFilePath}.tmp";
var tempSymbols = $"{symbolsPath}.tmp";
File.Copy(AssemblyFilePath, tempAssembly,true);
File.Copy(symbolsPath, tempSymbols, true);
SymbolStream = File.OpenRead(tempSymbols);
var readerParameters = new ReaderParameters
{
AssemblyResolver = this,
ReadSymbols = true,
SymbolReaderProvider = debugReaderProvider,
SymbolStream = SymbolStream,
};
ModuleDefinition = ModuleDefinition.ReadModule(tempAssembly, readerParameters);
}
public void ReadModule()
{
if (pdbFound)
{
using (var symbolStream = File.OpenRead(pdbPath))
{
var readerParameters = new ReaderParameters
{
AssemblyResolver = this,
ReadSymbols = pdbFound || mdbFound,
SymbolReaderProvider = debugReaderProvider,
SymbolStream = symbolStream
};
ModuleDefinition = ModuleDefinition.ReadModule(AssemblyFilePath, readerParameters);
}
}
else
{
var readerParameters = new ReaderParameters
{
AssemblyResolver = this,
ReadSymbols = pdbFound || mdbFound,
SymbolReaderProvider = debugReaderProvider,
};
ModuleDefinition = ModuleDefinition.ReadModule(AssemblyFilePath, readerParameters);
}
}
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 WeaverHelper(string projectPath)
{
this.projectPath = Path.GetFullPath(Path.Combine(TestContext.CurrentContext.TestDirectory, @"..\..\..\TestAssemblies", projectPath));
GetAssemblyPath();
AfterAssemblyPath = BeforeAssemblyPath.Replace(".dll", "2.dll");
File.Copy(BeforeAssemblyPath, AfterAssemblyPath, true);
var assemblyResolver = new TestAssemblyResolver(BeforeAssemblyPath, this.projectPath);
var readerParameters = new ReaderParameters
{
AssemblyResolver = assemblyResolver
};
var moduleDefinition = ModuleDefinition.ReadModule(AfterAssemblyPath, readerParameters);
var weavingTask = new ModuleWeaver
{
ModuleDefinition = moduleDefinition,
AssemblyResolver = assemblyResolver
};
weavingTask.Execute();
moduleDefinition.Write(AfterAssemblyPath);
Assembly = Assembly.LoadFile(AfterAssemblyPath);
}
public AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters)
{
lock (resolutionCache)
{
string key = name.FullName;
AssemblyDefinition result;
if (resolutionCache.TryGetValue(key, out result))
return result;
}
if (!name.Name.StartsWith("System", StringComparison.OrdinalIgnoreCase)
&& !name.Name.StartsWith("mscorlib", StringComparison.OrdinalIgnoreCase))
return null;
var asm = Assembly.Load(name.ToString());
var asmDef = AssemblyDefinition.ReadAssembly(
asm.Location,
parameters ??
new ReaderParameters(ReadingMode.Deferred) { AssemblyResolver = this });
lock (resolutionCache)
{
string key = name.FullName;
AssemblyDefinition result;
if (resolutionCache.TryGetValue(key, out result))
return result;
resolutionCache[key] = asmDef;
}
return asmDef;
}
public AssemblyDefinition Resolve(string fullName, ReaderParameters parameters)
{
var dllName = fullName.Split(',')[0] + ".dll";
var fullPath = _targetAssemblyDirs.Select(x => Path.Combine(x, dllName)).FirstOrDefault(x => File.Exists(x));
if (fullPath == null)
{
dllName = fullName.Split(',')[0] + ".winmd";
fullPath = _targetAssemblyDirs.Select(x => Path.Combine(x, dllName)).FirstOrDefault(x => File.Exists(x));
}
// NB: This hacks WinRT's weird mscorlib to just use the regular one
// We forget why this was needed, maybe it's not needed anymore?
if (fullName.Contains("mscorlib") && fullName.Contains("255"))
{
fullPath =
Environment.ExpandEnvironmentVariables(
@"%SystemRoot%\Microsoft.NET\Framework\v4.0.30319\mscorlib.dll");
}
if (fullPath == null)
{
var errorMessage = $"Failed to resolve!!! {fullName}";
Log.Error(errorMessage);
throw new Exception(errorMessage);
}
return AssemblyDefinition.ReadAssembly(fullPath, parameters);
}
public static AssemblyNode ReadAssembly (string filename)
{
var readerParameters = new ReaderParameters ();
AssemblyDefinition definition = AssemblyDefinition.ReadAssembly (filename, readerParameters);
return new AssemblyNode (definition);
}
/// <summary>
/// Patches the specified input PDB file.
/// </summary>
/// <param name="inputExeFile">The input PDB file.</param>
/// <param name="outputPdbFile">The output PDB file.</param>
/// <param name="sourcePathRewriter">The source path modifier.</param>
/// <exception cref="System.ArgumentNullException">inputExeFile</exception>
public static void Patch(string inputExeFile, string outputPdbFile, SourcePathRewriterDelegate sourcePathRewriter)
{
if (inputExeFile == null) throw new ArgumentNullException("inputExeFile");
if (outputPdbFile == null) throw new ArgumentNullException("outputPdbFile");
if (sourcePathRewriter == null) throw new ArgumentNullException("sourcePathRewriter");
// Copy PDB from input assembly to output assembly if any
var inputPdbFile = Path.ChangeExtension(inputExeFile, "pdb");
if (!File.Exists(inputPdbFile))
{
ShowMessage(string.Format("Warning file [{0}] does not exist", inputPdbFile), ConsoleColor.Yellow);
return;
}
var symbolReaderProvider = new PdbReaderProvider();
var readerParameters = new ReaderParameters
{
SymbolReaderProvider = symbolReaderProvider,
ReadSymbols = true
};
// Read Assembly
var assembly = AssemblyDefinition.ReadAssembly(inputExeFile, readerParameters);
// Write back the assembly and pdb
assembly.Write(inputExeFile, new WriterParameters {WriteSymbols = true, SourcePathRewriter = sourcePathRewriter});
}
public ObfuscationContext(bool symbols = false)
{
_resolver = new AssemblyResolver();
Symbols = symbols;
_readerParameters = new ReaderParameters() { ReadSymbols = Symbols };
Filter = new DefaultFilter();
}
public IEnumerable<MSpecTestCase> DiscoverSpecs(string assemblyFilePath)
{
if (!this.AssemblyContainsMSpecReference(assemblyFilePath) || !this.SourceDirectoryContainsMSpec(assemblyFilePath))
return new List<MSpecTestCase>();
assemblyFilePath = Path.GetFullPath(assemblyFilePath);
if (!File.Exists(assemblyFilePath))
{
throw new ArgumentException("Could not find file: " + assemblyFilePath);
}
this.AssemblyFilename = assemblyFilePath;
// make sure that cecil looks in the assembly path for mspec (+ related assemblies) first
this.AssemblyResolver = new ScopedAssemblyResolver(Path.GetDirectoryName(assemblyFilePath));
this.ReaderParameters = new ReaderParameters()
{
ReadSymbols = true,
AssemblyResolver = AssemblyResolver
};
List<MSpecTestCase> list = new List<MSpecTestCase>();
List<IDelegateFieldScanner> fieldScanners = new List<IDelegateFieldScanner>();
fieldScanners.Add(new ItDelegateFieldScanner());
fieldScanners.Add(new CustomDelegateFieldScanner());
// statically inspect the types in the assembly using mono.cecil
var assembly = AssemblyDefinition.ReadAssembly(this.AssemblyFilename, this.ReaderParameters);
foreach (TypeDefinition type in GetNestedTypes(assembly.MainModule.Types))
{
// if a type is an It delegate generate some test case info for it
foreach (FieldDefinition fieldDefinition in type.Fields.Where(x => !x.Name.Contains("__Cached")))
{
foreach (IDelegateFieldScanner scanner in fieldScanners)
{
if (scanner.ProcessFieldDefinition(fieldDefinition))
{
string typeName = NormalizeCecilTypeName(type.Name);
string typeFullName = NormalizeCecilTypeName(type.FullName);
MSpecTestCase testCase = new MSpecTestCase()
{
ClassName = typeName,
ContextFullType = typeFullName,
SpecificationName = fieldDefinition.Name,
ContextDisplayName = GetContextDisplayName(type),
SpecificationDisplayName = fieldDefinition.Name.Replace("_", " "),
};
// get the source code location for the It delegate from the PDB file using mono.cecil.pdb
this.UpdateTestCaseWithLocation(type, testCase);
list.Add(testCase);
break;
}
}
}
}
return list.Select(x => x);
}
public IAssemblyTracker CreateTracker()
{
if (_whiteList == null || _whiteList.Count == 0)
throw new InvalidOperationException
("Initialize options first. (AssemblyTracker: target files have to be set!)");
var readPDB = new ReaderParameters { ReadSymbols = true };
var ignorePDB = new ReaderParameters { ReadSymbols = false };
var allFiles = BuildTargetFilesList();
List<AssemblyDefinition> assemblies = new List<AssemblyDefinition> ();
foreach (var doc in allFiles)
{
try
{
if (_fileSystem.FileExists (doc.Substring (0, doc.Length-3) + "pdb"))
assemblies.Add (_fileSystem.ReadAssembly (doc, readPDB));
else
assemblies.Add (_fileSystem.ReadAssembly (doc, ignorePDB));
}
catch (BadImageFormatException e)
{
Console.WriteLine (" WARNING :: '" + doc + "' is not a valid .NET assembly! [is ignored]");
}
}
((BaseAssemblyResolver) GlobalAssemblyResolver.Instance).AddSearchDirectory (_workingDirectory);
return new AssemblyTracker (assemblies, new TypeDefinitionCache());
}
public virtual AssemblyDefinition Resolve (string fullName, ReaderParameters parameters)
{
if (fullName == null)
throw new ArgumentNullException ("fullName");
return Resolve (AssemblyNameReference.Parse (fullName), parameters);
}
public AssemblyLoader(IEnumerable<NPath> searchDirectories, [Optional, DefaultParameterValue(false)] bool readSymbols, [Optional, DefaultParameterValue(false)] bool applyWindowsRuntimeProjections)
{
this._resolver = new AssemblyResolver(this);
foreach (NPath path in searchDirectories)
{
if (path != null)
{
this._resolver.AddSearchDirectory(path);
}
}
ReaderParameters parameters = new ReaderParameters {
AssemblyResolver = this._resolver,
MetadataResolver = new WindowsRuntimeAwareMetadataResolver(this._resolver),
ReadSymbols = readSymbols,
SymbolReaderProvider = !readSymbols ? null : new MdbReaderProvider(),
ApplyWindowsRuntimeProjections = applyWindowsRuntimeProjections
};
this._readerParameters = parameters;
parameters = new ReaderParameters {
ApplyWindowsRuntimeProjections = this._readerParameters.ApplyWindowsRuntimeProjections,
AssemblyResolver = this._readerParameters.AssemblyResolver,
MetadataImporterProvider = this._readerParameters.MetadataImporterProvider,
MetadataResolver = this._readerParameters.MetadataResolver,
ReadingMode = this._readerParameters.ReadingMode,
ReadSymbols = false,
SymbolReaderProvider = null,
ReflectionImporterProvider = this._readerParameters.ReflectionImporterProvider,
SymbolStream = this._readerParameters.SymbolStream
};
this._readerWithoutSymbolsParameters = parameters;
}
public AssemblyWeaver(string assemblyPath, List<string> referenceAssemblyPaths = null)
{
if (referenceAssemblyPaths == null)
{
referenceAssemblyPaths = new List<string>();
}
assemblyPath = FixAssemblyPath(assemblyPath);
var newAssembly = assemblyPath.Replace(".dll", "2.dll");
File.Copy(assemblyPath, newAssembly, true);
var assemblyResolver = new MockAssemblyResolver();
foreach (var referenceAssemblyPath in referenceAssemblyPaths)
{
var directoryName = Path.GetDirectoryName(referenceAssemblyPath);
assemblyResolver.AddSearchDirectory(directoryName);
}
var readerParameters = new ReaderParameters
{
AssemblyResolver = assemblyResolver
};
var moduleDefinition = ModuleDefinition.ReadModule(newAssembly, readerParameters);
var weavingTask = new ModuleWeaver
{
ModuleDefinition = moduleDefinition,
AssemblyResolver = assemblyResolver,
LogError = LogError,
ReferenceCopyLocalPaths = referenceAssemblyPaths
};
weavingTask.Execute();
moduleDefinition.Write(newAssembly);
Assembly = Assembly.LoadFrom(newAssembly);
}
public void LoadAssemblyAndGetMethods()
{
var readerParameters = new ReaderParameters { ReadSymbols = true };
assembly = AssemblyDefinition.ReadAssembly(assemblyPath, readerParameters);
methods = assembly.MainModule.Types.
SelectMany(type => type.Methods);
}
public static string Weave(string assemblyPath)
{
var newAssembly = assemblyPath.Replace(".dll", "2.dll");
var oldPdb = assemblyPath.Replace(".dll", ".pdb");
var newPdb = assemblyPath.Replace(".dll", "2.pdb");
File.Copy(assemblyPath, newAssembly, true);
File.Copy(oldPdb, newPdb, true);
var assemblyResolver = new MockAssemblyResolver
{
Directory = Path.GetDirectoryName(assemblyPath)
};
using (var symbolStream = File.OpenRead(newPdb))
{
var readerParameters = new ReaderParameters
{
ReadSymbols = true,
SymbolStream = symbolStream,
SymbolReaderProvider = new PdbReaderProvider()
};
var moduleDefinition = ModuleDefinition.ReadModule(newAssembly, readerParameters);
var weavingTask = new ModuleWeaver
{
ModuleDefinition = moduleDefinition,
AssemblyResolver = assemblyResolver
};
weavingTask.Execute();
moduleDefinition.Write(newAssembly);
return newAssembly;
}
}
AssemblyDefinition LoadAssembly()
{
// runs on background thread
ReaderParameters p = new ReaderParameters();
p.AssemblyResolver = new MyAssemblyResolver(this);
return AssemblyDefinition.ReadAssembly(fileName, p);
}
public override AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters)
{
if (name == null)
throw new ArgumentNullException("name");
return Cache.GetOrCreate(name.FullName, () => base.Resolve(name, parameters));
}
public void CompileIfRequired(ilspy::Mono.Cecil.AssemblyDefinition assembly, bool stopBeforeGeneratingCode = false)
{
if (_compiler != null && _previousAssembly == assembly
&& (_isFullyCompiled || stopBeforeGeneratingCode))
return;
CompilationErrors = null;
_compiler = null;
#if DEBUG
var framework = Frameworks.Instance.GetBySdkVersion(15);
#else
var framework = Frameworks.Instance.GetNewestVersion();
#endif
string frameworkFolder = framework.Folder;
var refFolders = new List<string> { frameworkFolder };
var module = new XModule();
var classLoader = new AssemblyClassLoader(module.OnClassLoaded);
var resolver = new AssemblyResolver(refFolders, classLoader, module.OnAssemblyLoaded);
var parameter = new ReaderParameters(ReadingMode.Immediate) { AssemblyResolver = resolver,ReadSymbols = true};
var assemblies = new[] { resolver.Load(assembly.MainModule.FullyQualifiedName, parameter) }.ToList();
List<AssemblyDefinition> references = new List<AssemblyDefinition>();
if(assembly.MainModule.Name != "dot42.dll")
references = new[] { resolver.Load(AssemblyConstants.SdkAssemblyName, parameter) }.ToList();
foreach (var a in assemblies)
references.Remove(a);
var c = new AssemblyCompiler(CompilationMode.All, assemblies, references, new Table("pkg.name"),
new NameConverter("pkg.name", ""), true,
new AssemblyClassLoader(file => { }), definition => null,
new DexMethodBodyCompilerCache(), new HashSet<string>(),
module, _generateSetNextInstructionCode);
c.StopCompilationBeforeGeneratingCode = stopBeforeGeneratingCode;
c.StopAtFirstError = false;
try
{
c.Compile();
}
catch (AggregateException ex)
{
CompilationErrors = ex.Flatten().InnerExceptions.Select(e => e.Message.Replace(": ", "\n// ").Replace("; ", "\n// & ")).ToList();
}
if (c.MapFile != null)
{
c.MapFile.Optimize();
MapFile = new MapFileLookup(c.MapFile);
}
_compiler = c;
_previousAssembly = assembly;
_isFullyCompiled = !stopBeforeGeneratingCode;
}
void Run (Config config)
{
if (config.ShowHelp) {
Console.WriteLine ("Netjs compiler, Copyright 2014 Frank A. Krueger");
Console.WriteLine ("netjs [options] assembly-file");
Console.WriteLine (" -help Lists all compiler options (short: -?)");
return;
}
if (string.IsNullOrEmpty (config.MainAssembly)) {
throw new Exception ("No assembly specified.");
}
var asmPath = Path.GetFullPath (config.MainAssembly);
asmDir = Path.GetDirectoryName (asmPath);
var outPath = Path.ChangeExtension (asmPath, ".ts");
Step ("Reading IL");
var parameters = new ReaderParameters {
AssemblyResolver = this,
};
var asm = AssemblyDefinition.ReadAssembly (asmPath, parameters);
mscorlib = AssemblyDefinition.ReadAssembly (typeof(String).Assembly.Location, parameters);
system = AssemblyDefinition.ReadAssembly (typeof(INotifyPropertyChanged).Assembly.Location, parameters);
systemCore = AssemblyDefinition.ReadAssembly (typeof(Enumerable).Assembly.Location, parameters);
systemDrawing = AssemblyDefinition.ReadAssembly (typeof(System.Drawing.Bitmap).Assembly.Location, parameters);
Step ("Decompiling IL to C#");
var context = new DecompilerContext (asm.MainModule);
context.Settings.ForEachStatement = false;
context.Settings.ObjectOrCollectionInitializers = false;
context.Settings.UsingStatement = false;
context.Settings.AsyncAwait = false;
context.Settings.AutomaticProperties = true;
context.Settings.AutomaticEvents = true;
context.Settings.QueryExpressions = false;
context.Settings.AlwaysGenerateExceptionVariableForCatchBlocks = true;
context.Settings.UsingDeclarations = false;
context.Settings.FullyQualifyAmbiguousTypeNames = true;
context.Settings.YieldReturn = false;
var builder = new AstBuilder (context);
builder.AddAssembly (asm);
foreach (var a in referencedAssemblies.Values) {
if (a != null)
builder.AddAssembly (a);
}
builder.RunTransformations ();
Step ("Translating C# to TypeScript");
new CsToTs ().Run (builder.SyntaxTree);
Step ("Writing");
using (var outputWriter = new StreamWriter (outPath)) {
var output = new PlainTextOutput (outputWriter);
builder.GenerateCode (output, (s, e) => new TsOutputVisitor (s, e));
}
Step ("Done");
}
public void ProcessAssemblyFromStream(Stream inputStream, ReaderParameters readerParams, Stream outputStream, WriterParameters writerParams)
{
var assemblyDef = AssemblyDefinition.ReadAssembly(inputStream, readerParams);
Process(assemblyDef);
if (outputStream != null) {
assemblyDef.Write(outputStream, writerParams);
}
}
/// <summary>
/// Load an assembly for compiler from the given path and record it in the references.
/// </summary>
public AssemblyDefinition Load(string path, ReaderParameters parameter)
{
var fullPath = ResolvePath(path);
if (fullPath == null)
throw new FileNotFoundException(path);
return Load(null, fullPath, parameter);
}
void readFile()
{
var assemblyResolver = AssemblyResolver.Instance;
var readerParameters = new ReaderParameters(ReadingMode.Deferred);
readerParameters.AssemblyResolver = assemblyResolver;
module = ModuleDefinition.ReadModule(filename, readerParameters, dumpedMethods);
assemblyResolver.addModule(module);
}
public string ResolveProjectFilePath(Assembly assembly)
{
var readerParameters = new ReaderParameters {ReadSymbols = true, ReadingMode = ReadingMode.Deferred};
var definition = AssemblyDefinition.ReadAssembly(assembly.Location, readerParameters);
var methodDefinition = GetMethodWithBody(definition);
var document = GetMethodDocument(methodDefinition);
return document.Url;
}
public AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters)
{
var assembly = ResolveInFolder(localFolder, name, parameters);
if (assembly != null) return assembly;
assembly = ResolveInFolder(frameworkFolder, name, parameters);
if (assembly != null) return assembly;
throw new AssemblyResolutionException(name);
}
public AssemblyDefinition Resolve(string fullName, ReaderParameters parameters)
{
throw new NotImplementedException();
}
public AssemblyDefinition Resolve(string fullName, ReaderParameters parameters)
{
return(null);
}
public static TestResult ExecuteTestRun(
this BaseModuleWeaver weaver,
string assemblyPath,
bool runPeVerify = true,
Action <ModuleDefinition> afterExecuteCallback = null,
Action <ModuleDefinition> beforeExecuteCallback = null,
string assemblyName = null,
IEnumerable <string> ignoreCodes = null)
{
assemblyPath = Path.Combine(CodeBaseLocation.CurrentDirectory, assemblyPath);
var fodyTempDir = Path.Combine(Path.GetDirectoryName(assemblyPath), "fodytemp");
Directory.CreateDirectory(fodyTempDir);
IoHelper.PurgeDirectory(fodyTempDir);
string targetFileName;
if (assemblyName == null)
{
assemblyName = Path.GetFileNameWithoutExtension(assemblyPath);
targetFileName = Path.GetFileName(assemblyPath);
}
else
{
targetFileName = assemblyName + ".dll";
}
var targetAssemblyPath = Path.Combine(fodyTempDir, targetFileName);
using (var assemblyResolver = new MockAssemblyResolver())
{
var typeCache = CacheTypes(weaver, assemblyResolver);
var testStatus = new TestResult();
weaver.LogDebug = text => testStatus.AddMessage(text, MessageImportanceDefaults.Debug);
weaver.LogInfo = text => testStatus.AddMessage(text, MessageImportanceDefaults.Info);
weaver.LogMessage = (text, messageImportance) => testStatus.AddMessage(text, messageImportance);
weaver.LogWarning = text => testStatus.AddWarning(text, null);
weaver.LogWarningPoint = (text, sequencePoint) => testStatus.AddWarning(text, sequencePoint);
weaver.LogError = text => testStatus.AddError(text, null);
weaver.LogErrorPoint = (text, sequencePoint) => testStatus.AddError(text, sequencePoint);
weaver.AssemblyFilePath = assemblyPath;
weaver.FindType = typeCache.FindType;
weaver.TryFindType = typeCache.TryFindType;
weaver.ResolveAssembly = assemblyResolver.Resolve;
var readerParameters = new ReaderParameters
{
AssemblyResolver = assemblyResolver,
SymbolReaderProvider = new SymbolReaderProvider(),
ReadWrite = false,
ReadSymbols = true,
};
using (var module = ModuleDefinition.ReadModule(assemblyPath, readerParameters))
{
module.Assembly.Name.Name = assemblyName;
weaver.ModuleDefinition = module;
weaver.TypeSystem = new TypeSystem(typeCache.FindType, module);
beforeExecuteCallback?.Invoke(module);
weaver.Execute();
ReferenceCleaner.CleanReferences(module, weaver, weaver.LogDebug);
afterExecuteCallback?.Invoke(module);
var writerParameters = new WriterParameters
{
WriteSymbols = true
};
module.Write(targetAssemblyPath, writerParameters);
}
if (runPeVerify)
{
List <string> ignoreList;
if (ignoreCodes == null)
{
ignoreList = new List <string>();
}
else
{
ignoreList = ignoreCodes.ToList();
}
ignoreList.Add("0x80070002");
PeVerifier.ThrowIfDifferent(assemblyPath, targetAssemblyPath, ignoreList, Path.GetDirectoryName(assemblyPath));
}
testStatus.Assembly = Assembly.Load(File.ReadAllBytes(targetAssemblyPath));
testStatus.AssemblyPath = targetAssemblyPath;
return(testStatus);
}
}
protected override AssemblyDefinition SearchDirectory(AssemblyNameReference name, IEnumerable <string> directories, ReaderParameters parameters)
{
if (_dependencyContext != null)
{
var library = _dependencyContext.RuntimeLibraries.FirstOrDefault(c =>
{
return(c.Name == name.Name);
});
if (library != null)
{
foreach (var runtimeAssemblyGroup in library.RuntimeAssemblyGroups)
{
foreach (var runtimeAssemblyPath in runtimeAssemblyGroup.AssetPaths)
{
foreach (var directory in directories)
{
var file = directory;
if (!string.IsNullOrEmpty(library.Path))
{
file = Path.Combine(file, Path.Combine(library.Path.Split("/")));
}
file = Path.Combine(file, Path.Combine(runtimeAssemblyPath.Split("/")));
Console.WriteLine($"Try to load file {file}");
if (File.Exists(file))
{
try
{
return(GetAssembly(file, parameters));
}
catch (BadImageFormatException)
{
Console.WriteLine($"BadImageFormatException!");
continue;
}
}
}
}
}
}
else
{
Console.WriteLine($"DependencyContext.RuntimeLibraries. No information about assebmly {name.Name}!");
}
}
else
{
Console.WriteLine("Dependency context is null!");
}
Console.WriteLine("base SearchDirectory");
return(base.SearchDirectory(name, directories, parameters));
}
public ModuleWeaverTestHelper(
string inputAssembly,
string inputAssemblyDirectory = null,
bool modifyOriginalBinaries = false)
{
if (inputAssemblyDirectory == null)
{
inputAssemblyDirectory = @"..\..\..\" + Path.GetFileNameWithoutExtension(inputAssembly) + @"\bin\";
}
#if (DEBUG)
_beforeAssemblyPath = Path.GetFullPath(Path.Combine(inputAssemblyDirectory, "Debug", inputAssembly));
#else
_beforeAssemblyPath = Path.GetFullPath(Path.Combine(inputAssemblyDirectory, "Release", inputAssembly));
#endif
_afterAssemblyPath = _beforeAssemblyPath.Replace(".dll", "2.dll");
string oldPdb = _beforeAssemblyPath.Replace(".dll", ".pdb");
string newPdb = null;
if (modifyOriginalBinaries)
{
newPdb = oldPdb;
_afterAssemblyPath = _beforeAssemblyPath;
}
else
{
newPdb = oldPdb.Replace(".pdb", "2.pdb");
File.Copy(oldPdb, newPdb, true);
File.Copy(_beforeAssemblyPath, _afterAssemblyPath, true);
}
Errors = new List <string>();
InfoMessages = new List <string>();
var assemblyResolver = new MockAssemblyResolver
{
Directory = Path.GetDirectoryName(_afterAssemblyPath)
};
using (var symbolStream = File.OpenRead(newPdb))
{
var readerParameters = new ReaderParameters
{
ReadSymbols = true,
SymbolStream = symbolStream,
SymbolReaderProvider = new PdbReaderProvider()
};
var moduleDefinition = ModuleDefinition.ReadModule(_afterAssemblyPath, readerParameters);
dynamic weavingTask = new TModuleWeaver();
Action <string> errorAction = s =>
Errors.Add(s);
Action <string> infoAction = s =>
InfoMessages.Add(s);
weavingTask.ModuleDefinition = moduleDefinition;
weavingTask.AssemblyResolver = assemblyResolver;
weavingTask.LogError = errorAction;
weavingTask.LogInfo = infoAction;
weavingTask.Execute();
moduleDefinition.Write(_afterAssemblyPath);
ModuleDefinition = moduleDefinition;
}
}
public static void MethodInstrument(string targetAssembly, string src, string dst)
{
var inputAssembly = targetAssembly;
var path = Path.GetDirectoryName(inputAssembly);
var assemblyResolver = new DefaultAssemblyResolver();
var assemblyLocation = Path.GetDirectoryName(inputAssembly);
assemblyResolver.AddSearchDirectory(assemblyLocation);
var readerParameters = new ReaderParameters {
AssemblyResolver = assemblyResolver
};
var writerParameters = new WriterParameters();
var origPdb = Path.ChangeExtension(inputAssembly, "pdb");
bool existpdb = false;
if (File.Exists(origPdb))
{
existpdb = true;
var symbolReaderProvider = new PdbReaderProvider();
readerParameters.SymbolReaderProvider = symbolReaderProvider;
readerParameters.ReadSymbols = true;
//var symbolWriterProvider = new PdbWriterProvider();
//writerParameters.SymbolWriterProvider = symbolWriterProvider;
writerParameters.WriteSymbols = true;
}
else
{
Logger.Debug(".pdb file is unavailable.");
}
var assemblyDefinition = AssemblyDefinition.ReadAssembly(inputAssembly, readerParameters);
var module = assemblyDefinition.MainModule;
//Mono.Collections.Generic.Collection<ModuleDefinition> modules = assemblyDefinition.Modules;
//var module2 = ModuleDefinition.ReadModule(inputAssembly, readerParameters);
//----------------------
bool isChanged = false;
//----------------------------
foreach (var typeDefinition in module.Types)
{
if (typeDefinition.IsInterface)
{
continue;
}
foreach (var methodDefinition in typeDefinition.Methods)
{
ILProcessor ilprocessor = methodDefinition.Body.GetILProcessor();
Mono.Collections.Generic.Collection <Mono.Cecil.Cil.Instruction> allinstructions = methodDefinition.Body.Instructions;
int instructioncnt = allinstructions.Count;
for (int i = 0; i < instructioncnt; i++)
{
Mono.Cecil.Cil.Instruction instruction = allinstructions[i];
string instructpresent = instruction.ToString();
OpCode code = instruction.OpCode;
string codepresent = code.Name;
var operand = instruction.Operand;
string methodname = "";
if (operand != null)
{
methodname = operand.ToString(); //with parameter
}
if ((code == OpCodes.Callvirt || code == OpCodes.Call) && //codepresent.Contains("call")
(isSameMethod(methodname, src))) //or (operand as MethodReference == module.Import(src as MethodInfo))
{
Logger.Debug(codepresent + " " + methodname); //debug
//---------------------- remove --------------------------//
/**** remove instruction in case of no replacing method is provided ****/
//TODO: 1. I note the stack depth after the call and start removing instructions, beginning with the Code.Call
// and moving backward until I get to that stack depth again.
// 2. return value handling
ilprocessor.Remove(instruction);
instructioncnt--;
if (allinstructions[i].OpCode == OpCodes.Pop) //TODO: just for test
{
ilprocessor.Remove(allinstructions[i]);
instructioncnt--;
}
i--;
if (dst == "")
{
continue;
}
//---------------------- replace (remove + insert) ------------------------//
/**** create new MethodInfo ****/
string m_type = getNamespace(dst);
string m_name = getMethodName(dst);
string [] m_para = getParameters(dst);
MethodInfo writeLineMethod;
//e.g. MethodInfo writeLineMethod = typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) });
if (m_para != null)
{
int paraCnt = m_para.Length;
Type[] m_para_type = new Type[paraCnt];
for (int k = 0; k < paraCnt; k++)
{
m_para_type[k] = Type.GetType(m_para[k]);
}
writeLineMethod = Type.GetType(m_type).GetMethod(m_name, m_para_type);
}
else //the method does not have input parameters
{
writeLineMethod = Type.GetType(m_type).GetMethod(m_name, new Type[] { });
}
if (writeLineMethod == null)
{
throw new InvalidFileFormatException("no MethodInfo is created -- possibly a wrong method delaration.");
}
/*** Import the new (e.g. Console.WriteLine() method) ***/
MethodReference writeLine;
writeLine = module.Import(writeLineMethod); //convert "MethodInfo/MethodDefinition" to "MethodReference"
/*** Creates the CIL instruction for calling the new method (e.g. Console.WriteLine(string value) method) ***/
Mono.Cecil.Cil.Instruction callWriteLine;
callWriteLine = ilprocessor.Create(OpCodes.Call, writeLine);
/*** replace old instruction ***/
//TODO: 1. for simple-type parameters, create one instance and push to stack;
// otherwise just a null object?!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// 2. return value handling
ilprocessor.InsertAfter(allinstructions[i], callWriteLine);
//----------------------------------------------//
isChanged = true;
}
} //foreach instruction of a method
} //foreach method of a type/class
} //foreach type/class of loaded assembly
if (isChanged)
{
var temporaryFileName = Path.Combine(path, string.Format("{0}_temp{1}", Path.GetFileNameWithoutExtension(inputAssembly),
Path.GetExtension(inputAssembly)));
var backupFileName = Path.Combine(path, string.Format("{0}_orig{1}", Path.GetFileNameWithoutExtension(inputAssembly),
Path.GetExtension(inputAssembly)));
var tmpPdb = Path.Combine(path, string.Format("{0}_temp{1}", Path.GetFileNameWithoutExtension(inputAssembly), ".pdb"));
var backupPdb = Path.Combine(path, string.Format("{0}_orig{1}", Path.GetFileNameWithoutExtension(inputAssembly), ".pdb"));
//write an assembly with symbol file being rewritten
//module.Write(temporaryFileName, writerParameters);
assemblyDefinition.Write(temporaryFileName, writerParameters);
File.Replace(temporaryFileName, inputAssembly, backupFileName);
if (existpdb)
{
File.Replace(tmpPdb, origPdb, backupPdb);
}
//TODO: add snkfile in configuration file and parse ([email protected])
// If you have access to the key pair, you can ask Cecil to sign it directly.
//if (snkFile != "")
//{
//sn -R inputAssembly snkFile
//}
}
}
public DirectoryAssemblyResolver(Action <string, object[]> logWarnings, bool loadDebugSymbols, ReaderParameters loadReaderParameters = null)
{
if (logWarnings == null)
{
throw new ArgumentNullException(nameof(logWarnings));
}
cache = new Dictionary <string, AssemblyDefinition> ();
this.loadDebugSymbols = loadDebugSymbols;
this.logWarnings = logWarnings;
SearchDirectories = new List <string> ();
this.loadReaderParameters = loadReaderParameters ?? DefaultLoadReaderParameters;
}
static void Main(string[] args)
{
string input = null;
string output = null;
string keyPairContainer = null;
var options = new Mono.Options.OptionSet()
{
{ "i|input=", i => input = i },
{ "o|output:", o => output = o },
{ "k|key:", k => keyPairContainer = k },
};
try
{
var extra = options.Parse(args);
var pdb = Path.ChangeExtension(input, "pdb");
var mdb = Path.ChangeExtension(input, "mdb");
ISymbolReaderProvider provider = null;
if (File.Exists(pdb))
{
provider = new Mono.Cecil.Pdb.PdbReaderProvider();
}
else if (File.Exists(mdb))
{
provider = new Mono.Cecil.Mdb.MdbReaderProvider();
}
var assemblyResolver = new DefaultAssemblyResolver();
assemblyResolver.AddSearchDirectory(System.IO.Path.GetDirectoryName(input));
var readParameters = new ReaderParameters()
{
AssemblyResolver = assemblyResolver,
ReadingMode = ReadingMode.Immediate,
ReadSymbols = true,
SymbolReaderProvider = provider,
};
var writeParameters = new WriterParameters()
{
WriteSymbols = true,
};
if (keyPairContainer != null)
{
writeParameters.StrongNameKeyPair = new System.Reflection.StrongNameKeyPair(keyPairContainer);
}
if (output == null)
{
output = input;
}
Console.WriteLine("CilTK Rewriter");
Console.WriteLine("Reading assembly from {0}", input);
Console.WriteLine("Writing assembly to {0}", output);
InputAssembly = input;
var assembly = Mono.Cecil.AssemblyDefinition.ReadAssembly(input, readParameters);
var labelReplace = new LabelReplacer();
labelReplace.Visit(assembly);
var infoReplace = new InfoReplacer();
infoReplace.Visit(assembly);
var cilReplacer = new CilReplacer(labelReplace);
cilReplacer.Visit(assembly);
//remove references to Silk
foreach (var module in assembly.Modules)
{
int index = -1;
for (int i = 0; i < module.AssemblyReferences.Count; ++i)
{
if (module.AssemblyReferences[i].Name == "Silk")
{
index = i;
break;
}
}
if (index != -1)
{
module.AssemblyReferences.RemoveAt(index);
}
}
//write to a temp file then copy to output to assist with debugging
var temp = System.IO.Path.GetTempFileName();
assembly.Write(temp, writeParameters);
System.IO.File.Copy(temp, output, true);
}
catch (Mono.Options.OptionException)
{
options.WriteOptionDescriptions(Console.Out);
System.Environment.Exit(1);
}
}
public override AssemblyDefinition Resolve(string fullName, ReaderParameters parameters, TargetArchitecture platform, bool bubbleToUserIfFailed = true)
{
return(base.Resolve(fullName, parameters, platform, bubbleToUserIfFailed: false));
}
/// <summary>Resolve an assembly reference.</summary> /// <param name="name">The assembly name.</param> /// <param name="parameters">The assembly reader parameters.</param> public override AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters) => this.ResolveName(name.Name) ?? base.Resolve(name, parameters);
public override bool Execute(out IList <Exception> thrownExceptions)
{
thrownExceptions = null;
LoggingHelper.LogMessage(Normal, $"{new string(' ', 0)}Compiling Xaml, assembly: {Assembly}");
var skipassembly = !DefaultCompile;
bool success = true;
if (!File.Exists(Assembly))
{
LoggingHelper.LogMessage(Normal, $"{new string(' ', 2)}Assembly file not found. Skipping XamlC.");
return(true);
}
using (var fallbackResolver = DefaultAssemblyResolver == null ? new XamlCAssemblyResolver() : null)
{
var resolver = DefaultAssemblyResolver ?? fallbackResolver;
if (resolver is XamlCAssemblyResolver xamlCResolver)
{
if (ReferencePath != null)
{
var paths = ReferencePath.Select(p => IOPath.GetDirectoryName(p.Replace("//", "/"))).Distinct();
foreach (var searchpath in paths)
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 2)}Adding searchpath {searchpath}");
xamlCResolver.AddSearchDirectory(searchpath);
}
}
}
else
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 2)}Ignoring dependency and reference paths due to an unsupported resolver");
}
var debug = DebugSymbols || (!string.IsNullOrEmpty(DebugType) && DebugType.ToLowerInvariant() != "none");
var readerParameters = new ReaderParameters
{
AssemblyResolver = resolver,
ReadWrite = !ValidateOnly,
ReadSymbols = debug && !ValidateOnly, // We don't need symbols for ValidateOnly, since we won't be writing
};
using (var assemblyDefinition = AssemblyDefinition.ReadAssembly(IOPath.GetFullPath(Assembly), readerParameters))
{
CustomAttribute xamlcAttr;
if (assemblyDefinition.HasCustomAttributes &&
(xamlcAttr =
assemblyDefinition.CustomAttributes.FirstOrDefault(
ca => ca.AttributeType.FullName == "Microsoft.Maui.Controls.Xaml.XamlCompilationAttribute")) != null)
{
var options = (XamlCompilationOptions)xamlcAttr.ConstructorArguments[0].Value;
if ((options & XamlCompilationOptions.Skip) == XamlCompilationOptions.Skip)
{
skipassembly = true;
}
if ((options & XamlCompilationOptions.Compile) == XamlCompilationOptions.Compile)
{
skipassembly = false;
}
}
foreach (var module in assemblyDefinition.Modules)
{
var skipmodule = skipassembly;
if (module.HasCustomAttributes &&
(xamlcAttr =
module.CustomAttributes.FirstOrDefault(
ca => ca.AttributeType.FullName == "Microsoft.Maui.Controls.Xaml.XamlCompilationAttribute")) != null)
{
var options = (XamlCompilationOptions)xamlcAttr.ConstructorArguments[0].Value;
if ((options & XamlCompilationOptions.Skip) == XamlCompilationOptions.Skip)
{
skipmodule = true;
}
if ((options & XamlCompilationOptions.Compile) == XamlCompilationOptions.Compile)
{
skipmodule = false;
}
}
LoggingHelper.LogMessage(Low, $"{new string(' ', 2)}Module: {module.Name}");
var resourcesToPrune = new List <EmbeddedResource>();
foreach (var resource in module.Resources.OfType <EmbeddedResource>())
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 4)}Resource: {resource.Name}");
string classname;
if (!resource.IsXaml(module, out classname))
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}skipped.");
continue;
}
TypeDefinition typeDef = module.GetType(classname);
if (typeDef == null)
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}no type found... skipped.");
continue;
}
var skiptype = skipmodule;
if (typeDef.HasCustomAttributes &&
(xamlcAttr =
typeDef.CustomAttributes.FirstOrDefault(
ca => ca.AttributeType.FullName == "Microsoft.Maui.Controls.Xaml.XamlCompilationAttribute")) != null)
{
var options = (XamlCompilationOptions)xamlcAttr.ConstructorArguments[0].Value;
if ((options & XamlCompilationOptions.Skip) == XamlCompilationOptions.Skip)
{
skiptype = true;
}
if ((options & XamlCompilationOptions.Compile) == XamlCompilationOptions.Compile)
{
skiptype = false;
}
}
if (Type != null)
{
skiptype = !(Type == classname);
}
if (skiptype && !ForceCompile)
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}has XamlCompilationAttribute set to Skip and not Compile... skipped.");
continue;
}
var initComp = typeDef.Methods.FirstOrDefault(md => md.Name == "InitializeComponent");
if (initComp == null)
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}no InitializeComponent found... skipped.");
continue;
}
CustomAttribute xamlFilePathAttr;
var xamlFilePath = typeDef.HasCustomAttributes && (xamlFilePathAttr = typeDef.CustomAttributes.FirstOrDefault(ca => ca.AttributeType.FullName == "Microsoft.Maui.Controls.Xaml.XamlFilePathAttribute")) != null ?
(string)xamlFilePathAttr.ConstructorArguments[0].Value :
resource.Name;
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}Parsing Xaml");
var rootnode = ParseXaml(resource.GetResourceStream(), typeDef);
if (rootnode == null)
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 8)}failed.");
continue;
}
LoggingHelper.LogMessage(Low, $"{new string(' ', 8)}done.");
hasCompiledXamlResources = true;
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}Replacing {0}.InitializeComponent ()");
Exception e;
if (!TryCoreCompile(initComp, rootnode, xamlFilePath, out e))
{
success = false;
LoggingHelper.LogMessage(Low, $"{new string(' ', 8)}failed.");
(thrownExceptions = thrownExceptions ?? new List <Exception>()).Add(e);
if (e is BuildException be)
{
LoggingHelper.LogError("XamlC", be.Code.Code, be.HelpLink, xamlFilePath, be.XmlInfo?.LineNumber ?? 0, be.XmlInfo?.LinePosition ?? 0, 0, 0, ErrorMessages.ResourceManager.GetString(be.Code.ErrorMessageKey), be.MessageArgs);
}
else if (e is XamlParseException xpe) //shouldn't happen anymore
{
LoggingHelper.LogError("XamlC", null, xpe.HelpLink, xamlFilePath, xpe.XmlInfo.LineNumber, xpe.XmlInfo.LinePosition, 0, 0, xpe.Message);
}
else if (e is XmlException xe)
{
LoggingHelper.LogError("XamlC", null, xe.HelpLink, xamlFilePath, xe.LineNumber, xe.LinePosition, 0, 0, xe.Message);
}
else
{
LoggingHelper.LogError("XamlC", null, e.HelpLink, xamlFilePath, 0, 0, 0, 0, e.Message);
}
LoggingHelper.LogMessage(Low, e.StackTrace);
continue;
}
if (Type != null)
{
InitCompForType = initComp;
}
LoggingHelper.LogMessage(Low, $"{new string(' ', 8)}done.");
if (ValidateOnly)
{
continue;
}
if (OptimizeIL)
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}Optimizing IL");
initComp.Body.Optimize();
LoggingHelper.LogMessage(Low, $"{new string(' ', 8)}done.");
}
resourcesToPrune.Add(resource);
}
if (hasCompiledXamlResources)
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 4)}Changing the module MVID");
module.Mvid = Guid.NewGuid();
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}done.");
}
if (!KeepXamlResources)
{
if (resourcesToPrune.Any())
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 4)}Removing compiled xaml resources");
}
foreach (var resource in resourcesToPrune)
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}Removing {resource.Name}");
module.Resources.Remove(resource);
LoggingHelper.LogMessage(Low, $"{new string(' ', 8)}done.");
}
}
}
if (ValidateOnly)
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 0)}ValidateOnly=True. Skipping writing assembly.");
return(success);
}
if (!hasCompiledXamlResources)
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 0)}No compiled resources. Skipping writing assembly.");
return(success);
}
LoggingHelper.LogMessage(Low, $"{new string(' ', 0)}Writing the assembly");
try
{
assemblyDefinition.Write(new WriterParameters
{
WriteSymbols = debug,
});
LoggingHelper.LogMessage(Low, $"{new string(' ', 2)}done.");
}
catch (Exception e)
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 2)}failed.");
LoggingHelper.LogErrorFromException(e);
(thrownExceptions = thrownExceptions ?? new List <Exception>()).Add(e);
LoggingHelper.LogMessage(Low, e.StackTrace);
success = false;
}
}
}
return(success);
}
public void RunRegistrar()
{
// The static registrar.
if (Registrar != RegistrarMode.Static)
{
throw new ProductException(67, Errors.MT0067, Registrar); // this is only called during our own build
}
if (RootAssemblies.Count < 1)
{
throw ErrorHelper.CreateError(130, Errors.MX0130);
}
var registrar_m = RegistrarOutputLibrary;
var RootAssembly = RootAssemblies [0];
var resolvedAssemblies = new Dictionary <string, AssemblyDefinition> ();
var resolver = new PlatformResolver()
{
RootDirectory = Path.GetDirectoryName(RootAssembly),
#if MMP
CommandLineAssemblies = RootAssemblies,
#endif
};
if (Platform == ApplePlatform.iOS)
{
if (Is32Build)
{
resolver.ArchDirectory = Driver.GetArch32Directory(this);
}
else
{
resolver.ArchDirectory = Driver.GetArch64Directory(this);
}
}
var ps = new ReaderParameters();
ps.AssemblyResolver = resolver;
foreach (var reference in References)
{
var r = resolver.Load(reference);
if (r == null)
{
throw ErrorHelper.CreateError(2002, Errors.MT2002, reference);
}
}
var productAssembly = Driver.GetProductAssembly(this);
bool foundProductAssembly = false;
foreach (var asm in RootAssemblies)
{
var rootName = Path.GetFileNameWithoutExtension(asm);
if (rootName == productAssembly)
{
foundProductAssembly = true;
}
try {
AssemblyDefinition lastAssembly = ps.AssemblyResolver.Resolve(AssemblyNameReference.Parse(rootName), new ReaderParameters());
if (lastAssembly == null)
{
ErrorHelper.CreateWarning(7, Errors.MX0007, rootName);
continue;
}
if (resolvedAssemblies.TryGetValue(rootName, out var previousAssembly))
{
if (lastAssembly.MainModule.RuntimeVersion != previousAssembly.MainModule.RuntimeVersion)
{
Driver.Log(2, "Attemping to load an assembly another time {0} (previous {1})", lastAssembly.FullName, previousAssembly.FullName);
}
continue;
}
resolvedAssemblies.Add(rootName, lastAssembly);
Driver.Log(3, "Loaded {0}", lastAssembly.MainModule.FileName);
} catch (Exception ex) {
ErrorHelper.Warning(9, ex, Errors.MX0009, $"{rootName}: {ex.Message}");
continue;
}
}
if (!foundProductAssembly)
{
throw ErrorHelper.CreateError(131, Errors.MX0131, productAssembly, string.Join("', '", RootAssemblies.ToArray()));
}
#if MONOTOUCH
if (SelectAbis(Abis, Abi.SimulatorArchMask).Count > 0)
{
BuildTarget = BuildTarget.Simulator;
}
else if (SelectAbis(Abis, Abi.DeviceArchMask).Count > 0)
{
BuildTarget = BuildTarget.Device;
}
else
{
throw ErrorHelper.CreateError(99, Errors.MX0099, "No valid ABI");
}
#endif
var registrar = new Registrar.StaticRegistrar(this);
if (RootAssemblies.Count == 1)
{
registrar.GenerateSingleAssembly(resolvedAssemblies.Values, Path.ChangeExtension(registrar_m, "h"), registrar_m, Path.GetFileNameWithoutExtension(RootAssembly));
}
else
{
registrar.Generate(resolvedAssemblies.Values, Path.ChangeExtension(registrar_m, "h"), registrar_m);
}
}
void Rewrite(string file, string keyfile, IEnumerable <string> options)
{
// Specify assembly read and write parameters
// We want to keep a valid symbols file (pdb or mdb)
var read_params = new ReaderParameters();
var write_params = new WriterParameters();
var pdb = Path.ChangeExtension(file, "pdb");
var mdb = Path.ChangeExtension(file, "mdb");
ISymbolReaderProvider provider = null;
if (File.Exists(pdb))
{
provider = new Mono.Cecil.Pdb.PdbReaderProvider();
}
else if (File.Exists(mdb))
{
provider = new Mono.Cecil.Mdb.MdbReaderProvider();
}
read_params.SymbolReaderProvider = provider;
read_params.ReadSymbols = true;
write_params.WriteSymbols = true;
if (!String.IsNullOrEmpty(keyfile) && File.Exists(keyfile))
{
keyfile = Path.GetFullPath(keyfile);
var fs = new FileStream(keyfile, FileMode.Open);
var keypair = new System.Reflection.StrongNameKeyPair(fs);
fs.Close();
write_params.StrongNameKeyPair = keypair;
}
else
{
Console.Error.WriteLine("No keyfile specified or keyfile missing.");
}
// Load assembly and process all modules
var assembly = AssemblyDefinition.ReadAssembly(file, read_params);
var rewritten = assembly.CustomAttributes.FirstOrDefault(a => a.AttributeType.Name == "RewrittenAttribute");
if (rewritten == null)
{
foreach (var module in assembly.Modules)
{
foreach (var reference in module.AssemblyReferences)
{
var resolved = module.AssemblyResolver.Resolve(reference);
if (reference.Name == "mscorlib")
{
mscorlib = resolved;
}
}
}
if (mscorlib == null)
{
Console.Error.WriteLine("Failed to locate mscorlib");
return;
}
TypeMarshal = mscorlib.MainModule.GetType("System.Runtime.InteropServices.Marshal");
TypeStringArray = mscorlib.MainModule.GetType("System.String").MakeArrayType().Resolve();
TypeStringBuilder = mscorlib.MainModule.GetType("System.Text.StringBuilder");
TypeVoid = mscorlib.MainModule.GetType("System.Void");
TypeIntPtr = mscorlib.MainModule.GetType("System.IntPtr");
TypeInt32 = mscorlib.MainModule.GetType("System.Int32");
TypeBindingsBase = assembly.Modules.Select(m => m.GetType("OpenTK.BindingsBase")).First();
foreach (var module in assembly.Modules)
{
foreach (var type in module.Types)
{
Rewrite(type, options);
}
}
}
else
{
Console.Error.WriteLine("Error: assembly has already been rewritten");
}
// Save rewritten assembly
assembly.Write(file, write_params);
}
public AssemblyDefinition Resolve(string fullName, ReaderParameters parameters)
{
return(AssemblyDefinition.ReadAssembly(Find(fullName)));
}
private static void GenerateInterop(String filePath, String keyFilePath)
{
Console.WriteLine("Generating Interop...");
String pdbFile = Path.Combine(Path.GetDirectoryName(filePath), Path.GetFileNameWithoutExtension(filePath) + ".pdb");
ReaderParameters readerParams = new ReaderParameters();
WriterParameters writerParams = new WriterParameters();
if (keyFilePath != null)
{
writerParams.StrongNameKeyPair = new StrongNameKeyPair(File.Open(keyFilePath, FileMode.Open));
}
if (File.Exists(pdbFile))
{
readerParams.SymbolReaderProvider = new PdbReaderProvider();
readerParams.ReadSymbols = true;
writerParams.WriteSymbols = true;
}
AssemblyDefinition assemblyDef = AssemblyDefinition.ReadAssembly(filePath, readerParams);
((BaseAssemblyResolver)assemblyDef.MainModule.AssemblyResolver).AddSearchDirectory(Path.GetDirectoryName(filePath));
AssemblyDefinition mscorLib = null;
foreach (AssemblyNameReference assemblyNameReference in assemblyDef.MainModule.AssemblyReferences)
{
if (assemblyNameReference.Name.ToLower() == "mscorlib")
{
mscorLib = assemblyDef.MainModule.AssemblyResolver.Resolve(assemblyNameReference);
break;
}
else if (assemblyNameReference.Name == "System.Runtime")
{
((BaseAssemblyResolver)assemblyDef.MainModule.AssemblyResolver).AddSearchDirectory(Path.Combine(GetProgramFilesFolder(), @"Reference Assemblies\Microsoft\Framework\.NETCore\v4.5"));
mscorLib = assemblyDef.MainModule.AssemblyResolver.Resolve(assemblyNameReference);
break;
}
}
if (mscorLib == null)
{
throw new InvalidOperationException("Missing mscorlib.dll");
}
m_mscorLib = mscorLib;
for (int i = 0; i < assemblyDef.CustomAttributes.Count; i++)
{
CustomAttribute attr = assemblyDef.CustomAttributes[i];
if (attr.AttributeType.FullName == typeof(System.Runtime.CompilerServices.CompilationRelaxationsAttribute).FullName)
{
assemblyDef.CustomAttributes.RemoveAt(i);
i--;
}
}
foreach (TypeDefinition typeDef in assemblyDef.MainModule.Types)
{
PatchType(typeDef);
}
RemoveInteropClass(assemblyDef);
string tempFile = Path.GetTempFileName();
assemblyDef.Write(tempFile, writerParams);
assemblyDef.Dispose();
File.Delete(filePath);
File.Copy(tempFile, filePath);
Console.WriteLine("Interop Generation complete.");
}
static void Main(string[] args)
{
var cli = new CommandLineApplication();
cli.ResponseFileHandling = ResponseFileHandling.ParseArgsAsLineSeparated;
cli.HelpOption();
var paths = cli.Argument("paths", "The input dlls or directories of dlls to instrument", true).IsRequired();
var outputOption = cli.Option("-o|--output <DIR>", "The directory where output files will be written", CommandOptionType.SingleValue);
var refPathsOption = cli.Option("-r|--reference <DIR>", "Directory to search for references", CommandOptionType.MultipleValue);
var exRegexOption = cli.Option("-x|--exclude <REGEX>", "A regular expression used to exclude methods for instrumentation.", CommandOptionType.MultipleValue);
var incRegexOption = cli.Option("-i|--include <REGEX>", "A regular expression used to include methods for instrumentation.", CommandOptionType.MultipleValue);
cli.OnExecute(() =>
{
var processors = new List <InstrumentationProcessor>();
var directories = new HashSet <string>();
foreach (var path in paths.Values)
{
if (File.Exists(path))
{
if (path.EndsWith(".dll"))
{
processors.Add(new FileProcessor(path));
string dir = Path.GetDirectoryName(Path.GetFullPath(path));
directories.Add(dir);
}
else if (path.EndsWith(".zip"))
{
processors.Add(new ZipProcessor(path));
}
}
else if (Directory.Exists(path))
{
processors.Add(new DirectoryProcessor(path));
directories.Add(path);
}
}
if (processors.Count == 0)
{
Console.WriteLine("No assemblies found");
return;
}
string toolsAsmPath = LocateToolsAssembly();
var globalResolver = new DefaultAssemblyResolver();
foreach (var dir in directories)
{
globalResolver.AddSearchDirectory(dir);
}
foreach (var refPath in refPathsOption.Values)
{
globalResolver.AddSearchDirectory(refPath);
}
#if DEBUG
string resolverPaths = Environment.GetEnvironmentVariable("MTGINSTR_RESOLVERPATH");
if (resolverPaths != null)
{
Console.WriteLine("Adding debugging assembly resolver logic");
foreach (var path in resolverPaths.Split(";"))
{
Console.WriteLine($"Added resolver path: {path}");
globalResolver.AddSearchDirectory(path);
}
}
#endif
var readerParams = new ReaderParameters()
{
AssemblyResolver = globalResolver
};
var toolsAsm = AssemblyDefinition.ReadAssembly(toolsAsmPath, readerParams);
string outputDirectory = Environment.CurrentDirectory;
if (outputOption.HasValue())
{
outputDirectory = outputOption.Value();
Console.WriteLine($"Output directory: {outputDirectory}");
}
var toolsContext = new ToolsAssemblyContext(toolsAsm);
var opts = new InstrumenterOptions();
opts.Excludes.AddRange(exRegexOption.Values);
opts.Includes.AddRange(incRegexOption.Values);
var instrumenter = new AssemblyInstrumenter(toolsContext, opts);
var processingContext = new ProcessingContext()
{
OutputDirectory = outputDirectory,
Instrumenter = instrumenter,
ReaderParams = readerParams
};
int success = 0;
foreach (var processor in processors)
{
try
{
Console.WriteLine($"Processing {processor.DisplayName}");
processor.Process(processingContext);
Console.WriteLine($"Done processing {processor.DisplayName}");
success++;
}
catch (Exception e)
{
Console.WriteLine($"Error processing {processor.DisplayName}");
Console.WriteLine($"Error details: {e}");
}
}
if (success > 0)
{
Console.WriteLine($"Successfully processed {success} items");
}
});
cli.Execute(args);
}
public void InjectAssembly(string dllPath, string delegatePath, bool isWriteName)
{
m_IsWriteName = isWriteName;
var readerParameters = new ReaderParameters {
ReadSymbols = false
};
AssemblyDefinition assembly = AssemblyDefinition.ReadAssembly(dllPath, readerParameters);
m_NameLines.Clear();
foreach (var module in assembly.Modules)
{
List <TypeDefinition> types = module.Types.ToList();
TypeDefinition FunctionDelegate = types.Find((td) => { return(td.FullName.Contains("LCLFunctionDelegate")); });
if (FunctionDelegate != null)
{
m_DelegateFunctions = FunctionDelegate.NestedTypes.ToList().FindAll((_type) =>
{
string name = _type.BaseType.Name;
return(name == typeof(Delegate).Name || name == typeof(MulticastDelegate).Name);
});
if (m_DelegateFunctions != null && m_DelegateFunctions.Count > 0)
{
break;
}
}
}
foreach (var module in assembly.Modules)
{
List <TypeDefinition> types = module.Types.ToList();
m_FieldDelegateNameTD = types.Find((td) => { return(td.FullName.Contains("LCLFieldDelegateName")); });
if (m_FieldDelegateNameTD != null)
{
break;
}
}
foreach (var module in assembly.Modules)
{
foreach (var typ in module.Types)
{
if (typ.Namespace == null || !typ.Namespace.Contains("LCL"))
{
continue;
}
if (isWriteName)
{
if (!Filter.FilterType(typ))
{
continue;
}
}
foreach (var method in typ.Methods)
{
if (isWriteName)
{
if (!Filter.FilterMethod(method))
{
continue;
}
}
InjectMethod(typ, method);
}
}
}
if (!isWriteName)
{
var writerParameters = new WriterParameters {
WriteSymbols = true
};
assembly.Write(dllPath, writerParameters);
if (assembly.MainModule.SymbolReader != null)
{
assembly.MainModule.SymbolReader.Dispose();
}
}
else
{
ILName.WritedFieldDelegateName(delegatePath, m_NameLines);
}
}
public AssemblyDefinition Resolve(string fullName, ReaderParameters parameters)
{
return(Resolve(AssemblyNameReference.Parse(fullName), parameters));
}
public AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters)
{
return(AssemblyDefinition.ReadAssembly(Find(name)));
}
AssemblyDefinition SearchDirectory(AssemblyNameReference name, IEnumerable <string> directories, ReaderParameters parameters)
{
var extensions = new [] { ".dll", ".exe" };
foreach (var directory in directories)
{
foreach (var extension in extensions)
{
string file = Path.Combine(directory, name.Name + extension);
if (!File.Exists(file))
{
continue;
}
try {
return(GetAssembly(file, parameters));
} catch (BadImageFormatException) {
continue;
}
}
}
return(null);
}
public AssemblyDefinition Resolve(string fullName, ReaderParameters parameters)
{
return(ResolveInternal(fullName));
}
public AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters)
{
return(ResolveInternal(name.Name));
}
public static int Main(string[] args)
{
for (; null != args;)
{
try {
var fileName = args?[0];
if (null == fileName)
{
return((int)ExitStatus.UserCanceled);
}
var dirName = Path.GetDirectoryName(fileName) !;
var fileNameShort = Path.GetFileNameWithoutExtension(fileName);
var fileNameExt = Path.GetExtension(fileName);
var fileName_Original = Path.Combine(dirName, fileNameShort + fileNameExt);
var fileName_Modified = Path.Combine(dirName, fileNameShort + @".tmp");
var fileName_Backup = Path.Combine(dirName, fileNameShort + @".bak");
var fullpath = Path.GetFullPath(fileName_Original);
var rm = new ReaderParameters()
{
ThrowIfSymbolsAreNotMatching = true, ReadSymbols = true
};
rm.InMemory = true;
var assembly = AssemblyDefinition.ReadAssembly(fileName_Original, rm);
var module = assembly.MainModule;
// ProcessCoreLibByReference(module);
var modified = 0;
{
var OpCodes_fields = typeof(OpCodes).GetFields(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static);
var asmmap = OpCodes_fields.ToDictionary(x => x.Name.ToUpperInvariant());
asmmap.Add("Ldelem".ToUpperInvariant(), typeof(OpCodes).GetField(nameof(OpCodes.Ldelem_Any), System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static) !);
asmmap.Add("Stelem".ToUpperInvariant(), typeof(OpCodes).GetField(nameof(OpCodes.Stelem_Any), System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static) !);
asmmap.Add("Unaligned_".ToUpperInvariant(), typeof(OpCodes).GetField(nameof(OpCodes.Unaligned), System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static) !);
var int32Converter = new System.ComponentModel.Int32Converter();
var ilAttrName = "ILMethodBodyAttribute";
foreach (var typeref in module.GetTypes())
{
if (typeref is TypeDefinition type)
{
foreach (var method in type.Methods)
{
if (!method.HasCustomAttributes)
{
continue;
}
CustomAttribute?ilAttr = GetCustomAttributeByName(method, ilAttrName);
if (null == ilAttr)
{
continue;
}
Console.Out.Write($@"Assembling {method.FullName}... ");
var ilSource = ilAttr.ConstructorArguments[0].Value as string;
using var ilSourceReader = new StringReader(ilSource !);
var tts = type.GenericParameters;
var ts = method.GenericParameters;
if (!method.HasBody)
{
Console.Out.WriteLine($@"No stub body found. Skipped.");
continue;
}
{
var bd = method.Body;
var ins = bd.Instructions;
var ilg = (ILProcessor?)null;
ilg = bd.GetILProcessor();
ilg.Clear();
/*
* var insa = ins.ToArray();
* for (var i = 0; insa.Length > i; ++i) {
* var inn = insa[i];
* if (null != inn) {
* ilg.Remove(inn);
* }
* }
*/
{
string?ilasmLine;
for (; null != (ilasmLine = ilSourceReader.ReadLine());)
{
var sdfasd = ilasmLine.Split(new[] { ' ', '\t', }, StringSplitOptions.RemoveEmptyEntries);
var sdfas = sdfasd.FirstOrDefault();
if (null == sdfas)
{
continue;
}
var sdfa = sdfas.Replace('.', '_').ToUpperInvariant();
var safsad = asmmap[sdfa];
var sdfsaf = (safsad.GetValue(null) as OpCode?);
if (null == sdfsaf)
{
throw new Exception("gfghgh");
}
var sdfdsa = sdfsaf.Value;
switch (sdfdsa.OperandType)
{
case OperandType.InlineBrTarget:
throw new NotImplementedException();
case OperandType.InlineField:
throw new NotImplementedException();
case OperandType.InlineI:
throw new NotImplementedException();
case OperandType.InlineI8:
ilg.Append(ilg.Create(sdfdsa, int.Parse(sdfasd[1])));
break;
case OperandType.InlineMethod:
throw new NotImplementedException();
case OperandType.InlineNone:
ilg.Append(ilg.Create(sdfdsa));
break;
case OperandType.InlinePhi:
throw new NotImplementedException();
case OperandType.InlineR:
throw new NotImplementedException();
case OperandType.InlineSig:
throw new NotImplementedException();
case OperandType.InlineString:
throw new NotImplementedException();
case OperandType.InlineSwitch:
throw new NotImplementedException();
case OperandType.InlineTok:
throw new NotImplementedException();
case OperandType.InlineType:
if (sdfasd[1].StartsWith("!!"))
{
ilg.Append(ilg.Create(sdfdsa, ts[int.Parse(sdfasd[1][2..])]));
public AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters)
{
return(null);
}
public AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters)
{
var aname = name.Name;
AssemblyDefinition assembly;
if (cache.TryGetValue(aname, out assembly))
{
return(assembly);
}
if (EnableRepl)
{
var replDir = Path.Combine(FrameworkDirectory, "repl");
if (Directory.Exists(replDir))
{
assembly = SearchDirectory(aname, replDir);
if (assembly != null)
{
return(assembly);
}
}
}
var facadeDir = Path.Combine(FrameworkDirectory, "Facades");
if (Directory.Exists(facadeDir))
{
assembly = SearchDirectory(aname, facadeDir);
if (assembly != null)
{
return(assembly);
}
}
if (ArchDirectory != null)
{
assembly = SearchDirectory(aname, ArchDirectory);
if (assembly != null)
{
return(assembly);
}
}
assembly = SearchDirectory(aname, FrameworkDirectory);
if (assembly != null)
{
return(assembly);
}
assembly = SearchDirectory(aname, RootDirectory);
if (assembly != null)
{
return(assembly);
}
assembly = SearchDirectory(aname, RootDirectory, ".exe");
if (assembly != null)
{
return(assembly);
}
return(null);
}
public static void HotfixInject(string inject_assembly_path, IEnumerable <string> search_directorys, IEnumerable <Type> cfg_check_types = null)
{
AssemblyDefinition assembly = null;
try
{
#if HOTFIX_SYMBOLS_DISABLE
assembly = AssemblyDefinition.ReadAssembly(inject_assembly_path);
#else
var readerParameters = new ReaderParameters {
ReadSymbols = true
};
assembly = AssemblyDefinition.ReadAssembly(inject_assembly_path, readerParameters);
#endif
init(assembly, search_directorys);
if (assembly.MainModule.Types.Any(t => t.Name == "__XLUA_GEN_FLAG"))
{
Info("had injected!");
return;
}
assembly.MainModule.Types.Add(new TypeDefinition("__XLUA_GEN", "__XLUA_GEN_FLAG", Mono.Cecil.TypeAttributes.Class,
objType));
Config(cfg_check_types);
var hotfixDelegateAttributeType = assembly.MainModule.Types.Single(t => t.FullName == "XLua.HotfixDelegateAttribute");
hotfix_delegates = (from module in assembly.Modules
from type in module.Types
where type.CustomAttributes.Any(ca => ca.AttributeType == hotfixDelegateAttributeType)
select type).ToList();
var hotfixAttributeType = assembly.MainModule.Types.Single(t => t.FullName == "XLua.HotfixAttribute");
foreach (var type in (from module in assembly.Modules from type in module.Types select type))
{
if (!injectType(assembly, hotfixAttributeType, type))
{
return;
}
}
#if HOTFIX_SYMBOLS_DISABLE
assembly.Write(inject_assembly_path);
Info("hotfix inject finish!(no symbols)");
#else
var writerParameters = new WriterParameters {
WriteSymbols = true
};
assembly.Write(inject_assembly_path, writerParameters);
Info("hotfix inject finish!");
#endif
}
catch (Exception e)
{
Error("Exception! " + e);
}
finally
{
if (assembly != null)
{
Clean(assembly);
}
}
}
void Run(Config config)
{
if (config.ShowHelp)
{
Console.WriteLine("Netjs compiler, Copyright 2014 Frank A. Krueger");
Console.WriteLine("netjs [options] assembly-file");
Console.WriteLine(" -help Lists all compiler options (short: -?)");
return;
}
if (string.IsNullOrEmpty(config.MainAssembly))
{
throw new Exception("No assembly specified.");
}
var asmPath = Path.GetFullPath(config.MainAssembly);
asmDir = Path.GetDirectoryName(asmPath);
var outPath = Path.ChangeExtension(asmPath, ".ts");
Step("Reading IL");
var parameters = new ReaderParameters {
AssemblyResolver = this,
};
var asm = AssemblyDefinition.ReadAssembly(asmPath, parameters);
mscorlib = AssemblyDefinition.ReadAssembly(typeof(String).Assembly.Location, parameters);
system = AssemblyDefinition.ReadAssembly(typeof(INotifyPropertyChanged).Assembly.Location, parameters);
systemCore = AssemblyDefinition.ReadAssembly(typeof(Enumerable).Assembly.Location, parameters);
systemDrawing = AssemblyDefinition.ReadAssembly(typeof(System.Drawing.Bitmap).Assembly.Location, parameters);
Step("Decompiling IL to C#");
var context = new DecompilerContext(asm.MainModule);
context.Settings.ForEachStatement = false;
context.Settings.ObjectOrCollectionInitializers = false;
context.Settings.UsingStatement = false;
context.Settings.AsyncAwait = false;
context.Settings.AutomaticProperties = true;
context.Settings.AutomaticEvents = true;
context.Settings.QueryExpressions = false;
context.Settings.AlwaysGenerateExceptionVariableForCatchBlocks = true;
context.Settings.UsingDeclarations = false;
context.Settings.FullyQualifyAmbiguousTypeNames = true;
context.Settings.YieldReturn = false;
var builder = new AstBuilder(context);
builder.AddAssembly(asm);
foreach (var a in referencedAssemblies.Values)
{
if (a != null)
{
builder.AddAssembly(a);
}
}
builder.RunTransformations();
Step("Translating C# to TypeScript");
new CsToTs().Run(builder.SyntaxTree);
Step("Writing");
using (var outputWriter = new StreamWriter(outPath)) {
var output = new PlainTextOutput(outputWriter);
builder.GenerateCode(output, (s, e) => new TsOutputVisitor(s, e));
}
Step("Done");
}
public AssemblyDefinition Resolve(string fullName, ReaderParameters parameters)
{
//Info ("R4: {0}", fullName);
return(null);
}
AssemblyDefinition IAssemblyResolver.Resolve(string fullName, ReaderParameters parameters)
{
var loader = widget.AddReferenceByAssemblyName(fullName);
return(loader != null ? loader.Assembly : null);
}
public AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters)
{
throw new NotImplementedException();
}
