public override IEnumerable <ProofState> EvalStep(ProofState state0) { var tryEval = EvalExpr.EvalTacticExpression(state0, _guard); if (tryEval == null) { yield break; } var state = state0.Copy(); var literalExpr = tryEval as LiteralExpr; if (literalExpr != null && (bool)literalExpr.Value) { //insert the body frame var bodyFrame = new DefaultTacticFrameCtrl(); bodyFrame.InitBasicFrameCtrl(_body, state.IsCurFramePartial(), null, VerifyN); state.AddNewFrame(bodyFrame); } else { state.NeedVerify = true; } yield return(state); }
public override bool EvalTerminated(bool childFrameRes, ProofState state) { var tryEval = EvalExpr.EvalTacticExpression(state, _guard); var literalExpr = tryEval as LiteralExpr; return(literalExpr != null && (bool)literalExpr.Value); }
static void Main(string[] args) { Console.WriteLine(EvalExpr.Compile("x + 5").Eval(10)); Console.WriteLine(EvalExpr.Compile("(x - 3) * 5").Eval(10)); Console.WriteLine(EvalExpr.Compile("(x > 10) * x ^ 2 - x * 3").Eval(10)); Console.WriteLine(EvalExpr.Compile("ln e").Eval(10)); Console.WriteLine(EvalExpr.Compile("sin(pi / 2)").Eval(10)); Console.WriteLine(EvalExpr.Compile("(x + 5) * (x - 3)").Eval(9)); }
public static IEnumerable <ProofState> RegisterVariable(TacticVarDeclStmt declaration, ProofState state) { var rhs = declaration.Update as UpdateStmt; if (rhs != null) { foreach (var item in rhs.Rhss) { int index = rhs.Rhss.IndexOf(item); Contract.Assert(declaration.Locals.ElementAtOrDefault(index) != null, "register var err"); var exprRhs = item as ExprRhs; var res = EvalExpr.EvalTacticExpression(state, exprRhs?.Expr); if (res != null) { state.AddTacnyVar(declaration.Locals[index], res); yield return(state); } } } else { var stmt = declaration.Update as AssignSuchThatStmt; if (stmt != null) { foreach (var item in declaration.Locals) { state.AddTacnyVar(item, null); } foreach (var item in EvalSuchThatStmt(stmt, state)) { yield return(item); } } else { foreach (var item in declaration.Locals) { if (state.ContainTVal(item.Name)) { state.ReportTacticError(item.Tok, item.Name + " has already been defined in the current scope."); yield break; } else { state.AddTacnyVar(item, null); } } yield return(state); } } }
public override IEnumerable <ProofState> EvalInit(Statement statement, ProofState state0) { Contract.Assume(statement is WhileStmt); var whileStmt = statement as WhileStmt; if (whileStmt != null) { var tryEval = EvalExpr.EvalTacticExpression(state0, whileStmt.Guard); if (tryEval == null) { yield break; } if (!(tryEval is LiteralExpr && (tryEval as LiteralExpr).Value is bool)) { var state = state0.Copy(); var st = SimpExpr.SimpTacticExpr(state, statement); state.NeedVerify = true; state.AddStatement(st); yield return(state); yield break; } else { var state = state0.Copy(); var whileCtrl = this.Copy(); whileCtrl._guard = whileStmt.Guard; whileCtrl._body = whileStmt.Body.Body; if ((bool)(tryEval as LiteralExpr).Value) { // insert the control frame var dummyBody = new List <Statement> { whileStmt }; whileCtrl.InitBasicFrameCtrl(dummyBody, true, null, VerifyN); state.AddNewFrame(whileCtrl); //insert the body frame var bodyFrame = new DefaultTacticFrameCtrl(); bodyFrame.InitBasicFrameCtrl(whileCtrl._body, whileCtrl.IsPartial, null, VerifyN); state.AddNewFrame(bodyFrame); } yield return(state); } } }
public override IEnumerable <ProofState> EvalInit(Statement statement, ProofState state0) { bool partial = true; List <Tuple <Expression, List <Statement> > > guardBodyList = new List <Tuple <Expression, List <Statement> > >(); int counter = 0; guardBodyList = GetGuadBodyList(statement, guardBodyList); Contract.Assert(guardBodyList.Count > 0); var tryEval = EvalExpr.EvalTacticExpression(state0, guardBodyList[0].Item1); if (tryEval == null) { yield break; } //check whether the top level of the first guard is tactic level or object level if (!(tryEval is LiteralExpr && (tryEval as LiteralExpr).Value is bool)) { var state = state0.Copy(); var st = SimpExpr.SimpTacticExpr(state, statement); state.NeedVerify = true; state.AddStatement(st); yield return(state); yield break; } else { // tactic if foreach (var item in guardBodyList) { if (item.Item1 == null && counter == 0) //else branch and no other branch is satisfied. { counter++; var state = state0.Copy(); var ifChoice = this.Copy(); ifChoice.InitBasicFrameCtrl(item.Item2, partial, null, VerifyN); state.AddNewFrame(ifChoice); yield return(state); } else { var res = EvalExpr.EvalTacticExpression(state0, item.Item1); if (res == null) { yield break; } if (res is LiteralExpr && (res as LiteralExpr).Value is bool && (bool)(res as LiteralExpr).Value) { counter++; var state = state0.Copy(); var ifChoice = this.Copy(); ifChoice.InitBasicFrameCtrl(item.Item2, partial, null, VerifyN); state.AddNewFrame(ifChoice); yield return(state); } } } //no condition can be found, then do nothing if (counter == 0) { yield return(state0.Copy()); } } }
public override IEnumerable <ProofState> Generate(Statement statement, ProofState state) { AssignSuchThatStmt suchThat = null; if (statement is AssignSuchThatStmt) { suchThat = (AssignSuchThatStmt)statement; } else { state.ReportTacticError(statement.Tok, "Unexpected statement for suchthat(:|)"); yield break; } var nameExpr = suchThat.Lhss[0]; if (nameExpr is IdentifierExpr) { var id = nameExpr as IdentifierExpr; name = id.Name; } else if (nameExpr is NameSegment) { var id = nameExpr as NameSegment; if (!state.ContainTVal(id.Name)) { state.ReportTacticError(statement.Tok, "Fail to register variable " + id.Name); yield break; } else { name = id.Name; } } else { state.ReportTacticError(statement.Tok, "Fail to register variable."); yield break; } string errInfo; // var expr = Expr.SimpExpr.SimpTacticExpr(state, suchThat.Expr); var expr = suchThat.Expr; /* * if (!CheckExpr(expr, out errInfo)) { * state.ReportTacticError(statement.Tok, "Unexpceted expression in suchthat statement: " + errInfo); * yield break; * }*/ Expression pos, neg, pred; if (!RewriteExpr(expr as BinaryExpr, out pos, out neg, out pred)) { state.ReportTacticError(expr.tok, "Syntax error in Suchthat expression."); yield break; } if (pos != null) { pos = EvalExpr.EvalTacticExpression(state, pos); if (pos == null) { yield break; } } if (neg != null) { neg = EvalExpr.EvalTacticExpression(state, neg); if (neg == null) { yield break; } } if (pos == null) { state.ReportTacticError(statement.Tok, "Suchthat expression is evaluated as an empty sequence."); yield break; } if (pos is SeqDisplayExpr) { if (neg != null && !(neg is SeqDisplayExpr)) { state.ReportTacticError(statement.Tok, "Unexpceted expression in suchthat statement."); yield break; } var eles = EvalExpr.RemoveDup((pos as SeqDisplayExpr).Elements); if (eles.Count == 0) { state.ReportTacticError(statement.Tok, "The expression is evaluated as an empty set."); yield break; } foreach (var item in eles) { var copy = state.Copy(); copy.UpdateTacticVar(name, item); if (neg != null) { var inNeg = EvalExpr.EvalTacticExpression(state, new BinaryExpr(new Token(TacnyDriver.TacticCodeTokLine, 0), BinaryExpr.Opcode.In, item, neg)); if (inNeg is LiteralExpr && (inNeg as LiteralExpr).Value is bool) { if ((bool)(inNeg as LiteralExpr).Value) { continue; } } else { throw new Exception("A unhandled error orrurs when evaluating a suchtaht statement"); } } if (pred != null) { var value = new BinaryExpr(new Token(TacnyDriver.TacticCodeTokLine, 0), BinaryExpr.Opcode.Eq, suchThat.Lhss[0].Copy(), item); var candidate = new BinaryExpr(new Token(TacnyDriver.TacticCodeTokLine, 0), BinaryExpr.Opcode.Add, value, pred); var res = EvalExpr.EvalTacticExpression(copy, pred); Console.WriteLine(Printer.ExprToString(res)); if (res is LiteralExpr && (res as LiteralExpr).Value is bool) { if (!(bool)(res as LiteralExpr).Value) { continue; } } else { throw new Exception("A unhandled error orrurs when evaluating a suchtaht statement"); } } yield return(copy); } } else { state.ReportTacticError(statement.Tok, "Unexpceted expression in suchthat statement."); yield break; } }
public override IEnumerable <ProofState> Generate(Statement statement, ProofState state) { List <List <IVariable> > args = new List <List <IVariable> >(); List <IVariable> mdIns = new List <IVariable>(); List <Expression> callArguments; bool branchGenerated = false; state.NeedVerify = true; InitArgs(state, statement, out callArguments); /********************** * init lemmas **********************/ //check the number of arguments if (callArguments == null || callArguments.Count != 2) { state.ReportTacticError(statement.Tok, " The number of arguments for explore is not correct, expect 2."); yield break; } // get the first arg: a sequence of lemmas var members0 = EvalExpr.EvalTacticExpression(state, callArguments[0]) as SeqDisplayExpr; if (members0 == null) { state.ReportTacticError(statement.Tok, Printer.ExprToString(callArguments[0]) + " is not a sequence."); yield break; } List <MemberDecl> members = new List <MemberDecl>(); foreach (var mem in members0.Elements) { if (!(mem is TacticLiteralExpr)) { state.ReportTacticError(statement.Tok, "In " + Printer.ExprToString(callArguments[0]) + Printer.ExprToString(mem) + " is not a lemma."); yield break; } var key = (string)(mem as TacticLiteralExpr).Value; if (state.Members.ContainsKey(key)) { members.Add(state.Members[key]); } else { state.ReportTacticError(statement.Tok, "In " + Printer.ExprToString(callArguments[0]) + ", " + key + " is not a lemma."); yield break; } } if (members.Count == 0) { branchGenerated = true; yield return(state); yield break; } foreach (var member in members) { mdIns.Clear(); args.Clear(); var md = (MemberDecl)member; // take the membed decl parameters var method = md as Method; if (method != null) { mdIns.AddRange(method.Ins); } else if (md is Function) { mdIns.AddRange(((Function)md).Formals); } else { state.ReportTacticError(statement.Tok, Printer.ExprToString(callArguments[0]) + " is neither a Method or a Function"); yield break; } /********************** * init args for lemmas **********************/ var ovars = EvalExpr.EvalTacticExpression(state, callArguments[1]) as SeqDisplayExpr; if (ovars == null) { state.ReportTacticError(statement.Tok, Printer.ExprToString(callArguments[1]) + " is not a sequence."); yield break; } List <IVariable> vars = new List <IVariable>(); foreach (var var in ovars.Elements) { string key; if (var is TacticLiteralExpr) { key = (string)(var as TacticLiteralExpr).Value; } else if (var is NameSegment) { key = (var as NameSegment).Name; } else { state.ReportTacticError(statement.Tok, "In " + Printer.ExprToString(callArguments[1]) + ", " + Printer.ExprToString(var) + " is not a dafny variable."); yield break; } if (state.GetAllDafnyVars().ContainsKey(key)) { vars.Add(state.GetAllDafnyVars()[key].Variable); } else { state.ReportTacticError(statement.Tok, "In " + Printer.ExprToString(callArguments[1]) + ", " + key + " is not in scope."); yield break; } } //for the case of no args, just add an empty list if (mdIns.Count == 0) { args.Add(new List <IVariable>()); } //if any of the arguements is not valid, set it to false. bool flag = true; for (int i = 0; i < mdIns.Count; i++) { var item = mdIns[i]; args.Add(new List <IVariable>()); foreach (var arg in vars) { // get variable type Type type = state.GetDafnyVarType(arg.Name); if (type != null) { if (type is UserDefinedType && item.Type is UserDefinedType) { var udt1 = type as UserDefinedType; var udt2 = (UserDefinedType)item.Type; if (udt1.Name == udt2.Name) { args[i].Add(arg); } } else { // if variable type and current argument types match, or the type is yet to be inferred if (item.Type.ToString() == type.ToString() || type is InferredTypeProxy) { args[i].Add(arg); } } } else { args[i].Add(arg); } } /** * if no type correct variables have been added we can return * because we won't be able to generate valid calls */ if (args[i].Count == 0) { flag = false; } } // permute lemma call for the current lemma if (flag) { foreach (var result in PermuteArguments(args, 0, new List <NameSegment>())) { // create new fresh list of items to remove multiple references to the same object List <Expression> newList = result.Cast <Expression>().ToList().Copy(); ApplySuffix aps = new ApplySuffix(callArguments[0].tok, new NameSegment(callArguments[0].tok, md.Name, null), newList); var newState = state.Copy(); UpdateStmt us = new UpdateStmt(aps.tok, aps.tok, new List <Expression>(), new List <AssignmentRhs> { new ExprRhs(aps) }); newState.AddStatement(us); branchGenerated = true; yield return(newState); } } } // for the case when no lemma call is generated. if (!branchGenerated) { yield return(state); } }