mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-12-10 05:43:22 +00:00
Code Activity

Use override rather than virtual.

Browse source
This commit is contained in:
Bruce Mitchener 2018-02-10 09:15:12 +07:00
parent ce123d9dbc
commit 7167fda1dc
220 changed files with 2546 additions and 2548 deletions
Download patch file Download diff file Expand all files Collapse all files

34
src/muz/spacer/spacer_dl_interface.h
View file

@ -45,39 +45,39 @@ class dl_interface : public datalog::engine_base {
public:
dl_interface(datalog::context& ctx);
~dl_interface();
~dl_interface() override;
lbool query(expr* query);
lbool query(expr* query) override;
lbool query_from_lvl(expr* query, unsigned lvl);
lbool query_from_lvl(expr* query, unsigned lvl) override;
void display_certificate(std::ostream& out) const;
void display_certificate(std::ostream& out) const override;
void collect_statistics(statistics& st) const;
void collect_statistics(statistics& st) const override;
void reset_statistics();
void reset_statistics() override;
expr_ref get_answer();
expr_ref get_answer() override;
expr_ref get_ground_sat_answer();
expr_ref get_ground_sat_answer() override;
void get_rules_along_trace(datalog::rule_ref_vector& rules);
void get_rules_along_trace(datalog::rule_ref_vector& rules) override;
unsigned get_num_levels(func_decl* pred);
unsigned get_num_levels(func_decl* pred) override;
expr_ref get_cover_delta(int level, func_decl* pred);
expr_ref get_cover_delta(int level, func_decl* pred) override;
void add_cover(int level, func_decl* pred, expr* property);
void add_cover(int level, func_decl* pred, expr* property) override;
void add_invariant(func_decl* pred, expr* property);
void add_invariant(func_decl* pred, expr* property) override;
expr_ref get_reachable(func_decl *pred);
expr_ref get_reachable(func_decl *pred) override;
void updt_params();
void updt_params() override;
model_ref get_model();
model_ref get_model() override;
proof_ref get_proof();
proof_ref get_proof() override;
};
}

28
src/muz/spacer/spacer_generalizers.h
View file

