/////////////////////////////////////////////////////////////////////////////////////
public bool Visit(VCExprNAry node, LineariserOptions options)
{
//Contract.Requires(options != null);
//Contract.Requires(node != null);
VCExprOp op = node.Op;
Contract.Assert(op != null);
if (!options.AsTerm &&
(op.Equals(VCExpressionGenerator.AndOp) ||
op.Equals(VCExpressionGenerator.OrOp)))
{
// handle these operators without recursion
wr.Write("({0}",
op.Equals(VCExpressionGenerator.AndOp) ? andName : orName);
IEnumerator enumerator = new VCExprNAryUniformOpEnumerator(node);
Contract.Assert(enumerator != null);
while (enumerator.MoveNext())
{
VCExprNAry naryExpr = enumerator.Current as VCExprNAry;
if (naryExpr == null || !naryExpr.Op.Equals(op))
{
wr.Write(" ");
Linearise(cce.NonNull((VCExpr)enumerator.Current), options);
}
}
wr.Write(")");
return(true);
}
return(node.Accept <bool, LineariserOptions>(OpLineariser, options));
}
public Term Visit(VCExprNAry node, LineariserOptions options)
{
Contract.Requires(options != null);
Contract.Requires(node != null);
VCExprOp op = node.Op;
Contract.Assert(op != null);
if (op.Equals(VCExpressionGenerator.AndOp) || op.Equals(VCExpressionGenerator.OrOp))
{
// handle these operators without recursion
List <Term> asts = new List <Term>();
string opString = op.Equals(VCExpressionGenerator.AndOp) ? "AND" : "OR";
IEnumerator enumerator = new VCExprNAryUniformOpEnumerator(node);
Contract.Assert(enumerator != null);
while (enumerator.MoveNext())
{
VCExprNAry naryExpr = enumerator.Current as VCExprNAry;
if (naryExpr == null || !naryExpr.Op.Equals(op))
{
asts.Add(Linearise(cce.NonNull((VCExpr)enumerator.Current), options));
}
}
return(Make(op, asts));
}
return(node.Accept <Term, LineariserOptions>(OpLineariser, options));
}
public VCExpr /*!*/ Function(VCExprOp /*!*/ op,
List <VCExpr /*!*/> /*!*/ arguments,
List <Type /*!*/> /*!*/ typeArguments)
{
Contract.Requires(op != null);
Contract.Requires(cce.NonNullElements(arguments));
Contract.Requires(cce.NonNullElements(typeArguments));
if (typeArguments.Count > 0)
{
return(new VCExprMultiAry(op, arguments, typeArguments));
}
switch (arguments.Count)
{
case 0:
return(new VCExprNullary(op));
case 1:
return(new VCExprUnary(op, arguments));
case 2:
return(new VCExprBinary(op, arguments));
default:
return(new VCExprMultiAry(op, arguments));
}
}
public bool Visit(VCExprNAry node, TextWriter wr)
{
//Contract.Requires(wr != null);
//Contract.Requires(node != null);
VCExprOp /*!*/ op = node.Op;
Contract.Assert(op != null);
if (op.Equals(VCExpressionGenerator.AndOp) ||
op.Equals(VCExpressionGenerator.OrOp))
{
// handle these operators without recursion
wr.Write("({0}",
op.Equals(VCExpressionGenerator.AndOp) ? "And" : "Or");
IEnumerator /*!*/ enumerator = new VCExprNAryUniformOpEnumerator(node);
Contract.Assert(enumerator != null);
while (enumerator.MoveNext())
{
VCExprNAry naryExpr = enumerator.Current as VCExprNAry;
if (naryExpr == null || !naryExpr.Op.Equals(op))
{
wr.Write(" ");
Print(cce.NonNull((VCExpr /*!*/)enumerator.Current), wr);
}
}
wr.Write(")");
return(true);
}
return(node.Accept <bool, TextWriter /*!*/>(OpPrinter, wr));
}
/////////////////////////////////////////////////////////////////////////////////////
public bool Visit(VCExprNAry node, LineariserOptions options)
{
//Contract.Requires(node != null);
//Contract.Requires(options != null);
VCExprOp op = node.Op;
Contract.Assert(op != null);
if (op.Equals(VCExpressionGenerator.AndOp) ||
op.Equals(VCExpressionGenerator.OrOp))
{
// handle these operators without recursion
wr.Write("({0}",
op.Equals(VCExpressionGenerator.AndOp) ? "and" : "or");
foreach (var ch in node.UniformArguments)
{
wr.Write("\n");
Linearise(ch, options);
}
wr.Write(")");
return(true);
}
return(node.Accept <bool, LineariserOptions /*!*/>(OpLineariser, options));
}
///////////////////////////////////////////////////////////////////////////
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 OpTypesPair(VCExprOp op, List <Type /*!*/> /*!*/ types)
{
Contract.Requires(op != null);
Contract.Requires(cce.NonNullElements(types));
this.Op = op;
this.Types = types;
this.HashCode = HFNS.PolyHash(op.GetHashCode(), 17, types);
}
public VCExpr /*!*/ Function(VCExprOp /*!*/ op, List <VCExpr /*!*/> /*!*/ arguments)
{
Contract.Requires(op != null);
Contract.Requires(cce.NonNullElements(arguments));
Contract.Ensures(Contract.Result <VCExpr>() != null);
return(Function(op, arguments, VCExprNAry.EMPTY_TYPE_LIST));
}
// The following method should really be called "ReduceLeft". It must
// only be used for the binary operators "and" and "or"
public VCExpr /*!*/ NAry(VCExprOp /*!*/ op, List <VCExpr /*!*/> /*!*/ args)
{
Contract.Requires(op != null);
Contract.Requires(cce.NonNullElements(args));
Contract.Ensures(Contract.Result <VCExpr>() != null);
return(NAry(op, args.ToArray()));
}
/////////////////////////////////////////////////////////////////////////////////////
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);
}
return(node.Accept <bool, LineariserOptions /*!*/>(OpLineariser, options));
}
public VCExpr /*!*/ Function(VCExprOp /*!*/ op, params VCExpr[] /*!*/ arguments)
{
Contract.Requires(op != null);
Contract.Requires(cce.NonNullElements(arguments));
return(Function(op,
HelperFuns.ToNonNullList(arguments),
VCExprNAry.EMPTY_TYPE_LIST));
}
public TermClustersSameHead(VCExprOp op, IDictionary <VCExprVar /*!*/, VCExprVar /*!*/> /*!*/ globalVars, VCExpressionGenerator /*!*/ gen)
{
Contract.Requires(cce.NonNullDictionaryAndValues(globalVars));
Contract.Requires(gen != null);
Contract.Requires(op != null);
Op = op;
GlobalVariables = globalVars;
Gen = gen;
}
public VCExpr /*!*/ Add(VCExpr /*!*/ e0, VCExpr /*!*/ e1)
{
Contract.Requires(e0 != null);
Contract.Requires(e1 != null);
Contract.Ensures(Contract.Result <VCExpr>() != null);
VCExprOp op = cce.NonNull(cce.NonNull(e0).Type).IsInt ? AddIOp : AddROp;
return(Function(op, e0, e1));
}
public VCExpr /*!*/ Function(VCExprOp /*!*/ op, VCExpr[] /*!*/ arguments, Type[] /*!*/ typeArguments)
{
Contract.Requires(op != null);
Contract.Requires(cce.NonNullElements(arguments));
Contract.Requires(cce.NonNullElements(typeArguments));
Contract.Ensures(Contract.Result <VCExpr>() != null);
return(Function(op,
HelperFuns.ToNonNullList(arguments),
HelperFuns.ToNonNullList(typeArguments)));
}
///////////////////////////////////////////////////////////////////////////////////
private Term WriteApplication(VCExprOp op, IEnumerable <VCExpr> terms, LineariserOptions options)
{
Contract.Requires(options != null);
Contract.Requires(op != null);
Contract.Requires(cce.NonNullElements(terms));
List <Term> args = new List <Term>();
foreach (VCExpr e in terms)
{
Contract.Assert(e != null);
args.Add(ExprLineariser.Linearise(e, options));
}
return(ExprLineariser.Make(op, args));
}
public VCExpr /*!*/ NAry(VCExprOp /*!*/ op, params VCExpr[] /*!*/ args)
{
Contract.Requires(op != null);
Contract.Requires(cce.NonNullElements(args));
Contract.Requires(op == AndOp || op == OrOp);
Contract.Ensures(Contract.Result <VCExpr>() != null);
bool and = (op == AndOp);
VCExpr /*!*/
e = and ? True : False;
foreach (VCExpr a in args)
{
e = and ? AndSimp(e, cce.NonNull(a)) : OrSimp(e, cce.NonNull(a));
}
return(e);
}
/////////////////////////////////////////////////////////////////////////////////////
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));
}
private BinaryOperator.Opcode VCOpToOp (VCExprOp op)
{
if (op == VCExpressionGenerator.AddIOp)
return BinaryOperator.Opcode.Add;
if (op == VCExpressionGenerator.SubIOp)
return BinaryOperator.Opcode.Sub;
if (op == VCExpressionGenerator.MulIOp)
return BinaryOperator.Opcode.Mul;
if (op == VCExpressionGenerator.DivIOp)
return BinaryOperator.Opcode.Div;
if (op == VCExpressionGenerator.EqOp)
return BinaryOperator.Opcode.Eq;
if (op == VCExpressionGenerator.LeOp)
return BinaryOperator.Opcode.Le;
if (op == VCExpressionGenerator.LtOp)
return BinaryOperator.Opcode.Lt;
if (op == VCExpressionGenerator.GeOp)
return BinaryOperator.Opcode.Ge;
if (op == VCExpressionGenerator.GtOp)
return BinaryOperator.Opcode.Gt;
if (op == VCExpressionGenerator.AndOp)
return BinaryOperator.Opcode.And;
if (op == VCExpressionGenerator.OrOp)
return BinaryOperator.Opcode.Or;
throw new InternalError();
}
/////////////////////////////////////////////////////////////////////////////////////
public Term Make(VCExprOp op, List <Term> children)
{
Context z3 = cm.z3;
Term[] unwrapChildren = children.ToArray();
VCExprBoogieFunctionOp boogieFunctionOp = op as VCExprBoogieFunctionOp;
if (boogieFunctionOp != null)
{
FuncDecl f = cm.GetFunction(boogieFunctionOp.Func.Name);
return(z3.MkApp(f, unwrapChildren));
}
VCExprDistinctOp distinctOp = op as VCExprDistinctOp;
if (distinctOp != null)
{
return(z3.MkDistinct(unwrapChildren));
}
if (op == VCExpressionGenerator.AndOp)
{
return(z3.MkAnd(unwrapChildren));
}
if (op == VCExpressionGenerator.OrOp)
{
return(z3.MkOr(unwrapChildren));
}
if (op == VCExpressionGenerator.ImpliesOp)
{
return(z3.MkImplies(unwrapChildren[0], unwrapChildren[1]));
}
if (op == VCExpressionGenerator.NotOp)
{
return(z3.MkNot(unwrapChildren[0]));
}
if (op == VCExpressionGenerator.EqOp)
{
return(z3.MkEq(unwrapChildren[0], unwrapChildren[1]));
}
if (op == VCExpressionGenerator.NeqOp)
{
return(z3.MkNot(z3.MkEq(unwrapChildren[0], unwrapChildren[1])));
}
if (op == VCExpressionGenerator.LtOp)
{
return(z3.MkLt(unwrapChildren[0], unwrapChildren[1]));
}
if (op == VCExpressionGenerator.LeOp)
{
return(z3.MkLe(unwrapChildren[0], unwrapChildren[1]));
}
if (op == VCExpressionGenerator.GtOp)
{
return(z3.MkGt(unwrapChildren[0], unwrapChildren[1]));
}
if (op == VCExpressionGenerator.GeOp)
{
return(z3.MkGe(unwrapChildren[0], unwrapChildren[1]));
}
if (op == VCExpressionGenerator.AddOp)
{
return(z3.MkAdd(unwrapChildren));
}
if (op == VCExpressionGenerator.SubOp)
{
return(z3.MkSub(unwrapChildren));
}
if (op == VCExpressionGenerator.DivOp || op == VCExpressionGenerator.RealDivOp)
{
return(z3.MkDiv(unwrapChildren[0], unwrapChildren[1]));
}
if (op == VCExpressionGenerator.MulOp)
{
return(z3.MkMul(unwrapChildren));
}
if (op == VCExpressionGenerator.ModOp)
{
return(z3.MkMod(unwrapChildren[0], unwrapChildren[1]));
}
if (op == VCExpressionGenerator.IfThenElseOp)
{
return(z3.MkIte(unwrapChildren[0], unwrapChildren[1], unwrapChildren[2]));
}
if (op == VCExpressionGenerator.ToIntOp)
{
return(z3.MkToInt(unwrapChildren[0]));
}
if (op == VCExpressionGenerator.ToRealOp)
{
return(z3.MkToReal(unwrapChildren[0]));
}
throw new Exception("unhandled boogie operator");
}
public OpTypesPair(VCExprOp op, List<Type/*!*/>/*!*/ types) {
Contract.Requires(op != null);
Contract.Requires(cce.NonNullElements(types));
this.Op = op;
this.Types = types;
this.HashCode = HFNS.PolyHash(op.GetHashCode(), 17, types);
}
private VCExpr MakeBinary(VCExprOp op, VCExpr [] args)
{
if (args.Count() == 0)
{
// with zero args we need the identity of the op
if (op == VCExpressionGenerator.AndOp)
return VCExpressionGenerator.True;
if (op == VCExpressionGenerator.OrOp)
return VCExpressionGenerator.False;
if (op == VCExpressionGenerator.AddIOp)
{
Microsoft.Basetypes.BigNum x = Microsoft.Basetypes.BigNum.ZERO;
return gen.Integer(x);
}
HandleProverError("Prover error: bad expression ");
throw new BadExprFromProver();
}
var temp = args[0];
for (int i = 1; i < args.Count(); i++)
temp = gen.Function(op, temp, args[i]);
return temp;
}
