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
|
|
@ -76,15 +76,15 @@ struct simple_check_sat_result : public check_sat_result {
|
|||
|
||||
|
||||
simple_check_sat_result(ast_manager & m);
|
||||
virtual ~simple_check_sat_result();
|
||||
virtual ast_manager& get_manager() const { return m_proof.get_manager(); }
|
||||
virtual void collect_statistics(statistics & st) const;
|
||||
virtual void get_unsat_core(ptr_vector<expr> & r);
|
||||
virtual void get_model(model_ref & m);
|
||||
virtual proof * get_proof();
|
||||
virtual std::string reason_unknown() const;
|
||||
virtual void get_labels(svector<symbol> & r);
|
||||
virtual void set_reason_unknown(char const* msg) { m_unknown = msg; }
|
||||
~simple_check_sat_result() override;
|
||||
ast_manager& get_manager() const override { return m_proof.get_manager(); }
|
||||
void collect_statistics(statistics & st) const override;
|
||||
void get_unsat_core(ptr_vector<expr> & r) override;
|
||||
void get_model(model_ref & m) override;
|
||||
proof * get_proof() override;
|
||||
std::string reason_unknown() const override;
|
||||
void get_labels(svector<symbol> & r) override;
|
||||
void set_reason_unknown(char const* msg) override { m_unknown = msg; }
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -84,12 +84,12 @@ private:
|
|||
solver * m_solver;
|
||||
volatile bool m_canceled;
|
||||
aux_timeout_eh(solver * s):m_solver(s), m_canceled(false) {}
|
||||
~aux_timeout_eh() {
|
||||
~aux_timeout_eh() override {
|
||||
if (m_canceled) {
|
||||
m_solver->get_manager().limit().dec_cancel();
|
||||
}
|
||||
}
|
||||
virtual void operator()(event_handler_caller_t caller_id) {
|
||||
void operator()(event_handler_caller_t caller_id) override {
|
||||
m_canceled = true;
|
||||
m_solver->get_manager().limit().inc_cancel();
|
||||
}
|
||||
|
|
@ -102,7 +102,7 @@ private:
|
|||
m_inc_unknown_behavior = static_cast<inc_unknown_behavior>(p.solver2_unknown());
|
||||
}
|
||||
|
||||
virtual ast_manager& get_manager() const { return m_solver1->get_manager(); }
|
||||
ast_manager& get_manager() const override { return m_solver1->get_manager(); }
|
||||
|
||||
bool has_quantifiers() const {
|
||||
unsigned sz = get_num_assertions();
|
||||
|
|
@ -135,7 +135,7 @@ public:
|
|||
m_use_solver1_results = true;
|
||||
}
|
||||
|
||||
solver* translate(ast_manager& m, params_ref const& p) {
|
||||
solver* translate(ast_manager& m, params_ref const& p) override {
|
||||
solver* s1 = m_solver1->translate(m, p);
|
||||
solver* s2 = m_solver2->translate(m, p);
|
||||
combined_solver* r = alloc(combined_solver, s1, s2, p);
|
||||
|
|
@ -146,25 +146,25 @@ public:
|
|||
return r;
|
||||
}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
solver::updt_params(p);
|
||||
m_solver1->updt_params(p);
|
||||
m_solver2->updt_params(p);
|
||||
updt_local_params(p);
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
m_solver1->collect_param_descrs(r);
|
||||
m_solver2->collect_param_descrs(r);
|
||||
combined_solver_params::collect_param_descrs(r);
|
||||
}
|
||||
|
||||
virtual void set_produce_models(bool f) {
|
||||
void set_produce_models(bool f) override {
|
||||
m_solver1->set_produce_models(f);
|
||||
m_solver2->set_produce_models(f);
|
||||
}
|
||||
|
||||
virtual void assert_expr(expr * t) {
|
||||
void assert_expr(expr * t) override {
|
||||
if (m_check_sat_executed)
|
||||
switch_inc_mode();
|
||||
m_solver1->assert_expr(t);
|
||||
|
|
@ -172,7 +172,7 @@ public:
|
|||
m_solver2->assert_expr(t);
|
||||
}
|
||||
|
||||
virtual void assert_expr(expr * t, expr * a) {
|
||||
void assert_expr(expr * t, expr * a) override {
|
||||
if (m_check_sat_executed)
|
||||
switch_inc_mode();
|
||||
m_solver1->assert_expr(t, a);
|
||||
|
|
@ -180,23 +180,23 @@ public:
|
|||
m_solver2->assert_expr(t, a);
|
||||
}
|
||||
|
||||
virtual void push() {
|
||||
void push() override {
|
||||
switch_inc_mode();
|
||||
m_solver1->push();
|
||||
m_solver2->push();
|
||||
}
|
||||
|
||||
virtual void pop(unsigned n) {
|
||||
void pop(unsigned n) override {
|
||||
switch_inc_mode();
|
||||
m_solver1->pop(n);
|
||||
m_solver2->pop(n);
|
||||
}
|
||||
|
||||
virtual unsigned get_scope_level() const {
|
||||
unsigned get_scope_level() const override {
|
||||
return m_solver1->get_scope_level();
|
||||
}
|
||||
|
||||
virtual lbool get_consequences(expr_ref_vector const& asms, expr_ref_vector const& vars, expr_ref_vector& consequences) {
|
||||
lbool get_consequences(expr_ref_vector const& asms, expr_ref_vector const& vars, expr_ref_vector& consequences) override {
|
||||
switch_inc_mode();
|
||||
m_use_solver1_results = false;
|
||||
try {
|
||||
|
|
@ -213,7 +213,7 @@ public:
|
|||
return l_undef;
|
||||
}
|
||||
|
||||
virtual lbool check_sat(unsigned num_assumptions, expr * const * assumptions) {
|
||||
lbool check_sat(unsigned num_assumptions, expr * const * assumptions) override {
|
||||
m_check_sat_executed = true;
|
||||
m_use_solver1_results = false;
|
||||
|
||||
|
|
@ -258,73 +258,73 @@ public:
|
|||
return m_solver1->check_sat(num_assumptions, assumptions);
|
||||
}
|
||||
|
||||
virtual void set_progress_callback(progress_callback * callback) {
|
||||
void set_progress_callback(progress_callback * callback) override {
|
||||
m_solver1->set_progress_callback(callback);
|
||||
m_solver2->set_progress_callback(callback);
|
||||
}
|
||||
|
||||
virtual unsigned get_num_assertions() const {
|
||||
unsigned get_num_assertions() const override {
|
||||
return m_solver1->get_num_assertions();
|
||||
}
|
||||
|
||||
virtual expr * get_assertion(unsigned idx) const {
|
||||
expr * get_assertion(unsigned idx) const override {
|
||||
return m_solver1->get_assertion(idx);
|
||||
}
|
||||
|
||||
virtual unsigned get_num_assumptions() const {
|
||||
unsigned get_num_assumptions() const override {
|
||||
return m_solver1->get_num_assumptions() + m_solver2->get_num_assumptions();
|
||||
}
|
||||
|
||||
virtual expr * get_assumption(unsigned idx) const {
|
||||
expr * get_assumption(unsigned idx) const override {
|
||||
unsigned c1 = m_solver1->get_num_assumptions();
|
||||
if (idx < c1) return m_solver1->get_assumption(idx);
|
||||
return m_solver2->get_assumption(idx - c1);
|
||||
}
|
||||
|
||||
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_solver1->display(out, n, es);
|
||||
}
|
||||
|
||||
virtual void collect_statistics(statistics & st) const {
|
||||
void collect_statistics(statistics & st) const override {
|
||||
m_solver2->collect_statistics(st);
|
||||
if (m_use_solver1_results)
|
||||
m_solver1->collect_statistics(st);
|
||||
}
|
||||
|
||||
virtual void get_unsat_core(ptr_vector<expr> & r) {
|
||||
void get_unsat_core(ptr_vector<expr> & r) override {
|
||||
if (m_use_solver1_results)
|
||||
m_solver1->get_unsat_core(r);
|
||||
else
|
||||
m_solver2->get_unsat_core(r);
|
||||
}
|
||||
|
||||
virtual void get_model(model_ref & m) {
|
||||
void get_model(model_ref & m) override {
|
||||
if (m_use_solver1_results)
|
||||
m_solver1->get_model(m);
|
||||
else
|
||||
m_solver2->get_model(m);
|
||||
}
|
||||
|
||||
virtual proof * get_proof() {
|
||||
proof * get_proof() override {
|
||||
if (m_use_solver1_results)
|
||||
return m_solver1->get_proof();
|
||||
else
|
||||
return m_solver2->get_proof();
|
||||
}
|
||||
|
||||
virtual std::string reason_unknown() const {
|
||||
std::string reason_unknown() const override {
|
||||
if (m_use_solver1_results)
|
||||
return m_solver1->reason_unknown();
|
||||
else
|
||||
return m_solver2->reason_unknown();
|
||||
}
|
||||
|
||||
virtual void set_reason_unknown(char const* msg) {
|
||||
void set_reason_unknown(char const* msg) override {
|
||||
m_solver1->set_reason_unknown(msg);
|
||||
m_solver2->set_reason_unknown(msg);
|
||||
}
|
||||
|
||||
virtual void get_labels(svector<symbol> & r) {
|
||||
void get_labels(svector<symbol> & r) override {
|
||||
if (m_use_solver1_results)
|
||||
return m_solver1->get_labels(r);
|
||||
else
|
||||
|
|
@ -343,9 +343,9 @@ class combined_solver_factory : public solver_factory {
|
|||
scoped_ptr<solver_factory> m_f2;
|
||||
public:
|
||||
combined_solver_factory(solver_factory * f1, solver_factory * f2):m_f1(f1), m_f2(f2) {}
|
||||
virtual ~combined_solver_factory() {}
|
||||
~combined_solver_factory() override {}
|
||||
|
||||
virtual solver * operator()(ast_manager & m, params_ref const & p, bool proofs_enabled, bool models_enabled, bool unsat_core_enabled, symbol const & logic) {
|
||||
solver * operator()(ast_manager & m, params_ref const & p, bool proofs_enabled, bool models_enabled, bool unsat_core_enabled, symbol const & logic) override {
|
||||
return mk_combined_solver((*m_f1)(m, p, proofs_enabled, models_enabled, unsat_core_enabled, logic),
|
||||
(*m_f2)(m, p, proofs_enabled, models_enabled, unsat_core_enabled, logic),
|
||||
p);
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ public:
|
|||
class solver : public check_sat_result {
|
||||
params_ref m_params;
|
||||
public:
|
||||
virtual ~solver() {}
|
||||
~solver() override {}
|
||||
|
||||
/**
|
||||
\brief Creates a clone of the solver.
|
||||
|
|
|
|||
|
|
@ -92,20 +92,20 @@ public:
|
|||
m_solver(s)
|
||||
{}
|
||||
|
||||
virtual void updt_params(params_ref const & p) {
|
||||
void updt_params(params_ref const & p) override {
|
||||
m_params.append(p);
|
||||
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 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 {
|
||||
pc = 0; mc = 0; core = 0;
|
||||
expr_ref_vector clauses(m);
|
||||
expr2expr_map bool2dep;
|
||||
|
|
@ -155,21 +155,21 @@ public:
|
|||
local_solver->collect_statistics(m_st);
|
||||
}
|
||||
|
||||
virtual void collect_statistics(statistics & st) const {
|
||||
void collect_statistics(statistics & st) const override {
|
||||
st.copy(m_st);
|
||||
}
|
||||
virtual void reset_statistics() { m_st.reset(); }
|
||||
void reset_statistics() override { m_st.reset(); }
|
||||
|
||||
virtual void cleanup() { }
|
||||
virtual void reset() { cleanup(); }
|
||||
void cleanup() override { }
|
||||
void reset() override { cleanup(); }
|
||||
|
||||
virtual void set_logic(symbol const & l) {}
|
||||
void set_logic(symbol const & l) override {}
|
||||
|
||||
virtual void set_progress_callback(progress_callback * callback) {
|
||||
void set_progress_callback(progress_callback * callback) override {
|
||||
m_solver->set_progress_callback(callback);
|
||||
}
|
||||
|
||||
virtual tactic * translate(ast_manager & m) {
|
||||
tactic * translate(ast_manager & m) override {
|
||||
return alloc(solver2tactic, m_solver->translate(m, m_params));
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -32,21 +32,21 @@ class solver_na2as : public solver {
|
|||
void restore_assumptions(unsigned old_sz);
|
||||
public:
|
||||
solver_na2as(ast_manager & m);
|
||||
virtual ~solver_na2as();
|
||||
~solver_na2as() override;
|
||||
|
||||
virtual void assert_expr(expr * t, expr * a);
|
||||
virtual void assert_expr(expr * t) = 0;
|
||||
void assert_expr(expr * t, expr * a) override;
|
||||
void assert_expr(expr * t) override = 0;
|
||||
|
||||
// Subclasses of solver_na2as should redefine the following *_core methods instead of these ones.
|
||||
virtual lbool check_sat(unsigned num_assumptions, expr * const * assumptions);
|
||||
virtual void push();
|
||||
virtual void pop(unsigned n);
|
||||
virtual unsigned get_scope_level() const;
|
||||
lbool check_sat(unsigned num_assumptions, expr * const * assumptions) override;
|
||||
void push() override;
|
||||
void pop(unsigned n) override;
|
||||
unsigned get_scope_level() const override;
|
||||
|
||||
virtual unsigned get_num_assumptions() const { return m_assumptions.size(); }
|
||||
virtual expr * get_assumption(unsigned idx) const { return m_assumptions[idx]; }
|
||||
virtual lbool get_consequences(expr_ref_vector const& asms, expr_ref_vector const& vars, expr_ref_vector& consequences);
|
||||
virtual lbool find_mutexes(expr_ref_vector const& vars, vector<expr_ref_vector>& mutexes);
|
||||
unsigned get_num_assumptions() const override { return m_assumptions.size(); }
|
||||
expr * get_assumption(unsigned idx) const override { return m_assumptions[idx]; }
|
||||
lbool get_consequences(expr_ref_vector const& asms, expr_ref_vector const& vars, expr_ref_vector& consequences) override;
|
||||
lbool find_mutexes(expr_ref_vector const& vars, vector<expr_ref_vector>& mutexes) override;
|
||||
protected:
|
||||
virtual lbool check_sat_core(unsigned num_assumptions, expr * const * assumptions) = 0;
|
||||
virtual void push_core() = 0;
|
||||
|
|
|
|||
|
|
@ -53,7 +53,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual ~pool_solver() {
|
||||
~pool_solver() override {
|
||||
if (m_pushed) pop(get_scope_level());
|
||||
if (is_virtual()) {
|
||||
m_pred = m.mk_not(m_pred);
|
||||
|
|
@ -63,12 +63,12 @@ public:
|
|||
|
||||
solver* base_solver() { return m_base.get(); }
|
||||
|
||||
virtual solver* translate(ast_manager& m, params_ref const& p) { UNREACHABLE(); return nullptr; }
|
||||
virtual void updt_params(params_ref const& p) { solver::updt_params(p); m_base->updt_params(p); }
|
||||
virtual void collect_param_descrs(param_descrs & r) { m_base->collect_param_descrs(r); }
|
||||
virtual void collect_statistics(statistics & st) const { m_base->collect_statistics(st); }
|
||||
solver* translate(ast_manager& m, params_ref const& p) override { UNREACHABLE(); return nullptr; }
|
||||
void updt_params(params_ref const& p) override { solver::updt_params(p); m_base->updt_params(p); }
|
||||
void collect_param_descrs(param_descrs & r) override { m_base->collect_param_descrs(r); }
|
||||
void collect_statistics(statistics & st) const override { m_base->collect_statistics(st); }
|
||||
|
||||
virtual void get_unsat_core(ptr_vector<expr> & r) {
|
||||
void get_unsat_core(ptr_vector<expr> & r) override {
|
||||
m_base->get_unsat_core(r);
|
||||
unsigned j = 0;
|
||||
for (unsigned i = 0; i < r.size(); ++i)
|
||||
|
|
@ -77,12 +77,12 @@ public:
|
|||
r.shrink(j);
|
||||
}
|
||||
|
||||
virtual unsigned get_num_assumptions() const {
|
||||
unsigned get_num_assumptions() const override {
|
||||
unsigned sz = solver_na2as::get_num_assumptions();
|
||||
return is_virtual() ? sz - 1 : sz;
|
||||
}
|
||||
|
||||
virtual proof * get_proof() {
|
||||
proof * get_proof() override {
|
||||
scoped_watch _t_(m_pool.m_proof_watch);
|
||||
if (!m_proof.get()) {
|
||||
elim_aux_assertions pc(m_pred);
|
||||
|
|
@ -101,7 +101,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual lbool check_sat_core(unsigned num_assumptions, expr * const * assumptions) {
|
||||
lbool check_sat_core(unsigned num_assumptions, expr * const * assumptions) override {
|
||||
SASSERT(!m_pushed || get_scope_level() > 0);
|
||||
m_proof.reset();
|
||||
scoped_watch _t_(m_pool.m_check_watch);
|
||||
|
|
@ -158,7 +158,7 @@ public:
|
|||
return res;
|
||||
}
|
||||
|
||||
virtual void push_core() {
|
||||
void push_core() override {
|
||||
SASSERT(!m_pushed || get_scope_level() > 0);
|
||||
if (m_in_delayed_scope) {
|
||||
// second push
|
||||
|
|
@ -178,7 +178,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual void pop_core(unsigned n) {
|
||||
void pop_core(unsigned n) override {
|
||||
SASSERT(!m_pushed || get_scope_level() > 0);
|
||||
if (m_pushed) {
|
||||
SASSERT(!m_in_delayed_scope);
|
||||
|
|
@ -190,7 +190,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual void assert_expr(expr * e) {
|
||||
void assert_expr(expr * e) override {
|
||||
SASSERT(!m_pushed || get_scope_level() > 0);
|
||||
if (m.is_true(e)) return;
|
||||
if (m_in_delayed_scope) {
|
||||
|
|
@ -211,18 +211,18 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
virtual void get_model(model_ref & _m) { m_base->get_model(_m); }
|
||||
void get_model(model_ref & _m) override { m_base->get_model(_m); }
|
||||
|
||||
virtual expr * get_assumption(unsigned idx) const {
|
||||
expr * get_assumption(unsigned idx) const override {
|
||||
return solver_na2as::get_assumption(idx + is_virtual());
|
||||
}
|
||||
|
||||
virtual std::string reason_unknown() const { return m_base->reason_unknown(); }
|
||||
virtual void set_reason_unknown(char const* msg) { return m_base->set_reason_unknown(msg); }
|
||||
virtual void get_labels(svector<symbol> & r) { return m_base->get_labels(r); }
|
||||
virtual void set_progress_callback(progress_callback * callback) { m_base->set_progress_callback(callback); }
|
||||
std::string reason_unknown() const override { return m_base->reason_unknown(); }
|
||||
void set_reason_unknown(char const* msg) override { return m_base->set_reason_unknown(msg); }
|
||||
void get_labels(svector<symbol> & r) override { return m_base->get_labels(r); }
|
||||
void set_progress_callback(progress_callback * callback) override { m_base->set_progress_callback(callback); }
|
||||
|
||||
virtual ast_manager& get_manager() const { return m_base->get_manager(); }
|
||||
ast_manager& get_manager() const override { return m_base->get_manager(); }
|
||||
|
||||
void refresh(solver* new_base) {
|
||||
SASSERT(!m_pushed);
|
||||
|
|
|
|||
|
|
@ -44,36 +44,36 @@ class tactic2solver : public solver_na2as {
|
|||
|
||||
public:
|
||||
tactic2solver(ast_manager & m, tactic * t, params_ref const & p, bool produce_proofs, bool produce_models, bool produce_unsat_cores, symbol const & logic);
|
||||
virtual ~tactic2solver();
|
||||
~tactic2solver() override;
|
||||
|
||||
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;
|
||||
|
||||
virtual void set_produce_models(bool f) { m_produce_models = f; }
|
||||
void set_produce_models(bool f) override { m_produce_models = f; }
|
||||
|
||||
virtual void assert_expr(expr * t);
|
||||
void assert_expr(expr * t) override;
|
||||
|
||||
virtual void push_core();
|
||||
virtual void pop_core(unsigned n);
|
||||
virtual lbool check_sat_core(unsigned num_assumptions, expr * const * assumptions);
|
||||
void push_core() override;
|
||||
void pop_core(unsigned n) override;
|
||||
lbool check_sat_core(unsigned num_assumptions, expr * const * assumptions) override;
|
||||
|
||||
|
||||
virtual void collect_statistics(statistics & st) const;
|
||||
virtual void get_unsat_core(ptr_vector<expr> & r);
|
||||
virtual void get_model(model_ref & m);
|
||||
virtual proof * get_proof();
|
||||
virtual std::string reason_unknown() const;
|
||||
virtual void set_reason_unknown(char const* msg);
|
||||
virtual void get_labels(svector<symbol> & r) {}
|
||||
void collect_statistics(statistics & st) const override;
|
||||
void get_unsat_core(ptr_vector<expr> & r) override;
|
||||
void get_model(model_ref & m) override;
|
||||
proof * get_proof() override;
|
||||
std::string reason_unknown() const override;
|
||||
void set_reason_unknown(char const* msg) override;
|
||||
void get_labels(svector<symbol> & r) override {}
|
||||
|
||||
virtual void set_progress_callback(progress_callback * callback) {}
|
||||
void set_progress_callback(progress_callback * callback) override {}
|
||||
|
||||
virtual unsigned get_num_assertions() const;
|
||||
virtual expr * get_assertion(unsigned idx) const;
|
||||
unsigned get_num_assertions() const override;
|
||||
expr * get_assertion(unsigned idx) const override;
|
||||
|
||||
virtual ast_manager& get_manager() const;
|
||||
ast_manager& get_manager() const override;
|
||||
};
|
||||
|
||||
ast_manager& tactic2solver::get_manager() const { return m_assertions.get_manager(); }
|
||||
|
|
@ -261,9 +261,9 @@ public:
|
|||
tactic2solver_factory(tactic * t):m_tactic(t) {
|
||||
}
|
||||
|
||||
virtual ~tactic2solver_factory() {}
|
||||
~tactic2solver_factory() override {}
|
||||
|
||||
virtual solver * operator()(ast_manager & m, params_ref const & p, bool proofs_enabled, bool models_enabled, bool unsat_core_enabled, symbol const & logic) {
|
||||
solver * operator()(ast_manager & m, params_ref const & p, bool proofs_enabled, bool models_enabled, bool unsat_core_enabled, symbol const & logic) override {
|
||||
return mk_tactic2solver(m, m_tactic.get(), p, proofs_enabled, models_enabled, unsat_core_enabled, logic);
|
||||
}
|
||||
};
|
||||
|
|
@ -274,9 +274,9 @@ public:
|
|||
tactic_factory2solver_factory(tactic_factory * f):m_factory(f) {
|
||||
}
|
||||
|
||||
virtual ~tactic_factory2solver_factory() {}
|
||||
~tactic_factory2solver_factory() override {}
|
||||
|
||||
virtual solver * operator()(ast_manager & m, params_ref const & p, bool proofs_enabled, bool models_enabled, bool unsat_core_enabled, symbol const & logic) {
|
||||
solver * operator()(ast_manager & m, params_ref const & p, bool proofs_enabled, bool models_enabled, bool unsat_core_enabled, symbol const & logic) override {
|
||||
tactic * t = (*m_factory)(m, p);
|
||||
return mk_tactic2solver(m, t, p, proofs_enabled, models_enabled, unsat_core_enabled, logic);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue