コード例 #1
0
 public virtual Cmd VisitAssertRequiresCmd(AssertRequiresCmd node)
 {
     Contract.Requires(node != null);
       Contract.Ensures(Contract.Result<Cmd>() != null);
       node.Requires = this.VisitRequires(node.Requires);
       node.Expr = this.VisitExpr(node.Expr);
       return node;
 }
コード例 #2
0
ファイル: Duplicator.cs プロジェクト: qunyanm/boogie
 public override Cmd VisitAssertRequiresCmd(AssertRequiresCmd node)
 {
     //Contract.Requires(node != null);
     Contract.Ensures(Contract.Result<Cmd>() != null);
     return base.VisitAssertRequiresCmd((AssertRequiresCmd)node.Clone());
 }
コード例 #3
0
ファイル: StandardVisitor.cs プロジェクト: qunyanm/boogie
 public override Cmd VisitAssertRequiresCmd(AssertRequiresCmd node)
 {
     Contract.Ensures(Contract.Result<Cmd>() == node);
     this.VisitRequires(node.Requires);
     this.VisitExpr(node.Expr);
     return node;
 }
コード例 #4
0
ファイル: Inline.cs プロジェクト: qunyanm/boogie
 private Cmd InlinedRequires(CallCmd callCmd, Requires req) {
   Requires/*!*/ reqCopy = (Requires/*!*/)cce.NonNull(req.Clone());
   if (req.Free)
     reqCopy.Condition = Expr.True;
   else 
     reqCopy.Condition = codeCopier.CopyExpr(req.Condition);
   AssertCmd/*!*/ a = new AssertRequiresCmd(callCmd, reqCopy);
   a.ErrorDataEnhanced = reqCopy.ErrorDataEnhanced;
   return a;
 }
