public void ModelOperation(IModellingContext context, IMethodSymbol method, IEnumerable <ITypeModel> arguments)
{
Contract.Requires(context != null);
Contract.Requires(method != null);
Contract.Requires(arguments != null);
Contract.Requires(arguments.Count() == method.Parameters.Length);
if (method.MethodKind != MethodKind.BuiltinOperator ||
method.Parameters.Length == 0 ||
!this.IsTypeSupported(method.ReturnType))
{
// This might be the case of static methods etc.
context.SetUnsupported();
return;
}
BoolHandle boolResult = GetOperationResult(method, arguments);
if (boolResult.Expression != null)
{
Contract.Assert(this.IsTypeSupported(method.ReturnType));
var resultModel = new BooleanModel(this, method.ReturnType, boolResult);
context.SetResultValue(resultModel);
}
else
{
context.SetUnsupported();
}
}
internal BooleanModel(BooleanModelFactory factory, ITypeSymbol type, BoolHandle value)
{
Contract.Requires <ArgumentNullException>(factory != null, nameof(factory));
Contract.Requires <ArgumentException>(value.Expression != null, nameof(value));
this.Factory = factory;
this.Type = type;
this.Value = value;
}
internal InnerFlowEdge(InnerFlowEdgeId id, FlowNode from, FlowNode to, BoolHandle condition)
: base(from, to)
{
Contract.Requires(id.IsValid);
Contract.Requires(from.Graph == to.Graph);
Contract.Requires(condition.Expression != null);
this.Graph = from.Graph;
this.Id = id;
this.Condition = condition;
}
public InnerFlowEdge AddEdge(FlowNode from, FlowNode to, BoolHandle condition)
{
Contract.Requires <InvalidOperationException>(this.Graph != null);
Contract.Requires <ArgumentNullException>(from != null, nameof(from));
Contract.Requires <ArgumentNullException>(to != null, nameof(to));
Contract.Requires <ArgumentException>(from.Graph == this.Graph, nameof(from));
Contract.Requires <ArgumentException>(to.Graph == this.Graph, nameof(to));
var edgeId = this.edgeIdProvider.GenerateNewId();
var edge = new InnerFlowEdge(edgeId, from, to, condition);
this.Graph.MutableEdges.Add(edge);
Contract.Assert(edgeId.Value == this.Graph.MutableEdges.IndexOf(edge));
edge.From.MutableOutgoingEdges.Add(edge);
edge.To.MutableIngoingEdges.Add(edge);
return(edge);
}
public void InterpretationConstructedProperly()
{
var trueVal = new BoolHandle(true);
ExpressionTestHelper.CheckExpression(
trueVal.Expression,
ExpressionKind.Interpretation,
Sort.Bool,
true.ToString(),
0);
Assert.AreEqual(ExpressionFactory.True, trueVal.Expression);
BoolHandle falseVal = false;
ExpressionTestHelper.CheckExpression(
falseVal.Expression,
ExpressionKind.Interpretation,
Sort.Bool,
false.ToString(),
0);
Assert.AreEqual(ExpressionFactory.False, falseVal.Expression);
}
private void GetOperationResult(
IModellingContext context,
IMethodSymbol method,
IEnumerable <ITypeModel> arguments,
out IntHandle intResult,
out BoolHandle boolResult)
{
var first = ((IntegerModel)arguments.First()).Value;
if (method.Parameters.Length == 1)
{
if (method.Name == "op_UnaryNegation")
{
intResult = -first;
}
else if (method.Name == "op_UnaryPlus")
{
intResult = first;
}
}
else
{
Contract.Assert(method.Parameters.Length == 2);
var second = ((IntegerModel)arguments.ElementAt(1)).Value;
if (BooleanModelFactory.Instance.IsTypeSupported(method.ReturnType))
{
switch (method.Name)
{
case "op_Equality":
boolResult = (first == second);
break;
case "op_Inequality":
boolResult = (first != second);
break;
case "op_GreaterThan":
boolResult = (first > second);
break;
case "op_LessThan":
boolResult = (first < second);
break;
case "op_GreaterThanOrEqual":
boolResult = (first >= second);
break;
case "op_LessThanOrEqual":
boolResult = (first <= second);
break;
default:
break;
}
}
else
{
Contract.Assert(this.IsTypeSupported(method.ReturnType));
switch (method.Name)
{
case "op_Addition":
intResult = first + second;
break;
case "op_Subtraction":
intResult = first - second;
break;
case "op_Division":
// TODO: Set the exception if the right is zero
intResult = first / second;
break;
case "op_Modulus":
intResult = first % second;
break;
case "op_Multiply":
intResult = first * second;
break;
default:
break;
}
}
}
}
public BoolHandleTest()
{
this.a = (BoolHandle)ExpressionFactory.NamedVariable(Sort.Bool, "a");
this.b = (BoolHandle)ExpressionFactory.NamedVariable(Sort.Bool, "b");
this.c = (BoolHandle)ExpressionFactory.NamedVariable(Sort.Bool, "c");
}
public ArrayHandleTest()
{
this.a = (ArrayHandle <IntHandle, BoolHandle>)ExpressionFactory.NamedVariable(arraySort, "a");
this.k = (IntHandle)ExpressionFactory.NamedVariable(Sort.Int, "k");
this.v = (BoolHandle)ExpressionFactory.NamedVariable(Sort.Bool, "v");
}
protected override void OnConditionAsserted(BoolHandle condition)
{
this.smtSolver.AddAssertion(this.NameProvider, condition);
}
public void AddAssertion(BoolHandle assertion)
{
this.owner.smtSolver.AddAssertion(this.owner.pathConditionHandler.NameProvider, assertion);
}
public void AddExceptionThrow(BoolHandle condition, Type exceptionType)
{
throw new NotImplementedException();
}
public void AddAssertion <TVariable>(INameProvider <TVariable> varNameProvider, BoolHandle assertion)
where TVariable : Variable
{
// It is expected to be reused by multiple solvers
var converter = this.context.ExpressionConverter;
var expr = (BoolExpr)converter.Convert(assertion, varNameProvider);
this.solver.Assert(expr);
}
public void AddAssertion(BoolHandle assertion) => this.AddAssertion((INameProvider <Variable>)null, assertion);
public bool GetValue(BoolHandle handle)
{
throw new NotImplementedException();
}
internal BooleanValueModel(BooleanModelFactory factory, ITypeSymbol type, BoolHandle value)
: base(factory, type, value)
{
Contract.Requires(value.Expression.Kind == ExpressionKind.Interpretation);
}
