private static void InitializeEvaluator() { _Interop.VarStorage["ReplVersion"] = typeof(Program).Assembly.GetName().Version; var settings = new CompilerSettings() { StdLib = true }; var reportPrinter = new ConsoleReportPrinter(); var ctx = new CompilerContext(settings, reportPrinter); evaluator = new Evaluator(ctx); evaluator.ReferenceAssembly(typeof(_Interop).Assembly); evaluator.Run( @" using System; using System.Collections.Generic; using System.Linq; using System.Text; "); evaluator.Run("var _v = _Interop.VarStorage;"); evaluator.Run("var _h = _Interop.History;"); evaluator.Run("_Interop.VoidMethod exit = _Interop.Exit;"); evaluator.Run("_Interop.ReturnStringListMethod globals = _Interop.GetGlobals"); }
public int Run() { // Enable unsafe code by default var settings = new CompilerSettings () { Unsafe = true }; var startup_files = new string [0]; settings.SourceFiles.Clear (); ReportPrinter printer= new ConsoleReportPrinter (); var eval = new Evaluator (new CompilerContext (settings, printer)); eval.InteractiveBaseClass = typeof (InteractiveBaseShell); eval.DescribeTypeExpressions = true; eval.WaitOnTask = true; CSharpShell shell; #if !ON_DOTNET if (attach.HasValue) { shell = new ClientCSharpShell (eval, attach.Value); } else if (agent != null) { new CSharpAgent (eval, agent, agent_stderr).Run (startup_files); return 0; } else #endif { shell = new CSharpShell (eval, console); } return shell.Run (startup_files); }
static int Main (string [] args) { var cmd = new CommandLineParser (Console.Out); cmd.UnknownOptionHandler += HandleExtraArguments; // Enable unsafe code by default var settings = new CompilerSettings () { Unsafe = true }; if (!cmd.ParseArguments (settings, args)) return 1; var startup_files = new string [settings.SourceFiles.Count]; int i = 0; foreach (var source in settings.SourceFiles) startup_files [i++] = source.FullPathName; settings.SourceFiles.Clear (); TextWriter agent_stderr = null; ReportPrinter printer; if (agent != null) { agent_stderr = new StringWriter (); printer = new StreamReportPrinter (agent_stderr); } else { printer = new ConsoleReportPrinter (); } var eval = new Evaluator (new CompilerContext (settings, printer)); eval.InteractiveBaseClass = typeof (InteractiveBaseShell); eval.DescribeTypeExpressions = true; eval.WaitOnTask = true; CSharpShell shell; #if !ON_DOTNET if (attach.HasValue) { shell = new ClientCSharpShell (eval, attach.Value); } else if (agent != null) { new CSharpAgent (eval, agent, agent_stderr).Run (startup_files); return 0; } else #endif { shell = new CSharpShell (eval); } return shell.Run (startup_files); }
/// <summary> /// Optional initialization for the Evaluator. /// </summary> /// <remarks> /// Initializes the Evaluator with the command line /// options that would be processed by the command /// line compiler. Only the first call to /// InitAndGetStartupFiles or Init will work, any future /// invocations are ignored. /// /// You can safely avoid calling this method if your application /// does not need any of the features exposed by the command line /// interface. /// /// This method return an array of strings that contains any /// files that were specified in `args'. /// /// If the unknownOptionParser is not null, this function is invoked /// with the current args array and the index of the option that is not /// known. A value of true means that the value was processed, otherwise /// it will be reported as an error /// </remarks> public static string [] InitAndGetStartupFiles(string [] args, Func <string [], int, int> unknownOptionParser) { lock (evaluator_lock) { if (inited) { return(new string [0]); } CompilerCallableEntryPoint.Reset(); var crp = new ConsoleReportPrinter(); driver = Driver.Create(args, false, unknownOptionParser, crp); if (driver == null) { throw new Exception("Failed to create compiler driver with the given arguments"); } crp.Fatal = driver.fatal_errors; ctx = driver.ctx; RootContext.ToplevelTypes = new ModuleContainer(ctx); var startup_files = new List <string> (); foreach (CompilationUnit file in Location.SourceFiles) { startup_files.Add(file.Path); } CompilerCallableEntryPoint.PartialReset(); var importer = new ReflectionImporter(ctx.BuildinTypes); loader = new DynamicLoader(importer, ctx); RootContext.ToplevelTypes.SetDeclaringAssembly(new AssemblyDefinitionDynamic(RootContext.ToplevelTypes, "temp")); loader.LoadReferences(RootContext.ToplevelTypes); ctx.BuildinTypes.CheckDefinitions(RootContext.ToplevelTypes); RootContext.ToplevelTypes.InitializePredefinedTypes(); RootContext.EvalMode = true; inited = true; return(startup_files.ToArray()); } }
// This method evaluates the given code and returns a CompilerOutput object public static CompilerOutput evaluateCode(string code) { CompilerOutput compilerOutput = new CompilerOutput (); /* var compilerContext = new CompilerContext(new CompilerSettings(), new ConsoleReportPrinter()); var evaluator = new Evaluator(compilerContext); */ var reportWriter = new StringWriter(); var settings = new CompilerSettings(); var printer = new ConsoleReportPrinter(reportWriter); var compilerContext = new CompilerContext (settings, printer); var reports = new Report(compilerContext, printer); var evaluator = new Evaluator(compilerContext); var myString = ""; originalConsoleOut_global = Console.Out; // preserve the original stream using(var writer = new StringWriter()) { Console.SetOut(writer); evaluator.Run (code); evaluator.Run ("MainClass m1 = new MainClass(); m1.Main();"); //bConsole.WriteLine ("after executing code"); if (reports.Errors > 0) { Console.WriteLine ("reportWriter.ToString: \n" + reportWriter.ToString ()); compilerOutput.errors = reportWriter.ToString (); } writer.Flush(); // make sure everything is written out of consule myString = writer.GetStringBuilder().ToString(); compilerOutput.consoleOut = myString; } Console.SetOut(originalConsoleOut_global); // restore Console.Out return compilerOutput; }
/////////////////////////////////////////////////////////////////////// private void Initialize() { CompilerSettings sett = new CompilerSettings(); ReportPrinter prnt = new ConsoleReportPrinter(); // TODO programatically add references for all flynn assemblies sett.AssemblyReferences.Add("Flynn.Core.dll"); sett.AssemblyReferences.Add("Flynn.X10.dll"); sett.AssemblyReferences.Add("Flynn.Cron.dll"); sett.AssemblyReferences.Add("Flynn.Utilities.dll"); CompilerContext ctx = new CompilerContext(sett, prnt); _eval = new Evaluator(ctx); _eval.Run(Resources.CSharpEngine_InitUsings); _eval.Run(Resources.CSharpEngine_InitScript); }
/// <summary> /// Optional initialization for the Evaluator. /// </summary> /// <remarks> /// Initializes the Evaluator with the command line /// options that would be processed by the command /// line compiler. Only the first call to /// InitAndGetStartupFiles or Init will work, any future /// invocations are ignored. /// /// You can safely avoid calling this method if your application /// does not need any of the features exposed by the command line /// interface. /// /// This method return an array of strings that contains any /// files that were specified in `args'. /// /// If the unknownOptionParser is not null, this function is invoked /// with the current args array and the index of the option that is not /// known. A value of true means that the value was processed, otherwise /// it will be reported as an error /// </remarks> public static string [] InitAndGetStartupFiles (string [] args, Func<string [], int, int> unknownOptionParser) { lock (evaluator_lock){ if (inited) return new string [0]; CompilerCallableEntryPoint.Reset (); var crp = new ConsoleReportPrinter (); driver = Driver.Create (args, false, unknownOptionParser, crp); if (driver == null) throw new Exception ("Failed to create compiler driver with the given arguments"); crp.Fatal = driver.fatal_errors; ctx = driver.ctx; RootContext.ToplevelTypes = new ModuleContainer (ctx); var startup_files = new List<string> (); foreach (CompilationUnit file in Location.SourceFiles) startup_files.Add (file.Path); CompilerCallableEntryPoint.PartialReset (); var importer = new ReflectionImporter (ctx.BuildinTypes); loader = new DynamicLoader (importer, ctx); RootContext.ToplevelTypes.SetDeclaringAssembly (new AssemblyDefinitionDynamic (RootContext.ToplevelTypes, "temp")); loader.LoadReferences (RootContext.ToplevelTypes); ctx.BuildinTypes.CheckDefinitions (RootContext.ToplevelTypes); RootContext.ToplevelTypes.InitializePredefinedTypes (); RootContext.EvalMode = true; inited = true; return startup_files.ToArray (); } }
public static int Main (string[] args) { Location.InEmacs = Environment.GetEnvironmentVariable ("EMACS") == "t"; var crp = new ConsoleReportPrinter (); Driver d = Driver.Create (args, true, crp); if (d == null) return 1; crp.Fatal = d.fatal_errors; if (d.Compile () && d.Report.Errors == 0) { if (d.Report.Warnings > 0) { Console.WriteLine ("Compilation succeeded - {0} warning(s)", d.Report.Warnings); } Environment.Exit (0); return 0; } Console.WriteLine("Compilation failed: {0} error(s), {1} warnings", d.Report.Errors, d.Report.Warnings); Environment.Exit (1); return 1; }
static void Reset() { CompilerCallableEntryPoint.PartialReset (); RootContext.PartialReset (); // Workaround for API limitation where full message printer cannot be passed ReportPrinter printer; if (MessageOutput == Console.Out || MessageOutput == Console.Error){ var console_reporter = new ConsoleReportPrinter (MessageOutput); console_reporter.Fatal = driver.fatal_errors; printer = console_reporter; } else printer = new StreamReportPrinter (MessageOutput); ctx = new CompilerContext (new Report (printer)); RootContext.ToplevelTypes = new ModuleCompiled (ctx, true); // // PartialReset should not reset the core types, this is very redundant. // // if (!TypeManager.InitCoreTypes (ctx, null)) // throw new Exception ("Failed to InitCoreTypes"); // TypeManager.InitOptionalCoreTypes (ctx); Location.AddFile(null, FileName); Location.Initialize (); current_debug_name = FileName + (count++) + ".dll"; if (Environment.GetEnvironmentVariable ("SAVE") != null){ CodeGen.Init (current_debug_name, current_debug_name, false, ctx); } else CodeGen.InitDynamic (ctx, current_debug_name); }
void Init() { // workaround to load DLR types before Evaluator would want them var r = Microsoft.CSharp.RuntimeBinder.Binder.IsEvent(Microsoft.CSharp.RuntimeBinder.CSharpBinderFlags.BinaryOperationLogical, "gf", typeof(int)); var settings = new CompilerSettings(); var printer = new ConsoleReportPrinter(); eval = new Evaluator(new CompilerContext(settings, printer)); eval.ReferenceAssembly(typeof(REPL).Assembly); eval.Run("using System;"); eval.Run("using FOnline;"); eval.Run("using System.Collections.Generic;"); eval.Run("using System.Linq;"); statement = new StringBuilder(); }
static void Main(string[] args) { CSharpShell.InitStdOut(); CompilerSettings settings = new CompilerSettings() { Unsafe = true }; ConsoleReportPrinter printer = new ConsoleReportPrinter(); CSharpShell shell = new CSharpShell(() => new Evaluator(new CompilerContext(settings, printer)) { InteractiveBaseClass = typeof(InteractiveBase), DescribeTypeExpressions = true, WaitOnTask = true }); try { Syscall.unlink(args[0]); } catch {} UnixListener sock = new UnixListener(args[0]); sock.Start(); Syscall.chmod(args[0], FilePermissions.ACCESSPERMS); while (true) { NetworkStream s = new NetworkStream(sock.AcceptSocket(), true); Task.Run(() => { try { shell.ProcessConnection(s); } finally { s.Dispose(); } }); } }