private void AssumeFalseElementUse(VarLikeConstructUse directVarUse, MemoryContext memoryContext, SnapshotBase flowOutputSet)
{
memoryContext.AssignFalseEvaluable(directVarUse);
}
private void AssumeFalseDirectVarUse(DirectVarUse directVarUse, MemoryContext memoryContext, SnapshotBase flowOutputSet)
{
memoryContext.AssignFalseEvaluable(directVarUse.VarName, directVarUse);
}
/// <summary>
/// Makes the assumption for case like <value>a < b</value>.
/// </summary>
/// <param name="left">The left side of the expression.</param>
/// <param name="right">The right side of the expression.</param>
/// <param name="equal">if set to <c>true</c> lesser or equals is assumed.</param>
/// <param name="memoryContext">The memory context of the code block and it's variables.</param>
/// <param name="flowOutputSet">The Output set of a program point.</param>
private void AssumeLesserThan(LangElement left, LangElement right, bool equal, MemoryContext memoryContext, SnapshotBase flowOutputSet)
{
if (right is VarLikeConstructUse && !(left is VarLikeConstructUse))
{
AssumeGreaterThan(right, left, equal, memoryContext, flowOutputSet);
}
else if (left is VarLikeConstructUse)
{
var leftVar = (VarLikeConstructUse)left;
//this is probably not necessary{
if (right is StringLiteral)
{
memoryContext.IntersectionAssign(leftVar, memoryContext.AnyStringValue);
}
else if (right is DoubleLiteral)
{
var rigthValue = (DoubleLiteral)right;
double bound = (double)rigthValue.Value;
if (!equal)
{
bound -= double.Epsilon;
}
memoryContext.IntersectionAssign(leftVar, memoryContext.CreateFloatInterval(double.MinValue, bound));
}
else if (right is IntLiteral)
{
var rigthValue = (IntLiteral)right;
int bound = (int)rigthValue.Value;
if (!equal)
{
bound--;
}
memoryContext.IntersectionAssign(leftVar, memoryContext.CreateIntegerInterval(int.MinValue, bound));
}
else if (right is LongIntLiteral)
{
var rigthValue = (LongIntLiteral)right;
long bound = (long)rigthValue.Value;
if (!equal)
{
bound--;
}
memoryContext.IntersectionAssign(leftVar, memoryContext.CreateLongintInterval(long.MinValue, bound));
}
//}
else
{
var snapshotEntry = log.ReadSnapshotEntry(right);
if (snapshotEntry != null)
{
//get upper bound of right and intersect with left
int? maxInt;
long? maxLong;
double?maxDouble;
ValueHelper.TryGetMaximumValue(snapshotEntry.ReadMemory(flowOutputSet).PossibleValues, out maxInt, out maxLong, out maxDouble);
if (maxInt.HasValue)
{
if (!equal)
{
maxInt--;
}
memoryContext.IntersectionAssign(leftVar, memoryContext.CreateIntegerInterval(int.MinValue, maxInt.Value));
}
else if (maxLong.HasValue)
{
if (!equal)
{
maxLong--;
}
memoryContext.IntersectionAssign(leftVar, memoryContext.CreateLongintInterval(long.MinValue, maxLong.Value));
}
else if (maxDouble.HasValue)
{
if (!equal)
{
maxDouble -= double.Epsilon;
}
memoryContext.IntersectionAssign(leftVar, memoryContext.CreateFloatInterval(double.MinValue, maxDouble.Value));
}
}
}
}
}
/// <summary>
/// Makes the assumption in case of <c>false</c> as a condition result.
/// </summary>
/// <param name="langElement">The language element to assume.</param>
/// <param name="memoryContext">The memory context of the code block and it's variables.</param>
/// <param name="flowOutputSet">The Output set of a program point.</param>
private void AssumeFalse(LangElement langElement, MemoryContext memoryContext, FlowOutputSet flowOutputSet)
{
if (langElement is BinaryEx)
{
BinaryEx binaryExpression = (BinaryEx)langElement;
if (binaryExpression.PublicOperation == Operations.Equal)
{
AssumeNotEquals(binaryExpression.LeftExpr, binaryExpression.RightExpr, memoryContext);
}
else if (binaryExpression.PublicOperation == Operations.NotEqual)
{
AssumeEquals(binaryExpression.LeftExpr, binaryExpression.RightExpr, memoryContext, flowOutputSet.Snapshot);
}
else if (binaryExpression.PublicOperation == Operations.GreaterThan)
{
AssumeLesserThan(binaryExpression.LeftExpr, binaryExpression.RightExpr, true, memoryContext, flowOutputSet.Snapshot);
}
else if (binaryExpression.PublicOperation == Operations.GreaterThanOrEqual)
{
AssumeLesserThan(binaryExpression.LeftExpr, binaryExpression.RightExpr, false, memoryContext, flowOutputSet.Snapshot);
}
else if (binaryExpression.PublicOperation == Operations.LessThan)
{
AssumeGreaterThan(binaryExpression.LeftExpr, binaryExpression.RightExpr, true, memoryContext, flowOutputSet.Snapshot);
}
else if (binaryExpression.PublicOperation == Operations.LessThanOrEqual)
{
AssumeGreaterThan(binaryExpression.LeftExpr, binaryExpression.RightExpr, false, memoryContext, flowOutputSet.Snapshot);
}
else if (binaryExpression.PublicOperation == Operations.And ||
binaryExpression.PublicOperation == Operations.Or ||
binaryExpression.PublicOperation == Operations.Xor)
{
ConditionForm conditionForm = ConditionForm.SomeNot; // !(a AND b) --> !a OR !b
if (binaryExpression.PublicOperation == Operations.Or)
{
conditionForm = ConditionForm.None; // !(a OR b) --> !a AND !b
}
else if (binaryExpression.PublicOperation == Operations.Xor)
{
conditionForm = ConditionForm.NotExactlyOne; //!(a XOR b) --> !((a OR b) AND !(a AND b)) --> (!a AND !b) OR (a AND b)
}
MemoryContext currentMemoryContext = new MemoryContext(log, flowOutputSet);
//AssumptionConditionExecuterDepr condition = new AssumptionConditionExecuterDepr(conditionForm, flowOutputSet, log, binaryExpression.LeftExpr, binaryExpression.RightExpr);
//condition.MakeAssumption(currentMemoryContext);
memoryContext.UnionMerge(currentMemoryContext);
}
}
else if (langElement is UnaryEx)
{
UnaryEx unaryExpression = (UnaryEx)langElement;
if (unaryExpression.PublicOperation == Operations.LogicNegation)
{
AssumeTrue(unaryExpression.Expr, memoryContext, flowOutputSet);
}
}
else if (langElement is DirectVarUse)
{
DirectVarUse directVarUse = (DirectVarUse)langElement;
AssumeFalseDirectVarUse(directVarUse, memoryContext, flowOutputSet.Snapshot);
}
else if (langElement is IssetEx)
{
IssetEx issetEx = (IssetEx)langElement;
AssumeIsset(issetEx, memoryContext, flowOutputSet.Snapshot, false);
}
}
