public Shell(MainWindow container) : base() { this.container = container; WrapMode = WrapMode.Word; CreateTags (); Pango.FontDescription font_description = new Pango.FontDescription(); font_description.Family = "Monospace"; ModifyFont(font_description); TextIter end = Buffer.EndIter; Buffer.InsertWithTagsByName (ref end, "Mono C# Shell, type 'help;' for help\n\nEnter statements or expressions below.\n", "Comment"); ShowPrompt (false); report = new Report (new ConsoleReportPrinter ()); evaluator = new Evaluator (new CompilerSettings (), report); evaluator.DescribeTypeExpressions = true; evaluator.InteractiveBaseClass = typeof (InteractiveGraphicsBase); evaluator.Run ("LoadAssembly (\"System.Drawing\");"); evaluator.Run ("using System; using System.Linq; using System.Collections; using System.Collections.Generic; using System.Drawing;"); if (!MainClass.Debug){ GuiStream error_stream = new GuiStream ("Error", (x, y) => Output (x, y)); StreamWriter gui_output = new StreamWriter (error_stream); gui_output.AutoFlush = true; Console.SetError (gui_output); GuiStream stdout_stream = new GuiStream ("Stdout", (x, y) => Output (x, y)); gui_output = new StreamWriter (stdout_stream); gui_output.AutoFlush = true; Console.SetOut (gui_output); } }
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"); }
/// <summary> /// Initializes the evaluator and includes a few basic System libraries /// </summary> public Runner() { _report = new Report(new Printer(this)); _settings = new CommandLineParser(_report).ParseArguments(new string[] {}); _eval = new Evaluator(_settings, _report); _eval.Run("using System;"); _eval.Run("using System.Linq;"); _eval.Run("using System.Collections.Generic;"); }
/// <summary> /// Initializes the evaluator and includes a few basic System libraries /// </summary> public Runner() { _report = new Report(new Printer(this)); _settings = new CommandLineParser(_report).ParseArguments (new string[] {}); _eval = new Evaluator(_settings, _report); _eval.ReferenceAssembly(typeof(System.Linq.Enumerable).Assembly); _eval.Run("using System;"); _eval.Run("using System.Collections.Generic;"); _eval.Run("using System.Linq;"); }
private void DemandCompiler() { if (Engine != null) { return; } Engine = new Evaluator(new CompilerContext(new CompilerSettings(), new ConsoleReportPrinter())); Engine.Run("using System;"); Engine.Run("using System.Collections.Generic;"); Engine.Run("var dictionary = new Dictionary<string, dynamic>();"); Dictionary = Engine.Evaluate("dictionary") as IDictionary<string, dynamic>; }
private void resetEvaluator() { m_errorStream = new StringBuilder(); //StreamReader sr = TextWriter tw = new StringWriter(m_errorStream); var ctx = new Mono.CSharp.CompilerContext( new Mono.CSharp.CompilerSettings() { AssemblyReferences = new List <string>() { typeof(ILMath).Assembly.FullName, typeof(System.Drawing.PointF).Assembly.FullName, typeof(System.Linq.Queryable).Assembly.FullName }, //Unsafe = true }, new StreamReportPrinter(tw)); var eval = new Mono.CSharp.Evaluator(ctx); // reset line colors (thread safe) ILNumerics.Drawing.Plotting.ILLinePlot.NextColors = new ILColorEnumerator(); string m_head = @" using System; using System.Drawing; using System.Collections.Generic; using System.Linq; using ILNumerics; using ILNumerics.Drawing; using ILNumerics.Drawing.Plotting;"; eval.Run(m_head); m_evaluator = eval; }
// 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); }
private void AddDefaultNamespaces(Evaluator eval) { eval.Run("using System;"); eval.Run("using System.Collections.Generic;"); eval.Run("using System.Linq;"); eval.Run("using Db4objects.Db4o;"); eval.Run("using Db4objects.Db4o.Linq;"); eval.Run("using Db4oTutorial.ExampleRunner.Demos;"); eval.Run("using Console = Db4oTutorial.ExampleRunner.ConsoleOutReplacement;"); }
void Eval_Void_With_Pure_Mono() { Mono.CSharp.Evaluator evaluator = CSScript.MonoEvaluator.GetService(); //Note: Calling evaluator.ReferenceAssembly will trigger the error as the ExecutingAssembly //(as one of all AddDomain static assemblies) is already referenced during //CSScript.Evaluator initialization. //However the call CSScript.Evaluator.ReferenceAssembly is safe as CSScript.Evaluator //keeps track of the assemblies and does not reference one again if it is already there. //evaluator.ReferenceAssembly (Assembly.GetExecutingAssembly()); this.Name = "ScriptTester"; evaluator.Run("System.Console.WriteLine(\"Host Name = \" + HostApp.Instance.Name);"); }
private static void Main(string[] args) { Console.WriteLine("Starting Simple C# REPL, enter q to quit"); var evaluator = new Evaluator(new CompilerContext( new CompilerSettings(), new ConsoleReportPrinter())); evaluator.ReferenceAssembly(Assembly.GetExecutingAssembly()); evaluator.Run("using System;"); evaluator.Run("using SimpleREPL;"); while (true) { Console.Write("> "); var input = Console.ReadLine(); input = input.TrimStart('>', ' '); if (input.ToLower() == "q") { return; } try { if (input.EndsWith(";")) { evaluator.Run(input); } else { var output = evaluator.Evaluate(input); Console.WriteLine(output); } } catch { Console.WriteLine("Error in input"); } } }
public static Evaluator Create() { var evaluator = new Evaluator(new CompilerContext(new CompilerSettings(), new ConsoleReportPrinter())); evaluator.ReferenceAssembly(typeof(CodeEvaluator).Assembly); // Rx Core evaluator.ReferenceAssembly(typeof(ObservableExtensions).Assembly); // Rx Interfaces evaluator.ReferenceAssembly(typeof(IEventSource<>).Assembly); // Rx Linq evaluator.ReferenceAssembly(typeof(Observable).Assembly); evaluator.Run(@" using System; using System.Linq; using System.Linq.Expressions; using System.Reactive; using System.Reactive.Linq; using Sensorium; "); return evaluator; }
public IController Create(RequestContext requestContext, Type controllerType) { CompilerSettings settings = new CompilerSettings(); Report report = new Report(new ConsoleReportPrinter()); Evaluator eval = new Evaluator(settings, report); object instance = null; bool instanceCreated = false; eval.ReferenceAssembly(typeof(Controller).Assembly); foreach (Assembly assembly in assemblies) { eval.ReferenceAssembly(assembly); } string controllerName = GetControllerName(requestContext, controllerType); string path = pathProvider.GetPath(requestContext, controllerName); CSharpControllerFile controllerFile = CSharpControllerFile.Parse(File.ReadAllText(path)); eval.Run(controllerFile.ClassSource); eval.Evaluate("new " + controllerName + "();", out instance, out instanceCreated); return (IController)instance; }
private static void LoadPlugins(Server server) { // TODO: Make this better // Dynamic plugins var eval = new Evaluator(new CompilerContext(new CompilerSettings(), new ConsoleReportPrinter())); eval.ReferenceAssembly(typeof(Plugin).Assembly); eval.ReferenceAssembly(typeof(Command).Assembly); eval.ReferenceAssembly(typeof(MinecraftServer).Assembly); eval.InteractiveBaseClass = typeof(ScriptPluginBase); ScriptPluginBase.Server = server; foreach (var plugin in Directory.GetFiles(Path.Combine("plugins", "scripts"), "*.csx")) eval.Run(File.ReadAllText(plugin)); foreach (var plugin in Directory.GetFiles(Path.Combine("plugins", "scripts"), "*.csc")) // TODO: Upgrade Mono.CSharp to Mono 3.0 to support Roslyn-style inline classes in csx files eval.Compile(File.ReadAllText(plugin)); // Load plugins var types = AppDomain.CurrentDomain.GetAssemblies().Select(a => a.GetTypes()) .Aggregate((a, b) => a.Concat(b).ToArray()).Where(t => !t.IsAbstract && typeof(Plugin).IsAssignableFrom(t)); foreach (var type in types) { var plugin = (Plugin)Activator.CreateInstance(type); plugin.OnInitialize(server); } }
private void resetEvaluator() { m_errorStream = new StringBuilder(); //StreamReader sr = TextWriter tw = new StringWriter(m_errorStream); var ctx = new Mono.CSharp.CompilerContext( new Mono.CSharp.CompilerSettings() { AssemblyReferences = new List<string>() { typeof(ILMath).Assembly.FullName, typeof(System.Drawing.PointF).Assembly.FullName, typeof(System.Linq.Queryable).Assembly.FullName }, //Unsafe = true }, new StreamReportPrinter(tw)); var eval = new Mono.CSharp.Evaluator(ctx); eval.InteractiveBaseClass = typeof(ILShellBaseClass); // reset line colors (thread safe) ILNumerics.Drawing.Plotting.ILLinePlot.NextColors = new ILColorEnumerator(); string m_head = @" using System; using System.Drawing; using System.Collections.Generic; using System.Linq; using ILNumerics; using ILNumerics.Drawing; using ILNumerics.Drawing.Plotting;"; eval.Run(m_head); m_evaluator = eval; }
public R2Repl(string[] args) { this.e = new Evaluator(new CompilerContext( new CompilerSettings { WarningLevel = 0, ShowFullPaths = true }, new ConsoleReportPrinter())); e.Run("LoadAssembly(\"Mono.Posix\")"); e.Run("LoadAssembly(\"r2pipe\")"); e.Run("LoadAssembly(\"Newtonsoft.Json\")"); e.Run("using System;"); e.Run("using System.Collections;"); e.Run("using System.Collections.Generic;"); e.Run("using Mono.Unix;"); e.Run("using Newtonsoft.Json;"); e.Run(@" /* example */ public class Opcode { public string opcode; public string family; public string type; public string esil; public int address; public int size; } public class r2w { public r2pipe.IR2Pipe Instance; public r2w() { Instance = new r2pipe.RlangPipe(); } public r2w(string file) { Instance = new r2pipe.R2Pipe(file); } public string cmd(string cmd) { return Instance.RunCommand(cmd).Trim(); } public dynamic cmdj(string cmd) { return JsonConvert.DeserializeObject(this.cmd(cmd)); } public Opcode[] Opcodes(int n) { var ops = new List<Opcode>(); foreach (var op in cmdj(""aoj 10"")) { ops.Add (op.ToObject<Opcode>()); } return ops.ToArray(); } public void Seek(string addr) { cmd(""s "" + addr); } } "); args = ParseArgs(args); if (args == null) { /* exit */ return; } if (args.Length > 0) { e.Run("var r2 = new r2w(\""+args[0]+"\");"); } else { try { e.Run("var r2 = new r2w();"); } catch (Exception _) { Console.WriteLine(@" Cannot find R2PIPE environment. See: csharp-r2 -h Run this from r2 like this: '#!pipe mono main.exe' "); return; } } if (RunArgs()) { this.shell = new CSharpShell (e); } }
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(); }
private void CreateEvaluationObject(Evaluator eval, string theCode) { var code = CreateCode(theCode); eval.Run(code); }
private void Run() { string input = this._template.Content; // Ask thread pool for a new thread to do the work. Thread thread = null; Task<StringBuilder> task = Task.Factory.StartNew<StringBuilder> (() => { //Capture the thread, so we can abort worker thread if it hangs. thread = Thread.CurrentThread; // Setup error reporting. using (StringWriter reportwriter = new StringWriter ()) { try { string evalcode = string.Empty; Report report = new Report (new Mono.CSharp.StreamReportPrinter (reportwriter)); // Create new evaluator instance. var evaluator = new Evaluator (new CompilerSettings (), report); // Reference current assembly. evaluator.ReferenceAssembly (Assembly.GetExecutingAssembly ()); evaluator.ReferenceAssembly (typeof (SNDK.Convert).Assembly); // Using. evaluator.Run ("using System; using System.Collections.Generic; using SorentoLib; using SNDK"); foreach (SorentoLib.Addins.IRuntime runtime in AddinManager.GetExtensionObjects (typeof(SorentoLib.Addins.IRuntime))) { evaluator.ReferenceAssembly (runtime.Assembly); evaluator.Run ("using " + runtime.Assembly.GetName ().Name + ";"); } // Anonymous methods. evalcode += "SorentoLib.Parser.Hooks.Commands.Print.Delegate Print = delegate (object Value) { SorentoLib.Parser.Hooks.Commands.Print.Method (Value);};\n"; // Variables int counter = 0; Parser.Hooks.Variables = this._variables; foreach (ParserVariable variable in this._variables) { evalcode += variable.Value.GetType ().FullName + " " + variable.Name + " = (" + variable.Value.GetType ().FullName + ")SorentoLib.Parser.Hooks.Variables[" + counter + "].Value;\n"; counter++; } evalcode += input; // Output. Parser.Hooks.Errors = null; Parser.Hooks.Output = new StringBuilder (); // Run evaluation. evaluator.Run (evalcode); // Cleanup. evaluator = null; report = null; evalcode = null; if (reportwriter.ToString () != string.Empty) { Console.WriteLine ("!!!!" + reportwriter.ToString ()); Parser.Hooks.Errors = new ParserError (reportwriter.ToString ()); } } catch (Exception e) { Console.WriteLine (e); string interactive = string.Empty; interactive += "{interactive}(0,0): error SE0000: " + e.Message; interactive += reportwriter.ToString (); Parser.Hooks.Errors = new ParserError (interactive); } this._errors = Hooks.Errors; // this._output = Parser.Hooks.Output; return Parser.Hooks.Output; } } ); if (!task.IsCompleted) { if (!task.Wait (25000)) { thread.Abort (); throw new Exceptions.Parser ("TEMPLATE PARSER TIMEOUT"); } } if (this._errors != null) { string message = string.Empty; bool thr = false; message += "PARSER EXCEPTION:<br>\n"; foreach (SorentoLib.ParserError.Error error in this._errors.Errors) { if (error.Type == Enums.ParserErrorType.Error) { thr = true; } message += "Line: "+ error.Line + " - "+ error.Code +" - "+ error.Text +"<br>\n"; } if (thr) { throw new Exceptions.Parser (message); } } this._output = task.Result; // task.Dispose (); }
public void SameSettings () { var ctx = new CompilerContext (settings, new AssertReportPrinter ()); var evaluator2 = new Evaluator (ctx); evaluator2.Run ("int i = 0;"); }
/// <summary> /// Executes the code. /// </summary> /// <returns><c>null</c> if successful, otherwise, a <see cref="string"/></returns> /// <param name="code">Code to execute</param> /// <exception cref="InvalidProgramException"> /// Is thrown when a program contains invalid CIL instructions or metadata. /// </exception> public string ExecuteCode(string source, Project project) { Trace.Log(TraceEventType.Information, "source=\"{0}\", project.Name=\"{0}\"", source.Length < 48 ? source : string.Format("string({0})", source.Length), project == null ? "(null)" : project.Name); Project.CodeUsings = CSEvaluator.GetUsing(); Settings.AssemblyReferences = new System.Collections.Generic.List<string>(Project.ReferencePaths); CompilerOutput = new StringBuilder(); Context = new CompilerContext(Settings, new StreamReportPrinter(new StringWriter(CompilerOutput))); CSEvaluator = new Evaluator(Context); CSEvaluator.Run(project.CodeUsings); string r = string.Empty; try { string prefix = "EntityContext RootContext = EntityContext.Root; EntityContext CurrentContext = EntityContext.Current; ICollection<Scene> _scenes = RootContext.OfType<Scene>(); Scene[] Scenes = new Scene[_scenes.Count]; _scenes.CopyTo(Scenes, 0);"; string code = prefix + source; if (code.Contains(";") && !CSEvaluator.Run(code)) { string error = string.Format("Evaluator.Run() == false (source = \"{0}\")", source.Length < 48 ? source : string.Format("string({0})", source.Length)); Trace.Log(TraceEventType.Error, error); throw new InvalidProgramException(error); } else { object result; bool result_set; string input; source += ";"; if (!CSEvaluator.Run(prefix)) { string error = string.Format("Evaluator.Run() == false (prefix = \"{0}\")", prefix.Replace("\n", " ")); Trace.Log(TraceEventType.Error, error); throw new InvalidProgramException(error); } input = CSEvaluator.Evaluate(source, out result, out result_set); if (input != null) { string error = string.Format("Evaluator.Evaluate() != null (code = \"{0}\") = \"{1}\"", source.Replace("\n", " "), input.Replace("\n", " ")); Trace.Log(TraceEventType.Error, error); throw new InvalidProgramException(error); } if (result_set) r += result != null ? result.ToString() : "(null)"; } } catch (Exception ex) { string error = string.Format("Caught exception: " + ex.GetType().Name + ": " + ex.Message); Trace.Log(TraceEventType.Error, error); Console.Error.WriteLine((char)27 + "[31m" + ex.ToString()); } return r.Length > 0 ? string.Concat(r, "\n") : string.Empty; }