public override Expression VisitRelationalExpression(IRelationalExpression relationalExpressionParam, IMetadataResolver context)
            {
                Expression left  = relationalExpressionParam.LeftOperand.Accept(this, context);
                Expression right = relationalExpressionParam.RightOperand.Accept(this, context);

                return(new BinaryExpressionBuilder(relationalExpressionParam, left, right).Build());
            }
 public override void VisitRelationalExpression(IRelationalExpression expr, IList <IStatement> context)
 {
     foreach (var csExpr in expr.OperatorOperands)
     {
         csExpr.Accept(this, context);
     }
 }
Example #3
0
        public override IAssignableExpression VisitRelationalExpression(IRelationalExpression expr,
                                                                        IList <IStatement> context)
        {
            BinaryOperator op = BinaryOperator.Unknown;

            if (expr.OperatorSign.NodeType == CSharpTokenType.GT)
            {
                op = BinaryOperator.GreaterThan;
            }
            else if (expr.OperatorSign.NodeType == CSharpTokenType.GE)
            {
                op = BinaryOperator.GreaterThanOrEqual;
            }
            else if (expr.OperatorSign.NodeType == CSharpTokenType.LE)
            {
                op = BinaryOperator.LessThanOrEqual;
            }
            else if (expr.OperatorSign.NodeType == CSharpTokenType.LT)
            {
                op = BinaryOperator.LessThan;
            }

            return(new BinaryExpression
            {
                LeftOperand = ToSimpleExpression(expr.LeftOperand, context),
                Operator = op,
                RightOperand = ToSimpleExpression(expr.RightOperand, context)
            });
        }
        /// <summary>
        /// Negates the relational expression.
        /// </summary>
        /// <param name="factory">
        /// The factory.
        /// </param>
        /// <param name="relationalExpression">
        /// The relational expression.
        /// </param>
        private static void NegateRelationalExpression(CSharpElementFactory factory, IRelationalExpression relationalExpression)
        {
            var operatorSign = relationalExpression.OperatorSign.GetText();

              switch (operatorSign)
              {
            case "<":
              operatorSign = ">=";
              break;
            case ">":
              operatorSign = "<=";
              break;
            case "<=":
              operatorSign = ">";
              break;
            case ">=":
              operatorSign = "<";
              break;
              }

              var expression = factory.CreateExpression(string.Format("{0} {1} {2}", relationalExpression.LeftOperand.GetText(), operatorSign, relationalExpression.RightOperand.GetText()));

              relationalExpression.ReplaceBy(expression);
        }