@ -30,8 +30,8 @@ namespace spacer {
class lemma_sanity_checker : public lemma_generalizer {
public:
lemma_sanity_checker(context& ctx) : lemma_generalizer(ctx) {}
virtual ~lemma_sanity_checker() {}
virtual void operator()(lemma_ref &lemma);
~lemma_sanity_checker() override {}
void operator()(lemma_ref &lemma) override;
};
/**
@ -53,11 +53,11 @@ class lemma_bool_inductive_generalizer : public lemma_generalizer {
public:
lemma_bool_inductive_generalizer(context& ctx, unsigned failure_limit) :
lemma_generalizer(ctx), m_failure_limit(failure_limit) {}
virtual ~lemma_bool_inductive_generalizer() {}
virtual void operator()(lemma_ref &lemma);
~lemma_bool_inductive_generalizer() override {}
void operator()(lemma_ref &lemma) override;
virtual void collect_statistics(statistics& st) const;
virtual void reset_statistics() {m_st.reset();}
void collect_statistics(statistics& st) const override;
void reset_statistics() override {m_st.reset();}
};
class unsat_core_generalizer : public lemma_generalizer {
@ -72,26 +72,26 @@ class unsat_core_generalizer : public lemma_generalizer {
stats m_st;
public:
unsat_core_generalizer(context &ctx) : lemma_generalizer(ctx) {}
virtual ~unsat_core_generalizer() {}
virtual void operator()(lemma_ref &lemma);
~unsat_core_generalizer() override {}
void operator()(lemma_ref &lemma) override;
virtual void collect_statistics(statistics &st) const;
virtual void reset_statistics() {m_st.reset();}
void collect_statistics(statistics &st) const override;
void reset_statistics() override {m_st.reset();}
};
class lemma_array_eq_generalizer : public lemma_generalizer {
public:
lemma_array_eq_generalizer(context &ctx) : lemma_generalizer(ctx) {}
virtual ~lemma_array_eq_generalizer() {}
virtual void operator()(lemma_ref &lemma);
~lemma_array_eq_generalizer() override {}
void operator()(lemma_ref &lemma) override;
};
class lemma_eq_generalizer : public lemma_generalizer {
public:
lemma_eq_generalizer(context &ctx) : lemma_generalizer(ctx) {}
virtual ~lemma_eq_generalizer() {}
virtual void operator()(lemma_ref &lemma);
~lemma_eq_generalizer() override {}
void operator()(lemma_ref &lemma) override;
};

52
src/muz/spacer/spacer_itp_solver.h
View file

@ -86,10 +86,10 @@ public:
m_farkas_a_const(farkas_a_const)
{}
virtual ~itp_solver() {}
~itp_solver() override {}
/* itp solver specific */
virtual void get_unsat_core(expr_ref_vector &core);
void get_unsat_core(expr_ref_vector &core) override;
virtual void get_itp_core(expr_ref_vector &core);
void set_split_literals(bool v) {m_split_literals = v;}
bool mk_proxies(expr_ref_vector &v, unsigned from = 0);
@ -104,53 +104,53 @@ public:
/* solver interface */
virtual solver* translate(ast_manager &m, params_ref const &p)
solver* translate(ast_manager &m, params_ref const &p) override
{return m_solver.translate(m, p);}
virtual void updt_params(params_ref const &p)
void updt_params(params_ref const &p) override
{m_solver.updt_params(p);}
virtual void collect_param_descrs(param_descrs &r)
void collect_param_descrs(param_descrs &r) override
{m_solver.collect_param_descrs(r);}
virtual void set_produce_models(bool f)
void set_produce_models(bool f) override
{m_solver.set_produce_models(f);}
virtual void assert_expr(expr *t)
void assert_expr(expr *t) override
{m_solver.assert_expr(t);}
virtual void assert_expr(expr *t, expr *a)
void assert_expr(expr *t, expr *a) override
{NOT_IMPLEMENTED_YET();}
virtual void push();
virtual void pop(unsigned n);
virtual unsigned get_scope_level() const
void push() override;
void pop(unsigned n) override;
unsigned get_scope_level() const override
{return m_solver.get_scope_level();}
virtual lbool check_sat(unsigned num_assumptions, expr * const *assumptions);
virtual void set_progress_callback(progress_callback *callback)
lbool check_sat(unsigned num_assumptions, expr * const *assumptions) override;
void set_progress_callback(progress_callback *callback) override
{m_solver.set_progress_callback(callback);}
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);}
virtual unsigned get_num_assumptions() const
unsigned get_num_assumptions() const override
{return m_solver.get_num_assumptions();}
virtual expr * get_assumption(unsigned idx) const
expr * get_assumption(unsigned idx) const override
{return m_solver.get_assumption(idx);}
virtual std::ostream &display(std::ostream &out, unsigned n, expr* const* es) const
std::ostream &display(std::ostream &out, unsigned n, expr* const* es) const override
{ return m_solver.display(out, n, es); }
/* check_sat_result interface */
virtual void collect_statistics(statistics &st) const ;
void collect_statistics(statistics &st) const override ;
virtual void reset_statistics();
virtual void get_unsat_core(ptr_vector<expr> &r);
virtual void get_model(model_ref &m) {m_solver.get_model(m);}
virtual proof *get_proof() {return m_solver.get_proof();}
virtual std::string reason_unknown() const
void get_unsat_core(ptr_vector<expr> &r) override;
void get_model(model_ref &m) override {m_solver.get_model(m);}
proof *get_proof() override {return m_solver.get_proof();}
std::string reason_unknown() const override
{return m_solver.reason_unknown();}
virtual void set_reason_unknown(char const* msg)
void set_reason_unknown(char const* msg) override
{m_solver.set_reason_unknown(msg);}
virtual void get_labels(svector<symbol> &r)
void get_labels(svector<symbol> &r) override
{m_solver.get_labels(r);}
virtual ast_manager &get_manager() const {return m;}
ast_manager &get_manager() const override {return m;}
virtual void refresh();

4
src/muz/spacer/spacer_qe_project.cpp
View file

