| public Compile ( string input ) : CompiledMethod | ||
| input | string | |
| return | CompiledMethod | |
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);
}
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 DebuggerWindow(PluginContext context, String hackPath)
{
this.InitializeComponent();
Trace.Listeners.Add(this.listener);
var compilerSettings = new CompilerSettings
{
Unsafe = true,
};
compilerSettings.AssemblyReferences.Add("System.dll");
compilerSettings.AssemblyReferences.Add("System.Core.dll");
compilerSettings.AssemblyReferences.Add(typeof(MessageBox).Assembly.CodeBase); // PresentationFramework.dll
compilerSettings.AssemblyReferences.Add(Path.Combine(hackPath, "SharpCraft.dll"));
var compilerContext = new CompilerContext(compilerSettings, new DebuggerReportPrinter());
evaluator = new Evaluator(compilerContext);
evaluator.Compile("using System;");
evaluator.Compile("using TinkerWorX.SharpCraft;");
CompositionTarget.Rendering += CompositionTarget_Rendering;
}
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);
}
}
public ScriptResult Execute(string code, string[] scriptArgs, AssemblyReferences references, IEnumerable<string> namespaces,
ScriptPackSession scriptPackSession)
{
references.PathReferences.UnionWith(scriptPackSession.References);
SessionState<Evaluator> sessionState;
if (!scriptPackSession.State.ContainsKey(SessionKey))
{
Logger.Debug("Creating session");
var context = new CompilerContext(new CompilerSettings
{
AssemblyReferences = references.PathReferences.ToList()
}, new ConsoleReportPrinter());
var evaluator = new Evaluator(context);
var builder = new StringBuilder();
foreach (var ns in namespaces.Union(scriptPackSession.Namespaces).Distinct())
{
builder.AppendLine(string.Format("using {0};", ns));
}
evaluator.Compile(builder.ToString());
var parser = new SyntaxParser();
var parseResult = parser.Parse(code);
var host = _scriptHostFactory.CreateScriptHost(new ScriptPackManager(scriptPackSession.Contexts), scriptArgs);
MonoHost.SetHost((ScriptHost)host);
evaluator.ReferenceAssembly(typeof(MonoHost).Assembly);
evaluator.InteractiveBaseClass = typeof(MonoHost);
if (parseResult.Declarations != null)
{
evaluator.Compile(parseResult.Declarations);
code = null;
}
if (parseResult.Evaluations != null)
{
code = parseResult.Evaluations;
}
sessionState = new SessionState<Evaluator>
{
References = references,
Session = evaluator
};
scriptPackSession.State[SessionKey] = sessionState;
}
else
{
Logger.Debug("Reusing existing session");
sessionState = (SessionState<Evaluator>)scriptPackSession.State[SessionKey];
var newReferences = sessionState.References == null ? references : references.Except(sessionState.References);
foreach (var reference in newReferences.PathReferences)
{
Logger.DebugFormat("Adding reference to {0}", reference);
sessionState.Session.LoadAssembly(reference);
}
sessionState.References = newReferences;
var parser = new SyntaxParser();
var parseResult = parser.Parse(code);
if (parseResult.Declarations != null)
{
var compiledMethod = sessionState.Session.Compile(parseResult.Declarations);
return new ScriptResult();
//code = parseResult.Declarations;
}
//var newUsings = sessionState.References == null || !sessionState.References.Any() ? distinctReferences : distinctReferences.Except(sessionState.References);
}
Logger.Debug("Starting execution");
try
{
if (code != null)
{
object scriptResult;
bool resultSet;
var result = sessionState.Session.Evaluate(code, out scriptResult, out resultSet);
Logger.Debug("Finished execution");
return new ScriptResult { ReturnValue = scriptResult };
}
}
catch (Exception e)
{
Logger.Error(e.Message);
}
return new ScriptResult();
}
