Beispiel #1
0
 private bool IsBinaryExpression(Expression expression, out Expression binaryExpression, out bool isWrappedInUnary)
 {
     binaryExpression = null;
     isWrappedInUnary = false;
     V_0 = expression as BinaryExpression;
     V_1 = expression as UnaryExpression;
     if (V_0 != null)
     {
         binaryExpression = V_0;
         return(true);
     }
     if (V_1 == null || V_1.get_Operator() != 11 && V_1.get_Operator() != 1 || V_1.get_Operand() as BinaryExpression == null)
     {
         return(false);
     }
     if (V_1.get_Operator() != 1)
     {
         binaryExpression = V_1.get_Operand();
     }
     else
     {
         binaryExpression = Negator.Negate(V_1.get_Operand(), this.typeSystem);
         if (binaryExpression as BinaryExpression == null)
         {
             isWrappedInUnary = true;
         }
     }
     return(true);
 }
Beispiel #2
0
		private static Expression NegateConditionExpression(Expression expression, TypeSystem typeSystem)
		{
			stackVariable1 = (ConditionExpression)expression;
			stackVariable1.set_Then(Negator.Negate(stackVariable1.get_Then(), typeSystem));
			stackVariable1.set_Else(Negator.Negate(stackVariable1.get_Else(), typeSystem));
			return stackVariable1;
		}
Beispiel #3
0
		private static Expression NegateUnaryExpression(Expression expression, TypeSystem typeSystem)
		{
			V_0 = (UnaryExpression)expression;
			V_1 = V_0.get_Operator();
			if (V_1 == 1)
			{
				V_0.set_Operator(11);
				return V_0;
			}
			if (V_1 != 8 && V_1 != 11)
			{
				throw new ArgumentException("expression");
			}
			if (V_0.get_Operand().get_CodeNodeType() == 24)
			{
				V_2 = Negator.NegateBinaryExpression(V_0.get_Operand() as BinaryExpression, typeSystem);
				V_0.set_Operand(V_2);
				return V_0;
			}
			if (V_0.get_Operand().get_CodeNodeType() != 23 || (V_0.get_Operand() as UnaryExpression).get_Operator() != 1)
			{
				V_0.set_Operator(1);
			}
			else
			{
				V_0.set_Operand((V_0.get_Operand() as UnaryExpression).get_Operand());
			}
			return V_0;
		}
        private void TryMergeExpressions(ConditionStatement node)
        {
            if (!(node.Condition is UnaryExpression))
            {
                return;
            }

            UnaryExpression unaryExpression = (UnaryExpression)node.Condition;

            if (unaryExpression.Operator != UnaryOperator.LogicalNot)
            {
                return;
            }

            if (unaryExpression.Operand is MethodInvocationExpression || unaryExpression.Operand is PropertyReferenceExpression)
            {
                return;
            }

            if (!IsConditionExpression(unaryExpression.Operand))
            {
                return;
            }

            node.Condition = Negator.Negate(unaryExpression.Operand, typeSystem);
        }
        private void InvertIfStatement(IfStatement theIf)
        {
            theIf.Condition = Negator.Negate(theIf.Condition, context.MethodContext.Method.Module.TypeSystem);
            BlockStatement swap = theIf.Else;

            theIf.Else = theIf.Then;
            theIf.Then = swap;
        }
 private void InvertIfStatement(IfStatement theIf)
 {
     theIf.set_Condition(Negator.Negate(theIf.get_Condition(), this.context.get_MethodContext().get_Method().get_Module().get_TypeSystem()));
     V_0 = theIf.get_Else();
     theIf.set_Else(theIf.get_Then());
     theIf.set_Then(V_0);
     return;
 }
