public void ShouldResolveMethodOfExternalInterface() { var csharp = DecompilationResult.CreateFromDelegate <NullCursor, string>(_delegateReader, (cursor, args, keys) => { ISomeInterface foo = new SomeInterace("abc"); return(foo.Greeting("def")); }); var redIL = _csharpCompiler.Compile(csharp) as RootNode; }
public IHandle <TRes> GetHandle <TRes>(Func <ICursor, RedisValue[], RedisKey[], TRes> action) where TRes : RedResult { var decompilation = _decompiler.Decompile(action); var redIL = _csharpCompiler.Compile(decompilation); var handle = _luaHandler.CreateHandle <TRes>(redIL); return(handle); }
public void ShouldResolveConstructor() { var csharp = DecompilationResult.CreateFromDelegate <NullCursor, bool>(_delegateReader, (cursor, args, keys) => { var foo = new Foo <double>(3.5); return(true); }); var redIL = _csharpCompiler.Compile(csharp) as RootNode; var block = redIL.Body as BlockNode; block.Children.Count.Should().Be(2); var varDec = block.Children.First() as VariableDeclareNode; varDec.Value.Should().BeEquivalentTo(new ConstantValueNode(DataValueType.Float, (double)3.5)); }
public static ExtensionLoader BuildLoader <TCodeSource>( ILog logger, IEnumerable <ExtensionTypeRecord> typeRecords, IEnumerable <TCodeSource> selectedSources, IEnumerable <TCodeSource> additionalSources = null, CSharpCompilerOptions compilerOptions = null, Options options = null) where TCodeSource : ICodeSource { options = options ?? new Options(); var compiler = new CSharpCompiler <TCodeSource>(compilerOptions ?? new CSharpCompilerOptions()); var selectedSourcesList = selectedSources as IList <TCodeSource> ?? selectedSources.ToList(); var results = compiler.Compile(selectedSourcesList, additionalSources).ToDictionary(r => r.Source.UniqueName); var assemblies = new List <Assembly>(results.Count); var orderedSelected = selectedSourcesList.Select(s => results[s.UniqueName]).ToList(); if (options.InclusionStrategy == InclusionStrategy.AfterFirst) { // TODO: implement throw new NotImplementedException("non-None inclusion strategies not yet implemented, pull requests welcome."); } else if (options.InclusionStrategy == InclusionStrategy.AfterLast) { // TODO: implement throw new NotImplementedException("non-None inclusion strategies not yet implemented, pull requests welcome."); } return(new ExtensionLoader(logger, assemblies, typeRecords, options.ThrowOnConstructorMissing)); }
public override string Render() { string executableCode = ((CSharpParser)parser).Parse(codeTemplate, variables, values); compiler.Compile(executableCode); return(compiler.Result); }
protected async Task <CompilationResult> Compile(IFileSystem fileSystem) { var compiler = new CSharpCompiler( fileSystem.GetFiles("GeneratedCode", "*.cs", SearchOption.AllDirectories) .Select(each => new KeyValuePair <string, string>(each, fileSystem.ReadFileAsText(each))).ToArray(), ManagedAssets.FrameworkAssemblies.Concat( AppDomain.CurrentDomain.GetAssemblies() .Where(each => !each.IsDynamic && !string.IsNullOrEmpty(each.Location)) .Select(each => each.Location) .Concat(new[] { Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Microsoft.Rest.ClientRuntime.dll"), Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Microsoft.Rest.ClientRuntime.Azure.dll") }) )); var result = await compiler.Compile(OutputKind.DynamicallyLinkedLibrary); // if it failed compiling and we're in an interactive session if (!result.Succeeded && System.Environment.OSVersion.Platform == PlatformID.Win32NT && System.Environment.UserInteractive) { var error = result.Messages.FirstOrDefault(each => each.Severity == DiagnosticSeverity.Error); if (error != null) { // use this to dump the files to disk for examination // open in Favorite Code Editor InspectWithFavoriteCodeEditor(fileSystem.SaveFilesToTemp(GetType().Name), error.Location.GetMappedLineSpan()); } } return(result); }
public FileCompileResult Compile(string fileToCompile) { CompileResult result; if (fileToCompile.EndsWith(".cs")) { var compiler = new CSharpCompiler(); var copiedFileName = fileToCompile + ".cs"; File.Copy(fileToCompile, copiedFileName); result = compiler.Compile(this.csharpCompilerPath, copiedFileName, "/optimize+ /nologo /reference:System.Numerics.dll"); } else if (fileToCompile.EndsWith(".zip")) { var compiler = new MsBuildCompiler(); var copiedFileName = fileToCompile + ".zip"; File.Copy(fileToCompile, copiedFileName); result = compiler.Compile(this.msbuildCompilerPath, copiedFileName, "/t:rebuild /p:Configuration=Release,Optimize=true /verbosity:quiet /nologo"); } else { throw new ArgumentException("Invalid file extension", "fileToCompile"); } return(new FileCompileResult(result)); }
protected async Task <Microsoft.Rest.CSharp.Compiler.Compilation.CompilationResult> Compile(IFileSystem fileSystem) { var compiler = new CSharpCompiler(fileSystem.GetFiles("", "*.cs", SearchOption.AllDirectories) .Select(each => new KeyValuePair <string, string>(each, fileSystem.ReadAllText(each))).ToArray(), _assemblies); return(await compiler.Compile(OutputKind.DynamicallyLinkedLibrary)); }
static void CompilerTest(string[] args) { var compiler = new CSharpCompiler(); var dllPath = Path.GetFullPath("TestClasses") + CommonFolders.Sep + "TestApp.dll"; var results = compiler.Compile("TestApp", "TestClasses", new List <string> { Path.GetFullPath("TestClasses/TestClass1.cs"), Path.GetFullPath("TestClasses/TestClass2.cs") }); foreach (CompilerError err in results.Errors) { Console.WriteLine($"{(err.IsWarning ? "WARNING :" : "ERROR :")} {err.ErrorText}"); } if (!results.Errors.HasErrors) { var loader = new AppDomainLoader("TestApp", dllPath); if (loader.IsLoaded) { var testClass1 = loader.RunRemoteFunc <object>(() => { Console.WriteLine(AppDomain.CurrentDomain.SetupInformation.ApplicationName); return(null); }); } } }
public void CompileTest() { var compiler = new CSharpCompiler("test"); var func = compiler.Compile("test.prop2 = test.prop;"); dynamic test = new ExpandoObject(); test.prop = "test"; func(test, null); Assert.AreEqual(test.prop, test.prop2); }
public void ShouldResolveArrayLength() { var csharp = DecompilationResult.CreateFromDelegate <NullCursor, int>(_delegateReader, (cursor, args, keys) => { var arr = new int[] { 1, 2, 3 }; return(arr.Length); }); var redIL = _csharpCompiler.Compile(csharp) as RootNode; }
public void CompileFailed() { var code = "class TestClass { void TestMethod() { var i = 0 } }"; var ex = Assert.Throws <CompilationException>(() => CSharpCompiler.Compile("test", CSharpCompiler.ParseText(code))); Assert.Contains("Error", ex.Message); Assert.Contains("; expected", ex.Message); }
private static List <TreeItem <MemberInfo> > Collect(string code) { var assemblyName = Guid.NewGuid().ToString(); var syntaxTree = CSharpCompiler.ParseText(code); var(_, assembly) = CSharpCompiler.Compile(assemblyName, syntaxTree); var syntaxItems = CSharpHelper.CollectSyntax(syntaxTree.GetRoot()); return(CSharpHelper.CollectMembers(assembly, syntaxItems)); }
public void Create_process_code_should_can_be_compiled() { // Arrange using (var compiler = new CSharpCompiler()) { // Act var asm = compiler.Compile(Code); // Assert asm.HasErrors.Should().BeFalse(); } }
static void OkScenario(CSRunner.Base.Environment env) { var assembly = CSharpCompiler.Compile(env.CommandLine, (string errors, object[] parameters) => { System.Console.WriteLine(string.Format(errors, parameters)); }); var runner = assembly.ExportedTypes.Where(t => t.IsSubclassOf(typeof(Runner))).SingleOrDefault(); var runnerInstance = Activator.CreateInstance(runner, new[] { env }) as Runner; runnerInstance.Run(); }
internal static FileInfo CompileCodeIntoLocation(string source, IEnumerable <string> embeddedResources, IEnumerable <string> referencedAssemblies, DirectoryInfo location) { if (!location.Exists) { throw new ArgumentException(string.Format("Directory '{0}' does not exist", location.FullName), "location"); } var binaryPath = Path.Combine(location.FullName, string.Format("{0}.dll", Guid.NewGuid())); CSharpCompiler.Compile(source, binaryPath, embeddedResources, referencedAssemblies); return(new FileInfo(binaryPath)); }
public void LoadScripts() { string[] files = CSharpCompiler.GetScripts("*.cs"); Console.WriteLine("Found {0} Scripts.", files.Length); CSharpCompiler.Compile(files); // So look for our new assembly string dll = Path.Combine(ServerGlobals.BaseDirectory, "Scripts\\Scripts.dll"); Assembly a = Assembly.LoadFrom(dll); if (a != null) { ScriptResolver.LoadScriptObjects(a); } }
public void CompileThrowsCompilerExceptionTest() { var compiler = new CSharpCompiler("test"); try { var func = compiler.Compile("not valid c# code"); func(null, null); Assert.Fail(); } catch (Exception err) { Assert.IsInstanceOfType(err, typeof(CompilerException)); } }
/// <summary> /// Accepts a Function delegate and creates a non-initialized handle for executing the function /// </summary> /// <param name="function">A delegate with the function to execute</param> /// <typeparam name="TRes">The return type of the function</typeparam> /// <returns>A non-initialized handle for executing the function</returns> public IHandle <TRes> GetHandle <TRes>(Function <TCursor, TRes> function) { var decompilation = DecompilationResult.CreateFromDelegate(_delegateReader, function); var redIL = _csharpCompiler.Compile(decompilation); // We create the Lua handle regardless of whether we in Debug or not // Because we still want to fail/throw if RedIL/Lua compilation has failed var luaHandle = _luaHandler.CreateHandle <TRes>(redIL); if (DebuggingEnabled && Debugger.IsAttached && !(DebugInstance is null)) { return(new DebugHandle <TCursor, TRes>(luaHandle, DebugInstance, function)); } return(luaHandle); }
public void Run_can_accept_vary_input(int size) { // Arrange var compiler = new CSharpCompiler(); var asm = compiler.Compile(Code); var path = asm.PathToAssembly; var info = new SandboxRunInfo { LimitProcessCount = 1, MemoryLimitMb = 150.0f, Path = path, TimeLimitMs = 3000 }; // Act var ior = Sandbox.BeginRun(info); // Assert var input = new string('林', size); var expected = string.Format("Hey {0}!", input); var writer = new StreamWriter(ior.InputWriteStream); var writeTask = writer.WriteAsync(input).ContinueWith(a => writer.Close()); var reader = new StreamReader(ior.OutputReadStream); var readTask = reader.ReadToEndAsync(); var res = Sandbox.EndRun(ior.InstanceHandle); writeTask.Wait(); readTask.Wait(); res.Succeed.Should().BeTrue(); res.MemoryMb.Should().BeLessThan(info.MemoryLimitMb); res.TimeMs.Should().BeLessThan(info.TimeLimitMs); res.ExitCode.Should().Be(0); var actual = readTask.Result; actual.Should().Be(expected); Console.WriteLine("Time: {0}ms", res.TimeMs); Console.WriteLine("Memory: {0}MB", res.MemoryMb); compiler.Dispose(); }
private CompiledTypes Compile( IFieldResolverDescriptor[] resolverDescriptors, IDirectiveMiddlewareDescriptor[] middlewareDescriptors) { GeneratedClass resolverClass = _codeGenerator .Generate(resolverDescriptors); GeneratedClass middlewareClass = _codeGenerator .Generate(middlewareDescriptors); Assembly assembly = CSharpCompiler.Compile( resolverClass.SourceText, middlewareClass.SourceText); return(new CompiledTypes( assembly.GetType(resolverClass.FullName), assembly.GetType(middlewareClass.FullName))); }
public void CSharpCompilerShouldWorkWhenGivenValidSourceCode() { const string Source = @"using System; class Program { static void Main() { Console.WriteLine(""It works!""); } }"; var compiler = new CSharpCompiler(); var result = compiler.Compile(CSharpCompilerPath, FileHelpers.SaveStringToTempFile(Source), string.Empty); Assert.IsTrue(result.IsCompiledSuccessfully, "Compilation is not successful"); Assert.IsFalse(string.IsNullOrWhiteSpace(result.OutputFile), "Output file is null"); Assert.IsTrue(result.OutputFile.EndsWith(".exe"), "Output file does not ends with .exe"); }
public void CSharpCompilerShouldWorkWhenGivenValidSourceCode() { const string Source = @"using System; class Program { static void Main() { Console.WriteLine(""It works!""); } }"; var compiler = new CSharpCompiler(CSharpCompilerProcessExitTimeOutMultiplier); var result = compiler.Compile(CSharpCompilerPath, FileHelpers.SaveStringToTempFile(Source), string.Empty); Assert.IsTrue(result.IsCompiledSuccessfully, "Compilation is not successful"); Assert.IsFalse(string.IsNullOrWhiteSpace(result.OutputFile), "Output file is null"); Assert.IsTrue(result.OutputFile.EndsWith(".exe"), "Output file does not ends with .exe"); }
protected async Task <CompilationResult> Compile(IFileSystem fileSystem) { var compiler = new CSharpCompiler( fileSystem.GetFiles("GeneratedCode", "*.cs", SearchOption.AllDirectories) .Select(each => new KeyValuePair <string, string>(each, fileSystem.ReadFileAsText(each))).ToArray(), ManagedAssets.FrameworkAssemblies.Concat( AppDomain.CurrentDomain.GetAssemblies() .Where(each => !each.IsDynamic && !string.IsNullOrEmpty(each.Location)) .Select(each => each.Location) .Concat(new[] { Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Microsoft.Rest.ClientRuntime.dll") }) )); return(await compiler.Compile(OutputKind.DynamicallyLinkedLibrary)); }
private static List <Disassembler> GetFileDisassemblers(DisassembleFileOptions options, MessageWriter writer) { var begin = DateTime.Now; // Parsing writer.Write("; Parsing from file ... "); var syntaxTree = CSharpCompiler.ParseFrom(options.FilePath); var parsed = DateTime.Now; writer.WriteLine($"done. ({Diff(begin, parsed)})"); // Compiling writer.Write("; Compiling ... "); var compilationOptions = new CompilationOptions { SaveAssembly = options.SaveAssembly, DisableOptimization = options.DisableOptimization }; var assemblyName = Path.GetFileNameWithoutExtension(options.FilePath); var(_, assembly) = CSharpCompiler.Compile(assemblyName, syntaxTree, compilationOptions); var compiled = DateTime.Now; writer.WriteLine($"done. ({Diff(parsed, compiled)})"); // Analyzing writer.Write("; Analyzing ... "); var syntaxItems = CSharpHelper.CollectSyntax(syntaxTree.GetRoot()); var memberItems = CSharpHelper.CollectMembers(assembly, syntaxItems); var disassemblers = memberItems.Select(Disassembler.Create).ToList(); var analyzed = DateTime.Now; writer.WriteLine($"done. ({Diff(compiled, analyzed)})"); writer.WriteLine(""); return(disassemblers); }
public void Create_multiple_process_in_limit_should_be_ok(int limitCount, int createCount, bool result) { // Arrange using (var compiler = new CSharpCompiler()) { var asm = compiler.Compile(Code); var info = new SandboxRunInfo { LimitProcessCount = limitCount, MemoryLimitMb = 40.0f, Path = asm.PathToAssembly, TimeLimitMs = 1000, }; var ior = Sandbox.BeginRun(info); using (var writer = new StreamWriter(ior.InputWriteStream)) { writer.Write(createCount); } var res = Sandbox.EndRun(ior.InstanceHandle); res.Succeed.Should().BeTrue(); if (result) { res.ExitCode.Should().Be(0); } else { res.ExitCode.Should().NotBe(0); } res.TimeMs.Should().BeLessThan(info.TimeLimitMs); res.MemoryMb.Should().BeLessThan(info.MemoryLimitMb); Console.WriteLine("Time: {0}ms", res.TimeMs); Console.WriteLine("Memory: {0}MB", res.MemoryMb); Console.WriteLine(info.Path); Thread.Sleep(10); } }
protected async Task <CompilationResult> Compile(IFileSystem fileSystem) { var compiler = new CSharpCompiler(fileSystem.GetFiles("", "*.cs", SearchOption.AllDirectories) .Select(each => new KeyValuePair <string, string>(each, fileSystem.ReadAllText(each))).ToArray(), _assemblies); var result = await compiler.Compile(OutputKind.DynamicallyLinkedLibrary); #if false // if it failed compiling and we're in an interactive session if (!result.Succeeded && Environment.OSVersion.Platform == PlatformID.Win32NT && Environment.UserInteractive) { var error = result.Messages.FirstOrDefault(each => each.Severity == DiagnosticSeverity.Error); if (error != null) { // use this to dump the files to disk for examination // open in Favorite Code Editor InspectWithFavoriteCodeEditor(fileSystem.SaveFilesToTemp(GetType().Name), error.Location.GetMappedLineSpan()); } } #endif return(result); }
public void Run_can_accept_unicode_input() { // Arrange var compiler = new CSharpCompiler(); var asm = compiler.Compile(Code); var path = asm.PathToAssembly; var info = new SandboxRunInfo { LimitProcessCount = 1, MemoryLimitMb = 10.0f, Path = path, TimeLimitMs = 1000 }; // Act var ior = Sandbox.BeginRun(info); // Assert using (var writer = new StreamWriter(ior.InputWriteStream)) { writer.WriteAsync("Flash中文"); } var reader = new StreamReader(ior.OutputReadStream); var readTask = reader.ReadToEndAsync(); var res = Sandbox.EndRun(ior.InstanceHandle); readTask.Result.Should().Be("Hey Flash中文!"); res.Succeed.Should().BeTrue(); res.MemoryMb.Should().BeGreaterThan(0); res.TimeMs.Should().BeGreaterOrEqualTo(0); compiler.Dispose(); Console.WriteLine("Time: {0}ms", res.TimeMs); Console.WriteLine("Memory: {0}MB", res.MemoryMb); }
public void CompilePassed() { var code = "class TestClass { void TestMethod() { var i = 0; } }"; Assert.NotNull(CSharpCompiler.Compile("test", CSharpCompiler.ParseText(code))); }
private Action<object, object> Compile() { var compiler = new CSharpCompiler(Field); return compiler.Compile(_code); }