internal new static IEnumerable <ProofState> Search(ProofState rootState, ErrorReporterDelegate er)
{
var queue = new Queue <IEnumerator <ProofState> >();
queue.Enqueue(Interpreter.EvalStep(rootState).GetEnumerator());
IEnumerator <ProofState> enumerator = Enumerable.Empty <ProofState>().GetEnumerator();
while (queue.Count > 0)
{
// check if there is any more item in the enumerartor, if so, MoveNext will move to the next item
if (!enumerator.MoveNext())
{
// if no item in the current enumerator, pop a new enumerator from the queie,
enumerator = queue.Dequeue();
// set the start point for enumulator, if there is no valid start point, i.e. empty, skip this one
if (!enumerator.MoveNext())
{
continue;
}
}
var proofState = enumerator.Current;
//check if any new added code reuqires to call the dafny to verity, or reach the last line of code
if (proofState.IfVerify || proofState.IsEvaluated())
{
proofState.IfVerify = false;
switch (VerifyState(proofState, er))
{
case VerifyResult.Verified:
proofState.MarkCurFrameAsTerminated(true);
if (proofState.IsTerminated())
{
yield return(proofState);
yield break;
}
//queue.Enqueue(Interpreter.EvalStep(proofState).GetEnumerator());
break;
case VerifyResult.Failed:
if (proofState.IsEvaluated())
{
proofState.MarkCurFrameAsTerminated(false);
if (proofState.IsTerminated())
{
yield return(proofState);
yield break;
}
}
break;
case VerifyResult.Unresolved:
//discharge current branch if fails to resolve
continue;
default:
throw new ArgumentOutOfRangeException();
}
}
/*
* when failed, check if this mmethod is evaluated , i.e. all tstmt are evalauted,
* if so, dischard this branch and continue with the next one
* otherwise, continue to evaluate the next stmt
*/
if (!proofState.IsEvaluated())
{
queue.Enqueue(Interpreter.EvalStep(proofState).GetEnumerator());
}
}
}
internal new static IEnumerable <ProofState> Search(ProofState rootState, ErrorReporterDelegate er)
{
var stack = new Stack <IEnumerator <ProofState> >();
stack.Push(Interpreter.EvalStep(rootState).GetEnumerator());
IEnumerator <ProofState> enumerator = Enumerable.Empty <ProofState>().GetEnumerator();
while (stack.Count > 0)
{
if (!enumerator.MoveNext())
{
enumerator = stack.Pop();
if (!enumerator.MoveNext())
{
continue;
}
}
var proofState = enumerator.Current;
//check if any new added coded reuqires to call verifier, or reach the last line of code
if (proofState.IfVerify || proofState.IsEvaluated())
{
proofState.IfVerify = false;
switch (VerifyState(proofState, er))
{
case VerifyResult.Verified:
proofState.MarkCurFrameAsTerminated(true);
if (proofState.IsTerminated())
{
yield return(proofState);
yield break;
}
//stack.Push(enumerator);
//enumerator = (Interpreter.EvalStep(proofState).GetEnumerator());
break;
case VerifyResult.Failed:
if (proofState.IsEvaluated())
{
proofState.MarkCurFrameAsTerminated(false);
if (proofState.IsTerminated())
{
yield return(proofState);
yield break;
}
}
break;
case VerifyResult.Unresolved:
//discharge current branch if fails to resolve
continue;
default:
throw new ArgumentOutOfRangeException();
}
}
/*
* when failed, check if this mmethod is evaluated , i.e. all tstmt are evalauted,
* if so, dischard this branch and continue with the next one
* otherwise, continue to evaluate the next stmt
*/
if (!proofState.IsEvaluated())
{
//push the current one to the stack
stack.Push(enumerator);
//move to the next stmt
enumerator = (Interpreter.EvalStep(proofState).GetEnumerator());
}
}
}
internal new static IEnumerable <ProofState> Search(ProofState rootState, ErrorReporterDelegate er)
{
var queue = new Queue <IEnumerator <ProofState> >();
queue.Enqueue(Interpreter.EvalStep(rootState).GetEnumerator());
while (queue.Count > 0)
{
// remove first enumerator on the queue
var enumerator = queue.Dequeue();
// if all the statements have been resolve skip
if (!enumerator.MoveNext())
{
continue;
}
var proofState = enumerator.Current;
queue.Enqueue(enumerator);
if (Verify)
{
if (proofState.IsEvaluated() || proofState.IsPartiallyEvaluated())
{
switch (VerifyState(proofState, er))
{
case VerifyResult.Cached:
if (proofState.IsPartiallyEvaluated())
{
yield return(proofState);
queue.Enqueue(Interpreter.EvalStep(proofState).GetEnumerator());
}
continue;
case VerifyResult.Verified:
yield return(proofState);
yield break;
case VerifyResult.Failed:
/*
* verification failed, but the evaluation is partial return
* but continue evaluating the proofState
*/
if (proofState.IsPartiallyEvaluated())
{
yield return(proofState);
queue.Enqueue(Interpreter.EvalStep(proofState).GetEnumerator());
}
continue;
default:
throw new ArgumentOutOfRangeException();
}
}
queue.Enqueue(Interpreter.EvalStep(proofState).GetEnumerator());
}
else
{
if (!(proofState.IsEvaluated() || proofState.IsPartiallyEvaluated()))
{
queue.Enqueue(Interpreter.EvalStep(proofState).GetEnumerator());
}
else
{
yield return(proofState);
if (proofState.IsPartiallyEvaluated())
{
queue.Enqueue(Interpreter.EvalStep(proofState).GetEnumerator());
}
}
}
}
}
