/// <summary>
/// Gets the errors and associated metadata after verifying the program.
/// </summary>
/// <returns>The metadata of the errors.</returns>
public IEnumerable <RepairableError> GetErrors()
{
List <Error> errors = new List <Error>();
VCGen gen = new VCGen(program, CommandLineOptions.Clo.SimplifyLogFilePath, CommandLineOptions.Clo.SimplifyLogFileAppend, new List <Checker>());
foreach (Declaration declaration in program.TopLevelDeclarations)
{
if (declaration is Implementation)
{
Implementation implementation = declaration as Implementation;
List <Counterexample> examples;
ConditionGeneration.Outcome outcome = gen.VerifyImplementation(implementation, out examples);
if (outcome == ConditionGeneration.Outcome.Errors)
{
foreach (Counterexample example in examples)
{
errors.AddRange(GenerateErrors(example, implementation));
}
}
}
}
gen.Close();
// there are no repairable errors that have a variable assigned to them
if (!errors.Any(x => x is RepairableError && (x as RepairableError).Barriers.Any()))
{
if (errors.Any(x => x.CounterExample is AssertCounterexample))
{
throw new AssertionException("Assertions do not hold!");
}
if (errors.Any(x => !(x is RepairableError)))
{
throw new NonBarrierException("The program cannot be repaired since it has errors besides race and divergence errors!");
}
if (errors.Any(x => x is RepairableError))
{
throw new RepairException("Encountered a counterexample without any barrier assignments!");
}
}
return(errors.Where(x => x is RepairableError && (x as RepairableError).Barriers.Any())
.Select(x => x as RepairableError).ToList());
}
public void ReadOutcome(ref ConditionGeneration.Outcome curOutcome, out bool proverFailed)
{
Contract.EnsuresOnThrow <UnexpectedProverOutputException>(true);
ProverInterface.Outcome outcome = cce.NonNull(checker).ReadOutcome();
if (CommandLineOptions.Clo.Trace && splitNum >= 0)
{
System.Console.WriteLine(" --> split #{0} done, [{1} s] {2}", splitNum,
checker.ProverRunTime.TotalSeconds, outcome);
}
if (CommandLineOptions.Clo.VcsDumpSplits)
{
DumpDot(splitNum);
}
proverFailed = false;
switch (outcome)
{
case ProverInterface.Outcome.Valid:
return;
case ProverInterface.Outcome.Invalid:
curOutcome = ConditionGeneration.Outcome.Errors;
return;
case ProverInterface.Outcome.OutOfMemory:
proverFailed = true;
if (curOutcome != ConditionGeneration.Outcome.Errors && curOutcome != ConditionGeneration.Outcome.Inconclusive)
{
curOutcome = ConditionGeneration.Outcome.OutOfMemory;
}
return;
case ProverInterface.Outcome.TimeOut:
proverFailed = true;
if (curOutcome != ConditionGeneration.Outcome.Errors && curOutcome != ConditionGeneration.Outcome.Inconclusive)
{
curOutcome = ConditionGeneration.Outcome.TimedOut;
}
return;
case ProverInterface.Outcome.OutOfResource:
proverFailed = true;
if (curOutcome != ConditionGeneration.Outcome.Errors && curOutcome != ConditionGeneration.Outcome.Inconclusive)
{
curOutcome = ConditionGeneration.Outcome.OutOfResource;
}
return;
case ProverInterface.Outcome.Undetermined:
if (curOutcome != ConditionGeneration.Outcome.Errors)
{
curOutcome = ConditionGeneration.Outcome.Inconclusive;
}
return;
default:
Contract.Assert(false);
throw new cce.UnreachableException();
}
}
public VerificationResult(string requestId, string checksum, string depsChecksum, ConditionGeneration.Outcome outcome, List<Counterexample> errors)
: this(requestId, checksum, depsChecksum)
{
Outcome = outcome;
Errors = errors;
}
