mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-24 09:35:32 +00:00
Code Activity

merge with master

Browse source 
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner 2018-03-25 14:57:01 -07:00
commit c513f3ca09
883 changed files with 13979 additions and 16480 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/solver/check_sat_result.cpp
View file

@ -57,11 +57,11 @@ void simple_check_sat_result::get_model_core(model_ref & m) {
if (m_status != l_false)
m = m_model;
else
m = 0;
m = nullptr;
}
proof * simple_check_sat_result::get_proof() {
return m_status == l_false ? m_proof.get() : 0;
return m_status == l_false ? m_proof.get() : nullptr;
}
std::string simple_check_sat_result::reason_unknown() const {

18
src/solver/check_sat_result.h
View file

@ -84,15 +84,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_core(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_core(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

65
src/solver/combined_solver.cpp
View file

@ -18,10 +18,11 @@ Author:
Notes:
--*/
#include "solver/solver.h"
#include "util/scoped_timer.h"
#include "solver/combined_solver_params.hpp"
#include "util/common_msgs.h"
#include "ast/ast_pp.h"
#include "solver/solver.h"
#include "solver/combined_solver_params.hpp"
#define PS_VB_LVL 15
/**
@ -84,12 +85,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 +103,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 +136,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 +147,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_core(expr * t) {
void assert_expr_core(expr * t) override {
if (m_check_sat_executed)
switch_inc_mode();
m_solver1->assert_expr(t);
@ -172,7 +173,7 @@ public:
m_solver2->assert_expr(t);
}
virtual void assert_expr_core2(expr * t, expr * a) {
void assert_expr_core2(expr * t, expr * a) override {
if (m_check_sat_executed)
switch_inc_mode();
m_solver1->assert_expr(t, a);
@ -180,23 +181,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 +214,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,77 +259,77 @@ 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_ref_vector cube(expr_ref_vector& vars, unsigned backtrack_level) {
expr_ref_vector cube(expr_ref_vector& vars, unsigned backtrack_level) override {
return m_solver1->cube(vars, backtrack_level);
}
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_core(model_ref & m) {
void get_model_core(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
@ -347,9 +348,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);

4
src/solver/mus.cpp
View file

@ -136,7 +136,7 @@ struct mus::imp {
// use correction sets
lbool get_mus2(expr_ref_vector& mus) {
expr* lit = 0;
expr* lit = nullptr;
lbool is_sat;
ptr_vector<expr> unknown(m_lit2expr.size(), m_lit2expr.c_ptr());
while (!unknown.empty()) {
@ -163,7 +163,7 @@ struct mus::imp {
expr_ref_vector nmcs(m);
expr_set core, min_core, nmcs_set;
bool min_core_valid = false;
expr* min_lit = 0;
expr* min_lit = nullptr;
while (!unknown.empty()) {
expr* lit = unknown.back();
unknown.pop_back();

4
src/solver/solver.cpp
View file

@ -33,7 +33,7 @@ unsigned solver::get_num_assertions() const {
expr * solver::get_assertion(unsigned idx) const {
NOT_IMPLEMENTED_YET();
return 0;
return nullptr;
}
std::ostream& solver::display(std::ostream & out, unsigned n, expr* const* assumptions) const {
@ -167,7 +167,7 @@ lbool solver::find_mutexes(expr_ref_vector const& vars, vector<expr_ref_vector>&
}
lbool solver::preferred_sat(expr_ref_vector const& asms, vector<expr_ref_vector>& cores) {
return check_sat(0, 0);
return check_sat(0, nullptr);
}
bool solver::is_literal(ast_manager& m, expr* e) {

2
src/solver/solver.h
View file

@ -48,7 +48,7 @@ class solver : public check_sat_result {
bool m_enforce_model_conversion;
public:
solver(): m_enforce_model_conversion(false) {}
virtual ~solver() {}
~solver() override {}
/**
\brief Creates a clone of the solver.

30
src/solver/solver2tactic.cpp
View file

@ -34,7 +34,7 @@ void extract_clauses_and_dependencies(goal_ref const& g, expr_ref_vector& clause
for (unsigned i = 0; i < sz; i++) {
expr * f = g->form(i);
expr_dependency * d = g->dep(i);
if (d == 0 || !g->unsat_core_enabled()) {
if (d == nullptr || !g->unsat_core_enabled()) {
clauses.push_back(f);
}
else {
@ -58,9 +58,9 @@ void extract_clauses_and_dependencies(goal_ref const& g, expr_ref_vector& clause
}
else {
// must normalize assumption
expr * b = 0;
expr * b = nullptr;
if (!dep2bool.find(d, b)) {
b = m.mk_fresh_const(0, m.mk_bool_sort());
b = m.mk_fresh_const(nullptr, m.mk_bool_sort());
dep2bool.insert(d, b);
bool2dep.insert(b, d);
assumptions.push_back(b);
@ -92,17 +92,17 @@ 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) {
void operator()(/* in */ goal_ref const & in,
/* out */ goal_ref_buffer & result) override {
expr_ref_vector clauses(m);
expr2expr_map bool2dep;
ptr_vector<expr> assumptions;
@ -127,8 +127,8 @@ public:
break;
case l_false: {
in->reset();
proof* pr = 0;
expr_dependency_ref lcore(m);
proof* pr = nullptr;
if (in->proofs_enabled()) {
pr = local_solver->get_proof();
in->set(proof2proof_converter(m, pr));
@ -164,21 +164,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));
}
};

18
src/solver/solver_na2as.h
View file

@ -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;
void assert_expr_core2(expr * t, expr * a) override;
// virtual void assert_expr_core(expr * t) = 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;

43
src/solver/solver_pool.cpp
View file

@ -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);
@ -143,7 +143,6 @@ public:
}
out << ")\n";
m_base->display(out, num_assumptions, assumptions);
bool first = true;
out << "(check-sat";
for (unsigned i = 0; i < num_assumptions; ++i) {
out << " " << mk_pp(assumptions[i], m);
@ -159,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
@ -179,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);
@ -191,7 +190,7 @@ public:
}
}
virtual void assert_expr_core(expr * e) {
void assert_expr_core(expr * e) override {
SASSERT(!m_pushed || get_scope_level() > 0);
if (m.is_true(e)) return;
if (m_in_delayed_scope) {
@ -212,20 +211,20 @@ public:
}
}
virtual void get_model_core(model_ref & _m) { m_base->get_model_core(_m); }
void get_model_core(model_ref & _m) override { m_base->get_model_core(_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 expr_ref_vector cube(expr_ref_vector& vars, unsigned ) { return expr_ref_vector(m); }
virtual ast_manager& get_manager() const { return m_base->get_manager(); }
expr_ref_vector cube(expr_ref_vector& vars, unsigned ) override { return expr_ref_vector(m); }
ast_manager& get_manager() const override { return m_base->get_manager(); }
void refresh(solver* new_base) {
SASSERT(!m_pushed);

74
src/solver/tactic2solver.cpp
View file

@ -45,43 +45,41 @@ 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_core(expr * t);
virtual void assert_lemma(expr * t);
void assert_expr_core(expr * t) override;
ast_manager& get_manager() const 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;
void collect_statistics(statistics & st) const override;
void get_unsat_core(ptr_vector<expr> & r) override;
void get_model_core(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 {}
void set_progress_callback(progress_callback * callback) override {}
unsigned get_num_assertions() const override;
expr * get_assertion(unsigned idx) const override;
virtual void collect_statistics(statistics & st) const;
virtual void get_unsat_core(ptr_vector<expr> & r);
virtual void get_model_core(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) {}
virtual void set_progress_callback(progress_callback * callback) {}
virtual unsigned get_num_assertions() const;
virtual expr * get_assertion(unsigned idx) const;
virtual ast_manager& get_manager() const;
virtual expr_ref_vector cube(expr_ref_vector& vars, unsigned ) {
expr_ref_vector cube(expr_ref_vector& vars, unsigned ) override {
return expr_ref_vector(get_manager());
}
virtual model_converter_ref get_model_converter() const { return m_mc; }
model_converter_ref get_model_converter() const override { return m_mc; }
};
@ -114,15 +112,13 @@ void tactic2solver::collect_param_descrs(param_descrs & r) {
void tactic2solver::assert_expr_core(expr * t) {
m_assertions.push_back(t);
m_result = 0;
m_result = nullptr;
}
void tactic2solver::assert_lemma(expr * t) {
}
void tactic2solver::push_core() {
m_scopes.push_back(m_assertions.size());
m_result = 0;
m_result = nullptr;
}
void tactic2solver::pop_core(unsigned n) {
@ -130,11 +126,11 @@ void tactic2solver::pop_core(unsigned n) {
unsigned old_sz = m_scopes[new_lvl];
m_assertions.shrink(old_sz);
m_scopes.shrink(new_lvl);
m_result = 0;
m_result = nullptr;
}
lbool tactic2solver::check_sat_core(unsigned num_assumptions, expr * const * assumptions) {
if (m_tactic.get() == 0)
if (m_tactic.get() == nullptr)
return l_false;
ast_manager & m = m_assertions.m();
m_result = alloc(simple_check_sat_result, m);
@ -204,7 +200,7 @@ lbool tactic2solver::check_sat_core(unsigned num_assumptions, expr * const * ass
solver* tactic2solver::translate(ast_manager& m, params_ref const& p) {
tactic* t = m_tactic->translate(m);
tactic2solver* r = alloc(tactic2solver, m, t, p, m_produce_proofs, m_produce_models, m_produce_unsat_cores, m_logic);
r->m_result = 0;
r->m_result = nullptr;
if (!m_scopes.empty()) {
throw default_exception("translation of contexts is only supported at base level");
}
@ -237,7 +233,7 @@ proof * tactic2solver::get_proof() {
if (m_result.get())
return m_result->get_proof();
else
return 0;
return nullptr;
}
std::string tactic2solver::reason_unknown() const {
@ -278,9 +274,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);
}
};
@ -291,9 +287,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);
}

2
src/solver/tactic2solver.h
View file

@ -30,7 +30,7 @@ class solver;
class solver_factory;
solver * mk_tactic2solver(ast_manager & m,
tactic * t = 0,
tactic * t = nullptr,
params_ref const & p = params_ref(),
bool produce_proofs = false,
bool produce_models = true,