public override void OnModel(IList<string>/*!>!*/ labels, Model model)
{
// TODO: it would be better to check which reachability variables are actually set to one!
List<Block> traceNodes = new List<Block>();
List<AssertCmd> assertNodes = new List<AssertCmd>();
foreach (string s in labels)
{
Contract.Assert(s != null);
Absy node = Label2Absy(s);
if (node is Block)
{
Block b = (Block)node;
traceNodes.Add(b);
//Console.Write("{0}, ", b.Label);
}
}
m_CurrentTrace.AddRange(traceNodes);
}
private Model.Element GetModelValue(Model m, Variable v, Dictionary<string,string> subst)
{
// first, get the unique name
string uniqueName;
VCExprVar vvar = boogieContext.BoogieExprTranslator.TryLookupVariable(v);
uniqueName = v.Name;
if(subst.ContainsKey(uniqueName))
return m.MkElement(subst[uniqueName]);
return m.MkFunc("@undefined", 0).GetConstant();
}
public override void OnModel(IList<string> labels, Model model)
{
Debug.Assert(model != null);
if(CommandLineOptions.Clo.PrintErrorModel >= 1) model.Write(Console.Out);
this.model = model;
}
public MLHoudiniErrorReporter()
{
model = null;
}
private Model.Element getValue(VCExpr arg, Model model)
{
if (arg is VCExprLiteral)
{
//return model.GetElement(arg.ToString());
return model.MkElement(arg.ToString());
}
else if (arg is VCExprVar)
{
var el = model.TryGetFunc(prover.Context.Lookup(arg as VCExprVar));
if (el != null)
{
Debug.Assert(el.Arity == 0 && el.AppCount == 1);
return el.Apps.First().Result;
}
else
{
// Variable not defined; assign arbitrary value
if (arg.Type.IsBool)
return model.MkElement("false");
else if (arg.Type.IsInt)
return model.MkIntElement(0);
else
return null;
}
}
else if (arg is VCExprNAry && (arg as VCExprNAry).Op is VCExprBvOp)
{
// support for BV constants
var bvc = (arg as VCExprNAry)[0] as VCExprLiteral;
if (bvc != null)
{
var ret = model.TryMkElement(bvc.ToString() + arg.Type.ToString());
if (ret != null && (ret is Model.BitVector)) return ret;
}
}
var val = prover.Evaluate(arg);
if (val is int || val is bool || val is Microsoft.Basetypes.BigNum)
{
return model.MkElement(val.ToString());
}
else
{
Debug.Assert(false);
}
return null;
}
private List<Tuple<string, List<Model.Element>>> ExtractState(string impl, Expr expr, Model model)
{
var funcsUsed = FunctionCollector.Collect(expr);
var ret = new List<Tuple<string, List<Model.Element>>>();
foreach (var tup in funcsUsed.Where(t => t.Item2 == null))
{
var constant = tup.Item1;
if (!constant2FuncCall.ContainsKey(constant.Name))
continue;
var func = constant2FuncCall[constant.Name];
var funcName = (func.Fun as FunctionCall).FunctionName;
var vals = new List<Model.Element>();
prover.Context.BoogieExprTranslator.Translate(func.Args).Iter(ve => vals.Add(getValue(ve, model)));
ret.Add(Tuple.Create(funcName, vals));
}
foreach (var tup in funcsUsed.Where(t => t.Item2 != null))
{
var constant = tup.Item1;
var boundExpr = tup.Item2;
if (!constant2FuncCall.ContainsKey(constant.Name))
continue;
// There are some bound variables (because the existential function was inside an \exists).
// We must find an assignment for bound varibles
// First, peice apart the existential functions
var cd = new Duplicator();
var tup2 = ExistentialExprModelMassage.Massage(cd.VisitExpr(boundExpr.Body));
var be = tup2.Item1;
Expr env = Expr.True;
foreach (var ahFunc in tup2.Item2)
{
var tup3 = impl2FuncCalls[impl].First(t => t.Item2.Name == ahFunc.Name);
var varList = new List<Expr>();
tup3.Item3.Args.OfType<Expr>().Iter(v => varList.Add(v));
env = Expr.And(env, function2Value[tup3.Item1].Gamma(varList));
}
be = Expr.And(be, Expr.Not(env));
// map formals to constants
var formalToConstant = new Dictionary<string, Constant>();
foreach (var f in boundExpr.Dummies.OfType<Variable>())
formalToConstant.Add(f.Name, new Constant(Token.NoToken, new TypedIdent(Token.NoToken, f.Name + "@subst@" + (existentialConstCounter++), f.TypedIdent.Type), false));
be = Substituter.Apply(new Substitution(v => formalToConstant.ContainsKey(v.Name) ? Expr.Ident(formalToConstant[v.Name]) : Expr.Ident(v)), be);
formalToConstant.Values.Iter(v => prover.Context.DeclareConstant(v, false, null));
var reporter = new MLHoudiniErrorReporter();
var ve = prover.Context.BoogieExprTranslator.Translate(be);
prover.Assert(ve, true);
prover.Check();
var proverOutcome = prover.CheckOutcomeCore(reporter);
if (proverOutcome != ProverInterface.Outcome.Invalid)
continue;
model = reporter.model;
var func = constant2FuncCall[constant.Name];
var funcName = (func.Fun as FunctionCall).FunctionName;
var vals = new List<Model.Element>();
foreach (var funcArg in func.Args.OfType<Expr>())
{
var arg = Substituter.Apply(new Substitution(v => formalToConstant.ContainsKey(v.Name) ? Expr.Ident(formalToConstant[v.Name]) : Expr.Ident(v)), funcArg);
vals.Add(getValue(prover.Context.BoogieExprTranslator.Translate(arg), model));
}
ret.Add(Tuple.Create(funcName, vals));
}
return ret;
}
internal BitVector(Model p, string n, int sz) : base(p, n) { Size = sz; }
public virtual void OnModel(IList<string> labels, Model model, Outcome proverOutcome)
{
Contract.Requires(cce.NonNullElements(labels));
}
internal Uninterpreted(Model p, string n) : base(p) { Name = n; }
protected Element(Model p)
{
Model = p;
Id = Model.elements.Count;
}
internal Func(Model p, string n, int a) { Model = p; Name = n; Arity = a; }
internal DatatypeValue(Model p, string name, List<Element> args) : base(p) {
ConstructorName = name;
Arguments = args.ToArray();
}
internal Array(Model p, Func v) : base(p) { Value = v; }
internal Boolean(Model p, bool v) : base(p) { Value = v; }
private void GetModelWithStates(Model m, RPFP.Node cex, StratifiedInliningInfo mainInfo,
List<StateId> orderedStateIds,
Dictionary<int,Dictionary<string,string>> varSubst)
{
if (m == null) return;
var mvInfo = mainInfo.mvInfo;
foreach (Variable v in mvInfo.AllVariables)
{
m.InitialState.AddBinding(v.Name, GetModelValue(m, v, varSubst[cex.Outgoing.number]));
}
Dictionary<int, RPFP.Edge> edgeNumbering = new Dictionary<int,RPFP.Edge>();
NumberCexEdges(cex, edgeNumbering);
int lastCandidate = 0;
int lastCapturePoint = CALL;
for (int i = 0; i < orderedStateIds.Count; ++i)
{
var s = orderedStateIds[i];
RPFP.Edge edge = s.edge;
int candidate = edge.number;
int capturePoint = s.capturePoint;
Dictionary<string, string> subst = varSubst[candidate];
string implName = edge.Parent.Name.GetDeclName();
var info = s.info.mvInfo;
if (capturePoint == CALL || capturePoint == RETURN)
{
lastCandidate = candidate;
lastCapturePoint = capturePoint;
continue;
}
Contract.Assume(0 <= capturePoint && capturePoint < info.CapturePoints.Count);
VC.ModelViewInfo.Mapping map = info.CapturePoints[capturePoint];
var prevInc = (lastCapturePoint != CALL && lastCapturePoint != RETURN && candidate == lastCandidate)
? info.CapturePoints[lastCapturePoint].IncarnationMap : new Dictionary<Variable, Expr>();
var cs = m.MkState(map.Description);
foreach (Variable v in info.AllVariables)
{
var e = (Expr)map.IncarnationMap[v];
if (e == null)
{
if (lastCapturePoint == CALL || lastCapturePoint == RETURN)
{
cs.AddBinding(v.Name, GetModelValue(m, v, subst));
}
continue;
}
if (lastCapturePoint != CALL && lastCapturePoint != RETURN && prevInc[v] == e) continue; // skip unchanged variables
Model.Element elt;
if (e is IdentifierExpr)
{
IdentifierExpr ide = (IdentifierExpr)e;
elt = GetModelValue(m, ide.Decl, subst);
}
else if (e is LiteralExpr)
{
LiteralExpr lit = (LiteralExpr)e;
elt = m.MkElement(lit.Val.ToString());
}
else
{
Contract.Assume(false);
elt = m.MkFunc(e.ToString(), 0).GetConstant();
}
cs.AddBinding(v.Name, elt);
}
lastCandidate = candidate;
lastCapturePoint = capturePoint;
}
return;
}
/** Set the model of the background theory used in a counterexample. */
public void SetBackgroundModel(Model m)
{
dualModel = m;
}
protected Number(Model p, string n) : base(p) { Numeral = n; }
protected void NewModel()
{
lastLine = "";
currModel = new Model ();
resModels.Add (currModel);
}
internal Integer(Model p, string n) : base(p, n) { }
