private object Invoke(BinaryExpression node, string opName) { if (opName is null) { ExecutionException.ThrowInvalidOp(node); } var left = node.Left.Accept(this); var right = node.Right.Accept(this); return(Invoke(node, opName, left, right)); }
static object Invoke(BinaryExpression node, string opName, object left, object right) { if (left is null) { ExecutionException.ThrowNullError(node.Left, node); } if (right is null) { ExecutionException.ThrowNullError(node.Right, node); } if (node.Method is null) { var leftType = left.GetType(); var rightType = right.GetType(); var types = new Type[2] { leftType, rightType }; ArgumentConversions conversions = new ArgumentConversions(2); System.Reflection.MethodInfo method; if (leftType.IsPrimitive || rightType.IsPrimitive) { var initial = (ReflectionUtils.FromSystemType(ref types)); method = ReflectionUtils. GetOperatorOverload(opName, conversions, types); conversions.SetInitial(initial); } else { method = ReflectionUtils. GetOperatorOverload(opName, conversions, types); } if (method is null) { ExecutionException.ThrowInvalidOp(node); } node.Method = method; node.Type = method.ReturnType; node.Conversions = conversions; } object[] args = new object[2] { left, right }; node.Conversions.Invoke(ref args); // operator overload invoke return(node.Method.Invoke(null, System.Reflection.BindingFlags.Default, null, args, null)); }
/// <summary> /// Safe compiler invoke for exceptions /// </summary> /// <param name="exp">Invoking expression</param> /// <param name="method">method to Invoke</param> /// <param name="target">method target</param> /// <param name="parmeters">parameters for invoke</param> /// <returns>result of invoke</returns> public static object SafeInvoke(Expression exp, System.Reflection.MethodBase method, object target, object[] parmeters) { try { return(method.Invoke(target, System.Reflection.BindingFlags.Default, null, parmeters, null)); } catch (System.Reflection.TargetInvocationException) { throw ExecutionException.ThrowInvalidOp(exp); } catch (ArgumentException ex) { throw ExecutionException.ThrowInvalidOp(exp, new NameExpression(ex.ParamName, ExpressionType.Identifier)); } catch (System.Reflection.TargetParameterCountException) { throw ExecutionException.ThrowArgumentMisMatch(exp); } }
public object VisitUnary(UnaryExpression node) { var value = node.Operand.Accept(this); if (node.NodeType == ExpressionType.Parenthesized) { node.Type = node.Operand.Type; return(value); } //modified a++; updated new value bool modified = false, updated = true; switch (node.NodeType) { case ExpressionType.PostfixPlusPlus: modified = true; updated = false; break; case ExpressionType.PrefixPlusPlus: modified = true; break; case ExpressionType.PostfixMinusMinus: modified = true; updated = false; break; case ExpressionType.PrefixMinusMinus: modified = true; break; case ExpressionType.Bang: // here value is null it is as not defined if (value is null) { return(Boolean.True); } break; } if (value is null) { ExecutionException.ThrowNullError(node.Operand, node); } // no primitive supported it should be wrapped //resolve call if (node.Method is null) { Type type = node.Operand.Type; ArgumentConversions conversions = new ArgumentConversions(1); System.Reflection.MethodInfo method; if (type.IsPrimitive) { type = TypeProvider.Find(Type.GetTypeCode(type)); method = ReflectionUtils.GetOperatorOverload(node.MethodName, conversions, type); conversions.AddFirst(new ParamConversion(0, ReflectionHelpers.ToAny)); } else { method = ReflectionUtils.GetOperatorOverload(node.MethodName, conversions, type); } if (method is null) { ExecutionException.ThrowInvalidOp(node); } node.Conversions = conversions; node.Method = method; node.Type = method.ReturnType; } object[] args = new object[1] { value }; node.Conversions.Invoke(ref args); object obj = node.Method.Invoke(null, args); if (modified) { if (node.Operand.NodeType == ExpressionType.Literal) { ExecutionException.ThrowNotSupported(node); } var exp = new AssignmentExpression(node.Operand, new LiteralExpression(obj)); exp.Accept(this); } return(updated ? obj : value); }