public bool Visit(VCExprLet node, TextWriter wr) { //Contract.Requires(wr != null); //Contract.Requires(node != null); wr.Write("(Let "); string /*!*/ sep = ""; foreach (VCExprLetBinding /*!*/ b in node) { Contract.Assert(b != null); wr.Write(sep); sep = ", "; Print(b.V, wr); wr.Write(" = "); Print(b.E, wr); } wr.Write(" "); Print(node.Body, wr); wr.Write(")"); return(true); }
///////////////////////////////////////////////////////////////////////////////////// public bool Visit(VCExprLet node, LineariserOptions options) { Namer.PushScope(); try { foreach (VCExprLetBinding b in node) { wr.Write("(let ("); Contract.Assert(b != null); wr.Write("({0} ", Namer.GetQuotedName(b.V, b.V.Name)); Linearise(b.E, options); wr.Write("))\n"); } Linearise(node.Body, options); foreach (VCExprLetBinding b in node) { wr.Write(")"); } return(true); } finally { Namer.PopScope(); } }
/// <summary> /// Returns a mapping from blocks to corresponding verification conditions /// Assumes that the expression defines a separate let binding for each block, where the name of the variable is given /// by /// "blockName_correct" /// </summary> public static IDictionary <Block, VCExpr> BlockToVCMapping(VCExprLet letExpr, CFGRepr cfg) { var blockToVC = new Dictionary <Block, VCExpr>(); foreach (var binding in letExpr) { var predictionSuccess = PredictBlockName(binding.V.Name, out var predictedBlockName); if (predictionSuccess) { try { var block = cfg.GetBlocksForwards().Single(b => b.Label.Equals(predictedBlockName)); blockToVC.Add(block, binding.E); } catch (Exception e) { throw new ProofGenUnexpectedStateException(typeof(VCBlockExtractor), e.Message); } } else { throw new ProofGenUnexpectedStateException(typeof(VCBlockExtractor), "let binding does not correspond to block"); } } if (blockToVC.Count != cfg.NumOfBlocks()) { throw new ProofGenUnexpectedStateException(typeof(VCBlockExtractor), "could not find let binding for all blocks"); } return(blockToVC); }
public Term Visit(VCExprLet node, LineariserOptions options) { foreach (VCExprLetBinding b in node) { Term defAst = Linearise(b.E, options); letBindings.Add(b.V, defAst); } Term letAst = Linearise(node.Body, options); foreach (VCExprLetBinding b in node) { letBindings.Remove(b.V); } return(letAst); }
protected override Dictionary <VCExprVar, Polarity> VisitAfterBinding(VCExprLet node, Polarity arg) { var result = node.Body.Accept(this, arg); for (int i = node.Length - 1; i >= 0; i--) { if (result.ContainsKey(node[i].V)) { result = Join(result, node[i].E.Accept(this, result[node[i].V])); } } foreach (var x in node.BoundVars) { result.Remove(x); } return(result); }
///////////////////////////////////////////////////////////////////////////////////// public bool Visit(VCExprLet node, LineariserOptions options) { //Contract.Requires(options != null); //Contract.Requires(node != null); Namer.PushScope(); try { wr.Write("(LET ("); LineariserOptions optionsWithVars = options.AddLetVariables(node.BoundVars); Contract.Assert(optionsWithVars != null); string s = "("; foreach (VCExprLetBinding b in node) { Contract.Assert(b != null); wr.Write(s); string printedName = Namer.GetLocalName(b.V, b.V.Name); bool formula = b.V.Type.IsBool; if (formula) { wr.Write("FORMULA "); } else { wr.Write("TERM "); } WriteId(printedName); wr.Write(" "); Linearise(b.E, optionsWithVars.SetAsTerm(!formula)); wr.Write(")"); s = " ("; } wr.Write(") "); Linearise(node.Body, optionsWithVars); wr.Write(")"); return(true); } finally { Namer.PopScope(); } }
public override VCExpr Visit(VCExprLet node, FlattenerState state) { Contract.Requires(node != null); Contract.Ensures(Contract.Result <VCExpr>() != null); if (state.InTerm) { return(GetVarFor(node)); } VCExprLet prelimRes = (VCExprLet)cce.NonNull(base.Visit(node, state)); List <VCExprLetBinding /*!*/> /*!*/ allBindings = new List <VCExprLetBinding /*!*/>(); allBindings.AddRange(prelimRes); // Check whether any of the extracted terms contain variables // bound by this binder. In this case, we have to add // let-binders and remove the extracted terms bool cont = true; while (cont) { List <VCExprLetBinding /*!*/> /*!*/ localBindings = RemoveBindingsWithVars(prelimRes.BoundVars, new List <TypeVariable /*!*/>()); if (localBindings.Count > 0) { allBindings.AddRange(FlattenBindings(localBindings, state)); } else { cont = false; } } return(Gen.Let(allBindings, prelimRes.Body)); }
public Term Visit(VCExprLet node, bool arg) { throw new ProofGenUnexpectedStateException(GetType(), "only expect variables and function operations in extractors"); }
public override VCExpr Visit(VCExprLet node, bool arg) { Contract.Requires(node != null); Contract.Ensures(Contract.Result <VCExpr>() != null); IDictionary <VCExprVar /*!*/, Binding /*!*/> boundVars = new Dictionary <VCExprVar /*!*/, Binding /*!*/>(); // recurse and collect the free variables in bound terms and formulae foreach (VCExprLetBinding /*!*/ binding in node) { Contract.Assert(binding != null); VCExpr /*!*/ newE = Mutate(binding.E, arg); Binding /*!*/ b = new Binding(binding.V, newE, FreeVarsIn(newE)); boundVars.Add(b.V, b); } // generate the occurrence edges foreach (KeyValuePair <VCExprVar /*!*/, Binding /*!*/> pair in boundVars) { Contract.Assert(cce.NonNullElements(pair)); Binding /*!*/ b = pair.Value; Contract.Assert(b != null); foreach (VCExprVar /*!*/ v in b.FreeVars) { Contract.Assert(v != null); Binding b2; if (boundVars.TryGetValue(v, out b2)) { cce.NonNull(b2).Occurrences.Add(b); b.InvOccurrencesNum = b.InvOccurrencesNum + 1; } } } // topological sort Stack <Binding /*!*/> rootBindings = new Stack <Binding /*!*/>(); foreach (KeyValuePair <VCExprVar /*!*/, Binding /*!*/> pair in boundVars) { Contract.Assert(cce.NonNullElements(pair)); if (pair.Value.InvOccurrencesNum == 0) { rootBindings.Push(pair.Value); } } List <Binding /*!*/> /*!*/ sortedBindings = new List <Binding /*!*/>(); while (rootBindings.Count > 0) { Binding /*!*/ b = rootBindings.Pop(); Contract.Assert(b != null); sortedBindings.Add(b); foreach (Binding /*!*/ b2 in b.Occurrences) { Contract.Assert(b2 != null); b2.InvOccurrencesNum = b2.InvOccurrencesNum - 1; if (b2.InvOccurrencesNum == 0) { rootBindings.Push(b2); } } } if (boundVars.Any(pair => pair.Value.InvOccurrencesNum > 0)) { System.Diagnostics.Debug.Fail("Cyclic let-bindings"); } Contract.Assert(node.Length == sortedBindings.Count); // check which of the bindings can be dropped VCExpr newBody = Mutate(node.Body, arg); Contract.Assert(newBody != null); IDictionary <VCExprVar /*!*/, VCExprVar /*!*/> /*!*/ usedVars = new Dictionary <VCExprVar /*!*/, VCExprVar /*!*/>(); foreach (VCExprVar /*!*/ v in FreeVarsIn(newBody)) { Contract.Assert(v != null); if (!usedVars.ContainsKey(v)) { usedVars.Add(v, v); } } for (int i = sortedBindings.Count - 1; i >= 0; --i) { if (usedVars.ContainsKey(sortedBindings[i].V)) { foreach (VCExprVar /*!*/ v in sortedBindings[i].FreeVars) { Contract.Assert(v != null); if (!usedVars.ContainsKey(v)) { usedVars.Add(v, v); } } } else { sortedBindings.RemoveAt(i); } } // assemble the resulting let-expression List <VCExprLetBinding /*!*/> /*!*/ newBindings = new List <VCExprLetBinding /*!*/>(); foreach (Binding b in sortedBindings) { newBindings.Add(Gen.LetBinding(b.V, b.E)); } return(Gen.Let(newBindings, newBody)); }
///////////////////////////////////////////////////////////////////////////////////// public bool Visit(VCExprLet node, LineariserOptions options) { throw new NotImplementedException(); }
//unsafe private static string getMemory(object o) //{ // //GCHandle h = GCHandle.Alloc(o, GCHandleType.Pinned); // TypedReference tr = __makeref(o); // IntPtr addr = **(IntPtr**)(&tr); // return "0x" + addr.ToString("X"); //} public override VCExpr Visit(VCExprLet node, bool arg) { Contract.Requires(node != null); Contract.Ensures(Contract.Result <VCExpr>() != null); IDictionary <VCExprVar /*!*/, Binding /*!*/> boundVars = new Dictionary <VCExprVar /*!*/, Binding /*!*/> (); //List<VCExpr> test = new List<VCExpr>(); // recurse and collect the free variables in bound terms and formulae foreach (VCExprLetBinding /*!*/ binding in node) { Contract.Assert(binding != null); //Console.WriteLine("Before mutate, the original expr variables is : {0}, address is {1}", binding.V.Name, getMemory(binding.V)); //Console.WriteLine("Before mutate, the original expr is : {0}", binding.E.ToString()); //Console.WriteLine("Before mutate, the original expr 's free variables are :"); //List<VCExprVar> oExprs = FreeVarsIn(binding.E); //for (int i = 0; i < oExprs.Count; i++) //{ // //Console.WriteLine(getMemory(oExprs[i])); // Console.WriteLine("Name : {0}, address {1}", oExprs[i].Name, getMemory(oExprs[i])); //} VCExpr /*!*/ newE = Mutate(binding.E, arg); List <VCExprVar> exprs = FreeVarsIn(newE); Binding /*!*/ b = new Binding(binding.V, newE, exprs); //Console.WriteLine("After mutate, the new expr is : {0}", newE.ToString()); //Console.WriteLine("After mutate, the new exprssion's free variables are :"); //for (int i = 0; i < exprs.Count; i++) { // Console.WriteLine("Name : {0}, address {1}", exprs[i].Name, getMemory(exprs[i])); //} //Console.WriteLine("After init new object, the new expr var is {0}, address is {1}:", b.V.Name, getMemory(b.V)); //Console.WriteLine("After init new object, the free variables are :"); //for (int i = 0; i < b.FreeVars.Count; i++) //{ // Console.WriteLine("Name : {0}, address {1}", b.FreeVars[i].Name, getMemory(b.FreeVars[i])); //} //foreach (VCExprVar/*!*/ p in exprs) // Contract.Assert(p != null); // Console.WriteLine(getMemory(p)); //} //foreach (VCExprVar/*!*/ v in b.FreeVars) //{ // Contract.Assert(v != null); // Console.WriteLine(getMemory(v)); //} boundVars.Add(b.V, b); //test.Add(b.V); } // generate the occurrence edges foreach (KeyValuePair <VCExprVar /*!*/, Binding /*!*/> pair in boundVars) { Contract.Assert(cce.NonNullElements(pair)); Binding /*!*/ b = pair.Value; Contract.Assert(b != null); foreach (VCExprVar /*!*/ v in b.FreeVars) { Contract.Assert(v != null); Binding b2; // Console.WriteLine("current is :\n {0}", v.ToString()); //Console.WriteLine(getMemory(v)); //foreach(VCExpr e in test){ // Console.WriteLine(e.ToString()); // Console.WriteLine(getMemory(e)); // bool equal = v == e; // if (equal) { // Console.WriteLine("Correct"); // } //} //bool equal = v == if (boundVars.TryGetValue(v, out b2)) { cce.NonNull(b2).Occurrences.Add(b); b.InvOccurrencesNum = b.InvOccurrencesNum + 1; } } } // topological sort Stack <Binding /*!*/> rootBindings = new Stack <Binding /*!*/> (); foreach (KeyValuePair <VCExprVar /*!*/, Binding /*!*/> pair in boundVars) { Contract.Assert(cce.NonNullElements(pair)); if (pair.Value.InvOccurrencesNum == 0) { rootBindings.Push(pair.Value); } } List <Binding /*!*/> /*!*/ sortedBindings = new List <Binding /*!*/> (); while (rootBindings.Count > 0) { Binding /*!*/ b = rootBindings.Pop(); Contract.Assert(b != null); sortedBindings.Add(b); foreach (Binding /*!*/ b2 in b.Occurrences) { Contract.Assert(b2 != null); b2.InvOccurrencesNum = b2.InvOccurrencesNum - 1; if (b2.InvOccurrencesNum == 0) { rootBindings.Push(b2); } } } if (boundVars.Any(pair => pair.Value.InvOccurrencesNum > 0)) { System.Diagnostics.Debug.Fail("Cyclic let-bindings"); } Contract.Assert(node.Length == sortedBindings.Count); // check which of the bindings can be dropped VCExpr newBody = Mutate(node.Body, arg); Contract.Assert(newBody != null); IDictionary <VCExprVar /*!*/, VCExprVar /*!*/> /*!*/ usedVars = new Dictionary <VCExprVar /*!*/, VCExprVar /*!*/> (); foreach (VCExprVar /*!*/ v in FreeVarsIn(newBody)) { Contract.Assert(v != null); if (!usedVars.ContainsKey(v)) { usedVars.Add(v, v); } } for (int i = sortedBindings.Count - 1; i >= 0; --i) { if (usedVars.ContainsKey(sortedBindings[i].V)) { foreach (VCExprVar /*!*/ v in sortedBindings[i].FreeVars) { Contract.Assert(v != null); if (!usedVars.ContainsKey(v)) { usedVars.Add(v, v); } } } else { sortedBindings.RemoveAt(i); } } // assemble the resulting let-expression List <VCExprLetBinding /*!*/> /*!*/ newBindings = new List <VCExprLetBinding /*!*/>(); foreach (Binding b in sortedBindings) { newBindings.Add(Gen.LetBinding(b.V, b.E)); } return(Gen.Let(newBindings, newBody)); }