public static VCExpr P_Block(Block b, HashSet <string> constantsAssumed, VCExpr N, VCContext ctxt)
//modifies ctxt.*;
{
Contract.Requires(b != null);
Contract.Requires(N != null);
Contract.Requires(ctxt != null);
Contract.Ensures(Contract.Result <VCExpr>() != null);
VCExpressionGenerator gen = ctxt.Ctxt.ExprGen;
Contract.Assert(gen != null);
VCExpr res = N;
for (int i = b.Cmds.Count; --i >= 0;)
{
res = P_Cmd(b, constantsAssumed, cce.NonNull(b.Cmds[i]), res, ctxt);
}
int id = b.UniqueId;
if (ctxt.Label2absy != null)
{
ctxt.Label2absy[id] = b;
}
try
{
cce.BeginExpose(ctxt);
if (ctxt.Label2absy == null)
{
return(res);
}
else
{
return(gen.Implies(gen.LabelPos(cce.NonNull(id.ToString()), VCExpressionGenerator.True), res));
}
}
finally
{
cce.EndExpose();
}
}
/// <summary>
/// Computes the wlp for an assert or assume command "cmd".
/// </summary>
internal static VCExpr Cmd(Block b, Cmd cmd, VCExpr N, VCContext ctxt)
{
Contract.Requires(cmd != null);
Contract.Requires(N != null);
Contract.Requires(ctxt != null);
Contract.Ensures(Contract.Result <VCExpr>() != null);
VCExpressionGenerator gen = ctxt.Ctxt.ExprGen;
Contract.Assert(gen != null);
if (cmd is AssertCmd)
{
AssertCmd ac = (AssertCmd)cmd;
var isFullyVerified = false;
if (ac.VerifiedUnder != null)
{
var litExpr = ac.VerifiedUnder as LiteralExpr;
isFullyVerified = litExpr != null && litExpr.IsTrue;
}
if (!isFullyVerified)
{
ctxt.Ctxt.BoogieExprTranslator.isPositiveContext = !ctxt.Ctxt.BoogieExprTranslator.isPositiveContext;
}
VCExpr C = ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr);
VCExpr VU = null;
if (!isFullyVerified)
{
if (ac.VerifiedUnder != null)
{
VU = ctxt.Ctxt.BoogieExprTranslator.Translate(ac.VerifiedUnder);
if (CommandLineOptions.Clo.RunDiagnosticsOnTimeout)
{
ctxt.Ctxt.TimeoutDiagnosticIDToAssertion[ctxt.Ctxt.TimeoutDiagnosticsCount] =
new Tuple <AssertCmd, TransferCmd>(ac, b.TransferCmd);
VU = gen.Or(VU,
gen.Function(VCExpressionGenerator.TimeoutDiagnosticsOp,
gen.Integer(BigNum.FromInt(ctxt.Ctxt.TimeoutDiagnosticsCount++))));
}
}
else if (CommandLineOptions.Clo.RunDiagnosticsOnTimeout)
{
ctxt.Ctxt.TimeoutDiagnosticIDToAssertion[ctxt.Ctxt.TimeoutDiagnosticsCount] =
new Tuple <AssertCmd, TransferCmd>(ac, b.TransferCmd);
VU = gen.Function(VCExpressionGenerator.TimeoutDiagnosticsOp,
gen.Integer(BigNum.FromInt(ctxt.Ctxt.TimeoutDiagnosticsCount++)));
}
ctxt.Ctxt.BoogieExprTranslator.isPositiveContext = !ctxt.Ctxt.BoogieExprTranslator.isPositiveContext;
}
{
var subsumption = Subsumption(ac);
if (subsumption == CommandLineOptions.SubsumptionOption.Always ||
(subsumption == CommandLineOptions.SubsumptionOption.NotForQuantifiers && !(C is VCExprQuantifier)))
{
N = gen.ImpliesSimp(C, N, false);
}
if (isFullyVerified)
{
return(N);
}
else if (VU != null)
{
C = gen.OrSimp(VU, C);
}
int id = ac.UniqueId;
if (ctxt.Label2absy != null)
{
ctxt.Label2absy[id] = ac;
}
ctxt.AssertionCount++;
if (ctxt.ControlFlowVariableExpr == null)
{
Contract.Assert(ctxt.Label2absy != null);
return(gen.AndSimp(C, N));
}
else
{
VCExpr controlFlowFunctionAppl = gen.ControlFlowFunctionApplication(ctxt.ControlFlowVariableExpr,
gen.Integer(BigNum.FromInt(b.UniqueId)));
Contract.Assert(controlFlowFunctionAppl != null);
VCExpr assertFailure = gen.Eq(controlFlowFunctionAppl, gen.Integer(BigNum.FromInt(-ac.UniqueId)));
return(gen.AndSimp(gen.Implies(assertFailure, C), N));
}
}
}
else if (cmd is AssumeCmd)
{
AssumeCmd ac = (AssumeCmd)cmd;
if (CommandLineOptions.Clo.StratifiedInlining > 0)
{
// Label the assume if it is a procedure call
NAryExpr naryExpr = ac.Expr as NAryExpr;
if (naryExpr != null)
{
if (naryExpr.Fun is FunctionCall)
{
int id = ac.UniqueId;
ctxt.Label2absy[id] = ac;
return(MaybeWrapWithOptimization(ctxt, gen, ac.Attributes,
gen.ImpliesSimp(ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr), N)));
}
}
}
var expr = ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr);
var aid = QKeyValue.FindStringAttribute(ac.Attributes, "id");
if (aid != null)
{
var isTry = QKeyValue.FindBoolAttribute(ac.Attributes, "try");
var v = gen.Variable((isTry ? "try$$" : "assume$$") + aid, Microsoft.Boogie.Type.Bool);
expr = gen.Function(VCExpressionGenerator.NamedAssumeOp, v, gen.ImpliesSimp(v, expr));
}
var soft = QKeyValue.FindBoolAttribute(ac.Attributes, "soft");
var softWeight = QKeyValue.FindIntAttribute(ac.Attributes, "soft", 0);
if ((soft || 0 < softWeight) && aid != null)
{
var v = gen.Variable("soft$$" + aid, Microsoft.Boogie.Type.Bool);
expr = gen.Function(new VCExprSoftOp(Math.Max(softWeight, 1)), v, gen.ImpliesSimp(v, expr));
}
return(MaybeWrapWithOptimization(ctxt, gen, ac.Attributes, gen.ImpliesSimp(expr, N)));
}
else
{
Console.WriteLine(cmd.ToString());
Contract.Assert(false);
throw new cce.UnreachableException(); // unexpected command
}
}
/// <summary>
/// Computes the wlp for an assert or assume command "cmd".
/// </summary>
public static VCExpr Cmd(Block b, Cmd cmd, VCExpr N, VCContext ctxt)
{
Contract.Requires(cmd != null);
Contract.Requires(N != null);
Contract.Requires(ctxt != null);
Contract.Ensures(Contract.Result <VCExpr>() != null);
VCExpressionGenerator gen = ctxt.Ctxt.ExprGen;
Contract.Assert(gen != null);
if (cmd is AssertCmd)
{
AssertCmd ac = (AssertCmd)cmd;
var isFullyVerified = false;
if (ac.VerifiedUnder != null)
{
var litExpr = ac.VerifiedUnder as LiteralExpr;
isFullyVerified = litExpr != null && litExpr.IsTrue;
}
if (!isFullyVerified)
{
ctxt.Ctxt.BoogieExprTranslator.isPositiveContext = !ctxt.Ctxt.BoogieExprTranslator.isPositiveContext;
}
VCExpr C = ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr);
VCExpr VU = null;
if (!isFullyVerified)
{
if (ac.VerifiedUnder != null)
{
VU = ctxt.Ctxt.BoogieExprTranslator.Translate(ac.VerifiedUnder);
}
ctxt.Ctxt.BoogieExprTranslator.isPositiveContext = !ctxt.Ctxt.BoogieExprTranslator.isPositiveContext;
}
VCExpr R = null;
if (CommandLineOptions.Clo.vcVariety == CommandLineOptions.VCVariety.Doomed)
{
R = gen.Implies(C, N);
}
else
{
var subsumption = Subsumption(ac);
if (subsumption == CommandLineOptions.SubsumptionOption.Always ||
(subsumption == CommandLineOptions.SubsumptionOption.NotForQuantifiers && !(C is VCExprQuantifier)))
{
N = gen.ImpliesSimp(C, N, false);
}
if (isFullyVerified)
{
return(N);
}
else if (VU != null)
{
C = gen.OrSimp(VU, C);
}
int id = ac.UniqueId;
if (ctxt.Label2absy != null)
{
ctxt.Label2absy[id] = ac;
}
ctxt.AssertionCount++;
if (ctxt.ControlFlowVariableExpr == null)
{
Contract.Assert(ctxt.Label2absy != null);
R = gen.AndSimp(gen.LabelNeg(cce.NonNull(id.ToString()), C), N);
}
else
{
VCExpr controlFlowFunctionAppl = gen.ControlFlowFunctionApplication(ctxt.ControlFlowVariableExpr, gen.Integer(BigNum.FromInt(b.UniqueId)));
Contract.Assert(controlFlowFunctionAppl != null);
VCExpr assertFailure = gen.Eq(controlFlowFunctionAppl, gen.Integer(BigNum.FromInt(-ac.UniqueId)));
if (ctxt.Label2absy == null)
{
R = gen.AndSimp(gen.Implies(assertFailure, C), N);
}
else
{
R = gen.AndSimp(gen.LabelNeg(cce.NonNull(id.ToString()), gen.Implies(assertFailure, C)), N);
}
}
}
return(R);
}
else if (cmd is AssumeCmd)
{
AssumeCmd ac = (AssumeCmd)cmd;
if (CommandLineOptions.Clo.StratifiedInlining > 0)
{
// Label the assume if it is a procedure call
NAryExpr naryExpr = ac.Expr as NAryExpr;
if (naryExpr != null)
{
if (naryExpr.Fun is FunctionCall)
{
int id = ac.UniqueId;
ctxt.Label2absy[id] = ac;
return(gen.ImpliesSimp(gen.LabelPos(cce.NonNull("si_fcall_" + id.ToString()), ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr)), N));
}
}
}
return(gen.ImpliesSimp(ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr), N));
}
else
{
Console.WriteLine(cmd.ToString());
Contract.Assert(false); throw new cce.UnreachableException(); // unexpected command
}
}
private VCExpr Execute(Implementation impl, VCExpr vcExpr)
{
impl.Blocks.ForEach(block => block.Cmds.OfType <PredicateCmd>().Iter(predicateCmd =>
{
AddDictionary(FindInstantiationSources(predicateCmd, "add_to_pool", exprTranslator), labelToInstances);
}));
vcExpr = Skolemizer.Skolemize(this, Polarity.Negative, vcExpr);
lambdaToInstances = LambdaInstanceCollector.CollectInstances(this, vcExpr);
while (labelToInstances.Count > 0)
{
var currLabelToInstances = labelToInstances;
labelToInstances = new Dictionary <string, HashSet <VCExpr> >();
AddDictionary(currLabelToInstances, accLabelToInstances);
var currLambdaToInstances = lambdaToInstances;
lambdaToInstances = new Dictionary <Function, HashSet <List <VCExpr> > >();
AddDictionary(currLambdaToInstances, accLambdaToInstances);
var visitedQuantifierBindings = new HashSet <VCExprVar>();
while (visitedQuantifierBindings.Count < quantifierBinding.Count)
{
foreach (var v in quantifierBinding.Keys)
{
if (visitedQuantifierBindings.Contains(v))
{
continue;
}
visitedQuantifierBindings.Add(v);
var quantifierExpr = quantifierBinding[v];
var quantifierInfo = quantifierInstantiationInfo[quantifierExpr];
if (quantifierInfo.relevantLabels.Overlaps(currLabelToInstances.Keys))
{
InstantiateQuantifier(quantifierExpr);
}
}
}
var visitedLambdaFunctions = new HashSet <Function>();
while (visitedLambdaFunctions.Count < lambdaDefinition.Count)
{
foreach (var lambdaFunction in lambdaDefinition.Keys)
{
if (visitedLambdaFunctions.Contains(lambdaFunction))
{
continue;
}
visitedLambdaFunctions.Add(lambdaFunction);
var quantifierExpr = lambdaDefinition[lambdaFunction];
var quantifierInfo = quantifierInstantiationInfo[quantifierExpr];
if (quantifierInfo.relevantLabels.Overlaps(currLabelToInstances.Keys) ||
currLambdaToInstances[lambdaFunction].Count > 0)
{
InstantiateLambdaDefinition(lambdaFunction);
}
}
}
}
var lambdaAxioms = vcExprGen.NAry(VCExpressionGenerator.AndOp, lambdaDefinition.Values
.SelectMany(quantifierExpr =>
quantifierInstantiationInfo[quantifierExpr].instances.Values.ToList()).ToList());
return(vcExprGen.Implies(lambdaAxioms, LetConvert(vcExpr)));
}
/// <summary>
/// Computes the wlp for an assert or assume command "cmd".
/// </summary>
public static VCExpr P_Cmd(Block b, HashSet <string> constantsAssumed, Cmd cmd, VCExpr N, VCContext ctxt)
{
Contract.Requires(cmd != null);
Contract.Requires(N != null);
Contract.Requires(ctxt != null);
Contract.Ensures(Contract.Result <VCExpr>() != null);
VCExpressionGenerator gen = ctxt.Ctxt.ExprGen;
Contract.Assert(gen != null);
if (cmd is AssertCmd)
{
AssertCmd ac = (AssertCmd)cmd;
ctxt.Ctxt.BoogieExprTranslator.isPositiveContext = !ctxt.Ctxt.BoogieExprTranslator.isPositiveContext;
VCExpr C = ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr);
ctxt.Ctxt.BoogieExprTranslator.isPositiveContext = !ctxt.Ctxt.BoogieExprTranslator.isPositiveContext;
if (CommandLineOptions.Clo.vcVariety == CommandLineOptions.VCVariety.Doomed)
{
return(gen.Implies(C, N));
}
else
{
int id = ac.UniqueId;
if (ctxt.Label2absy != null)
{
ctxt.Label2absy[id] = ac;
}
switch (Subsumption(ac))
{
case CommandLineOptions.SubsumptionOption.Never:
break;
case CommandLineOptions.SubsumptionOption.Always:
N = gen.Implies(C, N);
break;
case CommandLineOptions.SubsumptionOption.NotForQuantifiers:
if (!(C is VCExprQuantifier))
{
N = gen.Implies(C, N);
}
break;
default:
Contract.Assert(false); throw new cce.UnreachableException(); // unexpected case
}
// (MSchaef) Hack: This line might be useless, but at least it is not harmful
// need to test it
if (CommandLineOptions.Clo.vcVariety == CommandLineOptions.VCVariety.Doomed)
{
return(gen.Implies(C, N));
}
ctxt.AssertionCount++;
if (ctxt.ControlFlowVariableExpr == null)
{
Contract.Assert(ctxt.Label2absy != null);
return(gen.AndSimp(gen.LabelNeg(cce.NonNull(id.ToString()), C), N));
}
else
{
VCExpr controlFlowFunctionAppl = gen.ControlFlowFunctionApplication(ctxt.ControlFlowVariableExpr, gen.Integer(BigNum.FromInt(b.UniqueId)));
Contract.Assert(controlFlowFunctionAppl != null);
VCExpr assertFailure = gen.Eq(controlFlowFunctionAppl, gen.Integer(BigNum.FromInt(-ac.UniqueId)));
if (ctxt.Label2absy == null)
{
return(gen.AndSimp(gen.Implies(assertFailure, C), N));
}
else
{
return(gen.AndSimp(gen.LabelNeg(cce.NonNull(id.ToString()), gen.Implies(assertFailure, C)), N));
}
}
}
}
else if (cmd is AssumeCmd)
{
AssumeCmd ac = (AssumeCmd)cmd;
if (CommandLineOptions.Clo.StratifiedInlining > 0)
{
Contract.Assert(false);
throw new System.Exception(string.Format("VC Generation in ICE-learning does not handle stratified inlining"));
var pname = QKeyValue.FindStringAttribute(ac.Attributes, "candidate");
if (pname != null)
{
return(gen.ImpliesSimp(gen.LabelPos("candidate_" + pname.ToString(), ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr)), N));
}
// Label the assume if it is a procedure call
NAryExpr naryExpr = ac.Expr as NAryExpr;
if (naryExpr != null)
{
if (naryExpr.Fun is FunctionCall)
{
int id = ac.UniqueId;
ctxt.Label2absy[id] = ac;
return(gen.ImpliesSimp(gen.LabelPos(cce.NonNull("si_fcall_" + id.ToString()), ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr)), N));
}
}
}
//return gen.ImpliesSimp(ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr), N);
else
{
if (constantsAssumed == null)
{
return(gen.ImpliesSimp(ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr), N));
}
// check if the assume command contains any of the constantsAssumed (corresponding to existential function calls)?
var funcsUsed = FunctionCollector.Collect(ac.Expr);
bool hasAnyConstantAssumed = false;
foreach (var tup in funcsUsed)
{
var constantFunc = tup.Item1;
if (constantsAssumed.Contains(constantFunc.Name))
{
hasAnyConstantAssumed = true;
break;
}
}
if (hasAnyConstantAssumed)
{
int id = ac.UniqueId;
if (ctxt.Label2absy != null)
{
ctxt.Label2absy[id] = ac;
}
//ctxt.AssertionCount++;
if (ctxt.ControlFlowVariableExpr == null)
{
Contract.Assert(ctxt.Label2absy != null);
return(gen.ImpliesSimp(gen.LabelPos(cce.NonNull(id.ToString()), ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr)), N));
}
else
{
return(gen.ImpliesSimp(ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr), N));
/*VCExpr controlFlowFunctionAppl = gen.ControlFlowFunctionApplication(ctxt.ControlFlowVariableExpr, gen.Integer(BigNum.FromInt(b.UniqueId)));
* Contract.Assert(controlFlowFunctionAppl != null);
* VCExpr assumeFailure = gen.Eq(controlFlowFunctionAppl, gen.Integer(BigNum.FromInt(-ac.UniqueId)));
* if (ctxt.Label2absy == null)
* {
* throw new System.Exception(string.Format("Dont know how to handle labels for the assume cmd"));
* //return gen.ImpliesSimp(gen.LabelPos(cce.NonNull(id.ToString()), gen.Implies(assumeFailure, ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr))), N);
* }
* else
* {
* return gen.ImpliesSimp(gen.LabelPos(cce.NonNull(id.ToString()), gen.Implies(assumeFailure, ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr))), N);
* }
*/
}
}
else
{
return(gen.ImpliesSimp(ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr), N));
}
}
}
else
{
Console.WriteLine(cmd.ToString());
Contract.Assert(false); throw new cce.UnreachableException(); // unexpected command
}
}
/// <summary>
/// Computes the wlp for an assert or assume command "cmd".
/// </summary>
public static VCExpr Cmd(Block b, Cmd cmd, VCExpr N, VCContext ctxt)
{
Contract.Requires(cmd != null);
Contract.Requires(N != null);
Contract.Requires(ctxt != null);
Contract.Ensures(Contract.Result <VCExpr>() != null);
VCExpressionGenerator gen = ctxt.Ctxt.ExprGen;
Contract.Assert(gen != null);
if (cmd is AssertCmd)
{
AssertCmd ac = (AssertCmd)cmd;
ctxt.Ctxt.BoogieExprTranslator.isPositiveContext = !ctxt.Ctxt.BoogieExprTranslator.isPositiveContext;
VCExpr C = ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr);
ctxt.Ctxt.BoogieExprTranslator.isPositiveContext = !ctxt.Ctxt.BoogieExprTranslator.isPositiveContext;
if (CommandLineOptions.Clo.vcVariety == CommandLineOptions.VCVariety.Doomed)
{
return(gen.Implies(C, N));
}
else
{
int id = ac.UniqueId;
if (ctxt.Label2absy != null)
{
ctxt.Label2absy[id] = ac;
}
switch (Subsumption(ac))
{
case CommandLineOptions.SubsumptionOption.Never:
break;
case CommandLineOptions.SubsumptionOption.Always:
N = gen.Implies(C, N);
break;
case CommandLineOptions.SubsumptionOption.NotForQuantifiers:
if (!(C is VCExprQuantifier))
{
N = gen.Implies(C, N);
}
break;
default:
Contract.Assert(false); throw new cce.UnreachableException(); // unexpected case
}
// (MSchaef) Hack: This line might be useless, but at least it is not harmful
// need to test it
if (CommandLineOptions.Clo.vcVariety == CommandLineOptions.VCVariety.Doomed)
{
return(gen.Implies(C, N));
}
ctxt.AssertionCount++;
if (ctxt.ControlFlowVariableExpr == null)
{
Contract.Assert(ctxt.Label2absy != null);
return(gen.AndSimp(gen.LabelNeg(cce.NonNull(id.ToString()), C), N));
}
else
{
VCExpr controlFlowFunctionAppl = gen.ControlFlowFunctionApplication(ctxt.ControlFlowVariableExpr, gen.Integer(BigNum.FromInt(b.UniqueId)));
Contract.Assert(controlFlowFunctionAppl != null);
VCExpr assertFailure = gen.Eq(controlFlowFunctionAppl, gen.Integer(BigNum.FromInt(-ac.UniqueId)));
if (ctxt.Label2absy == null)
{
return(gen.AndSimp(gen.Implies(assertFailure, C), N));
}
else
{
return(gen.AndSimp(gen.LabelNeg(cce.NonNull(id.ToString()), gen.Implies(assertFailure, C)), N));
}
}
}
}
else if (cmd is AssumeCmd)
{
AssumeCmd ac = (AssumeCmd)cmd;
if (CommandLineOptions.Clo.StratifiedInlining > 0)
{
var pname = QKeyValue.FindStringAttribute(ac.Attributes, "candidate");
if (pname != null)
{
return(gen.ImpliesSimp(gen.LabelPos("candidate_" + pname.ToString(), ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr)), N));
}
// Label the assume if it is a procedure call
NAryExpr naryExpr = ac.Expr as NAryExpr;
if (naryExpr != null)
{
if (naryExpr.Fun is FunctionCall)
{
int id = ac.UniqueId;
ctxt.Label2absy[id] = ac;
return(gen.ImpliesSimp(gen.LabelPos(cce.NonNull("si_fcall_" + id.ToString()), ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr)), N));
}
}
}
return(gen.ImpliesSimp(ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr), N));
}
else
{
Console.WriteLine(cmd.ToString());
Contract.Assert(false); throw new cce.UnreachableException(); // unexpected command
}
}
public VCExpr get(Term arg)
{
if (memo.ContainsKey(arg))
{
return(memo[arg]);
}
VCExpr res = null;
switch (arg.GetKind())
{
case TermKind.Numeral:
var numstr = arg.GetNumeralString();
if (arg.GetSort().GetSortKind() == SortKind.Int)
{
res = gen.Integer(Basetypes.BigNum.FromString(numstr));
}
else
{
res = gen.Real(Basetypes.BigDec.FromString(numstr));
}
break;
case TermKind.App:
var args = arg.GetAppArgs();
var vcargs = new VCExpr[args.Length];
for (int i = 0; i < args.Length; i++)
{
vcargs[i] = get(args[i]);
}
switch (arg.GetAppDecl().GetKind())
{
case DeclKind.Add:
if (vcargs.Length == 0)
{
if (arg.GetSort().GetSortKind() == SortKind.Int)
{
res = gen.Integer(Basetypes.BigNum.ZERO);
}
else
{
res = gen.Real(Basetypes.BigDec.ZERO);
}
}
else
{
res = vcargs[0];
for (int k = 1; k < vcargs.Length; k++)
{
res = gen.Add(res, vcargs[k]);
}
}
break;
case DeclKind.And:
res = VCExpressionGenerator.True;
for (int i = 0; i < vcargs.Length; i++)
{
res = gen.AndSimp(res, vcargs[i]);
}
break;
case DeclKind.Div:
Debug.Assert(vcargs.Length == 2);
res = gen.Function(VCExpressionGenerator.RealDivOp, vcargs[0], vcargs[1]);
break;
case DeclKind.Eq:
Debug.Assert(vcargs.Length == 2);
res = gen.Eq(vcargs[0], vcargs[1]);
break;
case DeclKind.False:
res = VCExpressionGenerator.False;
break;
case DeclKind.Ge:
Debug.Assert(vcargs.Length == 2);
res = gen.Function(VCExpressionGenerator.GeOp, vcargs[0], vcargs[1]);
break;
case DeclKind.Gt:
Debug.Assert(vcargs.Length == 2);
res = gen.Gt(vcargs[0], vcargs[1]);
break;
case DeclKind.IDiv:
Debug.Assert(vcargs.Length == 2);
res = gen.Function(VCExpressionGenerator.DivOp, vcargs[0], vcargs[1]);
break;
case DeclKind.Iff:
Debug.Assert(vcargs.Length == 2);
var l = create_let(args[0], vcargs[0]);
var r = create_let(args[1], vcargs[1]);
return(gen.And(gen.Implies(l, r), gen.Implies(r, l)));
case DeclKind.Implies:
Debug.Assert(vcargs.Length == 2);
res = gen.Implies(vcargs[0], vcargs[1]);
break;
case DeclKind.Ite:
Debug.Assert(vcargs.Length == 3);
res = gen.Function(VCExpressionGenerator.IfThenElseOp, vcargs[0], vcargs[1], vcargs[2]);
break;
case DeclKind.Le:
Debug.Assert(vcargs.Length == 2);
res = gen.Function(VCExpressionGenerator.LeOp, vcargs[0], vcargs[1]);
break;
case DeclKind.Lt:
Debug.Assert(vcargs.Length == 2);
res = gen.Function(VCExpressionGenerator.LtOp, vcargs[0], vcargs[1]);
break;
case DeclKind.Mod:
Debug.Assert(vcargs.Length == 2);
res = gen.Function(VCExpressionGenerator.ModOp, vcargs[0], vcargs[1]);
break;
case DeclKind.Mul:
Debug.Assert(vcargs.Length == 2);
res = gen.Function(VCExpressionGenerator.MulOp, vcargs[0], vcargs[1]);
break;
case DeclKind.Not:
Debug.Assert(vcargs.Length == 1);
res = gen.Not(vcargs[0]);
break;
case DeclKind.Or:
res = VCExpressionGenerator.False;
for (int i = 0; i < vcargs.Length; i++)
{
res = gen.OrSimp(res, vcargs[i]);
}
break;
case DeclKind.Select:
Debug.Assert(vcargs.Length == 2);
res = gen.Select(vcargs[0], vcargs[1]);
break;
case DeclKind.Store:
Debug.Assert(vcargs.Length == 3);
res = gen.Store(vcargs[0], vcargs[1], vcargs[2]);
break;
case DeclKind.Sub:
Debug.Assert(vcargs.Length == 2);
res = gen.Function(VCExpressionGenerator.SubOp, vcargs[0], vcargs[1]);
break;
case DeclKind.True:
res = VCExpressionGenerator.True;
break;
case DeclKind.Uminus:
Debug.Assert(vcargs.Length == 1);
var argzero = null;
if (vcargs[0].Type.IsInt)
{
argzero = gen.Integer(Basetypes.BigNum.ZERO);
}
else
{
argzero = gen.Real(Basetypes.BigDec.ZERO);
}
res = gen.Function(VCExpressionGenerator.SubOp, argzero, vcargs[0]);
break;
case DeclKind.ToInt:
Debug.Assert(vcargs.Length == 1);
res = gen.Function(VCExpressionGenerator.ToIntOp, vcargs[0]);
break;
case DeclKind.ToReal:
Debug.Assert(vcargs.Length == 1);
res = gen.Function(VCExpressionGenerator.ToRealOp, vcargs[0]);
break;
case DeclKind.Uninterpreted:
var name = arg.GetAppDecl().GetDeclName();
if (args.Length == 0)
{ // a 0-ary constant is a VCExprVar
if (!constants_inv.TryGetValue(arg, out res))
{
throw new Exception("Z3 returned unknown constant: " + name);
}
}
else
{
Function f;
if (!functions_inv.TryGetValue(arg.GetAppDecl(), out f))
{
throw new Exception("Z3 returned unknown function: " + name);
}
List <VCExpr> vcargsList = new List <VCExpr>(vcargs);
res = gen.Function(f, vcargsList);
}
break;
default:
throw new Exception("Unknown Z3 operator");
}
break;
default:
Debug.Assert(false);
throw new Exception("Unknown Z3 AST kind");
}
memo.Add(arg, res);
return(res);
}
