mirror of
https://github.com/Z3Prover/z3
synced 2025-04-24 09:35:32 +00:00
Use override rather than virtual.
This commit is contained in:
Bruce Mitchener
parent
2b847478a2
commit
b7d1753843
138 changed files with 1621 additions and 1624 deletions
|
|
@ -46,7 +46,7 @@ public:
|
|||
updt_params(p);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
aig_tactic * t = alloc(aig_tactic);
|
||||
t->m_max_memory = m_max_memory;
|
||||
t->m_aig_gate_encoding = m_aig_gate_encoding;
|
||||
|
|
@ -54,13 +54,13 @@ public:
|
|||
return t;
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_max_memory = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX));
|
||||
m_aig_gate_encoding = p.get_bool("aig_default_gate_encoding", true);
|
||||
m_aig_per_assertion = p.get_bool("aig_per_assertion", true);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
insert_max_memory(r);
|
||||
r.insert("aig_per_assertion", CPK_BOOL, "(default: true) process one assertion at a time.");
|
||||
}
|
||||
|
|
@ -90,11 +90,11 @@ public:
|
|||
SASSERT(g->is_well_sorted());
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
fail_if_proof_generation("aig", g);
|
||||
mc = 0; pc = 0; core = 0;
|
||||
operator()(g);
|
||||
|
|
@ -102,7 +102,7 @@ public:
|
|||
result.push_back(g.get());
|
||||
}
|
||||
|
||||
virtual void cleanup() {}
|
||||
void cleanup() override {}
|
||||
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -48,10 +48,10 @@ bool is_unbounded(goal const & g) {
|
|||
|
||||
class is_unbounded_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return is_unbounded(g);
|
||||
}
|
||||
virtual ~is_unbounded_probe() {}
|
||||
~is_unbounded_probe() override {}
|
||||
};
|
||||
|
||||
probe * mk_is_unbounded_probe() {
|
||||
|
|
@ -142,33 +142,33 @@ public:
|
|||
m_imp = alloc(imp, m, p);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(add_bounds_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~add_bounds_tactic() {
|
||||
~add_bounds_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
m_imp->updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
r.insert("add_bound_lower", CPK_NUMERAL, "(default: -2) lower bound to be added to unbounded variables.");
|
||||
r.insert("add_bound_upper", CPK_NUMERAL, "(default: 2) upper bound to be added to unbounded variables.");
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
(*m_imp)(g, result, mc, pc, core);
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
imp * d = alloc(imp, m_imp->m, m_params);
|
||||
std::swap(d, m_imp);
|
||||
dealloc(d);
|
||||
|
|
|
|||
|
|
@ -23,15 +23,15 @@ struct arith_bounds_tactic : public tactic {
|
|||
ast_manager& get_manager() { return m; }
|
||||
|
||||
|
||||
virtual void operator()(/* in */ goal_ref const & in,
|
||||
/* out */ goal_ref_buffer & result,
|
||||
/* out */ model_converter_ref & mc,
|
||||
/* out */ proof_converter_ref & pc,
|
||||
/* out */ expr_dependency_ref & core) {
|
||||
void operator()(/* in */ goal_ref const & in,
|
||||
/* out */ goal_ref_buffer & result,
|
||||
/* out */ model_converter_ref & mc,
|
||||
/* out */ proof_converter_ref & pc,
|
||||
/* out */ expr_dependency_ref & core) override {
|
||||
bounds_arith_subsumption(in, result);
|
||||
}
|
||||
|
||||
virtual tactic* translate(ast_manager & mgr) {
|
||||
tactic* translate(ast_manager & mgr) override {
|
||||
return alloc(arith_bounds_tactic, mgr);
|
||||
}
|
||||
|
||||
|
|
@ -146,7 +146,7 @@ struct arith_bounds_tactic : public tactic {
|
|||
TRACE("arith_subsumption", s->display(tout); );
|
||||
}
|
||||
|
||||
virtual void cleanup() {}
|
||||
void cleanup() override {}
|
||||
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -36,26 +36,26 @@ public:
|
|||
m_params(p) {
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(card2bv_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~card2bv_tactic() {
|
||||
~card2bv_tactic() override {
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
}
|
||||
|
||||
|
||||
virtual void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
TRACE("card2bv-before", g->display(tout););
|
||||
SASSERT(g->is_well_sorted());
|
||||
mc = 0; pc = 0; core = 0; result.reset();
|
||||
|
|
@ -101,7 +101,7 @@ public:
|
|||
SASSERT(g->is_well_sorted());
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -297,23 +297,23 @@ public:
|
|||
m_imp = alloc(imp, m);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(degree_shift_tactic, m);
|
||||
}
|
||||
|
||||
virtual ~degree_shift_tactic() {
|
||||
~degree_shift_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
(*m_imp)(in, result, mc, pc, core);
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
imp * d = alloc(imp, m_imp->m);
|
||||
std::swap(d, m_imp);
|
||||
dealloc(d);
|
||||
|
|
|
|||
|
|
@ -354,28 +354,28 @@ public:
|
|||
m_imp = alloc(imp, m, p);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(diff_neq_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~diff_neq_tactic() {
|
||||
~diff_neq_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
m_imp->updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
r.insert("diff_neq_max_k", CPK_UINT, "(default: 1024) maximum variable upper bound for diff neq solver.");
|
||||
}
|
||||
|
||||
virtual void collect_statistics(statistics & st) const {
|
||||
void collect_statistics(statistics & st) const override {
|
||||
st.update("conflicts", m_imp->m_num_conflicts);
|
||||
}
|
||||
|
||||
virtual void reset_statistics() {
|
||||
void reset_statistics() override {
|
||||
m_imp->m_num_conflicts = 0;
|
||||
}
|
||||
|
||||
|
|
@ -383,15 +383,15 @@ public:
|
|||
\brief Fix a DL variable in s to 0.
|
||||
If s is not really in the difference logic fragment, then this is a NOOP.
|
||||
*/
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
(*m_imp)(in, result, mc, pc, core);
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
imp * d = alloc(imp, m_imp->m, m_params);
|
||||
d->m_num_conflicts = m_imp->m_num_conflicts;
|
||||
std::swap(d, m_imp);
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@ public:
|
|||
m_refs(m)
|
||||
{}
|
||||
|
||||
virtual void operator()(model_ref & old_model, unsigned goal_idx) {
|
||||
void operator()(model_ref & old_model, unsigned goal_idx) override {
|
||||
SASSERT(goal_idx == 0);
|
||||
model * new_model = alloc(model, m);
|
||||
unsigned num = old_model->get_num_constants();
|
||||
|
|
@ -106,7 +106,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual model_converter * translate(ast_translation & translator) {
|
||||
model_converter * translate(ast_translation & translator) override {
|
||||
bool2int_model_converter* mc = alloc(bool2int_model_converter, translator.to());
|
||||
for (unsigned i = 0; i < m_nums_as_int.size(); ++i) {
|
||||
mc->insert(m_nums_as_int[i], m_nums_as_bool[i].size(), m_nums_as_bool[i].c_ptr());
|
||||
|
|
@ -134,24 +134,24 @@ public:
|
|||
m_max_hi(rational(m_max_hi_default)) {
|
||||
}
|
||||
|
||||
virtual ~elim01_tactic() {
|
||||
~elim01_tactic() override {
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_max_hi = rational(p.get_uint("max_coefficient", m_max_hi_default));
|
||||
m_params = p;
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
r.insert("max_coefficient", CPK_UINT, "(default: 1) maximal upper bound for finite range -> Bool conversion");
|
||||
}
|
||||
|
||||
|
||||
virtual void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
expr_dependency_ref & core) override {
|
||||
SASSERT(g->is_well_sorted());
|
||||
mc = 0; pc = 0; core = 0;
|
||||
|
||||
|
|
@ -211,11 +211,11 @@ public:
|
|||
// TBD: support proof conversion (or not..)
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(elim01_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual void cleanup() {}
|
||||
void cleanup() override {}
|
||||
|
||||
void add_variable(bool2int_model_converter* b2i,
|
||||
expr_safe_replace& sub,
|
||||
|
|
|
|||
|
|
@ -82,7 +82,7 @@ class eq2bv_tactic : public tactic {
|
|||
m_map.insert(c_new, c_old);
|
||||
}
|
||||
|
||||
virtual void operator()(model_ref& mdl) {
|
||||
void operator()(model_ref& mdl) override {
|
||||
ast_manager& m = mdl->get_manager();
|
||||
bv_util bv(m);
|
||||
arith_util a(m);
|
||||
|
|
@ -105,7 +105,7 @@ class eq2bv_tactic : public tactic {
|
|||
mdl = new_m;
|
||||
}
|
||||
|
||||
virtual model_converter* translate(ast_translation & translator) {
|
||||
model_converter* translate(ast_translation & translator) override {
|
||||
bvmc* v = alloc(bvmc);
|
||||
obj_map<func_decl, func_decl*>::iterator it = m_map.begin(), end = m_map.end();
|
||||
for (; it != end; ++it) {
|
||||
|
|
@ -136,19 +136,18 @@ public:
|
|||
m_bounds(m) {
|
||||
}
|
||||
|
||||
virtual ~eq2bv_tactic() {
|
||||
~eq2bv_tactic() override {
|
||||
}
|
||||
|
||||
|
||||
void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
}
|
||||
|
||||
virtual void operator()(
|
||||
goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
SASSERT(g->is_well_sorted());
|
||||
mc = 0; pc = 0; core = 0;
|
||||
m_trail.reset();
|
||||
|
|
@ -213,14 +212,14 @@ public:
|
|||
}
|
||||
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(eq2bv_tactic, m);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
}
|
||||
|
||||
void cleanup_fd(ref<bvmc>& mc) {
|
||||
|
|
|
|||
|
|
@ -293,30 +293,30 @@ public:
|
|||
m_imp = alloc(imp, m, p);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(factor_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~factor_tactic() {
|
||||
~factor_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
m_imp->m_rw.cfg().updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
r.insert("split_factors", CPK_BOOL,
|
||||
"(default: true) apply simplifications such as (= (* p1 p2) 0) --> (or (= p1 0) (= p2 0)).");
|
||||
polynomial::factor_params::get_param_descrs(r);
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
try {
|
||||
(*m_imp)(in, result, mc, pc, core);
|
||||
}
|
||||
|
|
@ -328,7 +328,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
imp * d = alloc(imp, m_imp->m, m_params);
|
||||
std::swap(d, m_imp);
|
||||
dealloc(d);
|
||||
|
|
|
|||
|
|
@ -303,28 +303,28 @@ public:
|
|||
m_imp = alloc(imp, m, p);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(fix_dl_var_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~fix_dl_var_tactic() {
|
||||
~fix_dl_var_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
m_imp->updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
th_rewriter::get_param_descrs(r);
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
try {
|
||||
(*m_imp)(in, result, mc, pc, core);
|
||||
}
|
||||
|
|
@ -333,7 +333,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
imp * d = alloc(imp, m_imp->m, m_params);
|
||||
std::swap(d, m_imp);
|
||||
dealloc(d);
|
||||
|
|
|
|||
|
|
@ -164,7 +164,7 @@ class fm_tactic : public tactic {
|
|||
public:
|
||||
fm_model_converter(ast_manager & _m):m(_m) {}
|
||||
|
||||
virtual ~fm_model_converter() {
|
||||
~fm_model_converter() override {
|
||||
m.dec_array_ref(m_xs.size(), m_xs.c_ptr());
|
||||
vector<clauses>::iterator it = m_clauses.begin();
|
||||
vector<clauses>::iterator end = m_clauses.end();
|
||||
|
|
@ -180,7 +180,7 @@ class fm_tactic : public tactic {
|
|||
m_clauses.back().swap(c);
|
||||
}
|
||||
|
||||
virtual void operator()(model_ref & md, unsigned goal_idx) {
|
||||
void operator()(model_ref & md, unsigned goal_idx) override {
|
||||
TRACE("fm_mc", model_v2_pp(tout, *md); display(tout););
|
||||
model_evaluator ev(*(md.get()));
|
||||
ev.set_model_completion(true);
|
||||
|
|
@ -244,7 +244,7 @@ class fm_tactic : public tactic {
|
|||
}
|
||||
|
||||
|
||||
virtual void display(std::ostream & out) {
|
||||
void display(std::ostream & out) override {
|
||||
out << "(fm-model-converter";
|
||||
SASSERT(m_xs.size() == m_clauses.size());
|
||||
unsigned sz = m_xs.size();
|
||||
|
|
@ -261,7 +261,7 @@ class fm_tactic : public tactic {
|
|||
out << ")\n";
|
||||
}
|
||||
|
||||
virtual model_converter * translate(ast_translation & translator) {
|
||||
model_converter * translate(ast_translation & translator) override {
|
||||
ast_manager & to_m = translator.to();
|
||||
fm_model_converter * res = alloc(fm_model_converter, to_m);
|
||||
unsigned sz = m_xs.size();
|
||||
|
|
@ -1643,20 +1643,20 @@ public:
|
|||
m_imp = alloc(imp, m, p);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(fm_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~fm_tactic() {
|
||||
~fm_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
m_imp->updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
insert_produce_models(r);
|
||||
insert_max_memory(r);
|
||||
r.insert("fm_real_only", CPK_BOOL, "(default: true) consider only real variables for fourier-motzkin elimination.");
|
||||
|
|
@ -1668,17 +1668,17 @@ public:
|
|||
}
|
||||
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
imp * d = alloc(imp, m_imp->m, m_params);
|
||||
std::swap(d, m_imp);
|
||||
dealloc(d);
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
(*m_imp)(in, result, mc, pc, core);
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -148,21 +148,21 @@ public:
|
|||
m_compile_equality(false) {
|
||||
}
|
||||
|
||||
virtual ~lia2card_tactic() {
|
||||
~lia2card_tactic() override {
|
||||
dealloc(m_todo);
|
||||
dealloc(m_01s);
|
||||
}
|
||||
|
||||
void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
m_compile_equality = p.get_bool("compile_equality", false);
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
expr_dependency_ref & core) override {
|
||||
SASSERT(g->is_well_sorted());
|
||||
mc = 0; pc = 0; core = 0;
|
||||
m_01s->reset();
|
||||
|
|
@ -389,16 +389,16 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(lia2card_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
r.insert("compile_equality", CPK_BOOL,
|
||||
"(default:false) compile equalities into pseudo-Boolean equality");
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
expr_set* d = alloc(expr_set);
|
||||
ptr_vector<expr>* todo = alloc(ptr_vector<expr>);
|
||||
std::swap(m_01s, d);
|
||||
|
|
|
|||
|
|
@ -313,30 +313,30 @@ public:
|
|||
m_imp = alloc(imp, m, p);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(lia2pb_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~lia2pb_tactic() {
|
||||
~lia2pb_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
m_imp->updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
r.insert("lia2pb_partial", CPK_BOOL, "(default: false) partial lia2pb conversion.");
|
||||
r.insert("lia2pb_max_bits", CPK_UINT, "(default: 32) maximum number of bits to be used (per variable) in lia2pb.");
|
||||
r.insert("lia2pb_total_bits", CPK_UINT, "(default: 2048) total number of bits to be used (per problem) in lia2pb.");
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
try {
|
||||
(*m_imp)(in, result, mc, pc, core);
|
||||
}
|
||||
|
|
@ -345,7 +345,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
imp * d = alloc(imp, m_imp->m, m_params);
|
||||
std::swap(d, m_imp);
|
||||
dealloc(d);
|
||||
|
|
|
|||
|
|
@ -418,18 +418,18 @@ public:
|
|||
m_imp(0) {
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(nla2bv_tactic, m_params);
|
||||
}
|
||||
|
||||
virtual ~nla2bv_tactic() {
|
||||
~nla2bv_tactic() override {
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
r.insert("nla2bv_max_bv_size", CPK_UINT, "(default: inf) maximum bit-vector size used by nla2bv tactic");
|
||||
r.insert("nla2bv_bv_size", CPK_UINT, "(default: 4) default bit-vector size used by nla2bv tactic.");
|
||||
r.insert("nla2bv_root", CPK_UINT, "(default: 2) nla2bv tactic encodes reals into bit-vectors using expressions of the form a+b*sqrt(c), this parameter sets the value of c used in the encoding.");
|
||||
|
|
@ -441,11 +441,11 @@ public:
|
|||
arithmetic in place of non-linear integer arithmetic.
|
||||
\return false if transformation is not possible.
|
||||
*/
|
||||
virtual void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
SASSERT(g->is_well_sorted());
|
||||
fail_if_proof_generation("nla2bv", g);
|
||||
fail_if_unsat_core_generation("nla2bv", g);
|
||||
|
|
@ -459,7 +459,7 @@ public:
|
|||
SASSERT(g->is_well_sorted());
|
||||
}
|
||||
|
||||
virtual void cleanup(void) {
|
||||
void cleanup(void) override {
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -156,28 +156,28 @@ public:
|
|||
m_imp = alloc(imp, m, p);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(normalize_bounds_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~normalize_bounds_tactic() {
|
||||
~normalize_bounds_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_imp->updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
insert_produce_models(r);
|
||||
r.insert("norm_int_only", CPK_BOOL, "(default: true) normalize only the bounds of integer constants.");
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
try {
|
||||
(*m_imp)(in, result, mc, pc, core);
|
||||
}
|
||||
|
|
@ -186,7 +186,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
ast_manager & m = m_imp->m;
|
||||
imp * d = alloc(imp, m, m_params);
|
||||
std::swap(d, m_imp);
|
||||
|
|
|
|||
|
|
@ -30,11 +30,11 @@ class pb2bv_model_converter : public model_converter {
|
|||
public:
|
||||
pb2bv_model_converter(ast_manager & _m);
|
||||
pb2bv_model_converter(ast_manager & _m, obj_map<func_decl, expr*> const & c2bit, bound_manager const & bm);
|
||||
virtual ~pb2bv_model_converter();
|
||||
virtual void operator()(model_ref & md);
|
||||
virtual void operator()(model_ref & md, unsigned goal_idx);
|
||||
virtual void display(std::ostream & out);
|
||||
virtual model_converter * translate(ast_translation & translator);
|
||||
~pb2bv_model_converter() override;
|
||||
void operator()(model_ref & md) override;
|
||||
void operator()(model_ref & md, unsigned goal_idx) override;
|
||||
void display(std::ostream & out) override;
|
||||
model_converter * translate(ast_translation & translator) override;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -983,32 +983,32 @@ public:
|
|||
m_imp = alloc(imp, m, p);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(pb2bv_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~pb2bv_tactic() {
|
||||
~pb2bv_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
m_imp->updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
m_imp->collect_param_descrs(r);
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
(*m_imp)(in, result, mc, pc, core);
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
ast_manager & m = m_imp->m;
|
||||
imp * d = alloc(imp, m, m_params);
|
||||
std::swap(d, m_imp);
|
||||
|
|
@ -1023,7 +1023,7 @@ tactic * mk_pb2bv_tactic(ast_manager & m, params_ref const & p) {
|
|||
}
|
||||
|
||||
struct is_pb_probe : public probe {
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
try {
|
||||
ast_manager & m = g.m();
|
||||
bound_manager bm(m);
|
||||
|
|
|
|||
|
|
@ -74,7 +74,7 @@ class arith_degree_probe : public probe {
|
|||
public:
|
||||
arith_degree_probe(bool avg):m_avg(avg) {}
|
||||
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
proc p(g.m());
|
||||
for_each_expr_at(p, g);
|
||||
if (m_avg)
|
||||
|
|
@ -117,7 +117,7 @@ class arith_bw_probe : public probe {
|
|||
public:
|
||||
arith_bw_probe(bool avg):m_avg(avg) {}
|
||||
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
proc p(g.m());
|
||||
for_each_expr_at(p, g);
|
||||
if (m_avg)
|
||||
|
|
@ -269,14 +269,14 @@ static bool is_qfauflia(goal const & g) {
|
|||
|
||||
class is_qflia_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return is_qflia(g);
|
||||
}
|
||||
};
|
||||
|
||||
class is_qfauflia_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return is_qfauflia(g);
|
||||
}
|
||||
};
|
||||
|
|
@ -288,7 +288,7 @@ static bool is_qflra(goal const & g) {
|
|||
|
||||
class is_qflra_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return is_qflra(g);
|
||||
}
|
||||
};
|
||||
|
|
@ -300,7 +300,7 @@ static bool is_qflira(goal const & g) {
|
|||
|
||||
class is_qflira_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return is_qflira(g);
|
||||
}
|
||||
};
|
||||
|
|
@ -344,14 +344,14 @@ static bool is_mip(goal const & g) {
|
|||
|
||||
class is_ilp_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return is_ilp(g);
|
||||
}
|
||||
};
|
||||
|
||||
class is_mip_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return is_mip(g);
|
||||
}
|
||||
};
|
||||
|
|
@ -583,56 +583,56 @@ struct is_non_qfufnra_functor {
|
|||
|
||||
class is_qfnia_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return is_qfnia(g);
|
||||
}
|
||||
};
|
||||
|
||||
class is_qfnra_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return is_qfnra(g);
|
||||
}
|
||||
};
|
||||
|
||||
class is_nia_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return is_nia(g);
|
||||
}
|
||||
};
|
||||
|
||||
class is_nra_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return is_nra(g);
|
||||
}
|
||||
};
|
||||
|
||||
class is_nira_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return is_nira(g);
|
||||
}
|
||||
};
|
||||
|
||||
class is_lia_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return is_lia(g);
|
||||
}
|
||||
};
|
||||
|
||||
class is_lra_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return is_lra(g);
|
||||
}
|
||||
};
|
||||
|
||||
class is_lira_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return is_lira(g);
|
||||
}
|
||||
};
|
||||
|
|
@ -644,7 +644,7 @@ static bool is_qfufnra(goal const& g) {
|
|||
|
||||
class is_qfufnra_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return is_qfufnra(g);
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -43,18 +43,18 @@ class propagate_ineqs_tactic : public tactic {
|
|||
public:
|
||||
propagate_ineqs_tactic(ast_manager & m, params_ref const & p);
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(propagate_ineqs_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~propagate_ineqs_tactic();
|
||||
~propagate_ineqs_tactic() override;
|
||||
|
||||
virtual void updt_params(params_ref const & p);
|
||||
virtual void collect_param_descrs(param_descrs & r) {}
|
||||
void updt_params(params_ref const & p) override;
|
||||
void collect_param_descrs(param_descrs & r) override {}
|
||||
|
||||
virtual void operator()(goal_ref const & g, goal_ref_buffer & result, model_converter_ref & mc, proof_converter_ref & pc, expr_dependency_ref & core);
|
||||
void operator()(goal_ref const & g, goal_ref_buffer & result, model_converter_ref & mc, proof_converter_ref & pc, expr_dependency_ref & core) override;
|
||||
|
||||
virtual void cleanup();
|
||||
void cleanup() override;
|
||||
};
|
||||
|
||||
tactic * mk_propagate_ineqs_tactic(ast_manager & m, params_ref const & p) {
|
||||
|
|
|
|||
|
|
@ -802,18 +802,18 @@ public:
|
|||
m_params(p) {
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(purify_arith_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~purify_arith_tactic() {
|
||||
~purify_arith_tactic() override {
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
r.insert("complete", CPK_BOOL,
|
||||
"(default: true) add constraints to make sure that any interpretation of a underspecified arithmetic operators is a function. The result will include additional uninterpreted functions/constants: /0, div0, mod0, 0^0, neg-root");
|
||||
r.insert("elim_root_objects", CPK_BOOL,
|
||||
|
|
@ -823,11 +823,11 @@ public:
|
|||
th_rewriter::get_param_descrs(r);
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
try {
|
||||
SASSERT(g->is_well_sorted());
|
||||
mc = 0; pc = 0; core = 0;
|
||||
|
|
@ -852,7 +852,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
}
|
||||
|
||||
};
|
||||
|
|
|
|||
|
|
@ -390,29 +390,29 @@ public:
|
|||
m_imp = alloc(imp, m, p);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(recover_01_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~recover_01_tactic() {
|
||||
~recover_01_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
m_imp->updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
th_rewriter::get_param_descrs(r);
|
||||
r.insert("recover_01_max_bits", CPK_UINT, "(default: 10) maximum number of bits to consider in a clause.");
|
||||
}
|
||||
|
||||
void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
expr_dependency_ref & core) override {
|
||||
try {
|
||||
(*m_imp)(g, result, mc, pc, core);
|
||||
}
|
||||
|
|
@ -421,7 +421,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
imp * d = alloc(imp, m_imp->m, m_params);
|
||||
std::swap(d, m_imp);
|
||||
dealloc(d);
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ struct bit_blaster_model_converter : public model_converter {
|
|||
}
|
||||
}
|
||||
|
||||
virtual ~bit_blaster_model_converter() {
|
||||
~bit_blaster_model_converter() override {
|
||||
}
|
||||
|
||||
void collect_bits(obj_hashtable<func_decl> & bits) {
|
||||
|
|
@ -142,7 +142,7 @@ struct bit_blaster_model_converter : public model_converter {
|
|||
}
|
||||
}
|
||||
|
||||
virtual void operator()(model_ref & md, unsigned goal_idx) {
|
||||
void operator()(model_ref & md, unsigned goal_idx) override {
|
||||
SASSERT(goal_idx == 0);
|
||||
model * new_model = alloc(model, m());
|
||||
obj_hashtable<func_decl> bits;
|
||||
|
|
@ -152,11 +152,11 @@ struct bit_blaster_model_converter : public model_converter {
|
|||
md = new_model;
|
||||
}
|
||||
|
||||
virtual void operator()(model_ref & md) {
|
||||
void operator()(model_ref & md) override {
|
||||
operator()(md, 0);
|
||||
}
|
||||
|
||||
virtual void display(std::ostream & out) {
|
||||
void display(std::ostream & out) override {
|
||||
out << "(bit-blaster-model-converter";
|
||||
unsigned sz = m_vars.size();
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
|
|
@ -171,7 +171,7 @@ protected:
|
|||
bit_blaster_model_converter(ast_manager & m):m_vars(m), m_bits(m) { }
|
||||
public:
|
||||
|
||||
virtual model_converter * translate(ast_translation & translator) {
|
||||
model_converter * translate(ast_translation & translator) override {
|
||||
bit_blaster_model_converter * res = alloc(bit_blaster_model_converter, translator.to());
|
||||
for (unsigned i = 0; i < m_vars.size(); i++)
|
||||
res->m_vars.push_back(translator(m_vars[i].get()));
|
||||
|
|
|
|||
|
|
@ -111,21 +111,21 @@ public:
|
|||
m_imp = alloc(imp, m, m_rewriter, p);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
SASSERT(!m_rewriter); // assume translation isn't used where rewriter is external.
|
||||
return alloc(bit_blaster_tactic, m, 0, m_params);
|
||||
}
|
||||
|
||||
virtual ~bit_blaster_tactic() {
|
||||
~bit_blaster_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
m_imp->updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
insert_max_memory(r);
|
||||
insert_max_steps(r);
|
||||
r.insert("blast_mul", CPK_BOOL, "(default: true) bit-blast multipliers (and dividers, remainders).");
|
||||
|
|
@ -134,11 +134,11 @@ public:
|
|||
r.insert("blast_full", CPK_BOOL, "(default: false) bit-blast any term with bit-vector sort, this option will make E-matching ineffective in any pattern containing bit-vector terms.");
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
try {
|
||||
(*m_imp)(g, result, mc, pc, core);
|
||||
}
|
||||
|
|
@ -147,7 +147,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
imp * d = alloc(imp, m_imp->m(), m_rewriter, m_params);
|
||||
std::swap(d, m_imp);
|
||||
dealloc(d);
|
||||
|
|
|
|||
|
|
@ -426,20 +426,20 @@ public:
|
|||
m_imp = alloc(imp, m, p);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(bv1_blaster_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~bv1_blaster_tactic() {
|
||||
~bv1_blaster_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
m_imp->m_rw.cfg().updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
insert_max_memory(r);
|
||||
insert_max_steps(r);
|
||||
}
|
||||
|
|
@ -454,15 +454,15 @@ public:
|
|||
It also does not support quantifiers.
|
||||
Return a model_converter that converts any model for the updated set into a model for the old set.
|
||||
*/
|
||||
virtual void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
(*m_imp)(g, result, mc, pc, core);
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
imp * d = alloc(imp, m_imp->m(), m_params);
|
||||
std::swap(d, m_imp);
|
||||
dealloc(d);
|
||||
|
|
@ -480,7 +480,7 @@ tactic * mk_bv1_blaster_tactic(ast_manager & m, params_ref const & p) {
|
|||
|
||||
class is_qfbv_eq_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
bv1_blaster_tactic t(g.m());
|
||||
return t.is_target(g);
|
||||
|
||||
|
|
|
|||
|
|
@ -111,7 +111,7 @@ struct bv_bound_chk_rewriter : public rewriter_tpl<bv_bound_chk_rewriter_cfg> {
|
|||
updt_params(p);
|
||||
}
|
||||
|
||||
virtual ~bv_bound_chk_rewriter() {}
|
||||
~bv_bound_chk_rewriter() override {}
|
||||
|
||||
void updt_params(params_ref const & _p) {
|
||||
m_cfg.updt_params(_p);
|
||||
|
|
@ -135,17 +135,17 @@ class bv_bound_chk_tactic : public tactic {
|
|||
bv_bound_chk_stats m_stats;
|
||||
public:
|
||||
bv_bound_chk_tactic(ast_manager & m, params_ref const & p);
|
||||
virtual ~bv_bound_chk_tactic();
|
||||
~bv_bound_chk_tactic() override;
|
||||
void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core);
|
||||
virtual tactic * translate(ast_manager & m);
|
||||
virtual void updt_params(params_ref const & p);
|
||||
void cleanup();
|
||||
void collect_statistics(statistics & st) const;
|
||||
void reset_statistics();
|
||||
expr_dependency_ref & core) override;
|
||||
tactic * translate(ast_manager & m) override;
|
||||
void updt_params(params_ref const & p) override;
|
||||
void cleanup() override;
|
||||
void collect_statistics(statistics & st) const override;
|
||||
void reset_statistics() override;
|
||||
};
|
||||
|
||||
class bv_bound_chk_tactic::imp {
|
||||
|
|
|
|||
|
|
@ -305,7 +305,7 @@ namespace {
|
|||
updt_params(p);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_propagate_eq = p.get_bool("propagate_eq", false);
|
||||
}
|
||||
|
||||
|
|
@ -313,7 +313,7 @@ namespace {
|
|||
r.insert("propagate-eq", CPK_BOOL, "(default: false) propagate equalities from inequalities");
|
||||
}
|
||||
|
||||
virtual ~bv_bounds_simplifier() {
|
||||
~bv_bounds_simplifier() override {
|
||||
for (unsigned i = 0, e = m_expr_vars.size(); i < e; ++i) {
|
||||
dealloc(m_expr_vars[i]);
|
||||
}
|
||||
|
|
@ -322,7 +322,7 @@ namespace {
|
|||
}
|
||||
}
|
||||
|
||||
virtual bool assert_expr(expr * t, bool sign) {
|
||||
bool assert_expr(expr * t, bool sign) override {
|
||||
while (m.is_not(t, t)) {
|
||||
sign = !sign;
|
||||
}
|
||||
|
|
@ -353,7 +353,7 @@ namespace {
|
|||
return true;
|
||||
}
|
||||
|
||||
virtual bool simplify(expr* t, expr_ref& result) {
|
||||
bool simplify(expr* t, expr_ref& result) override {
|
||||
expr* t1;
|
||||
interval b;
|
||||
|
||||
|
|
@ -465,7 +465,7 @@ namespace {
|
|||
return false;
|
||||
}
|
||||
|
||||
virtual bool may_simplify(expr* t) {
|
||||
bool may_simplify(expr* t) override {
|
||||
if (m_bv.is_numeral(t))
|
||||
return false;
|
||||
|
||||
|
|
@ -504,7 +504,7 @@ namespace {
|
|||
return false;
|
||||
}
|
||||
|
||||
virtual void pop(unsigned num_scopes) {
|
||||
void pop(unsigned num_scopes) override {
|
||||
TRACE("bv", tout << "pop: " << num_scopes << "\n";);
|
||||
if (m_scopes.empty())
|
||||
return;
|
||||
|
|
@ -526,11 +526,11 @@ namespace {
|
|||
m_scopes.shrink(target);
|
||||
}
|
||||
|
||||
virtual simplifier * translate(ast_manager & m) {
|
||||
simplifier * translate(ast_manager & m) override {
|
||||
return alloc(bv_bounds_simplifier, m, m_params);
|
||||
}
|
||||
|
||||
virtual unsigned scope_level() const {
|
||||
unsigned scope_level() const override {
|
||||
return m_scopes.size();
|
||||
}
|
||||
};
|
||||
|
|
@ -622,7 +622,7 @@ namespace {
|
|||
r.insert("propagate-eq", CPK_BOOL, "(default: false) propagate equalities from inequalities");
|
||||
}
|
||||
|
||||
virtual ~dom_bv_bounds_simplifier() {
|
||||
~dom_bv_bounds_simplifier() override {
|
||||
for (unsigned i = 0, e = m_expr_vars.size(); i < e; ++i) {
|
||||
dealloc(m_expr_vars[i]);
|
||||
}
|
||||
|
|
@ -631,7 +631,7 @@ namespace {
|
|||
}
|
||||
}
|
||||
|
||||
virtual bool assert_expr(expr * t, bool sign) {
|
||||
bool assert_expr(expr * t, bool sign) override {
|
||||
while (m.is_not(t, t)) {
|
||||
sign = !sign;
|
||||
}
|
||||
|
|
@ -662,7 +662,7 @@ namespace {
|
|||
return true;
|
||||
}
|
||||
|
||||
virtual void operator()(expr_ref& r) {
|
||||
void operator()(expr_ref& r) override {
|
||||
expr* t1, * t = r;
|
||||
interval b;
|
||||
|
||||
|
|
@ -781,7 +781,7 @@ namespace {
|
|||
return false;
|
||||
}
|
||||
|
||||
virtual void pop(unsigned num_scopes) {
|
||||
void pop(unsigned num_scopes) override {
|
||||
TRACE("bv", tout << "pop: " << num_scopes << "\n";);
|
||||
if (m_scopes.empty())
|
||||
return;
|
||||
|
|
@ -803,11 +803,11 @@ namespace {
|
|||
m_scopes.shrink(target);
|
||||
}
|
||||
|
||||
virtual dom_simplifier * translate(ast_manager & m) {
|
||||
dom_simplifier * translate(ast_manager & m) override {
|
||||
return alloc(dom_bv_bounds_simplifier, m, m_params);
|
||||
}
|
||||
|
||||
virtual unsigned scope_level() const {
|
||||
unsigned scope_level() const override {
|
||||
return m_scopes.size();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -34,15 +34,15 @@ class bv_size_reduction_tactic : public tactic {
|
|||
public:
|
||||
bv_size_reduction_tactic(ast_manager & m);
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(bv_size_reduction_tactic, m);
|
||||
}
|
||||
|
||||
virtual ~bv_size_reduction_tactic();
|
||||
~bv_size_reduction_tactic() override;
|
||||
|
||||
virtual void operator()(goal_ref const & g, goal_ref_buffer & result, model_converter_ref & mc, proof_converter_ref & pc, expr_dependency_ref & core);
|
||||
void operator()(goal_ref const & g, goal_ref_buffer & result, model_converter_ref & mc, proof_converter_ref & pc, expr_dependency_ref & core) override;
|
||||
|
||||
virtual void cleanup();
|
||||
void cleanup() override;
|
||||
};
|
||||
|
||||
tactic * mk_bv_size_reduction_tactic(ast_manager & m, params_ref const & p) {
|
||||
|
|
|
|||
|
|
@ -113,32 +113,32 @@ public:
|
|||
m_imp = alloc(imp, m, p);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(bvarray2uf_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~bvarray2uf_tactic() {
|
||||
~bvarray2uf_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
m_imp->updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
insert_produce_models(r);
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
(*m_imp)(in, result, mc, pc, core);
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
ast_manager & m = m_imp->m();
|
||||
imp * d = alloc(imp, m, m_params);
|
||||
std::swap(d, m_imp);
|
||||
|
|
|
|||
|
|
@ -95,8 +95,8 @@ class dt2bv_tactic : public tactic {
|
|||
struct sort_pred : public i_sort_pred {
|
||||
dt2bv_tactic& m_t;
|
||||
sort_pred(dt2bv_tactic& t): m_t(t) {}
|
||||
virtual ~sort_pred() {}
|
||||
virtual bool operator()(sort* s) {
|
||||
~sort_pred() override {}
|
||||
bool operator()(sort* s) override {
|
||||
return m_t.m_fd_sorts.contains(s);
|
||||
}
|
||||
};
|
||||
|
|
@ -107,21 +107,21 @@ public:
|
|||
dt2bv_tactic(ast_manager& m, params_ref const& p):
|
||||
m(m), m_params(p), m_dt(m), m_bv(m), m_is_fd(*this) {}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(dt2bv_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
mc = 0; pc = 0; core = 0;
|
||||
bool produce_proofs = g->proofs_enabled();
|
||||
tactic_report report("dt2bv", *g);
|
||||
|
|
@ -177,7 +177,7 @@ public:
|
|||
SASSERT(g->is_well_sorted());
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
m_fd_sorts.reset();
|
||||
m_non_fd_sorts.reset();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -268,34 +268,34 @@ public:
|
|||
m_imp = alloc(imp, m, p);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(elim_small_bv_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~elim_small_bv_tactic() {
|
||||
~elim_small_bv_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
m_imp->m_rw.cfg().updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
insert_max_memory(r);
|
||||
insert_max_steps(r);
|
||||
r.insert("max_bits", CPK_UINT, "(default: 4) maximum bit-vector size of quantified bit-vectors to be eliminated.");
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
expr_dependency_ref & core) override {
|
||||
(*m_imp)(in, result, mc, pc, core);
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
ast_manager & m = m_imp->m;
|
||||
m_imp->~imp();
|
||||
m_imp = new (m_imp) imp(m, m_params);
|
||||
|
|
|
|||
|
|
@ -278,35 +278,35 @@ public:
|
|||
m_imp = alloc(imp, m, p);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(max_bv_sharing_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~max_bv_sharing_tactic() {
|
||||
~max_bv_sharing_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
m_imp->m_rw.cfg().updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
insert_max_memory(r);
|
||||
insert_max_steps(r);
|
||||
r.insert("max_args", CPK_UINT,
|
||||
"(default: 128) maximum number of arguments (per application) that will be considered by the greedy (quadratic) heuristic.");
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
(*m_imp)(in, result, mc, pc, core);
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
ast_manager & m = m_imp->m();
|
||||
params_ref p = std::move(m_params);
|
||||
m_imp->~imp();
|
||||
|
|
|
|||
|
|
@ -58,16 +58,16 @@ protected:
|
|||
public:
|
||||
concat_converter(T * c1, T * c2):m_c1(c1), m_c2(c2) {}
|
||||
|
||||
virtual ~concat_converter() {}
|
||||
~concat_converter() override {}
|
||||
|
||||
virtual void cancel() {
|
||||
void cancel() override {
|
||||
m_c2->cancel();
|
||||
m_c1->cancel();
|
||||
}
|
||||
|
||||
virtual char const * get_name() const = 0;
|
||||
|
||||
virtual void display(std::ostream & out) {
|
||||
void display(std::ostream & out) override {
|
||||
out << "(" << get_name() << "\n";
|
||||
m_c1->display(out);
|
||||
m_c2->display(out);
|
||||
|
|
@ -104,7 +104,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual ~concat_star_converter() {
|
||||
~concat_star_converter() override {
|
||||
unsigned sz = m_c2s.size();
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
T * c2 = m_c2s[i];
|
||||
|
|
@ -113,7 +113,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual void cancel() {
|
||||
void cancel() override {
|
||||
if (m_c1)
|
||||
m_c1->cancel();
|
||||
unsigned num = m_c2s.size();
|
||||
|
|
@ -125,7 +125,7 @@ public:
|
|||
|
||||
virtual char const * get_name() const = 0;
|
||||
|
||||
virtual void display(std::ostream & out) {
|
||||
void display(std::ostream & out) override {
|
||||
out << "(" << get_name() << "\n";
|
||||
if (m_c1)
|
||||
m_c1->display(out);
|
||||
|
|
|
|||
|
|
@ -152,35 +152,35 @@ public:
|
|||
m_imp = alloc(imp, m, p);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(blast_term_ite_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~blast_term_ite_tactic() {
|
||||
~blast_term_ite_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
m_imp->m_rw.cfg().updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
insert_max_memory(r);
|
||||
insert_max_steps(r);
|
||||
r.insert("max_args", CPK_UINT,
|
||||
"(default: 128) maximum number of arguments (per application) that will be considered by the greedy (quadratic) heuristic.");
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
(*m_imp)(in, result, mc, pc, core);
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
ast_manager & m = m_imp->m;
|
||||
dealloc(m_imp);
|
||||
m_imp = alloc(imp, m, m_params);
|
||||
|
|
|
|||
|
|
@ -46,19 +46,19 @@ public:
|
|||
m_elim_ite(m, p) {
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(cofactor_term_ite_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~cofactor_term_ite_tactic() {}
|
||||
virtual void updt_params(params_ref const & p) { m_params = p; m_elim_ite.updt_params(p); }
|
||||
virtual void collect_param_descrs(param_descrs & r) { m_elim_ite.collect_param_descrs(r); }
|
||||
~cofactor_term_ite_tactic() override {}
|
||||
void updt_params(params_ref const & p) override { m_params = p; m_elim_ite.updt_params(p); }
|
||||
void collect_param_descrs(param_descrs & r) override { m_elim_ite.collect_param_descrs(r); }
|
||||
|
||||
virtual void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
SASSERT(g->is_well_sorted());
|
||||
fail_if_proof_generation("cofactor-term-ite", g);
|
||||
fail_if_unsat_core_generation("cofactor-term-ite", g);
|
||||
|
|
@ -71,7 +71,7 @@ public:
|
|||
SASSERT(g->is_well_sorted());
|
||||
}
|
||||
|
||||
virtual void cleanup() { return m_elim_ite.cleanup(); }
|
||||
void cleanup() override { return m_elim_ite.cleanup(); }
|
||||
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -51,21 +51,21 @@ public:
|
|||
m_params(p) {
|
||||
}
|
||||
|
||||
virtual ~collect_statistics_tactic() {}
|
||||
~collect_statistics_tactic() override {}
|
||||
|
||||
virtual tactic * translate(ast_manager & m_) {
|
||||
tactic * translate(ast_manager & m_) override {
|
||||
return alloc(collect_statistics_tactic, m_, m_params);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {}
|
||||
void collect_param_descrs(param_descrs & r) override {}
|
||||
|
||||
virtual void operator()(goal_ref const & g, goal_ref_buffer & result,
|
||||
model_converter_ref & mc, proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & g, goal_ref_buffer & result,
|
||||
model_converter_ref & mc, proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
mc = 0;
|
||||
tactic_report report("collect-statistics", *g);
|
||||
|
||||
|
|
@ -86,13 +86,13 @@ public:
|
|||
result.push_back(g.get());
|
||||
}
|
||||
|
||||
virtual void cleanup() {}
|
||||
void cleanup() override {}
|
||||
|
||||
virtual void collect_statistics(statistics & st) const {
|
||||
void collect_statistics(statistics & st) const override {
|
||||
}
|
||||
|
||||
virtual void reset_statistics() { reset(); }
|
||||
virtual void reset() { cleanup(); }
|
||||
void reset_statistics() override { reset(); }
|
||||
void reset() override { cleanup(); }
|
||||
|
||||
protected:
|
||||
class collect_proc {
|
||||
|
|
|
|||
|
|
@ -33,13 +33,13 @@ class ctx_propagate_assertions : public ctx_simplify_tactic::simplifier {
|
|||
void assert_eq_core(expr * t, app * val);
|
||||
public:
|
||||
ctx_propagate_assertions(ast_manager& m);
|
||||
virtual ~ctx_propagate_assertions() {}
|
||||
virtual bool assert_expr(expr * t, bool sign);
|
||||
virtual bool simplify(expr* t, expr_ref& result);
|
||||
~ctx_propagate_assertions() override {}
|
||||
bool assert_expr(expr * t, bool sign) override;
|
||||
bool simplify(expr* t, expr_ref& result) override;
|
||||
void push();
|
||||
virtual void pop(unsigned num_scopes);
|
||||
virtual unsigned scope_level() const { return m_scopes.size(); }
|
||||
virtual simplifier * translate(ast_manager & m);
|
||||
void pop(unsigned num_scopes) override;
|
||||
unsigned scope_level() const override { return m_scopes.size(); }
|
||||
simplifier * translate(ast_manager & m) override;
|
||||
};
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -46,21 +46,21 @@ protected:
|
|||
public:
|
||||
ctx_simplify_tactic(ast_manager & m, simplifier* simp, params_ref const & p = params_ref());
|
||||
|
||||
virtual tactic * translate(ast_manager & m);
|
||||
tactic * translate(ast_manager & m) override;
|
||||
|
||||
virtual ~ctx_simplify_tactic();
|
||||
~ctx_simplify_tactic() override;
|
||||
|
||||
virtual void updt_params(params_ref const & p);
|
||||
void updt_params(params_ref const & p) override;
|
||||
static void get_param_descrs(param_descrs & r);
|
||||
virtual void collect_param_descrs(param_descrs & r) { get_param_descrs(r); }
|
||||
void collect_param_descrs(param_descrs & r) override { get_param_descrs(r); }
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core);
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override;
|
||||
|
||||
virtual void cleanup();
|
||||
void cleanup() override;
|
||||
};
|
||||
|
||||
tactic * mk_ctx_simplify_tactic(ast_manager & m, params_ref const & p = params_ref());
|
||||
|
|
|
|||
|
|
@ -65,26 +65,26 @@ public:
|
|||
m_imp = alloc(imp, m);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(der_tactic, m);
|
||||
}
|
||||
|
||||
virtual ~der_tactic() {
|
||||
~der_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
mc = 0; pc = 0; core = 0;
|
||||
(*m_imp)(*(in.get()));
|
||||
in->inc_depth();
|
||||
result.push_back(in.get());
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
ast_manager & m = m_imp->m();
|
||||
imp * d = alloc(imp, m);
|
||||
std::swap(d, m_imp);
|
||||
|
|
|
|||
|
|
@ -95,15 +95,15 @@ class distribute_forall_tactic : public tactic {
|
|||
public:
|
||||
distribute_forall_tactic():m_rw(0) {}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(distribute_forall_tactic);
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
SASSERT(g->is_well_sorted());
|
||||
ast_manager & m = g->m();
|
||||
bool produce_proofs = g->proofs_enabled();
|
||||
|
|
@ -134,7 +134,7 @@ public:
|
|||
m_rw = 0;
|
||||
}
|
||||
|
||||
virtual void cleanup() {}
|
||||
void cleanup() override {}
|
||||
};
|
||||
|
||||
tactic * mk_distribute_forall_tactic(ast_manager & m, params_ref const & p) {
|
||||
|
|
|
|||
|
|
@ -130,20 +130,20 @@ public:
|
|||
m_dominators(m), m_depth(0), m_max_depth(1024), m_forward(true) {}
|
||||
|
||||
|
||||
virtual ~dom_simplify_tactic();
|
||||
~dom_simplify_tactic() override;
|
||||
|
||||
virtual tactic * translate(ast_manager & m);
|
||||
virtual void updt_params(params_ref const & p) {}
|
||||
tactic * translate(ast_manager & m) override;
|
||||
void updt_params(params_ref const & p) override {}
|
||||
static void get_param_descrs(param_descrs & r) {}
|
||||
virtual void collect_param_descrs(param_descrs & r) { get_param_descrs(r); }
|
||||
void collect_param_descrs(param_descrs & r) override { get_param_descrs(r); }
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core);
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override;
|
||||
|
||||
virtual void cleanup();
|
||||
void cleanup() override;
|
||||
};
|
||||
|
||||
class expr_substitution_simplifier : public dom_simplifier {
|
||||
|
|
@ -160,18 +160,18 @@ class expr_substitution_simplifier : public dom_simplifier {
|
|||
|
||||
public:
|
||||
expr_substitution_simplifier(ast_manager& m): m(m), m_subst(m), m_scoped_substitution(m_subst), m_trail(m) {}
|
||||
virtual ~expr_substitution_simplifier() {}
|
||||
virtual bool assert_expr(expr * t, bool sign);
|
||||
~expr_substitution_simplifier() override {}
|
||||
bool assert_expr(expr * t, bool sign) override;
|
||||
|
||||
void update_substitution(expr* n, proof* pr);
|
||||
|
||||
virtual void operator()(expr_ref& r) { r = m_scoped_substitution.find(r); }
|
||||
void operator()(expr_ref& r) override { r = m_scoped_substitution.find(r); }
|
||||
|
||||
virtual void pop(unsigned num_scopes) { m_scoped_substitution.pop(num_scopes); }
|
||||
void pop(unsigned num_scopes) override { m_scoped_substitution.pop(num_scopes); }
|
||||
|
||||
virtual unsigned scope_level() const { return m_scoped_substitution.scope_level(); }
|
||||
unsigned scope_level() const override { return m_scoped_substitution.scope_level(); }
|
||||
|
||||
virtual dom_simplifier * translate(ast_manager & m) {
|
||||
dom_simplifier * translate(ast_manager & m) override {
|
||||
SASSERT(m_subst.empty());
|
||||
return alloc(expr_substitution_simplifier, m);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -141,35 +141,35 @@ public:
|
|||
m_imp = alloc(imp, m, p);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(elim_term_ite_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~elim_term_ite_tactic() {
|
||||
~elim_term_ite_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
m_imp->m_rw.cfg().updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
insert_max_memory(r);
|
||||
insert_max_steps(r);
|
||||
r.insert("max_args", CPK_UINT,
|
||||
"(default: 128) maximum number of arguments (per application) that will be considered by the greedy (quadratic) heuristic.");
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
(*m_imp)(in, result, mc, pc, core);
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
ast_manager & m = m_imp->m;
|
||||
m_imp->~imp();
|
||||
m_imp = new (m_imp) imp(m, m_params);
|
||||
|
|
|
|||
|
|
@ -915,34 +915,34 @@ public:
|
|||
m_imp = alloc(imp, m, p);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(elim_uncnstr_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~elim_uncnstr_tactic() {
|
||||
~elim_uncnstr_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
m_imp->updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
insert_max_memory(r);
|
||||
insert_max_steps(r);
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
(*m_imp)(g, result, mc, pc, core);
|
||||
report_tactic_progress(":num-elim-apps", get_num_elim_apps());
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
unsigned num_elim_apps = get_num_elim_apps();
|
||||
ast_manager & m = m_imp->m_manager;
|
||||
imp * d = alloc(imp, m, m_params);
|
||||
|
|
@ -955,11 +955,11 @@ public:
|
|||
return m_imp->m_num_elim_apps;
|
||||
}
|
||||
|
||||
virtual void collect_statistics(statistics & st) const {
|
||||
void collect_statistics(statistics & st) const override {
|
||||
st.update("eliminated applications", get_num_elim_apps());
|
||||
}
|
||||
|
||||
virtual void reset_statistics() {
|
||||
void reset_statistics() override {
|
||||
m_imp->m_num_elim_apps = 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -250,31 +250,31 @@ public:
|
|||
m_eq = alloc(rewriter_eq, m, *m_map, p);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(injectivity_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~injectivity_tactic() {
|
||||
~injectivity_tactic() override {
|
||||
dealloc(m_finder);
|
||||
dealloc(m_eq);
|
||||
dealloc(m_map);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
m_finder->updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
insert_max_memory(r);
|
||||
insert_produce_models(r);
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
(*m_finder)(g, result, mc, pc, core);
|
||||
|
||||
for (unsigned i = 0; i < g->size(); ++i) {
|
||||
|
|
@ -287,7 +287,7 @@ public:
|
|||
result.push_back(g.get());
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
InjHelper * m = alloc(InjHelper, m_manager);
|
||||
finder * f = alloc(finder, m_manager, *m, m_params);
|
||||
rewriter_eq * r = alloc(rewriter_eq, m_manager, *m, m_params);
|
||||
|
|
|
|||
|
|
@ -43,21 +43,21 @@ public:
|
|||
TRACE("nnf", tout << "nnf_tactic constructor: " << p << "\n";);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(nnf_tactic, m_params);
|
||||
}
|
||||
|
||||
virtual ~nnf_tactic() {}
|
||||
~nnf_tactic() override {}
|
||||
|
||||
virtual void updt_params(params_ref const & p) { m_params = p; }
|
||||
void updt_params(params_ref const & p) override { m_params = p; }
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) { nnf::get_param_descrs(r); }
|
||||
void collect_param_descrs(param_descrs & r) override { nnf::get_param_descrs(r); }
|
||||
|
||||
virtual void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
TRACE("nnf", tout << "params: " << m_params << "\n"; g->display(tout););
|
||||
SASSERT(g->is_well_sorted());
|
||||
mc = 0; pc = 0; core = 0;
|
||||
|
|
@ -106,7 +106,7 @@ public:
|
|||
SASSERT(g->is_well_sorted());
|
||||
}
|
||||
|
||||
virtual void cleanup() {}
|
||||
void cleanup() override {}
|
||||
};
|
||||
|
||||
tactic * mk_snf_tactic(ast_manager & m, params_ref const & p) {
|
||||
|
|
|
|||
|
|
@ -199,26 +199,26 @@ public:
|
|||
m_imp = alloc(imp, m);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(occf_tactic, m);
|
||||
}
|
||||
|
||||
virtual ~occf_tactic() {
|
||||
~occf_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {}
|
||||
virtual void collect_param_descrs(param_descrs & r) {}
|
||||
void updt_params(params_ref const & p) override {}
|
||||
void collect_param_descrs(param_descrs & r) override {}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
(*m_imp)(in, result, mc, pc, core);
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
imp * d = alloc(imp, m_imp->m);
|
||||
std::swap(d, m_imp);
|
||||
dealloc(d);
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@ class pb_preproc_model_converter : public model_converter {
|
|||
public:
|
||||
pb_preproc_model_converter(ast_manager& m):m(m), pb(m), m_refs(m) {}
|
||||
|
||||
virtual void operator()(model_ref & mdl, unsigned goal_idx) {
|
||||
void operator()(model_ref & mdl, unsigned goal_idx) override {
|
||||
SASSERT(goal_idx == 0);
|
||||
for (unsigned i = 0; i < m_const.size(); ++i) {
|
||||
mdl->register_decl(m_const[i].first->get_decl(), m_const[i].second);
|
||||
|
|
@ -63,7 +63,7 @@ public:
|
|||
set_value_p(to_app(e), p?m.mk_true():m.mk_false());
|
||||
}
|
||||
|
||||
virtual model_converter * translate(ast_translation & translator) {
|
||||
model_converter * translate(ast_translation & translator) override {
|
||||
pb_preproc_model_converter* mc = alloc(pb_preproc_model_converter, translator.to());
|
||||
for (unsigned i = 0; i < m_const.size(); ++i) {
|
||||
mc->set_value_p(translator(m_const[i].first), translator(m_const[i].second));
|
||||
|
|
@ -136,18 +136,17 @@ public:
|
|||
pb_preprocess_tactic(ast_manager& m, params_ref const& p = params_ref()):
|
||||
m(m), pb(m), m_r(m) {}
|
||||
|
||||
virtual ~pb_preprocess_tactic() {}
|
||||
~pb_preprocess_tactic() override {}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(pb_preprocess_tactic, m);
|
||||
}
|
||||
|
||||
virtual void operator()(
|
||||
goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
SASSERT(g->is_well_sorted());
|
||||
pc = 0; core = 0;
|
||||
|
||||
|
|
@ -262,15 +261,15 @@ public:
|
|||
return m_progress;
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
void reset() {
|
||||
void reset() override {
|
||||
m_ge.reset();
|
||||
m_other.reset();
|
||||
m_vars.reset();
|
||||
|
|
|
|||
|
|
@ -222,29 +222,29 @@ public:
|
|||
m_imp = alloc(imp, m, p);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(propagate_values_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~propagate_values_tactic() {
|
||||
~propagate_values_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
m_imp->updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
th_rewriter::get_param_descrs(r);
|
||||
r.insert("max_rounds", CPK_UINT, "(default: 2) maximum number of rounds.");
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
try {
|
||||
(*m_imp)(in, result, mc, pc, core);
|
||||
}
|
||||
|
|
@ -253,7 +253,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
ast_manager & m = m_imp->m;
|
||||
params_ref p = std::move(m_params);
|
||||
m_imp->~imp();
|
||||
|
|
|
|||
|
|
@ -68,14 +68,14 @@ class reduce_args_tactic : public tactic {
|
|||
public:
|
||||
reduce_args_tactic(ast_manager & m);
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(reduce_args_tactic, m);
|
||||
}
|
||||
|
||||
virtual ~reduce_args_tactic();
|
||||
~reduce_args_tactic() override;
|
||||
|
||||
virtual void operator()(goal_ref const & g, goal_ref_buffer & result, model_converter_ref & mc, proof_converter_ref & pc, expr_dependency_ref & core);
|
||||
virtual void cleanup();
|
||||
void operator()(goal_ref const & g, goal_ref_buffer & result, model_converter_ref & mc, proof_converter_ref & pc, expr_dependency_ref & core) override;
|
||||
void cleanup() override;
|
||||
};
|
||||
|
||||
tactic * mk_reduce_args_tactic(ast_manager & m, params_ref const & p) {
|
||||
|
|
|
|||
|
|
@ -28,23 +28,23 @@ class simplify_tactic : public tactic {
|
|||
params_ref m_params;
|
||||
public:
|
||||
simplify_tactic(ast_manager & m, params_ref const & ref = params_ref());
|
||||
virtual ~simplify_tactic();
|
||||
~simplify_tactic() override;
|
||||
|
||||
virtual void updt_params(params_ref const & p);
|
||||
void updt_params(params_ref const & p) override;
|
||||
static void get_param_descrs(param_descrs & r);
|
||||
virtual void collect_param_descrs(param_descrs & r) { get_param_descrs(r); }
|
||||
void collect_param_descrs(param_descrs & r) override { get_param_descrs(r); }
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core);
|
||||
|
||||
virtual void cleanup();
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override;
|
||||
|
||||
void cleanup() override;
|
||||
|
||||
unsigned get_num_steps() const;
|
||||
|
||||
virtual tactic * translate(ast_manager & m) { return alloc(simplify_tactic, m, m_params); }
|
||||
tactic * translate(ast_manager & m) override { return alloc(simplify_tactic, m, m_params); }
|
||||
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -790,35 +790,35 @@ public:
|
|||
m_imp = alloc(imp, m, p, r, owner);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(solve_eqs_tactic, m, m_params, mk_expr_simp_replacer(m, m_params), true);
|
||||
}
|
||||
|
||||
virtual ~solve_eqs_tactic() {
|
||||
~solve_eqs_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
m_imp->updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
r.insert("solve_eqs_max_occs", CPK_UINT, "(default: infty) maximum number of occurrences for considering a variable for gaussian eliminations.");
|
||||
r.insert("theory_solver", CPK_BOOL, "(default: true) use theory solvers.");
|
||||
r.insert("ite_solver", CPK_BOOL, "(default: true) use if-then-else solver.");
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
(*m_imp)(in, result, mc, pc, core);
|
||||
report_tactic_progress(":num-elim-vars", m_imp->get_num_eliminated_vars());
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
unsigned num_elim_vars = m_imp->m_num_eliminated_vars;
|
||||
ast_manager & m = m_imp->m();
|
||||
expr_replacer * r = m_imp->m_r;
|
||||
|
|
@ -833,11 +833,11 @@ public:
|
|||
dealloc(d);
|
||||
}
|
||||
|
||||
virtual void collect_statistics(statistics & st) const {
|
||||
void collect_statistics(statistics & st) const override {
|
||||
st.update("eliminated vars", m_imp->get_num_eliminated_vars());
|
||||
}
|
||||
|
||||
virtual void reset_statistics() {
|
||||
void reset_statistics() override {
|
||||
m_imp->m_num_eliminated_vars = 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -55,12 +55,12 @@ class split_clause_tactic : public tactic {
|
|||
m.inc_ref(pr);
|
||||
}
|
||||
|
||||
~split_pc() {
|
||||
~split_pc() override {
|
||||
m_manager.dec_ref(m_clause);
|
||||
m_manager.dec_ref(m_clause_pr);
|
||||
}
|
||||
|
||||
virtual void operator()(ast_manager & m, unsigned num_source, proof * const * source, proof_ref & result) {
|
||||
void operator()(ast_manager & m, unsigned num_source, proof * const * source, proof_ref & result) override {
|
||||
// Let m_clause be of the form (l_0 or ... or l_{num_source - 1})
|
||||
// Each source[i] proof is a proof for "false" using l_i as a hypothesis
|
||||
// So, I use lemma for producing a proof for (not l_i) that does not contain the hypothesis,
|
||||
|
|
@ -76,7 +76,7 @@ class split_clause_tactic : public tactic {
|
|||
result = m.mk_unit_resolution(prs.size(), prs.c_ptr());
|
||||
}
|
||||
|
||||
virtual proof_converter * translate(ast_translation & translator) {
|
||||
proof_converter * translate(ast_translation & translator) override {
|
||||
return alloc(split_pc, translator.to(), translator(m_clause), translator(m_clause_pr));
|
||||
}
|
||||
};
|
||||
|
|
@ -86,28 +86,28 @@ public:
|
|||
updt_params(ref);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
split_clause_tactic * t = alloc(split_clause_tactic);
|
||||
t->m_largest_clause = m_largest_clause;
|
||||
return t;
|
||||
}
|
||||
|
||||
virtual ~split_clause_tactic() {
|
||||
~split_clause_tactic() override {
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_largest_clause = p.get_bool("split_largest_clause", false);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
r.insert("split_largest_clause", CPK_BOOL, "(default: false) split the largest clause in the goal.");
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
SASSERT(in->is_well_sorted());
|
||||
tactic_report report("split-clause", *in);
|
||||
TRACE("before_split_clause", in->display(tout););
|
||||
|
|
@ -140,7 +140,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
// do nothing this tactic is too simple
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -32,18 +32,18 @@ class symmetry_reduce_tactic : public tactic {
|
|||
public:
|
||||
symmetry_reduce_tactic(ast_manager & m);
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(symmetry_reduce_tactic, m);
|
||||
}
|
||||
|
||||
virtual ~symmetry_reduce_tactic();
|
||||
~symmetry_reduce_tactic() override;
|
||||
|
||||
virtual void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core);
|
||||
virtual void cleanup();
|
||||
void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override;
|
||||
void cleanup() override;
|
||||
};
|
||||
|
||||
class ac_rewriter {
|
||||
|
|
|
|||
|
|
@ -861,20 +861,20 @@ public:
|
|||
m_imp = alloc(imp, m, p);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(tseitin_cnf_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~tseitin_cnf_tactic() {
|
||||
~tseitin_cnf_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
m_imp->updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
insert_max_memory(r);
|
||||
r.insert("common_patterns", CPK_BOOL, "(default: true) minimize the number of auxiliary variables during CNF encoding by identifing commonly used patterns");
|
||||
r.insert("distributivity", CPK_BOOL, "(default: true) minimize the number of auxiliary variables during CNF encoding by applying distributivity over unshared subformulas");
|
||||
|
|
@ -883,16 +883,16 @@ public:
|
|||
r.insert("ite_extra", CPK_BOOL, "(default: true) add redundant clauses (that improve unit propagation) when encoding if-then-else formulas");
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
(*m_imp)(in, result, mc, pc, core);
|
||||
report_tactic_progress(":cnf-aux-vars", m_imp->m_num_aux_vars);
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
ast_manager & m = m_imp->m;
|
||||
imp * d = alloc(imp, m, m_params);
|
||||
d->m_num_aux_vars = m_imp->m_num_aux_vars;
|
||||
|
|
@ -900,11 +900,11 @@ public:
|
|||
dealloc(d);
|
||||
}
|
||||
|
||||
virtual void collect_statistics(statistics & st) const {
|
||||
void collect_statistics(statistics & st) const override {
|
||||
st.update("cnf encoding aux vars", m_imp->m_num_aux_vars);
|
||||
}
|
||||
|
||||
virtual void reset_statistics() {
|
||||
void reset_statistics() override {
|
||||
m_imp->m_num_aux_vars = 0;
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -33,13 +33,13 @@ public:
|
|||
|
||||
equiv_proof_converter(ast_manager& m): m(m), m_replace(m) {}
|
||||
|
||||
virtual ~equiv_proof_converter() {}
|
||||
~equiv_proof_converter() override {}
|
||||
|
||||
virtual void operator()(ast_manager & m, unsigned num_source, proof * const * source, proof_ref & result) {
|
||||
void operator()(ast_manager & m, unsigned num_source, proof * const * source, proof_ref & result) override {
|
||||
m_replace(m, num_source, source, result);
|
||||
}
|
||||
|
||||
virtual proof_converter * translate(ast_translation & translator) {
|
||||
proof_converter * translate(ast_translation & translator) override {
|
||||
return m_replace.translate(translator);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -31,18 +31,18 @@ public:
|
|||
extension_model_converter(ast_manager & m):m_vars(m), m_defs(m) {
|
||||
}
|
||||
|
||||
virtual ~extension_model_converter();
|
||||
~extension_model_converter() override;
|
||||
|
||||
ast_manager & m() const { return m_vars.get_manager(); }
|
||||
|
||||
virtual void operator()(model_ref & md, unsigned goal_idx);
|
||||
void operator()(model_ref & md, unsigned goal_idx) override;
|
||||
|
||||
virtual void display(std::ostream & out);
|
||||
void display(std::ostream & out) override;
|
||||
|
||||
// register a variable that was eliminated
|
||||
void insert(func_decl * v, expr * def);
|
||||
|
||||
virtual model_converter * translate(ast_translation & translator);
|
||||
model_converter * translate(ast_translation & translator) override;
|
||||
};
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -26,25 +26,25 @@ class filter_model_converter : public model_converter {
|
|||
public:
|
||||
filter_model_converter(ast_manager & m):m_decls(m) {}
|
||||
|
||||
virtual ~filter_model_converter();
|
||||
~filter_model_converter() override;
|
||||
|
||||
ast_manager & m() const { return m_decls.get_manager(); }
|
||||
|
||||
virtual void operator()(model_ref & md, unsigned goal_idx);
|
||||
void operator()(model_ref & md, unsigned goal_idx) override;
|
||||
|
||||
virtual void operator()(svector<symbol> & labels, unsigned goal_idx);
|
||||
|
||||
virtual void operator()(model_ref & md) { operator()(md, 0); } // TODO: delete
|
||||
void operator()(model_ref & md) override { operator()(md, 0); } // TODO: delete
|
||||
|
||||
virtual void cancel() {}
|
||||
void cancel() override {}
|
||||
|
||||
virtual void display(std::ostream & out);
|
||||
void display(std::ostream & out) override;
|
||||
|
||||
void insert(func_decl * d) {
|
||||
m_decls.push_back(d);
|
||||
}
|
||||
|
||||
virtual model_converter * translate(ast_translation & translator);
|
||||
model_converter * translate(ast_translation & translator) override;
|
||||
};
|
||||
|
||||
typedef ref<filter_model_converter> filter_model_converter_ref;
|
||||
|
|
|
|||
|
|
@ -33,24 +33,24 @@ public:
|
|||
m_bv2fp(alloc(bv2fpa_converter, m, conv)) {
|
||||
}
|
||||
|
||||
virtual ~fpa2bv_model_converter() {
|
||||
~fpa2bv_model_converter() override {
|
||||
dealloc(m_bv2fp);
|
||||
}
|
||||
|
||||
virtual void operator()(model_ref & md, unsigned goal_idx) {
|
||||
void operator()(model_ref & md, unsigned goal_idx) override {
|
||||
SASSERT(goal_idx == 0);
|
||||
model * new_model = alloc(model, m);
|
||||
convert(md.get(), new_model);
|
||||
md = new_model;
|
||||
}
|
||||
|
||||
virtual void operator()(model_ref & md) {
|
||||
void operator()(model_ref & md) override {
|
||||
operator()(md, 0);
|
||||
}
|
||||
|
||||
void display(std::ostream & out);
|
||||
void display(std::ostream & out) override;
|
||||
|
||||
virtual model_converter * translate(ast_translation & translator);
|
||||
model_converter * translate(ast_translation & translator) override;
|
||||
|
||||
protected:
|
||||
fpa2bv_model_converter(ast_manager & m) :
|
||||
|
|
|
|||
|
|
@ -123,27 +123,27 @@ public:
|
|||
m_imp = alloc(imp, m, p);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(fpa2bv_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~fpa2bv_tactic() {
|
||||
~fpa2bv_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
m_imp->updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
try {
|
||||
(*m_imp)(in, result, mc, pc, core);
|
||||
}
|
||||
|
|
@ -152,7 +152,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
imp * d = alloc(imp, m_imp->m, m_params);
|
||||
std::swap(d, m_imp);
|
||||
dealloc(d);
|
||||
|
|
|
|||
|
|
@ -66,10 +66,10 @@ struct is_non_fp_qfnra_predicate {
|
|||
|
||||
class is_fp_qfnra_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return !test<is_non_fp_qfnra_predicate>(g);
|
||||
}
|
||||
virtual ~is_fp_qfnra_probe() {}
|
||||
~is_fp_qfnra_probe() override {}
|
||||
};
|
||||
|
||||
probe * mk_is_fp_qfnra_probe() {
|
||||
|
|
@ -141,11 +141,11 @@ struct is_non_qffp_predicate {
|
|||
|
||||
class is_qffp_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return !test<is_non_qffp_predicate>(g);
|
||||
}
|
||||
|
||||
virtual ~is_qffp_probe() {}
|
||||
~is_qffp_probe() override {}
|
||||
};
|
||||
|
||||
probe * mk_is_qffp_probe() {
|
||||
|
|
|
|||
|
|
@ -72,9 +72,9 @@ public:
|
|||
|
||||
void insert(func_decl* p, expr* body) { m_funcs.push_back(p); m_bodies.push_back(body); }
|
||||
|
||||
virtual void operator()(model_ref& _m);
|
||||
void operator()(model_ref& _m) override;
|
||||
|
||||
virtual model_converter * translate(ast_translation & translator);
|
||||
model_converter * translate(ast_translation & translator) override;
|
||||
|
||||
ast_manager& get_manager() { return m; }
|
||||
|
||||
|
|
|
|||
|
|
@ -23,25 +23,25 @@ class concat_model_converter : public concat_converter<model_converter> {
|
|||
public:
|
||||
concat_model_converter(model_converter * mc1, model_converter * mc2):concat_converter<model_converter>(mc1, mc2) {}
|
||||
|
||||
virtual void operator()(model_ref & m) {
|
||||
void operator()(model_ref & m) override {
|
||||
this->m_c2->operator()(m);
|
||||
this->m_c1->operator()(m);
|
||||
}
|
||||
|
||||
virtual void operator()(model_ref & m, unsigned goal_idx) {
|
||||
void operator()(model_ref & m, unsigned goal_idx) override {
|
||||
this->m_c2->operator()(m, goal_idx);
|
||||
this->m_c1->operator()(m, 0);
|
||||
}
|
||||
|
||||
virtual void operator()(labels_vec & r, unsigned goal_idx) {
|
||||
void operator()(labels_vec & r, unsigned goal_idx) override {
|
||||
this->m_c2->operator()(r, goal_idx);
|
||||
this->m_c1->operator()(r, 0);
|
||||
}
|
||||
|
||||
|
||||
virtual char const * get_name() const { return "concat-model-converter"; }
|
||||
char const * get_name() const override { return "concat-model-converter"; }
|
||||
|
||||
virtual model_converter * translate(ast_translation & translator) {
|
||||
model_converter * translate(ast_translation & translator) override {
|
||||
return this->translate_core<concat_model_converter>(translator);
|
||||
}
|
||||
};
|
||||
|
|
@ -60,12 +60,12 @@ public:
|
|||
concat_star_converter<model_converter>(mc1, num, mc2s, szs) {
|
||||
}
|
||||
|
||||
virtual void operator()(model_ref & m) {
|
||||
void operator()(model_ref & m) override {
|
||||
// TODO: delete method after conversion is complete
|
||||
UNREACHABLE();
|
||||
}
|
||||
|
||||
virtual void operator()(model_ref & m, unsigned goal_idx) {
|
||||
void operator()(model_ref & m, unsigned goal_idx) override {
|
||||
unsigned num = this->m_c2s.size();
|
||||
for (unsigned i = 0; i < num; i++) {
|
||||
if (goal_idx < this->m_szs[i]) {
|
||||
|
|
@ -83,7 +83,7 @@ public:
|
|||
UNREACHABLE();
|
||||
}
|
||||
|
||||
virtual void operator()(labels_vec & r, unsigned goal_idx) {
|
||||
void operator()(labels_vec & r, unsigned goal_idx) override {
|
||||
unsigned num = this->m_c2s.size();
|
||||
for (unsigned i = 0; i < num; i++) {
|
||||
if (goal_idx < this->m_szs[i]) {
|
||||
|
|
@ -101,9 +101,9 @@ public:
|
|||
UNREACHABLE();
|
||||
}
|
||||
|
||||
virtual char const * get_name() const { return "concat-star-model-converter"; }
|
||||
char const * get_name() const override { return "concat-star-model-converter"; }
|
||||
|
||||
virtual model_converter * translate(ast_translation & translator) {
|
||||
model_converter * translate(ast_translation & translator) override {
|
||||
return this->translate_core<concat_star_model_converter>(translator);
|
||||
}
|
||||
};
|
||||
|
|
@ -132,30 +132,30 @@ public:
|
|||
|
||||
model2mc(model * m, buffer<symbol> const & r):m_model(m), m_labels(r) {}
|
||||
|
||||
virtual ~model2mc() {}
|
||||
~model2mc() override {}
|
||||
|
||||
virtual void operator()(model_ref & m) {
|
||||
void operator()(model_ref & m) override {
|
||||
m = m_model;
|
||||
}
|
||||
|
||||
virtual void operator()(model_ref & m, unsigned goal_idx) {
|
||||
void operator()(model_ref & m, unsigned goal_idx) override {
|
||||
m = m_model;
|
||||
}
|
||||
|
||||
virtual void operator()(labels_vec & r, unsigned goal_idx) {
|
||||
void operator()(labels_vec & r, unsigned goal_idx) override {
|
||||
r.append(m_labels.size(), m_labels.c_ptr());
|
||||
}
|
||||
|
||||
virtual void cancel() {
|
||||
void cancel() override {
|
||||
}
|
||||
|
||||
virtual void display(std::ostream & out) {
|
||||
void display(std::ostream & out) override {
|
||||
out << "(model->model-converter-wrapper\n";
|
||||
model_v2_pp(out, *m_model);
|
||||
out << ")\n";
|
||||
}
|
||||
|
||||
virtual model_converter * translate(ast_translation & translator) {
|
||||
model_converter * translate(ast_translation & translator) override {
|
||||
model * m = m_model->translate(translator);
|
||||
return alloc(model2mc, m);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -709,27 +709,27 @@ public:
|
|||
m_asms(m)
|
||||
{}
|
||||
|
||||
virtual ~nl_purify_tactic() {}
|
||||
~nl_purify_tactic() override {}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager& m) {
|
||||
tactic * translate(ast_manager& m) override {
|
||||
return alloc(nl_purify_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual void collect_statistics(statistics & st) const {
|
||||
void collect_statistics(statistics & st) const override {
|
||||
m_nl_tac->collect_statistics(st);
|
||||
m_solver->collect_statistics(st);
|
||||
}
|
||||
|
||||
virtual void reset_statistics() {
|
||||
void reset_statistics() override {
|
||||
m_nl_tac->reset_statistics();
|
||||
}
|
||||
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
m_solver = mk_smt_solver(m, m_params, symbol::null);
|
||||
m_nl_tac->cleanup();
|
||||
m_eq_preds.reset();
|
||||
|
|
@ -744,11 +744,11 @@ public:
|
|||
m_bool2dep.reset();
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
|
||||
tactic_report report("qfufnl-purify", *g);
|
||||
TRACE("nlsat_smt", g->display(tout););
|
||||
|
|
|
|||
|
|
@ -65,18 +65,18 @@ public:
|
|||
m_bounds.push_back(alloc(bound_manager, m));
|
||||
}
|
||||
|
||||
virtual ~bounded_int2bv_solver() {
|
||||
~bounded_int2bv_solver() override {
|
||||
while (!m_bounds.empty()) {
|
||||
dealloc(m_bounds.back());
|
||||
m_bounds.pop_back();
|
||||
}
|
||||
}
|
||||
|
||||
virtual solver* translate(ast_manager& m, params_ref const& p) {
|
||||
solver* translate(ast_manager& m, params_ref const& p) override {
|
||||
return alloc(bounded_int2bv_solver, m, p, m_solver->translate(m, p));
|
||||
}
|
||||
|
||||
virtual void assert_expr(expr * t) {
|
||||
void assert_expr(expr * t) override {
|
||||
unsigned i = m_assertions.size();
|
||||
m_assertions.push_back(t);
|
||||
while (i < m_assertions.size()) {
|
||||
|
|
@ -92,14 +92,14 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual void push_core() {
|
||||
void push_core() override {
|
||||
flush_assertions();
|
||||
m_solver->push();
|
||||
m_bv_fns_lim.push_back(m_bv_fns.size());
|
||||
m_bounds.push_back(alloc(bound_manager, m));
|
||||
}
|
||||
|
||||
virtual void pop_core(unsigned n) {
|
||||
void pop_core(unsigned n) override {
|
||||
m_assertions.reset();
|
||||
m_solver->pop(n);
|
||||
|
||||
|
|
@ -125,31 +125,31 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual lbool check_sat_core(unsigned num_assumptions, expr * const * assumptions) {
|
||||
lbool check_sat_core(unsigned num_assumptions, expr * const * assumptions) override {
|
||||
flush_assertions();
|
||||
return m_solver->check_sat(num_assumptions, assumptions);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) { solver::updt_params(p); m_solver->updt_params(p); }
|
||||
virtual void collect_param_descrs(param_descrs & r) { m_solver->collect_param_descrs(r); }
|
||||
virtual void set_produce_models(bool f) { m_solver->set_produce_models(f); }
|
||||
virtual void set_progress_callback(progress_callback * callback) { m_solver->set_progress_callback(callback); }
|
||||
virtual void collect_statistics(statistics & st) const { m_solver->collect_statistics(st); }
|
||||
virtual void get_unsat_core(ptr_vector<expr> & r) { m_solver->get_unsat_core(r); }
|
||||
virtual void get_model(model_ref & mdl) {
|
||||
void updt_params(params_ref const & p) override { solver::updt_params(p); m_solver->updt_params(p); }
|
||||
void collect_param_descrs(param_descrs & r) override { m_solver->collect_param_descrs(r); }
|
||||
void set_produce_models(bool f) override { m_solver->set_produce_models(f); }
|
||||
void set_progress_callback(progress_callback * callback) override { m_solver->set_progress_callback(callback); }
|
||||
void collect_statistics(statistics & st) const override { m_solver->collect_statistics(st); }
|
||||
void get_unsat_core(ptr_vector<expr> & r) override { m_solver->get_unsat_core(r); }
|
||||
void get_model(model_ref & mdl) override {
|
||||
m_solver->get_model(mdl);
|
||||
if (mdl) {
|
||||
extend_model(mdl);
|
||||
filter_model(mdl);
|
||||
}
|
||||
}
|
||||
virtual proof * get_proof() { return m_solver->get_proof(); }
|
||||
virtual std::string reason_unknown() const { return m_solver->reason_unknown(); }
|
||||
virtual void set_reason_unknown(char const* msg) { m_solver->set_reason_unknown(msg); }
|
||||
virtual void get_labels(svector<symbol> & r) { m_solver->get_labels(r); }
|
||||
virtual ast_manager& get_manager() const { return m; }
|
||||
virtual lbool find_mutexes(expr_ref_vector const& vars, vector<expr_ref_vector>& mutexes) { return m_solver->find_mutexes(vars, mutexes); }
|
||||
virtual lbool get_consequences_core(expr_ref_vector const& asms, expr_ref_vector const& vars, expr_ref_vector& consequences) {
|
||||
proof * get_proof() override { return m_solver->get_proof(); }
|
||||
std::string reason_unknown() const override { return m_solver->reason_unknown(); }
|
||||
void set_reason_unknown(char const* msg) override { m_solver->set_reason_unknown(msg); }
|
||||
void get_labels(svector<symbol> & r) override { m_solver->get_labels(r); }
|
||||
ast_manager& get_manager() const override { return m; }
|
||||
lbool find_mutexes(expr_ref_vector const& vars, vector<expr_ref_vector>& mutexes) override { return m_solver->find_mutexes(vars, mutexes); }
|
||||
lbool get_consequences_core(expr_ref_vector const& asms, expr_ref_vector const& vars, expr_ref_vector& consequences) override {
|
||||
flush_assertions();
|
||||
expr_ref_vector bvars(m);
|
||||
for (unsigned i = 0; i < vars.size(); ++i) {
|
||||
|
|
@ -319,12 +319,12 @@ private:
|
|||
m_rewriter.reset();
|
||||
}
|
||||
|
||||
virtual unsigned get_num_assertions() const {
|
||||
unsigned get_num_assertions() const override {
|
||||
flush_assertions();
|
||||
return m_solver->get_num_assertions();
|
||||
}
|
||||
|
||||
virtual expr * get_assertion(unsigned idx) const {
|
||||
expr * get_assertion(unsigned idx) const override {
|
||||
flush_assertions();
|
||||
return m_solver->get_assertion(idx);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -47,13 +47,13 @@ public:
|
|||
solver::updt_params(p);
|
||||
}
|
||||
|
||||
virtual ~enum2bv_solver() {}
|
||||
~enum2bv_solver() override {}
|
||||
|
||||
virtual solver* translate(ast_manager& m, params_ref const& p) {
|
||||
solver* translate(ast_manager& m, params_ref const& p) override {
|
||||
return alloc(enum2bv_solver, m, p, m_solver->translate(m, p));
|
||||
}
|
||||
|
||||
virtual void assert_expr(expr * t) {
|
||||
void assert_expr(expr * t) override {
|
||||
expr_ref tmp(t, m);
|
||||
expr_ref_vector bounds(m);
|
||||
proof_ref tmp_proof(m);
|
||||
|
|
@ -63,40 +63,40 @@ public:
|
|||
m_solver->assert_expr(bounds);
|
||||
}
|
||||
|
||||
virtual void push_core() {
|
||||
void push_core() override {
|
||||
m_rewriter.push();
|
||||
m_solver->push();
|
||||
}
|
||||
|
||||
virtual void pop_core(unsigned n) {
|
||||
void pop_core(unsigned n) override {
|
||||
m_solver->pop(n);
|
||||
m_rewriter.pop(n);
|
||||
}
|
||||
|
||||
virtual lbool check_sat_core(unsigned num_assumptions, expr * const * assumptions) {
|
||||
lbool check_sat_core(unsigned num_assumptions, expr * const * assumptions) override {
|
||||
return m_solver->check_sat(num_assumptions, assumptions);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) { solver::updt_params(p); m_solver->updt_params(p); }
|
||||
virtual void collect_param_descrs(param_descrs & r) { m_solver->collect_param_descrs(r); }
|
||||
virtual void set_produce_models(bool f) { m_solver->set_produce_models(f); }
|
||||
virtual void set_progress_callback(progress_callback * callback) { m_solver->set_progress_callback(callback); }
|
||||
virtual void collect_statistics(statistics & st) const { m_solver->collect_statistics(st); }
|
||||
virtual void get_unsat_core(ptr_vector<expr> & r) { m_solver->get_unsat_core(r); }
|
||||
virtual void get_model(model_ref & mdl) {
|
||||
void updt_params(params_ref const & p) override { solver::updt_params(p); m_solver->updt_params(p); }
|
||||
void collect_param_descrs(param_descrs & r) override { m_solver->collect_param_descrs(r); }
|
||||
void set_produce_models(bool f) override { m_solver->set_produce_models(f); }
|
||||
void set_progress_callback(progress_callback * callback) override { m_solver->set_progress_callback(callback); }
|
||||
void collect_statistics(statistics & st) const override { m_solver->collect_statistics(st); }
|
||||
void get_unsat_core(ptr_vector<expr> & r) override { m_solver->get_unsat_core(r); }
|
||||
void get_model(model_ref & mdl) override {
|
||||
m_solver->get_model(mdl);
|
||||
if (mdl) {
|
||||
extend_model(mdl);
|
||||
filter_model(mdl);
|
||||
}
|
||||
}
|
||||
virtual proof * get_proof() { return m_solver->get_proof(); }
|
||||
virtual std::string reason_unknown() const { return m_solver->reason_unknown(); }
|
||||
virtual void set_reason_unknown(char const* msg) { m_solver->set_reason_unknown(msg); }
|
||||
virtual void get_labels(svector<symbol> & r) { m_solver->get_labels(r); }
|
||||
virtual ast_manager& get_manager() const { return m; }
|
||||
virtual lbool find_mutexes(expr_ref_vector const& vars, vector<expr_ref_vector>& mutexes) { return m_solver->find_mutexes(vars, mutexes); }
|
||||
virtual lbool get_consequences_core(expr_ref_vector const& asms, expr_ref_vector const& vars, expr_ref_vector& consequences) {
|
||||
proof * get_proof() override { return m_solver->get_proof(); }
|
||||
std::string reason_unknown() const override { return m_solver->reason_unknown(); }
|
||||
void set_reason_unknown(char const* msg) override { m_solver->set_reason_unknown(msg); }
|
||||
void get_labels(svector<symbol> & r) override { m_solver->get_labels(r); }
|
||||
ast_manager& get_manager() const override { return m; }
|
||||
lbool find_mutexes(expr_ref_vector const& vars, vector<expr_ref_vector>& mutexes) override { return m_solver->find_mutexes(vars, mutexes); }
|
||||
lbool get_consequences_core(expr_ref_vector const& asms, expr_ref_vector const& vars, expr_ref_vector& consequences) override {
|
||||
datatype_util dt(m);
|
||||
bv_util bv(m);
|
||||
expr_ref_vector bvars(m), conseq(m), bounds(m);
|
||||
|
|
@ -163,11 +163,11 @@ public:
|
|||
ext(mdl, 0);
|
||||
}
|
||||
|
||||
virtual unsigned get_num_assertions() const {
|
||||
unsigned get_num_assertions() const override {
|
||||
return m_solver->get_num_assertions();
|
||||
}
|
||||
|
||||
virtual expr * get_assertion(unsigned idx) const {
|
||||
expr * get_assertion(unsigned idx) const override {
|
||||
return m_solver->get_assertion(idx);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -42,55 +42,55 @@ public:
|
|||
solver::updt_params(p);
|
||||
}
|
||||
|
||||
virtual ~pb2bv_solver() {}
|
||||
~pb2bv_solver() override {}
|
||||
|
||||
virtual solver* translate(ast_manager& m, params_ref const& p) {
|
||||
solver* translate(ast_manager& m, params_ref const& p) override {
|
||||
return alloc(pb2bv_solver, m, p, m_solver->translate(m, p));
|
||||
}
|
||||
|
||||
virtual void assert_expr(expr * t) {
|
||||
void assert_expr(expr * t) override {
|
||||
m_assertions.push_back(t);
|
||||
}
|
||||
|
||||
virtual void push_core() {
|
||||
void push_core() override {
|
||||
flush_assertions();
|
||||
m_rewriter.push();
|
||||
m_solver->push();
|
||||
}
|
||||
|
||||
virtual void pop_core(unsigned n) {
|
||||
void pop_core(unsigned n) override {
|
||||
m_assertions.reset();
|
||||
m_solver->pop(n);
|
||||
m_rewriter.pop(n);
|
||||
}
|
||||
|
||||
virtual lbool check_sat_core(unsigned num_assumptions, expr * const * assumptions) {
|
||||
lbool check_sat_core(unsigned num_assumptions, expr * const * assumptions) override {
|
||||
flush_assertions();
|
||||
return m_solver->check_sat(num_assumptions, assumptions);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) { solver::updt_params(p); m_solver->updt_params(p); }
|
||||
virtual void collect_param_descrs(param_descrs & r) { m_solver->collect_param_descrs(r); }
|
||||
virtual void set_produce_models(bool f) { m_solver->set_produce_models(f); }
|
||||
virtual void set_progress_callback(progress_callback * callback) { m_solver->set_progress_callback(callback); }
|
||||
virtual void collect_statistics(statistics & st) const {
|
||||
void updt_params(params_ref const & p) override { solver::updt_params(p); m_solver->updt_params(p); }
|
||||
void collect_param_descrs(param_descrs & r) override { m_solver->collect_param_descrs(r); }
|
||||
void set_produce_models(bool f) override { m_solver->set_produce_models(f); }
|
||||
void set_progress_callback(progress_callback * callback) override { m_solver->set_progress_callback(callback); }
|
||||
void collect_statistics(statistics & st) const override {
|
||||
m_rewriter.collect_statistics(st);
|
||||
m_solver->collect_statistics(st);
|
||||
}
|
||||
virtual void get_unsat_core(ptr_vector<expr> & r) { m_solver->get_unsat_core(r); }
|
||||
virtual void get_model(model_ref & mdl) {
|
||||
void get_unsat_core(ptr_vector<expr> & r) override { m_solver->get_unsat_core(r); }
|
||||
void get_model(model_ref & mdl) override {
|
||||
m_solver->get_model(mdl);
|
||||
if (mdl) {
|
||||
filter_model(mdl);
|
||||
}
|
||||
}
|
||||
virtual proof * get_proof() { return m_solver->get_proof(); }
|
||||
virtual std::string reason_unknown() const { return m_solver->reason_unknown(); }
|
||||
virtual void set_reason_unknown(char const* msg) { m_solver->set_reason_unknown(msg); }
|
||||
virtual void get_labels(svector<symbol> & r) { m_solver->get_labels(r); }
|
||||
virtual ast_manager& get_manager() const { return m; }
|
||||
virtual lbool find_mutexes(expr_ref_vector const& vars, vector<expr_ref_vector>& mutexes) { return m_solver->find_mutexes(vars, mutexes); }
|
||||
virtual lbool get_consequences_core(expr_ref_vector const& asms, expr_ref_vector const& vars, expr_ref_vector& consequences) {
|
||||
proof * get_proof() override { return m_solver->get_proof(); }
|
||||
std::string reason_unknown() const override { return m_solver->reason_unknown(); }
|
||||
void set_reason_unknown(char const* msg) override { m_solver->set_reason_unknown(msg); }
|
||||
void get_labels(svector<symbol> & r) override { m_solver->get_labels(r); }
|
||||
ast_manager& get_manager() const override { return m; }
|
||||
lbool find_mutexes(expr_ref_vector const& vars, vector<expr_ref_vector>& mutexes) override { return m_solver->find_mutexes(vars, mutexes); }
|
||||
lbool get_consequences_core(expr_ref_vector const& asms, expr_ref_vector const& vars, expr_ref_vector& consequences) override {
|
||||
flush_assertions();
|
||||
return m_solver->get_consequences(asms, vars, consequences); }
|
||||
|
||||
|
|
@ -106,12 +106,12 @@ public:
|
|||
filter(mdl, 0);
|
||||
}
|
||||
|
||||
virtual unsigned get_num_assertions() const {
|
||||
unsigned get_num_assertions() const override {
|
||||
flush_assertions();
|
||||
return m_solver->get_num_assertions();
|
||||
}
|
||||
|
||||
virtual expr * get_assertion(unsigned idx) const {
|
||||
expr * get_assertion(unsigned idx) const override {
|
||||
flush_assertions();
|
||||
return m_solver->get_assertion(idx);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -122,8 +122,8 @@ class smt_strategic_solver_factory : public solver_factory {
|
|||
public:
|
||||
smt_strategic_solver_factory(symbol const & logic):m_logic(logic) {}
|
||||
|
||||
virtual ~smt_strategic_solver_factory() {}
|
||||
virtual solver * operator()(ast_manager & m, params_ref const & p, bool proofs_enabled, bool models_enabled, bool unsat_core_enabled, symbol const & logic) {
|
||||
~smt_strategic_solver_factory() override {}
|
||||
solver * operator()(ast_manager & m, params_ref const & p, bool proofs_enabled, bool models_enabled, bool unsat_core_enabled, symbol const & logic) override {
|
||||
symbol l;
|
||||
if (m_logic != symbol::null)
|
||||
l = m_logic;
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@ Revision History:
|
|||
|
||||
class memory_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return result(static_cast<double>(memory::get_allocation_size())/static_cast<double>(1024*1024));
|
||||
}
|
||||
};
|
||||
|
|
@ -38,21 +38,21 @@ probe * mk_memory_probe() {
|
|||
|
||||
class depth_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return result(g.depth());
|
||||
}
|
||||
};
|
||||
|
||||
class size_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return result(g.size());
|
||||
}
|
||||
};
|
||||
|
||||
class num_exprs_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return result(g.num_exprs());
|
||||
}
|
||||
};
|
||||
|
|
@ -79,7 +79,7 @@ public:
|
|||
p->inc_ref();
|
||||
}
|
||||
|
||||
~unary_probe() {
|
||||
~unary_probe() override {
|
||||
m_p->dec_ref();
|
||||
}
|
||||
|
||||
|
|
@ -99,7 +99,7 @@ public:
|
|||
p2->inc_ref();
|
||||
}
|
||||
|
||||
~bin_probe() {
|
||||
~bin_probe() override {
|
||||
m_p1->dec_ref();
|
||||
m_p2->dec_ref();
|
||||
}
|
||||
|
|
@ -108,7 +108,7 @@ public:
|
|||
class not_probe : public unary_probe {
|
||||
public:
|
||||
not_probe(probe * p):unary_probe(p) {}
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return result(!m_p->operator()(g).is_true());
|
||||
}
|
||||
};
|
||||
|
|
@ -116,7 +116,7 @@ public:
|
|||
class and_probe : public bin_probe {
|
||||
public:
|
||||
and_probe(probe * p1, probe * p2):bin_probe(p1, p2) {}
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return result(m_p1->operator()(g).is_true() && m_p2->operator()(g).is_true());
|
||||
}
|
||||
};
|
||||
|
|
@ -124,7 +124,7 @@ public:
|
|||
class or_probe : public bin_probe {
|
||||
public:
|
||||
or_probe(probe * p1, probe * p2):bin_probe(p1, p2) {}
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return result(m_p1->operator()(g).is_true() || m_p2->operator()(g).is_true());
|
||||
}
|
||||
};
|
||||
|
|
@ -132,7 +132,7 @@ public:
|
|||
class eq_probe : public bin_probe {
|
||||
public:
|
||||
eq_probe(probe * p1, probe * p2):bin_probe(p1, p2) {}
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return result(m_p1->operator()(g).get_value() == m_p2->operator()(g).get_value());
|
||||
}
|
||||
};
|
||||
|
|
@ -140,7 +140,7 @@ public:
|
|||
class le_probe : public bin_probe {
|
||||
public:
|
||||
le_probe(probe * p1, probe * p2):bin_probe(p1, p2) {}
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return result(m_p1->operator()(g).get_value() <= m_p2->operator()(g).get_value());
|
||||
}
|
||||
};
|
||||
|
|
@ -148,7 +148,7 @@ public:
|
|||
class add_probe : public bin_probe {
|
||||
public:
|
||||
add_probe(probe * p1, probe * p2):bin_probe(p1, p2) {}
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return result(m_p1->operator()(g).get_value() + m_p2->operator()(g).get_value());
|
||||
}
|
||||
};
|
||||
|
|
@ -156,7 +156,7 @@ public:
|
|||
class sub_probe : public bin_probe {
|
||||
public:
|
||||
sub_probe(probe * p1, probe * p2):bin_probe(p1, p2) {}
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return result(m_p1->operator()(g).get_value() - m_p2->operator()(g).get_value());
|
||||
}
|
||||
};
|
||||
|
|
@ -164,7 +164,7 @@ public:
|
|||
class mul_probe : public bin_probe {
|
||||
public:
|
||||
mul_probe(probe * p1, probe * p2):bin_probe(p1, p2) {}
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return result(m_p1->operator()(g).get_value() * m_p2->operator()(g).get_value());
|
||||
}
|
||||
};
|
||||
|
|
@ -172,7 +172,7 @@ public:
|
|||
class div_probe : public bin_probe {
|
||||
public:
|
||||
div_probe(probe * p1, probe * p2):bin_probe(p1, p2) {}
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return result(m_p1->operator()(g).get_value() / m_p2->operator()(g).get_value());
|
||||
}
|
||||
};
|
||||
|
|
@ -182,7 +182,7 @@ class const_probe : public probe {
|
|||
public:
|
||||
const_probe(double v):m_val(v) {}
|
||||
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return result(m_val);
|
||||
}
|
||||
};
|
||||
|
|
@ -303,7 +303,7 @@ struct is_non_qfbv_predicate {
|
|||
|
||||
class is_propositional_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return !test<is_non_propositional_predicate>(g);
|
||||
}
|
||||
};
|
||||
|
|
@ -311,7 +311,7 @@ public:
|
|||
|
||||
class is_qfbv_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return !test<is_non_qfbv_predicate>(g);
|
||||
}
|
||||
};
|
||||
|
|
@ -353,7 +353,7 @@ struct is_non_qfaufbv_predicate {
|
|||
|
||||
class is_qfaufbv_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return !test<is_non_qfaufbv_predicate>(g);
|
||||
}
|
||||
};
|
||||
|
|
@ -391,7 +391,7 @@ struct is_non_qfufbv_predicate {
|
|||
|
||||
class is_qfufbv_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return !test<is_non_qfufbv_predicate>(g);
|
||||
}
|
||||
};
|
||||
|
|
@ -442,7 +442,7 @@ public:
|
|||
num_consts_probe(bool b, char const * f):
|
||||
m_bool(b), m_family(f) {
|
||||
}
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
proc p(g.m(), m_bool, m_family);
|
||||
unsigned sz = g.size();
|
||||
expr_fast_mark1 visited;
|
||||
|
|
@ -471,21 +471,21 @@ probe * mk_num_bv_consts_probe() {
|
|||
|
||||
class produce_proofs_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return g.proofs_enabled();
|
||||
}
|
||||
};
|
||||
|
||||
class produce_models_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return g.models_enabled();
|
||||
}
|
||||
};
|
||||
|
||||
class produce_unsat_cores_probe : public probe {
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
return g.unsat_core_enabled();
|
||||
}
|
||||
};
|
||||
|
|
@ -514,7 +514,7 @@ struct has_pattern_probe : public probe {
|
|||
}
|
||||
};
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
try {
|
||||
expr_fast_mark1 visited;
|
||||
proc p;
|
||||
|
|
@ -544,7 +544,7 @@ struct has_quantifier_probe : public probe {
|
|||
void operator()(quantifier * n) { throw found(); }
|
||||
};
|
||||
public:
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
try {
|
||||
expr_fast_mark1 visited;
|
||||
proc p;
|
||||
|
|
|
|||
|
|
@ -23,16 +23,16 @@ class concat_proof_converter : public concat_converter<proof_converter> {
|
|||
public:
|
||||
concat_proof_converter(proof_converter * pc1, proof_converter * pc2):concat_converter<proof_converter>(pc1, pc2) {}
|
||||
|
||||
virtual char const * get_name() const { return "concat-proof-converter"; }
|
||||
char const * get_name() const override { return "concat-proof-converter"; }
|
||||
|
||||
virtual void operator()(ast_manager & m, unsigned num_source, proof * const * source, proof_ref & result) {
|
||||
void operator()(ast_manager & m, unsigned num_source, proof * const * source, proof_ref & result) override {
|
||||
proof_ref tmp(m);
|
||||
this->m_c2->operator()(m, num_source, source, tmp);
|
||||
proof * new_source = tmp.get();
|
||||
this->m_c1->operator()(m, 1, &new_source, result);
|
||||
}
|
||||
|
||||
virtual proof_converter * translate(ast_translation & translator) {
|
||||
proof_converter * translate(ast_translation & translator) override {
|
||||
return this->translate_core<concat_proof_converter>(translator);
|
||||
}
|
||||
};
|
||||
|
|
@ -51,9 +51,9 @@ public:
|
|||
concat_star_converter<proof_converter>(pc1, num, pc2s, szs) {
|
||||
}
|
||||
|
||||
virtual char const * get_name() const { return "concat-star-proof-converter"; }
|
||||
char const * get_name() const override { return "concat-star-proof-converter"; }
|
||||
|
||||
virtual void operator()(ast_manager & m, unsigned num_source, proof * const * source, proof_ref & result) {
|
||||
void operator()(ast_manager & m, unsigned num_source, proof * const * source, proof_ref & result) override {
|
||||
unsigned num = this->m_szs.size();
|
||||
#ifdef Z3DEBUG
|
||||
unsigned sum = 0;
|
||||
|
|
@ -86,7 +86,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual proof_converter * translate(ast_translation & translator) {
|
||||
proof_converter * translate(ast_translation & translator) override {
|
||||
return this->translate_core<concat_star_proof_converter>(translator);
|
||||
}
|
||||
};
|
||||
|
|
@ -111,18 +111,18 @@ class proof2pc : public proof_converter {
|
|||
proof_ref m_pr;
|
||||
public:
|
||||
proof2pc(ast_manager & m, proof * pr):m_pr(pr, m) {}
|
||||
virtual ~proof2pc() {}
|
||||
~proof2pc() override {}
|
||||
|
||||
virtual void operator()(ast_manager & m, unsigned num_source, proof * const * source, proof_ref & result) {
|
||||
void operator()(ast_manager & m, unsigned num_source, proof * const * source, proof_ref & result) override {
|
||||
SASSERT(num_source == 0);
|
||||
result = m_pr;
|
||||
}
|
||||
|
||||
virtual proof_converter * translate(ast_translation & translator) {
|
||||
proof_converter * translate(ast_translation & translator) override {
|
||||
return alloc(proof2pc, translator.to(), translator(m_pr.get()));
|
||||
}
|
||||
|
||||
virtual void display(std::ostream & out) {
|
||||
void display(std::ostream & out) override {
|
||||
out << "(proof->proof-converter-wrapper\n" << mk_ismt2_pp(m_pr.get(), m_pr.get_manager()) << ")\n";
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ Notes:
|
|||
|
||||
class proof_converter : public converter {
|
||||
public:
|
||||
virtual ~proof_converter() { }
|
||||
~proof_converter() override { }
|
||||
virtual void operator()(ast_manager & m, unsigned num_source, proof * const * source, proof_ref & result) = 0;
|
||||
virtual proof_converter * translate(ast_translation & translator) = 0;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -32,11 +32,11 @@ public:
|
|||
|
||||
replace_proof_converter(ast_manager& _m): m(_m), m_proofs(m) {}
|
||||
|
||||
virtual ~replace_proof_converter() {}
|
||||
~replace_proof_converter() override {}
|
||||
|
||||
virtual void operator()(ast_manager & _m, unsigned num_source, proof * const * source, proof_ref & result);
|
||||
void operator()(ast_manager & _m, unsigned num_source, proof * const * source, proof_ref & result) override;
|
||||
|
||||
virtual proof_converter * translate(ast_translation & translator);
|
||||
proof_converter * translate(ast_translation & translator) override;
|
||||
|
||||
void insert(proof* p) { m_proofs.push_back(p); }
|
||||
|
||||
|
|
|
|||
|
|
@ -38,21 +38,21 @@ public:
|
|||
sine_tactic(ast_manager& m, params_ref const& p):
|
||||
m(m), m_params(p) {}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(sine_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
mc = 0; pc = 0; core = 0;
|
||||
|
||||
TRACE("sine", g->display(tout););
|
||||
|
|
@ -73,7 +73,7 @@ public:
|
|||
mc = fmc;
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
}
|
||||
|
||||
private:
|
||||
|
|
|
|||
|
|
@ -42,28 +42,28 @@ public:
|
|||
m_engine = alloc(sls_engine, m, p);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(sls_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~sls_tactic() {
|
||||
~sls_tactic() override {
|
||||
dealloc(m_engine);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
m_engine->updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
sls_params::collect_param_descrs(r);
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
SASSERT(g->is_well_sorted());
|
||||
mc = 0; pc = 0; core = 0; result.reset();
|
||||
|
||||
|
|
@ -78,17 +78,17 @@ public:
|
|||
SASSERT(g->is_well_sorted());
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
sls_engine * d = alloc(sls_engine, m, m_params);
|
||||
std::swap(d, m_engine);
|
||||
dealloc(d);
|
||||
}
|
||||
|
||||
virtual void collect_statistics(statistics & st) const {
|
||||
void collect_statistics(statistics & st) const override {
|
||||
m_engine->collect_statistics(st);
|
||||
}
|
||||
|
||||
virtual void reset_statistics() {
|
||||
void reset_statistics() override {
|
||||
m_engine->reset_statistics();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@ Notes:
|
|||
#include "tactic/arith/probe_arith.h"
|
||||
|
||||
struct quasi_pb_probe : public probe {
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
bool found_non_01 = false;
|
||||
bound_manager bm(g.m());
|
||||
bm(g);
|
||||
|
|
|
|||
|
|
@ -51,13 +51,13 @@ public:
|
|||
, m_inc_use_sat(false)
|
||||
{}
|
||||
|
||||
virtual ~qfufbv_ackr_tactic() { }
|
||||
~qfufbv_ackr_tactic() override { }
|
||||
|
||||
virtual void operator()(goal_ref const & g,
|
||||
void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
expr_dependency_ref & core) override {
|
||||
mc = 0;
|
||||
ast_manager& m(g->m());
|
||||
tactic_report report("qfufbv_ackr", *g);
|
||||
|
|
@ -84,23 +84,23 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
void updt_params(params_ref const & _p) {
|
||||
void updt_params(params_ref const & _p) override {
|
||||
qfufbv_tactic_params p(_p);
|
||||
m_use_sat = p.sat_backend();
|
||||
m_inc_use_sat = p.inc_sat_backend();
|
||||
}
|
||||
|
||||
virtual void collect_statistics(statistics & st) const {
|
||||
void collect_statistics(statistics & st) const override {
|
||||
ackermannization_params p(m_p);
|
||||
if (!p.eager()) st.update("lackr-its", m_st.m_it);
|
||||
st.update("ackr-constraints", m_st.m_ackrs_sz);
|
||||
}
|
||||
|
||||
virtual void reset_statistics() { m_st.reset(); }
|
||||
void reset_statistics() override { m_st.reset(); }
|
||||
|
||||
virtual void cleanup() { }
|
||||
void cleanup() override { }
|
||||
|
||||
virtual tactic* translate(ast_manager& m) {
|
||||
tactic* translate(ast_manager& m) override {
|
||||
return alloc(qfufbv_ackr_tactic, m, m_p);
|
||||
}
|
||||
private:
|
||||
|
|
|
|||
|
|
@ -85,17 +85,17 @@ tactic * mk_skip_tactic() {
|
|||
|
||||
class fail_tactic : public tactic {
|
||||
public:
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
throw tactic_exception("fail tactic");
|
||||
}
|
||||
|
||||
virtual void cleanup() {}
|
||||
void cleanup() override {}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) { return this; }
|
||||
tactic * translate(ast_manager & m) override { return this; }
|
||||
};
|
||||
|
||||
tactic * mk_fail_tactic() {
|
||||
|
|
@ -108,11 +108,11 @@ class report_verbose_tactic : public skip_tactic {
|
|||
public:
|
||||
report_verbose_tactic(char const * msg, unsigned lvl) : m_msg(msg), m_lvl(lvl) {}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
IF_VERBOSE(m_lvl, verbose_stream() << m_msg << "\n";);
|
||||
skip_tactic::operator()(in, result, mc, pc, core);
|
||||
}
|
||||
|
|
@ -127,11 +127,11 @@ class trace_tactic : public skip_tactic {
|
|||
public:
|
||||
trace_tactic(char const * tag): m_tag(tag) {}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
TRACE(m_tag, in->display(tout););
|
||||
(void)m_tag;
|
||||
skip_tactic::operator()(in, result, mc, pc, core);
|
||||
|
|
@ -146,11 +146,11 @@ class fail_if_undecided_tactic : public skip_tactic {
|
|||
public:
|
||||
fail_if_undecided_tactic() {}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
if (!in->is_decided())
|
||||
throw tactic_exception("undecided");
|
||||
skip_tactic::operator()(in, result, mc, pc, core);
|
||||
|
|
|
|||
|
|
@ -119,9 +119,9 @@ void report_tactic_progress(char const * id, unsigned val);
|
|||
|
||||
class skip_tactic : public tactic {
|
||||
public:
|
||||
virtual void operator()(goal_ref const & in, goal_ref_buffer & result, model_converter_ref & mc, proof_converter_ref & pc, expr_dependency_ref & core);
|
||||
virtual void cleanup() {}
|
||||
virtual tactic * translate(ast_manager & m) { return this; }
|
||||
void operator()(goal_ref const & in, goal_ref_buffer & result, model_converter_ref & mc, proof_converter_ref & pc, expr_dependency_ref & core) override;
|
||||
void cleanup() override {}
|
||||
tactic * translate(ast_manager & m) override { return this; }
|
||||
};
|
||||
|
||||
tactic * mk_skip_tactic();
|
||||
|
|
|
|||
|
|
@ -27,8 +27,8 @@ protected:
|
|||
std::string m_msg;
|
||||
public:
|
||||
tactic_exception(char const * msg):m_msg(msg) {}
|
||||
virtual ~tactic_exception() {}
|
||||
virtual char const * msg() const { return m_msg.c_str(); }
|
||||
~tactic_exception() override {}
|
||||
char const * msg() const override { return m_msg.c_str(); }
|
||||
};
|
||||
|
||||
#define TACTIC_CANCELED_MSG Z3_CANCELED_MSG
|
||||
|
|
|
|||
|
|
@ -39,47 +39,47 @@ public:
|
|||
m_t2->inc_ref();
|
||||
}
|
||||
|
||||
virtual ~binary_tactical() {
|
||||
~binary_tactical() override {
|
||||
m_t1->dec_ref();
|
||||
m_t2->dec_ref();
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_t1->updt_params(p);
|
||||
m_t2->updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
m_t1->collect_param_descrs(r);
|
||||
m_t2->collect_param_descrs(r);
|
||||
}
|
||||
|
||||
virtual void collect_statistics(statistics & st) const {
|
||||
void collect_statistics(statistics & st) const override {
|
||||
m_t1->collect_statistics(st);
|
||||
m_t2->collect_statistics(st);
|
||||
}
|
||||
|
||||
virtual void reset_statistics() {
|
||||
void reset_statistics() override {
|
||||
m_t1->reset_statistics();
|
||||
m_t2->reset_statistics();
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
m_t1->cleanup();
|
||||
m_t2->cleanup();
|
||||
}
|
||||
|
||||
virtual void reset() {
|
||||
void reset() override {
|
||||
m_t1->reset();
|
||||
m_t2->reset();
|
||||
}
|
||||
|
||||
virtual void set_logic(symbol const & l) {
|
||||
void set_logic(symbol const & l) override {
|
||||
m_t1->set_logic(l);
|
||||
m_t2->set_logic(l);
|
||||
}
|
||||
|
||||
virtual void set_progress_callback(progress_callback * callback) {
|
||||
void set_progress_callback(progress_callback * callback) override {
|
||||
m_t1->set_progress_callback(callback);
|
||||
m_t2->set_progress_callback(callback);
|
||||
}
|
||||
|
|
@ -104,13 +104,13 @@ struct false_pred {
|
|||
class and_then_tactical : public binary_tactical {
|
||||
public:
|
||||
and_then_tactical(tactic * t1, tactic * t2):binary_tactical(t1, t2) {}
|
||||
virtual ~and_then_tactical() {}
|
||||
~and_then_tactical() override {}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
|
||||
bool models_enabled = in->models_enabled();
|
||||
bool proofs_enabled = in->proofs_enabled();
|
||||
|
|
@ -212,7 +212,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return translate_core<and_then_tactical>(m);
|
||||
}
|
||||
|
||||
|
|
@ -282,14 +282,14 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual ~nary_tactical() {
|
||||
~nary_tactical() override {
|
||||
unsigned sz = m_ts.size();
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
m_ts[i]->dec_ref();
|
||||
}
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
TRACE("nary_tactical_updt_params", tout << "updt_params: " << p << "\n";);
|
||||
ptr_vector<tactic>::iterator it = m_ts.begin();
|
||||
ptr_vector<tactic>::iterator end = m_ts.end();
|
||||
|
|
@ -297,49 +297,49 @@ public:
|
|||
(*it)->updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
ptr_vector<tactic>::iterator it = m_ts.begin();
|
||||
ptr_vector<tactic>::iterator end = m_ts.end();
|
||||
for (; it != end; ++it)
|
||||
(*it)->collect_param_descrs(r);
|
||||
}
|
||||
|
||||
virtual void collect_statistics(statistics & st) const {
|
||||
void collect_statistics(statistics & st) const override {
|
||||
ptr_vector<tactic>::const_iterator it = m_ts.begin();
|
||||
ptr_vector<tactic>::const_iterator end = m_ts.end();
|
||||
for (; it != end; ++it)
|
||||
(*it)->collect_statistics(st);
|
||||
}
|
||||
|
||||
virtual void reset_statistics() {
|
||||
void reset_statistics() override {
|
||||
ptr_vector<tactic>::const_iterator it = m_ts.begin();
|
||||
ptr_vector<tactic>::const_iterator end = m_ts.end();
|
||||
for (; it != end; ++it)
|
||||
(*it)->reset_statistics();
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
ptr_vector<tactic>::iterator it = m_ts.begin();
|
||||
ptr_vector<tactic>::iterator end = m_ts.end();
|
||||
for (; it != end; ++it)
|
||||
(*it)->cleanup();
|
||||
}
|
||||
|
||||
virtual void reset() {
|
||||
void reset() override {
|
||||
ptr_vector<tactic>::iterator it = m_ts.begin();
|
||||
ptr_vector<tactic>::iterator end = m_ts.end();
|
||||
for (; it != end; ++it)
|
||||
(*it)->reset();
|
||||
}
|
||||
|
||||
virtual void set_logic(symbol const & l) {
|
||||
void set_logic(symbol const & l) override {
|
||||
ptr_vector<tactic>::iterator it = m_ts.begin();
|
||||
ptr_vector<tactic>::iterator end = m_ts.end();
|
||||
for (; it != end; ++it)
|
||||
(*it)->set_logic(l);
|
||||
}
|
||||
|
||||
virtual void set_progress_callback(progress_callback * callback) {
|
||||
void set_progress_callback(progress_callback * callback) override {
|
||||
ptr_vector<tactic>::iterator it = m_ts.begin();
|
||||
ptr_vector<tactic>::iterator end = m_ts.end();
|
||||
for (; it != end; ++it)
|
||||
|
|
@ -367,13 +367,13 @@ class or_else_tactical : public nary_tactical {
|
|||
public:
|
||||
or_else_tactical(unsigned num, tactic * const * ts):nary_tactical(num, ts) { SASSERT(num > 0); }
|
||||
|
||||
virtual ~or_else_tactical() {}
|
||||
~or_else_tactical() override {}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
goal orig(*(in.get()));
|
||||
unsigned sz = m_ts.size();
|
||||
unsigned i;
|
||||
|
|
@ -401,7 +401,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) { return translate_core<or_else_tactical>(m); }
|
||||
tactic * translate(ast_manager & m) override { return translate_core<or_else_tactical>(m); }
|
||||
};
|
||||
|
||||
tactic * or_else(unsigned num, tactic * const * ts) {
|
||||
|
|
@ -464,15 +464,15 @@ class par_tactical : public or_else_tactical {
|
|||
|
||||
public:
|
||||
par_tactical(unsigned num, tactic * const * ts):or_else_tactical(num, ts) {}
|
||||
virtual ~par_tactical() {}
|
||||
~par_tactical() override {}
|
||||
|
||||
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
bool use_seq;
|
||||
#ifdef _NO_OMP_
|
||||
use_seq = true;
|
||||
|
|
@ -572,7 +572,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) { return translate_core<par_tactical>(m); }
|
||||
tactic * translate(ast_manager & m) override { return translate_core<par_tactical>(m); }
|
||||
};
|
||||
|
||||
tactic * par(unsigned num, tactic * const * ts) {
|
||||
|
|
@ -597,13 +597,13 @@ tactic * par(tactic * t1, tactic * t2, tactic * t3, tactic * t4) {
|
|||
class par_and_then_tactical : public and_then_tactical {
|
||||
public:
|
||||
par_and_then_tactical(tactic * t1, tactic * t2):and_then_tactical(t1, t2) {}
|
||||
virtual ~par_and_then_tactical() {}
|
||||
~par_and_then_tactical() override {}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
bool use_seq;
|
||||
#ifdef _NO_OMP_
|
||||
use_seq = true;
|
||||
|
|
@ -862,7 +862,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return translate_core<and_then_tactical>(m);
|
||||
}
|
||||
|
||||
|
|
@ -895,26 +895,26 @@ public:
|
|||
t->inc_ref();
|
||||
}
|
||||
|
||||
virtual ~unary_tactical() {
|
||||
~unary_tactical() override {
|
||||
m_t->dec_ref();
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
m_t->operator()(in, result, mc, pc, core);
|
||||
}
|
||||
|
||||
virtual void cleanup(void) { m_t->cleanup(); }
|
||||
virtual void collect_statistics(statistics & st) const { m_t->collect_statistics(st); }
|
||||
virtual void reset_statistics() { m_t->reset_statistics(); }
|
||||
virtual void updt_params(params_ref const & p) { m_t->updt_params(p); }
|
||||
virtual void collect_param_descrs(param_descrs & r) { m_t->collect_param_descrs(r); }
|
||||
virtual void reset() { m_t->reset(); }
|
||||
virtual void set_logic(symbol const& l) { m_t->set_logic(l); }
|
||||
virtual void set_progress_callback(progress_callback * callback) { m_t->set_progress_callback(callback); }
|
||||
void cleanup(void) override { m_t->cleanup(); }
|
||||
void collect_statistics(statistics & st) const override { m_t->collect_statistics(st); }
|
||||
void reset_statistics() override { m_t->reset_statistics(); }
|
||||
void updt_params(params_ref const & p) override { m_t->updt_params(p); }
|
||||
void collect_param_descrs(param_descrs & r) override { m_t->collect_param_descrs(r); }
|
||||
void reset() override { m_t->reset(); }
|
||||
void set_logic(symbol const& l) override { m_t->set_logic(l); }
|
||||
void set_progress_callback(progress_callback * callback) override { m_t->set_progress_callback(callback); }
|
||||
protected:
|
||||
|
||||
template<typename T>
|
||||
|
|
@ -1056,15 +1056,15 @@ public:
|
|||
m_max_depth(max_depth) {
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
operator()(0, in, result, mc, pc, core);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
tactic * new_t = m_t->translate(m);
|
||||
return alloc(repeat_tactical, new_t, m_max_depth);
|
||||
}
|
||||
|
|
@ -1079,11 +1079,11 @@ class fail_if_branching_tactical : public unary_tactical {
|
|||
public:
|
||||
fail_if_branching_tactical(tactic * t, unsigned threshold):unary_tactical(t), m_threshold(threshold) {}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
m_t->operator()(in, result, mc, pc, core);
|
||||
if (result.size() > m_threshold) {
|
||||
result.reset();
|
||||
|
|
@ -1094,7 +1094,7 @@ public:
|
|||
}
|
||||
};
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
tactic * new_t = m_t->translate(m);
|
||||
return alloc(fail_if_branching_tactical, new_t, m_threshold);
|
||||
}
|
||||
|
|
@ -1108,16 +1108,16 @@ class cleanup_tactical : public unary_tactical {
|
|||
public:
|
||||
cleanup_tactical(tactic * t):unary_tactical(t) {}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
m_t->operator()(in, result, mc, pc, core);
|
||||
m_t->cleanup();
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
tactic * new_t = m_t->translate(m);
|
||||
return alloc(cleanup_tactical, new_t);
|
||||
}
|
||||
|
|
@ -1132,11 +1132,11 @@ class try_for_tactical : public unary_tactical {
|
|||
public:
|
||||
try_for_tactical(tactic * t, unsigned ts):unary_tactical(t), m_timeout(ts) {}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
cancel_eh<reslimit> eh(in->m().limit());
|
||||
{
|
||||
// Warning: scoped_timer is not thread safe in Linux.
|
||||
|
|
@ -1145,7 +1145,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
tactic * new_t = m_t->translate(m);
|
||||
return alloc(try_for_tactical, new_t, m_timeout);
|
||||
}
|
||||
|
|
@ -1162,7 +1162,7 @@ public:
|
|||
t->updt_params(p);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
TRACE("using_params",
|
||||
tout << "before p: " << p << "\n";
|
||||
tout << "m_params: " << m_params << "\n";);
|
||||
|
|
@ -1177,7 +1177,7 @@ public:
|
|||
tout << "new_p: " << new_p << "\n";);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
tactic * new_t = m_t->translate(m);
|
||||
return alloc(using_params_tactical, new_t, m_params);
|
||||
}
|
||||
|
|
@ -1202,16 +1202,16 @@ public:
|
|||
annotate_tactical(char const* name, tactic* t):
|
||||
unary_tactical(t), m_name(name) {}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
scope _scope(m_name);
|
||||
m_t->operator()(in, result, mc, pc, core);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
tactic * new_t = m_t->translate(m);
|
||||
return alloc(annotate_tactical, m_name.c_str(), new_t);
|
||||
}
|
||||
|
|
@ -1232,22 +1232,22 @@ public:
|
|||
m_p->inc_ref();
|
||||
}
|
||||
|
||||
~cond_tactical() {
|
||||
~cond_tactical() override {
|
||||
m_p->dec_ref();
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
if (m_p->operator()(*(in.get())).is_true())
|
||||
m_t1->operator()(in, result, mc, pc, core);
|
||||
else
|
||||
m_t2->operator()(in, result, mc, pc, core);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
tactic * new_t1 = m_t1->translate(m);
|
||||
tactic * new_t2 = m_t2->translate(m);
|
||||
return alloc(cond_tactical, m_p, new_t1, new_t2);
|
||||
|
|
@ -1271,17 +1271,17 @@ public:
|
|||
m_p->inc_ref();
|
||||
}
|
||||
|
||||
~fail_if_tactic() {
|
||||
~fail_if_tactic() override {
|
||||
m_p->dec_ref();
|
||||
}
|
||||
|
||||
void cleanup() {}
|
||||
void cleanup() override {}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
mc = 0;
|
||||
pc = 0;
|
||||
core = 0;
|
||||
|
|
@ -1291,7 +1291,7 @@ public:
|
|||
result.push_back(in.get());
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return this;
|
||||
}
|
||||
};
|
||||
|
|
@ -1308,11 +1308,11 @@ class if_no_proofs_tactical : public unary_tactical {
|
|||
public:
|
||||
if_no_proofs_tactical(tactic * t):unary_tactical(t) {}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
if (in->proofs_enabled()) {
|
||||
mc = 0; pc = 0; core = 0;
|
||||
result.reset();
|
||||
|
|
@ -1323,18 +1323,18 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) { return translate_core<if_no_proofs_tactical>(m); }
|
||||
tactic * translate(ast_manager & m) override { return translate_core<if_no_proofs_tactical>(m); }
|
||||
};
|
||||
|
||||
class if_no_unsat_cores_tactical : public unary_tactical {
|
||||
public:
|
||||
if_no_unsat_cores_tactical(tactic * t):unary_tactical(t) {}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
if (in->unsat_core_enabled()) {
|
||||
mc = 0; pc = 0; core = 0;
|
||||
result.reset();
|
||||
|
|
@ -1345,18 +1345,18 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) { return translate_core<if_no_unsat_cores_tactical>(m); }
|
||||
tactic * translate(ast_manager & m) override { return translate_core<if_no_unsat_cores_tactical>(m); }
|
||||
};
|
||||
|
||||
class if_no_models_tactical : public unary_tactical {
|
||||
public:
|
||||
if_no_models_tactical(tactic * t):unary_tactical(t) {}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
if (in->models_enabled()) {
|
||||
mc = 0; pc = 0; core = 0;
|
||||
result.reset();
|
||||
|
|
@ -1367,7 +1367,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) { return translate_core<if_no_models_tactical>(m); }
|
||||
tactic * translate(ast_manager & m) override { return translate_core<if_no_models_tactical>(m); }
|
||||
};
|
||||
|
||||
tactic * if_no_proofs(tactic * t) {
|
||||
|
|
@ -1386,4 +1386,3 @@ tactic * skip_if_failed(tactic * t) {
|
|||
return or_else(t, mk_skip_tactic());
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -97,35 +97,35 @@ public:
|
|||
m_imp = alloc(imp, m, p);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(macro_finder_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~macro_finder_tactic() {
|
||||
~macro_finder_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
m_imp->updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
insert_max_memory(r);
|
||||
insert_produce_models(r);
|
||||
insert_produce_proofs(r);
|
||||
r.insert("elim_and", CPK_BOOL, "(default: false) eliminate conjunctions during (internal) calls to the simplifier.");
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
(*m_imp)(in, result, mc, pc, core);
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
ast_manager & m = m_imp->m();
|
||||
imp * d = alloc(imp, m, m_params);
|
||||
std::swap(d, m_imp);
|
||||
|
|
|
|||
|
|
@ -109,34 +109,34 @@ public:
|
|||
m_imp = alloc(imp, m, p);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(quasi_macros_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~quasi_macros_tactic() {
|
||||
~quasi_macros_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
m_imp->updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
insert_max_memory(r);
|
||||
insert_produce_models(r);
|
||||
insert_produce_proofs(r);
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
(*m_imp)(in, result, mc, pc, core);
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
ast_manager & m = m_imp->m();
|
||||
imp * d = alloc(imp, m, m_params);
|
||||
std::swap(d, m_imp);
|
||||
|
|
|
|||
|
|
@ -81,34 +81,34 @@ public:
|
|||
m_imp = alloc(imp, m, p);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(ufbv_rewriter_tactic, m, m_params);
|
||||
}
|
||||
|
||||
virtual ~ufbv_rewriter_tactic() {
|
||||
~ufbv_rewriter_tactic() override {
|
||||
dealloc(m_imp);
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params = p;
|
||||
m_imp->updt_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
insert_max_memory(r);
|
||||
insert_produce_models(r);
|
||||
insert_produce_proofs(r);
|
||||
}
|
||||
|
||||
virtual void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) override {
|
||||
(*m_imp)(in, result, mc, pc, core);
|
||||
}
|
||||
|
||||
virtual void cleanup() {
|
||||
void cleanup() override {
|
||||
ast_manager & m = m_imp->m();
|
||||
imp * d = alloc(imp, m, m_params);
|
||||
std::swap(d, m_imp);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue