Example #1
0
        private BinaryRelationship GetNormalizedRelationship(BoolConstraint boolConstraint, SymbolicValue leftOperand, SymbolicValue rightOperand)
        {
            var invertCount = 0;

            var leftOp           = leftOperand;
            var logicalNotLeftOp = leftOp as LogicalNotSymbolicValue;

            while (logicalNotLeftOp != null)
            {
                leftOp           = logicalNotLeftOp.Operand;
                logicalNotLeftOp = leftOp as LogicalNotSymbolicValue;
                invertCount++;
            }

            var rightOp           = rightOperand;
            var logicalNotRightOp = rightOp as LogicalNotSymbolicValue;

            while (logicalNotRightOp != null)
            {
                rightOp           = logicalNotRightOp.Operand;
                logicalNotRightOp = rightOp as LogicalNotSymbolicValue;
                invertCount++;
            }

            var relationship = GetRelationship(boolConstraint, leftOp, rightOp);

            return(invertCount % 2 == 0
                ? relationship
                : relationship.Negate());
        }
Example #2
0
        private BinaryRelationship GetRelationship(BoolConstraint boolConstraint, SymbolicValue left, SymbolicValue right)
        {
            var equalsRelationship = GetRelationship(left, right);

            return(boolConstraint == BoolConstraint.True
                ? equalsRelationship
                : equalsRelationship.Negate());
        }
        private BinaryRelationship GetRelationship(BoolConstraint boolConstraint)
        {
            var relationship = new ComparisonRelationship(this.comparisonKind, LeftOperand, RightOperand);

            return(boolConstraint == BoolConstraint.True
                ? relationship
                : relationship.Negate());
        }
        internal override IEnumerable <ProgramState> SetConstraint(BoolConstraint boolConstraint,
                                                                   SymbolicValueConstraints leftConstraints, SymbolicValueConstraints rightConstraints,
                                                                   ProgramState programState)
        {
            if (boolConstraint == BoolConstraint.False)
            {
                return(RightOperand.TrySetConstraints(leftConstraints, programState)
                       .SelectMany(ps => LeftOperand.TrySetConstraints(rightConstraints, ps)));
            }

            return(RightOperand.TrySetOppositeConstraints(leftConstraints, programState)
                   .SelectMany(ps => LeftOperand.TrySetOppositeConstraints(rightConstraints, ps)));
        }
        public override IEnumerable <ProgramState> TrySetConstraint(SymbolicValueConstraint constraint, ProgramState programState)
        {
            var boolConstraint = constraint as BoolConstraint;

            if (boolConstraint == null)
            {
                return(new[] { programState });
            }

            SymbolicValueConstraints oldConstraints;
            BoolConstraint           oldBoolConstraint = null;

            if (TryGetConstraints(programState, out oldConstraints))
            {
                oldBoolConstraint = oldConstraints.GetConstraintOrDefault <BoolConstraint>();
            }

            if (oldBoolConstraint != null /* could also be ObjectConstraint.NotNull, which can be overridden */ &&
                oldBoolConstraint != boolConstraint)
            {
                return(Enumerable.Empty <ProgramState>());
            }

            SymbolicValueConstraints leftConstraints;
            var leftHasConstraint = LeftOperand.TryGetConstraints(programState, out leftConstraints);
            SymbolicValueConstraints rightConstraints;
            var rightHasConstraint = RightOperand.TryGetConstraints(programState, out rightConstraints);

            var relationship = GetRelationship(boolConstraint);

            var newProgramState = programState.TrySetRelationship(relationship);

            if (newProgramState == null)
            {
                return(Enumerable.Empty <ProgramState>());
            }

            if (!rightHasConstraint && !leftHasConstraint)
            {
                return(new[] { newProgramState });
            }

            return(SetConstraint(boolConstraint, leftConstraints, rightConstraints, newProgramState));
        }
Example #6
0
        private IEnumerable <ProgramState> TrySetBoolConstraint(BoolConstraint constraint,
                                                                SymbolicValueConstraints oldConstraints, ProgramState programState)
        {
            if (oldConstraints.HasConstraint(ObjectConstraint.Null))
            {
                // It was null, and now it should be true or false
                return(Enumerable.Empty <ProgramState>());
            }

            var oldBoolConstraint = oldConstraints.GetConstraintOrDefault <BoolConstraint>();

            if (oldBoolConstraint != null &&
                oldBoolConstraint != constraint)
            {
                return(Enumerable.Empty <ProgramState>());
            }

            // Either same bool constraint, or previously not null, and now a bool constraint
            return(new[] { programState.SetConstraint(this, constraint) });
        }
Example #7
0
 private BinaryRelationship GetRelationship(BoolConstraint boolConstraint)
 {
     return(GetNormalizedRelationship(boolConstraint, LeftOperand, RightOperand));
 }
Example #8
0
 internal abstract IEnumerable <ProgramState> SetConstraint(BoolConstraint boolConstraint,
                                                            SymbolicValueConstraints leftConstraints, SymbolicValueConstraints rightConstraints,
                                                            ProgramState programState);