mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-29 03:45:51 +00:00
Code Activity

Use override rather than virtual.

Browse source
This commit is contained in:
Bruce Mitchener 2018-02-09 21:15:02 +07:00
parent 2b847478a2
commit b7d1753843
138 changed files with 1621 additions and 1624 deletions
Download patch file Download diff file Expand all files Collapse all files

20
src/tactic/core/blast_term_ite_tactic.cpp
View file

@ -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);

20
src/tactic/core/cofactor_term_ite_tactic.cpp
View file

@ -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(); }
};

22
src/tactic/core/collect_statistics_tactic.cpp
View file

@ -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 {

12
src/tactic/core/ctx_simplify_tactic.cpp
View file

@ -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;
};

20
src/tactic/core/ctx_simplify_tactic.h
View file

@ -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());

16
src/tactic/core/der_tactic.cpp
View file

@ -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);

14
src/tactic/core/distribute_forall_tactic.cpp
View file

@ -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) {

32
src/tactic/core/dom_simplify_tactic.h
View file

@ -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);
}

20
src/tactic/core/elim_term_ite_tactic.cpp
View file

@ -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);

24
src/tactic/core/elim_uncnstr_tactic.cpp
View file

@ -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;
}

20
src/tactic/core/injectivity_tactic.cpp
View file

@ -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);

20
src/tactic/core/nnf_tactic.cpp
View file

@ -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) {

20
src/tactic/core/occf_tactic.cpp
View file

@ -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);

25
src/tactic/core/pb_preprocess_tactic.cpp
View file

@ -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();

20
src/tactic/core/propagate_values_tactic.cpp
View file

@ -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();

8
src/tactic/core/reduce_args_tactic.cpp
View file

@ -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) {

22
src/tactic/core/simplify_tactic.h
View file

@ -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); }
};

24
src/tactic/core/solve_eqs_tactic.cpp
View file

@ -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;
}

26
src/tactic/core/split_clause_tactic.cpp
View file

@ -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
}
};

16
src/tactic/core/symmetry_reduce_tactic.cpp
View file

@ -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 {

24
src/tactic/core/tseitin_cnf_tactic.cpp
View file

@ -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;
}
};