コード例 #5
0
ファイル: AbsyCmd.cs プロジェクト: Chenguang-Zhu/ICE-C5
        protected override Cmd ComputeDesugaring()
        {
            Contract.Ensures(Contract.Result<Cmd>() != null);
              List<Cmd> newBlockBody = new List<Cmd>();
              Dictionary<Variable, Expr> substMap = new Dictionary<Variable, Expr>();
              Dictionary<Variable, Expr> substMapOld = new Dictionary<Variable, Expr>();
              Dictionary<Variable, Expr> substMapBound = new Dictionary<Variable, Expr>();
              List<Variable>/*!*/ tempVars = new List<Variable>();

              // proc P(ins) returns (outs)
              //   requires Pre
              //   //modifies frame
              //   ensures Post
              //
              // call aouts := P(ains)

              // ins    : formal in parameters of procedure
              // frame  : a list of global variables from the modifies clause
              // outs   : formal out parameters of procedure
              // ains   : actual in arguments passed to call
              // aouts  : actual variables assigned to from call
              // cins   : new variables created just for this call, one per ains
              // cframe : new variables created just for this call, to keep track of OLD values
              // couts  : new variables created just for this call, one per aouts
              // WildcardVars : new variables created just for this call, one per null in ains

              #region Create cins; each one is an incarnation of the corresponding in parameter
              List<Variable>/*!*/ cins = new List<Variable>();
              List<Variable> wildcardVars = new List<Variable>();
              Contract.Assume(this.Proc != null);
              for (int i = 0; i < this.Proc.InParams.Count; ++i) {
            Variable/*!*/ param = cce.NonNull(this.Proc.InParams[i]);
            bool isWildcard = this.Ins[i] == null;

            Type/*!*/ actualType;
            if (isWildcard)
              actualType = param.TypedIdent.Type.Substitute(TypeParamSubstitution());
            else
              // during type checking, we have ensured that the type of the actual
              // parameter Ins[i] is correct, so we can use it here
              actualType = cce.NonNull(cce.NonNull(Ins[i]).Type);

            Variable cin = CreateTemporaryVariable(tempVars, param, actualType,
                                               TempVarKind.Formal);
            cins.Add(cin);
            IdentifierExpr ie = new IdentifierExpr(cin.tok, cin);
            substMap.Add(param, ie);
            if (isWildcard) {
              cin = CreateTemporaryVariable(tempVars, param,
                                        actualType, TempVarKind.Bound);
              wildcardVars.Add(cin);
              ie = new IdentifierExpr(cin.tok, cin);
            }
            substMapBound.Add(param, ie);
              }
              #endregion
              #region call aouts := P(ains) becomes: (open outlining one level to see)
              #region cins := ains (or havoc cin when ain is null)
              for (int i = 0, n = this.Ins.Count; i < n; i++) {
            IdentifierExpr/*!*/ cin_exp = new IdentifierExpr(cce.NonNull(cins[i]).tok, cce.NonNull(cins[i]));
            Contract.Assert(cin_exp != null);
            if (this.Ins[i] != null) {
              AssignCmd assign = Cmd.SimpleAssign(Token.NoToken, cin_exp, cce.NonNull(this.Ins[i]));
              newBlockBody.Add(assign);
            } else {
              List<IdentifierExpr>/*!*/ ies = new List<IdentifierExpr>();
              ies.Add(cin_exp);
              HavocCmd havoc = new HavocCmd(Token.NoToken, ies);
              newBlockBody.Add(havoc);
            }
              }
              #endregion

              #region assert (exists wildcardVars :: Pre[ins := cins])
              Substitution s = Substituter.SubstitutionFromHashtable(substMapBound);
              bool hasWildcard = (wildcardVars.Count != 0);
              Expr preConjunction = null;
              for (int i = 0; i < this.Proc.Requires.Count; i++) {
            Requires/*!*/ req = cce.NonNull(this.Proc.Requires[i]);
            if (!req.Free && !IsFree) {
              if (hasWildcard) {
            Expr pre = Substituter.Apply(s, req.Condition);
            if (preConjunction == null) {
              preConjunction = pre;
            } else {
              preConjunction = Expr.And(preConjunction, pre);
            }
              } else {
            Requires/*!*/ reqCopy = (Requires/*!*/)cce.NonNull(req.Clone());
            reqCopy.Condition = Substituter.Apply(s, req.Condition);
            AssertCmd/*!*/ a = new AssertRequiresCmd(this, reqCopy);
            Contract.Assert(a != null);
            a.ErrorDataEnhanced = reqCopy.ErrorDataEnhanced;
            newBlockBody.Add(a);
              }
            }
            else if (CommandLineOptions.Clo.StratifiedInlining > 0)
            {
            // inject free requires as assume statements at the call site
            AssumeCmd/*!*/ a = new AssumeCmd(req.tok, Substituter.Apply(s, req.Condition));
            Contract.Assert(a != null);
            newBlockBody.Add(a);
            }
              }
              if (hasWildcard) {
            if (preConjunction == null) {
              preConjunction = Expr.True;
            }
            Expr/*!*/ expr = new ExistsExpr(tok, wildcardVars, preConjunction);
            Contract.Assert(expr != null);
            AssertCmd/*!*/ a = new AssertCmd(tok, expr);
            Contract.Assert(a != null);
            a.ErrorDataEnhanced = AssertCmd.GenerateBoundVarMiningStrategy(expr);
            newBlockBody.Add(a);
              }
              #endregion

              #region assume Pre[ins := cins] with formal paramters
              if (hasWildcard) {
            s = Substituter.SubstitutionFromHashtable(substMap);
            for (int i = 0; i < this.Proc.Requires.Count; i++) {
              Requires/*!*/ req = cce.NonNull(this.Proc.Requires[i]);
              if (!req.Free) {
            Requires/*!*/ reqCopy = (Requires/*!*/)cce.NonNull(req.Clone());
            reqCopy.Condition = Substituter.Apply(s, req.Condition);
            AssumeCmd/*!*/ a = new AssumeCmd(tok, reqCopy.Condition);
            Contract.Assert(a != null);
            newBlockBody.Add(a);
              }
            }
              }
              #endregion

              #region cframe := frame (to hold onto frame values in case they are referred to in the postcondition)
              List<IdentifierExpr> havocVarExprs = new List<IdentifierExpr>();

              foreach (IdentifierExpr/*!*/ f in this.Proc.Modifies) {
            Contract.Assert(f != null);
            Contract.Assume(f.Decl != null);
            Contract.Assert(f.Type != null);
            Variable v = CreateTemporaryVariable(tempVars, f.Decl, f.Type, TempVarKind.Old);
            IdentifierExpr v_exp = new IdentifierExpr(v.tok, v);
            substMapOld.Add(f.Decl, v_exp);  // this assumes no duplicates in this.Proc.Modifies
            AssignCmd assign = Cmd.SimpleAssign(f.tok, v_exp, f);
            newBlockBody.Add(assign);

            // fra
            if (!havocVarExprs.Contains(f))
              havocVarExprs.Add(f);
              }
              #endregion
              #region Create couts
              List<Variable>/*!*/ couts = new List<Variable>();
              for (int i = 0; i < this.Proc.OutParams.Count; ++i) {
            Variable/*!*/ param = cce.NonNull(this.Proc.OutParams[i]);
            bool isWildcard = this.Outs[i] == null;

            Type/*!*/ actualType;
            if (isWildcard)
              actualType = param.TypedIdent.Type.Substitute(TypeParamSubstitution());
            else
              // during type checking, we have ensured that the type of the actual
              // out parameter Outs[i] is correct, so we can use it here
              actualType = cce.NonNull(cce.NonNull(Outs[i]).Type);

            Variable cout = CreateTemporaryVariable(tempVars, param, actualType,
                                                TempVarKind.Formal);
            couts.Add(cout);
            IdentifierExpr ie = new IdentifierExpr(cout.tok, cout);
            substMap.Add(param, ie);

            if (!havocVarExprs.Contains(ie))
              havocVarExprs.Add(ie);
              }
              // add the where clauses, now that we have the entire substitution map
              foreach (Variable/*!*/ param in this.Proc.OutParams) {
            Contract.Assert(param != null);
            Expr w = param.TypedIdent.WhereExpr;
            if (w != null) {
              IdentifierExpr ie = (IdentifierExpr/*!*/)cce.NonNull(substMap[param]);
              Contract.Assert(ie.Decl != null);
              ie.Decl.TypedIdent.WhereExpr = Substituter.Apply(Substituter.SubstitutionFromHashtable(substMap), w);
            }
              }
              #endregion

              #region havoc frame, couts
              // pass on this's token
              HavocCmd hc = new HavocCmd(this.tok, havocVarExprs);
              newBlockBody.Add(hc);
              #endregion

              #region assume Post[ins, outs, old(frame) := cins, couts, cframe]
              Substitution s2 = Substituter.SubstitutionFromHashtable(substMap);
              Substitution s2old = Substituter.SubstitutionFromHashtable(substMapOld);
              foreach (Ensures/*!*/ e in this.Proc.Ensures) {
            Contract.Assert(e != null);
            Expr copy = Substituter.ApplyReplacingOldExprs(s2, s2old, e.Condition);
            AssumeCmd assume = new AssumeCmd(this.tok, copy);
            #region stratified inlining support
            if (QKeyValue.FindBoolAttribute(e.Attributes, "si_fcall"))
            {
            assume.Attributes = Attributes;
            }
            if (QKeyValue.FindBoolAttribute(e.Attributes, "candidate"))
            {
            assume.Attributes = new QKeyValue(Token.NoToken, "candidate", new List<object>(), assume.Attributes);
            assume.Attributes.Params.Add(this.callee);
            }
            #endregion
            newBlockBody.Add(assume);
              }
              #endregion

              #region aouts := couts
              for (int i = 0, n = this.Outs.Count; i < n; i++) {
            if (this.Outs[i] != null) {
              Variable/*!*/ param_i = cce.NonNull(this.Proc.OutParams[i]);
              Expr/*!*/ cout_exp = new IdentifierExpr(cce.NonNull(couts[i]).tok, cce.NonNull(couts[i]));
              Contract.Assert(cout_exp != null);
              AssignCmd assign = Cmd.SimpleAssign(param_i.tok, cce.NonNull(this.Outs[i]), cout_exp);
              newBlockBody.Add(assign);
            }
              }
              #endregion
              #endregion

              return new StateCmd(this.tok, tempVars, newBlockBody);
        }
コード例 #6
0
ファイル: Checker.cs プロジェクト: Chenguang-Zhu/ICE-C5
 public override Cmd VisitAssertRequiresCmd(AssertRequiresCmd node)
 {
     AddHoudiniConstant(node);
       return base.VisitAssertRequiresCmd(node);
 }