Beispiel #7
0
		private Expression SimplifyBooleanComparison(BinaryExpression expression)
		{
			V_0 = this.IsFalse(expression.get_Right());
			if (!V_0 || expression.get_Operator() != 9 && V_0 || expression.get_Operator() != 10)
			{
				return expression;
			}
			V_1 = new List<Instruction>(expression.get_MappedInstructions());
			V_1.AddRange(expression.get_Right().get_UnderlyingSameMethodInstructions());
			return Negator.Negate(expression.get_Left(), this.typeSystem).CloneAndAttachInstructions(V_1);
		}
        /// <summary>
        /// Simplifies boolean expressions.
        /// </summary>
        /// <param name="expression">The expression to be simplified.</param>
        /// <returns>Returns the simplified expression.</returns>
        private Expression SimplifyBooleanComparison(BinaryExpression expression)
        {
            bool isFalse = IsFalse(expression.Right);

            if (isFalse && expression.Operator == BinaryOperator.ValueEquality ||
                !isFalse && expression.Operator == BinaryOperator.ValueInequality)
            {
                List <Instruction> instructions = new List <Instruction>(expression.MappedInstructions);
                instructions.AddRange(expression.Right.UnderlyingSameMethodInstructions);
                return(Negator.Negate(expression.Left, typeSystem).CloneAndAttachInstructions(instructions));
            }
            return(expression);
        }
Beispiel #9
0
		private static Expression NegateBinaryExpression(Expression expression, TypeSystem typeSystem)
		{
			V_0 = (BinaryExpression)expression;
			if (Negator.IsLogicalOperator(V_0.get_Operator()))
			{
				if (V_0.get_Operator() == 12)
				{
					stackVariable48 = 11;
				}
				else
				{
					stackVariable48 = 12;
				}
				V_2 = stackVariable48;
				V_0.set_Left(Negator.Negate(V_0.get_Left(), typeSystem));
				V_0.set_Operator(V_2);
				V_0.set_Right(Negator.Negate(V_0.get_Right(), typeSystem));
				return V_0;
			}
			if (!Negator.IsBitwiseOperator(V_0.get_Operator()) || !String.op_Equality(V_0.get_ExpressionType().get_FullName(), typeSystem.get_Boolean().get_FullName()))
			{
				if (!Negator.TryGetInverseOperator(V_0.get_Operator(), out V_1))
				{
					throw new ArgumentException("expression");
				}
				V_0.set_Operator(V_1);
				return V_0;
			}
			if (V_0.get_Operator() != 23)
			{
				V_0.set_Left(Negator.Negate(V_0.get_Left(), typeSystem));
				stackVariable32 = V_0;
				if (V_0.get_Operator() == 22)
				{
					stackVariable36 = 21;
				}
				else
				{
					stackVariable36 = 22;
				}
				stackVariable32.set_Operator(stackVariable36);
				V_0.set_Right(Negator.Negate(V_0.get_Right(), typeSystem));
			}
			else
			{
				V_0.set_Operator(9);
			}
			return V_0;
		}
