internal override object GetValue(InterpreterState state, bool outParam)
{
if (outParam)
{
return(null);
}
return(base.GetValue(state, outParam));
}
internal override object AssignValue(InterpreterState state, object value)
{
EvaluationAddress addr = _addrs[Index];
if (addr != null)
{
return(addr.AssignValue(state, value));
}
return(null);
}
/// <summary>
/// Gets the delegate associated with the LambdaExpression.
/// Either it uses cached MethodInfo and creates delegate from it, or it will generate
/// completely new dynamic method, store it in a cache and use it to create the delegate.
/// </summary>
private static Delegate GetDelegateForInterpreter(InterpreterState state, LambdaExpression lambda)
{
MethodInfo method;
if (!LambdaInvoker.TryGetGenericInvokeMethod(lambda.Parameters.Count, out method) || HasByRefParameter(lambda))
{
return(GenerateDelegateForInterpreter(state, lambda));
}
Type[] signature = GetSignature(lambda);
method = method.MakeGenericMethod(signature);
return(ReflectionUtils.CreateDelegate(method, lambda.Type, new LambdaInvoker(lambda, state)));
}
private static object DoExecute(InterpreterState state, LambdaExpression lambda)
{
object ret = Interpreter.Interpret(state, lambda.Body);
ControlFlow cf = ret as ControlFlow;
if (cf != null)
{
return(cf.Value);
}
else
{
return(ret);
}
}
private static Delegate GenerateDelegateForInterpreter(InterpreterState state, LambdaExpression lambda)
{
if (_Delegates == null)
{
Interlocked.CompareExchange <WeakDictionary <LambdaExpression, MethodInfo> >(
ref _Delegates,
new WeakDictionary <LambdaExpression, MethodInfo>(),
null
);
}
bool found;
MethodInfo method;
//
// LOCK to find the MethodInfo
//
lock (_Delegates) {
found = _Delegates.TryGetValue(lambda, out method);
}
if (!found)
{
method = CreateDelegateForInterpreter(lambda.Type);
//
// LOCK to store the MethodInfo
// (and maybe find one added while we were creating new delegate, in which case
// throw away the new one and use the one from the cache.
//
lock (_Delegates) {
MethodInfo conflict;
if (!_Delegates.TryGetValue(lambda, out conflict))
{
_Delegates.Add(lambda, method);
}
else
{
method = conflict;
}
}
}
return(ReflectionUtils.CreateDelegate(method, lambda.Type, new LambdaInvoker(lambda, state)));
}
private static InterpreterState CreateForLambda(InterpretedScriptCode scriptCode, LambdaExpression lambda,
InterpreterState lexicalParent, InterpreterState caller, object[] args)
{
InterpreterState state = new InterpreterState(lexicalParent, new LambdaState(scriptCode, lambda, caller));
Debug.Assert(args.Length == lambda.Parameters.Count, "number of parameters should match number of arguments");
//
// Populate all parameters ...
//
for (int i = 0; i < lambda.Parameters.Count; i++)
{
state._vars.Add(lambda.Parameters[i], args[i]);
}
return(state);
}
internal override object GetValue(InterpreterState state, bool outParam)
{
object result = null;
for (int i = 0; i < _addrs.Count; i++)
{
EvaluationAddress current = _addrs[i];
if (current != null)
{
object val = current.GetValue(state, outParam);
if (i == Index)
{
result = val;
}
}
}
return(result);
}
internal object GetValue(Expression variable)
{
InterpreterState state = this;
for (; ;)
{
object value;
if (state._vars.TryGetValue(variable, out value))
{
return(value);
}
state = state._lexicalParent;
// Couldn't find variable
if (state == null)
{
throw InvalidVariableReference(variable);
}
}
}
internal void SetValue(Expression variable, object value)
{
InterpreterState state = this;
for (; ;)
{
if (state._vars.ContainsKey(variable))
{
state._vars[variable] = value;
return;
}
state = state._lexicalParent;
// Couldn't find variable
if (state == null)
{
throw InvalidVariableReference(variable);
}
}
}
internal InterpreterState CreateForScope(BlockExpression scope)
{
InterpreterState state = new InterpreterState(this, _lambdaState);
foreach (ParameterExpression v in scope.Variables)
{
// initialize variables to default(T)
object value;
if (v.Type.IsValueType)
{
value = Activator.CreateInstance(v.Type);
}
else
{
value = null;
}
state._vars.Add(v, value);
}
return(state);
}
/// <summary>
/// Called by the code:LambdaInvoker.Invoke from the delegate generated below by
/// code:GetDelegateForInterpreter.
///
/// This method must repackage arguments to match the lambdas signature, which
/// may mean repackaging the parameter arrays.
///
/// Input are two arrays - regular arguments passed into the generated delegate,
/// and (if the delegate had params array), the parameter array, separately.
/// </summary>
internal static object InterpretLambda(InterpreterState lexicalParentState, LambdaExpression lambda, object[] args)
{
Assert.NotNull(lexicalParentState, lambda, args);
var state = InterpreterState.Current.Update(
(caller) => lexicalParentState.CreateForLambda(lambda, caller, args)
);
try {
object result = Interpret(state, lambda.Body);
var cf = result as ControlFlow;
if (cf != null)
{
return((cf.Kind == ControlFlowKind.Yield) ? cf.Value : null);
}
return(result);
} finally {
InterpreterState.Current.Value = state.Caller;
}
}
internal static InterpreterState CreateForTopLambda(InterpretedScriptCode scriptCode, LambdaExpression lambda, InterpreterState caller, params object[] args)
{
return(CreateForLambda(scriptCode, lambda, null, caller, args));
}
internal InterpreterVariables(InterpreterState state, RuntimeVariablesExpression node)
{
_state = state;
_vars = node.Variables;
}
internal InterpreterBox(InterpreterState state, Expression variable)
{
_state = state;
_variable = variable;
}
internal virtual object AssignValue(InterpreterState state, object value)
{
return(Interpreter.EvaluateAssign(state, _expr, value));
}
internal virtual object GetValue(InterpreterState state, bool outParam)
{
return(Interpreter.Evaluate(state, _expr));
}
internal GeneratorInvoker(GeneratorExpression generator, InterpreterState state)
{
_generator = generator;
_state = state;
}
private InterpreterState(InterpreterState parent, LambdaState lambdaState)
{
Assert.NotNull(lambdaState);
_lexicalParent = parent;
_lambdaState = lambdaState;
}
internal InterpreterState CreateForLambda(LambdaExpression lambda, InterpreterState caller, object[] args)
{
return(CreateForLambda(_lambdaState.ScriptCode, lambda, this, caller, args));
}
internal InterpreterState CreateForGenerator(InterpreterState caller)
{
return(new InterpreterState(this, new LambdaState(_lambdaState.ScriptCode, caller.Lambda, caller)));
}
private static object Interpret(InterpreterState state, Expression expr)
{
switch (expr.NodeType)
{
#region Generated Ast Interpreter
// *** BEGIN GENERATED CODE ***
// generated by function: gen_interpreter from: generate_tree.py
case ExpressionType.Add: return(InterpretBinaryExpression(state, expr));
case ExpressionType.AddChecked: return(InterpretBinaryExpression(state, expr));
case ExpressionType.And: return(InterpretBinaryExpression(state, expr));
case ExpressionType.AndAlso: return(InterpretAndAlsoBinaryExpression(state, expr));
case ExpressionType.ArrayLength: return(InterpretUnaryExpression(state, expr));
case ExpressionType.ArrayIndex: return(InterpretBinaryExpression(state, expr));
case ExpressionType.Call: return(InterpretMethodCallExpression(state, expr));
case ExpressionType.Coalesce: return(InterpretCoalesceBinaryExpression(state, expr));
case ExpressionType.Conditional: return(InterpretConditionalExpression(state, expr));
case ExpressionType.Constant: return(InterpretConstantExpression(state, expr));
case ExpressionType.Convert: return(InterpretConvertUnaryExpression(state, expr));
case ExpressionType.ConvertChecked: return(InterpretConvertUnaryExpression(state, expr));
case ExpressionType.Divide: return(InterpretBinaryExpression(state, expr));
case ExpressionType.Equal: return(InterpretBinaryExpression(state, expr));
case ExpressionType.ExclusiveOr: return(InterpretBinaryExpression(state, expr));
case ExpressionType.GreaterThan: return(InterpretBinaryExpression(state, expr));
case ExpressionType.GreaterThanOrEqual: return(InterpretBinaryExpression(state, expr));
case ExpressionType.Invoke: return(InterpretInvocationExpression(state, expr));
case ExpressionType.Lambda: return(InterpretLambdaExpression(state, expr));
case ExpressionType.LeftShift: return(InterpretBinaryExpression(state, expr));
case ExpressionType.LessThan: return(InterpretBinaryExpression(state, expr));
case ExpressionType.LessThanOrEqual: return(InterpretBinaryExpression(state, expr));
case ExpressionType.ListInit: return(InterpretListInitExpression(state, expr));
case ExpressionType.MemberAccess: return(InterpretMemberExpression(state, expr));
case ExpressionType.MemberInit: return(InterpretMemberInitExpression(state, expr));
case ExpressionType.Modulo: return(InterpretBinaryExpression(state, expr));
case ExpressionType.Multiply: return(InterpretBinaryExpression(state, expr));
case ExpressionType.MultiplyChecked: return(InterpretBinaryExpression(state, expr));
case ExpressionType.Negate: return(InterpretUnaryExpression(state, expr));
case ExpressionType.UnaryPlus: return(InterpretUnaryExpression(state, expr));
case ExpressionType.NegateChecked: return(InterpretUnaryExpression(state, expr));
case ExpressionType.New: return(InterpretNewExpression(state, expr));
case ExpressionType.NewArrayInit: return(InterpretNewArrayExpression(state, expr));
case ExpressionType.NewArrayBounds: return(InterpretNewArrayExpression(state, expr));
case ExpressionType.Not: return(InterpretUnaryExpression(state, expr));
case ExpressionType.NotEqual: return(InterpretBinaryExpression(state, expr));
case ExpressionType.Or: return(InterpretBinaryExpression(state, expr));
case ExpressionType.OrElse: return(InterpretOrElseBinaryExpression(state, expr));
case ExpressionType.Parameter: return(InterpretParameterExpression(state, expr));
case ExpressionType.Power: return(InterpretBinaryExpression(state, expr));
case ExpressionType.Quote: return(InterpretQuoteUnaryExpression(state, expr));
case ExpressionType.RightShift: return(InterpretBinaryExpression(state, expr));
case ExpressionType.Subtract: return(InterpretBinaryExpression(state, expr));
case ExpressionType.SubtractChecked: return(InterpretBinaryExpression(state, expr));
case ExpressionType.TypeAs: return(InterpretUnaryExpression(state, expr));
case ExpressionType.TypeIs: return(InterpretTypeBinaryExpression(state, expr));
case ExpressionType.Assign: return(InterpretAssignBinaryExpression(state, expr));
case ExpressionType.Block: return(InterpretBlockExpression(state, expr));
case ExpressionType.DebugInfo: return(InterpretDebugInfoExpression(state, expr));
case ExpressionType.Decrement: return(InterpretUnaryExpression(state, expr));
case ExpressionType.Dynamic: return(InterpretDynamicExpression(state, expr));
case ExpressionType.Default: return(InterpretEmptyExpression(state, expr));
case ExpressionType.Extension: return(InterpretExtensionExpression(state, expr));
case ExpressionType.Goto: return(InterpretGotoExpression(state, expr));
case ExpressionType.Increment: return(InterpretUnaryExpression(state, expr));
case ExpressionType.Index: return(InterpretIndexExpression(state, expr));
case ExpressionType.Label: return(InterpretLabelExpression(state, expr));
case ExpressionType.RuntimeVariables: return(InterpretRuntimeVariablesExpression(state, expr));
case ExpressionType.Loop: return(InterpretLoopExpression(state, expr));
case ExpressionType.Switch: return(InterpretSwitchExpression(state, expr));
case ExpressionType.Throw: return(InterpretThrowUnaryExpression(state, expr));
case ExpressionType.Try: return(InterpretTryExpression(state, expr));
case ExpressionType.Unbox: return(InterpretUnboxUnaryExpression(state, expr));
case ExpressionType.AddAssign:
case ExpressionType.AndAssign:
case ExpressionType.DivideAssign:
case ExpressionType.ExclusiveOrAssign:
case ExpressionType.LeftShiftAssign:
case ExpressionType.ModuloAssign:
case ExpressionType.MultiplyAssign:
case ExpressionType.OrAssign:
case ExpressionType.PowerAssign:
case ExpressionType.RightShiftAssign:
case ExpressionType.SubtractAssign:
case ExpressionType.AddAssignChecked:
case ExpressionType.MultiplyAssignChecked:
case ExpressionType.SubtractAssignChecked:
case ExpressionType.PreIncrementAssign:
case ExpressionType.PreDecrementAssign:
case ExpressionType.PostIncrementAssign:
case ExpressionType.PostDecrementAssign:
case ExpressionType.TypeEqual:
return(InterpretReducibleExpression(state, expr));
// *** END GENERATED CODE ***
#endregion
default: throw Assert.Unreachable;
}
;
}
public LambdaState(InterpretedScriptCode scriptCode, LambdaExpression lambda, InterpreterState caller)
{
Assert.NotNull(scriptCode, lambda);
ScriptCode = scriptCode;
Lambda = lambda;
Caller = caller;
}
