public dynamic Visit(AndOrExpr expr)
{
Visit((ExpressionBase)expr);
if (OptimizeMode.ExpressionSimplify)
{
var left = expr.First as LiteralExpr;
var right = expr.Second as LiteralExpr;
if (left != null && right != null)
{
var literal = new LiteralExpr {
Namespace = expr.Namespace, Node = expr.Node, SymbolType = expr.GetExprType()
};
bool result;
switch (expr.Type)
{
case AndOrOperation.Or:
result = left.Value || right.Value;
break;
case AndOrOperation.And:
result = left.Value && right.Value;
break;
default:
throw new ArgumentOutOfRangeException();
}
literal.Value = result;
return(literal);
}
}
return(expr);
}
private IEnumerable <Solution> IsNat(Statement st)
{
IVariable lv = null;
List <Expression> callArgs;
object result = null;
InitArgs(st, out lv, out callArgs);
Contract.Assert(lv != null, Error.MkErr(st, 8));
Contract.Assert(callArgs.Count == 1, Error.MkErr(st, 0, 1, callArgs.Count));
foreach (var item in ResolveExpression(callArgs[0]))
{
var ns = item as NameSegment;
if (ns == null)
{
continue;
}
var type = StaticContext.GetVariableType(ns);
if (type != null)
{
continue;
}
Contract.Assert(false, Error.MkErr(st, 24));
result = new LiteralExpr(st.Tok, false);
}
yield return(AddNewLocal(lv, result));
}
public void CachedHashCodeOldExpr()
{
var literalBv = new LiteralExpr(Token.NoToken, Microsoft.BaseTypes.BigNum.FromInt(0), 4, /*immutable=*/ true);
var oldExpr = new OldExpr(Token.NoToken, literalBv, /*immutable=*/ true);
Assert.AreEqual(oldExpr.ComputeHashCode(), oldExpr.GetHashCode());
}
/// <summary>
/// Apply the assignments in the form of axioms.
/// </summary>
/// <param name="program">The program.</param>
/// <param name="assignments">The assignments provided by the solver.</param>
private void ApplyAssignments(Microsoft.Boogie.Program program, Dictionary <string, bool> assignments)
{
// remove existing axioms
List <Axiom> axioms = new List <Axiom>();
foreach (Axiom axiom in program.Axioms.Where(x => x.Comment == "repair_constraint"))
{
axioms.Add(axiom);
}
axioms.ForEach(x => program.RemoveTopLevelDeclaration(x));
// add the axioms corresponding to the assignments
foreach (KeyValuePair <string, bool> assignment in assignments)
{
Expr identifier = new IdentifierExpr(Token.NoToken, assignment.Key, Type.Bool);
Expr literal = new LiteralExpr(Token.NoToken, assignment.Value);
BinaryOperator _operator = new BinaryOperator(Token.NoToken, BinaryOperator.Opcode.Iff);
NAryExpr expr = new NAryExpr(Token.NoToken, _operator, new List <Expr> {
identifier, literal
});
Axiom axiom = new Axiom(Token.NoToken, expr, "repair_constraint");
program.AddTopLevelDeclaration(axiom);
}
}
private void SlicePolicyAxioms()
{
LiteralExpr policy_target = null;
if (this.source_assert.Expr is NAryExpr && ((this.source_assert.Expr) as NAryExpr).Fun.FunctionName == "policy")
{
Utils.Assert(((this.source_assert.Expr) as NAryExpr).Args.Count == 1, "Expecting \"policy\" axiom with a single argument");
if (!(((this.source_assert.Expr) as NAryExpr).Args.First() is LiteralExpr))
{
return;
}
policy_target = ((this.source_assert.Expr) as NAryExpr).Args.First() as LiteralExpr;
}
foreach (Declaration d in this.prog.TopLevelDeclarations.ToList())
{
if (d is Axiom && (d as Axiom).Expr is NAryExpr && ((d as Axiom).Expr as NAryExpr).Fun.FunctionName == "policy")
{
if (policy_target != null && policy_target.ToString().Equals(((d as Axiom).Expr as NAryExpr).Args.First().ToString()))
{
continue;
}
else
{
this.prog.RemoveTopLevelDeclaration(d);
}
}
}
}
public void FunctionCall()
{
var fc = CreateFunctionCall("bv8slt", Microsoft.Boogie.Type.Bool, new List <Microsoft.Boogie.Type>()
{
BasicType.GetBvType(8),
BasicType.GetBvType(8)
});
var constantBv = new LiteralExpr(Token.NoToken, BigNum.FromInt(0), 8);
var nary = new NAryExpr(Token.NoToken, fc, new List <Expr>()
{
constantBv, constantBv
});
// Get shallow type (this was broken when this test was written)
Assert.AreEqual(BasicType.Bool, nary.ShallowType);
// Deep type check (this was not broken before writing this test)
Assert.IsNull(nary.Type);
var tc = new TypecheckingContext(this);
nary.Typecheck(tc);
Assert.AreEqual(BasicType.Bool, nary.Type);
}
private static List <int> FindLayers(QKeyValue kv)
{
HashSet <int> attrs = new HashSet <int>();
for (; kv != null; kv = kv.Next)
{
if (kv.Key != "layer")
{
continue;
}
foreach (var o in kv.Params)
{
Expr e = o as Expr;
if (e == null)
{
continue;
}
LiteralExpr l = e as LiteralExpr;
if (l != null && l.isBigNum)
{
attrs.Add(l.asBigNum.ToIntSafe);
}
}
}
List <int> layers = attrs.ToList();
layers.Sort();
return(layers);
}
public override void Visit(LiteralExpr expr)
{
Value value;
switch (expr.literal.type)
{
case TokenType.TRUE:
chunk.WriteOpCode(OpCode.TRUE);
break;
case TokenType.FALSE:
chunk.WriteOpCode(OpCode.FALSE);
break;
case TokenType.NIL:
chunk.WriteOpCode(OpCode.NIL);
break;
case TokenType.NUMBER:
value = new Value((double)expr.literal.literal);
AddConstant(value);
break;
case TokenType.STRING:
value = new Value((string)expr.literal.literal);
AddConstant(value);
break;
default:
value = new Value();
AddConstant(value);
ReportError(expr.literal.line, expr.literal.column, "Unknown literal.");
break;
}
}
public static bool findAnyVariable(Expr root, out Variable v, out LiteralExpr literal)
{
if (root is NAryExpr)
{
var naryExpr = root as NAryExpr;
var idExpr = naryExpr.Args.OfType <IdentifierExpr>();
if (idExpr.Count() == 0)
{
v = null;
literal = null;
return(false);
}
if (naryExpr.Fun is BinaryOperator)
{
var operation = (naryExpr.Fun as BinaryOperator).Op;
if (operation == BinaryOperator.Opcode.Eq || // var == Literal
operation == BinaryOperator.Opcode.Iff // var <==> Literal (for bools)
)
{
var literalExpr = naryExpr.Args.OfType <LiteralExpr>();
if (literalExpr.Count() > 0)
{
v = idExpr.First().Decl;
literal = literalExpr.First();
return(true);
}
}
}
}
v = null;
literal = null;
return(false);
}
public void ProtectedBvExtract()
{
var bv = new LiteralExpr(Token.NoToken, Microsoft.Basetypes.BigNum.FromInt(0), 32, /*immutable=*/true);
var extract = new BvExtractExpr(Token.NoToken, bv, 32, 0, /*immutable=*/true);
Assert.IsTrue(extract.Immutable);
Assert.Throws(typeof(InvalidOperationException), () => extract.Bitvector = bv);
}
public void CachedHashCodeBvConcatExpr()
{
var literalBv = new LiteralExpr(Token.NoToken, Microsoft.BaseTypes.BigNum.FromInt(0), 4, /*immutable=*/ true);
var bvConcat = new BvConcatExpr(Token.NoToken, literalBv, literalBv, /*immutable=*/ true);
Assert.AreEqual(bvConcat.ComputeHashCode(), bvConcat.GetHashCode());
}
private LiteralExpr EvaluateNAryExpr(NAryExpr node)
{
if (node.Args.Count == 2)
{
try
{
LiteralExpr arg1 = DecideArg(node.Args.ElementAt(0));
LiteralExpr arg2 = DecideArg(node.Args.ElementAt(1));
if (arg1 == null || arg2 == null)
{
return null;
}
Utils.Assert(arg1.asBvConst.Bits == arg2.asBvConst.Bits, "Expected operation on same width bit-vectors.");
if (node.Fun.FunctionName.Contains("PLUS"))
{
return new LiteralExpr(Token.NoToken, arg1.asBvConst.Value + arg2.asBvConst.Value, arg1.asBvConst.Bits);
}
else if (node.Fun.FunctionName.Contains("MINUS"))
{
return new LiteralExpr(Token.NoToken, arg1.asBvConst.Value - arg2.asBvConst.Value, arg1.asBvConst.Bits);
}
}
catch (InvalidCastException) { };
}
return null;
}
private void CheckType(Microsoft.Boogie.Type type, LiteralExpr theConstant, string expectedType, string expectedExpr)
{
string result = null;
using (var stringWriter = new StringWriter())
{
var printer = GetPrinter(stringWriter);
var ts = CreateTypeSynonym(type, "mysn");
// Check we get the basic type back
Assert.AreEqual(expectedType, SMTLIBQueryPrinter.GetSMTLIBType(ts));
// Now check it can be used in a query
var typeIdent = new TypedIdent(Token.NoToken, "thetype", ts);
var variable = new LocalVariable(Token.NoToken, typeIdent);
// SymbolicVariable constructor requires that a ProgramLocation is already attached
variable.SetMetadata((int)AnnotationIndex.PROGRAM_LOCATION, new ProgramLocation(variable));
var symbolic = new SymbolicVariable("symbolic_0", variable);
var theExpr = Expr.Eq(symbolic.Expr, theConstant);
printer.AddDeclarations(theExpr);
printer.PrintExpr(theExpr);
result = stringWriter.ToString();
}
Assert.AreEqual(expectedExpr, result);
}
private bool IsConstant(Expr expr, int x)
{
if (!(expr is LiteralExpr))
{
return(false);
}
LiteralExpr lit = expr as LiteralExpr;
if (lit.Val is BvConst)
{
if (((BvConst)lit.Val).Value.InInt32)
{
return(((BvConst)lit.Val).Value.ToIntSafe == x);
}
}
if (lit.Val is Microsoft.Basetypes.BigNum)
{
if (((Microsoft.Basetypes.BigNum)lit.Val).InInt32)
{
return(((Microsoft.Basetypes.BigNum)lit.Val).ToInt == x);
}
}
return(false);
}
public void checkEqualityConstraint(object executor, Executor.BreakPointEventArgs data, Predicate <LiteralExpr> condition)
{
// Check that the equality constraint has been stored
bool found = false;
// Find the symbolic associated with variable "a".
var theLocal = e.CurrentState.GetInScopeVariableAndExprByName("a");
//var symbolic = e.CurrentState.Symbolics.Where( s => s.Origin.AsVariable == theLocal.Key).First();
foreach (Expr constraint in e.CurrentState.Constraints.ConstraintExprs)
{
LiteralExpr literal = null;
Variable symbolic = null;
found = FindLiteralAssignment.findAnyVariable(constraint, out symbolic, out literal);
if (found)
{
Assert.IsInstanceOf <SymbolicVariable>(symbolic);
var asSym = symbolic as SymbolicVariable;
if (asSym.Origin.IsVariable && asSym.Origin.AsVariable == theLocal.Key)
{
Assert.IsTrue(condition(literal));
found = true;
break;
}
}
}
Assert.IsTrue(found, "Equality constraint not found");
}
public void CachedHashCodeLiteralExpr()
{
var literal = new LiteralExpr(Token.NoToken, true, /*immutable=*/ true);
Assert.AreEqual(literal.ComputeHashCode(), literal.GetHashCode());
var literal2 = new LiteralExpr(Token.NoToken, Microsoft.BaseTypes.BigNum.FromInt(0), /*immutable=*/ true);
Assert.AreEqual(literal2.ComputeHashCode(), literal2.GetHashCode());
var literal3 = new LiteralExpr(Token.NoToken, Microsoft.BaseTypes.BigDec.FromInt(0), /*immutable=*/ true);
Assert.AreEqual(literal3.ComputeHashCode(), literal3.GetHashCode());
var literal4 = new LiteralExpr(Token.NoToken, Microsoft.BaseTypes.BigNum.FromInt(0), 8, /*immutable=*/ true);
Assert.AreEqual(literal4.ComputeHashCode(), literal4.GetHashCode());
var literal5 = new LiteralExpr(Token.NoToken, Microsoft.BaseTypes.BigFloat.FromInt(0), /*immutable=*/ true);
Assert.AreEqual(literal5.ComputeHashCode(), literal5.GetHashCode());
var literal6 = new LiteralExpr(Token.NoToken, Microsoft.BaseTypes.RoundingMode.RNE, /*immutable=*/ true);
Assert.AreEqual(literal6.ComputeHashCode(), literal6.GetHashCode());
}
private void LiteralArgumentAnalyser(Procedure p, int arg)
{
LiteralExpr literal = null;
foreach (CallCmd callCmd in CallSites[p])
{
if (callCmd.Ins[arg] == null || !(callCmd.Ins[arg] is LiteralExpr))
{
return;
}
LiteralExpr l = callCmd.Ins[arg] as LiteralExpr;
if (literal == null)
{
literal = l;
}
else if (!literal.Equals(l))
{
return;
}
}
Expr e;
e = new IdentifierExpr(Token.NoToken, p.InParams[arg]);
e = Expr.Eq(e, literal);
p.Requires.Add(new Requires(false, e));
}
public Expr VisitLiteralExpr(LiteralExpr e)
{
if (e.isBool)
{
if (e.IsTrue)
{
TW.Write("true");
}
else
{
TW.Write("false");
}
}
else if (e.isBvConst)
{
// FIXME: Support other bit vector literal printing modes
TW.Write(string.Format("(_ bv{0} {1})", e.asBvConst.Value, e.asBvConst.Bits));
}
else if (e.isBigNum)
{
// Int
TW.Write(e.asBigNum);
}
else if (e.isBigDec)
{
// Real
TW.Write(e.asBigDec.ToDecimalString());
}
else
{
throw new NotImplementedException("LiteralExpr type not handled");
}
return(e);
}
public dynamic Visit(LiteralExpr expr)
{
var node = Visit((ExpressionBase)expr);
node.Text = expr.StrValue;
return(node);
}
// This is a bit messy at the moment, sighs. Trying to decide what to do with it.
public LLVMValueRef Visit(LiteralExpr expr)
{
string literal = (string)expr.Value.Literal;
var baseType = expr.DataType.BaseType;
LLVMValueRef llvmValue;
if (baseType.IsInt() || baseType.IsBool())
{
ulong longValue = ulong.Parse(literal);
var isSigned = longValue < 0 ? LLVMBoolFalse : LLVMBoolTrue;
llvmValue = LLVM.ConstInt(baseType.ToLLVMType(), longValue, isSigned);
}
else if (baseType.IsFloat())
{
llvmValue = LLVM.ConstReal(baseType.ToLLVMType(), double.Parse(literal));
}
else
{
// Other datatypes, just string for now, but will probably become more? Hence the switch.
switch (baseType)
{
case BaseType.StringConst:
var stringConst = LLVM.ConstString(literal, (uint)literal.Length, LLVMBoolTrue);
llvmValue = LLVM.BuildGlobalString(_builder, literal, ".str");
break;
default:
throw new Exception($"Unknown datatype '{baseType.ToString()}'.");
}
}
llvmValue = CastIfNeeded(llvmValue, expr.Cast);
return(llvmValue);
}
/// <summary>
/// Initialize the variables.
/// </summary>
/// <param name="program">The source Boogie program.</param>
/// <param name="sourceLanguage">The source language of the input program.</param>
/// <param name="disableInspection">Disables inspection of programmer inserted barriers.</param>
/// <param name="disableGridBarriers">Disables grid-level barriers during instrumentation.</param>
/// <param name="useAxioms">Use axioms for instrumentation instead of variable assignments.</param>
public Instrumentor(Microsoft.Boogie.Program program, SourceLanguage sourceLanguage,
bool disableInspection, bool disableGridBarriers, bool useAxioms)
{
this.program = program;
this.sourceLanguage = sourceLanguage;
this.disableInspection = disableInspection;
this.disableGridBarriers = disableGridBarriers;
this.useAxioms = useAxioms;
analyzer = new GraphAnalyzer(program);
foreach (Declaration declaration in program.TopLevelDeclarations)
{
if (declaration is Procedure)
{
Procedure procedure = declaration as Procedure;
if (procedure.Name == "$bugle_barrier")
{
barrier_definition = procedure;
}
else if (procedure.Name == "$bugle_grid_barrier")
{
grid_barrier_definition = procedure;
}
}
}
_1bv1 = new LiteralExpr(Token.NoToken, BigNum.ONE, 1);
Logger.Log($"Blocks;{program.Blocks().Count()}");
Logger.Log($"Commands;{program.Blocks().Sum(x => x.Cmds.Count)}");
}
private static List <int> FindLayers(QKeyValue kv)
{
List <int> layers = new List <int>();
for (; kv != null; kv = kv.Next)
{
if (kv.Key != "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);
}
public static Expr Extract(Expr expr, Program program, List <Axiom> axioms)
{
Contract.Requires(expr != null && program != null && !program.TopLevelDeclarationsAreFrozen && axioms != null);
if (expr is LiteralExpr)
{
return(expr);
}
var extractor = new FunctionExtractor();
var body = extractor.VisitExpr(expr);
var name = program.FreshExtractedFunctionName();
var originalVars = extractor.Substitutions.Keys.ToList();
var formalInArgs = originalVars.Select(v => new Formal(Token.NoToken, new TypedIdent(Token.NoToken, extractor.Substitutions[v].Name, extractor.Substitutions[v].TypedIdent.Type), true)).ToList <Variable>();
var formalOutArg = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, name + "$result$", expr.Type), false);
var func = new Function(Token.NoToken, name, formalInArgs, formalOutArg);
func.AddAttribute("never_pattern");
var boundVars = originalVars.Select(k => extractor.Substitutions[k]);
var axiomCall = new NAryExpr(Token.NoToken, new FunctionCall(func), boundVars.Select(b => new IdentifierExpr(Token.NoToken, b)).ToList <Expr>());
axiomCall.Type = expr.Type;
axiomCall.TypeParameters = SimpleTypeParamInstantiation.EMPTY;
var eq = LiteralExpr.Eq(axiomCall, body);
eq.Type = body.Type;
eq.TypeParameters = SimpleTypeParamInstantiation.EMPTY;
if (0 < formalInArgs.Count)
{
var forallExpr = new ForallExpr(Token.NoToken, boundVars.ToList <Variable>(), new Trigger(Token.NoToken, true, new List <Expr> {
axiomCall
}), eq);
body = forallExpr;
forallExpr.Attributes = new QKeyValue(Token.NoToken, "weight", new List <object> {
new LiteralExpr(Token.NoToken, Basetypes.BigNum.FromInt(30))
}, null);
body.Type = Type.Bool;
}
else
{
body = eq;
}
var axiom = new Axiom(Token.NoToken, body);
func.DefinitionAxiom = axiom;
program.AddTopLevelDeclaration(func);
program.AddTopLevelDeclaration(axiom);
axioms.Add(axiom);
var call = new NAryExpr(Token.NoToken, new FunctionCall(func), originalVars.Select(v => new IdentifierExpr(Token.NoToken, v)).ToList <Expr>());
call.Type = expr.Type;
call.TypeParameters = SimpleTypeParamInstantiation.EMPTY;
return(call);
}
public void NaryExpr() {
var bv1_8 = new LiteralExpr(Token.NoToken, BigNum.FromInt(1), 8);
var bv2_8 = new LiteralExpr(Token.NoToken, BigNum.FromInt(2), 8);
var A = NAryExpr.Eq (bv1_8, bv2_8);
var B = d.Visit(A);
Assert.AreNotSame(A, B);
}
public override Expr VisitLiteralExpr(LiteralExpr node)
{
if (GetReplacementVariable(node, out var variable))
{
return(new IdentifierExpr(variable.tok, variable));
}
return(base.VisitLiteralExpr(node));
}
public void ProtectedBvExtract()
{
var bv = new LiteralExpr(Token.NoToken, Microsoft.Basetypes.BigNum.FromInt(0), 32, /*immutable=*/ true);
var extract = new BvExtractExpr(Token.NoToken, bv, 32, 0, /*immutable=*/ true);
Assert.IsTrue(extract.Immutable);
extract.Bitvector = bv; // Should throw
}
public void ProtectedBvConcatExprRhs()
{
var lhs = new LiteralExpr(Token.NoToken, Microsoft.Basetypes.BigNum.FromInt(0), 32, /*immutable=*/true);
var rhs = new LiteralExpr(Token.NoToken, Microsoft.Basetypes.BigNum.FromInt(1), 32, /*immutable=*/true);
var concat = new BvConcatExpr(Token.NoToken, lhs, rhs, /* immutable=*/true);
Assert.IsTrue(concat.Immutable);
Assert.Throws(typeof(InvalidOperationException), () => concat.E1 = lhs);
}
public void BvExtractExpr() {
var bv2_8 = new LiteralExpr(Token.NoToken, BigNum.FromInt(2), 8);
var A = new BvExtractExpr(Token.NoToken, bv2_8, 6,0);
var B = d.Visit(A);
// The duplicator should ensure we get new BVExtractExprs
Assert.AreNotSame(A, B);
}
public void BvExtractExpr()
{
var bv2_8 = new LiteralExpr(Token.NoToken, BigNum.FromInt(2), 8);
var A = new BvExtractExpr(Token.NoToken, bv2_8, 6, 0);
var B = d.Visit(A);
// The duplicator should ensure we get new BVExtractExprs
Assert.AreNotSame(A, B);
}
private void checkLiteral(LiteralExpr e, string expected)
{
using (var writer = new StringWriter())
{
var printer = GetPrinter(writer);
printer.PrintExpr(e);
Assert.IsTrue(writer.ToString() == expected);
}
}
public void ProtectedBvConcatExprRhs()
{
var lhs = new LiteralExpr(Token.NoToken, Microsoft.Basetypes.BigNum.FromInt(0), 32, /*immutable=*/ true);
var rhs = new LiteralExpr(Token.NoToken, Microsoft.Basetypes.BigNum.FromInt(1), 32, /*immutable=*/ true);
var concat = new BvConcatExpr(Token.NoToken, lhs, rhs, /* immutable=*/ true);
Assert.IsTrue(concat.Immutable);
concat.E1 = lhs; // Should throw
}
public void LiteralReal() {
var constant = new LiteralExpr(Token.NoToken, BigDec.FromString("11.7")); // Real
var constant2 = new LiteralExpr(Token.NoToken, BigDec.FromString("11.7")); // Real
Assert.AreNotSame(constant, constant2); // These are different references
Assert.IsTrue(constant.Equals(constant2)); // These are "structurally equal"
Assert.AreEqual(constant.GetHashCode(), constant2.GetHashCode()); // If the .Equals() is true then hash codes must be the same
}
/// <summary>
/// Identity expression
/// </summary>
/// <param name="st"></param>
/// <param name="solution"></param>
/// <returns></returns>
public IEnumerable<Solution> Resolve(Statement st, Solution solution) {
List<Expression> args = null;
IVariable lv = null;
InitArgs(st, out lv, out args);
LiteralExpr lit = new LiteralExpr(st.Tok, true);
var ac = Copy();
ac.DynamicContext.AddLocal(lv, lit);
yield return new Solution(ac);
}
public void NaryExpr()
{
var bv1_8 = new LiteralExpr(Token.NoToken, BigNum.FromInt(1), 8);
var bv2_8 = new LiteralExpr(Token.NoToken, BigNum.FromInt(2), 8);
var A = NAryExpr.Eq(bv1_8, bv2_8);
var B = d.Visit(A);
Assert.AreNotSame(A, B);
}
public void LiteralInt() {
var constant = new LiteralExpr(Token.NoToken, BigNum.FromInt(18)); // Integer
var constant2 = new LiteralExpr(Token.NoToken, BigNum.FromInt(18)); // Integer
Assert.AreNotSame(constant, constant2); // These are different references
Assert.IsTrue(constant.Equals(constant2)); // These are "structurally equal"
Assert.AreEqual(constant.GetHashCode(), constant2.GetHashCode()); // If the .Equals() is true then hash codes must be the same
}
private static LiteralExpr IsInductive(string datatypeName, DatatypeDecl datatype) {
LiteralExpr lit = new LiteralExpr(datatype.tok, false);
foreach (var ctor in datatype.Ctors) {
foreach (var formal in ctor.Formals) {
if (formal.Type.ToString() == datatypeName) {
return new LiteralExpr(datatype.tok, true);
}
}
}
return lit;
}
public void SimpleAdd() {
var constant = new LiteralExpr(Token.NoToken, BigNum.FromInt(18)); // Integer
var constant2 = new LiteralExpr(Token.NoToken, BigNum.FromInt(19)); // Integer
var add = Expr.Add(constant, constant2);
var add2 = Expr.Add(constant, constant2);
Assert.AreNotSame(constant, constant2); // These are different references
Assert.AreNotSame(add, add2); // These are different references
Assert.IsTrue(add.Equals(add2)); // These are "structurally equal"
Assert.AreEqual(add.GetHashCode(), add2.GetHashCode()); // If the .Equals() is true then hash codes must be the same
}
public void CachedHashCodeLiteralExpr()
{
var literal = new LiteralExpr(Token.NoToken, true, /*immutable=*/true);
Assert.AreEqual(literal.ComputeHashCode(), literal.GetHashCode());
var literal2 = new LiteralExpr(Token.NoToken, Microsoft.Basetypes.BigNum.FromInt(0), /*immutable=*/true);
Assert.AreEqual(literal2.ComputeHashCode(), literal2.GetHashCode());
var literal3 = new LiteralExpr(Token.NoToken, Microsoft.Basetypes.BigDec.FromInt(0), /*immutable=*/true);
Assert.AreEqual(literal3.ComputeHashCode(), literal3.GetHashCode());
var literal4 = new LiteralExpr(Token.NoToken, Microsoft.Basetypes.BigNum.FromInt(0), 8, /*immutable=*/true);
Assert.AreEqual(literal4.ComputeHashCode(), literal4.GetHashCode());
}
private IEnumerable<Solution> IsNat(Statement st) {
IVariable lv = null;
List<Expression> callArgs;
object result = null;
InitArgs(st, out lv, out callArgs);
Contract.Assert(lv != null, Error.MkErr(st, 8));
Contract.Assert(callArgs.Count == 1, Error.MkErr(st, 0, 1, callArgs.Count));
foreach (var item in ResolveExpression(callArgs[0])) {
var ns = item as NameSegment;
if (ns == null) continue;
var type = StaticContext.GetVariableType(ns);
if (type != null) continue;
Contract.Assert(false, Error.MkErr(st, 24));
result = new LiteralExpr(st.Tok, false);
}
yield return AddNewLocal(lv, result);
}
public void FunctionCall()
{
var fc = CreateFunctionCall("bv8slt", Microsoft.Boogie.Type.Bool, new List<Microsoft.Boogie.Type>() {
BasicType.GetBvType(8),
BasicType.GetBvType(8)
});
var constantBv = new LiteralExpr(Token.NoToken, BigNum.FromInt(0) , 8);
var nary = new NAryExpr(Token.NoToken,fc, new List<Expr>() { constantBv, constantBv} );
// Get shallow type (this was broken when this test was written)
Assert.AreEqual(BasicType.Bool, nary.ShallowType);
// Deep type check (this was not broken before writing this test)
Assert.IsNull(nary.Type);
var tc = new TypecheckingContext(this);
nary.Typecheck(tc);
Assert.AreEqual(BasicType.Bool, nary.Type);
}
public IEnumerable<Solution> Resolve(Statement st, Solution solution) {
List<Expression> call_arguments = null;
IVariable lv = null;
DatatypeDecl datatype = null;
InitArgs(st, out lv, out call_arguments);
Contract.Assert(tcce.OfSize(call_arguments, 1), Error.MkErr(st, 0, 1, call_arguments.Count));
string argType = GetArgumentType(call_arguments[0] as NameSegment);
foreach (var result in ResolveExpression(call_arguments[0])) {
if (argType == "Element") {
var ns = result as NameSegment;
IVariable originalDecl = StaticContext.GetGlobalVariable(ns.Name);
Contract.Assert(originalDecl != null, Error.MkErr(st, 9, ((NameSegment)call_arguments[0]).Name));
var datatypeName = originalDecl.Type.ToString();
datatype = StaticContext.GetGlobal(datatypeName);
var lit = IsInductive(datatypeName, datatype);
yield return AddNewLocal(lv, lit);
} else {
var ctor = result as DatatypeCtor;
Contract.Assert(ctor != null, Error.MkErr(st, 1, "Datatype constructor"));
var datatypeName = ctor.EnclosingDatatype.Name;
LiteralExpr lit = new LiteralExpr(st.Tok, false);
foreach (var formal in ctor.Formals) {
if (formal.Type.ToString() == datatypeName) {
lit = new LiteralExpr(st.Tok, true);
break;
}
}
yield return AddNewLocal(lv, lit);
}
}
}
public override Expr VisitLiteralExpr(LiteralExpr node) {
//Contract.Requires(node != null);
Contract.Ensures(Contract.Result<Expr>() != null);
return base.VisitLiteralExpr((LiteralExpr)node.Clone());
}
public void CachedHashCodeBvConcatExpr()
{
var literalBv = new LiteralExpr(Token.NoToken, Microsoft.Basetypes.BigNum.FromInt(0), 4, /*immutable=*/true);
var bvConcat = new BvConcatExpr(Token.NoToken, literalBv, literalBv, /*immutable=*/true);
Assert.AreEqual(bvConcat.ComputeHashCode(), bvConcat.GetHashCode());
}
public void CachedHashCodeOldExpr()
{
var literalBv = new LiteralExpr(Token.NoToken, Microsoft.Basetypes.BigNum.FromInt(0), 4, /*immutable=*/true);
var oldExpr = new OldExpr(Token.NoToken, literalBv, /*immutable=*/true);
Assert.AreEqual(oldExpr.ComputeHashCode(), oldExpr.GetHashCode());
}
public void ProtectedBvConcatExprRhs()
{
var lhs = new LiteralExpr(Token.NoToken, Microsoft.Basetypes.BigNum.FromInt(0), 32, /*immutable=*/true);
var rhs = new LiteralExpr(Token.NoToken, Microsoft.Basetypes.BigNum.FromInt(1), 32, /*immutable=*/true);
var concat = new BvConcatExpr(Token.NoToken, lhs, rhs,/* immutable=*/true);
Assert.IsTrue(concat.Immutable);
concat.E1 = lhs; // Should throw
}
public void ProtectedBvExtract()
{
var bv = new LiteralExpr(Token.NoToken, Microsoft.Basetypes.BigNum.FromInt(0), 32, /*immutable=*/true);
var extract = new BvExtractExpr(Token.NoToken, bv, 32, 0, /*immutable=*/true);
Assert.IsTrue(extract.Immutable);
extract.Bitvector = bv; // Should throw
}
public virtual Expr VisitLiteralExpr(LiteralExpr node) {
Contract.Requires(node != null);
Contract.Ensures(Contract.Result<Expr>() != null);
return node;
}
public override LiteralExpr VisitLiteralExpr(LiteralExpr node)
{
if (node.Val is BigNum) {
var n = ((BigNum)node.Val).ToBigInteger;
Lo = n;
Hi = n + 1;
} else if (node.Val is BigDec) {
var n = ((BigDec)node.Val).Floor(-BigInteger.Pow(10, 12), BigInteger.Pow(10, 12));
Lo = n;
Hi = n + 1;
} else if (node.Val is bool) {
if ((bool)node.Val) {
// true
Lo = one;
Hi = null;
} else {
// false
Lo = null;
Hi = one;
}
}
return node;
}
public override LiteralExpr VisitLiteralExpr(LiteralExpr node)
{
if (node.Type == Type.Int)
{
int value = ((BigNum)(node.Val)).ToIntSafe;
value = Math.Abs(value);
if (value > maxConst)
maxConst = value;
}
return base.VisitLiteralExpr(node);
}
public override Expr VisitLiteralExpr(LiteralExpr node) {
if (node.Val is BigNum) {
var n = ((BigNum)node.Val).ToBigInteger;
Lo = n;
Hi = n + 1;
} else if (node.Val is BigDec) {
BigInteger floor, ceiling;
((BigDec)node.Val).FloorCeiling(out floor, out ceiling);
Lo = floor;
Hi = ceiling;
} else if (node.Val is bool) {
if ((bool)node.Val) {
// true
Lo = one;
Hi = null;
} else {
// false
Lo = null;
Hi = one;
}
}
return node;
}
public Implementation Inject(Implementation implementation, Program programInCachedSnapshot)
{
Contract.Requires(implementation != null && programInCachedSnapshot != null);
this.programInCachedSnapshot = programInCachedSnapshot;
assumptionVariableCount = 0;
temporaryVariableCount = 0;
currentImplementation = implementation;
#region Introduce explict assumption about the precondition.
var oldProc = programInCachedSnapshot.FindProcedure(currentImplementation.Proc.Name);
if (oldProc != null
&& oldProc.DependencyChecksum != currentImplementation.Proc.DependencyChecksum
&& currentImplementation.ExplicitAssumptionAboutCachedPrecondition == null)
{
var axioms = new List<Axiom>();
var after = new List<Cmd>();
Expr assumedExpr = new LiteralExpr(Token.NoToken, false);
var canUseSpecs = DependencyCollector.CanExpressOldSpecs(oldProc, Program, true);
if (canUseSpecs && oldProc.SignatureEquals(currentImplementation.Proc))
{
var always = Substituter.SubstitutionFromHashtable(currentImplementation.GetImplFormalMap(), true, currentImplementation.Proc);
var forOld = Substituter.SubstitutionFromHashtable(new Dictionary<Variable, Expr>());
var clauses = oldProc.Requires.Select(r => Substituter.FunctionCallReresolvingApply(always, forOld, r.Condition, Program));
var conj = Expr.And(clauses, true);
assumedExpr = conj != null ? FunctionExtractor.Extract(conj, Program, axioms) : new LiteralExpr(Token.NoToken, true);
}
if (assumedExpr != null)
{
var lv = new LocalVariable(Token.NoToken,
new TypedIdent(Token.NoToken, string.Format("a##cached##{0}", FreshAssumptionVariableName), Type.Bool),
new QKeyValue(Token.NoToken, "assumption", new List<object>(), null));
currentImplementation.InjectAssumptionVariable(lv, !canUseSpecs);
var lhs = new SimpleAssignLhs(Token.NoToken, new IdentifierExpr(Token.NoToken, lv));
var rhs = LiteralExpr.And(new IdentifierExpr(Token.NoToken, lv), assumedExpr);
var assumed = new AssignCmd(currentImplementation.tok, new List<AssignLhs> { lhs }, new List<Expr> { rhs });
assumed.IrrelevantForChecksumComputation = true;
currentImplementation.ExplicitAssumptionAboutCachedPrecondition = assumed;
after.Add(assumed);
}
if (CommandLineOptions.Clo.TraceCachingForTesting || CommandLineOptions.Clo.TraceCachingForBenchmarking)
{
using (var tokTxtWr = new TokenTextWriter("<console>", Console.Out, false, false))
{
var loc = currentImplementation.tok != null && currentImplementation.tok != Token.NoToken ? string.Format("{0}({1},{2})", currentImplementation.tok.filename, currentImplementation.tok.line, currentImplementation.tok.col) : "<unknown location>";
Console.Out.WriteLine("Processing implementation {0} (at {1}):", currentImplementation.Name, loc);
foreach (var a in axioms)
{
Console.Out.Write(" >>> added axiom: ");
a.Expr.Emit(tokTxtWr);
Console.Out.WriteLine();
}
foreach (var b in after)
{
Console.Out.Write(" >>> added after assuming the current precondition: ");
b.Emit(tokTxtWr, 0);
}
}
}
}
#endregion
var result = VisitImplementation(currentImplementation);
currentImplementation = null;
this.programInCachedSnapshot = null;
return result;
}
void AtomExpression(out Expr/*!*/ e) {
Contract.Ensures(Contract.ValueAtReturn(out e) != null); IToken/*!*/ x; int n; BigNum bn; BigDec bd; BigFloat bf;
List<Expr>/*!*/ es; List<Variable>/*!*/ ds; Trigger trig;
List<TypeVariable>/*!*/ typeParams;
IdentifierExpr/*!*/ id;
QKeyValue kv;
e = dummyExpr;
List<Variable>/*!*/ locals;
List<Block/*!*/>/*!*/ blocks;
switch (la.kind) {
case 83: {
Get();
e = new LiteralExpr(t, false);
break;
}
case 84: {
Get();
e = new LiteralExpr(t, true);
break;
}
case 3: {
Nat(out bn);
e = new LiteralExpr(t, bn);
break;
}
case 5: case 6: {
Dec(out bd);
e = new LiteralExpr(t, bd);
break;
}
case 7: {
Float(out bf);
e = new LiteralExpr(t, bf);
break;
}
case 2: {
BvLit(out bn, out n);
e = new LiteralExpr(t, bn, n);
break;
}
case 1: {
Ident(out x);
id = new IdentifierExpr(x, x.val); e = id;
if (la.kind == 10) {
Get();
if (StartOf(9)) {
Expressions(out es);
e = new NAryExpr(x, new FunctionCall(id), es);
} else if (la.kind == 11) {
e = new NAryExpr(x, new FunctionCall(id), new List<Expr>());
} else SynErr(124);
Expect(11);
}
break;
}
case 85: {
Get();
x = t;
Expect(10);
Expression(out e);
Expect(11);
e = new OldExpr(x, e);
break;
}
case 15: {
Get();
x = t;
Expect(10);
Expression(out e);
Expect(11);
e = new NAryExpr(x, new ArithmeticCoercion(x, ArithmeticCoercion.CoercionType.ToInt), new List<Expr>{ e });
break;
}
case 16: {
Get();
x = t;
Expect(10);
Expression(out e);
Expect(11);
e = new NAryExpr(x, new ArithmeticCoercion(x, ArithmeticCoercion.CoercionType.ToReal), new List<Expr>{ e });
break;
}
case 10: {
Get();
if (StartOf(9)) {
Expression(out e);
if (e is BvBounds)
this.SemErr("parentheses around bitvector bounds " +
"are not allowed");
} else if (la.kind == 89 || la.kind == 90) {
Forall();
x = t;
QuantifierBody(x, out typeParams, out ds, out kv, out trig, out e);
if (typeParams.Count + ds.Count > 0)
e = new ForallExpr(x, typeParams, ds, kv, trig, e);
} else if (la.kind == 91 || la.kind == 92) {
Exists();
x = t;
QuantifierBody(x, out typeParams, out ds, out kv, out trig, out e);
if (typeParams.Count + ds.Count > 0)
e = new ExistsExpr(x, typeParams, ds, kv, trig, e);
} else if (la.kind == 93 || la.kind == 94) {
Lambda();
x = t;
QuantifierBody(x, out typeParams, out ds, out kv, out trig, out e);
if (trig != null)
SemErr("triggers not allowed in lambda expressions");
if (typeParams.Count + ds.Count > 0)
e = new LambdaExpr(x, typeParams, ds, kv, e);
} else SynErr(125);
Expect(11);
break;
}
case 41: {
IfThenElseExpression(out e);
break;
}
case 86: {
CodeExpression(out locals, out blocks);
e = new CodeExpr(locals, blocks);
break;
}
default: SynErr(126); break;
}
}
public override Cmd VisitCallCmd(CallCmd node)
{
var result = base.VisitCallCmd(node);
var oldProc = programInCachedSnapshot.FindProcedure(node.Proc.Name);
if (oldProc != null
&& oldProc.DependencyChecksum != node.Proc.DependencyChecksum
&& node.AssignedAssumptionVariable == null)
{
var before = new List<Cmd>();
var beforePrecondtionCheck = new List<Cmd>();
var after = new List<Cmd>();
var axioms = new List<Axiom>();
Expr assumedExpr = new LiteralExpr(Token.NoToken, false);
// TODO(wuestholz): Try out two alternatives: only do this for low priority implementations or not at all.
var canUseSpecs = DependencyCollector.CanExpressOldSpecs(oldProc, Program);
if (canUseSpecs && oldProc.SignatureEquals(node.Proc))
{
var desugaring = node.Desugaring;
Contract.Assert(desugaring != null);
var precond = node.CheckedPrecondition(oldProc, Program, e => FunctionExtractor.Extract(e, Program, axioms));
if (precond != null)
{
var assume = new AssumeCmd(node.tok, precond, new QKeyValue(Token.NoToken, "precondition_previous_snapshot", new List<object>(), null));
assume.IrrelevantForChecksumComputation = true;
beforePrecondtionCheck.Add(assume);
}
var unmods = node.UnmodifiedBefore(oldProc);
var eqs = new List<Expr>();
foreach (var unmod in unmods)
{
var oldUnmod = new LocalVariable(Token.NoToken,
new TypedIdent(Token.NoToken, string.Format("{0}##old##{1}", unmod.Name, FreshTemporaryVariableName), unmod.Type));
var lhs = new SimpleAssignLhs(Token.NoToken, new IdentifierExpr(Token.NoToken, oldUnmod));
var rhs = new IdentifierExpr(Token.NoToken, unmod.Decl);
var cmd = new AssignCmd(Token.NoToken, new List<AssignLhs> { lhs }, new List<Expr> { rhs });
cmd.IrrelevantForChecksumComputation = true;
before.Add(cmd);
var eq = LiteralExpr.Eq(new IdentifierExpr(Token.NoToken, oldUnmod), new IdentifierExpr(Token.NoToken, unmod.Decl));
eq.Type = Type.Bool;
eq.TypeParameters = SimpleTypeParamInstantiation.EMPTY;
eqs.Add(eq);
}
var mods = node.ModifiedBefore(oldProc);
var oldSubst = new Dictionary<Variable, Expr>();
foreach (var mod in mods)
{
var oldMod = new LocalVariable(Token.NoToken,
new TypedIdent(Token.NoToken, string.Format("{0}##old##{1}", mod.Name, FreshTemporaryVariableName), mod.Type));
oldSubst[mod.Decl] = new IdentifierExpr(Token.NoToken, oldMod);
var lhs = new SimpleAssignLhs(Token.NoToken, new IdentifierExpr(Token.NoToken, oldMod));
var rhs = new IdentifierExpr(Token.NoToken, mod.Decl);
var cmd = new AssignCmd(Token.NoToken, new List<AssignLhs> { lhs }, new List<Expr> { rhs });
cmd.IrrelevantForChecksumComputation = true;
before.Add(cmd);
}
assumedExpr = node.Postcondition(oldProc, eqs, oldSubst, Program, e => FunctionExtractor.Extract(e, Program, axioms));
if (assumedExpr == null)
{
assumedExpr = new LiteralExpr(Token.NoToken, true);
}
}
if (assumedExpr != null)
{
var lv = new LocalVariable(Token.NoToken,
new TypedIdent(Token.NoToken, string.Format("a##cached##{0}", FreshAssumptionVariableName), Type.Bool),
new QKeyValue(Token.NoToken, "assumption", new List<object>(), null));
node.AssignedAssumptionVariable = lv;
currentImplementation.InjectAssumptionVariable(lv, !canUseSpecs);
var lhs = new SimpleAssignLhs(Token.NoToken, new IdentifierExpr(Token.NoToken, lv));
var rhs = LiteralExpr.And(new IdentifierExpr(Token.NoToken, lv), assumedExpr);
var assumed = new AssignCmd(node.tok, new List<AssignLhs> { lhs }, new List<Expr> { rhs });
assumed.IrrelevantForChecksumComputation = true;
after.Add(assumed);
}
node.ExtendDesugaring(before, beforePrecondtionCheck, after);
if (CommandLineOptions.Clo.TraceCachingForTesting || CommandLineOptions.Clo.TraceCachingForBenchmarking)
{
using (var tokTxtWr = new TokenTextWriter("<console>", Console.Out, false, false))
{
var loc = node.tok != null && node.tok != Token.NoToken ? string.Format("{0}({1},{2})", node.tok.filename, node.tok.line, node.tok.col) : "<unknown location>";
Console.Out.WriteLine("Processing call to procedure {0} in implementation {1} (at {2}):", node.Proc.Name, currentImplementation.Name, loc);
foreach (var a in axioms)
{
Console.Out.Write(" >>> added axiom: ");
a.Expr.Emit(tokTxtWr);
Console.Out.WriteLine();
}
foreach (var b in before)
{
Console.Out.Write(" >>> added before: ");
b.Emit(tokTxtWr, 0);
}
foreach (var b in beforePrecondtionCheck)
{
Console.Out.Write(" >>> added before precondition check: ");
b.Emit(tokTxtWr, 0);
}
foreach (var a in after)
{
Console.Out.Write(" >>> added after: ");
a.Emit(tokTxtWr, 0);
}
}
}
}
return result;
}
void ConstAtomExpression(out Expression e, bool allowSemi, bool allowLambda)
{
Contract.Ensures(Contract.ValueAtReturn(out e) != null);
IToken/*!*/ x; BigInteger n; Basetypes.BigDec d;
e = dummyExpr; Type toType = null;
switch (la.kind) {
case 131: {
Get();
e = new LiteralExpr(t, false);
break;
}
case 132: {
Get();
e = new LiteralExpr(t, true);
break;
}
case 133: {
Get();
e = new LiteralExpr(t);
break;
}
case 2: case 3: {
Nat(out n);
e = new LiteralExpr(t, n);
break;
}
case 4: {
Dec(out d);
e = new LiteralExpr(t, d);
break;
}
case 19: {
Get();
e = new CharLiteralExpr(t, t.val.Substring(1, t.val.Length - 2));
break;
}
case 20: {
Get();
bool isVerbatimString;
string s = Util.RemoveParsedStringQuotes(t.val, out isVerbatimString);
e = new StringLiteralExpr(t, s, isVerbatimString);
break;
}
case 134: {
Get();
e = new ThisExpr(t);
break;
}
case 135: {
Get();
x = t;
Expect(50);
Expression(out e, true, true);
Expect(51);
e = new UnaryOpExpr(x, UnaryOpExpr.Opcode.Fresh, e);
break;
}
case 136: {
Get();
x = t;
Expect(50);
Expression(out e, true, true);
Expect(51);
e = new OldExpr(x, e);
break;
}
case 23: {
Get();
x = t;
Expression(out e, true, true);
e = new UnaryOpExpr(x, UnaryOpExpr.Opcode.Cardinality, e);
Expect(23);
break;
}
case 8: case 10: {
if (la.kind == 8) {
Get();
x = t; toType = new IntType();
} else {
Get();
x = t; toType = new RealType();
}
Expect(50);
Expression(out e, true, true);
Expect(51);
e = new ConversionExpr(x, e, toType);
break;
}
case 50: {
ParensExpression(out e, allowSemi, allowLambda);
break;
}
default: SynErr(234); break;
}
}
public override Expr VisitLiteralExpr(LiteralExpr node)
{
Contract.Ensures(Contract.Result<Expr>() == node);
return node;
}
public void SimpleBVConcat() {
var variable = new GlobalVariable(Token.NoToken, new TypedIdent(Token.NoToken, "foo", Microsoft.Boogie.Type.GetBvType(8)));
var id = new IdentifierExpr(Token.NoToken, variable);
var constant = new LiteralExpr(Token.NoToken, BigNum.FromInt(5), 8); // 5bv8;
var concat = new BvConcatExpr(Token.NoToken, id, constant);
// Don't trust the Boogie duplicator here. Do it ourselves
var constant2 = new LiteralExpr(Token.NoToken, BigNum.FromInt(5), 8); // 5bv8;
// We don't duplicate the variable because that is not an Expr and we require reference equality.
var id2 = new IdentifierExpr(Token.NoToken, variable);
var concat2 = new BvConcatExpr(Token.NoToken, id2, constant2);
Assert.AreNotSame(concat, concat2); // These are different references
Assert.IsTrue(concat.Equals(concat2)); // These are "structurally equal"
Assert.AreEqual(concat.GetHashCode(), concat2.GetHashCode()); // If the .Equals() is true then hash codes must be the same
}
public LazyInliningInfo(Implementation impl, Program program, ProverContext ctxt, int uniqueId, GlobalVariable errorVariable)
{
Contract.Requires(impl != null);
Contract.Requires(program != null);
Procedure proc = cce.NonNull(impl.Proc);
this.impl = impl;
this.uniqueId = uniqueId;
this.controlFlowVariable = new LocalVariable(Token.NoToken, new TypedIdent(Token.NoToken, "cfc", Microsoft.Boogie.Type.Int));
impl.LocVars.Add(controlFlowVariable);
List<Variable> interfaceVars = new List<Variable>();
Expr assertExpr = new LiteralExpr(Token.NoToken, true);
Contract.Assert(assertExpr != null);
foreach (Variable v in program.GlobalVariables())
{
Contract.Assert(v != null);
interfaceVars.Add(v);
if (v.Name == "error")
inputErrorVariable = v;
}
// InParams must be obtained from impl and not proc
foreach (Variable v in impl.InParams)
{
Contract.Assert(v != null);
interfaceVars.Add(v);
}
// OutParams must be obtained from impl and not proc
foreach (Variable v in impl.OutParams)
{
Contract.Assert(v != null);
Constant c = new Constant(Token.NoToken,
new TypedIdent(Token.NoToken, impl.Name + "_" + v.Name, v.TypedIdent.Type));
interfaceVars.Add(c);
Expr eqExpr = Expr.Eq(new IdentifierExpr(Token.NoToken, c), new IdentifierExpr(Token.NoToken, v));
assertExpr = Expr.And(assertExpr, eqExpr);
}
if (errorVariable != null)
{
proc.Modifies.Add(new IdentifierExpr(Token.NoToken, errorVariable));
}
foreach (IdentifierExpr e in proc.Modifies)
{
Contract.Assert(e != null);
if (e.Decl == null)
continue;
Variable v = e.Decl;
Constant c = new Constant(Token.NoToken, new TypedIdent(Token.NoToken, impl.Name + "_" + v.Name, v.TypedIdent.Type));
interfaceVars.Add(c);
if (v.Name == "error")
{
outputErrorVariable = c;
continue;
}
Expr eqExpr = Expr.Eq(new IdentifierExpr(Token.NoToken, c), new IdentifierExpr(Token.NoToken, v));
assertExpr = Expr.And(assertExpr, eqExpr);
}
this.interfaceVars = interfaceVars;
this.assertExpr = Expr.Not(assertExpr);
List<Variable> functionInterfaceVars = new List<Variable>();
foreach (Variable v in interfaceVars)
{
Contract.Assert(v != null);
functionInterfaceVars.Add(new Formal(Token.NoToken, new TypedIdent(Token.NoToken, v.Name, v.TypedIdent.Type), true));
}
TypedIdent ti = new TypedIdent(Token.NoToken, "", Microsoft.Boogie.Type.Bool);
Contract.Assert(ti != null);
Formal returnVar = new Formal(Token.NoToken, ti, false);
Contract.Assert(returnVar != null);
this.function = new Function(Token.NoToken, proc.Name, functionInterfaceVars, returnVar);
ctxt.DeclareFunction(this.function, "");
interfaceVarCopies = new List<List<Variable>>();
int temp = 0;
for (int i = 0; i < /* CommandLineOptions.Clo.ProcedureCopyBound */ 0; i++)
{
interfaceVarCopies.Add(new List<Variable>());
foreach (Variable v in interfaceVars)
{
Constant constant = new Constant(Token.NoToken, new TypedIdent(Token.NoToken, v.Name + temp++, v.TypedIdent.Type));
interfaceVarCopies[i].Add(constant);
//program.TopLevelDeclarations.Add(constant);
}
}
}
void ConstAtomExpression(out Expression e, bool allowSemi, bool allowLambda)
{
Contract.Ensures(Contract.ValueAtReturn(out e) != null);
IToken/*!*/ x; BigInteger n; Basetypes.BigDec d;
e = dummyExpr; Type toType = null;
switch (la.kind) {
case 138: {
Get();
e = new LiteralExpr(t, false);
break;
}
case 139: {
Get();
e = new LiteralExpr(t, true);
break;
}
case 140: {
Get();
e = new LiteralExpr(t);
break;
}
case 2: case 3: {
Nat(out n);
e = new LiteralExpr(t, n);
break;
}
case 4: {
Dec(out d);
e = new LiteralExpr(t, d);
break;
}
case 20: {
Get();
e = new CharLiteralExpr(t, t.val.Substring(1, t.val.Length - 2));
break;
}
case 21: {
Get();
bool isVerbatimString;
string s = Util.RemoveParsedStringQuotes(t.val, out isVerbatimString);
e = new StringLiteralExpr(t, s, isVerbatimString);
break;
}
case 141: {
Get();
e = new ThisExpr(t);
break;
}
case 142: {
Get();
x = t;
Expect(54);
Expression(out e, true, true);
Expect(55);
e = new UnaryOpExpr(x, UnaryOpExpr.Opcode.Fresh, e);
break;
}
case 143: {
Get();
x = t;
Expect(54);
Expression(out e, true, true);
Expect(55);
e = new UnaryOpExpr(x, UnaryOpExpr.Opcode.Allocated, e);
break;
}
case 144: {
Get();
x = t; FrameExpression fe; var mod = new List<FrameExpression>();
Expect(54);
FrameExpression(out fe, false, false);
mod.Add(fe);
while (la.kind == 23) {
Get();
FrameExpression(out fe, false, false);
mod.Add(fe);
}
Expect(55);
e = new UnchangedExpr(x, mod);
break;
}
case 145: {
Get();
x = t;
Expect(54);
Expression(out e, true, true);
Expect(55);
e = new OldExpr(x, e);
break;
}
case 24: {
Get();
x = t;
Expression(out e, true, true, false);
e = new UnaryOpExpr(x, UnaryOpExpr.Opcode.Cardinality, e);
Expect(24);
break;
}
case 9: case 11: {
if (la.kind == 9) {
Get();
x = t; toType = new IntType();
} else {
Get();
x = t; toType = new RealType();
}
errors.Deprecated(t, string.Format("the syntax \"{0}(expr)\" for type conversions has been deprecated; the new syntax is \"expr as {0}\"", x.val));
Expect(54);
Expression(out e, true, true);
Expect(55);
e = new ConversionExpr(x, e, toType);
break;
}
case 54: {
ParensExpression(out e, allowSemi, allowLambda);
break;
}
default: SynErr(262); break;
}
}
void ForallStmt(out Statement/*!*/ s)
{
Contract.Ensures(Contract.ValueAtReturn(out s) != null);
IToken/*!*/ x = Token.NoToken;
List<BoundVar> bvars = null;
Attributes attrs = null;
Expression range = null;
var ens = new List<MaybeFreeExpression/*!*/>();
bool isFree;
Expression/*!*/ e;
BlockStmt block = null;
IToken bodyStart, bodyEnd;
IToken tok = Token.NoToken;
if (la.kind == 103) {
Get();
x = t; tok = x;
} else if (la.kind == 104) {
Get();
x = t;
errors.Warning(t, "the 'parallel' keyword has been deprecated; the comprehension statement now uses the keyword 'forall' (and the parentheses around the bound variables are now optional)");
} else SynErr(190);
if (la.kind == _openparen) {
Expect(50);
if (la.kind == 1) {
QuantifierDomain(out bvars, out attrs, out range);
}
Expect(51);
} else if (StartOf(24)) {
if (la.kind == _ident) {
QuantifierDomain(out bvars, out attrs, out range);
}
} else SynErr(191);
if (bvars == null) { bvars = new List<BoundVar>(); }
if (range == null) { range = new LiteralExpr(x, true); }
while (la.kind == 88 || la.kind == 89) {
isFree = false;
if (la.kind == 88) {
Get();
isFree = true;
errors.Warning(t, "the 'free' keyword is soon to be deprecated");
}
Expect(89);
Expression(out e, false, true);
ens.Add(new MaybeFreeExpression(e, isFree));
OldSemi();
tok = t;
}
if (la.kind == _lbrace) {
BlockStmt(out block, out bodyStart, out bodyEnd);
}
if (DafnyOptions.O.DisallowSoundnessCheating && block == null && 0 < ens.Count) {
SemErr(t, "a forall statement with an ensures clause must have a body");
}
if (block != null) {
tok = block.EndTok;
}
s = new ForallStmt(x, tok, bvars, attrs, range, ens, block);
}
