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);
}
}
