context::context(ast_manager & m, register_engine_base& re, smt_params& fp, params_ref const& pa):
m(m),
m_register_engine(re),
m_fparams(fp),
m_params_ref(pa),
m_params(alloc(fp_params, m_params_ref)),
m_decl_util(m),
m_rewriter(m),
m_var_subst(m),
m_rule_manager(*this),
m_contains_p(*this),
m_rule_properties(m, m_rule_manager, *this, m_contains_p),
m_transf(*this),
m_trail(*this),
m_pinned(m),
m_bind_variables(m),
m_rule_set(*this),
m_transformed_rule_set(*this),
m_rule_fmls_head(0),
m_rule_fmls(m),
m_background(m),
m_mc(nullptr),
m_rel(nullptr),
m_engine(nullptr),
m_closed(false),
m_saturation_was_run(false),
m_enable_bind_variables(true),
m_last_status(OK),
m_last_answer(m),
m_last_ground_answer(m),
m_engine_type(LAST_ENGINE) {
re.set_context(this);
updt_params(pa);
}
rw_cfg(ast_manager & _m, params_ref const & p):
m(_m),
m_defined_names(m, 0 /* don't use prefix */) {
updt_params(p);
m_set = 0;
m_num_fresh = 0;
}
blaster_rewriter_cfg(ast_manager & m, blaster & b, params_ref const & p):
m_manager(m),
m_blaster(b),
m_in1(m),
m_in2(m),
m_out(m),
m_bindings(m) {
updt_params(p);
}
bound_propagator::bound_propagator(numeral_manager & _m, allocator & a, params_ref const & p):
m(_m),
m_allocator(a),
m_eq_manager(m, a) {
m_timestamp = 0;
m_qhead = 0;
m_conflict = null_var;
updt_params(p);
reset_statistics();
}
rw_cfg(ast_manager & m, params_ref const & p):
m_manager(m),
m_util(m),
m_saved(m),
m_bit1(m),
m_bit0(m) {
m_bit1 = butil().mk_numeral(rational(1), 1);
m_bit0 = butil().mk_numeral(rational(0), 1);
updt_params(p);
}
fpa2bv_rewriter_cfg::fpa2bv_rewriter_cfg(ast_manager & m, fpa2bv_converter & c, params_ref const & p) :
m_manager(m),
m_out(m),
m_conv(c),
m_bindings(m)
{
updt_params(p);
// We need to make sure that the mananger has the BV plugin loaded.
symbol s_bv("bv");
if (!m_manager.has_plugin(s_bv))
m_manager.register_plugin(s_bv, alloc(bv_decl_plugin));
}
sls_engine::sls_engine(ast_manager & m, params_ref const & p) :
m_manager(m),
m_powers(m_mpz_manager),
m_zero(m_mpz_manager.mk_z(0)),
m_one(m_mpz_manager.mk_z(1)),
m_two(m_mpz_manager.mk_z(2)),
m_bv_util(m),
m_tracker(m, m_bv_util, m_mpz_manager, m_powers),
m_evaluator(m, m_bv_util, m_tracker, m_mpz_manager, m_powers)
{
updt_params(p);
m_tracker.updt_params(p);
}
lackr::lackr(ast_manager& m, const params_ref& p, lackr_stats& st,
const ptr_vector<expr>& formulas, solver * uffree_solver)
: m_m(m)
, m_p(p)
, m_formulas(formulas)
, m_abstr(m)
, m_sat(uffree_solver)
, m_ackr_helper(m)
, m_simp(m)
, m_ackrs(m)
, m_st(st)
, m_is_init(false)
{
updt_params(p);
}
bvarray2uf_rewriter_cfg::bvarray2uf_rewriter_cfg(ast_manager & m, params_ref const & p) :
m_manager(m),
m_out(m),
m_bindings(m),
m_bv_util(m),
m_array_util(m),
m_emc(0),
m_fmc(0),
extra_assertions(m) {
updt_params(p);
// We need to make sure that the mananger has the BV and array plugins loaded.
symbol s_bv("bv");
if (!m_manager.has_plugin(s_bv))
m_manager.register_plugin(s_bv, alloc(bv_decl_plugin));
symbol s_array("array");
if (!m_manager.has_plugin(s_array))
m_manager.register_plugin(s_array, alloc(array_decl_plugin));
}
inc_sat_solver(ast_manager& m, params_ref const& p, bool incremental_mode):
m(m),
m_solver(p, m.limit()),
m_fmls(m),
m_asmsf(m),
m_fmls_head(0),
m_core(m),
m_map(m),
m_is_cnf(true),
m_num_scopes(0),
m_unknown("no reason given"),
m_internalized_converted(false),
m_internalized_fmls(m) {
updt_params(p);
m_mcs.push_back(nullptr);
init_preprocess();
m_solver.set_incremental(incremental_mode && !override_incremental());
}
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) {
SASSERT(g->is_well_sorted());
mc = 0; pc = 0; core = 0;
tactic_report report("horn", *g);
bool produce_proofs = g->proofs_enabled();
if (produce_proofs) {
if (!m_ctx.get_params().generate_proof_trace()) {
params_ref params = m_ctx.get_params().p;
params.set_bool("generate_proof_trace", true);
updt_params(params);
}
}
unsigned sz = g->size();
expr_ref q(m), f(m);
expr_ref_vector queries(m);
std::stringstream msg;
m_ctx.reset();
m_ctx.ensure_opened();
for (unsigned i = 0; i < sz; i++) {
f = g->form(i);
formula_kind k = get_formula_kind(f);
switch(k) {
case IS_RULE:
m_ctx.add_rule(f, symbol::null);
break;
case IS_QUERY:
queries.push_back(f);
break;
default:
msg << "formula is not in Horn fragment: " << mk_pp(g->form(i), m) << "\n";
TRACE("horn", tout << msg.str(););
throw tactic_exception(msg.str().c_str());
}
}
context::context(ast_manager& m):
m(m),
m_arith(m),
m_bv(m),
m_hard_constraints(m),
m_solver(0),
m_box_index(UINT_MAX),
m_optsmt(m),
m_scoped_state(m),
m_fm(m),
m_objective_refs(m),
m_enable_sat(false),
m_is_clausal(false),
m_pp_neat(false)
{
params_ref p;
p.set_bool("model", true);
p.set_bool("unsat_core", true);
p.set_bool("elim_to_real", true);
updt_params(p);
}
fpa_rewriter::fpa_rewriter(ast_manager & m, params_ref const & p) :
m_util(m),
m_fm(m_util.fm()),
m_hi_fp_unspecified(true) {
updt_params(p);
}
void context_params::updt_params() {
updt_params(gparams::get());
}
aig_tactic(params_ref const & p = params_ref()):m_aig_manager(0) {
updt_params(p);
}
float_rewriter::float_rewriter(ast_manager & m, params_ref const & p):
m_util(m) {
updt_params(p);
}
context_params::context_params() {
updt_params();
}
