public override Cmd VisitAssignCmd(AssignCmd node) { if (node.Lhss.Count != node.Rhss.Count) { throw new ProofGenUnexpectedStateException(typeof(BasicCmdIsaVisitor), "different number of lhs and rhs"); } if (node.Lhss.Count != 1) { throw new NotImplementedException("Parallel assignments are not supported."); } /* * var lhsResults = node.Lhss.Select(lhs => Translate(lhs)).ToList(); * var rhsResults = node.Rhss.Select(rhs => Translate(rhs)).ToList(); * IList<Term> results = new List<Term>(); * lhsResults.ZipDo(rhsResults, (lhs, rhs) => results.Add(new TermTuple(new List<Term>() { lhs, rhs }))); */ var lhs = Translate(node.Lhss[0]); var rhs = Translate(node.Rhss[0]); ReturnResult(IsaBoogieTerm.Assign(lhs, rhs)); return(node); }
public override Cmd VisitAssumeCmd(AssumeCmd node) { var result = Translate(node.Expr); ReturnResult(IsaBoogieTerm.Assume(result)); return(node); }
public override Expr VisitOldExpr(OldExpr node) { var body = Translate(node.Expr); ReturnResult(IsaBoogieTerm.Old(body)); return(node); }
public Term Visit(BinaryOperator binaryOperator) { if (_args.Count != 2) { throw new ExprArgException(); } return(IsaBoogieTerm.Binop(binaryOperator.Op, _args[0], _args[1])); }
public Term Visit(UnaryOperator unaryOperator) { if (_args.Count != 1) { throw new ExprArgException(); } return(IsaBoogieTerm.Unop(unaryOperator.Op, _args[0])); }
public override QuantifierExpr VisitQuantifierExpr(QuantifierExpr node) { if (!(node is ForallExpr || node is ExistsExpr)) { throw new ProofGenUnexpectedStateException(GetType(), "can only handle forall and exists quantifiers"); } var isForall = IsForall(node); //Quantifers with multiple bound variables are desugared into multiple quantifiers expressions with single variables foreach (var boundVar in node.Dummies) { boogieVarTranslation.VarTranslation.AddBoundVariable(boundVar); } foreach (var boundTyVar in node.TypeParameters) { boogieVarTranslation.TypeVarTranslation.AddBoundVariable(boundTyVar); } var numValVarBefore = boogieVarTranslation.VarTranslation.NumBoundVariables(); var numTyVarBefore = boogieVarTranslation.TypeVarTranslation.NumBoundVariables(); var result = Translate(node.Body); if (numValVarBefore != boogieVarTranslation.VarTranslation.NumBoundVariables() || numTyVarBefore != boogieVarTranslation.TypeVarTranslation.NumBoundVariables()) { throw new ProofGenUnexpectedStateException(GetType(), "quantifier levels not the same before and after"); } for (var i = node.Dummies.Count - 1; i >= 0; i--) { boogieVarTranslation.VarTranslation.DropLastBoundVariable(); var boundVar = node.Dummies[i]; var boundVarType = typeIsaVisitor.Translate(boundVar.TypedIdent.Type); result = IsaBoogieTerm.Quantifier(isForall, boundVarType, result); } for (var i = node.TypeParameters.Count - 1; i >= 0; i--) { boogieVarTranslation.TypeVarTranslation.DropLastBoundVariable(); result = IsaBoogieTerm.TypeQuantifier(isForall, result); } ReturnResult(result); return(node); }
public Term Visit(FunctionCall functionCall) { if (_args.Count != functionCall.ArgumentCount) { throw new ExprArgException(); } var typeInstIsa = new List <Term>(); foreach (var typeVar in _typeInst.FormalTypeParams) { var t = typeIsaVisitor.Translate(_typeInst[typeVar]); typeInstIsa.Add(t); } return(IsaBoogieTerm.FunCall(functionCall.FunctionName, typeInstIsa, _args)); }
public override Cmd VisitCallCmd(CallCmd node) { if (node.TypeParameters != null && node.TypeParameters.FormalTypeParams.Any()) { throw new NotImplementedException("Do not support procedures with type parameters"); } var argsTerm = node.Ins.Select(e => Translate(e)).ToList(); var outsTerm = node.Outs.Select(e => { if (boogieVarTranslation.VarTranslation.TryTranslateVariableId(e.Decl, out Term id, out _)) { return(id); } throw new ProofGenUnexpectedStateException("Could not retrieve id of variable"); }).ToList(); ReturnResult(IsaBoogieTerm.ProcCall(node.Proc.Name, argsTerm, outsTerm)); return(node); }
public IProgramAccessor GetIsaProgram( string theoryName, string procName, BoogieMethodData methodData, IsaProgramGeneratorConfig config, IVariableTranslationFactory varTranslationFactory, CFGRepr cfg, out IList <OuterDecl> decls, bool generateMembershipLemmas = true, bool onlyGlobalData = false ) { this.varTranslationFactory = varTranslationFactory; varTranslation = varTranslationFactory.CreateTranslation(); cmdIsaVisitor = new MultiCmdIsaVisitor(varTranslationFactory); /* * Term program = IsaBoogieTerm.Program(IsaCommonTerms.TermIdentFromName(funcs.name), * new TermList(new List<Term>()), * new TermList(new List<Term>()), * IsaCommonTerms.TermIdentFromName(axiomsDecl.name), * new List<Term>() { method }); * * var list = new List<Tuple<IList<Term>, Term>> * { * new Tuple<IList<Term>, Term>(new List<Term>(), program) * }; */ //OuterDecl programDefinition = new DefDecl("ProgramM", new Tuple<IList<Term>, Term>(new List<Term>(), program)); decls = new List <OuterDecl>(); var isaGlobalProgramRepr = new IsaGlobalProgramRepr( FunctionDeclarationsName(), AxiomDeclarationsName(), VariableDeclarationsName("globals"), VariableDeclarationsName("constants") ); var globalsMax = methodData.Constants.Count() + methodData.GlobalVars.Count() - 1; // assume single versioning and order on constants, globals, params, locals var localsMin = globalsMax + 1; if (globalsMax < 0) { globalsMax = 0; } MembershipLemmaManager membershipLemmaManager; if (onlyGlobalData) { membershipLemmaManager = new MembershipLemmaManager( isaGlobalProgramRepr, globalsMax, varTranslationFactory, theoryName); } else { var outEdges = GetOutEdgesIsa(procName, cfg, out var edgeLemmas); var blockInfo = BlockToInfo(theoryName, procName, cfg, edgeLemmas); var isaProgramRepr = new IsaProgramRepr( isaGlobalProgramRepr, PreconditionDeclarationName(), PostconditionDeclarationName(), VariableDeclarationsName("params"), VariableDeclarationsName("locals"), cfgName, procDefName); membershipLemmaManager = new MembershipLemmaManager(config, isaProgramRepr, blockInfo, Tuple.Create(globalsMax, localsMin), varTranslationFactory, theoryName); var nodesToBlocks = GetNodeToBlocksIsa(cfg, blockInfo.BlockCmdsDefs); decls.AddRange(blockInfo.BlockCmdsDefs.Values); Term entry = new IntConst(BigNum.FromInt(cfg.GetUniqueIntLabel(cfg.entry))); var methodBodyCFG = IsaBoogieTerm.MethodCFGBody( entry, IsaCommonTerms.TermIdentFromName(outEdges.Name), IsaCommonTerms.TermIdentFromName(nodesToBlocks.Name) ); var methodBodyDecl = GetMethodBodyCFGDecl(procName, methodBodyCFG); decls.AddRange( new List <OuterDecl> { outEdges, nodesToBlocks, methodBodyDecl }); decls.AddRange(blockInfo.BlockCmdsLemmas.Values); decls.AddRange(blockInfo.BlockOutEdgesLemmas.Values); if (config.specsConfig != SpecsConfig.None) { OuterDecl preconditions; OuterDecl postconditions; if (config.specsConfig == SpecsConfig.AllPreCheckedPost) { preconditions = GetExprListIsa(PreconditionDeclarationName(), methodData.Preconditions.Select(pre => pre.Item1)); postconditions = GetExprListIsa(PostconditionDeclarationName(), methodData.Postconditions.Where(post => !post.Item2).Select(post => post.Item1)); } else { preconditions = GetExprListIsa(PreconditionDeclarationName(), methodData.Preconditions); postconditions = GetExprListIsa(PostconditionDeclarationName(), methodData.Postconditions); } decls.Add(preconditions); decls.Add(postconditions); } if (config.generateParamsAndLocals) { decls.Add(GetVariableDeclarationsIsa("params", methodData.InParams)); decls.Add(GetVariableDeclarationsIsa("locals", methodData.Locals)); } /* membership lemmas might still be added even if the parameter and local variable definitions are not generated * at this point (since the variable context may still be different, which requires other lookup lemmas) */ if (generateMembershipLemmas) { membershipLemmaManager.AddVariableMembershipLemmas(methodData.InParams, VarKind.ParamOrLocal); membershipLemmaManager.AddVariableMembershipLemmas(methodData.Locals, VarKind.ParamOrLocal); } } if (config.generateAxioms) { decls.Add(GetAxioms(methodData.Axioms)); if (generateMembershipLemmas) { membershipLemmaManager.AddAxiomMembershipLemmas(methodData.Axioms); } } if (config.generateFunctions) { decls.Add(GetFunctionDeclarationsIsa(methodData.Functions)); if (generateMembershipLemmas) { membershipLemmaManager.AddFunctionMembershipLemmas(methodData.Functions); } } if (config.generateGlobalsAndConstants) { decls.Add(GetVariableDeclarationsIsa("globals", methodData.GlobalVars)); decls.Add(GetVariableDeclarationsIsa("constants", methodData.Constants)); } if (generateMembershipLemmas) { membershipLemmaManager.AddVariableMembershipLemmas(methodData.GlobalVars, VarKind.Global); membershipLemmaManager.AddVariableMembershipLemmas(methodData.Constants, VarKind.Constant); decls.AddRange(membershipLemmaManager.OuterDecls()); } if (config.specsConfig != SpecsConfig.None) { DefDecl methodDef = MethodDefinition(membershipLemmaManager, methodData, config.specsConfig); decls.Add(methodDef); } return(membershipLemmaManager); }
public override Expr VisitLiteralExpr(LiteralExpr node) { ReturnResult(IsaBoogieTerm.ExprFromLiteral(IsaBoogieTerm.Literal(node))); return(node); }