public Task <bool> EvaluateExpression(string expression, string code, EvalResult result)
{
EnsureConfigured();
try
{
object retResult;
bool hasResult;
printer.Reset();
if (!String.IsNullOrEmpty(code))
{
var ret = eval.Evaluate(code, out retResult, out hasResult);
}
result.Result = eval.Evaluate(expression);
return(Task.FromResult(true));
}
catch (Exception ex)
{
Log.Error($"Error creating a new instance of {expression}");
if (printer.Messages.Count != 0)
{
result.Messages = printer.Messages.ToArray();
}
else
{
result.Messages = new EvalMessage[] { new EvalMessage("error", ex.ToString()) };
}
if (!result.HasResult && result.Messages.Length == 0)
{
result.Messages = new EvalMessage[] { new EvalMessage("error", "Internal Error") };
}
eval = null;
}
return(Task.FromResult(false));
}
async Task <bool> Evaluate(string code, EvalResult result, string initCode, bool retryOnError)
{
try
{
printer.Reset();
if (initCode != null)
{
eval.Evaluate(initCode, out object retResult, out bool result_set);
}
result.Result = eval.Evaluate(code);
return(true);
}
catch (Exception ex)
{
if (retryOnError)
{
eval = null;
EnsureConfigured();
return(await Evaluate(code, result, initCode, false));
}
Log.Error($"Error evalutaing code");
eval = null;
if (printer.Messages.Count != 0)
{
result.Messages = printer.Messages.ToArray();
}
else
{
result.Messages = new[] { new EvalMessage("error", ex.ToString()) };
}
return(false);
}
}
static void MonoCSharp_Test()
{
string className = GetClass();
string code = GetCode(className);
evaluator.Compile(code);
dynamic script = evaluator.Evaluate("new " + className + "();");
int result = script.Sum(1, 2);
}
public Task <bool> EvaluateCode(string code, EvalResult result)
{
if (string.IsNullOrEmpty(code))
{
return(Task.FromResult(false));
}
EnsureConfigured();
try
{
printer.Reset();
eval.Evaluate(code, out object retResult, out bool result_set);
result.Result = retResult;
return(Task.FromResult(true));
}
catch (Exception ex)
{
Log.Error($"Error evalutaing code");
eval = null;
if (printer.Messages.Count != 0)
{
result.Messages = printer.Messages.ToArray();
}
else
{
result.Messages = new[] { new EvalMessage("error", ex.ToString()) };
}
return(Task.FromResult(false));
}
}
static void Main(string[] args)
{
var compilerContext = new CompilerContext(new CompilerSettings(), new ConsoleReportPrinter());
var evaluator = new Evaluator(compilerContext);
// Make it reference our own assembly so it can use IFoo
evaluator.ReferenceAssembly(typeof(IFoo).Assembly);
// Feed it some code
evaluator.Compile(
@"
public class Foo : MonoCompilerDemo.IFoo
{
public string Bar(string s) { return s.ToUpper(); }
}");
for (; ; )
{
string line = Console.ReadLine();
if (line == null) break;
object result;
bool result_set;
evaluator.Evaluate(line, out result, out result_set);
if (result_set) Console.WriteLine(result);
}
}
public Cs(Bot bot)
{
this.bot = bot;
evaluator = new Evaluator(new CompilerContext(new CompilerSettings { Unsafe = true }, reportPrinter))
{
DescribeTypeExpressions = true,
WaitOnTask = true
};
bool resultSet;
object result;
evaluator.Evaluate("using System; using System.Linq; using System.Collections.Generic; using System.Text;", out result, out resultSet);
}
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>;
}
static Evaluator()
{
var eval = new Mono.CSharp.Evaluator(new CompilerContext(new CompilerSettings(), new Printer()));
try
{
eval.Evaluate("2+2");
isEvaluationSupported = true;
}
catch (Exception ex)
{
isEvaluationSupported = false;
}
}
static Evaluator()
{
var eval = new Mono.CSharp.Evaluator(new CompilerContext(new CompilerSettings(), new Printer()));
try
{
eval.Evaluate("2+2");
isEvaluationSupported = true;
}
catch (Exception ex)
{
Log.Error("Runtime evaluation not supported, did you set the mtouch option --enable-repl?");
isEvaluationSupported = false;
}
}
public Task <bool> EvaluateExpression(string expression, string code, EvalResult result)
{
EnsureConfigured();
try
{
object retResult;
bool hasResult;
if (!String.IsNullOrEmpty(code))
{
var ret = eval.Evaluate(code, out retResult, out hasResult);
}
result.Result = eval.Evaluate(expression);
return(Task.FromResult(true));
}
catch (Exception ex)
{
Log.Exception(ex);
Log.Error($"Unhandled error creating new instance of {expression}");
result.Messages = new EvalMessage[] { new EvalMessage {
MessageType = "error", Text = ex.ToString()
} };
}
return(Task.FromResult(false));
}
public Task <bool> CreateTypeInstance(string typeName, EvalResult result)
{
EnsureConfigured();
try
{
result.Result = eval.Evaluate($"new {typeName} ()");
return(Task.FromResult(true));
}
catch (Exception ex)
{
Log.Exception(ex);
Log.Error($"Unhandled error creating new instance of {typeName}");
result.Messages = new EvalMessage[] { new EvalMessage {
MessageType = "error", Text = ex.ToString()
} };
}
return(Task.FromResult(false));
}
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 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");
}
}
}
/// <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;
}
void InitIfNeeded()
{
if (eval == null) {
Log ("INIT EVAL");
var settings = new CompilerSettings ();
settings.AddConditionalSymbol ("__Continuous__");
settings.AddConditionalSymbol ("DEBUG");
PlatformSettings (settings);
var context = new CompilerContext (settings, printer);
eval = new Evaluator (context);
//
// Add References to get UIKit, etc. Also add a hook to catch dynamically loaded assemblies.
//
AppDomain.CurrentDomain.AssemblyLoad += (_, e) => {
Log ("DYNAMIC REF {0}", e.LoadedAssembly);
AddReference (e.LoadedAssembly);
};
foreach (var a in AppDomain.CurrentDomain.GetAssemblies ()) {
Log ("STATIC REF {0}", a);
AddReference (a);
}
//
// Add default namespaces
//
object res;
bool hasRes;
eval.Evaluate ("using System;", out res, out hasRes);
eval.Evaluate ("using System.Collections.Generic;", out res, out hasRes);
eval.Evaluate ("using System.Linq;", out res, out hasRes);
PlatformInit ();
}
}
private Tuple<string, bool, object> EvaluateHelper(Evaluator ev, string input, CancellationToken canceller)
{
using (canceller.Register(Thread.CurrentThread.Abort)) {
bool result_set;
object result;
input = ev.Evaluate(input, out result, out result_set);
return Tuple.Create(input, result_set, result);
}
}
