private static void DoCompilation(ConfigData cfg, ref bool showUsage) { var showUsage1 = showUsage; CompilerEngine.ExecuteInSeparateAppDomain( ce => { ce.Configuration = cfg.Configuration; ce.CsProject = cfg.CsProject; ce.OutDir = cfg.OutDir; ce.Referenced.Clear(); ce.TranlationHelpers.Clear(); ce.ReferencedPyLibsLocations.Clear(); // src and dest can be in different application domain // we need to add item by item ce.Set1(cfg.Referenced.ToArray(), cfg.TranlationHelpers.ToArray(), cfg.ReferencedPyLibsLocations.Select(a => a.Key + "\n" + a.Value).ToArray() ); ce.BinaryOutputDir = cfg.BinaryOutputDir; Debug.Assert(ce.Referenced.Count == cfg.Referenced.Count); Debug.Assert(ce.TranlationHelpers.Count == cfg.TranlationHelpers.Count); Debug.Assert(ce.ReferencedPyLibsLocations.Count == cfg.ReferencedPyLibsLocations.Count); //ce.CopyFrom(aa); ce.Check(); showUsage1 = false; ce.Compile(); }); showUsage = showUsage1; }
protected void btnCompileAndRun_Click(object sender, EventArgs e) { string code = this.StripHTML(txtSourceLib.InnerText); string mainBlock = this.StripHTML(txtMain.InnerText); CompilerEngine compiler = new CompilerEngine(code, mainBlock); lblOutput.Text = compiler.EndToEndCompileAndRun(); }
/* * /// <summary> * /// The main. * /// </summary> * /// <param name="args"> * /// The args. * /// </param> * private static void Main(string[] args) * { * var host = new ScriptingHost(); * System.Diagnostics.Trace.Write("And it's started."); * string codeLine; * Console.Write(">"); * while ((codeLine = Console.ReadLine()) != "Exit();") * { * try * { * // Execute the code * var res = host.Execute(codeLine); * * // Write the result back to console * if (res != null) * { * Console.WriteLine(" = " + res.ToString()); * } * } * catch (Exception e) * { * Console.WriteLine(" !! " + e.Message); * } * * Console.Write(">"); * } * } */ static void Main(string[] args) { string code = "public class Test{" + "public string SayHello() {" + "return \"Hi, WWW.\"; " + "}" + "}"; string mainBlock = "Test test = new Test(); " + "Print(test.SayHello());"; CompilerEngine compiler = new CompilerEngine(code, mainBlock); Console.WriteLine(compiler.EndToEndCompileAndRun()); Console.Read(); }
//private const string KernelFile = CosmosRoot + @"\Users\Emile\TestBed\TestBed\bin\Debug\TestBed.dll"; //private const string OutputFile = CosmosRoot + @"\Users\Emile\TestBed\TestBed\bin\Debug\TestBedBoot.asm"; private static void Main(string[] args) { //Console.SetOut(new StreamWriter("out", false)); var xSW = Stopwatch.StartNew(); try { CosmosPaths.DebugStubSrc = Path.Combine(CosmosRoot, "source", "Cosmos.Debug.DebugStub"); var xTask = new CompilerEngine(); xTask.DebugEnabled = true; xTask.StackCorruptionDetectionEnabled = true; xTask.StackCorruptionDetectionLevel = "AllInstructions"; xTask.DebugMode = "Source"; xTask.TraceAssemblies = "All"; xTask.DebugCom = 1; xTask.UseNAsm = true; xTask.OutputFilename = OutputFile; xTask.EnableLogging = true; xTask.EmitDebugSymbols = true; xTask.IgnoreDebugStubAttribute = false; xTask.References = GetReferences(); xTask.OnLogError = (m) => Console.WriteLine("Error: {0}", m); xTask.OnLogWarning = (m) => Console.WriteLine("Warning: {0}", m); xTask.OnLogMessage = (m) => { Console.WriteLine("Message: {0}", m); }; xTask.OnLogException = (m) => Console.WriteLine("Exception: {0}", m.ToString()); if (xTask.Execute()) { Console.WriteLine("Executed OK"); } else { Console.WriteLine("Errorred"); } xSW.Stop(); } catch (Exception E) { Console.Out.Flush(); Console.WriteLine(E.ToString()); //Console.ReadLine(); return; } Console.WriteLine("Run took {0}", xSW.Elapsed); Console.WriteLine("Generated {0} Guids", DebugInfo.GeneratedIdsCount()); Console.Out.Flush(); Console.ReadKey(); }
public void Execute() { if (String.IsNullOrWhiteSpace(OutputFile)) { throw new InvalidOperationException("No OutputFile specified!"); } if (References.Count == 0) { throw new InvalidOperationException("No References specified!"); } DebugInfo.SetRange(DebugInfo.AssemblerDebugSymbolsRange); Console.WriteLine("Compiling to '{0}'", OutputFile); var xTask = new CompilerEngine(); xTask.DebugEnabled = false; xTask.StackCorruptionDetectionEnabled = false; xTask.StackCorruptionDetectionLevel = "MethodFooters"; xTask.DebugMode = "Source"; xTask.TraceAssemblies = "User"; xTask.DebugCom = 1; xTask.UseNAsm = true; xTask.OutputFilename = OutputFile; xTask.EnableLogging = true; xTask.EmitDebugSymbols = true; xTask.IgnoreDebugStubAttribute = false; xTask.References = GetReferences(); xTask.AssemblerLog = AssemblerLogFile; xTask.OnLogError = m => { throw new Exception("Error during compilation: " + m); }; xTask.OnLogWarning = (m) => Console.WriteLine("Warning: {0}", m); xTask.OnLogMessage = (m) => { Console.WriteLine("Message: {0}", m); }; xTask.OnLogException = (m) => Console.WriteLine("Exception: {0}", m.ToString()); if (!xTask.Execute()) { throw new Exception("Error occurred while running compiler!"); } }
/// <summary> /// The compile operation to compile the requested code unit. /// </summary> /// <param name="compileRequest"> /// The compile request. /// </param> /// <returns> /// The <see cref="CompileResponse"/>. /// </returns> public CompileResponse Compile(CompileRequest compileRequest) { // TODO: Future version execution /* * FlowRequirement requirement = new FlowRequirement(compileRequest.SourceCode); * ExecutionFlowBuilder.Build().Execute(ContextProvider.Context, requirement); * */ ICompiler csharpCompiler = new CompilerEngine(); CompileArgs arguments = new CompileArgs { SourceCode = compileRequest.SourceCode }; var result = csharpCompiler.Compile(arguments); return(new CompileResponse { CompileResult = result }); }
public static ABIExitCode Compile(ABIFileSystemOptions options, LogFactory factory) { #region Argument exceptions if (options == null) { throw new ArgumentNullException(nameof(options)); } if (factory == null) { throw new ArgumentNullException(nameof(factory)); } #endregion _logger = factory.GetCurrentClassLogger(); _logger.Debug(options); try { if (!Validate(options)) { return(ABIExitCode.ErrorDuringValidation); } var engine = new CompilerEngine(options, factory); var result = engine.Compile(); Debug.Assert(result != ABIExitCode.ErrorExitCodeUnassigned); return(result); } catch (Exception ex) // avoid external unhandled exceptions { _logger.Error(ex); } return(ABIExitCode.ErrorUnhandledException); }
public void Run() { StringBuilder sb = new StringBuilder(); sb.Append("using CodeRank.CSharpProblems.Ruleset.Base;"); sb.Append("namespace CodeRank.CSharpProblems.Ruleset.Solution"); sb.Append("{"); sb.Append("public class SampleTestRuleSolution : ISampleTest"); sb.Append("{"); sb.Append("public int Sum(int a, int b)"); sb.Append("{"); sb.Append("return a + b;"); sb.Append("}"); sb.Append("}"); sb.Append("}"); CompilerEngine engine = new CompilerEngine(); var response = engine.Compile(new CompileArgs { SourceCode = sb.ToString() }); string pathToDlls = Path.GetDirectoryName(new Uri(Assembly.GetExecutingAssembly().CodeBase).LocalPath); var assemblyFilePath = Path.Combine(pathToDlls, response.AssemblyFileName); Console.WriteLine(AppDomain.CurrentDomain.FriendlyName); AppDomain.CurrentDomain.Load(response.LoadedStream.ToArray()); CoreExtensions.Host.InstallBuiltins(); var runner = new InMemoryNunitTestRunner().RunTests(new TestRunRequest { TestAssembly = Assembly.Load("CodeRank.CSharpProblems.Ruleset"), SourceAssemblyStream = response.LoadedStream }); Console.WriteLine(runner); Console.Read(); }
public void Compile() { using (new AppConfigManipulator()) { CompilerEngine.ExecuteInSeparateAppDomain( ce => { #if DEBUG ce.Configuration = "DEBUG"; #else ce.Configuration = "RELEASE"; #endif ce.CsProject = LangPhpTestCsProj; ce.OutDir = ce.BinaryOutputDir = Path.GetTempPath(); ce.Referenced.Clear(); var types = new[] { typeof(Func <,>), typeof(EmitContext), typeof(ThisExpression), typeof(CompilerEngine) }; { var tmp = Assembly.Load( "System.Runtime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"); ce.Referenced.Add(tmp.GetCodeLocation().FullName); } ce.Referenced.AddRange(types.Select(type => type.Assembly.GetCodeLocation().FullName)); ce.TranlationHelpers.Clear(); ce.ReferencedPhpLibsLocations.Clear(); ce.Check(); using (var comp = ce.PreparePhpCompiler()) { Console.WriteLine("Compilation"); var emitResult = comp.CompileCSharpProject(comp.Sandbox, ce.DllFilename); if (!emitResult.Success) { foreach (var i in emitResult.Diagnostics.Where(a => a.Severity == DiagnosticSeverity.Error)) { throw new Exception("Compilation error: " + i.GetMessage()); } } var translationInfo = comp.ParseCsSource(); translationInfo.CurrentAssembly = comp.CompiledAssembly; var assemblyTi = translationInfo.GetOrMakeTranslationInfo(comp.CompiledAssembly); var ecBaseDir = Path.Combine(Directory.GetCurrentDirectory(), assemblyTi.RootPath.Replace("/", "\\")); Console.WriteLine("Output root {0}", ecBaseDir); var translationState = new TranslationState(translationInfo); var translator = new Translator(translationState); translator.Translate(comp.Sandbox); // ============= var m = string.Join(", ", translator.Modules.Select(i => i.Name.Name).OrderBy(i => i)).ToArray(); //Assert.True(m == "Lang_Php_Test_Code_MyCode, Lang_Php_Test_Code_SampleEmptyClass", m); MethodTranslation(ModuleMycode, ClassMycode, "BasicMath1", translator); MethodTranslation(ModuleMycode, ClassMycode, "Collections", translator); MethodTranslation(ModuleMycode, ClassMycode, "CostantsAndVariables", translator); MethodTranslation(ModuleMycode, ClassMycode, "Filters", translator); MethodTranslation(ModuleMycode, ClassMycode, "StringConcats", translator); MethodTranslation(ModuleMycode, ClassMycode, "PregTest", translator); // ModuleTranslation("Lang_Php_Test_Code_SampleEmptyClass", translator); // ModuleTranslation("Lang_Php_Test_Code_BusinessClass", translator); // ModuleTranslation("Lang_Php_Test_Code_BusinessClassDefinedConst", translator); foreach (var moduleName in translator.Modules.Select(i => i.Name.Name)) { ModuleTranslation(moduleName, translator); } } ; }, AppDomain.CurrentDomain); } }
private static int Main(string[] args) { try { var tmp = ""; foreach (var s in args) { tmp += s; string[] s1 = s.Split(':'); string argID = s1[0].ToLower(); if (argID != "References".ToLower()) { CmdOptions.Add(argID, s.Replace(s1[0] + ":", "")); } else { References.Add(s.Replace(s1[0] + ":", "")); } } //File.WriteAllText("C:\\Users\\Emile\\Desktop\\dump.txt",tmp); var xTask = new CompilerEngine(); xTask.DebugEnabled = Convert.ToBoolean(CmdOptions["DebugEnabled".ToLower()]); Console.WriteLine("Loaded : DebugEnabled"); xTask.StackCorruptionDetectionEnabled = Convert.ToBoolean(CmdOptions["StackCorruptionDetectionEnabled".ToLower()]); Console.WriteLine("Loaded : StackCorruptionDetectionEnabled"); xTask.DebugMode = CmdOptions["DebugMode".ToLower()]; Console.WriteLine("Loaded : DebugMode"); xTask.TraceAssemblies = null; Console.WriteLine("Loaded : TraceAssemblies"); xTask.DebugCom = Convert.ToByte(CmdOptions["DebugCom".ToLower()]); Console.WriteLine("Loaded : DebugCom"); xTask.UseNAsm = Convert.ToBoolean(CmdOptions["UseNAsm".ToLower()]); Console.WriteLine("Loaded : UseNAsm"); xTask.OutputFilename = CmdOptions["OutputFilename".ToLower()];; Console.WriteLine("Loaded : OutputFilename"); xTask.EnableLogging = Convert.ToBoolean(CmdOptions["EnableLogging".ToLower()]);; Console.WriteLine("Loaded : EnableLogging"); xTask.EmitDebugSymbols = Convert.ToBoolean(CmdOptions["EmitDebugSymbols".ToLower()]);; Console.WriteLine("Loaded : EmitDebugSymbols"); xTask.IgnoreDebugStubAttribute = Convert.ToBoolean(CmdOptions["IgnoreDebugStubAttribute".ToLower()]); Console.WriteLine("Loaded : IgnoreDebugStubAttribute"); xTask.References = References.ToArray(); Console.WriteLine("Loaded : References"); xTask.OnLogError = (m) => Console.Error.WriteLine("Error: {0}", m); xTask.OnLogWarning = (m) => Console.WriteLine("Warning: {0}", m); xTask.OnLogMessage = (m) => { Console.WriteLine("Message: {0}", m); }; xTask.OnLogException = (m) => Console.Error.WriteLine("Exception: {0}", m.ToString()); xTask.AssemblerLog = "Cosmos.Assembler.log"; if (xTask.Execute()) { Console.WriteLine("Executed OK"); // File.WriteAllText(@"e:\compiler.log", "OK"); return(0); } else { Console.WriteLine("Errorred"); // File.WriteAllText(@"e:\compiler.log", "Errored"); return(2); } } catch (Exception E) { // Console.Out.Flush(); // File.WriteAllText("./ErrorDump.txt",E.ToString() + " " + E.Source); Console.WriteLine("Error occurred: " + E.ToString()); // File.WriteAllText(@"e:\compiler.log", "Exception: " + E.ToString()); return(1); } }
public static int Run(string[] args, Action <string> logMessage, Action <string> logError) { if (args == null) { throw new ArgumentNullException("args"); } if (logMessage == null) { throw new ArgumentNullException("logMessage"); } if (logError == null) { throw new ArgumentNullException("logError"); } try { var tmp = ""; foreach (var s in args) { tmp += s; string[] s1 = s.Split(':'); string argID = s1[0].ToLower(); if (argID != "References".ToLower()) { CmdOptions.Add(argID, s.Replace(s1[0] + ":", "")); } else { References.Add(s.Replace(s1[0] + ":", "")); } } var xTask = new CompilerEngine(); xTask.DebugEnabled = Convert.ToBoolean(CmdOptions["DebugEnabled".ToLower()]); logMessage("Loaded : DebugEnabled"); xTask.StackCorruptionDetectionEnabled = Convert.ToBoolean(CmdOptions["StackCorruptionDetectionEnabled".ToLower()]); logMessage("Loaded : StackCorruptionDetectionEnabled"); xTask.DebugMode = CmdOptions["DebugMode".ToLower()]; logMessage("Loaded : DebugMode"); xTask.TraceAssemblies = null; logMessage("Loaded : TraceAssemblies"); xTask.DebugCom = Convert.ToByte(CmdOptions["DebugCom".ToLower()]); logMessage("Loaded : DebugCom"); xTask.UseNAsm = Convert.ToBoolean(CmdOptions["UseNAsm".ToLower()]); logMessage("Loaded : UseNAsm"); xTask.OutputFilename = CmdOptions["OutputFilename".ToLower()];; logMessage("Loaded : OutputFilename"); xTask.EnableLogging = Convert.ToBoolean(CmdOptions["EnableLogging".ToLower()]);; logMessage("Loaded : EnableLogging"); xTask.EmitDebugSymbols = Convert.ToBoolean(CmdOptions["EmitDebugSymbols".ToLower()]);; logMessage("Loaded : EmitDebugSymbols"); xTask.IgnoreDebugStubAttribute = Convert.ToBoolean(CmdOptions["IgnoreDebugStubAttribute".ToLower()]); logMessage("Loaded : IgnoreDebugStubAttribute"); xTask.References = References.ToArray(); logMessage("Loaded : References"); xTask.OnLogError = logError; xTask.OnLogWarning = m => logMessage(String.Format("Warning: {0}", m)); xTask.OnLogMessage = logMessage; xTask.OnLogException = (m) => logError(String.Format("Exception: {0}", m.ToString())); xTask.AssemblerLog = "Cosmos.Assembler.log"; if (xTask.Execute()) { logMessage("Executed OK"); // File.WriteAllText(@"e:\compiler.log", "OK"); return(0); } else { logMessage("Errorred"); // File.WriteAllText(@"e:\compiler.log", "Errored"); return(2); } } catch (Exception E) { logError(String.Format("Error occurred: " + E.ToString())); return(1); } }