protected DeclFreeProverContext(DeclFreeProverContext ctxt)
{
Contract.Requires(ctxt != null);
this.gen = ctxt.gen;
this.genOptions = ctxt.genOptions;
Boogie2VCExprTranslator t = (Boogie2VCExprTranslator)ctxt.translator.Clone();
Contract.Assert(t != null);
this.translator = t;
this.orderingAxiomBuilder = new OrderingAxiomBuilder(ctxt.gen, t, ctxt.orderingAxiomBuilder);
StringBuilder cmds = new StringBuilder();
distincts = new List <Variable>(ctxt.distincts);
axiomConjuncts = new List <VCExpr>(ctxt.axiomConjuncts);
if (ctxt.exprTranslator == null)
{
exprTranslator = null;
}
else
{
exprTranslator = (VCExprTranslator)cce.NonNull(ctxt.exprTranslator.Clone());
}
}
/////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Constructor. Initialize a checker with the program and log file.
/// Optionally, use prover context provided by parameter "ctx".
/// </summary>
public Checker(VC.ConditionGeneration vcgen, Program prog, string /*?*/ logFilePath, bool appendLogFile, int timeout, ProverContext ctx = null)
{
Contract.Requires(vcgen != null);
Contract.Requires(prog != null);
this.timeout = timeout;
this.Program = prog;
ProverOptions options = cce.NonNull(CommandLineOptions.Clo.TheProverFactory).BlankProverOptions();
if (logFilePath != null)
{
options.LogFilename = logFilePath;
if (appendLogFile)
{
options.AppendLogFile = appendLogFile;
}
}
if (timeout > 0)
{
options.TimeLimit = timeout * 1000;
}
options.Parse(CommandLineOptions.Clo.ProverOptions);
ContextCacheKey key = new ContextCacheKey(prog);
ProverInterface prover;
if (vcgen.CheckerCommonState == null)
{
vcgen.CheckerCommonState = new Dictionary <ContextCacheKey, ProverContext>();
}
IDictionary <ContextCacheKey, ProverContext> /*!>!*/ cachedContexts = (IDictionary <ContextCacheKey, ProverContext /*!*/>)vcgen.CheckerCommonState;
if (ctx == null && cachedContexts.TryGetValue(key, out ctx))
{
ctx = (ProverContext)cce.NonNull(ctx).Clone();
prover = (ProverInterface)
CommandLineOptions.Clo.TheProverFactory.SpawnProver(options, ctx);
}
else
{
if (ctx == null)
{
ctx = (ProverContext)CommandLineOptions.Clo.TheProverFactory.NewProverContext(options);
}
Setup(prog, ctx);
// we first generate the prover and then store a clone of the
// context in the cache, so that the prover can setup stuff in
// the context to be cached
prover = (ProverInterface)
CommandLineOptions.Clo.TheProverFactory.SpawnProver(options, ctx);
cachedContexts.Add(key, cce.NonNull((ProverContext)ctx.Clone()));
}
this.thmProver = prover;
this.gen = prover.VCExprGen;
}
private void SetupOrderingAxiomBuilder(VCExpressionGenerator gen, Boogie2VCExprTranslator t)
{
OrderingAxiomBuilder oab = new OrderingAxiomBuilder(gen, t);
Contract.Assert(oab != null);
oab.Setup();
this.orderingAxiomBuilder = oab;
}
public OrderingAxiomBuilder(VCExpressionGenerator gen,
Boogie2VCExprTranslator translator)
{
Contract.Requires(gen != null);
Contract.Requires(translator != null);
this.Gen = gen;
this.Translator = translator;
OneStepFuns = new Dictionary <Type, Function>();
Constants = new List <Constant>();
CompleteConstantsOpen = new List <Constant>();
AllAxioms = new List <VCExpr>();
IncAxioms = new List <VCExpr>();
}
public DeclFreeProverContext(VCExpressionGenerator gen,
VCGenerationOptions genOptions)
{
Contract.Requires(gen != null);
Contract.Requires(genOptions != null);
this.gen = gen;
this.genOptions = genOptions;
Boogie2VCExprTranslator t = new Boogie2VCExprTranslator(gen, genOptions);
this.translator = t;
SetupOrderingAxiomBuilder(gen, t);
distincts = new List <Variable>();
axiomConjuncts = new List <VCExpr>();
exprTranslator = null;
}
public override void FullReset(VCExpressionGenerator gen)
{
throw new NotImplementedException();
}
public abstract void FullReset(VCExpressionGenerator gen);
public FixedpointVC( Program _program, string/*?*/ logFilePath, bool appendLogFile, List<Checker> checkers)
: base(_program, logFilePath, appendLogFile, checkers)
{
switch (CommandLineOptions.Clo.FixedPointMode)
{
case CommandLineOptions.FixedPointInferenceMode.Corral:
mode = Mode.Corral;
style = AnnotationStyle.Procedure;
break;
case CommandLineOptions.FixedPointInferenceMode.OldCorral:
mode = Mode.OldCorral;
style = AnnotationStyle.Procedure;
break;
case CommandLineOptions.FixedPointInferenceMode.Flat:
mode = Mode.Boogie;
style = AnnotationStyle.Flat;
break;
case CommandLineOptions.FixedPointInferenceMode.Procedure:
mode = Mode.Boogie;
style = AnnotationStyle.Procedure;
break;
case CommandLineOptions.FixedPointInferenceMode.Call:
mode = Mode.Boogie;
style = AnnotationStyle.Call;
break;
}
ctx = new Context(); // TODO is this right?
rpfp = new RPFP(RPFP.CreateLogicSolver(ctx));
program = _program;
gen = ctx;
if(old_checker == null)
checker = new Checker(this, program, logFilePath, appendLogFile, CommandLineOptions.Clo.ProverKillTime, null);
else {
checker = old_checker;
checker.RetargetWithoutReset(program,checker.TheoremProver.Context);
}
old_checker = checker;
boogieContext = checker.TheoremProver.Context;
linOptions = null; // new Microsoft.Boogie.Z3.Z3LineariserOptions(false, options, new List<VCExprVar>());
}
