/// <summary>
/// Perform some rewritings to the boxed expressions, so that is is simplified, and it is nicer for a human reader
/// </summary>
public static BoxedExpression MakeItPrettier <Variable>(this BoxedExpression be, IExpressionDecoder <BoxedVariable <Variable>, BoxedExpression> decoder, IExpressionEncoder <BoxedVariable <Variable>, BoxedExpression> encoder)
{
Contract.Requires(encoder != null);
var result = be;
// 0. Do not do any work on MinValue <= exp, as -exp <= -MinValue is wrong
BinaryOperator bop;
BoxedExpression left, right;
int maybeMinInt; long maybeMinLong;
if (be.IsBinaryExpression(out bop, out left, out right) &&
(bop == BinaryOperator.Cle || bop == BinaryOperator.Clt || bop == BinaryOperator.Cle_Un || bop == BinaryOperator.Clt_Un) &&
((left.IsConstantInt(out maybeMinInt) && maybeMinInt == Int32.MinValue) || (left.IsConstantInt64(out maybeMinLong) && maybeMinLong == Int64.MinValue))
)
{
return(result);
}
// 1. If it is a polynomial, do some arithmetic simplification, puts all the variables on one side, etc.
Polynomial <BoxedVariable <Variable>, BoxedExpression> pol;
if (Polynomial <BoxedVariable <Variable>, BoxedExpression> .TryToPolynomialForm(be, decoder, out pol))
{
if (pol.IsTautology)
{
return(encoder.ConstantFor(true));
}
// m1 - m2 == 0 becomes m1 == m2
BoxedVariable <Variable> x, y;
Rational k;
if (pol.TryMatch_XMinusYEqualk3(out x, out y, out k) && k.IsZero)
{
var xExp = encoder.VariableFor(x);
var yExp = encoder.VariableFor(y);
return(encoder.CompoundExpressionFor(ExpressionType.Bool, ExpressionOperator.Equal, xExp, yExp));
}
result = pol.ToPureExpression(encoder);
}
// To do: add some more pretty printing there
result = MakeItPrettier(result, x => encoder.ConstantFor(x));
return(result);
}
public override Expression Convert <Expression>(IExpressionEncoder <Variable, Expression> encoder)
{
return(encoder.CompoundExpressionFor(ExpressionType.Int32,
ExpressionOperator.Addition,
encoder.VariableFor(var),
encoder.ConstantFor(value)));
}
public static INumericalAbstractDomain <Variable, Expression> TestTrueEqual <Variable, Expression>(
this INumericalAbstractDomain <Variable, Expression> aState,
Expression exp, SetOfConstraints <Variable> equalities,
IExpressionEncoder <Variable, Expression> encoder)
{
Contract.Requires(aState != null);
Contract.Requires(exp != null);
Contract.Requires(equalities != null);
Contract.Requires(encoder != null);
Contract.Ensures(Contract.Result <INumericalAbstractDomain <Variable, Expression> >() != null);
if (equalities.IsNormal())
{
var newSet = new Set <Expression>();
foreach (var v in equalities.Values)
{
newSet.Add(encoder.VariableFor(v));
}
return(aState.TestTrueEqual(exp, newSet));
}
else
{
return(aState);
}
}
/// <summary>
/// Construct left - right, or left iff right == 0
/// </summary>
public static Expression SmartSubtraction <Variable, Expression>(this IExpressionEncoder <Variable, Expression> encoder,
Variable leftVar, Variable rightVar, IExpressionDecoder <Variable, Expression> decoder)
{
Contract.Requires(decoder != null);
Contract.Requires(encoder != null);
var right = encoder.VariableFor(rightVar);
var left = encoder.VariableFor(leftVar);
int value;
if (decoder.IsConstantInt(right, out value) && value == 0)
{
return(left);
}
return(encoder.CompoundExpressionFor(ExpressionType.Int32, ExpressionOperator.Subtraction, left, right));
}
public static INumericalAbstractDomain <Variable, Expression> TestTrue <Variable, Expression>(
this INumericalAbstractDomain <Variable, Expression> aState,
Variable v, NonRelationalValueAbstraction <Variable, Expression> nonRelationalValue,
IExpressionEncoder <Variable, Expression> encoder)
{
Contract.Requires(v != null);
Contract.Requires(aState != null);
Contract.Requires(nonRelationalValue != null);
Contract.Requires(encoder != null);
Contract.Ensures(Contract.Result <INumericalAbstractDomain <Variable, Expression> >() != null);
if (nonRelationalValue.IsBottom)
{
Contract.Assume(aState.Bottom as INumericalAbstractDomain <Variable, Expression> != null); // F: Adding the assumption as we do not track types
return(aState.Bottom as INumericalAbstractDomain <Variable, Expression>);
}
if (nonRelationalValue.IsTop)
{
return(aState);
}
var result = aState;
// Assume the interval
if (nonRelationalValue.Interval.IsNormal())
{
result.AssumeInDisInterval(v, nonRelationalValue.Interval);
}
var vExp = encoder.VariableFor(v);
// Assume the equalities
if (nonRelationalValue.Equalities.IsNormal())
{
result = result.TestTrueEqual(vExp, nonRelationalValue.Equalities, encoder);
}
// Assume the strict upper bounds
if (nonRelationalValue.StrictUpperBounds.IsNormal())
{
result = result.TestTrueLessThan(vExp, nonRelationalValue.StrictUpperBounds, encoder);
}
// Assume the weak upper bounds
if (nonRelationalValue.WeakUpperBounds.IsNormal())
{
result = result.TestTrueLessEqualThan(vExp, nonRelationalValue.WeakUpperBounds, encoder);
}
return(result);
}
public static INumericalAbstractDomain <Variable, Expression> TestTrueLessThan <Variable, Expression>(
this INumericalAbstractDomain <Variable, Expression> aState,
Expression exp, Set <Variable> uppBounds,
IExpressionEncoder <Variable, Expression> encoder)
{
Contract.Requires(aState != null);
Contract.Requires(exp != null);
Contract.Requires(uppBounds != null);
Contract.Requires(encoder != null);
Contract.Ensures(Contract.Result <INumericalAbstractDomain <Variable, Expression> >() != null);
return(aState.TestTrueLessThan(exp, uppBounds.ConvertAll(v => encoder.VariableFor(v))));
}
public override Expression Convert <Expression>(IExpressionEncoder <Variable, Expression> encoder)
{
return(encoder.VariableFor(var));
}
