mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-23 00:55:31 +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/qe/nlarith_util.cpp
View file

@ -1018,13 +1018,13 @@ namespace nlarith {
app* m_x;
public:
basic_subst(imp& i, app* x) : isubst(i), m_x(x) {}
virtual void mk_lt(poly const& p, app_ref& r) {
void mk_lt(poly const& p, app_ref& r) override {
imp& I = m_imp;
app_ref result(I.m());
I.mk_polynomial(m_x, p, result);
r = I.mk_lt(result);
}
virtual void mk_eq(poly const& p, app_ref& r) {
void mk_eq(poly const& p, app_ref& r) override {
imp& I = m_imp;
app_ref result(I.m());
I.mk_polynomial(m_x, p, result);
@ -1039,7 +1039,7 @@ namespace nlarith {
// p[e/x] < 0: (a*parity(d) < 0 /\ 0 < a*a - b*b*c) \/
// (b*parity(d) <= 0 /\ (a*parity(d) < 0 \/ a*a - b*b*c < 0))
virtual void mk_lt(poly const& p, app_ref& r) {
void mk_lt(poly const& p, app_ref& r) override {
imp& I = m_imp;
ast_manager& m = I.m();
app_ref a(m), b(m), c(m_s.m_c), d(m);
@ -1061,7 +1061,7 @@ namespace nlarith {
// p[e/x] = 0: a*b <= 0 & a*a - b*b*c = 0
virtual void mk_eq(poly const& p, app_ref& r) {
void mk_eq(poly const& p, app_ref& r) override {
imp& I = m_imp;
ast_manager& m = I.m();
app_ref a(m), b(m), c(m_s.m_c),d(m), aabbc(m);
@ -1076,7 +1076,7 @@ namespace nlarith {
}
// p[e/x] <= 0: a*parity(d) <= 0 /\ 0 <= a*a - b*b*c \/ b*parity(d) <= 0 /\ a*a - b*b*c <= 0
virtual void mk_le(poly const& p, app_ref& r) {
void mk_le(poly const& p, app_ref& r) override {
imp& I = m_imp;
ast_manager& m = I.m();
app_ref a(m), b(m), c(m_s.m_c), d(m);
@ -1125,10 +1125,10 @@ namespace nlarith {
public:
plus_eps_subst(imp& i, isubst& s) : isubst(i), m_s(s) {}
virtual void mk_lt(poly const& p, app_ref& r) { mk_nu(p, r); }
void mk_lt(poly const& p, app_ref& r) override { mk_nu(p, r); }
// /\ p[i] = 0
virtual void mk_eq(poly const& p, app_ref& r) { r = m_imp.mk_zero(p); }
void mk_eq(poly const& p, app_ref& r) override { r = m_imp.mk_zero(p); }
};
class minus_eps_subst : public isubst {
@ -1172,10 +1172,10 @@ namespace nlarith {
public:
minus_eps_subst(imp& i, isubst& s) : isubst(i), m_s(s) {}
virtual void mk_lt(poly const& p, app_ref& r) { mk_nu(p, true, r); }
void mk_lt(poly const& p, app_ref& r) override { mk_nu(p, true, r); }
// /\ p[i] = 0
virtual void mk_eq(poly const& p, app_ref& r) { r = m_imp.mk_zero(p); }
void mk_eq(poly const& p, app_ref& r) override { r = m_imp.mk_zero(p); }
};
class minus_inf_subst : public isubst {
@ -1208,12 +1208,12 @@ namespace nlarith {
public:
minus_inf_subst(imp& i) : isubst(i) {}
virtual void mk_lt(poly const& p, app_ref& r) {
void mk_lt(poly const& p, app_ref& r) override {
r = mk_lt(p, p.size());
}
// /\ p[i] = 0
virtual void mk_eq(poly const& p, app_ref& r) { r = m_imp.mk_zero(p); }
void mk_eq(poly const& p, app_ref& r) override { r = m_imp.mk_zero(p); }
};
@ -1238,10 +1238,10 @@ namespace nlarith {
public:
plus_inf_subst(imp& i) : isubst(i) {}
virtual void mk_lt(poly const& p, app_ref& r) { r = mk_lt(p, p.size()); }
void mk_lt(poly const& p, app_ref& r) override { r = mk_lt(p, p.size()); }
// /\ p[i] = 0
virtual void mk_eq(poly const& p, app_ref& r) { r = m_imp.mk_zero(p); }
void mk_eq(poly const& p, app_ref& r) override { r = m_imp.mk_zero(p); }
};
/**
@ -1615,9 +1615,9 @@ namespace nlarith {
public:
simple_branch(ast_manager& m, app* cnstr):
m_cnstr(cnstr, m), m_atoms(m) {}
virtual ~simple_branch() {}
virtual app* get_constraint() { return m_cnstr.get(); }
virtual void get_updates(ptr_vector<app>& atoms, svector<util::atom_update>& updates) {
~simple_branch() override {}
app* get_constraint() override { return m_cnstr.get(); }
void get_updates(ptr_vector<app>& atoms, svector<util::atom_update>& updates) override {
for (unsigned i = 0; i < m_atoms.size(); ++i) {
atoms.push_back(m_atoms[i].get());
updates.push_back(m_updates[i]);
@ -1635,7 +1635,7 @@ namespace nlarith {
public:
ins_rem_branch(ast_manager& m, app* a, app* r, app* cnstr):
simple_branch(m, cnstr) { insert(a); remove(r); }
virtual ~ins_rem_branch() {}
~ins_rem_branch() override {}
};
/**

22
src/qe/nlqsat.cpp
View file

@ -555,7 +555,7 @@ namespace qe {
}
void reset() {
void reset() override {
//m_solver.reset();
m_asms.reset();
m_cached_asms.reset();
@ -798,16 +798,16 @@ namespace qe {
m_nftactic = mk_tseitin_cnf_tactic(m);
}
virtual ~nlqsat() {
~nlqsat() override {
}
void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
params_ref p2(p);
p2.set_bool("factor", false);
m_solver.updt_params(p2);
}
void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
}
@ -815,7 +815,7 @@ namespace qe {
/* out */ goal_ref_buffer & result,
/* out */ model_converter_ref & mc,
/* out */ proof_converter_ref & pc,
/* out */ expr_dependency_ref & core) {
/* out */ expr_dependency_ref & core) override {
tactic_report report("nlqsat-tactic", *in);
@ -863,27 +863,27 @@ namespace qe {
}
void collect_statistics(statistics & st) const {
void collect_statistics(statistics & st) const override {
st.copy(m_st);
st.update("qsat num rounds", m_stats.m_num_rounds);
}
void reset_statistics() {
void reset_statistics() override {
m_stats.reset();
m_solver.reset_statistics();
}
void cleanup() {
void cleanup() override {
reset();
}
void set_logic(symbol const & l) {
void set_logic(symbol const & l) override {
}
void set_progress_callback(progress_callback * callback) {
void set_progress_callback(progress_callback * callback) override {
}
tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(nlqsat, m, m_mode, m_params);
}
};

42
src/qe/qe.cpp
View file

@ -1383,7 +1383,7 @@ namespace qe {
m_rewriter.updt_params(params);
}
virtual ~quant_elim_plugin() {
~quant_elim_plugin() override {
reset();
}
@ -2035,7 +2035,7 @@ namespace qe {
{
}
virtual ~quant_elim_new() {
~quant_elim_new() override {
reset();
}
@ -2052,17 +2052,17 @@ namespace qe {
}
void collect_statistics(statistics & st) const {
void collect_statistics(statistics & st) const override {
for (unsigned i = 0; i < m_plugins.size(); ++i) {
m_plugins[i]->collect_statistics(st);
}
}
void updt_params(params_ref const& p) {
void updt_params(params_ref const& p) override {
m_eliminate_variables_as_block = p.get_bool("eliminate_variables_as_block", m_eliminate_variables_as_block);
}
void eliminate(bool is_forall, unsigned num_vars, app* const* vars, expr_ref& fml) {
void eliminate(bool is_forall, unsigned num_vars, app* const* vars, expr_ref& fml) override {
if (is_forall) {
eliminate_forall_bind(num_vars, vars, fml);
}
@ -2092,14 +2092,14 @@ namespace qe {
}
}
virtual void set_assumption(expr* fml) {
void set_assumption(expr* fml) override {
m_assumption = fml;
}
virtual lbool eliminate_exists(
lbool eliminate_exists(
unsigned num_vars, app* const* vars, expr_ref& fml,
app_ref_vector& free_vars, bool get_first, guarded_defs* defs) {
app_ref_vector& free_vars, bool get_first, guarded_defs* defs) override {
if (get_first) {
return eliminate_block(num_vars, vars, fml, free_vars, get_first, defs);
}
@ -2483,7 +2483,7 @@ namespace qe {
m_fparams.updt_params(p);
}
virtual ~simplify_solver_context() { reset(); }
~simplify_solver_context() override { reset(); }
void solve(expr_ref& fml, app_ref_vector& vars) {
@ -2502,16 +2502,16 @@ namespace qe {
while (solved);
}
virtual ast_manager& get_manager() { return m; }
ast_manager& get_manager() override { return m; }
virtual atom_set const& pos_atoms() const { return m_pos; }
virtual atom_set const& neg_atoms() const { return m_neg; }
atom_set const& pos_atoms() const override { return m_pos; }
atom_set const& neg_atoms() const override { return m_neg; }
// Access current set of variables to solve
virtual unsigned get_num_vars() const { return m_vars->size(); }
virtual app* get_var(unsigned idx) const { return (*m_vars)[idx].get(); }
virtual app_ref_vector const& get_vars() const { return *m_vars; }
virtual bool is_var(expr* e, unsigned& idx) const {
unsigned get_num_vars() const override { return m_vars->size(); }
app* get_var(unsigned idx) const override { return (*m_vars)[idx].get(); }
app_ref_vector const& get_vars() const override { return *m_vars; }
bool is_var(expr* e, unsigned& idx) const override {
for (unsigned i = 0; i < m_vars->size(); ++i) {
if ((*m_vars)[i].get() == e) {
idx = i;
@ -2521,12 +2521,12 @@ namespace qe {
return false;
}
virtual contains_app& contains(unsigned idx) {
contains_app& contains(unsigned idx) override {
return *m_contains[idx];
}
// callback to replace variable at index 'idx' with definition 'def' and updated formula 'fml'
virtual void elim_var(unsigned idx, expr* fml, expr* def) {
void elim_var(unsigned idx, expr* fml, expr* def) override {
TRACE("qe", tout << mk_pp(m_vars->get(idx), m) << " " << mk_pp(fml, m) << "\n";);
*m_fml = fml;
m_vars->set(idx, m_vars->get(m_vars->size()-1));
@ -2537,17 +2537,17 @@ namespace qe {
}
// callback to add new variable to branch.
virtual void add_var(app* x) {
void add_var(app* x) override {
TRACE("qe", tout << "add var: " << mk_pp(x, m) << "\n";);
m_vars->push_back(x);
}
// callback to add constraints in branch.
virtual void add_constraint(bool use_var, expr* l1 = 0, expr* l2 = 0, expr* l3 = 0) {
void add_constraint(bool use_var, expr* l1 = 0, expr* l2 = 0, expr* l3 = 0) override {
UNREACHABLE();
}
// eliminate finite domain variable 'var' from fml.
virtual void blast_or(app* var, expr_ref& fml) {
void blast_or(app* var, expr_ref& fml) override {
UNREACHABLE();
}

4
src/qe/qe.h
View file

@ -49,13 +49,13 @@ namespace qe {
i_solver_context& m_s;
public:
is_relevant(i_solver_context& s):m_s(s) {}
virtual bool operator()(expr* e);
bool operator()(expr* e) override;
};
class mk_atom_fn : public i_nnf_atom {
i_solver_context& m_s;
public:
mk_atom_fn(i_solver_context& s) : m_s(s) {}
void operator()(expr* e, bool p, expr_ref& result);
void operator()(expr* e, bool p, expr_ref& result) override;
};
is_relevant m_is_relevant;

10
src/qe/qe_arith.h
View file

@ -25,11 +25,11 @@ namespace qe {
imp* m_imp;
public:
arith_project_plugin(ast_manager& m);
virtual ~arith_project_plugin();
virtual bool operator()(model& model, app* var, app_ref_vector& vars, expr_ref_vector& lits);
virtual bool solve(model& model, app_ref_vector& vars, expr_ref_vector& lits);
virtual family_id get_family_id();
virtual void operator()(model& model, app_ref_vector& vars, expr_ref_vector& lits);
~arith_project_plugin() override;
bool operator()(model& model, app* var, app_ref_vector& vars, expr_ref_vector& lits) override;
bool solve(model& model, app_ref_vector& vars, expr_ref_vector& lits) override;
family_id get_family_id() override;
void operator()(model& model, app_ref_vector& vars, expr_ref_vector& lits) override;
opt::inf_eps maximize(expr_ref_vector const& fmls, model& mdl, app* t, expr_ref& ge, expr_ref& gt);

38
src/qe/qe_arith_plugin.cpp
View file

@ -1536,14 +1536,14 @@ public:
m_trail(m)
{}
~arith_plugin() {
~arith_plugin() override {
bounds_cache::iterator it = m_bounds_cache.begin(), end = m_bounds_cache.end();
for (; it != end; ++it) {
dealloc(it->get_value());
}
}
virtual void assign(contains_app& contains_x, expr* fml, rational const& vl) {
void assign(contains_app& contains_x, expr* fml, rational const& vl) override {
SASSERT(vl.is_unsigned());
app* x = contains_x.x();
unsigned v = vl.get_unsigned();
@ -1633,7 +1633,7 @@ public:
}
virtual bool get_num_branches(contains_app& contains_x, expr* fml, rational& nb) {
bool get_num_branches(contains_app& contains_x, expr* fml, rational& nb) override {
app* x = contains_x.x();
if (!update_bounds(contains_x, fml)) {
return false;
@ -1645,7 +1645,7 @@ public:
return true;
}
virtual void subst(contains_app& contains_x, rational const& vl, expr_ref& fml, expr_ref* def) {
void subst(contains_app& contains_x, rational const& vl, expr_ref& fml, expr_ref* def) override {
SASSERT(vl.is_unsigned());
if (def) {
get_def(contains_x, vl.get_unsigned(), fml, *def);
@ -1654,7 +1654,7 @@ public:
TRACE("qe", tout << mk_pp(contains_x.x(), m) << " " << vl << "\n" << mk_pp(fml, m) << "\n";);
}
virtual bool project(contains_app& x, model_ref& model, expr_ref& fml) {
bool project(contains_app& x, model_ref& model, expr_ref& fml) override {
if (!update_bounds(x, fml)) {
TRACE("qe", tout << mk_pp(x.x(), m) << " failed to update bounds\n";);
return false;
@ -1668,19 +1668,19 @@ public:
}
virtual unsigned get_weight(contains_app& contains_x, expr* fml) {
unsigned get_weight(contains_app& contains_x, expr* fml) override {
return 2;
}
virtual bool solve(conj_enum& conjs, expr* fml) {
bool solve(conj_enum& conjs, expr* fml) override {
return m_util.solve(conjs, fml);
}
virtual bool mk_atom(expr* e, bool p, expr_ref& result) {
bool mk_atom(expr* e, bool p, expr_ref& result) override {
return m_util.mk_atom(e, p, result);
}
virtual bool is_uninterpreted(app* f) {
bool is_uninterpreted(app* f) override {
switch(f->get_decl_kind()) {
case OP_NUM:
case OP_LE:
@ -2456,7 +2456,7 @@ public:
m_util.set_enable_linear(true); // (produce_models);
}
virtual ~nlarith_plugin() {
~nlarith_plugin() override {
bcs_t::iterator it = m_cache.begin(), end = m_cache.end();
for (; it != end; ++it) {
dealloc(it->get_value());
@ -2467,7 +2467,7 @@ public:
}
}
virtual bool simplify(expr_ref& fml) {
bool simplify(expr_ref& fml) override {
expr_ref tmp(m), tmp2(m);
m_factor_rw(fml, tmp);
m_rewriter(tmp, tmp2);
@ -2478,7 +2478,7 @@ public:
return false;
}
virtual void assign(contains_app& x, expr* fml, rational const& vl) {
void assign(contains_app& x, expr* fml, rational const& vl) override {
nlarith::branch_conditions *brs = 0;
VERIFY (m_cache.find(x.x(), fml, brs));
SASSERT(vl.is_unsigned());
@ -2491,8 +2491,8 @@ public:
m_ctx.add_constraint(true, result);
}
virtual bool get_num_branches(contains_app& x,
expr* fml, rational& num_branches) {
bool get_num_branches(contains_app& x,
expr* fml, rational& num_branches) override {
nlarith::branch_conditions *brs;
if (m_cache.find(x.x(), fml, brs)) {
num_branches = rational(brs->size());
@ -2515,7 +2515,7 @@ public:
return true;
}
virtual void subst(contains_app& x, rational const& vl, expr_ref& fml, expr_ref* def) {
void subst(contains_app& x, rational const& vl, expr_ref& fml, expr_ref* def) override {
nlarith::branch_conditions *brs = 0;
VERIFY (m_cache.find(x.x(), fml, brs));
SASSERT(vl.is_unsigned());
@ -2534,7 +2534,7 @@ public:
}
virtual unsigned get_weight(contains_app& x, expr* fml) {
unsigned get_weight(contains_app& x, expr* fml) override {
obj_map<app, unsigned>* weights = 0;
unsigned weight = 0;
if (!m_weights.find(fml, weights)) {
@ -2553,12 +2553,12 @@ public:
return UINT_MAX;
}
virtual bool solve(conj_enum& conjs, expr* fml) { return false; }
bool solve(conj_enum& conjs, expr* fml) override { return false; }
// we don't need to modify the atom.
virtual bool mk_atom(expr* e, bool p, expr_ref& result) { return false; }
bool mk_atom(expr* e, bool p, expr_ref& result) override { return false; }
virtual bool is_uninterpreted(app* f) {
bool is_uninterpreted(app* f) override {
if (m_produce_models) {
return true;
}

12
src/qe/qe_array_plugin.cpp
View file

@ -27,23 +27,23 @@ namespace qe {
{
}
virtual ~array_plugin() {}
~array_plugin() override {}
virtual void assign(contains_app& x, expr* fml, rational const& vl) {
void assign(contains_app& x, expr* fml, rational const& vl) override {
UNREACHABLE();
}
virtual bool get_num_branches( contains_app& x, expr* fml, rational& num_branches) {
bool get_num_branches( contains_app& x, expr* fml, rational& num_branches) override {
return false;
}
virtual void subst(contains_app& x, rational const& vl, expr_ref& fml, expr_ref* def) {
void subst(contains_app& x, rational const& vl, expr_ref& fml, expr_ref* def) override {
UNREACHABLE();
}
virtual bool solve(conj_enum& conjs, expr* fml) {
bool solve(conj_enum& conjs, expr* fml) override {
conj_enum::iterator it = conjs.begin(), end = conjs.end();
for (; it != end; ++it) {
@ -65,7 +65,7 @@ namespace qe {
return false;
}
virtual bool is_uninterpreted(app* f) {
bool is_uninterpreted(app* f) override {
return true;
}

8
src/qe/qe_arrays.h
View file

@ -31,10 +31,10 @@ namespace qe {
imp* m_imp;
public:
array_project_plugin(ast_manager& m);
virtual ~array_project_plugin();
virtual bool operator()(model& model, app* var, app_ref_vector& vars, expr_ref_vector& lits);
virtual bool solve(model& model, app_ref_vector& vars, expr_ref_vector& lits);
virtual family_id get_family_id();
~array_project_plugin() override;
bool operator()(model& model, app* var, app_ref_vector& vars, expr_ref_vector& lits) override;
bool solve(model& model, app_ref_vector& vars, expr_ref_vector& lits) override;
family_id get_family_id() override;
};
};

14
src/qe/qe_bool_plugin.cpp
View file

@ -39,16 +39,16 @@ namespace qe {
m_replace(m)
{}
virtual void assign(contains_app& x, expr* fml, rational const& vl) {
void assign(contains_app& x, expr* fml, rational const& vl) override {
SASSERT(vl.is_zero() || vl.is_one());
}
virtual bool get_num_branches(contains_app& x, expr* fml, rational& nb) {
bool get_num_branches(contains_app& x, expr* fml, rational& nb) override {
nb = rational(2);
return true;
}
virtual void subst(contains_app& x, rational const& vl, expr_ref& fml, expr_ref* def) {
void subst(contains_app& x, rational const& vl, expr_ref& fml, expr_ref* def) override {
SASSERT(vl.is_one() || vl.is_zero());
expr* tf = (vl.is_one())?m.mk_true():m.mk_false();
m_replace.apply_substitution(x.x(), tf, fml);
@ -57,7 +57,7 @@ namespace qe {
}
}
virtual bool project(contains_app& x, model_ref& model, expr_ref& fml) {
bool project(contains_app& x, model_ref& model, expr_ref& fml) override {
model_evaluator model_eval(*model);
expr_ref val_x(m);
rational val;
@ -69,7 +69,7 @@ namespace qe {
return true;
}
virtual unsigned get_weight(contains_app& contains_x, expr* fml) {
unsigned get_weight(contains_app& contains_x, expr* fml) override {
app* x = contains_x.x();
bool p = m_ctx.pos_atoms().contains(x);
bool n = m_ctx.neg_atoms().contains(x);
@ -79,13 +79,13 @@ namespace qe {
return 0;
}
virtual bool solve(conj_enum& conjs,expr* fml) {
bool solve(conj_enum& conjs,expr* fml) override {
return
solve_units(conjs, fml) ||
solve_polarized(fml);
}
virtual bool is_uninterpreted(app* a) {
bool is_uninterpreted(app* a) override {
return false;
}

14
src/qe/qe_bv_plugin.cpp
View file

@ -37,16 +37,16 @@ namespace qe {
m_bv(m)
{}
virtual void assign(contains_app& x, expr* fml, rational const& vl) {
void assign(contains_app& x, expr* fml, rational const& vl) override {
}
virtual bool get_num_branches(contains_app& x, expr* fml, rational& nb) {
bool get_num_branches(contains_app& x, expr* fml, rational& nb) override {
unsigned sz = m_bv.get_bv_size(x.x());
nb = power(rational(2), sz);
return true;
}
virtual void subst(contains_app& x, rational const& vl, expr_ref& fml, expr_ref* def) {
void subst(contains_app& x, rational const& vl, expr_ref& fml, expr_ref* def) override {
app_ref c(m_bv.mk_numeral(vl, m_bv.get_bv_size(x.x())), m);
m_replace.apply_substitution(x.x(), c, fml);
if (def) {
@ -54,7 +54,7 @@ namespace qe {
}
}
virtual bool project(contains_app& x, model_ref& model, expr_ref& fml) {
bool project(contains_app& x, model_ref& model, expr_ref& fml) override {
model_evaluator model_eval(*model);
expr_ref val_x(m);
rational val(0);
@ -65,13 +65,13 @@ namespace qe {
return true;
}
virtual unsigned get_weight(contains_app& contains_x, expr* fml) {
unsigned get_weight(contains_app& contains_x, expr* fml) override {
return 2;
}
bool solve(conj_enum& conjs, expr* fml) { return false; }
bool solve(conj_enum& conjs, expr* fml) override { return false; }
virtual bool is_uninterpreted(app* f) {
bool is_uninterpreted(app* f) override {
switch(f->get_decl_kind()) {
case OP_BSDIV0:
case OP_BUDIV0:

16
src/qe/qe_cmd.cpp
View file

@ -14,36 +14,36 @@ class qe_cmd : public parametric_cmd {
public:
qe_cmd(char const* name = "elim-quantifiers"):parametric_cmd(name) {}
virtual char const * get_usage() const { return "<term> (<keyword> <value>)*"; }
char const * get_usage() const override { return "<term> (<keyword> <value>)*"; }
virtual char const * get_main_descr() const {
char const * get_main_descr() const override {
return "apply quantifier elimination to the supplied expression";
}
virtual void init_pdescrs(cmd_context & ctx, param_descrs & p) {
void init_pdescrs(cmd_context & ctx, param_descrs & p) override {
insert_timeout(p);
p.insert("print", CPK_BOOL, "(default: true) print the simplified term.");
p.insert("print_statistics", CPK_BOOL, "(default: false) print statistics.");
}
virtual ~qe_cmd() {
~qe_cmd() override {
}
virtual void prepare(cmd_context & ctx) {
void prepare(cmd_context & ctx) override {
parametric_cmd::prepare(ctx);
m_target = 0;
}
virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const {
cmd_arg_kind next_arg_kind(cmd_context & ctx) const override {
if (m_target == 0) return CPK_EXPR;
return parametric_cmd::next_arg_kind(ctx);
}
virtual void set_next_arg(cmd_context & ctx, expr * arg) {
void set_next_arg(cmd_context & ctx, expr * arg) override {
m_target = arg;
}
virtual void execute(cmd_context & ctx) {
void execute(cmd_context & ctx) override {
proof_ref pr(ctx.m());
qe::simplify_rewriter_star qe(ctx.m());
expr_ref result(ctx.m());

18
src/qe/qe_datatype_plugin.cpp
View file

@ -435,7 +435,7 @@ namespace qe {
{
}
virtual ~datatype_plugin() {
~datatype_plugin() override {
{
eqs_cache::iterator it = m_eqs_cache.begin(), end = m_eqs_cache.end();
for (; it != end; ++it) {
@ -451,7 +451,7 @@ namespace qe {
}
virtual bool get_num_branches( contains_app& x, expr* fml, rational& num_branches) {
bool get_num_branches( contains_app& x, expr* fml, rational& num_branches) override {
sort* s = x.x()->get_decl()->get_range();
SASSERT(m_datatype_util.is_datatype(s));
if (m_datatype_util.is_recursive(s)) {
@ -463,7 +463,7 @@ namespace qe {
}
virtual void assign(contains_app& x, expr* fml, rational const& vl) {
void assign(contains_app& x, expr* fml, rational const& vl) override {
sort* s = x.x()->get_decl()->get_range();
SASSERT(m_datatype_util.is_datatype(s));
TRACE("qe", tout << mk_pp(x.x(), m) << " " << vl << "\n";);
@ -475,7 +475,7 @@ namespace qe {
}
}
virtual void subst(contains_app& x, rational const& vl, expr_ref& fml, expr_ref* def) {
void subst(contains_app& x, rational const& vl, expr_ref& fml, expr_ref* def) override {
sort* s = x.x()->get_decl()->get_range();
SASSERT(m_datatype_util.is_datatype(s));
TRACE("qe", tout << mk_pp(x.x(), m) << " " << vl << "\n";);
@ -487,20 +487,20 @@ namespace qe {
}
}
virtual unsigned get_weight( contains_app& x, expr* fml) {
unsigned get_weight( contains_app& x, expr* fml) override {
return UINT_MAX;
}
virtual bool solve( conj_enum& conj, expr* fml) {
bool solve( conj_enum& conj, expr* fml) override {
return false;
}
virtual bool simplify( expr_ref& fml) {
bool simplify( expr_ref& fml) override {
lift_foreign_vars lift(m, m_datatype_util, m_ctx);
return lift.lift(fml);
}
virtual bool mk_atom(expr* e, bool p, expr_ref& result) {
bool mk_atom(expr* e, bool p, expr_ref& result) override {
return false;
}
@ -807,7 +807,7 @@ namespace qe {
public:
has_select(app* x, func_decl* c, datatype_util& u): m_x(x), m_c(c), m_util(u) {}
virtual bool operator()(expr* e) {
bool operator()(expr* e) override {
if (!is_app(e)) return false;
app* a = to_app(e);
if (!m_util.is_accessor(a)) return false;

8
src/qe/qe_datatypes.h
View file

@ -31,10 +31,10 @@ namespace qe {
imp* m_imp;
public:
datatype_project_plugin(ast_manager& m);
virtual ~datatype_project_plugin();
virtual bool operator()(model& model, app* var, app_ref_vector& vars, expr_ref_vector& lits);
virtual bool solve(model& model, app_ref_vector& vars, expr_ref_vector& lits);
virtual family_id get_family_id();
~datatype_project_plugin() override;
bool operator()(model& model, app* var, app_ref_vector& vars, expr_ref_vector& lits) override;
bool solve(model& model, app_ref_vector& vars, expr_ref_vector& lits) override;
family_id get_family_id() override;
};
};

10
src/qe/qe_dl_plugin.cpp
View file

@ -56,7 +56,7 @@ namespace qe {
{
}
virtual ~dl_plugin() {
~dl_plugin() override {
eqs_cache::iterator it = m_eqs_cache.begin(), end = m_eqs_cache.end();
for (; it != end; ++it) {
dealloc(it->get_value());
@ -65,7 +65,7 @@ namespace qe {
bool get_num_branches(contains_app & x,expr * fml,rational & num_branches) {
bool get_num_branches(contains_app & x,expr * fml,rational & num_branches) override {
if (!update_eqs(x, fml)) {
return false;
}
@ -80,7 +80,7 @@ namespace qe {
return true;
}
void assign(contains_app & x,expr * fml,const rational & v) {
void assign(contains_app & x,expr * fml,const rational & v) override {
SASSERT(v.is_unsigned());
eq_atoms& eqs = get_eqs(x.x(), fml);
unsigned uv = v.get_unsigned();
@ -94,7 +94,7 @@ namespace qe {
}
}
void subst(contains_app & x,const rational & v,expr_ref & fml, expr_ref* def) {
void subst(contains_app & x,const rational & v,expr_ref & fml, expr_ref* def) override {
SASSERT(v.is_unsigned());
eq_atoms& eqs = get_eqs(x.x(), fml);
unsigned uv = v.get_unsigned();
@ -111,7 +111,7 @@ namespace qe {
}
}
virtual bool solve(conj_enum& conjs, expr* fml) { return false; }
bool solve(conj_enum& conjs, expr* fml) override { return false; }
private:

18
src/qe/qe_lite.cpp
View file

@ -2607,43 +2607,43 @@ public:
m_imp = alloc(imp, m, p);
}
virtual ~qe_lite_tactic() {
~qe_lite_tactic() override {
dealloc(m_imp);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(qe_lite_tactic, m, m_params);
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_params = p;
// m_imp->updt_params(p);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
// m_imp->collect_param_descrs(r);
}
virtual void operator()(goal_ref const & in,
void operator()(goal_ref const & in,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) {
expr_dependency_ref & core) override {
(*m_imp)(in, result, mc, pc, core);
}
virtual void collect_statistics(statistics & st) const {
void collect_statistics(statistics & st) const override {
// m_imp->collect_statistics(st);
}
virtual void reset_statistics() {
void reset_statistics() override {
// m_imp->reset_statistics();
}
virtual void cleanup() {
void cleanup() override {
ast_manager & m = m_imp->m;
dealloc(m_imp);
m_imp = alloc(imp, m, m_params);

57
src/qe/qe_sat_tactic.cpp
View file

@ -39,14 +39,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);
}
@ -97,7 +97,7 @@ namespace qe {
m_fml(m),
m_projection_mode_param(true) {}
virtual ~solver_context() {
~solver_context() override {
std::for_each(m_contains_app.begin(), m_contains_app.end(), delete_proc<contains_app>());
}
@ -111,28 +111,28 @@ namespace qe {
void set_projection_mode(bool p) { m_projection_mode_param = p; }
ast_manager& get_manager() { return m; }
ast_manager& get_manager() override { return m; }
expr* fml() { return m_fml; }
// set of atoms in current formula.
virtual atom_set const& pos_atoms() const { return m_pos; }
virtual atom_set const& neg_atoms() const { return m_neg; }
atom_set const& pos_atoms() const override { return m_pos; }
atom_set const& neg_atoms() const override { return m_neg; }
// Access current set of variables to solve
virtual unsigned get_num_vars() const { return m_vars.size(); }
virtual app* get_var(unsigned idx) const { return m_vars[idx]; }
virtual app_ref_vector const& get_vars() const { return m_vars; }
virtual bool is_var(expr* e, unsigned& idx) const {
unsigned get_num_vars() const override { return m_vars.size(); }
app* get_var(unsigned idx) const override { return m_vars[idx]; }
app_ref_vector const& get_vars() const override { return m_vars; }
bool is_var(expr* e, unsigned& idx) const override {
for (unsigned i = 0; i < m_vars.size(); ++i) {
if (e == m_vars[i]) return (idx = i, true);
}
return false;
}
virtual contains_app& contains(unsigned idx) { return *m_contains_app[idx]; }
contains_app& contains(unsigned idx) override { return *m_contains_app[idx]; }
// callback to replace variable at index 'idx' with definition 'def' and updated formula 'fml'
virtual void elim_var(unsigned idx, expr* fml, expr* def) {
void elim_var(unsigned idx, expr* fml, expr* def) override {
m_fml = fml;
m_pos.reset();
m_neg.reset();
@ -143,13 +143,13 @@ namespace qe {
}
// callback to add new variable to branch.
virtual void add_var(app* x) {
void add_var(app* x) override {
m_vars.push_back(x);
m_contains_app.push_back(alloc(contains_app, m, x));
}
// callback to add constraints in branch.
virtual void add_constraint(bool use_var, expr* l1 = 0, expr* l2 = 0, expr* l3 = 0) {
void add_constraint(bool use_var, expr* l1 = 0, expr* l2 = 0, expr* l3 = 0) override {
ptr_buffer<expr> args;
if (l1) args.push_back(l1);
if (l2) args.push_back(l2);
@ -160,7 +160,7 @@ namespace qe {
}
// eliminate finite domain variable 'var' from fml.
virtual void blast_or(app* var, expr_ref& fml) {
void blast_or(app* var, expr_ref& fml) override {
expr_ref result(m);
expr_quant_elim qelim(m, m_super.m_fparams);
qe::mk_exists(1, &var, fml);
@ -223,20 +223,19 @@ namespace qe {
m_fparams.m_model = true;
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(sat_tactic, m);
}
virtual ~sat_tactic() {
~sat_tactic() override {
reset();
}
virtual void operator()(
goal_ref const& goal,
goal_ref_buffer& result,
model_converter_ref& mc,
proof_converter_ref & pc,
expr_dependency_ref& core)
void operator()(goal_ref const& goal,
goal_ref_buffer& result,
model_converter_ref& mc,
proof_converter_ref & pc,
expr_dependency_ref& core) override
{
try {
checkpoint();
@ -269,7 +268,7 @@ namespace qe {
}
}
virtual void collect_statistics(statistics & st) const {
void collect_statistics(statistics & st) const override {
for (unsigned i = 0; i < m_solvers.size(); ++i) {
m_solvers[i]->collect_statistics(st);
}
@ -277,7 +276,7 @@ namespace qe {
m_ctx_rewriter.collect_statistics(st);
}
virtual void reset_statistics() {
void reset_statistics() override {
for (unsigned i = 0; i < m_solvers.size(); ++i) {
m_solvers[i]->reset_statistics();
}
@ -285,9 +284,9 @@ namespace qe {
m_ctx_rewriter.reset_statistics();
}
virtual void cleanup() {}
void cleanup() override {}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_extrapolate_strategy_param = p.get_uint("extrapolate_strategy", m_extrapolate_strategy_param);
m_projection_mode_param = p.get_bool("projection_mode", m_projection_mode_param);
m_strong_context_simplify_param = p.get_bool("strong_context_simplify", m_strong_context_simplify_param);
@ -296,7 +295,7 @@ namespace qe {
m_qe_rw.updt_params(p);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
r.insert("extrapolate_strategy",CPK_UINT, "(default: 0 trivial extrapolation) 1 - nnf strengthening 2 - smt-test 3 - nnf_weakening");
r.insert("projection_mode", CPK_BOOL, "(default: true - full) false - partial quantifier instantiation");
r.insert("strong_context_simplify", CPK_BOOL, "(default: true) use strong context simplifier on result of quantifier elimination");
@ -326,7 +325,7 @@ namespace qe {
smt::kernel& solver(unsigned i) { return *m_solvers[i]; }
void reset() {
void reset() override {
for (unsigned i = 0; i < m_solvers.size(); ++i) {
dealloc(m_solvers[i]);
}

24
src/qe/qe_tactic.cpp
View file

@ -102,46 +102,46 @@ public:
m_imp = alloc(imp, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(qe_tactic, m, m_params);
}
virtual ~qe_tactic() {
~qe_tactic() override {
dealloc(m_imp);
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_params = p;
m_imp->updt_params(p);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
r.insert("qe_nonlinear", CPK_BOOL, "(default: false) enable virtual term substitution.");
m_imp->collect_param_descrs(r);
}
virtual void operator()(goal_ref const & in,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) {
void operator()(goal_ref const & in,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) override {
(*m_imp)(in, result, mc, pc, core);
m_st.reset();
m_imp->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() {
void reset_statistics() override {
m_st.reset();
}
virtual void cleanup() {
void cleanup() override {
ast_manager & m = m_imp->m;
dealloc(m_imp);
m_imp = alloc(imp, m, m_params);

2
src/qe/qe_vartest.h
View file

@ -42,7 +42,7 @@ public:
m_num_decls(num_decls),
m_var_kind(BY_NUM_DECLS) {}
virtual bool operator()(expr* e) const {
bool operator()(expr* e) const override {
if (!is_var(e)) {
return false;
}

22
src/qe/qsat.cpp
View file

@ -696,7 +696,7 @@ namespace qe {
m_level -= num_scopes;
}
void reset() {
void reset() override {
m_st.reset();
m_fa.s().collect_statistics(m_st);
m_ex.s().collect_statistics(m_st);
@ -1204,14 +1204,14 @@ namespace qe {
reset();
}
virtual ~qsat() {
~qsat() override {
reset();
}
void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
}
void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
}
@ -1219,7 +1219,7 @@ namespace qe {
/* out */ goal_ref_buffer & result,
/* out */ model_converter_ref & mc,
/* out */ proof_converter_ref & pc,
/* out */ expr_dependency_ref & core) {
/* out */ expr_dependency_ref & core) override {
tactic_report report("qsat-tactic", *in);
ptr_vector<expr> fmls;
expr_ref_vector defs(m);
@ -1291,7 +1291,7 @@ namespace qe {
}
}
void collect_statistics(statistics & st) const {
void collect_statistics(statistics & st) const override {
st.copy(m_st);
m_fa.s().collect_statistics(st);
m_ex.s().collect_statistics(st);
@ -1300,23 +1300,23 @@ namespace qe {
m_pred_abs.collect_statistics(st);
}
void reset_statistics() {
void reset_statistics() override {
m_stats.reset();
m_fa.reset();
m_ex.reset();
}
void cleanup() {
void cleanup() override {
reset();
}
void set_logic(symbol const & l) {
void set_logic(symbol const & l) override {
}
void set_progress_callback(progress_callback * callback) {
void set_progress_callback(progress_callback * callback) override {
}
tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(qsat, m, m_params, m_mode);
}