protected override void OnVariableAssignmentRetracted(
FlowVariable variable,
int assignedVersion,
Expression value)
{
this.AddVariableValue(new VersionedVariable(variable, assignedVersion));
}
public T this[FlowVariable variable]
{
get
{
var localVariable = variable as LocalFlowVariable;
if (localVariable != null)
{
return(this[localVariable]);
}
else
{
return(this[(GlobalFlowVariable)variable]);
}
}
set
{
var localVariable = variable as LocalFlowVariable;
if (localVariable != null)
{
this[localVariable] = value;
}
else
{
this[(GlobalFlowVariable)variable] = value;
}
}
}
public Assignment(FlowVariable variable, Expression value)
{
Contract.Requires <ArgumentNullException>(variable != null, nameof(variable));
Contract.Requires <ArgumentNullException>(value != null, nameof(value));
Contract.Requires <ArgumentException>(value.Sort == variable.Sort, nameof(value));
this.Variable = variable;
this.Value = value;
}
private void AssertEquals(FlowVariable variable, int version, Expression value)
{
var symbolName = this.SmtContextHandler.GetVariableVersionSymbol(variable, version);
var symbolWrapper = ExpressionFactory.NamedVariable(variable.Sort, symbolName);
var equal = (BoolHandle)ExpressionFactory.Equal(symbolWrapper, value);
this.smtSolver.AddAssertion(this.NameProvider, equal);
}
protected FieldOperation(FlowVariable reference, IFieldDefinition field)
{
Contract.Requires(reference != null, nameof(reference));
Contract.Requires(field != null, nameof(field));
Contract.Requires(reference.IsReference, nameof(reference));
this.Reference = reference;
this.Field = field;
}
public FieldRead(FlowVariable resultStore, FlowVariable reference, IFieldDefinition field)
: base(reference, field)
{
Contract.Requires <ArgumentNullException>(resultStore != null, nameof(resultStore));
Contract.Requires <ArgumentNullException>(reference != null, nameof(reference));
Contract.Requires <ArgumentNullException>(field != null, nameof(field));
Contract.Requires <ArgumentException>(reference.IsReference, nameof(reference));
Contract.Requires <ArgumentException>(resultStore.Sort == field.Sort, nameof(resultStore));
this.ResultStore = resultStore;
}
private void NewVariableRelayCommand(object parameter)
{
var lastVariable = Variables.OrderBy(x => x.Name).LastOrDefault();
var newVariable = new FlowVariable
{
Name = lastVariable != null ? lastVariable.Name + "(Copy)" : "New Variable",
Type = typeof(string)
};
Variables.Add(newVariable);
}
public FieldWrite(FlowVariable reference, IFieldDefinition field, Expression value)
: base(reference, field)
{
Contract.Requires <ArgumentNullException>(reference != null, nameof(reference));
Contract.Requires <ArgumentNullException>(field != null, nameof(field));
Contract.Requires <ArgumentNullException>(value != null, nameof(value));
Contract.Requires <ArgumentException>(reference.IsReference, nameof(reference));
Contract.Requires <ArgumentException>(value.Sort == field.Sort, nameof(value));
this.Value = value;
}
public int GetVariableVersion(FlowVariable variable)
{
// TODO: Consider turning null into a global variable to avoid this check
if (variable == References.Null)
{
return(VersionedVariable.Null.Version);
}
else
{
return(this.variableVersions[variable].CurrentVersion);
}
}
public static bool IsReferenceComparison(
Expression expr,
out bool areEqual,
out FlowVariable left,
out FlowVariable right)
{
if ((expr?.Kind == ExpressionKind.Equal || expr?.Kind == ExpressionKind.Distinct) &&
expr.GetChild(0).Sort == Sort &&
expr.GetChild(0) is FlowVariable leftVar &&
expr.GetChild(1) is FlowVariable rightVar)
{
Contract.Assert(expr.Sort == Sort.Bool);
Contract.Assert(expr.GetChild(1).Sort == Sort);
areEqual = (expr.Kind == ExpressionKind.Equal);
left = leftVar;
right = rightVar;
return(true);
}
internal SymbolName GetVariableVersionSymbol(FlowVariable variable, int version)
{
Contract.Requires(variable != null);
Contract.Requires(version >= 0);
var versionsList = this.variableVersionSymbols[variable];
for (int i = versionsList.Count; i <= version; i++)
{
// TODO: Make configurable without the dependence on the Debug/Release configuration
#if DEBUG
var symbolName = new SymbolName($"{variable.ToString()}_{version}", this.lastVariableNumber);
#else
var symbolName = new SymbolName(null, this.lastVariableNumber);
#endif
this.lastVariableNumber++;
versionsList.Add(symbolName);
}
return(versionsList[version]);
}
protected override void OnVariableAssigned(
FlowVariable variable,
int lastVersion,
Expression value)
{
if (variable.IsReference)
{
var leftRef = new VersionedVariable(variable, lastVersion);
var rightRef = this.GetVersioned((FlowVariable)value);
this.Heap.AssignReference(leftRef, rightRef);
}
else if (References.IsReferenceComparison(value, out bool areEqual, out var left, out var right))
{
var varLeft = this.GetVersioned(left);
var varRight = this.GetVersioned(right);
value = this.Heap.GetEqualityExpression(areEqual, varLeft, varRight);
}
if (!variable.IsReference)
{
this.AssertEquals(variable, lastVersion, value);
}
}
public VersionedVariable(FlowVariable variable, int version)
{
this.Variable = variable;
this.Version = version;
}
protected override void OnRandomVariableRetracted(FlowVariable variable, int version)
{
this.AddVariableValue(new VersionedVariable(variable, version));
}
public VersionedVariable GetVersioned(FlowVariable variable)
{
int version = this.owner.pathConditionHandler.GetVariableVersion(variable);
return(new VersionedVariable(variable, version));
}
public VersionedVariable GetVersioned(FlowVariable variable)
{
int version = this.GetVariableVersion(variable);
return(new VersionedVariable(variable, version));
}
