public void PushBinary(BinaryOperator binaryOperator) { ExpressionNode rightExpressionNode = _expressionStack.Pop(); ExpressionNode leftExpressionNode = _expressionStack.Pop(); BinaryExpression binaryExpression = new BinaryExpression(binaryOperator, leftExpressionNode, rightExpressionNode); _expressionStack.Push(binaryExpression); }
public PartExtractor(LogicalOperator logicalOperator) { if (logicalOperator == LogicalOperator.And) _operatorToBreakAt = BinaryOperator.LogicalAnd; else _operatorToBreakAt = BinaryOperator.LogicalOr; }
public static BinaryOperator NegateBinaryOp(BinaryOperator op) { if (op == BinaryOperator.LogicalAnd) return BinaryOperator.LogicalOr; if (op == BinaryOperator.LogicalOr) return BinaryOperator.LogicalAnd; if (op == BinaryOperator.Equal) return BinaryOperator.NotEqual; if (op == BinaryOperator.NotEqual) return BinaryOperator.Equal; if (op == BinaryOperator.Greater) return BinaryOperator.LessOrEqual; if (op == BinaryOperator.GreaterOrEqual) return BinaryOperator.Less; if (op == BinaryOperator.Less) return BinaryOperator.GreaterOrEqual; if (op == BinaryOperator.LessOrEqual) return BinaryOperator.Greater; return null; }
private static void Add(TokenId tokenId, string text, bool isKeyword, bool isQueryKeyword, UnaryOperator unOp, BinaryOperator binOp) { TokenInfo info = new TokenInfo(tokenId, text, isKeyword, isQueryKeyword, unOp, binOp); _infosById.Add(tokenId, info); if (text != null) _infosByText.Add(text, info); }
private TokenInfo(TokenId tokenId, string text, bool isKeyword, bool isQueryKeyword, UnaryOperator unOp, BinaryOperator binOp) { _tokenId = tokenId; _text = text; _isKeyword = isKeyword; _isQueryKeyword = isQueryKeyword; _unaryOperator = unOp; _binaryOperator = binOp; }
void IErrorReporter.InvalidOperatorForAllAny(SourceRange sourceRange, BinaryOperator foundOp) { string message = String.Format(CultureInfo.CurrentCulture, Resources.InvalidOperatorForAllAny, foundOp.TokenText); HandleError(sourceRange, ErrorId.InvalidOperatorForAllAny, message); }
void IErrorReporter.CannotApplyOperator(BinaryOperator op, Type leftType, Type rightType) { string message = String.Format( CultureInfo.CurrentCulture, Resources.CannotApplyBinaryOp, op.TokenText, FormattingHelpers.FormatType(leftType), FormattingHelpers.FormatType(rightType) ); HandleError(ErrorId.CannotApplyBinaryOperator, message); }
void IErrorReporter.AmbiguousOperatorOverloading(BinaryOperator op, Type leftType, Type rightType) { string message = String.Format( CultureInfo.CurrentCulture, Resources.AmbiguousOperatorOverloading, op.TokenText, FormattingHelpers.FormatType(leftType), FormattingHelpers.FormatType(rightType) ); HandleError(ErrorId.AmbiguousOperatorOverloading, message); }
void IErrorReporter.AmbiguousOperator(BinaryOperator op, Type leftType, Type rightType, MethodInfo opMethod1, MethodInfo opMethod2) { string message = String.Format( CultureInfo.CurrentCulture, Resources.AmbiguousBinaryOperator, op.TokenText, FormattingHelpers.FormatType(leftType), FormattingHelpers.FormatType(rightType), FormattingHelpers.FormatMethodInfo(opMethod1), FormattingHelpers.FormatMethodInfo(opMethod2) ); HandleError(ErrorId.AmbiguousBinaryOperator, message); }
public static RuntimeException BinaryOperatorFailed(BinaryOperator binaryOperator, MethodInfo operatorMethod, Type leftOperandType, Type rightOperandType, object left, object right, Exception exception) { if (binaryOperator == null) throw new ArgumentNullException("binaryOperator"); if (operatorMethod == null) throw new ArgumentNullException("operatorMethod"); if (leftOperandType == null) throw new ArgumentNullException("leftOperandType"); if (rightOperandType == null) throw new ArgumentNullException("rightOperandType"); if (exception == null) throw new ArgumentNullException("exception"); string message = String.Format( CultureInfo.CurrentCulture, Resources.BinaryOperatorFailed, FormattingHelpers.FormatType(leftOperandType), binaryOperator.TokenText, FormattingHelpers.FormatType(rightOperandType), FormattingHelpers.FormatMethodInfo(operatorMethod), left, right, exception.Message, Environment.NewLine ); return new RuntimeException(message, exception); }
public BinaryExpression(BinaryOperator op, ExpressionNode left, ExpressionNode right) { _op = op; _left = left; _right = right; }
public MethodInfo BindOperator(BinaryOperator op, Type leftOperandType, Type rightOperandType) { if (leftOperandType == typeof(DBNull) || rightOperandType == typeof(DBNull)) return _binaryOperatorPlaceholder; MethodInfo result; try { List<MethodInfo> methodList = new List<MethodInfo>(); // Get the operator method from left... methodList.AddRange(OperatorMethodCache.GetOperatorMethods(leftOperandType, op)); if (leftOperandType != rightOperandType) { List<Type> declaringTypes = new List<Type>(); foreach (MethodInfo info in methodList) { if (!declaringTypes.Contains(info.DeclaringType)) declaringTypes.Add(info.DeclaringType); } foreach (MethodInfo rightOperatorMethod in OperatorMethodCache.GetOperatorMethods(rightOperandType, op)) { if (!declaringTypes.Contains(rightOperatorMethod.DeclaringType)) methodList.Add(rightOperatorMethod); } } // ...from the builtin ones. methodList.AddRange(OperatorMethodCache.GetOperatorMethods(typeof(BuiltInOperators), op)); // Perform overload resolution. MethodInfo[] methods = methodList.ToArray(); result = BindMethodInfo(methods, new Type[] {leftOperandType, rightOperandType}); } catch (InvocationIsAmbiguousException ex) { _errorReporter.AmbiguousOperator(op, leftOperandType, rightOperandType, ex.Method1, ex.Method2); // Avoid cascading errors result = ex.Method1; } // Due to the lack of generic operator methods we have to manually some rules here. // // 1. = and <>. There exists an operator method op_X(object, object) that would allow // comparing any type to any other type. This is not correct. We want to enforce // that both type are compatible (or if any operand is an interface). // 2. & and | for enums. There exists an operator method op_X(Enum, Enum) that would allow // combining any enum with any other enum. This is not correct. We want to enforce // that both enums are the same. if (result == _generalEqualityOperator || result == _generalInequalityOperator) { if (!leftOperandType.IsAssignableFrom(rightOperandType) && !rightOperandType.IsAssignableFrom(leftOperandType) && !leftOperandType.IsInterface && !rightOperandType.IsInterface) return null; } else if (result == _enumBitAndOperator || result == _enumBitOrOperator) { if (leftOperandType != rightOperandType) return null; } return result; }
private static JoinOperator JoinOperatorFromBinaryOperator(BinaryOperator op) { // TODO: Uncomment the following lines if we can create optimized nodes // for other joins than equijoin. if (op == BinaryOperator.Equal) return JoinOperator.Equal; // else if (expression.Op == BinaryOperator.Less) // return JoinOperator.Less; // else if (expression.Op == BinaryOperator.LessOrEqual) // return JoinOperator.LessOrEqual; // else if (expression.Op == BinaryOperator.Greater) // return JoinOperator.Greater; // else if (expression.Op == BinaryOperator.GreaterOrEqual) // return JoinOperator.GreaterOrEqual; else return JoinOperator.None; }
public override ExpressionNode VisitUnaryExpression(UnaryExpression expression) { // First visit arguments base.VisitUnaryExpression(expression); if (expression.Op == UnaryOperator.LogicalNot) { // Replace "NOT NOT expr" by "expr" UnaryExpression unOp = expression.Operand as UnaryExpression; if (unOp != null) { if (unOp.Op == UnaryOperator.LogicalNot) { return(VisitExpression(unOp.Operand)); } } // Replace "NOT expr IS NULL" and "NOT expr IS NOT NULL" by // "expr IS NOT NULL" and "expr IS NULL" resp. IsNullExpression isNull = expression.Operand as IsNullExpression; if (isNull != null) { isNull.Negated = !isNull.Negated; return(VisitExpression(isNull)); } // Apply negation on EXISTS ExistsSubselect existsSubselect = expression.Operand as ExistsSubselect; if (existsSubselect != null) { existsSubselect.Negated = !existsSubselect.Negated; return(existsSubselect); } // Apply negation on ALL/ANY subquery AllAnySubselect allAnySubselect = expression.Operand as AllAnySubselect; if (allAnySubselect != null) { allAnySubselect.Op = AstUtil.NegateBinaryOp(allAnySubselect.Op); allAnySubselect.Type = (allAnySubselect.Type == AllAnySubselect.AllAnyType.All) ? AllAnySubselect.AllAnyType.Any : AllAnySubselect.AllAnyType.All; return(allAnySubselect); } // Apply De Morgan's law BinaryExpression binOp = expression.Operand as BinaryExpression; if (binOp != null) { BinaryOperator negatedOp = AstUtil.NegateBinaryOp(binOp.Op); if (negatedOp != null) { ExpressionNode newLeft; ExpressionNode newRight; if (binOp.Op == BinaryOperator.LogicalAnd || binOp.Op == BinaryOperator.LogicalOr) { newLeft = new UnaryExpression(expression.Op, binOp.Left); newRight = new UnaryExpression(expression.Op, binOp.Right); } else { newLeft = binOp.Left; newRight = binOp.Right; } binOp.Op = negatedOp; binOp.Left = newLeft; binOp.Right = newRight; return(VisitExpression(binOp)); } } } return(expression); }