Beispiel #10
0
		public static Expression Negate(Expression expression, TypeSystem typeSystem)
		{
			if (expression == null)
			{
				return null;
			}
			V_1 = expression.get_CodeNodeType();
			if (V_1 == 23)
			{
				return Negator.NegateUnaryExpression(expression, typeSystem);
			}
			if (V_1 == 24)
			{
				V_2 = (BinaryExpression)expression;
				if (!Negator.IsMathOperator(V_2.get_Operator()))
				{
					return Negator.NegateBinaryExpression(expression, typeSystem);
				}
				if (String.op_Equality(V_2.get_ExpressionType().get_FullName(), "System.Boolean"))
				{
					return new UnaryExpression(1, expression, null);
				}
				return new BinaryExpression(9, expression, new LiteralExpression((object)0, typeSystem, null), typeSystem, null, false);
			}
			if (V_1 == 36)
			{
				return Negator.NegateConditionExpression(expression, typeSystem);
			}
			if (expression.get_CodeNodeType() == 22 && String.op_Equality(expression.get_ExpressionType().get_FullName(), typeSystem.get_Boolean().get_FullName()))
			{
				return new LiteralExpression((object)(!(Boolean)(expression as LiteralExpression).get_Value()), typeSystem, expression.get_UnderlyingSameMethodInstructions());
			}
			V_0 = expression.get_ExpressionType().GetDefaultValueExpression(typeSystem) as LiteralExpression;
			if (V_0 == null)
			{
				return new UnaryExpression(1, expression, null);
			}
			if (String.op_Equality(V_0.get_ExpressionType().get_FullName(), typeSystem.get_Boolean().get_FullName()))
			{
				return new UnaryExpression(1, expression, null);
			}
			return new BinaryExpression(9, expression, V_0, typeSystem, null, false);
		}
 private void TryMergeExpressions(ConditionStatement node)
 {
     if (node.get_Condition() as UnaryExpression == null)
     {
         return;
     }
     V_0 = (UnaryExpression)node.get_Condition();
     if (V_0.get_Operator() != 1)
     {
         return;
     }
     if (V_0.get_Operand() as MethodInvocationExpression != null || V_0.get_Operand() as PropertyReferenceExpression != null)
     {
         return;
     }
     if (!this.IsConditionExpression(V_0.get_Operand()))
     {
         return;
     }
     node.set_Condition(Negator.Negate(V_0.get_Operand(), this.typeSystem));
     return;
 }
        private bool IsBinaryExpression(Expression expression, out Expression binaryExpression, out bool isWrappedInUnary)
        {
            binaryExpression = null;
            isWrappedInUnary = false;

            BinaryExpression nestedBinary = expression as BinaryExpression;
            UnaryExpression  nestedUnary  = expression as UnaryExpression;

            if (nestedBinary != null)
            {
                binaryExpression = nestedBinary;

                return(true);
            }
            else if (nestedUnary != null &&
                     (nestedUnary.Operator == UnaryOperator.None || nestedUnary.Operator == UnaryOperator.LogicalNot) &&
                     nestedUnary.Operand is BinaryExpression)
            {
                if (nestedUnary.Operator == UnaryOperator.LogicalNot)
                {
                    binaryExpression = Negator.Negate(nestedUnary.Operand, typeSystem);
                    if (!(binaryExpression is BinaryExpression))
                    {
                        // Currently the only boolean expression that cannot be negated (without wrapping it in unary with logical not)
                        // is binary expression with XOR operator.
                        isWrappedInUnary = true;
                    }
                }
                else
                {
                    binaryExpression = nestedUnary.Operand;
                }

                return(true);
            }

            return(false);
        }
        /// <summary>
        /// Fixes expressions, generated for brtrue and brfalse. As 0,false and null are all represented as 0 in IL, this step adds the correct constant
        /// to the expression.
        /// </summary>
        /// <param name="expression">The expression.</param>
        /// <param name="isBrTrue">The type of jump.</param>
        /// <returns>Returns the fixed expression.</returns>
        private ICodeNode FixBranchingExpression(Expression expression, Instruction branch)
        {
            /// example:
            /// before the step:
            /// ...
            /// a //a is int32, opperation is brfalse
            /// After the step:
            /// ...
            /// a == 0

            bool isBrTrue = branch.OpCode.Code == Code.Brtrue || branch.OpCode.Code == Code.Brtrue_S;

            TypeReference    expressionType = expression.ExpressionType;
            BinaryExpression newCondition;
            BinaryOperator   operation = BinaryOperator.ValueEquality;

            Instruction[] instructions = new Instruction[] { branch };
            if (isBrTrue)
            {
                operation = BinaryOperator.ValueInequality;
            }
            if (expressionType.Name == "Boolean" || expressionType.Name.Contains("Boolean "))
            {
                Expression operand;
                if (!isBrTrue)
                {
                    operand = Negator.Negate(expression, typeSystem);
                }
                else
                {
                    operand = expression;
                }

                Expression result;
                if (expression is SafeCastExpression)
                {
                    result = new BinaryExpression(operation, expression, GetLiteralExpression(false, null), typeSystem, instructions);
                }
                else
                {
                    result = new UnaryExpression(UnaryOperator.None, operand, instructions);
                }

                return(result);
            }
            if (expressionType.Name == "Char")
            {
                newCondition = new BinaryExpression(operation, expression, GetLiteralExpression('\u0000', null), typeSystem, instructions);
                newCondition.ExpressionType = typeSystem.Boolean;
            }
            if (!expressionType.IsPrimitive)
            {
                TypeDefinition expressionTypeDefinition = expressionType.Resolve();

                /// expressionTypeDefinition can resolve to null when dealing with generics
                if (expressionTypeDefinition != null && expressionTypeDefinition.IsEnum && !expressionType.IsArray)
                {
                    ///Find the field that corresponds to 0
                    FieldDefinition field = null;
                    foreach (FieldDefinition enumField in expressionTypeDefinition.Fields)
                    {
                        if (enumField.Constant != null && enumField.Constant.Value != null && enumField.Constant.Value.Equals(0))
                        {
                            field = enumField;
                            break;
                        }
                    }

                    if (field == null)
                    {
                        newCondition = new BinaryExpression(operation, expression, GetLiteralExpression(0, null), typeSystem, instructions);
                        newCondition.ExpressionType = typeSystem.Boolean;
                    }
                    else
                    {
                        newCondition = new BinaryExpression(operation, expression, new EnumExpression(field, null), typeSystem, instructions);
                        newCondition.ExpressionType = typeSystem.Boolean;
                    }
                }
                else
                {
                    /// If it is not primitive class, then the check should be against null
                    newCondition = new BinaryExpression(operation, expression, GetLiteralExpression(null, null), typeSystem, instructions);
                    newCondition.ExpressionType = typeSystem.Boolean;
                }
            }
            else
            {
                /// This is primitive type, the check should be against 0
                newCondition = new BinaryExpression(operation, expression, GetLiteralExpression(0, null), typeSystem, instructions);
                newCondition.ExpressionType = typeSystem.Boolean;
            }
            return(newCondition);
        }
        private bool TryTransformTernary(ConditionExpression ternary, out Expression transformed)
        {
            transformed = null;

            LiteralExpression literal;
            bool isLiteralInThen;
            LiteralExpression literalInThen = ternary.Then as LiteralExpression;
            LiteralExpression literalInElse = ternary.Else as LiteralExpression;

            // Transforms the case: Method() && someVar > 12 ? 0 : 1
            if (literalInThen != null && literalInElse != null)
            {
                bool areValidValues  = false;
                bool shouldBeNegated = false;
                if (literalInThen.ExpressionType.FullName == Constants.Int32 &&
                    literalInElse.ExpressionType.FullName == Constants.Int32)
                {
                    int valueInThen = (int)literalInThen.Value;
                    int valueInElse = (int)literalInElse.Value;
                    if ((valueInThen == 0 && valueInElse == 1) ||
                        (valueInThen == 1 && valueInElse == 0))
                    {
                        areValidValues = true;
                        if (valueInThen == 0 && valueInElse == 1)
                        {
                            shouldBeNegated = true;
                        }
                    }
                }
                else if (literalInThen.ExpressionType.FullName == Constants.Boolean &&
                         literalInElse.ExpressionType.FullName == Constants.Boolean)
                {
                    bool valueInThen = (bool)literalInThen.Value;
                    bool valueInElse = (bool)literalInElse.Value;
                    if ((valueInThen == false && valueInElse == true) ||
                        (valueInThen == true && valueInElse == false))
                    {
                        areValidValues = true;
                        if (valueInThen == false && valueInElse == true)
                        {
                            shouldBeNegated = true;
                        }
                    }
                }

                if (areValidValues)
                {
                    if (shouldBeNegated)
                    {
                        transformed = Transform(Negator.Negate(ternary.Condition, typeSystem));
                    }
                    else
                    {
                        transformed = Transform(ternary.Condition);
                    }

                    return(true);
                }
            }

            if (literalInThen != null)
            {
                literal         = literalInThen;
                isLiteralInThen = true;
            }
            else if (literalInElse != null)
            {
                literal         = literalInElse;
                isLiteralInThen = false;
            }
            else // Transforms the case: someCondition ? (int)boolVar1 : (int)boolVar2
            {
                CastExpression thenCast = ternary.Then as CastExpression;
                CastExpression elseCast = ternary.Else as CastExpression;
                if (thenCast != null && elseCast != null &&
                    thenCast.TargetType.FullName == Constants.Int32 && thenCast.Expression.ExpressionType.FullName == Constants.Boolean &&
                    elseCast.TargetType.FullName == Constants.Int32 && elseCast.Expression.ExpressionType.FullName == Constants.Boolean)
                {
                    ternary.Then = thenCast.Expression;
                    ternary.Else = elseCast.Expression;

                    transformed = ternary;

                    return(true);
                }

                return(false);
            }

            bool isTrueLikeValue;

            if (literal.ExpressionType.FullName == Constants.Int32)
            {
                isTrueLikeValue = (int)literal.Value != 0 ? true : false;
            }
            else if (literal.ExpressionType.FullName == Constants.Boolean)
            {
                isTrueLikeValue = (bool)literal.Value;
            }
            else
            {
                return(false);
            }

            BinaryOperator newOperator;
            Expression     newLeft  = null;
            Expression     newRight = null;

            newLeft = Transform(ternary.Condition);

            Expression expression;

            if (isLiteralInThen)
            {
                expression = ternary.Else;
            }
            else
            {
                expression = ternary.Then;
            }

            ConditionExpression nestedTernary            = expression as ConditionExpression;
            CastExpression      castExpression           = expression as CastExpression;
            Expression          nestedBinaryAsExpression = null;
            bool isNestedBinaryInUnary = false;

            if (nestedTernary == null &&
                (castExpression == null || castExpression.TargetType.FullName != Constants.Int32 || castExpression.Expression.ExpressionType.FullName != Constants.Boolean) &&
                !IsBinaryExpression(expression, out nestedBinaryAsExpression, out isNestedBinaryInUnary) &&
                expression.ExpressionType.FullName != Constants.Boolean)
            {
                return(false);
            }

            bool isRightTransformed = false;

            if (castExpression != null)
            {
                newRight           = castExpression.Expression;
                isRightTransformed = true;
            }
            else
            {
                if (nestedBinaryAsExpression != null)
                {
                    BinaryExpression nestedBinary = GetBinaryExpression(isNestedBinaryInUnary, nestedBinaryAsExpression);
                    if (TryTransformBinary(nestedBinary))
                    {
                        newRight           = GetResultExpression(isNestedBinaryInUnary, nestedBinaryAsExpression, nestedBinary);
                        isRightTransformed = true;
                    }
                }
                else if (nestedTernary != null && TryTransformTernary(nestedTernary, out newRight))
                {
                    isRightTransformed = true;
                }
            }

            if (!isRightTransformed)
            {
                newRight = expression;
            }

            if (newLeft == null || newRight == null)
            {
                return(false);
            }

            if (isTrueLikeValue)
            {
                newOperator = BinaryOperator.LogicalOr;
                newLeft     = isLiteralInThen ? newLeft : Negator.Negate(newLeft, this.typeSystem);
            }
            else
            {
                newOperator = BinaryOperator.LogicalAnd;
                newLeft     = isLiteralInThen ? Negator.Negate(newLeft, this.typeSystem) : newLeft;
            }

            transformed = new BinaryExpression(newOperator, newLeft, newRight, this.typeSystem, ternary.MappedInstructions);
            return(true);
        }
