public void Test() { var primaryAssembly = AssemblyCompiler.Compile(primaryAssemblyCode); var assemblyName = primaryAssembly.GetName().Name; CopyAssemblyToTestDirectory(primaryAssembly); CopyAssemblyToTestDirectory(typeof(IContainer).Assembly); CopyAssemblyToTestDirectory(Assembly.GetExecutingAssembly()); CopyAssemblyToTestDirectory(typeof(Assert).Assembly); GetInvoker().DoCallBack(assemblyName, delegate(string s) { var f = new ContainerFactory() .WithAssembliesFilter(x => x.Name.StartsWith("tmp_")) .WithTypesFromDefaultBinDirectory(false); var type = Type.GetType("A1.ISomeInterface, " + s); Assert.That(type, Is.Not.Null); using (var c = f.Build()) { var exception = Assert.Throws <SimpleContainerException>(() => c.Get(type)); var assemblies = new[] { "SimpleContainer", s }.OrderBy(x => x).Select(x => "\t" + x).JoinStrings("\r\n"); const string expectedMessage = "no instances for [ISomeInterface]\r\n\r\n!" + "ISomeInterface - has no implementations\r\n" + "scanned assemblies\r\n"; Assert.That(exception.Message, Is.EqualTo(expectedMessage + assemblies)); } }); }
public void ApplicationAssemblyInclusion_DependsOnAttribute() { string compiledAssemblyPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "NonApplicationMarkedAssembly.dll"); try { AppDomainRunner.Run( delegate(object[] args) { var path = (string)args[0]; ApplicationAssemblyLoaderFilter filter = ApplicationAssemblyLoaderFilter.Instance; Assert.That(filter.ShouldIncludeAssembly(typeof(AttributeAssemblyLoaderFilterTest).Assembly), Is.True); Assert.That(filter.ShouldIncludeAssembly(typeof(TestFixtureAttribute).Assembly), Is.True); Assert.That(filter.ShouldIncludeAssembly(typeof(ApplicationAssemblyLoaderFilter).Assembly), Is.True); Assert.That(filter.ShouldIncludeAssembly(typeof(object).Assembly), Is.True); Assert.That(filter.ShouldIncludeAssembly(typeof(Uri).Assembly), Is.True); var assemblyCompiler = new AssemblyCompiler(@"Reflection\TypeDiscovery\TestAssemblies\NonApplicationMarkedAssembly", path, typeof(NonApplicationAssemblyAttribute).Assembly.Location); assemblyCompiler.Compile(); Assert.That(filter.ShouldIncludeAssembly(assemblyCompiler.CompiledAssembly), Is.False); }, compiledAssemblyPath); } finally { if (File.Exists(compiledAssemblyPath)) { FileUtility.DeleteAndWaitForCompletion(compiledAssemblyPath); } } }
private static void CommonCode(string input) { AssemblyCompiler compiler = new AssemblyCompiler(input, true); compiler.Compile(true); compiler.RunAssembly(); }
private Assembly Generate() { var assemblyPath = Path.GetDirectoryName(this.assembly.Location); var trees = new ConcurrentBag<SyntaxTree>(); var allowUnsafe = false; Parallel.ForEach(assembly.GetExportedTypes() .Where(_ => string.IsNullOrWhiteSpace(_.Validate(this.options.Serialization, new AssemblyNameGenerator(_))) && !typeof(Array).IsAssignableFrom(_) && !typeof(Enum).IsAssignableFrom(_) && !typeof(ValueType).IsAssignableFrom(_) && !typeof(Delegate).IsAssignableFrom(_)), _ => { var builder = new AssemblyBuilder(_, new ReadOnlyDictionary<int, ReadOnlyCollection<HandlerInformation>>( new Dictionary<int, ReadOnlyCollection<HandlerInformation>>()), new SortedSet<string>(), this.options); builder.Build(); trees.Add(builder.Tree); allowUnsafe |= builder.IsUnsafe; }); var referencedAssemblies = this.assembly.GetReferencedAssemblies().Select(_ => Assembly.Load(_)).ToList(); referencedAssemblies.Add(this.assembly); var compiler = new AssemblyCompiler(trees, this.options.Optimization, new AssemblyNameGenerator(this.assembly).AssemblyName, referencedAssemblies.AsReadOnly(), currentDirectory, allowUnsafe, this.options.AllowWarnings); compiler.Compile(); return compiler.Result; }
public static void Main(string[] args) { if (args.Length == 0) { Console.WriteLine("You should pass at least one parameter!"); return; } string sourceModelPath = args[0]; List <string> passedRefsPaths = args.Skip(1).ToList(); if (!passedRefsPaths.Any()) { passedRefsPaths = Compiler.AssemblyCompiler.DefaultRefs.ToList(); } try { FileInfo modelFile; List <FileInfo> libraries; modelFile = GetFile(sourceModelPath); libraries = new List <FileInfo>(); foreach (var passedRef in passedRefsPaths) { libraries.Add(GetFile(passedRef)); } AssemblyCompiler compiler = new AssemblyCompiler(modelFile, libraries); compiler.Compile(false); } catch (ArgumentException e) { Console.WriteLine(e.Message); } }
private static void CommonCode(string input) { AssemblyCompiler compiler = new AssemblyCompiler(input, true); compiler.Compile(true); Console.WriteLine(GenerationUtils.PrintCodeObject(compiler.CompileUnit)); }
public static void Run(string input) { AssemblyCompiler compiler = new AssemblyCompiler(input, true); //Set this to false to generate exe in default folder compiler.Compile(true); compiler.RunAssembly(); }
private static void CommonCode(string input) { input = Defaults.DefUsing + input; AssemblyCompiler compiler = new AssemblyCompiler(input, true); compiler.Compile(true); compiler.RunAssembly(); }
/// <summary> /// Runs the given source text /// </summary> /// <param name="source">The source to execute</param> /// <param name="memorySize">The size the memory should have</param> /// <returns>The return value of the program</returns> public static BigInteger Run(string source, int memorySize = 43) { var instructions = AssemblyCompiler.Compile(source); var emulator = new Emulator(memorySize); emulator.Execute(instructions); return(emulator.GetReturnValue()); }
private Assembly CompileTestAssemblyInMemory(string assemblyName, params string[] referencedAssemblies) { AssemblyCompiler assemblyCompiler = AssemblyCompiler.CreateInMemoryAssemblyCompiler( c_testAssemblySourceDirectoryRoot + "\\" + assemblyName, ArrayUtility.Combine(new[] { typeof(MarkerAttribute).Module.Name }, referencedAssemblies)); assemblyCompiler.Compile(); return(assemblyCompiler.CompiledAssembly); }
private static void CommonCode(string input) { input = Defaults.DefUsing + input; AssemblyCompiler compiler = new AssemblyCompiler(input, true); compiler.Compile(true); Assert.Pass(GenerationUtils.PrintCodeObject(compiler.CompileUnit)); }
public void Test() { var referencedAssembly = AssemblyCompiler.Compile(referencedCode); var assembly = AssemblyCompiler.Compile(code, referencedAssembly); var factory = new ContainerFactory().WithTypesFromAssemblies(new[] { assembly }); using (var container = factory.Build()) { var interfaceType = referencedAssembly.GetType("A1.ISomeInterface"); Assert.That(container.Get(interfaceType).GetType().Name, Is.EqualTo("SomeInterfaceImpl")); } }
public void Test() { var assembly = AssemblyCompiler.Compile(testCode); File.WriteAllText(configFileName, "A.parameter->11"); var factory = new ContainerFactory() .WithAssembliesFilter(x => x.Name.StartsWith("tmp_")) .WithConfigFile(configFileName) .WithTypesFromAssemblies(new[] { assembly }); var e = Assert.Throws <SimpleContainerException>(() => factory.Build()); Assert.That(e.Message, Is.EqualTo("for name [A] more than one type found [A1.A], [A2.A]")); }
private string Compile(string sourceDirectory, string outputAssemblyName, bool generateExecutable, string compilerOptions) { var compiler = new AssemblyCompiler( sourceDirectory, outputAssemblyName, typeof(FilteringAssemblyLoader).Assembly.Location, typeof(Remotion.Logging.LogManager).Assembly.Location); compiler.CompilerParameters.GenerateExecutable = generateExecutable; compiler.CompilerParameters.CompilerOptions = compilerOptions; compiler.Compile(); return(compiler.OutputAssemblyPath); }
/// <summary> /// Compile an assembly into a dex file. /// </summary> private static void CompileAssembly(CommandLineOptions options, NameConverter nsConverter) { // Load resource type usage info file var usedTypeNames = LoadResourceTypeUsageInformation(options); // Load assemblies var assemblies = new List <AssemblyDefinition>(); var module = new XModule(); var classLoader = new AssemblyClassLoader(module.OnClassLoaded); var resolver = new AssemblyResolver(options.ReferenceFolders, classLoader, module.OnAssemblyLoaded); var readerParameters = new ReaderParameters(ReadingMode.Immediate) { AssemblyResolver = resolver, SymbolReaderProvider = new SafeSymbolReaderProvider(), ReadSymbols = true }; foreach (var asmPath in options.Assemblies) { var asm = resolver.Load(asmPath, readerParameters); module.OnAssemblyLoaded(asm); classLoader.LoadAssembly(asm); assemblies.Add(asm); } // Load references var references = new List <AssemblyDefinition>(); foreach (var refPath in options.References) { var asm = resolver.Load(refPath, readerParameters); module.OnAssemblyLoaded(asm); classLoader.LoadAssembly(asm); references.Add(asm); } // Load resources Table table; using (var stream = new FileStream(options.InputResources, FileMode.Open, FileAccess.Read)) { table = new Table(stream); } // Create compiler var compiler = new AssemblyCompiler(options.CompilationMode, assemblies, references, table, nsConverter, options.DebugInfo, classLoader, usedTypeNames, module); compiler.Compile(); compiler.Save(options.OutputFolder, options.FreeAppsKeyPath); }
public void Test() { var referencedAssembly = AssemblyCompiler.Compile(referencedCode); var a1 = AssemblyCompiler.Compile(code1, referencedAssembly); var a2 = AssemblyCompiler.Compile(code2, referencedAssembly); var factory = new ContainerFactory() .WithTypesFromAssemblies(new[] { a1, a2 }) .WithAssembliesFilter(x => x.Name == a2.GetName().Name); using (var container = factory.Build()) { var interfaceType = referencedAssembly.GetType("A1.ISomeInterface"); Assert.That(container.Get(interfaceType).GetType().Name, Is.EqualTo("TestClass2")); } }
static void Main(string[] args) { AssemblyCompiler asm = new AssemblyCompiler(TargetFramework.x86, 0x001C0000); byte[] code = asm.Compile( "start:", "mov eax,[eax*4+100]", "mov eax,[eax*4]", mov(eax, ~eax * 4 + 100) ); Console.WriteLine(BytesToString(code)); Console.ReadLine(); }
public void CheckILVerifier_IsFunctional() { const string dummyCode = @"using System; public class DummyClass { public int SimpleAdd() { var a = 2; var b = 3; return a + b; } }"; var validAssembly = new MemoryStream(); var dummyAssembly = AssemblyCompiler.Compile("DummyLib", dummyCode); dummyAssembly.Write(validAssembly); var typ = dummyAssembly.MainModule.GetType("DummyClass"); var testMethod = typ.Methods.FirstOrDefault(m => m.Name == "SimpleAdd"); if (testMethod != null) { var processor = testMethod.Body.GetILProcessor(); // Break IL codes by injecting a line that loads string to stack while adding 2 integers processor.Body.Instructions.Insert(2, processor.Create(OpCodes.Ldstr, "AElf")); } var invalidAssembly = new MemoryStream(); dummyAssembly.Write(invalidAssembly); // Ensure contract auditor doesn't throw any exception Should.NotThrow(() => _auditorFixture.Audit(validAssembly.ToArray())); // Ensure ILVerifier is doing its job Should.Throw <InvalidCodeException>(() => _auditorFixture.Audit(invalidAssembly.ToArray())) .Findings.FirstOrDefault(f => f is ILVerifierResult).ShouldNotBeNull(); }
public void Test() { var referencedAssemblyV2 = AssemblyCompiler.Compile(referencedAssemblyCodeV2); AssemblyCompiler.Compile(referencedAssemblyCodeV1, Path.Combine(testDirectory, Path.GetFileName(referencedAssemblyV2.Location))); var primaryAssembly = AssemblyCompiler.Compile(primaryAssemblyCode, referencedAssemblyV2); CopyAssemblyToTestDirectory(primaryAssembly); CopyAssemblyToTestDirectory(typeof(IContainer).Assembly); CopyAssemblyToTestDirectory(Assembly.GetExecutingAssembly()); var exceptionText = GetInvoker().CreateCointainerWithCrash(); Assert.That(exceptionText, Is.StringContaining("A1.ISomeInterface.Do")); const string englishText = "Unable to load one or more of the requested types"; const string russianText = "Не удается загрузить один или более запрошенных типов"; Assert.That(exceptionText, Is.StringContaining(englishText).Or.StringContaining(russianText)); Assert.That(exceptionText, Is.StringContaining(primaryAssembly.GetName().Name)); }
public void RunDefault() { _parameters.AssemblyOutputDirectory = "MixerRunnerTest"; _parameters.BaseDirectory = "MixerRunnerTest_Input"; var assemblyPath = Path.Combine(_parameters.AssemblyOutputDirectory, "Remotion.Mixins.Persistent.1.dll"); Assert.That(Directory.Exists(_parameters.AssemblyOutputDirectory), Is.False); Assert.That(File.Exists(assemblyPath), Is.False); Assert.That(Directory.Exists(_parameters.BaseDirectory), Is.False); try { Directory.CreateDirectory(_parameters.BaseDirectory); var compiler = new AssemblyCompiler( @"Core\MixerTools\SampleAssembly", Path.Combine(_parameters.BaseDirectory, "SampleAssembly.dll"), typeof(Mixin).Assembly.Location); compiler.Compile(); var runner = new MixerRunner(_parameters); runner.Run(); Assert.That(Directory.Exists(_parameters.AssemblyOutputDirectory), Is.True); Assert.That(File.Exists(assemblyPath), Is.True); } finally { if (Directory.Exists(_parameters.BaseDirectory)) { Directory.Delete(_parameters.BaseDirectory, true); } if (Directory.Exists(_parameters.AssemblyOutputDirectory)) { Directory.Delete(_parameters.AssemblyOutputDirectory, true); } } }
/// <summary> /// Compile an assembly into a dex file. /// </summary> private static void CompileAssembly(CommandLineOptions options, NameConverter nsConverter) { // Load resource type usage info file var usedTypeNames = LoadResourceTypeUsageInformation(options); // Load assemblies List <AssemblyDefinition> assemblies = new List <AssemblyDefinition>(); List <AssemblyDefinition> references = new List <AssemblyDefinition>(); var dxJarCompiler = options.EnableDxJarCompilation ? new DxClassfileMethodBodyCompiler(options.OutputFolder, options.DebugInfo) : null; Action <ClassSource> jarLoaded = dxJarCompiler != null ? dxJarCompiler.PreloadJar : (Action <ClassSource>)null; var module = new XModule(); var classLoader = new AssemblyClassLoader(module.OnClassLoaded); var resolver = new AssemblyResolver(options.ReferenceFolders, classLoader, module.OnAssemblyLoaded); // initialize compiler cache in background. var ccache = options.EnableCompilerCache ? new DexMethodBodyCompilerCache(options.OutputFolder, resolver.GetFileName) : new DexMethodBodyCompilerCache(); var readerParameters = new ReaderParameters { AssemblyResolver = resolver, SymbolReaderProvider = new SafeSymbolReaderProvider(), ReadSymbols = true, ReadingMode = ReadingMode.Immediate }; // load assemblies var toLoad = options.Assemblies.Select(path => new { path, target = assemblies }) .Concat(options.References.Select(path => new { path, target = references })) // Some micro optimizations... // Our startup is IO bound until we have loaded first assembly from disk. // So just load from smallest to largest. .Select(load => new { load.path, load.target, length = new FileInfo(resolver.ResolvePath(load.path)).Length }) .OrderBy(load => load.length) .ToList(); using (AssemblyCompiler.Profile("for loading assemblies")) { toLoad.AsParallel().ForAll( //toLoad.ForEach( load => { var assm = resolver.Load(load.path, readerParameters); lock (load.target) load.target.Add(assm); }); } // Load resources Table table; using (var stream = new FileStream(options.InputResources, FileMode.Open, FileAccess.Read)) { table = new Table(stream); } // Create compiler var compiler = new AssemblyCompiler(options.CompilationMode, assemblies, references, table, nsConverter, options.DebugInfo, classLoader, resolver.GetFileName, ccache, usedTypeNames, module, options.GenerateSetNextInstructionCode); compiler.DxClassfileMethodBodyCompiler = dxJarCompiler; using (AssemblyCompiler.Profile("total compilation time", true)) compiler.Compile(); ccache.PrintStatistics(); using (AssemblyCompiler.Profile("saving results")) compiler.Save(options.OutputFolder, options.FreeAppsKeyPath); }
public override void DecompileMethod(Mono.Cecil.MethodDefinition method, ICSharpCode.Decompiler.ITextOutput output, DecompilationOptions options) { var declaringType = method.DeclaringType; var assembly = declaringType.Module.Assembly; if ((compiler == null) || (compiler.Assembly != assembly)) { compiler = null; var c = new AssemblyCompiler(assembly, new NamespaceConverter("pkg.name", "")); c.Compile(); compiler = c; } var cmethod = compiler.GetMethod(method); if ((cmethod != null) && (cmethod.DexMethod != null)) { var body = cmethod.DexMethod.Body; body.UpdateInstructionOffsets(); var targetInstructions = body.Instructions.Select(x => x.Operand).OfType <Instruction>().ToList(); targetInstructions.AddRange(body.Exceptions.Select(x => x.TryStart)); targetInstructions.AddRange(body.Exceptions.Select(x => x.TryEnd)); targetInstructions.AddRange(body.Exceptions.SelectMany(x => x.Catches, (h, y) => y.Instruction)); targetInstructions.AddRange(body.Exceptions.Select(x => x.CatchAll)); foreach (var ins in body.Instructions) { if (targetInstructions.Contains(ins) || (ins.Offset == 0)) { output.Write(string.Format("D_{0:X4}:", ins.Offset)); output.WriteLine(); } output.Indent(); output.Write(ins.ToString()); output.WriteLine(); output.Unindent(); } if (body.Exceptions.Any()) { output.WriteLine(); output.Write("Exception handlers:"); output.WriteLine(); output.Indent(); foreach (var handler in body.Exceptions) { output.Write(string.Format("{0:x4}-{1:x4}", handler.TryStart.Offset, handler.TryEnd.Offset)); output.WriteLine(); output.Indent(); foreach (var c in handler.Catches) { output.Write(string.Format("{0} => {1:x4}", c.Type, c.Instruction.Offset)); output.WriteLine(); } if (handler.CatchAll != null) { output.Write(string.Format("{0} => {1:x4}", "<any>", handler.CatchAll.Offset)); output.WriteLine(); } output.Unindent(); } output.Unindent(); } } else { output.Write("Method not found in dex"); output.WriteLine(); } }
public override void DecompileMethod(Mono.Cecil.MethodDefinition method, ICSharpCode.Decompiler.ITextOutput output, DecompilationOptions options) { var declaringType = method.DeclaringType; var assembly = declaringType.Module.Assembly; if ((compiler == null) || (compiler.Assembly != assembly)) { compiler = null; var c = new AssemblyCompiler(assembly, new NamespaceConverter("pkg.name", "")); c.Compile(); compiler = c; } var cmethod = compiler.GetMethod(method); if ((cmethod != null) && (cmethod.RLBody != null)) { var body = cmethod.RLBody; var basicBlocks = BasicBlock.Find(body); foreach (var block in basicBlocks) { output.Write(string.Format("D_{0:X4}:", block.Entry.Index)); output.WriteLine(); output.Indent(); foreach (var ins in block.Instructions) { output.Write(ins.ToString()); output.WriteLine(); } output.Unindent(); } if (body.Exceptions.Any()) { output.WriteLine(); output.Write("Exception handlers:"); output.WriteLine(); output.Indent(); foreach (var handler in body.Exceptions) { output.Write(string.Format("{0:x4}-{1:x4}", handler.TryStart.Index, handler.TryEnd.Index)); output.WriteLine(); output.Indent(); foreach (var c in handler.Catches) { output.Write(string.Format("{0} => {1:x4}", c.Type, c.Instruction.Index)); output.WriteLine(); } if (handler.CatchAll != null) { output.Write(string.Format("{0} => {1:x4}", "<any>", handler.CatchAll.Index)); output.WriteLine(); } output.Unindent(); } output.Unindent(); } } else { output.Write("Method not found in dex"); output.WriteLine(); } }
public override void DecompileMethod(Mono.Cecil.MethodDefinition method, ICSharpCode.Decompiler.ITextOutput output, DecompilationOptions options) { var declaringType = method.DeclaringType; var assembly = declaringType.Module.Assembly; if ((compiler == null) || (compiler.Assembly != assembly)) { compiler = null; var c = new AssemblyCompiler(assembly, new NamespaceConverter("pkg.name", "")); c.Compile(); compiler = c; } var cmethod = compiler.GetMethod(method); if ((cmethod != null) && (cmethod.RLBody != null)) { var body = cmethod.RLBody; var basicBlocks = BasicBlock.Find(body); foreach (var block in basicBlocks) { output.Write(string.Format("D_{0:X4}:", block.Entry.Index)); output.WriteLine(); output.Indent(); foreach (var ins in block.Instructions) { output.Write(ins.ToString()); output.WriteLine(); } output.Unindent(); } if (body.Exceptions.Any()) { output.WriteLine(); output.Write("Exception handlers:"); output.WriteLine(); output.Indent(); foreach (var handler in body.Exceptions) { output.Write(string.Format("{0:x4}-{1:x4}", handler.TryStart.Index, handler.TryEnd.Index)); output.WriteLine(); output.Indent(); foreach (var c in handler.Catches) { output.Write(string.Format("{0} => {1:x4}", c.Type, c.Instruction.Index)); output.WriteLine(); } if (handler.CatchAll != null) { output.Write(string.Format("{0} => {1:x4}", "<any>", handler.CatchAll.Index)); output.WriteLine(); } output.Unindent(); } output.Unindent(); } } else { output.Write("Method not found in dex"); output.WriteLine(); } }