private object FuncInvoker <Arg1T, Arg2T, ResultT>(Closure closure, ExecutionNode[] argumentFns)
{
var arg1 = closure.Unbox <Arg1T>(argumentFns[0].Run(closure));
var arg2 = closure.Unbox <Arg2T>(argumentFns[1].Run(closure));
return(((Func <Arg1T, Arg2T, ResultT>) this.fn).Invoke(arg1, arg2));
}
/// <inheritdoc />
public override object Run(Closure closure)
{
var instance = closure.Unbox <object>(closure.Locals[LOCAL_OPERAND1]);
if (this.bindingsByMember.Count == 0)
{
return(instance);
}
foreach (var bindings in this.bindingsByMember)
{
var member = bindings.Key;
var addTarget = default(object);
var fieldInfo = member as FieldInfo;
var propertyInfo = member as PropertyInfo;
if (fieldInfo != null)
{
if (fieldInfo.IsStatic == false && instance == null)
{
throw new NullReferenceException();
}
addTarget = fieldInfo.GetValue(instance);
}
else if (propertyInfo != null)
{
var getMethod = propertyInfo.GetGetMethod(nonPublic: true);
if (getMethod.IsStatic == false && instance == null)
{
throw new NullReferenceException();
}
addTarget = propertyInfo.GetValue(instance, null);
}
else
{
throw new InvalidOperationException(string.Format(Properties.Resources.EXCEPTION_EXECUTION_INVALIDMEMBERFOREXPRESSION, member));
}
foreach (var bindGroup in bindings)
{
var addMethod = bindGroup.AddMethod;
var addArgumentNodes = bindGroup.AddMethodArguments;
var addArguments = new object[addArgumentNodes.Length];
for (var i = 0; i < addArgumentNodes.Length; i++)
{
addArguments[i] = closure.Unbox <object>(addArgumentNodes[i].Run(closure));
}
addMethod.Invoke(addTarget, addArguments);
}
}
return(instance);
}
/// <inheritdoc />
public override object Run(Closure closure)
{
var left = this.leftNode.Run(closure);
// shortcut for and-also(&&) and or-else(||)
if (this.shortcutLeftValue != null && Equals(this.shortcutLeftValue, closure.Unbox <object>(left)))
{
return(this.shortcutLeftValue);
}
var right = this.rightNode.Run(closure);
if (this.isNullable && (left == null || right == null))
{
left = closure.Unbox <object>(left);
right = closure.Unbox <object>(right);
// ReSharper disable once SwitchStatementMissingSomeCases
switch (this.binaryExpression.NodeType)
{
case ExpressionType.Equal: return(ReferenceEquals(left, right) ? Constants.TrueObject : Constants.FalseObject);
case ExpressionType.NotEqual: return(ReferenceEquals(left, right) ? Constants.FalseObject : Constants.TrueObject);
case ExpressionType.GreaterThan:
case ExpressionType.GreaterThanOrEqual:
case ExpressionType.LessThan:
case ExpressionType.LessThanOrEqual: return(Constants.FalseObject);
// C# Specs -> 7.11.4 Nullable boolean logical operators
case ExpressionType.And:
if (Equals(left, Constants.FalseObject) || Equals(right, Constants.FalseObject))
{
return(Constants.FalseObject);
}
goto default;
case ExpressionType.Or:
if (Equals(left, Constants.TrueObject) || Equals(right, Constants.TrueObject))
{
return(Constants.TrueObject);
}
goto default;
default:
return(null);
}
}
return(Intrinsic.InvokeBinaryOperation(closure, left, right, this.binaryExpression.NodeType, this.operation));
}
public static Func <Arg1T, Arg2T, Arg3T, ResultT> PrepareFunc <Arg1T, Arg2T, Arg3T, ResultT>(Expression body, ReadOnlyCollection <ParameterExpression> parameters)
{
if (body == null)
{
throw new ArgumentNullException("body");
}
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var collector = new ConstantsCollector();
collector.Visit(body);
var constExpressions = collector.Constants.ToArray();
var parameterExpressions = parameters.ToArray();
var compiledBody = Compile(body, constExpressions, parameterExpressions);
var constants = ArrayUtils.ConvertAll(constExpressions, c => c.Value);
return((arg1, arg2, arg3) =>
{
var locals = new object[] { null, null, null, arg1, arg2, arg3 };
var closure = new Closure(constants, locals);
var result = closure.Unbox <ResultT>(compiledBody.Run(closure));
Array.Clear(locals, 0, locals.Length);
return result;
});
}
/// <inheritdoc />
public override object Run(Closure closure)
{
var instance = closure.Unbox <object>(this.newNode.Run(closure));
if (ReferenceEquals(this.memberAssignmentNode, MemberAssignmentsNode.Empty) == false)
{
closure.Locals[LOCAL_OPERAND1] = instance;
this.memberAssignmentNode.Run(closure);
}
if (ReferenceEquals(this.listBindingNode, MemberListBindingsNode.Empty) == false)
{
closure.Locals[LOCAL_OPERAND1] = instance;
this.listBindingNode.Run(closure);
}
if (ReferenceEquals(this.memberMemberBindingNode, MemberMemberBindingsNode.Empty) == false)
{
closure.Locals[LOCAL_OPERAND1] = instance;
this.memberMemberBindingNode.Run(closure);
}
closure.Locals[LOCAL_OPERAND1] = null;
return(instance);
}
/// <inheritdoc />
public override object Run(Closure closure)
{
var testValue = closure.Unbox <bool>(this.conditionTestNode.Run(closure));
var value = testValue ? this.trueBranchNode.Run(closure) : this.falseBranchNode.Run(closure);
return(value);
}
/// <inheritdoc />
public override object Run(Closure closure)
{
var initializationValues = new object[this.initializationValueNodes.Length];
for (var i = 0; i < initializationValues.Length; i++)
{
initializationValues[i] = closure.Unbox <object>(this.initializationValueNodes[i].Run(closure));
}
var constructorArguments = EmptyArguments;
if (this.constructorParametersCount > 0)
{
constructorArguments = new object[this.constructorParametersCount];
Array.Copy(initializationValues, constructorArguments, this.constructorParametersCount);
}
var newInstance = this.isNullableType ? null : Activator.CreateInstance(this.newExpression.Type, constructorArguments);
if (newInstance == null)
{
throw new NullReferenceException(string.Format(Properties.Resources.EXCEPTION_EXECUTION_EXPRESSIONGIVESNULLRESULT, this.newExpression));
}
return(newInstance);
}
/// <inheritdoc />
public override object Run(Closure closure)
{
var targetDelegate = closure.Unbox <Delegate>(this.target.Run(closure));
var invokeArguments = new object[this.argumentNodes.Length];
for (var i = 0; i < invokeArguments.Length; i++)
{
invokeArguments[i] = closure.Unbox <object>(this.argumentNodes[i].Run(closure));
}
if (targetDelegate == null)
{
throw new NullReferenceException(string.Format(Properties.Resources.EXCEPTION_EXECUTION_EXPRESSIONGIVESNULLRESULT, this.invocationExpression.Expression));
}
return(targetDelegate.DynamicInvoke(invokeArguments));
}
/// <inheritdoc />
public override object Run(Closure closure)
{
var target = closure.Unbox <object>(this.targetNode.Run(closure));
if (target == null)
{
return(Constants.FalseObject);
}
return(this.typeBinaryExpression.TypeOperand.IsInstanceOfType(target) ? Constants.TrueObject : Constants.FalseObject);
}
/// <inheritdoc />
public override object Run(Closure closure)
{
var target = closure.Unbox <Array>(this.targetNode.Run(closure));
if (target == null)
{
throw new NullReferenceException(string.Format(Properties.Resources.EXCEPTION_EXECUTION_EXPRESSIONGIVESNULLRESULT, this.unaryExpression.Operand));
}
return(closure.Box(target.Length));
}
/// <inheritdoc />
public override object Run(Closure closure)
{
var target = closure.Unbox <object>(this.targetNode.Run(closure));
if (target == null)
{
return(Constants.FalseObject);
}
return(this.targetType.IsAssignableFrom(target.GetType()) ? Constants.TrueObject : Constants.FalseObject);
}
/// <inheritdoc />
public override object Run(Closure closure)
{
if (this.methodCallNode != null)
{
return(this.methodCallNode.Run(closure));
}
else
{
var target = closure.Unbox <Array>(this.targetNode.Run(closure));
if (target == null)
{
throw new NullReferenceException(string.Format(Properties.Resources.EXCEPTION_EXECUTION_EXPRESSIONGIVESNULLRESULT, this.expression));
}
var index = this.indexNode.Run(closure);
return(closure.Is <int[]>(index)
? target.GetValue(closure.Unbox <int[]>(index))
: target.GetValue(closure.Unbox <int>(index)));
}
}
/// <inheritdoc />
public override object Run(Closure closure)
{
var initializationValues = new object[this.initializationValueNodes.Length];
for (var i = 0; i < initializationValues.Length; i++)
{
initializationValues[i] = closure.Unbox <object>(this.initializationValueNodes[i].Run(closure));
}
var constructorArguments = EmptyArguments;
if (this.constructorParametersCount > 0)
{
constructorArguments = new object[this.constructorParametersCount];
Array.Copy(initializationValues, constructorArguments, this.constructorParametersCount);
}
var newInstance = this.isNullableType ? null : Activator.CreateInstance(this.newExpression.Type, constructorArguments);
if (this.newExpression.Members == null)
{
return(newInstance);
}
if (newInstance == null)
{
throw new NullReferenceException(string.Format(Properties.Resources.EXCEPTION_EXECUTION_EXPRESSIONGIVESNULLRESULT, this.newExpression));
}
for (var j = 0; j < this.newExpression.Members.Count; j++)
{
var member = this.newExpression.Members[j];
var fieldInfo = member as FieldInfo;
var propertyInfo = member as PropertyInfo;
var value = initializationValues[constructorArguments.Length + j];
if (fieldInfo != null)
{
fieldInfo.SetValue(newInstance, value);
}
else if (propertyInfo != null)
{
propertyInfo.SetValue(newInstance, value, null);
}
else
{
throw new InvalidOperationException(string.Format(Properties.Resources.EXCEPTION_EXECUTION_INVALIDMEMBERFOREXPRESSION, member));
}
}
return(newInstance);
}
/// <inheritdoc />
public override object Run(Closure closure)
{
// ReSharper disable once AssignNullToNotNullAttribute
var array = Array.CreateInstance(this.newArrayExpression.Type.GetElementType(), this.initializationValueNodes.Length);
for (var i = 0; i < this.initializationValueNodes.Length; i++)
{
var initializationValue = this.initializationValueNodes[i].Run(closure);
array.SetValue(closure.Unbox <object>(initializationValue), i);
}
return(array);
}
/// <inheritdoc />
public override object Run(Closure closure)
{
var left = closure.Unbox <object>(this.leftNode.Run(closure));
if (left != null)
{
return(left);
}
else
{
return(this.rightNode.Run(closure));
}
}
/// <inheritdoc />
public override object Run(Closure closure)
{
var instance = closure.Unbox <object>(closure.Locals[LOCAL_OPERAND1]);
if (this.memberAssignments.Length == 0)
{
return(instance);
}
foreach (var assignFn in this.memberAssignments)
{
var member = assignFn.Member;
var valueFn = assignFn.ValueNode;
var value = closure.Unbox <object>(valueFn.Run(closure));
var fieldInfo = member as FieldInfo;
var propertyInfo = member as PropertyInfo;
if (instance == null)
{
throw new NullReferenceException();
}
if (fieldInfo != null)
{
fieldInfo.SetValue(instance, value);
}
else if (propertyInfo != null)
{
propertyInfo.SetValue(instance, value, null);
}
else
{
throw new InvalidOperationException(string.Format(Properties.Resources.EXCEPTION_EXECUTION_INVALIDMEMBERFOREXPRESSION, member));
}
}
return(instance);
}
/// <inheritdoc />
public override object Run(Closure closure)
{
var ranks = new int[this.rankNodes.Length];
for (var i = 0; i < this.rankNodes.Length; i++)
{
ranks[i] = closure.Unbox <int>(this.rankNodes[i].Run(closure));
}
// ReSharper disable once AssignNullToNotNullAttribute
var array = Array.CreateInstance(this.newArrayExpression.Type.GetElementType(), ranks);
return(array);
}
/// <inheritdoc />
public override object Run(Closure closure)
{
var list = closure.Unbox <object>(this.newNode.Run(closure));
if (this.initializationNodes.Length == 0)
{
return(list);
}
foreach (var listInit in this.initializationNodes)
{
var addMethod = listInit.Key;
var argumentNodes = listInit.Value;
var addArguments = new object[argumentNodes.Length];
for (var i = 0; i < argumentNodes.Length; i++)
{
addArguments[i] = closure.Unbox <object>(argumentNodes[i].Run(closure));
}
addMethod.Invoke(list, addArguments);
}
return(list);
}
/// <inheritdoc />
public override object Run(Closure closure)
{
if (this.convertNode != null)
{
return(this.convertNode.Run(closure));
}
var target = closure.Unbox <object>(this.targetNode.Run(closure));
if (target == null)
{
return(null);
}
if (this.typeAsExpression.Type.IsInstanceOfType(target) == false)
{
return(null);
}
return(target);
}
/// <inheritdoc />
public override object Run(Closure closure)
{
if (this.convertNode != null)
{
return(this.convertNode.Run(closure));
}
var target = closure.Unbox <object>(this.targetNode.Run(closure));
if (target == null)
{
return(null);
}
if (this.targetType.IsAssignableFrom(target.GetType()) == false)
{
return(null);
}
return(target);
}
/// <inheritdoc />
public override object Run(Closure closure)
{
var target = closure.Unbox <object>(this.targetNode.Run(closure));
if (this.isStatic == false && target == null)
{
throw new NullReferenceException(string.Format(Properties.Resources.EXCEPTION_EXECUTION_EXPRESSIONGIVESNULLRESULT, this.memberExpression.Expression));
}
if (this.fieldInfo != null)
{
return(this.fieldInfo.GetValue(target));
}
else if (this.propertyGetter != null)
{
return(this.propertyGetter.Invoke(target, null));
}
else
{
throw new InvalidOperationException(string.Format(Properties.Resources.EXCEPTION_EXECUTION_INVALIDMEMBERFOREXPRESSION, this.memberExpression.Member));
}
}
/// <inheritdoc />
public override object Run(Closure closure)
{
if (this.fastCallInvoker != null)
{
return(this.fastCallInvoker(closure, this.argumentNodes));
}
else
{
var target = this.targetNode.Run(closure);
if (this.isStatic == false && target == null)
{
throw new NullReferenceException(string.Format(Properties.Resources.EXCEPTION_EXECUTION_EXPRESSIONGIVESNULLRESULT, this.methodCallExpression.Object));
}
var arguments = new object[this.argumentNodes.Length];
for (var i = 0; i < arguments.Length; i++)
{
arguments[i] = closure.Unbox <object>(this.argumentNodes[i].Run(closure));
}
return(this.methodCallExpression.Method.Invoke(target, arguments));
}
}
/// <inheritdoc />
public override object Run(Closure closure)
{
var target = closure.Unbox <object>(closure.Locals[LOCAL_OPERAND1]);
if (this.bindingsByMember.Count == 0)
{
return(target);
}
foreach (var bindings in this.bindingsByMember)
{
var member = bindings.Key;
var fieldInfo = member as FieldInfo;
var propertyInfo = member as PropertyInfo;
var bindTarget = default(object);
if (fieldInfo != null)
{
if (fieldInfo.IsStatic == false && target == null)
{
throw new NullReferenceException();
}
bindTarget = fieldInfo.GetValue(target);
}
else if (propertyInfo != null)
{
var getMethod = propertyInfo.GetGetMethod(nonPublic: true);
if (getMethod.IsStatic == false && target == null)
{
throw new NullReferenceException();
}
bindTarget = propertyInfo.GetValue(target, null);
}
else
{
throw new InvalidOperationException(string.Format(Properties.Resources.EXCEPTION_EXECUTION_INVALIDMEMBERFOREXPRESSION, member));
}
foreach (var bind in bindings)
{
if (ReferenceEquals(bind.MemberAssignments, MemberAssignmentsNode.Empty) == false)
{
closure.Locals[LOCAL_OPERAND1] = bindTarget;
bind.MemberAssignments.Run(closure);
}
if (ReferenceEquals(bind.MemberListBindings, MemberListBindingsNode.Empty) == false)
{
closure.Locals[LOCAL_OPERAND1] = bindTarget;
bind.MemberListBindings.Run(closure);
}
if (ReferenceEquals(bind.MemberMemberBindings, Empty) == false)
{
closure.Locals[LOCAL_OPERAND1] = bindTarget;
bind.MemberMemberBindings.Run(closure);
}
}
}
return(target);
}
/// <inheritdoc />
public override object Run(Closure closure)
{
var operand = closure.Unbox <object>(this.operandNode.Run(closure));
if (operand == null && (this.convertExpression.Type.IsValueType == false || this.isTargetTypeNullable))
{
return(null);
}
var operandType = closure.GetType(operand);
var convertType = this.convertExpression.NodeType;
if (convertType != ExpressionType.Convert)
{
convertType = ExpressionType.ConvertChecked;
}
// un-box
if ((this.sourceType == typeof(object) || this.sourceType == typeof(ValueType) || this.sourceType.IsInterface) && this.targetType.IsValueType)
{
// null un-box
if (operand == null)
{
throw new NullReferenceException(string.Format(Properties.Resources.EXCEPTION_EXECUTION_EXPRESSIONGIVESNULLRESULT, this.convertExpression.Operand));
}
// type check for un-box
if (operandType == this.targetType)
{
return(operand);
}
throw new InvalidCastException();
}
// box
else if (this.sourceType.IsValueType && (this.targetType == typeof(object) || this.targetType == typeof(ValueType) || this.targetType.IsInterface))
{
// type check for box
return(this.targetType.IsAssignableFrom(operandType) ? operand : null);
}
// to enum
else if (this.targetType.IsEnum && (this.sourceType == typeof(byte) ||
this.sourceType == typeof(sbyte) ||
this.sourceType == typeof(short) ||
this.sourceType == typeof(ushort) ||
this.sourceType == typeof(int) ||
this.sourceType == typeof(uint) ||
this.sourceType == typeof(long) ||
this.sourceType == typeof(ulong)))
{
if (operand == null)
{
throw new NullReferenceException(string.Format(Properties.Resources.EXCEPTION_EXECUTION_EXPRESSIONGIVESNULLRESULT, this.convertExpression.Operand));
}
operand = Intrinsic.InvokeConversion(closure, operand, Enum.GetUnderlyingType(this.targetType), this.convertExpression.NodeType, null);
return(Enum.ToObject(this.targetType, closure.Unbox <object>(operand)));
}
// from enum
else if (this.sourceType.IsEnum && (this.targetType == typeof(byte) ||
this.targetType == typeof(sbyte) ||
this.targetType == typeof(short) ||
this.targetType == typeof(ushort) ||
this.targetType == typeof(int) ||
this.targetType == typeof(uint) ||
this.targetType == typeof(long) ||
this.targetType == typeof(ulong)))
{
if (operand == null)
{
throw new NullReferenceException(string.Format(Properties.Resources.EXCEPTION_EXECUTION_EXPRESSIONGIVESNULLRESULT, this.convertExpression.Operand));
}
operand = Convert.ChangeType(closure.Unbox <object>(operand), Enum.GetUnderlyingType(this.sourceType));
operand = Intrinsic.InvokeConversion(closure, operand, this.targetType, this.convertExpression.NodeType, null);
return(operand);
}
// from nullable
if (this.targetType.IsValueType && this.isSourceTypeNullable)
{
if (operand == null)
{
throw new NullReferenceException(string.Format(Properties.Resources.EXCEPTION_EXECUTION_EXPRESSIONGIVESNULLRESULT, this.convertExpression.Operand));
}
operand = Intrinsic.InvokeConversion(closure, operand, this.targetType, this.convertExpression.NodeType, null);
}
else if (this.targetType.IsAssignableFrom(operandType))
{
return(operand);
}
return(Intrinsic.InvokeConversion(closure, operand, this.targetType, convertType, this.operation));
}