Beispiel #15
0
 private bool TryTransformTernary(ConditionExpression ternary, out Expression transformed)
 {
     transformed = null;
     V_2         = ternary.get_Then() as LiteralExpression;
     V_3         = ternary.get_Else() as LiteralExpression;
     if (V_2 != null && V_3 != null)
     {
         V_14 = false;
         V_15 = false;
         if (!String.op_Equality(V_2.get_ExpressionType().get_FullName(), "System.Int32") || !String.op_Equality(V_3.get_ExpressionType().get_FullName(), "System.Int32"))
         {
             if (String.op_Equality(V_2.get_ExpressionType().get_FullName(), "System.Boolean") && String.op_Equality(V_3.get_ExpressionType().get_FullName(), "System.Boolean"))
             {
                 V_18 = (Boolean)V_2.get_Value();
                 V_19 = (Boolean)V_3.get_Value();
                 if (!V_18 && V_19 || V_18 && !V_19)
                 {
                     V_14 = true;
                     if (!V_18 && V_19)
                     {
                         V_15 = true;
                     }
                 }
             }
         }
         else
         {
             V_16 = (Int32)V_2.get_Value();
             V_17 = (Int32)V_3.get_Value();
             if (V_16 == 0 && V_17 == 1 || V_16 == 1 && V_17 == 0)
             {
                 V_14 = true;
                 if (V_16 == 0 && V_17 == 1)
                 {
                     V_15 = true;
                 }
             }
         }
         if (V_14)
         {
             if (!V_15)
             {
                 transformed = this.Transform(ternary.get_Condition());
             }
             else
             {
                 transformed = this.Transform(Negator.Negate(ternary.get_Condition(), this.typeSystem));
             }
             return(true);
         }
     }
     if (V_2 == null)
     {
         if (V_3 == null)
         {
             V_20 = ternary.get_Then() as ExplicitCastExpression;
             V_21 = ternary.get_Else() as ExplicitCastExpression;
             if (V_20 == null || V_21 == null || !String.op_Equality(V_20.get_TargetType().get_FullName(), "System.Int32") || !String.op_Equality(V_20.get_Expression().get_ExpressionType().get_FullName(), "System.Boolean") || !String.op_Equality(V_21.get_TargetType().get_FullName(), "System.Int32") || !String.op_Equality(V_21.get_Expression().get_ExpressionType().get_FullName(), "System.Boolean"))
             {
                 return(false);
             }
             ternary.set_Then(V_20.get_Expression());
             ternary.set_Else(V_21.get_Expression());
             transformed = ternary;
             return(true);
         }
         V_0 = V_3;
         V_1 = false;
     }
     else
     {
         V_0 = V_2;
         V_1 = true;
     }
     if (!String.op_Equality(V_0.get_ExpressionType().get_FullName(), "System.Int32"))
     {
         if (!String.op_Equality(V_0.get_ExpressionType().get_FullName(), "System.Boolean"))
         {
             return(false);
         }
         V_4 = (Boolean)V_0.get_Value();
     }
     else
     {
         if ((Int32)V_0.get_Value() != 0)
         {
             stackVariable163 = true;
         }
         else
         {
             stackVariable163 = false;
         }
         V_4 = stackVariable163;
     }
     V_6 = null;
     V_7 = null;
     V_6 = this.Transform(ternary.get_Condition());
     if (!V_1)
     {
         V_8 = ternary.get_Then();
     }
     else
     {
         V_8 = ternary.get_Else();
     }
     V_9  = V_8 as ConditionExpression;
     V_10 = V_8 as ExplicitCastExpression;
     V_11 = null;
     V_12 = false;
     if (V_9 == null && V_10 == null || String.op_Inequality(V_10.get_TargetType().get_FullName(), "System.Int32") || String.op_Inequality(V_10.get_Expression().get_ExpressionType().get_FullName(), "System.Boolean") && !this.IsBinaryExpression(V_8, out V_11, out V_12) && String.op_Inequality(V_8.get_ExpressionType().get_FullName(), "System.Boolean"))
     {
         return(false);
     }
     V_13 = false;
     if (V_10 == null)
     {
         if (V_11 == null)
         {
             if (V_9 != null && this.TryTransformTernary(V_9, out V_7))
             {
                 V_13 = true;
             }
         }
         else
         {
             V_22 = TransformCatchClausesFilterExpressionStep.GetBinaryExpression(V_12, V_11);
             if (this.TryTransformBinary(V_22))
             {
                 V_7  = TransformCatchClausesFilterExpressionStep.GetResultExpression(V_12, V_11, V_22);
                 V_13 = true;
             }
         }
     }
     else
     {
         V_7  = V_10.get_Expression();
         V_13 = true;
     }
     if (!V_13)
     {
         V_7 = V_8;
     }
     if (V_6 == null || V_7 == null)
     {
         return(false);
     }
     if (!V_4)
     {
         V_5 = 12;
         if (V_1)
         {
             stackVariable97 = Negator.Negate(V_6, this.typeSystem);
         }
         else
         {
             stackVariable97 = V_6;
         }
         V_6 = stackVariable97;
     }
     else
     {
         V_5 = 11;
         if (V_1)
         {
             stackVariable111 = V_6;
         }
         else
         {
             stackVariable111 = Negator.Negate(V_6, this.typeSystem);
         }
         V_6 = stackVariable111;
     }
     transformed = new BinaryExpression(V_5, V_6, V_7, this.typeSystem, ternary.get_MappedInstructions(), false);
     return(true);
 }
