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; }