private static IEnumerable <ProofState> UpdateLocalValue(UpdateStmt us, ProofState state)
{
Contract.Requires <ArgumentNullException>(us != null, "stmt");
Contract.Requires <ArgumentNullException>(state != null, "state");
Contract.Requires <ArgumentException>(state.IsLocalAssignment(us), "stmt");
foreach (var item in us.Rhss)
{
int index = us.Rhss.IndexOf(item);
Contract.Assert(us.Lhss.ElementAtOrDefault(index) != null, "register var err");
var exprRhs = item as ExprRhs;
if (exprRhs?.Expr is ApplySuffix)
{
var aps = (ApplySuffix)exprRhs.Expr;
var result = SimpExpr.UnfoldTacticProjection(state, aps);
state.UpdateTacticVar(((NameSegment)us.Lhss[index]).Name, result);
}
else if (exprRhs?.Expr is Microsoft.Dafny.LiteralExpr)
{
state.UpdateTacticVar(((NameSegment)us.Lhss[index]).Name, (Microsoft.Dafny.LiteralExpr)exprRhs?.Expr);
}
else
{
throw new NotSupportedException("Not supported update statement");
}
}
yield return(state.Copy());
}
public static IEnumerable <ProofState> EvalStmt(Statement stmt, ProofState state)
{
Contract.Requires <ArgumentNullException>(state != null, "state");
IEnumerable <ProofState> enumerable = null;
var flowctrls = Assembly.GetAssembly(typeof(Language.TacticFrameCtrl))
.GetTypes().Where(t => t.IsSubclassOf(typeof(Language.TacticFrameCtrl)));
foreach (var ctrl in flowctrls)
{
var porjInst = Activator.CreateInstance(ctrl) as Language.TacticFrameCtrl;
if (porjInst?.MatchStmt(stmt, state) == true)
{
//TODO: validate input countx
enumerable = porjInst.EvalInit(stmt, state);
}
}
// no frame control is triggered
if (enumerable == null)
{
if (stmt is TacticVarDeclStmt)
{
enumerable = RegisterVariable(stmt as TacticVarDeclStmt, state);
}
else if (stmt is AssignSuchThatStmt)
{
enumerable = EvalSuchThatStmt((AssignSuchThatStmt)stmt, state);
}
else if (stmt is PredicateStmt)
{
enumerable = EvalPredicateStmt((PredicateStmt)stmt, state);
}
else
{
var updateStmt = stmt as UpdateStmt;
if (updateStmt != null)
{
var us = updateStmt;
if (state.IsLocalAssignment(us))
{
enumerable = UpdateLocalValue(us, state);
}
else if (state.IsArgumentApplication(us))
{
//TODO: argument application ??
}
else
{
// apply atomic
string sig = Util.GetSignature(us);
//Firstly, check if this is a projection function
var types =
Assembly.GetAssembly(typeof(Atomic.Atomic))
.GetTypes()
.Where(t => t.IsSubclassOf(typeof(Atomic.Atomic)));
foreach (var fType in types)
{
var porjInst = Activator.CreateInstance(fType) as Atomic.Atomic;
if (sig == porjInst?.Signature)
{
//TODO: validate input countx
enumerable = porjInst?.Generate(us, state);
}
}
}
}
if (enumerable == null)
{
// default action as macro
enumerable = DefaultAction(stmt, state);
}
}
}
return(enumerable);
}