Beispiel #16
0
		private ICodeNode FixBranchingExpression(Expression expression, Instruction branch)
		{
			if (branch.get_OpCode().get_Code() == 57)
			{
				stackVariable5 = true;
			}
			else
			{
				V_5 = branch.get_OpCode();
				stackVariable5 = V_5.get_Code() == 44;
			}
			V_0 = stackVariable5;
			V_1 = expression.get_ExpressionType();
			V_3 = 9;
			stackVariable10 = new Instruction[1];
			stackVariable10[0] = branch;
			V_4 = stackVariable10;
			if (V_0)
			{
				V_3 = 10;
			}
			if (String.op_Equality(V_1.get_Name(), "Boolean") || V_1.get_Name().Contains("Boolean "))
			{
				if (V_0)
				{
					V_6 = expression;
				}
				else
				{
					V_6 = Negator.Negate(expression, this.typeSystem);
				}
				if (expression as SafeCastExpression == null)
				{
					V_7 = new UnaryExpression(11, V_6, V_4);
				}
				else
				{
					V_7 = new BinaryExpression(V_3, expression, this.GetLiteralExpression(false, null), this.typeSystem, V_4, false);
				}
				return V_7;
			}
			if (String.op_Equality(V_1.get_Name(), "Char"))
			{
				V_2 = new BinaryExpression(V_3, expression, this.GetLiteralExpression('\0', null), this.typeSystem, V_4, false);
				V_2.set_ExpressionType(this.typeSystem.get_Boolean());
			}
			if (V_1.get_IsPrimitive())
			{
				V_2 = new BinaryExpression(V_3, expression, this.GetLiteralExpression(0, null), this.typeSystem, V_4, false);
				V_2.set_ExpressionType(this.typeSystem.get_Boolean());
			}
			else
			{
				V_8 = V_1.Resolve();
				if (V_8 == null || !V_8.get_IsEnum() || V_1.get_IsArray())
				{
					V_2 = new BinaryExpression(V_3, expression, this.GetLiteralExpression(null, null), this.typeSystem, V_4, false);
					V_2.set_ExpressionType(this.typeSystem.get_Boolean());
				}
				else
				{
					V_9 = null;
					V_10 = V_8.get_Fields().GetEnumerator();
					try
					{
						while (V_10.MoveNext())
						{
							V_11 = V_10.get_Current();
							if (V_11.get_Constant() == null || V_11.get_Constant().get_Value() == null || !V_11.get_Constant().get_Value().Equals(0))
							{
								continue;
							}
							V_9 = V_11;
							goto Label0;
						}
					}
					finally
					{
						V_10.Dispose();
					}
				Label0:
					if (V_9 != null)
					{
						V_2 = new BinaryExpression(V_3, expression, new EnumExpression(V_9, null), this.typeSystem, V_4, false);
						V_2.set_ExpressionType(this.typeSystem.get_Boolean());
					}
					else
					{
						V_2 = new BinaryExpression(V_3, expression, this.GetLiteralExpression(0, null), this.typeSystem, V_4, false);
						V_2.set_ExpressionType(this.typeSystem.get_Boolean());
					}
				}
			}
			return V_2;
		}