public AssertCmd(IToken/*!*/ tok, Expr/*!*/ expr, QKeyValue kv)
: base(tok, expr, kv)
{
Contract.Requires(tok != null);
Contract.Requires(expr != null);
errorDataEnhanced = GenerateBoundVarMiningStrategy(expr);
}
public BinderExpr(IToken/*!*/ tok, List<TypeVariable>/*!*/ typeParameters,
List<Variable>/*!*/ dummies, QKeyValue kv, Expr/*!*/ body)
: base(tok)
{
Contract.Requires(tok != null);
Contract.Requires(typeParameters != null);
Contract.Requires(dummies != null);
Contract.Requires(body != null);
Contract.Requires(dummies.Count + typeParameters.Count > 0);
TypeParameters = typeParameters;
Dummies = dummies;
Attributes = kv;
Body = body;
}
public BinderExpr(IToken/*!*/ tok, List<TypeVariable>/*!*/ typeParameters,
List<Variable>/*!*/ dummies, QKeyValue kv, Expr/*!*/ body, bool immutable)
: base(tok, immutable) {
Contract.Requires(tok != null);
Contract.Requires(typeParameters != null);
Contract.Requires(dummies != null);
Contract.Requires(body != null);
Contract.Requires(dummies.Count + typeParameters.Count > 0);
TypeParameters = typeParameters;
Dummies = dummies;
Attributes = kv;
_Body = body;
if (immutable)
CachedHashCode = ComputeHashCode();
}
void Attribute(ref QKeyValue kv) {
Trigger trig = null;
AttributeOrTrigger(ref kv, ref trig);
if (trig != null) this.SemErr("only attributes, not triggers, allowed here");
}
void VarOrType(out TypedIdent/*!*/ tyd, out QKeyValue kv) {
Contract.Ensures(Contract.ValueAtReturn(out tyd) != null);
string/*!*/ varName = TypedIdent.NoName;
Bpl.Type/*!*/ ty;
IToken/*!*/ tok;
kv = null;
while (la.kind == 28) {
Attribute(ref kv);
}
Type(out ty);
tok = ty.tok;
if (la.kind == 12) {
Get();
var uti = ty as UnresolvedTypeIdentifier;
if (uti != null && uti.Arguments.Count == 0) {
varName = uti.Name;
} else {
this.SemErr("expected identifier before ':'");
}
Type(out ty);
}
tyd = new TypedIdent(tok, varName, ty);
}
// ----------------------------- Substitutions for QKeyValue -------------------------------
/// <summary>
/// Apply a substitution to a list of attributes. Any variables not in domain(subst)
/// is not changed. The substitutions apply within the "old", but the "old"
/// expression remains.
/// </summary>
public static QKeyValue Apply(Substitution subst, QKeyValue kv) {
Contract.Requires(subst != null);
if (kv == null) {
return null;
} else {
return (QKeyValue)new NormalSubstituter(subst).Visit(kv);
}
}
private void EmitLineDirective(Bpl.IToken methodCallToken) {
var sloc = this.StmtTraverser.lastSourceLocation;
if (sloc != null) {
var fileName = sloc.Document.Location;
var lineNumber = sloc.StartLine;
var attrib = new Bpl.QKeyValue(methodCallToken, "sourceLine", new List<object> { Bpl.Expr.Literal((int)lineNumber) }, null);
attrib = new Bpl.QKeyValue(methodCallToken, "sourceFile", new List<object> { fileName }, attrib);
this.StmtTraverser.StmtBuilder.Add(new Bpl.AssertCmd(methodCallToken, Bpl.Expr.True, attrib));
}
}
public static void ComputeBinderFreeVariables(List<TypeVariable> typeParameters, List<Variable> dummies, Expr body, QKeyValue attributes, Set freeVars) {
Contract.Requires(dummies != null);
Contract.Requires(body != null);
foreach (var v in dummies) {
Contract.Assert(v != null);
Contract.Assert(!freeVars[v]);
}
body.ComputeFreeVariables(freeVars);
for (var a = attributes; a != null; a = a.Next) {
foreach (var o in a.Params) {
var e = o as Expr;
if (e != null) {
e.ComputeFreeVariables(freeVars);
}
}
}
foreach (var v in dummies) {
freeVars.AddRange(v.TypedIdent.Type.FreeVariables);
}
freeVars.RemoveRange(dummies);
freeVars.RemoveRange(typeParameters);
}
public static QKeyValue RemoveMoverAttribute(QKeyValue iter)
{
if (iter == null) return null;
iter.Next = RemoveMoverAttribute(iter.Next);
if (iter.Key == "atomic" || iter.Key == "right" || iter.Key == "left" || iter.Key == "both")
return iter.Next;
else
return iter;
}
public QuantifierExpr(IToken/*!*/ tok, List<TypeVariable>/*!*/ typeParameters,
List<Variable>/*!*/ dummies, QKeyValue kv, Trigger triggers, Expr/*!*/ body, bool immutable)
: base(tok, typeParameters, dummies, kv, body, immutable) {
Contract.Requires(tok != null);
Contract.Requires(typeParameters != null);
Contract.Requires(dummies != null);
Contract.Requires(body != null);
Contract.Requires(dummies.Count + typeParameters.Count > 0);
Contract.Assert((this is ForallExpr) || (this is ExistsExpr));
Triggers = triggers;
SkolemId = GetNextSkolemId();
}
private void CheckAndAddLayers(Absy node, QKeyValue attributes, int enclosingProcLayerNum)
{
List<int> attrs = RemoveDuplicatesAndSort(FindLayers(attributes));
if (attrs.Count == 0)
{
Error(node, "layer not present");
return;
}
LayerRange upperBound = FindLayerRange();
absyToLayerNums[node] = new HashSet<int>();
foreach (int layerNum in attrs)
{
if (layerNum > enclosingProcLayerNum)
{
Error(node, "The layer cannot be greater than the layer of enclosing procedure");
}
else if (upperBound.Contains(layerNum))
{
absyToLayerNums[node].Add(layerNum);
}
else
{
Error(node, string.Format("A variable being accessed in this specification is unavailable at layer {0}", layerNum));
}
}
}
// Return 'true' if {:name true} or {:name} is an attribute in 'kv'
public static bool FindBoolAttribute(QKeyValue kv, string name) {
Contract.Requires(name != null);
for (; kv != null; kv = kv.Next) {
if (kv.Key == name) {
return kv.Params.Count == 0 ||
(kv.Params.Count == 1 && kv.Params[0] is LiteralExpr && ((LiteralExpr)kv.Params[0]).IsTrue);
}
}
return false;
}
public static int FindIntAttribute(QKeyValue kv, string name, int defl) {
Contract.Requires(name != null);
Expr e = FindExprAttribute(kv, name);
LiteralExpr l = e as LiteralExpr;
if (l != null && l.isBigNum)
return l.asBigNum.ToIntSafe;
return defl;
}
// Look for {:name expr} in list of attributes.
public static Expr FindExprAttribute(QKeyValue kv, string name) {
Contract.Requires(name != null);
for (; kv != null; kv = kv.Next) {
if (kv.Key == name) {
if (kv.Params.Count == 1 && kv.Params[0] is Expr) {
return (Expr)kv.Params[0];
}
}
}
return null;
}
public void AddLast(QKeyValue other) {
Contract.Requires(other != null);
QKeyValue current = this;
while (current.Next != null) {
current = current.Next;
}
current.Next = other;
}
public QKeyValue(IToken tok, string key, IList<object/*!*/>/*!*/ parameters, QKeyValue next)
: base(tok) {
Contract.Requires(key != null);
Contract.Requires(tok != null);
Contract.Requires(cce.NonNullElements(parameters));
Key = key;
this._params = new List<object>(parameters);
Next = next;
}
void UserDefinedType(out Declaration/*!*/ decl, QKeyValue kv) {
Contract.Ensures(Contract.ValueAtReturn(out decl) != null); IToken/*!*/ id; List<IToken>/*!*/ paramTokens = new List<IToken> ();
Bpl.Type/*!*/ body = dummyType; bool synonym = false;
Ident(out id);
if (la.kind == 1) {
WhiteSpaceIdents(out paramTokens);
}
if (la.kind == 32) {
Get();
Type(out body);
synonym = true;
}
if (synonym) {
List<TypeVariable>/*!*/ typeParams = new List<TypeVariable>();
foreach(Token/*!*/ t in paramTokens){
Contract.Assert(t != null);
typeParams.Add(new TypeVariable(t, t.val));}
decl = new TypeSynonymDecl(id, id.val, typeParams, body, kv);
} else {
decl = new TypeCtorDecl(id, id.val, paramTokens.Count, kv);
}
}
public virtual QKeyValue VisitQKeyValue(QKeyValue node) {
Contract.Requires(node != null);
Contract.Ensures(Contract.Result<QKeyValue>() != null);
var newParams = new List<object>();
for (int i = 0, n = node.Params.Count; i < n; i++) {
var e = node.Params[i] as Expr;
newParams.Add(e != null ? this.Visit(e) : node.Params[i]);
}
node.ClearParams();
node.AddParams(newParams);
if (node.Next != null) {
node.Next = (QKeyValue)this.Visit(node.Next);
}
return node;
}
void ProcSignature(bool allowWhereClausesOnFormals, out IToken/*!*/ name, out List<TypeVariable>/*!*/ typeParams,
out List<Variable>/*!*/ ins, out List<Variable>/*!*/ outs, out QKeyValue kv) {
Contract.Ensures(Contract.ValueAtReturn(out name) != null); Contract.Ensures(Contract.ValueAtReturn(out typeParams) != null); Contract.Ensures(Contract.ValueAtReturn(out ins) != null); Contract.Ensures(Contract.ValueAtReturn(out outs) != null);
IToken/*!*/ typeParamTok; typeParams = new List<TypeVariable>();
outs = new List<Variable>(); kv = null;
while (la.kind == 28) {
Attribute(ref kv);
}
Ident(out name);
if (la.kind == 20) {
TypeParams(out typeParamTok, out typeParams);
}
ProcFormals(true, allowWhereClausesOnFormals, out ins);
if (la.kind == 27) {
Get();
ProcFormals(false, allowWhereClausesOnFormals, out outs);
}
}
private QKeyValue RemoveLinearAttribute(QKeyValue iter)
{
if (iter == null) return null;
iter.Next = RemoveLinearAttribute(iter.Next);
return (iter.Key == "linear" || iter.Key == "linear_in" || iter.Key == "linear_out") ? iter.Next : iter;
}
private static List<int> FindLayers(QKeyValue kv)
{
List<int> layers = new List<int>();
for (; kv != null; kv = kv.Next)
{
if (kv.Key != CivlAttributes.LAYER) continue;
foreach (var o in kv.Params)
{
Expr e = o as Expr;
if (e == null) return null;
LiteralExpr l = e as LiteralExpr;
if (l == null) return null;
if (!l.isBigNum) return null;
layers.Add(l.asBigNum.ToIntSafe);
}
}
return layers;
}
static void Instrument(Implementation impl, NativeLattice.Element[] pre, NativeLattice.Element[] post)
{
Contract.Requires(impl != null);
Contract.Requires(pre != null);
foreach (var b in impl.Blocks) {
var element = pre[b.aiId];
if (element != null && (b.widenBlock || CommandLineOptions.Clo.InstrumentInfer == CommandLineOptions.InstrumentationPlaces.Everywhere)) {
List<Cmd> newCommands = new List<Cmd>();
Expr inv = element.ToExpr();
PredicateCmd cmd;
var kv = new QKeyValue(Token.NoToken, "inferred", new List<object>(), null);
if (CommandLineOptions.Clo.InstrumentWithAsserts) {
cmd = new AssertCmd(Token.NoToken, inv, kv);
} else {
cmd = new AssumeCmd(Token.NoToken, inv, kv);
}
newCommands.Add(cmd);
newCommands.AddRange(b.Cmds);
if (post != null && post[b.aiId] != null) {
inv = post[b.aiId].ToExpr();
kv = new QKeyValue(Token.NoToken, "inferred", new List<object>(), null);
if (CommandLineOptions.Clo.InstrumentWithAsserts) {
cmd = new AssertCmd(Token.NoToken, inv, kv);
} else {
cmd = new AssumeCmd(Token.NoToken, inv, kv);
}
newCommands.Add(cmd);
}
b.Cmds = newCommands; // destructively replace the commands of the block
}
}
}
public override QKeyValue VisitQKeyValue(QKeyValue node) {
Contract.Ensures(Contract.Result<QKeyValue>() == node);
for (int i = 0, n = node.Params.Count; i < n; i++) {
var e = node.Params[i] as Expr;
if (e != null) {
this.Visit(e);
}
}
if (node.Next != null) {
this.Visit(node.Next);
}
return node;
}
public LambdaExpr(IToken/*!*/ tok, List<TypeVariable>/*!*/ typeParameters,
List<Variable>/*!*/ dummies, QKeyValue kv, Expr/*!*/ body, bool immutable=false)
: base(tok, typeParameters, dummies, kv, body, immutable) {
Contract.Requires(tok != null);
Contract.Requires(typeParameters != null);
Contract.Requires(dummies != null);
Contract.Requires(body != null);
Contract.Requires(dummies.Count + typeParameters.Count > 0);
}
public static QKeyValue RemoveYieldsAttribute(QKeyValue iter)
{
if (iter == null) return null;
iter.Next = RemoveYieldsAttribute(iter.Next);
return (iter.Key == "yields") ? iter.Next : iter;
}
void CallParams(bool isAsync, bool isFree, QKeyValue kv, IToken x, out Cmd c) {
List<IdentifierExpr> ids = new List<IdentifierExpr>();
List<Expr> es = new List<Expr>();
Expr en;
IToken first;
IToken p;
c = null;
Ident(out first);
if (la.kind == 10) {
Get();
if (StartOf(9)) {
Expression(out en);
es.Add(en);
while (la.kind == 13) {
Get();
Expression(out en);
es.Add(en);
}
}
Expect(11);
c = new CallCmd(x, first.val, es, ids, kv); ((CallCmd) c).IsFree = isFree; ((CallCmd) c).IsAsync = isAsync;
} else if (la.kind == 13 || la.kind == 51) {
ids.Add(new IdentifierExpr(first, first.val));
if (la.kind == 13) {
Get();
Ident(out p);
ids.Add(new IdentifierExpr(p, p.val));
while (la.kind == 13) {
Get();
Ident(out p);
ids.Add(new IdentifierExpr(p, p.val));
}
}
Expect(51);
Ident(out first);
Expect(10);
if (StartOf(9)) {
Expression(out en);
es.Add(en);
while (la.kind == 13) {
Get();
Expression(out en);
es.Add(en);
}
}
Expect(11);
c = new CallCmd(x, first.val, es, ids, kv); ((CallCmd) c).IsFree = isFree; ((CallCmd) c).IsAsync = isAsync;
} else SynErr(112);
}
public override QKeyValue VisitQKeyValue(QKeyValue node) {
//Contract.Requires(node != null);
var newParams = new List<object>();
foreach (var o in node.Params) {
var e = o as Expr;
if (e == null) {
newParams.Add(o);
} else {
newParams.Add((Expr)this.Visit(e));
}
}
QKeyValue next = node.Next == null ? null : (QKeyValue)this.Visit(node.Next);
return new QKeyValue(node.tok, node.Key, newParams, next);
}
void QuantifierBody(IToken/*!*/ q, out List<TypeVariable>/*!*/ typeParams, out List<Variable>/*!*/ ds,
out QKeyValue kv, out Trigger trig, out Expr/*!*/ body) {
Contract.Requires(q != null); Contract.Ensures(Contract.ValueAtReturn(out typeParams) != null); Contract.Ensures(Contract.ValueAtReturn(out ds) != null); Contract.Ensures(Contract.ValueAtReturn(out body) != null);
trig = null; typeParams = new List<TypeVariable> ();
IToken/*!*/ tok;
kv = null;
ds = new List<Variable> ();
if (la.kind == 20) {
TypeParams(out tok, out typeParams);
if (la.kind == 1 || la.kind == 28) {
BoundVars(q, out ds);
}
} else if (la.kind == 1 || la.kind == 28) {
BoundVars(q, out ds);
} else SynErr(129);
QSep();
while (la.kind == 28) {
AttributeOrTrigger(ref kv, ref trig);
}
Expression(out body);
}
/// <summary>
/// Apply a substitution to a list of attributes replacing "old" expressions.
/// For a further description, see "ApplyReplacingOldExprs" above for Expr.
/// </summary>
public static QKeyValue ApplyReplacingOldExprs(Substitution always, Substitution forOld, QKeyValue kv) {
Contract.Requires(always != null);
Contract.Requires(forOld != null);
if (kv == null) {
return null;
} else {
return (QKeyValue)new ReplacingOldSubstituter(always, forOld).Visit(kv);
}
}
void AttributeOrTrigger(ref QKeyValue kv, ref Trigger trig) {
IToken/*!*/ tok; Expr/*!*/ e; List<Expr>/*!*/ es;
string key;
List<object/*!*/> parameters; object/*!*/ param;
Expect(28);
tok = t;
if (la.kind == 12) {
Get();
Expect(1);
key = t.val; parameters = new List<object/*!*/>();
if (StartOf(16)) {
AttributeParameter(out param);
parameters.Add(param);
while (la.kind == 13) {
Get();
AttributeParameter(out param);
parameters.Add(param);
}
}
if (key == "nopats") {
if (parameters.Count == 1 && parameters[0] is Expr) {
e = (Expr)parameters[0];
if(trig==null){
trig = new Trigger(tok, false, new List<Expr> { e }, null);
} else {
trig.AddLast(new Trigger(tok, false, new List<Expr> { e }, null));
}
} else {
this.SemErr("the 'nopats' quantifier attribute expects a string-literal parameter");
}
} else {
if (kv==null) {
kv = new QKeyValue(tok, key, parameters, null);
} else {
kv.AddLast(new QKeyValue(tok, key, parameters, null));
}
}
} else if (StartOf(9)) {
Expression(out e);
es = new List<Expr> { e };
while (la.kind == 13) {
Get();
Expression(out e);
es.Add(e);
}
if (trig==null) {
trig = new Trigger(tok, true, es, null);
} else {
trig.AddLast(new Trigger(tok, true, es, null));
}
} else SynErr(133);
Expect(29);
}