Example #1
0
        public override object VisitUnaryOperatorExpression(UnaryOperatorExpression unary, object data)
        {
            // lifted operators can't be transformed
            if (unary.Annotation <LiftedOperator>() != null || unary.Expression.Annotation <LiftedOperator>() != null)
            {
                return(base.VisitUnaryOperatorExpression(unary, data));
            }

            // Remove double negation
            // !!a
            if (unary.Operator == UnaryOperatorType.Not &&
                unary.Expression is UnaryOperatorExpression &&
                (unary.Expression as UnaryOperatorExpression).Operator == UnaryOperatorType.Not)
            {
                AstNode newNode = (unary.Expression as UnaryOperatorExpression).Expression;
                unary.ReplaceWith(newNode);
                return(newNode.AcceptVisitor(this, data));
            }

            // Push through binary operation
            // !((a) op (b))
            BinaryOperatorExpression binaryOp = unary.Expression as BinaryOperatorExpression;

            if (unary.Operator == UnaryOperatorType.Not && binaryOp != null)
            {
                bool successful = true;
                switch (binaryOp.Operator)
                {
                case BinaryOperatorType.Equality:
                    binaryOp.Operator = BinaryOperatorType.InEquality;
                    break;

                case BinaryOperatorType.InEquality:
                    binaryOp.Operator = BinaryOperatorType.Equality;
                    break;

                case BinaryOperatorType.GreaterThan:                         // TODO: these are invalid for floats (stupid NaN)
                    binaryOp.Operator = BinaryOperatorType.LessThanOrEqual;
                    break;

                case BinaryOperatorType.GreaterThanOrEqual:
                    binaryOp.Operator = BinaryOperatorType.LessThan;
                    break;

                case BinaryOperatorType.LessThanOrEqual:
                    binaryOp.Operator = BinaryOperatorType.GreaterThan;
                    break;

                case BinaryOperatorType.LessThan:
                    binaryOp.Operator = BinaryOperatorType.GreaterThanOrEqual;
                    break;

                default:
                    successful = false;
                    break;
                }
                if (successful)
                {
                    unary.ReplaceWith(binaryOp);
                    return(binaryOp.AcceptVisitor(this, data));
                }

                successful = true;
                switch (binaryOp.Operator)
                {
                case BinaryOperatorType.ConditionalAnd:
                    binaryOp.Operator = BinaryOperatorType.ConditionalOr;
                    break;

                case BinaryOperatorType.ConditionalOr:
                    binaryOp.Operator = BinaryOperatorType.ConditionalAnd;
                    break;

                default:
                    successful = false;
                    break;
                }
                if (successful)
                {
                    binaryOp.Left.ReplaceWith(e => new UnaryOperatorExpression(UnaryOperatorType.Not, e));
                    binaryOp.Right.ReplaceWith(e => new UnaryOperatorExpression(UnaryOperatorType.Not, e));
                    unary.ReplaceWith(binaryOp);
                    return(binaryOp.AcceptVisitor(this, data));
                }
            }
            return(base.VisitUnaryOperatorExpression(unary, data));
        }
Example #2
0
        public override void VisitUnaryOperatorExpression(UnaryOperatorExpression unary)
        {
            base.VisitUnaryOperatorExpression (unary);

            Identifier identifier = unary.FindIdentifier();
            if (identifier == null)
                return;

            switch (unary.Operator)
            {
                case UnaryOperatorType.Increment:
                case UnaryOperatorType.Decrement:
                    unary.ReplaceWith (GetAssignmentExpression (identifier, unary));
                    break;

                case UnaryOperatorType.PostDecrement:
                case UnaryOperatorType.PostIncrement:

                    var variable = new IdentifierExpression (identifier.Name);
                    var name = new PrimitiveExpression (identifier.Name);

                    unary.ReplaceWith (GetHookExpression ("LogPostfix", GetSubmissionId(), GetId(), unary.Clone(), name, variable));
                    break;
            }
        }
        public override void VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression)
        {
            base.VisitUnaryOperatorExpression(unaryOperatorExpression);

            if (unaryOperatorExpression.Operator == UnaryOperatorType.Minus &&
                unaryOperatorExpression.Expression is PrimitiveExpression &&
                (dynamic)((PrimitiveExpression)unaryOperatorExpression.Expression).Value == 0)
                unaryOperatorExpression.ReplaceWith(new PrimitiveExpression(0));
        }