public static bool TryMatchVarPlusConst <Variable, Expression>(this IExpressionDecoder <Variable, Expression> decoder,
Expression exp, out Variable var, out int k)
{
Contract.Requires(decoder != null);
if (decoder.IsBinaryExpression(exp) && decoder.OperatorFor(exp) == ExpressionOperator.Addition)
{
var left = decoder.LeftExpressionFor(exp);
var right = decoder.RightExpressionFor(exp);
if (decoder.IsConstantInt(left, out k) && decoder.IsVariable(right))
{
var = decoder.UnderlyingVariable(right);
return(true);
}
if (decoder.IsConstantInt(right, out k) && decoder.IsVariable(left))
{
var = decoder.UnderlyingVariable(left);
return(true);
}
}
var = default(Variable);
k = default(int);
return(false);
}
public TryConvertRead(IExpressionDecoder <Variable, Expression> decoder)
: base(decoder)
{
Contract.Requires(decoder != null);
result = default(NormalizedExpression <Variable>);
}
private static bool IsConstantTrueOrFalse <Variable, Expression>(
Expression e, bool t, IExpressionDecoder <Variable, Expression> decoder)
{
Contract.Requires(decoder != null);
bool boolValue;
Int32 intValue;
if (decoder.IsConstant(e))
{
if (decoder.TryValueOf <bool>(e, ExpressionType.Bool, out boolValue))
{
return(boolValue == t);
}
else if (decoder.IsConstantInt(e, out intValue))
{
return((intValue != 0) == t);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
public SimpleArrayPropertiesAbstractDomain(SimpleArrayPropertiesAbstractDomain <Variable, Expression> source)
: base(source)
{
this.arrayAbstractor = source.arrayAbstractor;
this.encoder = source.encoder;
this.decoder = source.decoder;
}
public SubPoly(IExpressionDecoder <Expression> decoder, IExpressionEncoder <Expression> encoder)
{
IntervalEnvironment <Expression> intv = new IntervalEnvironment <Expression>(decoder, encoder);
LinearEqualitiesEnvironment <Expression> lineq = new LinearEqualitiesEnvironment <Expression>(decoder, encoder, true, false);
this.subpoly = new SubPolyhedra <Expression>(lineq, intv, decoder, encoder);
}
protected IntervalEnvironmentBase
(IExpressionDecoder <TVar, TExpr> decoder,
EnvironmentDomain <TVar, TInterval> varsToInterval)
{
Decoder = decoder;
vars_to_intervals = varsToInterval;
}
public SimpleArrayPropertiesAbstractDomain(IExpressionEncoder <Variable, Expression> encoder, IExpressionDecoder <Variable, Expression> decoder)
: base()
{
this.arrayAbstractor = new SimpleArrayAbstraction <Variable, Expression>(encoder, decoder);
this.encoder = encoder;
this.decoder = decoder;
}
public ExpressionManagerWithEncoder(TimeOutChecker timeout, IExpressionDecoder <Variable, Expression> decoder, IExpressionEncoder <Variable, Expression> encoder, Logger log = null)
: base(timeout, decoder, encoder)
{
Contract.Requires(timeout != null);
Contract.Requires(decoder != null);
Contract.Requires(encoder != null);
}
public static bool Match_E1aritopE2eq0 <Variable, Expression>(
this IExpressionDecoder <Variable, Expression> decoder,
Expression e1, Expression e2,
out ExpressionOperator op, out Expression e11, out Expression e12)
{
Contract.Requires(decoder != null);
Int32 value;
if (decoder.IsConstantInt(e2, out value) && value == 0)
{
op = decoder.OperatorFor(e1);
if (op.Equals(ExpressionOperator.Addition) || op.Equals(ExpressionOperator.Subtraction))
{
e11 = decoder.LeftExpressionFor(e1);
e12 = decoder.RightExpressionFor(e1);
return(true);
}
}
op = default(ExpressionOperator);
e11 = e12 = default(Expression);
return(false);
}
/// <summary>
/// Construct an empty abstract domain of symbolic expressions
/// </summary>
public SymbolicExpressionsAbstractDomain(IExpressionDecoder <Expression> decoder, IExpressionEncoder <Expression> encoder)
{
this.decoder = decoder;
this.encoder = encoder;
this.var2exp = new SimpleFunctional <Expression, FlatAbstractDomainWithComparer <Expression> >();
InitStaticFields();
}
public static void Init(IExpressionDecoder <Variable, Expression> decoder, IExpressionEncoder <Variable, Expression> encoder)
{
linearfactory = new LinearExpFactory <Expression>(decoder, encoder);
propfactory = new PropFactory <Expression>(decoder, encoder);
UnderlyingPolyhedra = new AI.PolyhedraLattice(linearfactory, propfactory);
UnderlyingPolyhedra.Validate();
}
public EvaluateExpressionVisitor(IExpressionDecoder <TVar, TExpr> decoder)
: base(decoder)
{
occurences = new VariableOccurences(decoder);
constToIntv =
new ConstToIntervalEvaluator
<IntervalContextBase <TInterval, TNumeric>, TVar, TExpr, TInterval, TNumeric> (
decoder);
}
private SimpleStringAbstractDomain(SimpleStringAbstractDomain <Variable, Expression> /*!*/ source)
{
decoder = source.decoder;
foreach (var x in source.Keys)
{
var cloned = source[x].Clone() as IStringAbstraction;
this[x] = cloned;
}
}
private static string ConstantPrint <Variable, Expression>(Expression exp, IExpressionDecoder <Variable, Expression> decoder, int height)
{
Contract.Ensures(Contract.Result <string>() != null);
var tmp = new VisitorForConstantPrint <Variable, Expression>(decoder).Visit(exp, Unit.Value);
Contract.Assume(tmp != null); // F: to shut off Clousot for now
return(tmp);
}
public IntervalTestVisitor(IExpressionDecoder <TVar, TExpr> decoder)
{
true_visitor =
new IntervalAssumeTrueVisitor <TVar, TExpr, TInterval, TNumeric> (decoder);
false_visitor =
new IntervalAssumeFalseVisitor <TVar, TExpr, TInterval, TNumeric> (decoder);
true_visitor.FalseVisitor = false_visitor;
false_visitor.TrueVisitor = true_visitor;
}
public static IDictionary <TVar, Sequence <TInterval> > LessThan <TEnv, TVar, TExpr, TInterval>
(TExpr left, TExpr right, IExpressionDecoder <TVar, TExpr> decoder, TEnv env, out bool isBottom)
where TEnv : IIntervalEnvironment <TVar, TExpr, TInterval, Rational>
where TVar : IEquatable <TVar>
where TInterval : IntervalBase <TInterval, Rational>
{
isBottom = false;
var result = new Dictionary <TVar, Sequence <TInterval> > ();
var leftIntv = env.Eval(left);
var rightIntv = env.Eval(right);
var rightVar = decoder.UnderlyingVariable(right);
var successor = IsFloat(left, decoder) || IsFloat(right, decoder) ? Rational.Zero : Rational.One;
TInterval refinedIntv;
if (TryRefineKLessThanRight <TEnv, TVar, TExpr, TInterval> (leftIntv, rightVar, successor, env, out refinedIntv) && !refinedIntv.IsSinglePoint)
{
AddToResult(result, rightVar, refinedIntv);
}
if (successor.IsZero)
{
return(result);
}
var leftVar = decoder.UnderlyingVariable(left);
if (TryRefineLessThan <TEnv, TVar, TExpr, TInterval> (leftVar, rightIntv, env, out refinedIntv) && !refinedIntv.IsSinglePoint)
{
AddToResult(result, leftVar, refinedIntv);
}
Polynomial <TVar, TExpr> poly;
Polynomial <TVar, TExpr> leftPoly;
Polynomial <TVar, TExpr> rightPoly;
if (Polynomial <TVar, TExpr> .TryBuildFrom(left, decoder, out leftPoly) &&
Polynomial <TVar, TExpr> .TryBuildFrom(right, decoder, out rightPoly) &&
Polynomial <TVar, TExpr> .TryToPolynomial(ExpressionOperator.LessThan, leftPoly, rightPoly, out poly) &&
poly.IsLinear)
{
if (poly.Left.Length == 1)
{
return(TestTrueLessEqualThan_AxLtK(poly, env, result, out isBottom));
}
if (poly.Left.Length == 2)
{
return(TestTrueLessEqualThan_AxByLtK(poly, env, result, out isBottom));
}
}
return(result);
}
static bool IsFloat <TVar, TExpr> (TExpr expr, IExpressionDecoder <TVar, TExpr> decoder)
{
if (decoder == null)
{
return(false);
}
var type = decoder.TypeOf(expr);
return(type == ExpressionType.Float32 || type == ExpressionType.Float64);
}
private static bool IsFloat <Variable, Expression>(Expression exp, IExpressionDecoder <Variable, Expression> decoder)
{
if (decoder == null)
{
return(false);
}
var type = decoder.TypeOf(exp);
return(type == ExpressionType.Float32 || type == ExpressionType.Float64);
}
public StripeWithIntervalsForUnsafeCode(
IntervalsForUnsafeCode /*!*/ left,
StripeForUnsafeCode /*!*/ right,
IExpressionDecoder <BoxedExpression> decoder,
IExpressionContext <APC, Local, Parameter, Method, Field, Type, ExternalExpression, Variable> context,
IDecodeMetaData <Local, Parameter, Method, Field, Property, Type, Attribute, Assembly> mdDecoder
)
: base(left, right, decoder)
{
this.context = context;
this.mdDecoder = mdDecoder;
}
private SimpleDisequalities(SimpleDisequalities <Variable, Expression> original)
: base(original)
{
decoder = original.decoder;
encoder = original.encoder;
evalConstant = original.evalConstant;
testTrueVisitor = original.testTrueVisitor;
testFalseVisitor = original.testFalseVisitor;
checkIfHoldsVisitor = original.checkIfHoldsVisitor;
}
/// <returns>A string representation of the expression exp</returns>
public static string ToString <Variable, Expression>(Expression exp, IExpressionDecoder <Variable, Expression> decoder)
{
Contract.Ensures(Contract.Result <string>() != null);
Contract.Assume(!ToStringInvokedFromTheOutside); // This method can be invoked just from the outside of the class
ToStringInvokedFromTheOutside = true;
var result = ToString(exp, decoder, 0);
ToStringInvokedFromTheOutside = false;
return(result);
}
private PolyhedraEnvironment(IExpressionDecoder <Variable, Expression> decoder, IExpressionEncoder <Variable, Expression> encoder, AI.PolyhedraLattice.Element value, IntervalEnvironment <Variable, Expression> intv)
{
this.decoder = decoder;
this.encoder = encoder;
embedded = value;
this.intv = intv;
testTrueVisitor = new PolyhedraEnvironment <Expression> .PolyhedraTestTrueVisitor(decoder);
testFalseVisitor = new PolyhedraEnvironment <Expression> .PolyhedraTestFalseVisitor(decoder);
testTrueVisitor.FalseVisitor = testFalseVisitor;
testFalseVisitor.TrueVisitor = testTrueVisitor;
}
public PolyhedraEnvironment(IExpressionDecoder <Variable, Expression> decoder, IExpressionEncoder <Variable, Expression> encoder)
{
this.decoder = decoder;
this.encoder = encoder;
embedded = UnderlyingPolyhedra.Top;
intv = new IntervalEnvironment <Variable, Expression>(decoder, encoder);
testTrueVisitor = new PolyhedraEnvironment <Expression> .PolyhedraTestTrueVisitor(decoder);
testFalseVisitor = new PolyhedraEnvironment <Expression> .PolyhedraTestFalseVisitor(decoder);
testTrueVisitor.FalseVisitor = testFalseVisitor;
testFalseVisitor.TrueVisitor = testTrueVisitor;
}
public static IDictionary <TVar, Sequence <TInterval> > GreaterEqualThanZero <TEnv, TVar, TExpr, TInterval>
(TExpr expr, IExpressionDecoder <TVar, TExpr> decoder, TEnv env)
where TEnv : IIntervalEnvironment <TVar, TExpr, TInterval, Rational>
where TVar : IEquatable <TVar>
where TInterval : IntervalBase <TInterval, Rational>
{
var result = new Dictionary <TVar, Sequence <TInterval> > ();
var variable = decoder.UnderlyingVariable(expr);
AddToResult(result, variable, env.Eval(expr).Meet(env.Context.Positive));
if (!decoder.IsVariable(expr))
{
Polynomial <TVar, TExpr> zeroPoly; // poly(0)
if (!Polynomial <TVar, TExpr> .TryToPolynomial(new[] { Monomial <TVar> .From(Rational.Zero) }, out zeroPoly))
{
throw new AbstractInterpretationException(
"It can never be the case that the conversion of a list of monomials into a polynomial fails.");
}
Polynomial <TVar, TExpr> exprPoly; // poly(expr)
Polynomial <TVar, TExpr> fullPoly; // '0 <= poly(expr)' polynome
if (Polynomial <TVar, TExpr> .TryBuildFrom(expr, decoder, out exprPoly) &&
Polynomial <TVar, TExpr> .TryToPolynomial(ExpressionOperator.LessEqualThan, zeroPoly, exprPoly, out fullPoly) &&
fullPoly.IsIntervalForm)
{
var k = fullPoly.Left[0].Coeff; // k != 0
TVar x;
fullPoly.Left[0].IsSingleVariable(out x);
Rational constraint;
if (Rational.TryDivide(fullPoly.Right[0].Coeff, k, out constraint))
{
TInterval interval;
if (k > 0L) // +x <= constraint
{
interval = env.Eval(x).Meet(env.Context.For(Rational.MinusInfinity, constraint));
}
else // -x <= -constraint ==> x >= constraint
{
interval = env.Eval(x).Meet(env.Context.For(constraint, Rational.PlusInfinity));
}
AddToResult(result, x, interval);
}
}
}
return(result);
}
static bool IsVariableEqConstant(Expression guard, IExpressionDecoder <Variable, Expression> decoder)
{
switch (decoder.OperatorFor(guard))
{
case ExpressionOperator.Equal:
case ExpressionOperator.Equal_Obj:
Expression left = decoder.LeftExpressionFor(guard);
Expression right = decoder.RightExpressionFor(guard);
return((decoder.IsVariable(left) && decoder.IsConstant(right)) || (decoder.IsVariable(right) && decoder.IsConstant(right)));
default:
return(false);
}
}
public ExpressionManager(TimeOutChecker timeout, IExpressionDecoder <Variable, Expression> decoder, IExpressionEncoder <Variable, Expression> encoder = null, Logger log = null)
{
Contract.Requires(decoder != null);
Contract.Ensures(this.decoder == decoder);
Contract.Ensures(this.encoder == encoder);
Contract.Ensures(this.TimeOut != null);
this.TimeOut = timeout ?? DFARoot.TimeOut;
Contract.Assume(this.TimeOut != null, "weakeness with ?? ?");
this.decoder = decoder;
this.encoder = encoder;
this.Log = log == null ? VoidLogger.Log : log;
}
/// <summary>
/// Construct a new domain
/// </summary>
public SimpleDisequalities(IExpressionDecoder <Variable, Expression> /*!*/ decoder,
IExpressionEncoder <Variable, Expression> /*!*/ encoder)
{
this.decoder = decoder;
this.encoder = encoder;
evalConstant = new ConstantVisitor(decoder);
testTrueVisitor = new SimpleDisequalitiesTestTrueVisitor(this.decoder, evalConstant);
testFalseVisitor = new SimpleDisequalitiesTestFalseVisitor(this.decoder);
testTrueVisitor.FalseVisitor = testFalseVisitor;
testFalseVisitor.TrueVisitor = testTrueVisitor;
checkIfHoldsVisitor = new SimpleDisequalitiesCheckIfHoldsVisitor(this.decoder, evalConstant);
}
static public bool TryConvertFrom <Expression>(
Expression exp, IExpressionDecoder <Variable, Expression> decoder,
out NormalizedExpression <Variable> result)
{
Contract.Requires(exp != null);
if (decoder == null)
{
result = default(NormalizedExpression <Variable>);
return(false);
}
var reader = new TryConvertRead <Expression>(decoder);
return(reader.TryConvert(exp, out result));
}
public static bool TryGetAThreshold <TVar, TExpr> (TExpr e, IExpressionDecoder <TVar, TExpr> decoder, out List <int> thresholds)
{
var visitor = new GetThresholdVisitor <TVar, TExpr> (decoder);
if (visitor.Visit(e, Dummy.Value))
{
thresholds = new List <int> ();
foreach (var threshold in visitor.Thresholds)
{
thresholds.Add(threshold - 1);
thresholds.Add(threshold);
thresholds.Add(threshold + 1);
}
return(true);
}
return(false.Without(out thresholds));
}
static public Exp <E> Box <E>(E exp, IExpressionDecoder <E> decoder)
{
if (decoder.IsVariable(exp))
{
return(new Var <E>(exp, decoder));
}
else
{
switch (decoder.OperatorFor(exp))
{
case ExpressionOperator.ConvertToInt32:
case ExpressionOperator.ConvertToUInt16:
case ExpressionOperator.ConvertToUInt32:
case ExpressionOperator.ConvertToUInt8:
return(Box(decoder.LeftExpressionFor(exp), decoder));
}
return(new Exp <E>(exp, decoder));
}
}
