public bool VisitFloatEqOp(VCExprNAry node, TextWriter wr)
{
//Contract.Requires(wr != null);
//Contract.Requires(node != null);
return(PrintNAry("fp.eq", node, wr));
}
public bool VisitGeOp(VCExprNAry node, LineariserOptions options)
{
WriteApplication(">=", node, options);
return(true);
}
public override VCExpr VisitBoogieFunctionOp(VCExprNAry node, VariableBindings bindings)
{
Contract.Requires(bindings != null);
Contract.Requires(node != null);
Contract.Ensures(Contract.Result<VCExpr>() != null);
Function/*!*/ oriFun = ((VCExprBoogieFunctionOp)node.Op).Func;
Contract.Assert(oriFun != null);
UntypedFunction untypedFun = AxBuilderPremisses.Typed2Untyped(oriFun);
Contract.Assert(untypedFun.Fun.InParams.Count ==
untypedFun.ExplicitTypeParams.Count + node.Arity);
List<Type/*!*/>/*!*/ typeArgs =
ExtractTypeArgs(node,
oriFun.TypeParameters, untypedFun.ExplicitTypeParams);
return HandleFunctionOp(untypedFun.Fun, typeArgs, node, bindings);
}
public override VCExpr VisitStoreOp(VCExprNAry node, VariableBindings bindings)
{
Contract.Requires(bindings != null);
Contract.Requires(node != null);
Contract.Ensures(Contract.Result<VCExpr>() != null);
List<Type>/*!*/ instantiations; // not used
Function/*!*/ store =
AxBuilder.MapTypeAbstracter.Store(node[0].Type.AsMap, out instantiations);
Contract.Assert(store != null);
return HandleFunctionOp(store,
// the store function never has explicit
// type parameters
new List<Type/*!*/>(),
node, bindings);
}
public override VCExpr VisitSubtypeOp(VCExprNAry node, VariableBindings bindings) {
Contract.Requires((bindings != null));
Contract.Requires((node != null));
Contract.Ensures(Contract.Result<VCExpr>() != null);
// UGLY: the code for tracking polarities should be factored out
int oldPolarity = Eraser.Polarity;
Eraser.Polarity = 0;
VCExpr/*!*/ res =
Gen.Function(VCExpressionGenerator.Subtype3Op,
AxBuilder.Type2Term(node[0].Type,
bindings.TypeVariableBindings),
AxBuilder.Cast(Eraser.Mutate(node[0], bindings),
AxBuilder.U),
AxBuilder.Cast(Eraser.Mutate(node[1], bindings),
AxBuilder.U));
Eraser.Polarity = oldPolarity;
return res;
}
private OpTypesPair TypesPairForSelectStore(VCExprNAry/*!*/ node, Function/*!*/ untypedOp,
// instantiation of the abstract map type parameters
List<Type>/*!*/ abstractionInstantiation) {
Contract.Requires(node != null);
Contract.Requires(untypedOp != null);
Contract.Requires(abstractionInstantiation != null);
List<Type/*!*/>/*!*/ inferredTypeArgs = new List<Type/*!*/> ();
foreach (Type/*!*/ t in node.TypeArguments){Contract.Assert(t != null);
// inferredTypeArgs.Add(AxBuilder.MapTypeAbstracter.AbstractMapTypeRecursively(t));
inferredTypeArgs.Add(t);}
foreach (Type/*!*/ t in abstractionInstantiation) {
Contract.Assert(t != null);
inferredTypeArgs.Add(t);}
Contract.Assert(untypedOp.InParams.Count == inferredTypeArgs.Count + node.Arity);
return new OpTypesPair (Gen.BoogieFunctionOp(untypedOp), inferredTypeArgs);
}
/////////////////////////////////////////////////////////////////////////////////////
public bool Visit(VCExprNAry node, LineariserOptions options)
{
VCExprOp op = node.Op;
Contract.Assert(op != null);
var booleanOps = new HashSet <VCExprOp>();
booleanOps.Add(VCExpressionGenerator.NotOp);
booleanOps.Add(VCExpressionGenerator.ImpliesOp);
booleanOps.Add(VCExpressionGenerator.AndOp);
booleanOps.Add(VCExpressionGenerator.OrOp);
if (booleanOps.Contains(op))
{
Stack <VCExpr> exprs = new Stack <VCExpr>();
exprs.Push(node);
while (exprs.Count > 0)
{
VCExpr expr = exprs.Pop();
if (expr == null)
{
wr.Write(")");
continue;
}
wr.Write(" ");
VCExprNAry naryExpr = expr as VCExprNAry;
if (naryExpr == null || !booleanOps.Contains(naryExpr.Op))
{
Linearise(expr, options);
continue;
}
else if (naryExpr.Op.Equals(VCExpressionGenerator.NotOp))
{
wr.Write("(not");
}
else if (naryExpr.Op.Equals(VCExpressionGenerator.ImpliesOp))
{
wr.Write("(=>");
}
else if (naryExpr.Op.Equals(VCExpressionGenerator.AndOp))
{
wr.Write("(and");
}
else
{
System.Diagnostics.Debug.Assert(naryExpr.Op.Equals(VCExpressionGenerator.OrOp));
wr.Write("(or");
}
exprs.Push(null);
for (int i = naryExpr.Arity - 1; i >= 0; i--)
{
exprs.Push(naryExpr[i]);
}
}
return(true);
}
if (OptimizationRequests != null &&
(node.Op.Equals(VCExpressionGenerator.MinimizeOp) || node.Op.Equals(VCExpressionGenerator.MaximizeOp)))
{
string optOp = node.Op.Equals(VCExpressionGenerator.MinimizeOp) ? "minimize" : "maximize";
OptimizationRequests.Add(string.Format("({0} {1})", optOp,
ToString(node[0], Namer, ProverOptions, NamedAssumes)));
Linearise(node[1], options);
return(true);
}
if (node.Op is VCExprSoftOp)
{
Linearise(node[1], options);
return(true);
}
if (node.Op.Equals(VCExpressionGenerator.NamedAssumeOp))
{
var exprVar = node[0] as VCExprVar;
NamedAssumes.Add(exprVar);
Linearise(node[1], options);
return(true);
}
return(node.Accept <bool, LineariserOptions /*!*/>(OpLineariser, options));
}
// for the time being, we store both the types of the arguments and the explicit
// type parameters (for most operators, this is more than actually necessary)
private OpTypesPair OriginalOpTypes(VCExprNAry node){
Contract.Requires(node != null);
List<Type/*!*/>/*!*/ originalTypes = new List<Type/*!*/> ();
foreach (VCExpr/*!*/ expr in node) {
Contract.Assert(expr != null);
originalTypes.Add(expr.Type);
}
originalTypes.AddRange(node.TypeArguments);
return new OpTypesPair (node.Op, originalTypes);
}
public bool VisitToRealOp(VCExprNAry node, TextWriter wr)
{
//Contract.Requires(wr != null);
//Contract.Requires(node != null);
return(PrintNAry("real", node, wr));
}
private static string CheckMapApply(string name, VCExprNAry node)
{
if (name == "MapConst")
{
Type type = node.Type;
string s = TypeToString(type);
return("(as const " + s + ")");
}
else if (name == "MapAdd")
{
return("(_ map (+ (Int Int) Int))");
}
else if (name == "MapSub")
{
return("(_ map (- (Int Int) Int))");
}
else if (name == "MapMul")
{
return("(_ map (* (Int Int) Int))");
}
else if (name == "MapDiv")
{
return("(_ map (div (Int Int) Int))");
}
else if (name == "MapMod")
{
return("(_ map (mod (Int Int) Int))");
}
else if (name == "MapEq")
{
Type type = ResultType(node[0].Type);
string s = TypeToString(type);
return("(_ map (= (" + s + " " + s + ") Bool))");
}
else if (name == "MapIff")
{
return("(_ map (= (Bool Bool) Bool))");
}
else if (name == "MapGt")
{
return("(_ map (> (Int Int) Int))");
}
else if (name == "MapGe")
{
return("(_ map (>= (Int Int) Int))");
}
else if (name == "MapLt")
{
return("(_ map (< (Int Int) Int))");
}
else if (name == "MapLe")
{
return("(_ map (<= (Int Int) Int))");
}
else if (name == "MapOr")
{
return("(_ map or)");
}
else if (name == "MapAnd")
{
return("(_ map and)");
}
else if (name == "MapNot")
{
return("(_ map not)");
}
else if (name == "MapImp")
{
return("(_ map =>)");
}
else if (name == "MapIte")
{
Type type = ResultType(node.Type);
string s = TypeToString(type);
return("(_ map (ite (Bool " + s + " " + s + ") " + s + "))");
}
else
{
return(name);
}
}
public bool VisitSubtype3Op(VCExprNAry node, TextWriter wr)
{
//Contract.Requires(wr != null);
//Contract.Requires(node != null);
return(PrintNAry("<::", node, wr));
}
public bool VisitIfThenElseOp(VCExprNAry node, TextWriter wr)
{
//Contract.Requires(wr != null);
//Contract.Requires(node != null);
return(PrintNAry("if-then-else", node, wr));
}
public bool VisitBvConcatOp(VCExprNAry node, TextWriter wr)
{
//Contract.Requires(wr != null);
//Contract.Requires(node != null);
return(PrintNAry("BvConcat", node, wr));
}
public bool VisitSubtype3Op(VCExprNAry node, LineariserOptions options)
{
WriteApplication("UOrdering3", node, options);
return(true);
}
///////////////////////////////////////////////////////////////////////////////////
public bool VisitNotOp(VCExprNAry node, LineariserOptions options)
{
WriteApplication("not", node, options); // arguments can be both terms and formulas
return(true);
}
public bool VisitToIntOp(VCExprNAry node, LineariserOptions options)
{
WriteApplication("to_int", node, options);
return(true);
}
public bool VisitEqOp(VCExprNAry node, LineariserOptions options)
{
return(PrintEq(node, options));
}
public override VCExpr VisitNeqOp(VCExprNAry node, VariableBindings bindings) {
Contract.Requires((bindings != null));
Contract.Requires((node != null));
Contract.Ensures(Contract.Result<VCExpr>() != null);
// we also have to state that the types are (un)equal, because the
// translation does not contain any information about the
// relationship between values and types
return Gen.OrSimp(base.VisitNeqOp(node, bindings),
Gen.Not(EqualTypes(node[0].Type, node[1].Type, bindings)));
}
public bool VisitIfThenElseOp(VCExprNAry node, LineariserOptions options)
{
WriteApplication("ite", node, options);
return(true);
}
public override VCExpr VisitStoreOp(VCExprNAry node, VariableBindings bindings) {
Contract.Requires((bindings != null));
Contract.Requires((node != null));
Contract.Ensures(Contract.Result<VCExpr>() != null);
OpTypesPair originalOpTypes = OriginalOpTypes(node);
OpTypesPair newOpTypes;
if (!NewOpCache.TryGetValue(originalOpTypes, out newOpTypes)) {
MapType/*!*/ rawType = node[0].Type.AsMap;
List<Type>/*!*/ abstractionInstantiation;
Function/*!*/ store =
AxBuilder.MapTypeAbstracter.Store(rawType, out abstractionInstantiation);
newOpTypes = TypesPairForSelectStore(node, store, abstractionInstantiation);
NewOpCache.Add(originalOpTypes, newOpTypes);
}
return AssembleOpExpression(newOpTypes, node, bindings);
}
public bool VisitFloatEqOp(VCExprNAry node, LineariserOptions options)
{
WriteApplication("fp.eq", node, options);
return(true);
}
///////////////////////////////////////////////////////////////////////////
public override VCExpr VisitBoogieFunctionOp(VCExprNAry node, VariableBindings bindings) {
Contract.Requires((bindings != null));
Contract.Requires((node != null));
Contract.Ensures(Contract.Result<VCExpr>() != null);
OpTypesPair originalOpTypes = OriginalOpTypes(node);
OpTypesPair newOpTypes;
if (!NewOpCache.TryGetValue(originalOpTypes, out newOpTypes)) {
Function/*!*/ oriFun = ((VCExprBoogieFunctionOp)node.Op).Func;
Contract.Assert(oriFun != null);
List<Type/*!*/>/*!*/ inferredTypeArgs = new List<Type/*!*/> ();
foreach (Type/*!*/ t in node.TypeArguments){Contract.Assert(t != null);
// inferredTypeArgs.Add(AxBuilder.MapTypeAbstracter.AbstractMapTypeRecursively(t));
inferredTypeArgs.Add(t);}
VCExprOp/*!*/ newOp = Gen.BoogieFunctionOp(AxBuilderArguments.Typed2Untyped(oriFun));
newOpTypes = new OpTypesPair (newOp, inferredTypeArgs);
NewOpCache.Add(originalOpTypes, newOpTypes);
}
return AssembleOpExpression(newOpTypes, node, bindings);
}
public bool VisitBvConcatOp(VCExprNAry node, LineariserOptions options)
{
WriteApplication("concat", node, options);
return(true);
}
/*!*/
public override VCExpr VisitSelectOp(VCExprNAry/*!*/ node,
VariableBindings/*!*/ bindings)
{
Contract.Requires(node != null); Contract.Requires(bindings != null);
Contract.Ensures(Contract.Result<VCExpr>() != null);
MapType/*!*/ mapType = node[0].Type.AsMap;
Contract.Assert(mapType != null);
List<Type>/*!*/ instantiations; // not used
Function/*!*/ select =
AxBuilder.MapTypeAbstracter.Select(mapType, out instantiations);
Contract.Assert(select != null);
List<int>/*!*/ explicitTypeParams =
AxBuilderPremisses.MapTypeAbstracterPremisses
.ExplicitSelectTypeParams(mapType);
Contract.Assert(select.InParams.Count == explicitTypeParams.Count + node.Arity);
List<Type/*!*/>/*!*/ typeArgs = new List<Type/*!*/>(explicitTypeParams.Count);
foreach (int i in explicitTypeParams)
typeArgs.Add(node.TypeArguments[i]);
return HandleFunctionOp(select, typeArgs, node, bindings);
}
public bool VisitPowOp(VCExprNAry node, LineariserOptions options)
{
WriteApplication("real_pow", node, options);
return(true);
}
/*!*/
private List<Type/*!*/> ExtractTypeArgs(VCExprNAry node, List<TypeVariable> allTypeParams, List<TypeVariable/*!*/>/*!*/ explicitTypeParams)
{
Contract.Requires(allTypeParams != null);
Contract.Requires(node != null);
Contract.Requires(cce.NonNullElements(explicitTypeParams));
Contract.Ensures(cce.NonNullElements(Contract.Result<List<Type>>()));
List<Type/*!*/>/*!*/ res = new List<Type/*!*/>(explicitTypeParams.Count);
foreach (TypeVariable/*!*/ var in explicitTypeParams) {
Contract.Assert(var != null);
// this lookup could be optimised
res.Add(node.TypeArguments[allTypeParams.IndexOf(var)]);
}
return res;
}
public bool VisitImpliesOp(VCExprNAry node, TextWriter wr)
{
//Contract.Requires(wr != null);
//Contract.Requires(node != null);
return(PrintNAry("Implies", node, wr));
}
