mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-07-18 02:16:40 +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

10
src/tactic/bv/bit_blaster_model_converter.cpp
View file

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

20
src/tactic/bv/bit_blaster_tactic.cpp
View file

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

22
src/tactic/bv/bv1_blaster_tactic.cpp
View file

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

16
src/tactic/bv/bv_bound_chk_tactic.cpp
View file

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

28
src/tactic/bv/bv_bounds_tactic.cpp
View file

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

8
src/tactic/bv/bv_size_reduction_tactic.cpp
View file

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

20
src/tactic/bv/bvarray2uf_tactic.cpp
View file

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

22
src/tactic/bv/dt2bv_tactic.cpp
View file

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

14
src/tactic/bv/elim_small_bv_tactic.cpp
View file

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

20
src/tactic/bv/max_bv_sharing_tactic.cpp
View file

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