public ExecuteExpression <T> CreateExpressionDelegate <T>(string expression, object functionClass)
{
ExecuteExpression <T> expressionDelegate = null;
DynamicMethodState methodState;
IExpressionCompiler compiler;
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
AppDomainSetup loSetup = new AppDomainSetup();
loSetup.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory;
AppDomain loAppDomain = AppDomain.CreateDomain("CompilerDomain", null, loSetup);
compiler = (IExpressionCompiler)loAppDomain.CreateInstanceFromAndUnwrap("ArcherFusion.ExpressionCompiler.dll", "ArcherFusion.ExpressionCompiler.CSharpExpressionCompiler");
try
{
methodState = compiler.CompileExpression(expression, functionClass.GetType(), typeof(T));
}
catch (CompileException e)
{
StringBuilder exceptionMessage = new StringBuilder();
foreach (CompilerError error in e.CompileErrors)
{
exceptionMessage.Append("Error# ").Append(error.ErrorNumber);
exceptionMessage.Append(", column ").Append(error.Column);
exceptionMessage.Append(", ").Append(error.ErrorText);
exceptionMessage.Append(Environment.NewLine);
}
throw new ApplicationException(exceptionMessage.ToString());
}
finally
{
AppDomain.Unload(loAppDomain);
}
stopWatch.Stop();
if (methodState != null && methodState.CodeBytes != null)
{
expressionDelegate = CreateExpressionDelegate <T>(methodState, functionClass);
}
return(expressionDelegate);
}
/// <summary>
/// Compiles an expression and returns a delegate to the compiled code.
/// </summary>
/// <typeparam name="R">The return type of the expression</typeparam>
/// <typeparam name="C">The type of the function class</typeparam>
/// <param name="expression">Expression to evaluate</param>
/// <returns>ExecuteExpression<R, C> - a delegate that calls the compiled expression</returns>
public ExecuteExpression <R, C> CreateExpressionDelegate <R, C>(string expression)
{
ExecuteExpression <R, C> expressionDelegate = null;
//create the compiled expression
var methodState = CreateExpressionMethodState <R, C>(expression);
if (methodState != null && methodState.CodeBytes != null)
{
//get a dynamic method delegate from the method state
expressionDelegate = CreateExpressionDelegate <R, C>(methodState);
}
return(expressionDelegate);
}
/// <summary>
/// Compiles a DynamicMethodState and returns a delegate.
/// </summary>
/// <typeparam name="R">The return type of the expression</typeparam>
/// <typeparam name="C">The type of the function class</typeparam>
/// <param name="methodState">The serialized version of a method on the functionClass</param>
/// <returns>EvalExpression<R, C> - a delegate that calls the compiled expression</returns>
internal EvalExpression <R, C> GetDelegate <R, C>(DynamicMethodState methodState)
{
ExecuteExpression <R, C> methodDelegate = null;
//get delegate factory
var delegateFactory = new ExpressionDelegateFactory();
if (methodState != null && methodState.CodeBytes != null)
{
//get delegate from factory
methodDelegate = delegateFactory.CreateExpressionDelegate <R, C>(methodState);
}
//return an eval delegate based on the delegate from the factory
return(new EvalExpression <R, C>(methodDelegate));
}
/// <summary>
/// Compiles a DynamicMethodState and returns a delegate.
/// </summary>
/// <typeparam name="R">The return type of the expression</typeparam>
/// <typeparam name="C">The type of the function class</typeparam>
/// <param name="methodState">The serialized version of a method on the functionClass</param>
/// <returns>CompiledCode<R, C> - a delegate that calls the compiled expression</returns>
public CompiledCode <R, C> GetDelegate <R, C>(DynamicMethodState methodState)
{
ExecuteExpression <R, C> methodDelegate = null;
//get delegate factory
IExpressionDelegateFactory delegateFactory = new ExpressionDelegateFactory(m_language);
if (methodState != null && methodState.codeBytes != null)
{
//get delegate from factory
methodDelegate = delegateFactory.CreateExpressionDelegate <R, C>(methodState);
}
//return an eval delegate based on the delegate from the factory
return(new CompiledCode <R, C>(methodDelegate));
}
public override void EmitIL(_ATHProgram program, Colour expressionColour, ILGenerator ilGenerator, Dictionary <string, ImportHandle> importHandles, Dictionary <Tuple <string, Colour>, ImportHandle> objects)
{
var startLabel = ilGenerator.DefineLabel();
var endLabel = ilGenerator.DefineLabel();
ilGenerator.MarkLabel(startLabel);
if (Target == "THIS")
{
program.EmitIsTHISAlive(ilGenerator, TargetColour ?? expressionColour);
if (Not)
{
ilGenerator.Emit(OpCodes.Brtrue, endLabel);
}
else
{
ilGenerator.Emit(OpCodes.Brfalse, endLabel);
}
}
else
{
var target = Tuple.Create(Target, TargetColour ?? expressionColour);
objects[target].EmitIsAlive(program, ilGenerator, target);
if (Not)
{
ilGenerator.Emit(OpCodes.Brtrue, endLabel);
}
else
{
ilGenerator.Emit(OpCodes.Brfalse, endLabel);
}
}
foreach (var expression in _loopExpressions)
{
program.EmitDieIfKilled(ilGenerator, expressionColour);
expression.EmitIL(program, expressionColour, ilGenerator, importHandles, objects);
}
#if !NODELAY
var threadSleep = ((Action <int>)Thread.Sleep).Method;
ilGenerator.Emit(OpCodes.Ldc_I4, 100);
ilGenerator.EmitCall(OpCodes.Call, threadSleep, null);
#endif
ilGenerator.Emit(OpCodes.Br, startLabel);
ilGenerator.MarkLabel(endLabel);
if (ExecuteExpression != null)
{
if (ExecuteExpression is NULLExpression)
{
// Empty.
}
else
{
program.EmitDieIfKilled(ilGenerator, expressionColour);
ExecuteExpression.EmitIL(program, expressionColour, ilGenerator, importHandles, objects);
}
}
else
{
var getFullPath = ((Func <string, string>)Path.GetFullPath).Method;
var startProcess = ((Func <string, Process>)Process.Start).Method;
ilGenerator.Emit(OpCodes.Ldstr, ExecuteCommand);
ilGenerator.EmitCall(OpCodes.Call, getFullPath, null);
ilGenerator.EmitCall(OpCodes.Call, startProcess, null);
ilGenerator.Emit(OpCodes.Pop);
}
}
