public IAbstractDomain Join(IAbstractDomain a)
{
IAbstractDomain result;
if (AbstractDomainsHelper.TryTrivialJoin(this, a, out result))
{
return(result);
}
BoundedDisjunction <Variable, Expression> asDisjunctionDomain = a as BoundedDisjunction <Variable, Expression>;
Debug.Assert(asDisjunctionDomain != null);
INumericalAbstractDomain <Variable, Expression>[] joinDisjuncts = new INumericalAbstractDomain <Variable, Expression> [this.disjuncts.Length + asDisjunctionDomain.disjuncts.Length];
// Copy both the domains
for (int i = 0; i < this.disjuncts.Length; i++)
{
joinDisjuncts[i] = this.disjuncts[i];
}
for (int i = 0; i < asDisjunctionDomain.disjuncts.Length; i++)
{
joinDisjuncts[this.disjuncts.Length + i] = asDisjunctionDomain.disjuncts[i];
}
return(new BoundedDisjunction <Variable, Expression>(joinDisjuncts));
}
public SimpleArrayAbstraction <Variable, Expression> Join(SimpleArrayAbstraction <Variable, Expression> right)
{
SimpleArrayAbstraction <Variable, Expression> trivialResult;
if (AbstractDomainsHelper.TryTrivialJoin(this, right, out trivialResult))
{
return(trivialResult);
}
SimpleArrayAbstraction <Variable, Expression> result = new SimpleArrayAbstraction <Variable, Expression>(this.encoder, this.decoder);
foreach (var e in this.content)
{
IAbstractDomainForEnvironments <Variable, Expression> rightProperty;
var leftProperty = e.Value;
if (right.content.TryGetValue(e.Key, out rightProperty))
{
result.content.Add(e.Key, (IAbstractDomainForEnvironments <Variable, Expression>)leftProperty.Join(rightProperty));
}
else
{
throw new AbstractInterpretationException();
}
}
return(result);
}
public IAbstractDomain /*!*/ Join(IAbstractDomain /*!*/ a)
{
IAbstractDomain /*!*/ result;
if (AbstractDomainsHelper.TryTrivialJoin(this, a, out result))
{
return(result);
}
Debug.Assert(a is SymbolicExpressionsAbstractDomain <Expression>, "Expecting an instance of SymbolicExpressionsAbstractDomain. Found " + a);
//^ assert a is SymbolicExpressionsAbstractDomain<Expression>;
SymbolicExpressionsAbstractDomain <Expression> right = a as SymbolicExpressionsAbstractDomain <Expression>;
FunctionalAbstractDomain <Expression, FlatAbstractDomainWithComparer <Expression> > joinSymbolicExpressions =
(FunctionalAbstractDomain <Expression, FlatAbstractDomainWithComparer <Expression> >) this.var2exp.Join(right.var2exp); // Join the symbolic expression bindings
Debug.Assert(!joinSymbolicExpressions.IsBottom, "The join of two non-bottom expression environments cannot be bottom");
//^ assert !joinSymbolicExpressions.IsBottom;
/*
* if (joinSymbolicExpressions.IsTop)
* {
* return this.Top;
* }
* else
* {*/
return(new SymbolicExpressionsAbstractDomain <Expression>(joinSymbolicExpressions, this.decoder, this.encoder));
//}
}
public PolyhedraEnvironment <Expression> Join(PolyhedraEnvironment <Expression> right)
{
PolyhedraEnvironment <Expression> result;
if (AbstractDomainsHelper.TryTrivialJoin(this, right, out result))
{
return(result);
}
else
{
return(Factory(UnderlyingPolyhedra.Join(embedded, right.embedded), intv.Join(right.intv)));
}
}
public SimpleArrayAbstractDomain <Variable, Expression> Join(SimpleArrayAbstractDomain <Variable, Expression> a, Set <Variable> keep)
{
SimpleArrayAbstractDomain <Variable, Expression> result;
if (AbstractDomainsHelper.TryTrivialJoin(this, a, out result))
{
return(result);
}
var joinLeftPart = (INumericalAbstractDomain <Variable, Expression>) this.Left.Join(a.Left);
var joinRightPart = this.Right.Join(a.Right, keep);
return((SimpleArrayAbstractDomain <Variable, Expression>) this.Reduce(joinLeftPart, joinRightPart));
}
public PolyhedraEnvironment <Expression> Widening(PolyhedraEnvironment <Expression> prev)
{
PolyhedraEnvironment <Expression> result;
if (AbstractDomainsHelper.TryTrivialJoin(this, prev, out result))
{
return(result);
}
else
{
// Boogie's polyhedra has it in the other order
return(Factory(UnderlyingPolyhedra.Widen(prev.embedded, embedded), intv.Widening(prev.intv)));
}
}
public SymbolicExpressionTracker <Variable, Expression> Join(SymbolicExpressionTracker <Variable, Expression> other)
{
Contract.Requires(other != null);
Contract.Ensures(Contract.Result <SymbolicExpressionTracker <Variable, Expression> >() != null);
SymbolicExpressionTracker <Variable, Expression> result;
if (AbstractDomainsHelper.TryTrivialJoin(this, other, out result))
{
return(result);
}
other = UnifySlackVariableWith(other);
return(new SymbolicExpressionTracker <Variable, Expression>(slackVar, symbolicConditions.Join(other.symbolicConditions)));
}
public SegmentLimit <Variable> Join(SegmentLimit <Variable> other)
{
Contract.Requires(other != null);
Contract.Ensures(Contract.Result <SegmentLimit <Variable> >() != null);
SegmentLimit <Variable> result;
if (AbstractDomainsHelper.TryTrivialJoin(this, other, out result))
{
return(result);
}
var set = expressions.Intersection(other.Expressions);
var isconditional = this.IsConditional || other.IsConditional;
return(new SegmentLimit <Variable>(set, isconditional));
}
public EnumDefined <Variable, Type, Expression> Join(EnumDefined <Variable, Type, Expression> other)
{
Contract.Requires(other != null);
Contract.Ensures(Contract.Result <EnumDefined <Variable, Type, Expression> >() != null);
EnumDefined <Variable, Type, Expression> result;
if (AbstractDomainsHelper.TryTrivialJoin(this, other, out result))
{
return(result);
}
Contract.Assume(other.conditions != null);
Contract.Assume(other.defined != null);
return(new EnumDefined <Variable, Type, Expression>(conditions.Join(other.conditions), defined.Join(other.defined)));
}
public ScalarFromArrayTracking Widening(ScalarFromArrayTracking prev)
{
Contract.Requires(prev != null);
Contract.Ensures(Contract.Result <ScalarFromArrayTracking>() != null);
ScalarFromArrayTracking result;
if (AbstractDomainsHelper.TryTrivialJoin(this, prev, out result))
{
return(result);
}
return(new ScalarFromArrayTracking(
(SetOfConstraints <BoxedVariable <Variable> >) this.left.Widening(prev.left),
(SetOfConstraints <BoxedVariable <Variable> >) this.right.Widening(prev.right),
this.isUnmodifiedFromEntry.Join(prev.isUnmodifiedFromEntry), this.conditions.Join(prev.conditions)));
}
public IAbstractDomain Widening(IAbstractDomain prev)
{
IAbstractDomain result;
if (AbstractDomainsHelper.TryTrivialJoin(this, prev, out result))
{
return(result);
}
BoundedDisjunction <Variable, Expression> asDisjunctionDomain = prev as BoundedDisjunction <Variable, Expression>;
Debug.Assert(asDisjunctionDomain != null);
INumericalAbstractDomain <Variable, Expression> left = SmashTogether(this.disjuncts);
INumericalAbstractDomain <Variable, Expression> right = SmashTogether(asDisjunctionDomain.disjuncts);
return(new BoundedDisjunction <Variable, Expression>((INumericalAbstractDomain <Variable, Expression>)left.Widening(right)));
}
public override DisInterval Join(DisInterval a)
{
DisInterval trivial;
if (AbstractDomainsHelper.TryTrivialJoin(this, a, out trivial))
{
return(trivial);
}
var joinIntervals = Join(this.intervals, a.intervals);
if (joinIntervals.Count == 0)
{
return(Top);
}
return(new DisInterval(joinIntervals));
}
public ArrayState Widening(ArrayState a)
{
Contract.Requires(this.PluginsCount == a.PluginsCount);
Contract.Ensures(Contract.Result <ArrayState>() != null);
Contract.Ensures(Contract.Result <ArrayState>().PluginsCount == this.PluginsCount);
ArrayState result;
if (AbstractDomainsHelper.TryTrivialJoin(this, a, out result))
{
return(result);
}
#if DEBUG
// F: for debugging
result = null;
#endif
ArraySegmentationEnvironment <NonRelationalValueAbstraction <BoxedVariable <Variable>, BoxedExpression>, BoxedVariable <Variable>, BoxedExpression> array = null;
INumericalAbstractDomain <BoxedVariable <Variable>, BoxedExpression> numerical = null;
#if PARALLELWIDENING
var arrayTask = Task.Run(() => array = this.Array.Widening(a.Array));
var numericalTask = Task.Run(() => numerical = this.Numerical.Widening(a.Numerical) as INumericalAbstractDomain <BoxedVariable <Variable>, BoxedExpression>);
#else
array = this.Array.Widening(a.Array);
numerical = this.Numerical.Widening(a.Numerical) as INumericalAbstractDomain <BoxedVariable <Variable>, BoxedExpression>;
#endif
var plugins = new IAbstractDomainForEnvironments <BoxedVariable <Variable>, BoxedExpression> [this.PluginsCount];
for (var i = 0; i < this.PluginsCount; i++)
{
plugins[i] = this.PluginAbstractStateAt(i).Widening(a.PluginAbstractStateAt(i)) as IAbstractDomainForEnvironments <BoxedVariable <Variable>, BoxedExpression>;
}
#if PARALLELWIDENING
Task.WaitAll(arrayTask, numericalTask);
#endif
return(new ArrayState(array, numerical, plugins, this.mappings));
}
public NonRelationalValueAbstraction <Variable, Expression> Widening(NonRelationalValueAbstraction <Variable, Expression> prev)
{
Contract.Requires(prev != null);
Contract.Ensures(Contract.Result <NonRelationalValueAbstraction <Variable, Expression> >() != null);
NonRelationalValueAbstraction <Variable, Expression> result;
if (AbstractDomainsHelper.TryTrivialJoin(this, prev, out result))
{
return(result);
}
var intv = disInterval.Widening(prev.Interval);
var symbolicConditions = this.symbolicConditions.Join(prev.symbolicConditions);
Contract.Assume(weaklyRelationalDomains.Length == prev.weaklyRelationalDomains.Length);
var newWeaklyDomains = ParallelOperation(weaklyRelationalDomains, prev.weaklyRelationalDomains, (x, y) => x.Widening(y));
return(new NonRelationalValueAbstraction <Variable, Expression>(intv, SymbolicConditions, newWeaklyDomains));
}
public NonRelationalValueAbstraction <Variable, Expression> Join(NonRelationalValueAbstraction <Variable, Expression> other)
{
Contract.Requires(other != null);
Contract.Ensures(Contract.Result <NonRelationalValueAbstraction <Variable, Expression> >() != null);
NonRelationalValueAbstraction <Variable, Expression> result;
if (AbstractDomainsHelper.TryTrivialJoin(this, other, out result))
{
return(result);
}
var intv = this.disInterval.Join(other.Interval);
var symbolicConditions = this.symbolicConditions.Join(other.symbolicConditions);
Contract.Assume(this.weaklyRelationalDomains.Length == other.weaklyRelationalDomains.Length);
var newWeaklyDomains = ParallelOperation(this.weaklyRelationalDomains, other.weaklyRelationalDomains, (x, y) => x.Join(y));
return(new NonRelationalValueAbstraction <Variable, Expression>(intv, symbolicConditions, newWeaklyDomains));
}
public IAbstractDomain /*!*/ Join(IAbstractDomain /*!*/ a)
{
IAbstractDomain tryResult;
if (AbstractDomainsHelper.TryTrivialJoin(this, a, out tryResult))
{
return(tryResult);
}
StringAbstraction right = a as StringAbstraction;
//^ assert right != null;
Debug.Assert(right != null, "I was expecting a " + this.GetType().ToString());
IAbstractDomain /*!*/ result;
if (content == right.content)
{
switch (content)
{
#region All the cases
case ContentType.Prefix:
result = HelperForPrefixJoin(prefix, right.prefix);
break;
case ContentType.SetOfCharacters:
result = HelperForSetOfCharactersJoin(characters, right.characters);
break;
case ContentType.String:
result = HelperForStringJoin(fullstring, right.fullstring);
break;
case ContentType.Top:
case ContentType.Bottom:
default:
// Impossible cases as they have already been checked before
throw new AbstractInterpretationException("Impossible case?");
#endregion
}
}
else
{
switch (content)
{
#region All the cases...
case ContentType.Prefix:
if (right.content == ContentType.SetOfCharacters)
{
result = this.Top;
}
else if (right.content == ContentType.String)
{
result = HelperForStringPrefixJoin(right.fullstring, prefix);
}
else
{
goto default;
}
break;
case ContentType.SetOfCharacters:
if (right.content == ContentType.Prefix)
{
result = this.Top;
}
else if (right.content == ContentType.String)
{
result = HelperForSetOfCharactersJoin(characters, AlphaToSetOfCharacters(right.fullstring));
}
else
{
goto default;
}
break;
case ContentType.String:
if (right.content == ContentType.Prefix)
{
result = HelperForStringPrefixJoin(fullstring, right.prefix);
}
else if (right.content == ContentType.SetOfCharacters)
{
result = HelperForSetOfCharactersJoin(AlphaToSetOfCharacters(fullstring), right.characters);
}
else
{
goto default;
}
break;
case ContentType.Top:
case ContentType.Bottom:
default:
// Impossible cases as they have already been checked before
throw new AbstractInterpretationException("Impossible case?");
#endregion
}
}
return(result);
}
