public BinaryExpression(TokenKind type, Expression left, Expression right) { ContractUtils.RequiresNotNull(left, "left"); ContractUtils.RequiresNotNull(right, "right"); switch (type) { case TokenKind.Add: _op = MSAst.ExpressionType.Add; break; case TokenKind.Subtract: _op = MSAst.ExpressionType.Subtract; break; case TokenKind.Mod: _op = MSAst.ExpressionType.Modulo; break; case TokenKind.Multiply: _op = MSAst.ExpressionType.Multiply; break; case TokenKind.Divide: _op = MSAst.ExpressionType.Divide; break; case TokenKind.LessThan: _op = MSAst.ExpressionType.LessThan; break; case TokenKind.LessThanOrEqual: _op = MSAst.ExpressionType.LessThanOrEqual; break; case TokenKind.GreaterThan: _op = MSAst.ExpressionType.GreaterThan; break; case TokenKind.GreaterThanOrEqual: _op = MSAst.ExpressionType.GreaterThanOrEqual; break; case TokenKind.Equals: _op = MSAst.ExpressionType.Equal; break; case TokenKind.NotEquals: _op = MSAst.ExpressionType.NotEqual; break; case TokenKind.LogicalAnd: _op = MSAst.ExpressionType.And; break; case TokenKind.LogicalOr: _op = MSAst.ExpressionType.Or; break; default: throw Assert.Unreachable; } _left = left; _right = right; StartIndex = left.StartIndex; EndIndex = right.EndIndex; }
public void Regular(Linq.ExpressionType binaryType, Type leftType = null, Type rightType = null) { leftType ??= typeof(int); rightType ??= leftType; var expected = LinqExpression.MakeBinary( binaryType, LinqExpression.Parameter( leftType), LinqExpression.Parameter( rightType)); var actual = $@" @prefix : <http://example.com/> . @prefix xt: <http://example.com/ExpressionTypes/> . :s :binaryExpressionType xt:{binaryType} ; :binaryLeft [ :parameterType [ :typeName ""{leftType}"" ; ] ] ; :binaryRight [ :parameterType [ :typeName ""{rightType}"" ; ] ; ] ; . "; ShouldBe(actual, expected); }
public void Typed(Linq.ExpressionType expression, Type type = null) { var operandType = typeof(object); type ??= operandType; var expected = LinqExpression.MakeUnary(expression, LinqExpression.Parameter(operandType), type); var actual = $@" @prefix : <http://example.com/> . @prefix xt: <http://example.com/ExpressionTypes/> . :s :unaryExpressionType xt:{expression} ; :unaryOperand [ :parameterType [ :typeName ""{operandType}"" ; ] ; ] ; :unaryType [ :typeName ""{type}"" ; ] ; . "; ShouldBe(actual, expected); }
public GridSearchOperationNodeTypeAttribute(System.Linq.Expressions.ExpressionType nodeType, bool isBinary, String stringComparisonMethod = null, String stringManipulationMethod = null) { NodeType = nodeType; IsBinary = isBinary; StringComparisonMethod = stringComparisonMethod; StringManipulationMethod = stringManipulationMethod; }
public AssignExpression(TokenKind type, Expression left, Expression right) { switch (type) { case TokenKind.Assign: _op = MSAst.ExpressionType.Assign; break; case TokenKind.AddEqual: _op = MSAst.ExpressionType.AddAssign; break; case TokenKind.SubtractEqual: _op = MSAst.ExpressionType.SubtractAssign; break; default: throw Assert.Unreachable; } _left = left; _right = right; }
/// <summary> /// 表达式类型计算 /// </summary> /// <param name="type"></param> /// <returns></returns> string ExpressionTypeCast(System.Linq.Expressions.ExpressionType type) { switch (type) { case System.Linq.Expressions.ExpressionType.And: case System.Linq.Expressions.ExpressionType.AndAlso: return(" AND "); case System.Linq.Expressions.ExpressionType.Equal: return(" ="); case System.Linq.Expressions.ExpressionType.GreaterThan: return(" >"); case System.Linq.Expressions.ExpressionType.GreaterThanOrEqual: return(">="); case System.Linq.Expressions.ExpressionType.LessThan: return("<"); case System.Linq.Expressions.ExpressionType.LessThanOrEqual: return("<="); case System.Linq.Expressions.ExpressionType.NotEqual: return("<>"); case System.Linq.Expressions.ExpressionType.Or: case System.Linq.Expressions.ExpressionType.OrElse: return(" Or "); case System.Linq.Expressions.ExpressionType.Add: case System.Linq.Expressions.ExpressionType.AddChecked: return("+"); case System.Linq.Expressions.ExpressionType.Subtract: case System.Linq.Expressions.ExpressionType.SubtractChecked: return("-"); case System.Linq.Expressions.ExpressionType.Divide: return("/"); case System.Linq.Expressions.ExpressionType.Multiply: case System.Linq.Expressions.ExpressionType.MultiplyChecked: return("*"); default: return(null); } }
public static string GetExceptionMessage <TLeft, TRight, TResult>(exp.ExpressionType operatorType) { ParameterExpression leftParameter = Expression.Parameter(typeof(TLeft), "left"); ParameterExpression rightParameter = Expression.Parameter(typeof(TRight), "right"); try { Expression.MakeBinary(operatorType, leftParameter, rightParameter); throw new Exception(); } catch (InvalidOperationException e) { return(e.Message); } }
internal MSAst Operator(ExpressionType op, MSAst left, MSAst right) { var returnType = ((op == ExpressionType.IsTrue) || (op == ExpressionType.IsFalse)) ? typeof(bool) : typeof(object); if (right == null) { return(MSAst.Dynamic( _binder.UnaryOperation(op), returnType, left)); } return(MSAst.Dynamic( _binder.BinaryOperation(op), returnType, left, right)); }
public static string GetExceptionMessage <TOperand, TResult>(exp.ExpressionType operatorType) { ParameterExpression operand = Expression.Parameter(typeof(TOperand), "operand"); try { Expression.MakeUnary(operatorType, operand, typeof(TResult)); throw new Exception( string.Format("Expression.MakeUnary was expected to throw exception for: TOperand of type {0} and TResult of type {1} for ExpressionType {2}", typeof(TOperand).Name, typeof(TResult).Name, operatorType)); } catch (InvalidOperationException e) { return(e.Message); } }
private static string GetOperatorToken(MSAst.ExpressionType @operator) { switch (@operator) { case MSAst.ExpressionType.OnesComplement: return("~"); case MSAst.ExpressionType.Not: return("!"); case MSAst.ExpressionType.Negate: return("-"); case MSAst.ExpressionType.UnaryPlus: return("+"); } return(OperatorInfo.GetOperatorInfo(@operator).Name); }
static Expression DoNumericPromotion(ParseContext ec, MSAst.ExpressionType op, Expression expr) { var exprType = expr.Type; if ((op == MSAst.ExpressionType.UnaryPlus || op == MSAst.ExpressionType.Negate || op == MSAst.ExpressionType.OnesComplement) && exprType == TypeManager.CoreTypes.Byte || exprType == TypeManager.CoreTypes.SByte || exprType == TypeManager.CoreTypes.Int16 || exprType == TypeManager.CoreTypes.UInt16 || exprType == TypeManager.CoreTypes.Char) { return(ConvertExpression.MakeImplicitNumericConversion(ec, expr, expr.Type, TypeManager.CoreTypes.Int32)); } if (op == MSAst.ExpressionType.Negate && exprType == TypeManager.CoreTypes.UInt32) { return(ConvertExpression.MakeImplicitNumericConversion(ec, expr, expr.Type, TypeManager.CoreTypes.Int64)); } return(expr); }
Expression SetUserDefinedOperationInformations(ResolveContext rc, OverloadResolution r) {//TODO:Is It OK if (r.BestCandidateErrors != OverloadResolutionErrors.None) { rc.Report.Error(0, loc, "Operator `{0}' is ambiguous on an operand of type `{1}'", OperName(Oper), Expr.Type.ToString()); return(r.CreateInvocation(null)); } IMethod method = (IMethod)r.BestCandidate; var operands = r.GetArgumentsWithConversions(); this.operatortype = ResolveContext.GetLinqNodeType(this.Oper, rc.checkForOverflow); this.isLiftedOperator = method is OverloadResolution.ILiftedOperator; this.ResolvedType = method.ReturnType; this.Expr = operands[0]; this.userDefinedOperatorMethod = method; _resolved = true; return(this); }
private Binary getOperator(Linq.ExpressionType type) { switch (type) { case Linq.ExpressionType.Add: return(Binary.Add); case Linq.ExpressionType.Subtract: return(Binary.Subtract); case Linq.ExpressionType.Multiply: return(Binary.Multiply); case Linq.ExpressionType.Divide: return(Binary.Divide); case Linq.ExpressionType.Power: return(Binary.Power); } throw new Exception("Can't parse a non-binary operator"); }
public UnaryExpression(bool postfix, TokenKind kind, Expression expression) { _expression = expression; if (postfix) { switch (kind) { case TokenKind.Increment: _op = MSAst.ExpressionType.PostIncrementAssign; break; case TokenKind.Decrement: _op = MSAst.ExpressionType.PostDecrementAssign; break; default: throw Assert.Unreachable; } } else { switch (kind) { case TokenKind.Increment: _op = MSAst.ExpressionType.PreIncrementAssign; break; case TokenKind.Decrement: _op = MSAst.ExpressionType.PreDecrementAssign; break; case TokenKind.LogicalNot: _op = MSAst.ExpressionType.Not; break; default: throw Assert.Unreachable; } } }
public override object BinaryOperation(Func <object> proceed, object self, System.Linq.Expressions.ExpressionType operation, object value) { var supertype = ((dynamic)self).Supertype(); var isObject = (supertype != "Value" && supertype != "Null"); switch (operation) { case ExpressionType.Equal: return((value == null) ? (!isObject && _localValue == null) : (isObject ? false : (_localValue != null && value.Equals(_localValue)))); case ExpressionType.NotEqual: return((value == null) ? (isObject || _localValue != null) : (isObject ? false : (_localValue == null || !value.Equals(_localValue)))); case ExpressionType.GreaterThan: return((value == null) ? false : (isObject ? false : (_localValue != null && (Compare(_localValue, value) > 0)))); case ExpressionType.GreaterThanOrEqual: return((value == null) ? false : (isObject ? false : (_localValue != null && (Compare(_localValue, value) >= 0)))); case ExpressionType.LessThan: return((value == null) ? false : (isObject ? false : (_localValue != null && (Compare(_localValue, value) < 0)))); case ExpressionType.LessThanOrEqual: return((value == null) ? false : (isObject ? false : (_localValue != null && (Compare(_localValue, value) <= 0)))); } return(proceed()); }
internal MSAst Operator(ExpressionType op, MSAst left) { return(Operator(op, left, null)); }
public override System.Dynamic.UnaryOperationBinder CreateUnaryOperationBinder(System.Linq.Expressions.ExpressionType operation) { return(base.CreateUnaryOperationBinder(operation)); }
private static RemoteLinq.UnaryOperator ToUnaryOperator(this SystemLinq.ExpressionType expressionType) => (RemoteLinq.UnaryOperator)(int) expressionType;
public LiftedUnaryOperator(MSAst.ExpressionType @operator, Expression operand) { Operator = @operator; Operand = operand; }
private static RemoteLinq.NewArrayType ToNewArrayType(this SystemLinq.ExpressionType expressionType) => (RemoteLinq.NewArrayType)(int) expressionType;
private Expression GetComparisonLinqExpression([NotNull] ParameterExpression shapes, NodeType type) { List <BinaryExpression> comparisons = new List <BinaryExpression>(); List <Expression> body = new List <Expression>(); List <ParameterExpression> vars = new List <ParameterExpression>(); Expression last = null; float lastConst = 0; foreach (Expression exp in Expressions.Select(e => e.GetLinqExpression(shapes))) { Expression expression = exp; Debug.Assert(expression != null, "expression != null"); ConstantExpression constExp = expression as ConstantExpression; if (constExp != null) { Debug.Assert(constExp.Value is float); float curr = (float)constExp.Value; if (last != null) { switch (type) { // TODO tolerance case NodeType.GreaterThan: if (lastConst <= curr) { return(Expression.Constant(false)); } break; case NodeType.LessThan: if (lastConst >= curr) { return(Expression.Constant(false)); } break; case NodeType.GreaterThanOrEqual: if (lastConst < curr) { return(Expression.Constant(false)); } break; case NodeType.LessThanOrEqual: if (lastConst > curr) { return(Expression.Constant(false)); } break; } } lastConst = curr; } else { ParameterExpression varExp = Expression.Variable(typeof(float)); vars.Add(varExp); body.Add(Expression.Assign(varExp, expression)); expression = varExp; } if (last != null) { comparisons.Add(Expression.MakeBinary(type, last, expression)); } last = expression; } Expression result = null; foreach (BinaryExpression comparison in comparisons) { Debug.Assert(comparison != null, "comparison != null"); ConstantExpression leftConst, rightConst; if ((leftConst = comparison.Left as ConstantExpression) != null && (rightConst = comparison.Right as ConstantExpression) != null) { #if DEBUG Debug.Assert(leftConst.Value is float); Debug.Assert(rightConst.Value is float); float leftVal = (float)leftConst.Value; float rightVal = (float)rightConst.Value; switch (type) { case NodeType.GreaterThan: Debug.Assert(leftVal > rightVal); break; case NodeType.LessThan: Debug.Assert(leftVal > rightVal); break; case NodeType.GreaterThanOrEqual: Debug.Assert(leftVal > rightVal); break; case NodeType.LessThanOrEqual: Debug.Assert(leftVal > rightVal); break; default: Debug.Assert(false); throw new ArgumentOutOfRangeException(); } #endif continue; } result = result == null ? comparison : Expression.AndAlso(result, comparison); } body.Add(result); return(result == null ? (Expression)Expression.Constant(true) : Expression.Block(typeof(bool), vars, body)); }
public override BinaryOperationBinder CreateBinaryOperationBinder(System.Linq.Expressions.ExpressionType operation) { return(new TjsBinaryOperationBinder(this, operation)); }
public Rule(string comparisonPredicate, System.Linq.Expressions.ExpressionType comparisonOperator, string comparisonValue) { ComparisonPredicate = comparisonPredicate; ComparisonOperator = comparisonOperator; ComparisonValue = comparisonValue; }
/// <summary> /// 二元运算符表达式 /// </summary> /// <param name="left"></param> /// <param name="right"></param> /// <param name="type"></param> /// <returns></returns> string BinarExpressionProvider(System.Linq.Expressions.Expression left, System.Linq.Expressions.Expression right, System.Linq.Expressions.ExpressionType type) { string where = "("; //先处理左边 string leftStr = ExpressionRouter(left); //获取实体列的特性 List <EntityPropColumnAttributes> columnAttrList = AttributeHelper.GetEntityColumnAtrributes <TEntity>(); var list = columnAttrList.Where(w => w.propName == leftStr); if (list.Count() > 0) { EntityPropColumnAttributes columnAttribute = list.First(); leftStr = columnAttribute.fieldName; } //节点类型 string typeStr = ExpressionTypeCast(type); //再处理右边 string rightStr = RightExpressionRouter(right).ToStr(); where += leftStr; where += typeStr; if (rightStr == "null") { if (where.EndsWith(" =")) { where = where.Substring(0, where.Length - 2) + " is null"; } else if (where.EndsWith("<>")) { where = where.Substring(0, where.Length - 2) + " is not null"; } } else { //如果左侧包含(则代表左侧非字段 if (leftStr.Contains("(")) { where += rightStr; } else { int num = random.Next(100, 999); where += "@" + leftStr + num; listPara.Add(new SqlParameter("@" + leftStr + num, rightStr)); } } return(where += ")"); }