mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-08-03 09:50:23 +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

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

@ -64,14 +64,14 @@ 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& dst_m, params_ref const& p) {
solver* translate(ast_manager& dst_m, params_ref const& p) override {
flush_assertions();
bounded_int2bv_solver* result = alloc(bounded_int2bv_solver, dst_m, p, m_solver->translate(dst_m, p));
ast_translation tr(m, dst_m);
@ -89,7 +89,7 @@ public:
return result;
}
virtual void assert_expr_core(expr * t) {
void assert_expr_core(expr * t) override {
unsigned i = m_assertions.size();
m_assertions.push_back(t);
while (i < m_assertions.size()) {
@ -105,14 +105,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);
@ -138,18 +138,18 @@ 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_core(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_core(model_ref & mdl) override {
m_solver->get_model(mdl);
if (mdl) {
model_converter_ref mc = local_model_converter();
@ -182,14 +182,14 @@ public:
mc = concat(mc.get(), m_solver->get_model_converter().get());
return mc;
}
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 expr_ref_vector cube(expr_ref_vector& vars, unsigned backtrack_level) { flush_assertions(); return m_solver->cube(vars, backtrack_level); }
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; }
expr_ref_vector cube(expr_ref_vector& vars, unsigned backtrack_level) override { flush_assertions(); return m_solver->cube(vars, backtrack_level); }
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) {
@ -207,7 +207,7 @@ public:
// translate bit-vector consequences back to integer values
for (unsigned i = 0; i < consequences.size(); ++i) {
expr* a = 0, *b = 0, *u = 0, *v = 0;
expr* a = nullptr, *b = nullptr, *u = nullptr, *v = nullptr;
func_decl* f;
rational num;
unsigned bvsize;
@ -331,12 +331,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);
}

2
src/tactic/portfolio/default_tactic.cpp
View file

@ -40,8 +40,8 @@ tactic * mk_default_tactic(ast_manager & m, params_ref const & p) {
cond(mk_is_qflra_probe(), mk_qflra_tactic(m),
cond(mk_is_qfnra_probe(), mk_qfnra_tactic(m),
cond(mk_is_qfnia_probe(), mk_qfnia_tactic(m),
cond(mk_is_nra_probe(), mk_nra_tactic(m),
cond(mk_is_lira_probe(), mk_lira_tactic(m, p),
cond(mk_is_nra_probe(), mk_nra_tactic(m),
cond(mk_is_qffp_probe(), mk_qffp_tactic(m, p),
mk_smt_tactic()))))))))))),
p);

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

@ -46,9 +46,9 @@ public:
solver::updt_params(p);
}
virtual ~enum2bv_solver() {}
~enum2bv_solver() override {}
virtual solver* translate(ast_manager& dst_m, params_ref const& p) {
solver* translate(ast_manager& dst_m, params_ref const& p) override {
solver* result = alloc(enum2bv_solver, dst_m, p, m_solver->translate(dst_m, p));
model_converter_ref mc = external_model_converter();
if (mc) {
@ -58,7 +58,7 @@ public:
return result;
}
virtual void assert_expr_core(expr * t) {
void assert_expr_core(expr * t) override {
expr_ref tmp(t, m);
expr_ref_vector bounds(m);
proof_ref tmp_proof(m);
@ -68,17 +68,17 @@ 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 {
m_solver->updt_params(get_params());
return m_solver->check_sat(num_assumptions, assumptions);
}
@ -160,7 +160,7 @@ public:
// translate bit-vector consequences back to enumeration types
for (unsigned i = 0; i < consequences.size(); ++i) {
expr* a = 0, *b = 0, *u = 0, *v = 0;
expr* a = nullptr, *b = nullptr, *u = nullptr, *v = nullptr;
func_decl* f;
rational num;
unsigned bvsize;
@ -180,11 +180,11 @@ public:
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);
}

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

@ -45,9 +45,9 @@ public:
solver::updt_params(p);
}
virtual ~pb2bv_solver() {}
~pb2bv_solver() override {}
virtual solver* translate(ast_manager& dst_m, params_ref const& p) {
solver* translate(ast_manager& dst_m, params_ref const& p) override {
flush_assertions();
solver* result = alloc(pb2bv_solver, dst_m, p, m_solver->translate(dst_m, p));
model_converter_ref mc = external_model_converter();
@ -58,59 +58,60 @@ public:
return result;
}
virtual void assert_expr_core(expr * t) {
void assert_expr_core(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_rewriter.updt_params(p); m_solver->updt_params(p); }
virtual void collect_param_descrs(param_descrs & r) { m_solver->collect_param_descrs(r); m_rewriter.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_rewriter.updt_params(p); m_solver->updt_params(p); }
void collect_param_descrs(param_descrs & r) override { m_solver->collect_param_descrs(r); m_rewriter.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_core(model_ref & mdl) {
void get_unsat_core(ptr_vector<expr> & r) override { m_solver->get_unsat_core(r); }
void get_model_core(model_ref & mdl) override {
m_solver->get_model(mdl);
if (mdl) {
model_converter_ref mc = local_model_converter();
if (mc) (*mc)(mdl);
}
}
model_converter* external_model_converter() const {
model_converter* external_model_converter() const{
return concat(mc0(), local_model_converter());
}
virtual model_converter_ref get_model_converter() const {
model_converter_ref get_model_converter() const override {
model_converter_ref mc = external_model_converter();
mc = concat(mc.get(), m_solver->get_model_converter().get());
return mc;
}
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 expr_ref_vector cube(expr_ref_vector& vars, unsigned backtrack_level) { flush_assertions(); return m_solver->cube(vars, backtrack_level); }
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; }
expr_ref_vector cube(expr_ref_vector& vars, unsigned backtrack_level) override { flush_assertions(); return m_solver->cube(vars, backtrack_level); }
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); }
@ -126,12 +127,12 @@ public:
return filter;
}
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);
}

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

@ -101,7 +101,7 @@ tactic * mk_tactic_for_logic(ast_manager & m, params_ref const & p, symbol const
static solver* mk_special_solver_for_logic(ast_manager & m, params_ref const & p, symbol const& logic) {
if ((logic == "QF_FD" || logic == "SAT") && !m.proofs_enabled())
return mk_fd_solver(m, p);
return 0;
return nullptr;
}
static solver* mk_solver_for_logic(ast_manager & m, params_ref const & p, symbol const& logic) {
@ -119,8 +119,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;