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

44
src/tactic/portfolio/bounded_int2bv_solver.cpp
View file

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

44
src/tactic/portfolio/enum2bv_solver.cpp
View file

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

44
src/tactic/portfolio/pb2bv_solver.cpp
View file

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

4
src/tactic/portfolio/smt_strategic_solver.cpp
View file

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