public override bool VisitConstant(Expression left, Void data)
{
Int32 value;
if (this.Decoder.TryValueOf <Int32>(left, ExpressionType.Int32, out value))
{
result = NormalizedExpression <Variable> .For(value);
return(true);
}
return(false);
}
public override bool VisitAddition(Expression left, Expression right, Expression original, Void data)
{
NormalizedExpression <Variable> leftNorm, rightNorm;
if (this.TryConvert(left, out leftNorm))
{
Contract.Assert(leftNorm != null);
if (this.TryConvert(right, out rightNorm))
{
Contract.Assert(rightNorm != null);
// All the cases. We declare all the variables here,
// so to leverage the definite assignment analysis of
// the compiler to check we are doing everything right
int leftConst, rightCont;
Variable leftVar, rightVar;
if (leftNorm.IsConstant(out leftConst))
{
// K + K
if (rightNorm.IsConstant(out rightCont))
{
result = NormalizedExpression <Variable> .For(leftConst + rightCont); // Can overflow, we do not care has it may be the concrete semantics
return(true);
}
// K + V
if (rightNorm.IsVariable(out rightVar))
{
result = NormalizedExpression <Variable> .For(rightVar, leftConst);
return(true);
}
}
else if (leftNorm.IsVariable(out leftVar))
{
// V + K
if (rightNorm.IsConstant(out rightCont))
{
result = NormalizedExpression <Variable> .For(leftVar, rightCont);
return(true);
}
}
}
}
return(Default(data));
}
public override void AssignInParallel(Dictionary <Variable, FList <Variable> > sourcesToTargets, Converter <Variable, Expression> convert)
{
var newMaps = this.Factory();
foreach (var pair in this.Elements)
{
FList <Variable> newNames;
if (sourcesToTargets.TryGetValue(pair.Key, out newNames))
{
Contract.Assume(pair.Value != null);
ArraySegmentation <AbstractDomain, Variable, Expression> renamedElement;
if (pair.Value.TryAssignInParallelFunctional(sourcesToTargets, convert, out renamedElement))
{
renamedElement = renamedElement.Simplify();
foreach (var name in newNames.GetEnumerable())
{
newMaps.AddElement(name, renamedElement);
}
}
}
// else, it is abstracted away...
}
// We need constants....
// So we want to add all the knowledge const == var the possible
var decoder = this.ExpressionManager.Decoder;
foreach (var pair in sourcesToTargets)
{
int value;
var sourceExp = convert(pair.Key);
if (decoder.TryValueOf(sourceExp, ExpressionType.Int32, out value))
{
var k = NormalizedExpression <Variable> .For(value);
var eq = new Set <NormalizedExpression <Variable> >();
foreach (var v in pair.Value.GetEnumerable())
{
eq.Add(NormalizedExpression <Variable> .For(v));
}
newMaps = newMaps.TestTrueEqualAsymmetric(eq, k);
}
}
this.CopyAndTransferOwnership(newMaps);
}
public SegmentLimit <Variable> AssignInParallel <Expression>(Dictionary <Variable, FList <Variable> > sourceToTargets, Converter <Variable, Expression> convert,
IExpressionDecoder <Variable, Expression> decoder)
{
#region Contracts
Contract.Requires(sourceToTargets != null);
Contract.Requires(convert != null);
Contract.Requires(decoder != null);
Contract.Ensures(Contract.Result <SegmentLimit <Variable> >() != null);
#endregion
var newSet = new Set <NormalizedExpression <Variable> >();
foreach (var x in expressions)
{
Contract.Assume(x != null);
FList <Variable> targets;
int value;
Variable var;
if (x.IsConstant(out value))
{
newSet.Add(x);
}
else if (x.IsVariable(out var))
{
if (sourceToTargets.TryGetValue(var, out targets))
{
Contract.Assume(targets != null);
foreach (var newName in targets.GetEnumerable())
{
newSet.Add(NormalizedExpression <Variable> .For(newName));
}
}
}
else if (x.IsAddition(out var, out value))
{
if (sourceToTargets.TryGetValue(var, out targets))
{
Contract.Assume(targets != null);
foreach (var newName in targets.GetEnumerable())
{
newSet.Add(NormalizedExpression <Variable> .For(newName, value));
}
}
// This is a special case to handle renaming for a[p++] = ...
// We have (var + value) --> var
Variable source;
if (IsATarget(var, sourceToTargets, out source))
{
Variable v;
int k;
if (decoder.TryMatchVarPlusConst(convert(source), out v, out k) && v.Equals(var) && k == value)
{
newSet.Add(NormalizedExpression <Variable> .For(var));
}
}
}
}
return(new SegmentLimit <Variable>(newSet, this.IsConditional));
}
public override bool VisitVariable(Variable variable, Expression original, Void data)
{
result = NormalizedExpression <Variable> .For(variable);
return(true);
}