@ -190,14 +190,14 @@ namespace qe {
class is_relevant_default : public i_expr_pred {
public:
bool operator()(expr* e) {
bool operator()(expr* e) override {
return true;
}
};
class mk_atom_default : public i_nnf_atom {
public:
virtual void operator()(expr* e, bool pol, expr_ref& result) {
void operator()(expr* e, bool pol, expr_ref& result) override {
if (pol) result = e;
else result = result.get_manager().mk_not(e);
}

14
src/muz/spacer/spacer_unsat_core_plugin.h
View file

@ -43,7 +43,7 @@ class unsat_core_plugin_lemma : public unsat_core_plugin {
public:
unsat_core_plugin_lemma(unsat_core_learner& learner) : unsat_core_plugin(learner){};
virtual void compute_partial_core(proof* step) override;
void compute_partial_core(proof* step) override;
private:
void add_lowest_split_to_core(proof* step) const;
@ -55,7 +55,7 @@ class unsat_core_plugin_farkas_lemma : public unsat_core_plugin {
public:
unsat_core_plugin_farkas_lemma(unsat_core_learner& learner, bool split_literals, bool use_constant_from_a=true) : unsat_core_plugin(learner), m_split_literals(split_literals), m_use_constant_from_a(use_constant_from_a) {};
virtual void compute_partial_core(proof* step) override;
void compute_partial_core(proof* step) override;
private:
bool m_split_literals;
@ -71,8 +71,8 @@ private:
public:
unsat_core_plugin_farkas_lemma_optimized(unsat_core_learner& learner, ast_manager& m) : unsat_core_plugin(learner), m(m) {};
virtual void compute_partial_core(proof* step) override;
virtual void finalize() override;
void compute_partial_core(proof* step) override;
void finalize() override;
protected:
vector<vector<std::pair<app*, rational> > > m_linear_combinations;
@ -88,7 +88,7 @@ private:
public:
unsat_core_plugin_farkas_lemma_bounded(unsat_core_learner& learner, ast_manager& m) : unsat_core_plugin_farkas_lemma_optimized(learner, m) {};
virtual void finalize() override;
void finalize() override;
};
class unsat_core_plugin_min_cut : public unsat_core_plugin {
@ -96,8 +96,8 @@ private:
public:
unsat_core_plugin_min_cut(unsat_core_learner& learner, ast_manager& m);
virtual void compute_partial_core(proof* step) override;
virtual void finalize() override;
void compute_partial_core(proof* step) override;
void finalize() override;
private:
ast_manager& m;

40
src/muz/spacer/spacer_virtual_solver.h
View file

@ -65,46 +65,46 @@ private:
void refresh();
public:
virtual ~virtual_solver();
virtual unsigned get_num_assumptions() const
~virtual_solver() override;
unsigned get_num_assumptions() const override
{
unsigned sz = solver_na2as::get_num_assumptions();
return m_virtual ? sz - 1 : sz;
}
virtual expr* get_assumption(unsigned idx) const
expr* get_assumption(unsigned idx) const override
{
if(m_virtual) { idx++; }
return solver_na2as::get_assumption(idx);
}
virtual void get_unsat_core(ptr_vector<expr> &r);
virtual void assert_expr(expr *e);
virtual void collect_statistics(statistics &st) const {}
virtual void get_model(model_ref &m) {m_context.get_model(m);}
virtual proof* get_proof();
virtual std::string reason_unknown() const
void get_unsat_core(ptr_vector<expr> &r) override;
void assert_expr(expr *e) override;
void collect_statistics(statistics &st) const override {}
void get_model(model_ref &m) override {m_context.get_model(m);}
proof* get_proof() override;
std::string reason_unknown() const override
{return m_context.last_failure_as_string();}
virtual void set_reason_unknown(char const *msg)
void set_reason_unknown(char const *msg) override
{m_context.set_reason_unknown(msg);}
virtual ast_manager& get_manager() const {return m;}
virtual void get_labels(svector<symbol> &r);
virtual void set_produce_models(bool f);
ast_manager& get_manager() const override {return m;}
void get_labels(svector<symbol> &r) override;
void set_produce_models(bool f) override;
virtual bool get_produce_models();
virtual smt_params &fparams();
virtual void reset();
virtual void set_progress_callback(progress_callback *callback)
void set_progress_callback(progress_callback *callback) override
{UNREACHABLE();}
virtual solver *translate(ast_manager &m, params_ref const &p);
solver *translate(ast_manager &m, params_ref const &p) 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;
protected:
virtual lbool check_sat_core(unsigned num_assumptions, expr *const * assumptions);
virtual void push_core();
virtual void pop_core(unsigned n);
lbool check_sat_core(unsigned num_assumptions, expr *const * assumptions) override;
void push_core() override;
void pop_core(unsigned n) override;
};
/// multi-solver abstraction on top of a single smt::kernel