mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-06 01:24:08 +00:00
Code Activity

Use override rather than virtual.

Browse source
This commit is contained in:
Bruce Mitchener 2018-02-09 21:15:02 +07:00
parent 2b847478a2
commit b7d1753843
138 changed files with 1621 additions and 1624 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

38
src/ast/arith_decl_plugin.h
View file

@ -145,7 +145,7 @@ protected:
bool m_convert_int_numerals_to_real;
func_decl * mk_func_decl(decl_kind k, bool is_real);
virtual void set_manager(ast_manager * m, family_id id);
void set_manager(ast_manager * m, family_id id) override;
decl_kind fix_kind(decl_kind k, unsigned arity);
void check_arity(unsigned arity, unsigned expected_arity);
func_decl * mk_num_decl(unsigned num_parameters, parameter const * parameters, unsigned arity);
@ -153,38 +153,38 @@ protected:
public:
arith_decl_plugin();
virtual ~arith_decl_plugin();
virtual void finalize();
~arith_decl_plugin() override;
void finalize() override;
algebraic_numbers::manager & am() const;
algebraic_numbers_wrapper & aw() const;
virtual void del(parameter const & p);
virtual parameter translate(parameter const & p, decl_plugin & target);
void del(parameter const & p) override;
parameter translate(parameter const & p, decl_plugin & target) override;
virtual decl_plugin * mk_fresh() {
decl_plugin * mk_fresh() override {
return alloc(arith_decl_plugin);
}
virtual sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters);
sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) override;
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range);
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range) override;
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned num_args, expr * const * args, sort * range);
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned num_args, expr * const * args, sort * range) override;
virtual bool is_value(app * e) const;
bool is_value(app * e) const override;
virtual bool is_unique_value(app * e) const;
bool is_unique_value(app * e) const override;
virtual bool are_equal(app * a, app * b) const;
bool are_equal(app * a, app * b) const override;
virtual bool are_distinct(app * a, app * b) const;
bool are_distinct(app * a, app * b) const override;
virtual void get_op_names(svector<builtin_name> & op_names, symbol const & logic);
void get_op_names(svector<builtin_name> & op_names, symbol const & logic) override;
virtual void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic);
void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) override;
app * mk_numeral(rational const & n, bool is_int);
@ -197,9 +197,9 @@ public:
app * mk_e() const { return m_e; }
virtual expr * get_some_value(sort * s);
expr * get_some_value(sort * s) override;
virtual bool is_considered_uninterpreted(func_decl * f) {
bool is_considered_uninterpreted(func_decl * f) override {
if (f->get_family_id() != get_family_id())
return false;
switch (f->get_decl_kind())

18
src/ast/array_decl_plugin.h
View file

@ -98,9 +98,9 @@ class array_decl_plugin : public decl_plugin {
bool is_array_sort(sort* s) const;
public:
array_decl_plugin();
virtual ~array_decl_plugin() {}
~array_decl_plugin() override {}
virtual decl_plugin * mk_fresh() {
decl_plugin * mk_fresh() override {
return alloc(array_decl_plugin);
}
@ -111,23 +111,23 @@ class array_decl_plugin : public decl_plugin {
// parameters[n-1] - nth dimension
// parameters[n] - range
//
virtual sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters);
sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) override;
//
// Contract for func_decl:
// parameters[0] - array sort
// Contract for others:
// no parameters
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range);
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range) override;
virtual void get_op_names(svector<builtin_name> & op_names, symbol const & logic);
void get_op_names(svector<builtin_name> & op_names, symbol const & logic) override;
virtual void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic);
void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) override;
virtual expr * get_some_value(sort * s);
expr * get_some_value(sort * s) override;
virtual bool is_fully_interp(sort * s) const;
bool is_fully_interp(sort * s) const override;
};
class array_recognizers {

74
src/ast/ast.h
View file

@ -1129,7 +1129,7 @@ protected:
unsigned num_parameters, parameter const* params, unsigned num_parents);
virtual void set_manager(ast_manager * m, family_id id);
void set_manager(ast_manager * m, family_id id) override;
func_decl * mk_eq_decl_core(char const * name, decl_kind k, sort * s, ptr_vector<func_decl> & cache);
func_decl * mk_ite_decl(sort * s);
sort* join(sort* s1, sort* s2);
@ -1138,33 +1138,33 @@ protected:
public:
basic_decl_plugin();
virtual ~basic_decl_plugin() {}
virtual void finalize();
~basic_decl_plugin() override {}
void finalize() override;
virtual decl_plugin * mk_fresh() {
decl_plugin * mk_fresh() override {
return alloc(basic_decl_plugin);
}
virtual sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const* parameters);
sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const* parameters) override;
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range);
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range) override;
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned num_args, expr * const * args, sort * range);
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned num_args, expr * const * args, sort * range) override;
virtual void get_op_names(svector<builtin_name> & op_names, symbol const & logic);
void get_op_names(svector<builtin_name> & op_names, symbol const & logic) override;
virtual void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic);
void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) override;
virtual bool is_value(app* a) const;
bool is_value(app* a) const override;
virtual bool is_unique_value(app* a) const;
bool is_unique_value(app* a) const override;
sort * mk_bool_sort() const { return m_bool_sort; }
sort * mk_proof_sort() const { return m_proof_sort; }
virtual expr * get_some_value(sort * s);
expr * get_some_value(sort * s) override;
};
typedef app proof; /* a proof is just an application */
@ -1188,15 +1188,15 @@ class label_decl_plugin : public decl_plugin {
symbol m_lblneg;
symbol m_lbllit;
virtual void set_manager(ast_manager * m, family_id id);
void set_manager(ast_manager * m, family_id id) override;
public:
label_decl_plugin();
virtual ~label_decl_plugin();
~label_decl_plugin() override;
virtual decl_plugin * mk_fresh() { return alloc(label_decl_plugin); }
decl_plugin * mk_fresh() override { return alloc(label_decl_plugin); }
virtual sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters);
sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) override;
/**
contract: when label
@ -1210,8 +1210,8 @@ public:
...
parameter[n-1] (symbol): label's tag.
*/
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range);
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range) override;
};
// -----------------------------------
@ -1230,12 +1230,12 @@ enum pattern_op_kind {
*/
class pattern_decl_plugin : public decl_plugin {
public:
virtual decl_plugin * mk_fresh() { return alloc(pattern_decl_plugin); }
decl_plugin * mk_fresh() override { return alloc(pattern_decl_plugin); }
virtual sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters);
sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) override;
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range);
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range) override;
};
// -----------------------------------
@ -1263,21 +1263,21 @@ class model_value_decl_plugin : public decl_plugin {
public:
model_value_decl_plugin() {}
virtual decl_plugin * mk_fresh() { return alloc(model_value_decl_plugin); }
decl_plugin * mk_fresh() override { return alloc(model_value_decl_plugin); }
virtual sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters);
sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) override;
/**
contract:
parameter[0]: (integer) value idx
parameter[1]: (ast) sort of the value.
*/
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range);
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range) override;
virtual bool is_value(app* n) const;
bool is_value(app* n) const override;
virtual bool is_unique_value(app* a) const;
bool is_unique_value(app* a) const override;
};
// -----------------------------------
@ -1292,11 +1292,11 @@ class user_sort_plugin : public decl_plugin {
public:
user_sort_plugin() {}
virtual sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters);
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range);
sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) override;
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range) override;
decl_kind register_name(symbol s);
virtual decl_plugin * mk_fresh();
decl_plugin * mk_fresh() override;
};
@ -2467,9 +2467,9 @@ class scoped_mark : public ast_mark {
unsigned_vector m_lim;
public:
scoped_mark(ast_manager& m): m_stack(m) {}
virtual ~scoped_mark() {}
virtual void mark(ast * n, bool flag);
virtual void reset();
~scoped_mark() override {}
void mark(ast * n, bool flag) override;
void reset() override;
void mark(ast * n);
void push_scope();
void pop_scope();

20
src/ast/ast_printer.cpp
View file

@ -25,24 +25,24 @@ class simple_ast_printer_context : public ast_printer_context {
smt2_pp_environment_dbg & env() const { return *(m_env.get()); }
public:
simple_ast_printer_context(ast_manager & m):m_manager(m) { m_env = alloc(smt2_pp_environment_dbg, m); }
virtual ~simple_ast_printer_context() {}
~simple_ast_printer_context() override {}
ast_manager & m() const { return m_manager; }
virtual ast_manager & get_ast_manager() { return m_manager; }
virtual void display(std::ostream & out, sort * s, unsigned indent = 0) const { out << mk_ismt2_pp(s, m(), indent); }
virtual void display(std::ostream & out, expr * n, unsigned indent = 0) const { out << mk_ismt2_pp(n, m(), indent); }
virtual void display(std::ostream & out, func_decl * f, unsigned indent = 0) const {
ast_manager & get_ast_manager() override { return m_manager; }
void display(std::ostream & out, sort * s, unsigned indent = 0) const override { out << mk_ismt2_pp(s, m(), indent); }
void display(std::ostream & out, expr * n, unsigned indent = 0) const override { out << mk_ismt2_pp(n, m(), indent); }
void display(std::ostream & out, func_decl * f, unsigned indent = 0) const override {
out << f->get_name();
}
virtual void pp(sort * s, format_ns::format_ref & r) const { mk_smt2_format(s, env(), params_ref(), r); }
virtual void pp(func_decl * f, format_ns::format_ref & r) const { mk_smt2_format(f, env(), params_ref(), r); }
virtual void pp(expr * n, format_ns::format_ref & r) const {
void pp(sort * s, format_ns::format_ref & r) const override { mk_smt2_format(s, env(), params_ref(), r); }
void pp(func_decl * f, format_ns::format_ref & r) const override { mk_smt2_format(f, env(), params_ref(), r); }
void pp(expr * n, format_ns::format_ref & r) const override {
sbuffer<symbol> buf;
mk_smt2_format(n, env(), params_ref(), 0, 0, r, buf);
}
virtual void pp(expr * n, unsigned num_vars, char const * var_prefix, format_ns::format_ref & r, sbuffer<symbol> & var_names) const {
void pp(expr * n, unsigned num_vars, char const * var_prefix, format_ns::format_ref & r, sbuffer<symbol> & var_names) const override {
mk_smt2_format(n, env(), params_ref(), num_vars, var_prefix, r, var_names);
}
virtual void display(std::ostream & out, expr * n, unsigned indent, unsigned num_vars, char const * var_prefix, sbuffer<symbol> & var_names) const {
void display(std::ostream & out, expr * n, unsigned indent, unsigned num_vars, char const * var_prefix, sbuffer<symbol> & var_names) const override {
NOT_IMPLEMENTED_YET();
}

2
src/ast/ast_printer.h
View file

@ -45,7 +45,7 @@ public:
class ast_printer_context : public ast_printer {
public:
virtual ~ast_printer_context() {}
~ast_printer_context() override {}
virtual ast_manager & get_ast_manager() = 0;
virtual std::ostream & regular_stream() { return std::cout; }
virtual std::ostream & diagnostic_stream() { return std::cerr; }

18
src/ast/ast_smt2_pp.h
View file

@ -80,15 +80,15 @@ class smt2_pp_environment_dbg : public smt2_pp_environment {
datalog::dl_decl_util m_dlutil;
public:
smt2_pp_environment_dbg(ast_manager & m):m_manager(m), m_autil(m), m_bvutil(m), m_arutil(m), m_futil(m), m_sutil(m), m_dtutil(m), m_dlutil(m) {}
virtual ast_manager & get_manager() const { return m_manager; }
virtual arith_util & get_autil() { return m_autil; }
virtual bv_util & get_bvutil() { return m_bvutil; }
virtual seq_util & get_sutil() { return m_sutil; }
virtual array_util & get_arutil() { return m_arutil; }
virtual fpa_util & get_futil() { return m_futil; }
virtual datalog::dl_decl_util& get_dlutil() { return m_dlutil; }
virtual datatype_util& get_dtutil() { return m_dtutil; }
virtual bool uses(symbol const & s) const { return false; }
ast_manager & get_manager() const override { return m_manager; }
arith_util & get_autil() override { return m_autil; }
bv_util & get_bvutil() override { return m_bvutil; }
seq_util & get_sutil() override { return m_sutil; }
array_util & get_arutil() override { return m_arutil; }
fpa_util & get_futil() override { return m_futil; }
datalog::dl_decl_util& get_dlutil() override { return m_dlutil; }
datatype_util& get_dtutil() override { return m_dtutil; }
bool uses(symbol const & s) const override { return false; }
};
void mk_smt2_format(expr * n, smt2_pp_environment & env, params_ref const & p,

32
src/ast/bv_decl_plugin.h
View file

@ -204,7 +204,7 @@ protected:
vector<ptr_vector<func_decl> > m_bit2bool;
ptr_vector<func_decl> m_mkbv;
virtual void set_manager(ast_manager * m, family_id id);
void set_manager(ast_manager * m, family_id id) override;
void mk_bv_sort(unsigned bv_size);
sort * get_bv_sort(unsigned bv_size);
func_decl * mk_func_decl(decl_kind k, unsigned bv_size);
@ -241,34 +241,34 @@ protected:
public:
bv_decl_plugin();
virtual ~bv_decl_plugin() {}
virtual void finalize();
~bv_decl_plugin() override {}
void finalize() override;
virtual decl_plugin * mk_fresh() { return alloc(bv_decl_plugin); }
decl_plugin * mk_fresh() override { return alloc(bv_decl_plugin); }
virtual sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters);
sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) override;
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range);
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range) override;
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned num_args, expr * const * args, sort * range);
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned num_args, expr * const * args, sort * range) override;
virtual bool is_value(app * e) const;
bool is_value(app * e) const override;
virtual bool is_unique_value(app * e) const { return is_value(e); }
bool is_unique_value(app * e) const override { return is_value(e); }
virtual void get_op_names(svector<builtin_name> & op_names, symbol const & logic);
void get_op_names(svector<builtin_name> & op_names, symbol const & logic) override;
virtual void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic);
void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) override;
virtual bool are_distinct(app* a, app* b) const;
bool are_distinct(app* a, app* b) const override;
virtual expr * get_some_value(sort * s);
expr * get_some_value(sort * s) override;
bool get_int2bv_size(unsigned num_parameters, parameter const * parameters, int & result);
virtual bool is_considered_uninterpreted(func_decl * f) {
bool is_considered_uninterpreted(func_decl * f) override {
if (f->get_family_id() != get_family_id())
return false;
switch (f->get_decl_kind()) {

54
src/ast/datatype_decl_plugin.h
View file

@ -124,16 +124,16 @@ namespace datatype {
struct offset : public size {
sort_size m_offset;
offset(sort_size const& s): m_offset(s) {}
virtual ~offset() {}
virtual size* subst(obj_map<sort,size*>& S) { return this; }
virtual sort_size eval(obj_map<sort, sort_size> const& S) { return m_offset; }
~offset() override {}
size* subst(obj_map<sort,size*>& S) override { return this; }
sort_size eval(obj_map<sort, sort_size> const& S) override { return m_offset; }
};
struct plus : public size {
size* m_arg1, *m_arg2;
plus(size* a1, size* a2): m_arg1(a1), m_arg2(a2) { a1->inc_ref(); a2->inc_ref();}
virtual ~plus() { m_arg1->dec_ref(); m_arg2->dec_ref(); }
virtual size* subst(obj_map<sort,size*>& S) { return mk_plus(m_arg1->subst(S), m_arg2->subst(S)); }
virtual sort_size eval(obj_map<sort, sort_size> const& S) {
~plus() override { m_arg1->dec_ref(); m_arg2->dec_ref(); }
size* subst(obj_map<sort,size*>& S) override { return mk_plus(m_arg1->subst(S), m_arg2->subst(S)); }
sort_size eval(obj_map<sort, sort_size> const& S) override {
sort_size s1 = m_arg1->eval(S);
sort_size s2 = m_arg2->eval(S);
if (s1.is_infinite()) return s1;
@ -147,9 +147,9 @@ namespace datatype {
struct times : public size {
size* m_arg1, *m_arg2;
times(size* a1, size* a2): m_arg1(a1), m_arg2(a2) { a1->inc_ref(); a2->inc_ref(); }
virtual ~times() { m_arg1->dec_ref(); m_arg2->dec_ref(); }
virtual size* subst(obj_map<sort,size*>& S) { return mk_times(m_arg1->subst(S), m_arg2->subst(S)); }
virtual sort_size eval(obj_map<sort, sort_size> const& S) {
~times() override { m_arg1->dec_ref(); m_arg2->dec_ref(); }
size* subst(obj_map<sort,size*>& S) override { return mk_times(m_arg1->subst(S), m_arg2->subst(S)); }
sort_size eval(obj_map<sort, sort_size> const& S) override {
sort_size s1 = m_arg1->eval(S);
sort_size s2 = m_arg2->eval(S);
if (s1.is_infinite()) return s1;
@ -163,9 +163,9 @@ namespace datatype {
struct power : public size {
size* m_arg1, *m_arg2;
power(size* a1, size* a2): m_arg1(a1), m_arg2(a2) { a1->inc_ref(); a2->inc_ref(); }
virtual ~power() { m_arg1->dec_ref(); m_arg2->dec_ref(); }
virtual size* subst(obj_map<sort,size*>& S) { return mk_power(m_arg1->subst(S), m_arg2->subst(S)); }
virtual sort_size eval(obj_map<sort, sort_size> const& S) {
~power() override { m_arg1->dec_ref(); m_arg2->dec_ref(); }
size* subst(obj_map<sort,size*>& S) override { return mk_power(m_arg1->subst(S), m_arg2->subst(S)); }
sort_size eval(obj_map<sort, sort_size> const& S) override {
sort_size s1 = m_arg1->eval(S);
sort_size s2 = m_arg2->eval(S);
// s1^s2
@ -183,9 +183,9 @@ namespace datatype {
struct sparam : public size {
sort_ref m_param;
sparam(sort_ref& p): m_param(p) {}
virtual ~sparam() {}
virtual size* subst(obj_map<sort,size*>& S) { return S[m_param]; }
virtual sort_size eval(obj_map<sort, sort_size> const& S) { return S[m_param]; }
~sparam() override {}
size* subst(obj_map<sort,size*>& S) override { return S[m_param]; }
sort_size eval(obj_map<sort, sort_size> const& S) override { return S[m_param]; }
};
};
@ -241,30 +241,30 @@ namespace datatype {
unsigned m_class_id;
util & u() const;
virtual void inherit(decl_plugin* other_p, ast_translation& tr);
void inherit(decl_plugin* other_p, ast_translation& tr) override;
public:
plugin(): m_class_id(0) {}
virtual ~plugin();
~plugin() override;
virtual void finalize();
void finalize() override;
virtual decl_plugin * mk_fresh() { return alloc(plugin); }
decl_plugin * mk_fresh() override { return alloc(plugin); }
virtual sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters);
sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) override;
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range);
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range) override;
virtual expr * get_some_value(sort * s);
expr * get_some_value(sort * s) override;
virtual bool is_fully_interp(sort * s) const;
bool is_fully_interp(sort * s) const override;
virtual bool is_value(app* e) const;
bool is_value(app* e) const override;
virtual bool is_unique_value(app * e) const { return is_value(e); }
bool is_unique_value(app * e) const override { return is_value(e); }
virtual void get_op_names(svector<builtin_name> & op_names, symbol const & logic);
void get_op_names(svector<builtin_name> & op_names, symbol const & logic) override;
void begin_def_block() { m_class_id++; m_def_block.reset(); }

18
src/ast/dl_decl_plugin.h
View file

@ -102,9 +102,9 @@ namespace datalog {
public:
dl_decl_plugin();
virtual ~dl_decl_plugin() {}
~dl_decl_plugin() override {}
virtual decl_plugin * mk_fresh() { return alloc(dl_decl_plugin); }
decl_plugin * mk_fresh() override { return alloc(dl_decl_plugin); }
//
// Contract for sort DL_RELATION_SORT
@ -116,7 +116,7 @@ namespace datalog {
// parameters[0] - name
// parameters[1] - uint64
//
virtual sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters);
sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) override;
//
// Contract for func_decl:
@ -126,15 +126,15 @@ namespace datalog {
// parameters[1] - a DL_FINITE_SORT sort of the constant
// Contract for others:
// no parameters
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range);
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range) override;
virtual void get_op_names(svector<builtin_name> & op_names, symbol const & logic);
void get_op_names(svector<builtin_name> & op_names, symbol const & logic) override;
virtual void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic);
void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) override;
virtual bool is_value(app * e) const { return is_app_of(e, m_family_id, OP_DL_CONSTANT); }
virtual bool is_unique_value(app * e) const { return is_value(e); }
bool is_value(app * e) const override { return is_app_of(e, m_family_id, OP_DL_CONSTANT); }
bool is_unique_value(app * e) const override { return is_value(e); }
};

6
src/ast/expr2polynomial.h
View file

@ -103,10 +103,10 @@ class default_expr2polynomial : public expr2polynomial {
svector<bool> m_is_int;
public:
default_expr2polynomial(ast_manager & am, polynomial::manager & pm);
virtual ~default_expr2polynomial();
virtual bool is_int(polynomial::var x) const;
~default_expr2polynomial() override;
bool is_int(polynomial::var x) const override;
protected:
virtual polynomial::var mk_var(bool is_int);
polynomial::var mk_var(bool is_int) override;
};
#endif

2
src/ast/expr_functors.h
View file

@ -73,7 +73,7 @@ class contains_app {
app* m_x;
public:
pred(app* x) : m_x(x) {}
virtual bool operator()(expr* e) {
bool operator()(expr* e) override {
return m_x == e;
}
};

14
src/ast/format.cpp
View file

@ -32,7 +32,7 @@ namespace format_ns {
symbol m_line_break;
symbol m_line_break_ext;
virtual void set_manager(ast_manager * m, family_id id) {
void set_manager(ast_manager * m, family_id id) override {
SASSERT(m->is_format_manager());
decl_plugin::set_manager(m, id);
@ -52,24 +52,24 @@ namespace format_ns {
m_line_break_ext("cr++") {
}
virtual ~format_decl_plugin() {}
~format_decl_plugin() override {}
virtual void finalize() {
void finalize() override {
if (m_format_sort)
m_manager->dec_ref(m_format_sort);
}
virtual decl_plugin * mk_fresh() {
decl_plugin * mk_fresh() override {
return alloc(format_decl_plugin);
}
virtual sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const* parameters) {
sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const* parameters) override {
SASSERT(k == FORMAT_SORT);
return m_format_sort;
}
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range) {
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range) override {
switch (k) {
case OP_NIL:
return m_manager->mk_func_decl(m_nil, arity, domain, m_format_sort,

30
src/ast/fpa_decl_plugin.h
View file

@ -159,11 +159,11 @@ class fpa_decl_plugin : public decl_plugin {
func_decl * mk_bv_wrap(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range);
virtual void set_manager(ast_manager * m, family_id id);
void set_manager(ast_manager * m, family_id id) override;
unsigned mk_id(mpf const & v);
void recycled_id(unsigned id);
virtual bool is_considered_uninterpreted(func_decl * f) { return false; }
bool is_considered_uninterpreted(func_decl * f) override { return false; }
public:
fpa_decl_plugin();
@ -171,18 +171,18 @@ public:
bool is_float_sort(sort * s) const { return is_sort_of(s, m_family_id, FLOATING_POINT_SORT); }
bool is_rm_sort(sort * s) const { return is_sort_of(s, m_family_id, ROUNDING_MODE_SORT); }
virtual ~fpa_decl_plugin();
virtual void finalize();
~fpa_decl_plugin() override;
void finalize() override;
virtual decl_plugin * mk_fresh();
virtual sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters);
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range);
virtual void get_op_names(svector<builtin_name> & op_names, symbol const & logic);
virtual void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic);
virtual expr * get_some_value(sort * s);
virtual bool is_value(app* e) const;
virtual bool is_unique_value(app* e) const;
decl_plugin * mk_fresh() override;
sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) override;
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range) override;
void get_op_names(svector<builtin_name> & op_names, symbol const & logic) override;
void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) override;
expr * get_some_value(sort * s) override;
bool is_value(app* e) const override;
bool is_unique_value(app* e) const override;
mpf_manager & fm() { return m_fm; }
func_decl * mk_numeral_decl(mpf const & v);
@ -197,8 +197,8 @@ public:
return m_values[id];
}
virtual void del(parameter const & p);
virtual parameter translate(parameter const & p, decl_plugin & target);
void del(parameter const & p) override;
parameter translate(parameter const & p, decl_plugin & target) override;
};
class fpa_util {

2
src/ast/normal_forms/defined_names.cpp
View file

@ -74,7 +74,7 @@ struct defined_names::impl {
struct defined_names::pos_impl : public defined_names::impl {
pos_impl(ast_manager & m, char const * fresh_prefix):impl(m, fresh_prefix) {}
virtual void mk_definition(expr * e, app * n, sort_ref_buffer & var_sorts, buffer<symbol> const & var_names, expr_ref & new_def);
void mk_definition(expr * e, app * n, sort_ref_buffer & var_sorts, buffer<symbol> const & var_names, expr_ref & new_def) override;
};

16
src/ast/normal_forms/name_exprs.cpp
View file

@ -77,10 +77,10 @@ public:
m_rw(m, m.proofs_enabled(), m_cfg) {
}
virtual ~name_exprs_core() {
~name_exprs_core() override {
}
virtual void operator()(expr * n, expr_ref_vector & new_defs, proof_ref_vector & new_def_proofs, expr_ref & r, proof_ref & p) {
void operator()(expr * n, expr_ref_vector & new_defs, proof_ref_vector & new_def_proofs, expr_ref & r, proof_ref & p) override {
m_cfg.m_def_exprs = &new_defs;
m_cfg.m_def_proofs = &new_def_proofs;
m_rw(n, r, p);
@ -88,7 +88,7 @@ public:
}
virtual void reset() {
void reset() override {
m_rw.reset();
}
};
@ -102,7 +102,7 @@ class name_quantifier_labels : public name_exprs_core {
ast_manager & m_manager;
public:
pred(ast_manager & m):m_manager(m) {}
virtual bool operator()(expr * t) {
bool operator()(expr * t) override {
return is_quantifier(t) || m_manager.is_label(t);
}
};
@ -114,7 +114,7 @@ public:
m_pred(m) {
}
virtual ~name_quantifier_labels() {
~name_quantifier_labels() override {
}
};
@ -129,7 +129,7 @@ class name_nested_formulas : public name_exprs_core {
pred(ast_manager & m):m_manager(m), m_root(0) {}
virtual bool operator()(expr * t) {
bool operator()(expr * t) override {
TRACE("name_exprs", tout << "name_nested_formulas::pred:\n" << mk_ismt2_pp(t, m_manager) << "\n";);
if (is_app(t))
return to_app(t)->get_family_id() == m_manager.get_basic_family_id() && to_app(t)->get_num_args() > 0 && t != m_root;
@ -145,10 +145,10 @@ public:
m_pred(m) {
}
virtual ~name_nested_formulas() {
~name_nested_formulas() override {
}
virtual void operator()(expr * n, expr_ref_vector & new_defs, proof_ref_vector & new_def_proofs, expr_ref & r, proof_ref & p) {
void operator()(expr * n, expr_ref_vector & new_defs, proof_ref_vector & new_def_proofs, expr_ref & r, proof_ref & p) override {
m_pred.m_root = n;
TRACE("name_exprs", tout << "operator()\n";);
name_exprs_core::operator()(n, new_defs, new_def_proofs, r, p);

14
src/ast/pb_decl_plugin.h
View file

@ -53,14 +53,14 @@ class pb_decl_plugin : public decl_plugin {
func_decl * mk_eq(unsigned arity, rational const* coeffs, int k);
public:
pb_decl_plugin();
virtual ~pb_decl_plugin() {}
~pb_decl_plugin() override {}
virtual sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) {
sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) override {
UNREACHABLE();
return 0;
}
virtual decl_plugin * mk_fresh() {
decl_plugin * mk_fresh() override {
return alloc(pb_decl_plugin);
}
@ -69,11 +69,11 @@ public:
// parameters[0] - integer (at most k elements)
// all sorts are Booleans
// parameters[1] .. parameters[arity] - coefficients
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range);
virtual void get_op_names(svector<builtin_name> & op_names, symbol const & logic);
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range) override;
void get_op_names(svector<builtin_name> & op_names, symbol const & logic) override;
virtual bool is_considered_uninterpreted(func_decl * f) { return false; }
bool is_considered_uninterpreted(func_decl * f) override { return false; }
};

22
src/ast/proofs/proof_checker.h
View file

@ -48,24 +48,24 @@ class proof_checker {
func_decl* m_atom;
func_decl* m_nil;
sort* m_cell;
virtual void set_manager(ast_manager * m, family_id id);
void set_manager(ast_manager * m, family_id id) override;
func_decl * mk_func_decl(decl_kind k);
public:
hyp_decl_plugin();
virtual ~hyp_decl_plugin() {}
~hyp_decl_plugin() override {}
virtual void finalize();
void finalize() override;
virtual decl_plugin * mk_fresh() { return alloc(hyp_decl_plugin); }
decl_plugin * mk_fresh() override { return alloc(hyp_decl_plugin); }
virtual sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const* parameters);
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range);
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned num_args, expr * const * args, sort * range);
virtual void get_op_names(svector<builtin_name> & op_names, symbol const & logic);
virtual void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic);
sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const* parameters) override;
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range) override;
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned num_args, expr * const * args, sort * range) override;
void get_op_names(svector<builtin_name> & op_names, symbol const & logic) override;
void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) override;
};
public:
proof_checker(ast_manager& m);

2
src/ast/rewriter/elim_bounds.h
View file

@ -70,7 +70,7 @@ public:
m_cfg(m)
{}
virtual ~elim_bounds_rw() {}
~elim_bounds_rw() override {}
};
#endif /* ELIM_BOUNDS2_H_ */

22
src/ast/rewriter/expr_replacer.cpp
View file

@ -90,14 +90,14 @@ public:
m_replacer(m, m.proofs_enabled(), m_cfg) {
}
virtual ast_manager & m() const { return m_replacer.m(); }
ast_manager & m() const override { return m_replacer.m(); }
virtual void set_substitution(expr_substitution * s) {
void set_substitution(expr_substitution * s) override {
m_replacer.cleanup();
m_replacer.cfg().m_subst = s;
}
virtual void operator()(expr * t, expr_ref & result, proof_ref & result_pr, expr_dependency_ref & result_dep) {
void operator()(expr * t, expr_ref & result, proof_ref & result_pr, expr_dependency_ref & result_dep) override {
result_dep = 0;
m_replacer.operator()(t, result, result_pr);
if (m_cfg.m_used_dependencies != 0) {
@ -108,11 +108,11 @@ public:
}
virtual unsigned get_num_steps() const {
unsigned get_num_steps() const override {
return m_replacer.get_num_steps();
}
virtual void reset() {
void reset() override {
m_replacer.reset();
}
};
@ -131,23 +131,23 @@ public:
m_r(m, p) {
}
virtual ~th_rewriter2expr_replacer() {}
~th_rewriter2expr_replacer() override {}
virtual ast_manager & m() const { return m_r.m(); }
ast_manager & m() const override { return m_r.m(); }
virtual void set_substitution(expr_substitution * s) { m_r.set_substitution(s); }
void set_substitution(expr_substitution * s) override { m_r.set_substitution(s); }
virtual void operator()(expr * t, expr_ref & result, proof_ref & result_pr, expr_dependency_ref & result_dep) {
void operator()(expr * t, expr_ref & result, proof_ref & result_pr, expr_dependency_ref & result_dep) override {
m_r(t, result, result_pr);
result_dep = m_r.get_used_dependencies();
m_r.reset_used_dependencies();
}
virtual unsigned get_num_steps() const {
unsigned get_num_steps() const override {
return m_r.get_num_steps();
}
virtual void reset() {
void reset() override {
m_r.reset();
}

4
src/ast/rewriter/maximize_ac_sharing.h
View file

@ -103,8 +103,8 @@ public:
class maximize_bv_sharing : public maximize_ac_sharing {
bv_util m_util;
protected:
virtual void init_core();
virtual bool is_numeral(expr * n) const;
void init_core() override;
bool is_numeral(expr * n) const override;
public:
maximize_bv_sharing(ast_manager & m);
};

4
src/ast/rewriter/pull_ite_tree.h
View file

@ -96,8 +96,8 @@ public:
class pull_cheap_ite_tree_cfg : public pull_ite_tree_cfg {
public:
pull_cheap_ite_tree_cfg(ast_manager & m):pull_ite_tree_cfg(m) {}
virtual ~pull_cheap_ite_tree_cfg() {}
virtual bool is_target(app * n) const;
~pull_cheap_ite_tree_cfg() override {}
bool is_target(app * n) const override;
};
class pull_cheap_ite_tree_rw : public rewriter_tpl<pull_cheap_ite_tree_cfg> {

2
src/ast/rewriter/push_app_ite.h
View file

@ -45,7 +45,7 @@ struct push_app_ite_cfg : public default_rewriter_cfg {
*/
class ng_push_app_ite_cfg : public push_app_ite_cfg {
protected:
virtual bool is_target(func_decl * decl, unsigned num_args, expr * const * args);
bool is_target(func_decl * decl, unsigned num_args, expr * const * args) override;
public:
ng_push_app_ite_cfg(ast_manager& m, bool conservative = true): push_app_ite_cfg(m, conservative) {}
virtual ~ng_push_app_ite_cfg() {}

6
src/ast/rewriter/rewriter.h
View file

@ -150,7 +150,7 @@ class var_shifter : public var_shifter_core {
unsigned m_bound;
unsigned m_shift1;
unsigned m_shift2;
virtual void process_var(var * v);
void process_var(var * v) override;
public:
var_shifter(ast_manager & m):var_shifter_core(m) {}
void operator()(expr * t, unsigned bound, unsigned shift1, unsigned shift2, expr_ref & r);
@ -183,7 +183,7 @@ public:
class inv_var_shifter : public var_shifter_core {
protected:
unsigned m_shift;
virtual void process_var(var * v);
void process_var(var * v) override;
public:
inv_var_shifter(ast_manager & m):var_shifter_core(m) {}
void operator()(expr * t, unsigned shift, expr_ref & r);
@ -339,7 +339,7 @@ public:
Config & cfg() { return m_cfg; }
Config const & cfg() const { return m_cfg; }
~rewriter_tpl();
~rewriter_tpl() override;
void reset();
void cleanup();

16
src/ast/rewriter/seq_rewriter.cpp
View file

@ -85,15 +85,15 @@ public:
sym_expr_boolean_algebra(ast_manager& m, expr_solver& s):
m(m), m_solver(s) {}
virtual T mk_false() {
T mk_false() override {
expr_ref fml(m.mk_false(), m);
return sym_expr::mk_pred(fml, m.mk_bool_sort()); // use of Bool sort for bound variable is arbitrary
}
virtual T mk_true() {
T mk_true() override {
expr_ref fml(m.mk_true(), m);
return sym_expr::mk_pred(fml, m.mk_bool_sort());
}
virtual T mk_and(T x, T y) {
T mk_and(T x, T y) override {
if (x->is_char() && y->is_char()) {
if (x->get_char() == y->get_char()) {
return x;
@ -118,7 +118,7 @@ public:
br.mk_and(fml1, fml2, fml);
return sym_expr::mk_pred(fml, x->get_sort());
}
virtual T mk_or(T x, T y) {
T mk_or(T x, T y) override {
if (x->is_char() && y->is_char() &&
x->get_char() == y->get_char()) {
return x;
@ -135,7 +135,7 @@ public:
return sym_expr::mk_pred(fml, x->get_sort());
}
virtual T mk_and(unsigned sz, T const* ts) {
T mk_and(unsigned sz, T const* ts) override {
switch (sz) {
case 0: return mk_true();
case 1: return ts[0];
@ -148,7 +148,7 @@ public:
}
}
}
virtual T mk_or(unsigned sz, T const* ts) {
T mk_or(unsigned sz, T const* ts) override {
switch (sz) {
case 0: return mk_false();
case 1: return ts[0];
@ -161,7 +161,7 @@ public:
}
}
}
virtual lbool is_sat(T x) {
lbool is_sat(T x) override {
if (x->is_char()) {
return l_true;
}
@ -178,7 +178,7 @@ public:
}
return m_solver.check_sat(fml);
}
virtual T mk_not(T x) {
T mk_not(T x) override {
var_ref v(m.mk_var(0, x->get_sort()), m);
expr_ref fml(m.mk_not(x->accept(v)), m);
return sym_expr::mk_pred(fml, x->get_sort());

28
src/ast/seq_decl_plugin.h
View file

@ -162,34 +162,34 @@ class seq_decl_plugin : public decl_plugin {
void init();
virtual void set_manager(ast_manager * m, family_id id);
void set_manager(ast_manager * m, family_id id) override;
public:
seq_decl_plugin();
virtual ~seq_decl_plugin() {}
virtual void finalize();
~seq_decl_plugin() override {}
void finalize() override;
virtual decl_plugin * mk_fresh() { return alloc(seq_decl_plugin); }
decl_plugin * mk_fresh() override { return alloc(seq_decl_plugin); }
virtual sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters);
sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) override;
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range);
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, sort * range) override;
virtual void get_op_names(svector<builtin_name> & op_names, symbol const & logic);
void get_op_names(svector<builtin_name> & op_names, symbol const & logic) override;
virtual void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic);
void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) override;
virtual bool is_value(app * e) const;
bool is_value(app * e) const override;
virtual bool is_unique_value(app * e) const { return false; }
bool is_unique_value(app * e) const override { return false; }
virtual bool are_equal(app* a, app* b) const;
bool are_equal(app* a, app* b) const override;
virtual bool are_distinct(app* a, app* b) const;
bool are_distinct(app* a, app* b) const override;
virtual expr * get_some_value(sort * s);
expr * get_some_value(sort * s) override;
bool is_char(ast* a) const { return a == m_char; }

134
src/cmd_context/basic_cmds.cpp
View file

@ -49,12 +49,12 @@ class help_cmd : public cmd {
public:
help_cmd():cmd("help") {}
virtual char const * get_usage() const { return "<symbol>*"; }
virtual char const * get_descr(cmd_context & ctx) const { return "print this help."; }
virtual unsigned get_arity() const { return VAR_ARITY; }
virtual void prepare(cmd_context & ctx) { m_cmds.reset(); }
virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const { return CPK_SYMBOL; }
virtual void set_next_arg(cmd_context & ctx, symbol const & s) {
char const * get_usage() const override { return "<symbol>*"; }
char const * get_descr(cmd_context & ctx) const override { return "print this help."; }
unsigned get_arity() const override { return VAR_ARITY; }
void prepare(cmd_context & ctx) override { m_cmds.reset(); }
cmd_arg_kind next_arg_kind(cmd_context & ctx) const override { return CPK_SYMBOL; }
void set_next_arg(cmd_context & ctx, symbol const & s) override {
cmd * c = ctx.find_cmd(s);
if (c == 0) {
std::string err_msg("unknown command '");
@ -69,7 +69,7 @@ public:
bool operator()(named_cmd const & c1, named_cmd const & c2) const { return c1.first.str() < c2.first.str(); }
};
virtual void execute(cmd_context & ctx) {
void execute(cmd_context & ctx) override {
ctx.regular_stream() << "\"";
if (m_cmds.empty()) {
vector<named_cmd> cmds;
@ -101,14 +101,14 @@ class get_model_cmd : public cmd {
unsigned m_index;
public:
get_model_cmd(): cmd("get-model"), m_index(0) {}
virtual char const * get_usage() const { return "[<index of box objective>]"; }
virtual char const * get_descr(cmd_context & ctx) const {
char const * get_usage() const override { return "[<index of box objective>]"; }
char const * get_descr(cmd_context & ctx) const override {
return "retrieve model for the last check-sat command.\nSupply optional index if retrieving a model corresponding to a box optimization objective";
}
virtual unsigned get_arity() const { return VAR_ARITY; }
virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const { return CPK_UINT; }
virtual void set_next_arg(cmd_context & ctx, unsigned index) { m_index = index; }
virtual void execute(cmd_context & ctx) {
unsigned get_arity() const override { return VAR_ARITY; }
cmd_arg_kind next_arg_kind(cmd_context & ctx) const override { return CPK_UINT; }
void set_next_arg(cmd_context & ctx, unsigned index) override { m_index = index; }
void execute(cmd_context & ctx) override {
if (!ctx.is_model_available() || ctx.get_check_sat_result() == 0)
throw cmd_exception("model is not available");
model_ref m;
@ -120,7 +120,7 @@ public:
}
ctx.display_model(m);
}
virtual void reset(cmd_context& ctx) {
void reset(cmd_context& ctx) override {
m_index = 0;
}
};
@ -166,10 +166,10 @@ class cmd_is_declared : public ast_smt_pp::is_declared {
public:
cmd_is_declared(cmd_context& ctx): m_ctx(ctx) {}
virtual bool operator()(func_decl* d) const {
bool operator()(func_decl* d) const override {
return m_ctx.is_func_decl(d->get_name());
}
virtual bool operator()(sort* s) const {
bool operator()(sort* s) const override {
return m_ctx.is_sort_decl(s->get_name());
}
};
@ -360,7 +360,7 @@ public:
m_int_real_coercions(":int-real-coercions"),
m_reproducible_resource_limit(":reproducible-resource-limit") {
}
virtual ~set_get_option_cmd() {}
~set_get_option_cmd() override {}
};
@ -477,19 +477,19 @@ public:
m_unsupported(false) {
}
virtual char const * get_usage() const { return "<keyword> <value>"; }
char const * get_usage() const override { return "<keyword> <value>"; }
virtual char const * get_descr(cmd_context & ctx) const { return "set configuration option."; }
char const * get_descr(cmd_context & ctx) const override { return "set configuration option."; }
virtual unsigned get_arity() const { return 2; }
unsigned get_arity() const override { return 2; }
virtual void prepare(cmd_context & ctx) { m_unsupported = false; m_option = symbol::null; }
void prepare(cmd_context & ctx) override { m_unsupported = false; m_option = symbol::null; }
virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const {
cmd_arg_kind next_arg_kind(cmd_context & ctx) const override {
return m_option == symbol::null ? CPK_KEYWORD : CPK_OPTION_VALUE;
}
virtual void set_next_arg(cmd_context & ctx, symbol const & opt) {
void set_next_arg(cmd_context & ctx, symbol const & opt) override {
if (m_option == symbol::null) {
m_option = opt;
}
@ -498,7 +498,7 @@ public:
}
}
virtual void set_next_arg(cmd_context & ctx, rational const & val) {
void set_next_arg(cmd_context & ctx, rational const & val) override {
if (m_option == m_random_seed) {
ctx.set_random_seed(to_unsigned(val));
}
@ -517,7 +517,7 @@ public:
}
}
virtual void set_next_arg(cmd_context & ctx, char const * value) {
void set_next_arg(cmd_context & ctx, char const * value) override {
if (m_option == m_regular_output_channel) {
ctx.set_regular_stream(value);
}
@ -532,7 +532,7 @@ public:
}
}
virtual void execute(cmd_context & ctx) {
void execute(cmd_context & ctx) override {
if (m_unsupported)
ctx.print_unsupported(m_option, m_line, m_pos);
else
@ -557,11 +557,11 @@ public:
get_option_cmd():
set_get_option_cmd("get-option") {
}
virtual char const * get_usage() const { return "<keyword>"; }
virtual char const * get_descr(cmd_context & ctx) const { return "get configuration option."; }
virtual unsigned get_arity() const { return 1; }
virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const { return CPK_KEYWORD; }
virtual void set_next_arg(cmd_context & ctx, symbol const & opt) {
char const * get_usage() const override { return "<keyword>"; }
char const * get_descr(cmd_context & ctx) const override { return "get configuration option."; }
unsigned get_arity() const override { return 1; }
cmd_arg_kind next_arg_kind(cmd_context & ctx) const override { return CPK_KEYWORD; }
void set_next_arg(cmd_context & ctx, symbol const & opt) override {
if (opt == m_print_success) {
print_bool(ctx, ctx.print_success_enabled());
}
@ -651,11 +651,11 @@ public:
m_all_statistics(":all-statistics"),
m_assertion_stack_levels(":assertion-stack-levels") {
}
virtual char const * get_usage() const { return "<keyword>"; }
virtual char const * get_descr(cmd_context & ctx) const { return "get information."; }
virtual unsigned get_arity() const { return 1; }
virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const { return CPK_KEYWORD; }
virtual void set_next_arg(cmd_context & ctx, symbol const & opt) {
char const * get_usage() const override { return "<keyword>"; }
char const * get_descr(cmd_context & ctx) const override { return "get information."; }
unsigned get_arity() const override { return 1; }
cmd_arg_kind next_arg_kind(cmd_context & ctx) const override { return CPK_KEYWORD; }
void set_next_arg(cmd_context & ctx, symbol const & opt) override {
if (opt == m_error_behavior) {
if (ctx.exit_on_error())
ctx.regular_stream() << "(:error-behavior immediate-exit)" << std::endl;
@ -707,16 +707,16 @@ public:
m_sat("sat"),
m_unknown("unknown") {
}
virtual char const * get_usage() const { return "<keyword> <value>"; }
virtual char const * get_descr(cmd_context & ctx) const { return "set information."; }
virtual unsigned get_arity() const { return 2; }
virtual void prepare(cmd_context & ctx) { m_info = symbol::null; }
virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const {
char const * get_usage() const override { return "<keyword> <value>"; }
char const * get_descr(cmd_context & ctx) const override { return "set information."; }
unsigned get_arity() const override { return 2; }
void prepare(cmd_context & ctx) override { m_info = symbol::null; }
cmd_arg_kind next_arg_kind(cmd_context & ctx) const override {
return m_info == symbol::null ? CPK_KEYWORD : CPK_OPTION_VALUE;
}
virtual void set_next_arg(cmd_context & ctx, rational const & val) {}
virtual void set_next_arg(cmd_context & ctx, char const * val) {}
virtual void set_next_arg(cmd_context & ctx, symbol const & s) {
void set_next_arg(cmd_context & ctx, rational const & val) override {}
void set_next_arg(cmd_context & ctx, char const * val) override {}
void set_next_arg(cmd_context & ctx, symbol const & s) override {
if (m_info == symbol::null) {
m_info = s;
}
@ -737,7 +737,7 @@ public:
}
}
}
virtual void execute(cmd_context & ctx) {
void execute(cmd_context & ctx) override {
ctx.print_success();
}
};
@ -760,30 +760,30 @@ public:
}
return m_array_fid;
}
virtual char const * get_usage() const { return "<symbol> (<sort>+) <func-decl-ref>"; }
virtual char const * get_descr(cmd_context & ctx) const { return "declare a new array map operator with name <symbol> using the given function declaration.\n<func-decl-ref> ::= <symbol>\n | (<symbol> (<sort>*) <sort>)\n | ((_ <symbol> <numeral>+) (<sort>*) <sort>)\nThe last two cases are used to disumbiguate between declarations with the same name and/or select (indexed) builtin declarations.\nFor more details about the array map operator, see 'Generalized and Efficient Array Decision Procedures' (FMCAD 2009).\nExample: (declare-map set-union (Int) (or (Bool Bool) Bool))\nDeclares a new function (declare-fun set-union ((Array Int Bool) (Array Int Bool)) (Array Int Bool)).\nThe instance of the map axiom for this new declaration is:\n(forall ((a1 (Array Int Bool)) (a2 (Array Int Bool)) (i Int)) (= (select (set-union a1 a2) i) (or (select a1 i) (select a2 i))))"; }
virtual unsigned get_arity() const { return 3; }
virtual void prepare(cmd_context & ctx) { m_name = symbol::null; m_domain.reset(); }
virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const {
char const * get_usage() const override { return "<symbol> (<sort>+) <func-decl-ref>"; }
char const * get_descr(cmd_context & ctx) const override { return "declare a new array map operator with name <symbol> using the given function declaration.\n<func-decl-ref> ::= <symbol>\n | (<symbol> (<sort>*) <sort>)\n | ((_ <symbol> <numeral>+) (<sort>*) <sort>)\nThe last two cases are used to disumbiguate between declarations with the same name and/or select (indexed) builtin declarations.\nFor more details about the array map operator, see 'Generalized and Efficient Array Decision Procedures' (FMCAD 2009).\nExample: (declare-map set-union (Int) (or (Bool Bool) Bool))\nDeclares a new function (declare-fun set-union ((Array Int Bool) (Array Int Bool)) (Array Int Bool)).\nThe instance of the map axiom for this new declaration is:\n(forall ((a1 (Array Int Bool)) (a2 (Array Int Bool)) (i Int)) (= (select (set-union a1 a2) i) (or (select a1 i) (select a2 i))))"; }
unsigned get_arity() const override { return 3; }
void prepare(cmd_context & ctx) override { m_name = symbol::null; m_domain.reset(); }
cmd_arg_kind next_arg_kind(cmd_context & ctx) const override {
if (m_name == symbol::null) return CPK_SYMBOL;
if (m_domain.empty()) return CPK_SORT_LIST;
return CPK_FUNC_DECL;
}
virtual void set_next_arg(cmd_context & ctx, symbol const & s) { m_name = s; }
virtual void set_next_arg(cmd_context & ctx, unsigned num, sort * const * slist) {
void set_next_arg(cmd_context & ctx, symbol const & s) override { m_name = s; }
void set_next_arg(cmd_context & ctx, unsigned num, sort * const * slist) override {
if (num == 0)
throw cmd_exception("invalid map declaration, empty sort list");
m_domain.append(num, slist);
}
virtual void set_next_arg(cmd_context & ctx, func_decl * f) {
void set_next_arg(cmd_context & ctx, func_decl * f) override {
m_f = f;
if (m_f->get_arity() == 0)
throw cmd_exception("invalid map declaration, function declaration must have arity > 0");
}
virtual void reset(cmd_context & ctx) {
void reset(cmd_context & ctx) override {
m_array_fid = null_family_id;
}
virtual void execute(cmd_context & ctx) {
void execute(cmd_context & ctx) override {
psort_decl * array_sort = ctx.find_psort_decl(m_array_sort);
if (array_sort == 0)
throw cmd_exception("Array sort is not available");
@ -813,11 +813,11 @@ class get_consequences_cmd : public cmd {
unsigned m_count;
public:
get_consequences_cmd(): cmd("get-consequences"), m_count(0) {}
virtual char const * get_usage() const { return "(<boolean-variable>*) (<variable>*)"; }
virtual char const * get_descr(cmd_context & ctx) const { return "retrieve consequences that fix values for supplied variables"; }
virtual unsigned get_arity() const { return 2; }
virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const { return CPK_EXPR_LIST; }
virtual void set_next_arg(cmd_context & ctx, unsigned num, expr * const * tlist) {
char const * get_usage() const override { return "(<boolean-variable>*) (<variable>*)"; }
char const * get_descr(cmd_context & ctx) const override { return "retrieve consequences that fix values for supplied variables"; }
unsigned get_arity() const override { return 2; }
cmd_arg_kind next_arg_kind(cmd_context & ctx) const override { return CPK_EXPR_LIST; }
void set_next_arg(cmd_context & ctx, unsigned num, expr * const * tlist) override {
if (m_count == 0) {
m_assumptions.append(num, tlist);
++m_count;
@ -826,8 +826,8 @@ public:
m_variables.append(num, tlist);
}
}
virtual void failure_cleanup(cmd_context & ctx) {}
virtual void execute(cmd_context & ctx) {
void failure_cleanup(cmd_context & ctx) override {}
void execute(cmd_context & ctx) override {
ast_manager& m = ctx.m();
expr_ref_vector assumptions(m), variables(m), consequences(m);
assumptions.append(m_assumptions.size(), m_assumptions.c_ptr());
@ -835,12 +835,12 @@ public:
ctx.get_consequences(assumptions, variables, consequences);
ctx.regular_stream() << consequences << "\n";
}
virtual void prepare(cmd_context & ctx) { reset(ctx); }
void prepare(cmd_context & ctx) override { reset(ctx); }
virtual void reset(cmd_context& ctx) {
void reset(cmd_context& ctx) override {
m_assumptions.reset(); m_variables.reset(); m_count = 0;
}
virtual void finalize(cmd_context & ctx) {}
void finalize(cmd_context & ctx) override {}
};
// provides "help" for builtin cmds
@ -850,8 +850,8 @@ class builtin_cmd : public cmd {
public:
builtin_cmd(char const * name, char const * usage, char const * descr):
cmd(name), m_usage(usage), m_descr(descr) {}
virtual char const * get_usage() const { return m_usage; }
virtual char const * get_descr(cmd_context & ctx) const { return m_descr; }
char const * get_usage() const override { return m_usage; }
char const * get_descr(cmd_context & ctx) const override { return m_descr; }
};

26
src/cmd_context/cmd_context.cpp
View file

@ -414,25 +414,25 @@ protected:
public:
pp_env(cmd_context & o):m_owner(o), m_autil(o.m()), m_bvutil(o.m()), m_arutil(o.m()), m_futil(o.m()), m_sutil(o.m()), m_dtutil(o.m()), m_dlutil(o.m()) {}
virtual ~pp_env() {}
virtual ast_manager & get_manager() const { return m_owner.m(); }
virtual arith_util & get_autil() { return m_autil; }
virtual bv_util & get_bvutil() { return m_bvutil; }
virtual array_util & get_arutil() { return m_arutil; }
virtual fpa_util & get_futil() { return m_futil; }
virtual seq_util & get_sutil() { return m_sutil; }
virtual datatype_util & get_dtutil() { return m_dtutil; }
~pp_env() override {}
ast_manager & get_manager() const override { return m_owner.m(); }
arith_util & get_autil() override { return m_autil; }
bv_util & get_bvutil() override { return m_bvutil; }
array_util & get_arutil() override { return m_arutil; }
fpa_util & get_futil() override { return m_futil; }
seq_util & get_sutil() override { return m_sutil; }
datatype_util & get_dtutil() override { return m_dtutil; }
virtual datalog::dl_decl_util& get_dlutil() { return m_dlutil; }
virtual bool uses(symbol const & s) const {
datalog::dl_decl_util& get_dlutil() override { return m_dlutil; }
bool uses(symbol const & s) const override {
return
m_owner.m_builtin_decls.contains(s) ||
m_owner.m_func_decls.contains(s);
}
virtual format_ns::format * pp_sort(sort * s) {
format_ns::format * pp_sort(sort * s) override {
return m_owner.pp(s);
}
virtual format_ns::format * pp_fdecl(func_decl * f, unsigned & len) {
format_ns::format * pp_fdecl(func_decl * f, unsigned & len) override {
symbol s = f->get_name();
func_decls fs;
if (m_owner.m_func_decls.find(s, fs) && fs.contains(f)) {
@ -443,7 +443,7 @@ public:
}
return smt2_pp_environment::pp_fdecl(f, len);
}
virtual format_ns::format * pp_fdecl_ref(func_decl * f) {
format_ns::format * pp_fdecl_ref(func_decl * f) override {
symbol s = f->get_name();
func_decls fs;
if (m_owner.m_func_decls.find(s, fs) && fs.contains(f)) {

36
src/cmd_context/cmd_context.h
View file

@ -112,10 +112,10 @@ class ast_object_ref : public object_ref {
ast * m_ast;
public:
ast_object_ref(cmd_context & ctx, ast * a);
virtual void finalize(cmd_context & ctx);
void finalize(cmd_context & ctx) override;
ast * get_ast() const { return m_ast; }
static char const * cls_kind() { return "AST"; }
virtual char const * kind() const { return cls_kind(); }
char const * kind() const override { return cls_kind(); }
};
class stream_ref {
@ -250,8 +250,8 @@ protected:
datatype_util m_dt_util;
public:
dt_eh(cmd_context & owner);
virtual ~dt_eh();
virtual void operator()(sort * dt, pdecl* pd);
~dt_eh() override;
void operator()(sort * dt, pdecl* pd) override;
};
friend class dt_eh;
@ -307,7 +307,7 @@ protected:
public:
cmd_context(bool main_ctx = true, ast_manager * m = 0, symbol const & l = symbol::null);
~cmd_context();
~cmd_context() override;
void set_cancel(bool f);
context_params & params() { return m_params; }
solver_factory &get_solver_factory() { return *m_solver_factory; }
@ -354,7 +354,7 @@ public:
bool has_manager() const { return m_manager != 0; }
ast_manager & m() const { const_cast<cmd_context*>(this)->init_manager(); return *m_manager; }
virtual ast_manager & get_ast_manager() { return m(); }
ast_manager & get_ast_manager() override { return m(); }
pdecl_manager & pm() const { if (!m_pmanager) const_cast<cmd_context*>(this)->init_manager(); return *m_pmanager; }
sexpr_manager & sm() const { if (!m_sexpr_manager) const_cast<cmd_context*>(this)->m_sexpr_manager = alloc(sexpr_manager); return *m_sexpr_manager; }
@ -407,8 +407,8 @@ public:
void set_regular_stream(char const * name) { m_regular.set(name); }
void set_regular_stream(std::ostream& out) { m_regular.set(out); }
void set_diagnostic_stream(char const * name);
virtual std::ostream & regular_stream() { return *m_regular; }
virtual std::ostream & diagnostic_stream() { return *m_diagnostic; }
std::ostream & regular_stream() override { return *m_regular; }
std::ostream & diagnostic_stream() override { return *m_diagnostic; }
char const * get_regular_stream_name() const { return m_regular.name(); }
char const * get_diagnostic_stream_name() const { return m_diagnostic.name(); }
typedef dictionary<cmd*>::iterator cmd_iterator;
@ -462,14 +462,14 @@ public:
}
format_ns::format * pp(sort * s) const;
virtual void pp(sort * s, format_ns::format_ref & r) const { r = pp(s); }
virtual void pp(func_decl * f, format_ns::format_ref & r) const;
virtual void pp(expr * n, unsigned num_vars, char const * var_prefix, format_ns::format_ref & r, sbuffer<symbol> & var_names) const;
virtual void pp(expr * n, format_ns::format_ref & r) const;
virtual void display(std::ostream & out, sort * s, unsigned indent = 0) const;
virtual void display(std::ostream & out, expr * n, unsigned indent, unsigned num_vars, char const * var_prefix, sbuffer<symbol> & var_names) const;
virtual void display(std::ostream & out, expr * n, unsigned indent = 0) const;
virtual void display(std::ostream & out, func_decl * f, unsigned indent = 0) const;
void pp(sort * s, format_ns::format_ref & r) const override { r = pp(s); }
void pp(func_decl * f, format_ns::format_ref & r) const override;
void pp(expr * n, unsigned num_vars, char const * var_prefix, format_ns::format_ref & r, sbuffer<symbol> & var_names) const override;
void pp(expr * n, format_ns::format_ref & r) const override;
void display(std::ostream & out, sort * s, unsigned indent = 0) const override;
void display(std::ostream & out, expr * n, unsigned indent, unsigned num_vars, char const * var_prefix, sbuffer<symbol> & var_names) const override;
void display(std::ostream & out, expr * n, unsigned indent = 0) const override;
void display(std::ostream & out, func_decl * f, unsigned indent = 0) const override;
// dump assertions in out using the pretty printer.
void dump_assertions(std::ostream & out) const;
@ -478,8 +478,8 @@ public:
void display_smt2_benchmark(std::ostream & out, unsigned num, expr * const * assertions, symbol const & logic = symbol::null) const;
virtual void slow_progress_sample();
virtual void fast_progress_sample();
void slow_progress_sample() override;
void fast_progress_sample() override;
};
std::ostream & operator<<(std::ostream & out, cmd_context::status st);

22
src/cmd_context/echo_tactic.cpp
View file

@ -27,11 +27,11 @@ class echo_tactic : public skip_tactic {
public:
echo_tactic(cmd_context & ctx, char const * msg, bool newline):m_ctx(ctx), m_msg(msg), m_newline(newline) {}
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 {
#pragma omp critical (echo_tactic)
{
m_ctx.regular_stream() << m_msg;
@ -57,15 +57,15 @@ public:
m_p->inc_ref();
}
~probe_value_tactic() {
~probe_value_tactic() override {
m_p->dec_ref();
}
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 {
double val = (*m_p)(*(in.get())).get_value();
#pragma omp critical (probe_value_tactic)
{

14
src/cmd_context/eval_cmd.cpp
View file

@ -29,33 +29,33 @@ class eval_cmd : public parametric_cmd {
public:
eval_cmd():parametric_cmd("eval") {}
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 "evaluate the given term in the current model.";
}
virtual void init_pdescrs(cmd_context & ctx, param_descrs & p) {
void init_pdescrs(cmd_context & ctx, param_descrs & p) override {
model_evaluator::get_param_descrs(p);
insert_timeout(p);
p.insert("model_index", CPK_UINT, "(default: 0) index of model from box optimization objective");
}
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 {
if (!ctx.is_model_available())
throw cmd_exception("model is not available");
if (!m_target)

60
src/cmd_context/extra_cmds/dbg_cmds.cpp
View file

@ -104,15 +104,15 @@ class subst_cmd : public cmd {
ptr_vector<expr> m_subst;
public:
subst_cmd():cmd("dbg-subst") {}
virtual char const * get_usage() const { return "<symbol> (<symbol>*) <symbol>"; }
virtual char const * get_descr(cmd_context & ctx) const { return "substitute the free variables in the AST referenced by <symbol> using the ASTs referenced by <symbol>*"; }
virtual unsigned get_arity() const { return 3; }
virtual void prepare(cmd_context & ctx) { m_idx = 0; m_source = 0; }
virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const {
char const * get_usage() const override { return "<symbol> (<symbol>*) <symbol>"; }
char const * get_descr(cmd_context & ctx) const override { return "substitute the free variables in the AST referenced by <symbol> using the ASTs referenced by <symbol>*"; }
unsigned get_arity() const override { return 3; }
void prepare(cmd_context & ctx) override { m_idx = 0; m_source = 0; }
cmd_arg_kind next_arg_kind(cmd_context & ctx) const override {
if (m_idx == 1) return CPK_SYMBOL_LIST;
return CPK_SYMBOL;
}
virtual void set_next_arg(cmd_context & ctx, symbol const & s) {
void set_next_arg(cmd_context & ctx, symbol const & s) override {
if (m_idx == 0) {
m_source = get_expr_ref(ctx, s);
}
@ -121,7 +121,7 @@ public:
}
m_idx++;
}
virtual void set_next_arg(cmd_context & ctx, unsigned num, symbol const * s) {
void set_next_arg(cmd_context & ctx, unsigned num, symbol const * s) override {
m_subst.reset();
unsigned i = num;
while (i > 0) {
@ -130,7 +130,7 @@ public:
}
m_idx++;
}
virtual void execute(cmd_context & ctx) {
void execute(cmd_context & ctx) override {
expr_ref r(ctx.m());
beta_reducer p(ctx.m());
p(m_source, m_subst.size(), m_subst.c_ptr(), r);
@ -179,18 +179,18 @@ class lt_cmd : public cmd {
expr * m_t2;
public:
lt_cmd():cmd("dbg-lt") {}
virtual char const * get_usage() const { return "<term> <term>"; }
virtual char const * get_descr(cmd_context & ctx) const { return "return true if the first term is smaller than the second one in the internal Z3 total order on terms."; }
virtual unsigned get_arity() const { return 2; }
virtual void prepare(cmd_context & ctx) { m_t1 = 0; }
virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const { return CPK_EXPR; }
virtual void set_next_arg(cmd_context & ctx, expr * arg) {
char const * get_usage() const override { return "<term> <term>"; }
char const * get_descr(cmd_context & ctx) const override { return "return true if the first term is smaller than the second one in the internal Z3 total order on terms."; }
unsigned get_arity() const override { return 2; }
void prepare(cmd_context & ctx) override { m_t1 = 0; }
cmd_arg_kind next_arg_kind(cmd_context & ctx) const override { return CPK_EXPR; }
void set_next_arg(cmd_context & ctx, expr * arg) override {
if (m_t1 == 0)
m_t1 = arg;
else
m_t2 = arg;
}
virtual void execute(cmd_context & ctx) {
void execute(cmd_context & ctx) override {
bool r = lt(m_t1, m_t2);
ctx.regular_stream() << (r ? "true" : "false") << std::endl;
}
@ -283,23 +283,23 @@ protected:
ptr_vector<expr> m_args;
public:
instantiate_cmd_core(char const * name):cmd(name) {}
virtual char const * get_usage() const { return "<quantifier> (<symbol>*)"; }
virtual char const * get_descr(cmd_context & ctx) const { return "instantiate the quantifier using the given expressions."; }
virtual unsigned get_arity() const { return 2; }
virtual void prepare(cmd_context & ctx) { m_q = 0; m_args.reset(); }
char const * get_usage() const override { return "<quantifier> (<symbol>*)"; }
char const * get_descr(cmd_context & ctx) const override { return "instantiate the quantifier using the given expressions."; }
unsigned get_arity() const override { return 2; }
void prepare(cmd_context & ctx) override { m_q = 0; m_args.reset(); }
virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const {
cmd_arg_kind next_arg_kind(cmd_context & ctx) const override {
if (m_q == 0) return CPK_EXPR;
else return CPK_EXPR_LIST;
}
virtual void set_next_arg(cmd_context & ctx, expr * s) {
void set_next_arg(cmd_context & ctx, expr * s) override {
if (!is_quantifier(s))
throw cmd_exception("invalid command, quantifier expected.");
m_q = to_quantifier(s);
}
virtual void set_next_arg(cmd_context & ctx, unsigned num, expr * const * ts) {
void set_next_arg(cmd_context & ctx, unsigned num, expr * const * ts) override {
if (num != m_q->get_num_decls())
throw cmd_exception("invalid command, mismatch between the number of quantified variables and the number of arguments.");
unsigned i = num;
@ -315,7 +315,7 @@ public:
m_args.append(num, ts);
}
virtual void execute(cmd_context & ctx) {
void execute(cmd_context & ctx) override {
expr_ref r(ctx.m());
instantiate(ctx.m(), m_q, m_args.c_ptr(), r);
ctx.display(ctx.regular_stream(), r);
@ -332,9 +332,9 @@ class instantiate_nested_cmd : public instantiate_cmd_core {
public:
instantiate_nested_cmd():instantiate_cmd_core("dbg-instantiate-nested") {}
virtual char const * get_descr(cmd_context & ctx) const { return "instantiate the quantifier nested in the outermost quantifier, this command is used to test the instantiation procedure with quantifiers that contain free variables."; }
char const * get_descr(cmd_context & ctx) const override { return "instantiate the quantifier nested in the outermost quantifier, this command is used to test the instantiation procedure with quantifiers that contain free variables."; }
virtual void set_next_arg(cmd_context & ctx, expr * s) {
void set_next_arg(cmd_context & ctx, expr * s) override {
instantiate_cmd_core::set_next_arg(ctx, s);
if (!is_quantifier(m_q->get_expr()))
throw cmd_exception("invalid command, nested quantifier expected");
@ -345,11 +345,11 @@ public:
class print_dimacs_cmd : public cmd {
public:
print_dimacs_cmd():cmd("display-dimacs") {}
virtual char const * get_usage() const { return ""; }
virtual char const * get_descr(cmd_context & ctx) const { return "print benchmark in DIMACS format"; }
virtual unsigned get_arity() const { return 0; }
virtual void prepare(cmd_context & ctx) {}
virtual void execute(cmd_context & ctx) { ctx.display_dimacs(); }
char const * get_usage() const override { return ""; }
char const * get_descr(cmd_context & ctx) const override { return "print benchmark in DIMACS format"; }
unsigned get_arity() const override { return 0; }
void prepare(cmd_context & ctx) override {}
void execute(cmd_context & ctx) override { ctx.display_dimacs(); }
};

32
src/cmd_context/extra_cmds/polynomial_cmds.cpp
View file

@ -164,33 +164,33 @@ class poly_isolate_roots_cmd : public cmd {
public:
poly_isolate_roots_cmd(char const * name = "poly/isolate-roots"):cmd(name), m_ctx(0) {}
virtual char const * get_usage() const { return "<term> (<term> <value>)*"; }
char const * get_usage() const override { return "<term> (<term> <value>)*"; }
virtual char const * get_descr(cmd_context & ctx) const { return "isolate the roots a multivariate polynomial modulo an assignment"; }
char const * get_descr(cmd_context & ctx) const override { return "isolate the roots a multivariate polynomial modulo an assignment"; }
virtual unsigned get_arity() const { return VAR_ARITY; }
unsigned get_arity() const override { return VAR_ARITY; }
virtual void prepare(cmd_context & ctx) {
void prepare(cmd_context & ctx) override {
m_ctx = alloc(context, ctx.m());
}
virtual void finalize(cmd_context & ctx) {
void finalize(cmd_context & ctx) override {
m_ctx = 0;
}
virtual void failure_cleanup(cmd_context & ctx) {
void failure_cleanup(cmd_context & ctx) override {
m_ctx = 0;
}
virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const {
cmd_arg_kind next_arg_kind(cmd_context & ctx) const override {
return CPK_EXPR;
}
virtual void set_next_arg(cmd_context & ctx, expr * arg) {
void set_next_arg(cmd_context & ctx, expr * arg) override {
m_ctx->set_next_arg(ctx, arg);
}
virtual void execute(cmd_context & ctx) {
void execute(cmd_context & ctx) override {
m_ctx->execute(ctx);
m_ctx = 0;
}
@ -204,31 +204,31 @@ class poly_factor_cmd : public parametric_cmd {
public:
poly_factor_cmd(char const * name = "poly/factor"):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 "factor a polynomial";
}
virtual void init_pdescrs(cmd_context & ctx, param_descrs & p) {
void init_pdescrs(cmd_context & ctx, param_descrs & p) override {
polynomial::factor_params::get_param_descrs(p);
}
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 {
polynomial::factor_params ps;
ps.updt_params(m_params);
factor(ctx, m_target, ps);

16
src/cmd_context/interpolant_cmds.cpp
View file

@ -219,29 +219,29 @@ protected:
public:
get_interpolant_cmd(char const * name = "get-interpolant"):parametric_cmd(name) {}
virtual char const * get_usage() const { return "<fmla>+"; }
char const * get_usage() const override { return "<fmla>+"; }
virtual char const * get_main_descr() const {
char const * get_main_descr() const override {
return "get interpolant for formulas";
}
virtual void init_pdescrs(cmd_context & ctx, param_descrs & p) {
void init_pdescrs(cmd_context & ctx, param_descrs & p) override {
}
virtual void prepare(cmd_context & ctx) {
void prepare(cmd_context & ctx) override {
parametric_cmd::prepare(ctx);
m_targets.resize(0);
}
virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const {
cmd_arg_kind next_arg_kind(cmd_context & ctx) const override {
return CPK_EXPR;
}
virtual void set_next_arg(cmd_context & ctx, expr * arg) {
void set_next_arg(cmd_context & ctx, expr * arg) override {
m_targets.push_back(arg);
}
virtual void execute(cmd_context & ctx) {
void execute(cmd_context & ctx) override {
get_interpolant(ctx,m_targets,m_params);
}
};
@ -250,7 +250,7 @@ class compute_interpolant_cmd : public get_interpolant_cmd {
public:
compute_interpolant_cmd(char const * name = "compute-interpolant"):get_interpolant_cmd(name) {}
virtual void execute(cmd_context & ctx) {
void execute(cmd_context & ctx) override {
compute_interpolant(ctx,m_targets,m_params);
}

28
src/cmd_context/parametric_cmd.h
View file

@ -31,48 +31,48 @@ public:
scoped_ptr<param_descrs> m_pdescrs;
public:
parametric_cmd(char const * name):cmd(name), m_descr(0) {}
virtual ~parametric_cmd() { if (m_descr) dealloc(m_descr); }
~parametric_cmd() override { if (m_descr) dealloc(m_descr); }
virtual void init_pdescrs(cmd_context & ctx, param_descrs & d) = 0;
param_descrs const & pdescrs(cmd_context & ctx) const;
params_ref const & ps() const { return m_params; }
virtual char const * get_main_descr() const = 0;
virtual char const * get_descr(cmd_context & ctx) const;
virtual unsigned get_arity() const { return VAR_ARITY; }
virtual void prepare(cmd_context & ctx) { m_last = symbol::null; m_params.reset(); }
virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const;
virtual void set_next_arg(cmd_context & ctx, symbol const & s);
virtual void set_next_arg(cmd_context & ctx, unsigned val) {
char const * get_descr(cmd_context & ctx) const override;
unsigned get_arity() const override { return VAR_ARITY; }
void prepare(cmd_context & ctx) override { m_last = symbol::null; m_params.reset(); }
cmd_arg_kind next_arg_kind(cmd_context & ctx) const override;
void set_next_arg(cmd_context & ctx, symbol const & s) override;
void set_next_arg(cmd_context & ctx, unsigned val) override {
m_params.set_uint(m_last, val);
m_last = symbol::null;
}
virtual void set_next_arg(cmd_context & ctx, bool val) {
void set_next_arg(cmd_context & ctx, bool val) override {
m_params.set_bool(m_last, val);
m_last = symbol::null;
}
virtual void set_next_arg(cmd_context & ctx, rational const & val) {
void set_next_arg(cmd_context & ctx, rational const & val) override {
m_params.set_rat(m_last, val);
m_last = symbol::null;
}
virtual void set_next_arg(cmd_context & ctx, char const * val) {
void set_next_arg(cmd_context & ctx, char const * val) override {
m_params.set_str(m_last, val);
m_last = symbol::null;
}
virtual void set_next_arg(cmd_context & ctx, sort * s) {
void set_next_arg(cmd_context & ctx, sort * s) override {
NOT_IMPLEMENTED_YET();
// m_params.set_sort(m_last, s);
// m_last = symbol::null;
}
virtual void set_next_arg(cmd_context & ctx, expr * t) {
void set_next_arg(cmd_context & ctx, expr * t) override {
NOT_IMPLEMENTED_YET();
// m_params.set_expr(m_last, t);
// m_last = symbol::null;
}
virtual void set_next_arg(cmd_context & ctx, func_decl * f) {
void set_next_arg(cmd_context & ctx, func_decl * f) override {
NOT_IMPLEMENTED_YET();
// m_params.set_func_decl(m_last, f);
// m_last = symbol::null;
}
virtual void set_next_arg(cmd_context & ctx, sexpr * n) { UNREACHABLE(); }
void set_next_arg(cmd_context & ctx, sexpr * n) override { UNREACHABLE(); }
};
#endif

68
src/cmd_context/pdecl.cpp
View file

@ -136,25 +136,25 @@ class psort_sort : public psort {
friend class pdecl_manager;
sort * m_sort;
psort_sort(unsigned id, pdecl_manager & m, sort * s):psort(id, 0), m_sort(s) { m.m().inc_ref(m_sort); }
virtual void finalize(pdecl_manager & m) {
void finalize(pdecl_manager & m) override {
m.m().dec_ref(m_sort);
psort::finalize(m);
}
virtual bool check_num_params(pdecl * other) const { return true; }
virtual size_t obj_size() const { return sizeof(psort_sort); }
bool check_num_params(pdecl * other) const override { return true; }
size_t obj_size() const override { return sizeof(psort_sort); }
sort * get_sort() const { return m_sort; }
virtual sort * instantiate(pdecl_manager & m, sort * const * s) { return m_sort; }
sort * instantiate(pdecl_manager & m, sort * const * s) override { return m_sort; }
public:
virtual ~psort_sort() {}
virtual bool is_sort_wrapper() const { return true; }
virtual char const * hcons_kind() const { return "psort_sort"; }
virtual unsigned hcons_hash() const { return m_sort->get_id(); }
virtual bool hcons_eq(psort const * other) const {
~psort_sort() override {}
bool is_sort_wrapper() const override { return true; }
char const * hcons_kind() const override { return "psort_sort"; }
unsigned hcons_hash() const override { return m_sort->get_id(); }
bool hcons_eq(psort const * other) const override {
if (other->hcons_kind() != hcons_kind())
return false;
return m_sort == static_cast<psort_sort const *>(other)->m_sort;
}
virtual void display(std::ostream & out) const {
void display(std::ostream & out) const override {
out << m_sort->get_name();
}
};
@ -163,19 +163,19 @@ class psort_var : public psort {
friend class pdecl_manager;
unsigned m_idx;
psort_var(unsigned id, unsigned num_params, unsigned idx):psort(id, num_params), m_idx(idx) { SASSERT(idx < num_params); }
virtual sort * instantiate(pdecl_manager & m, sort * const * s) { return s[m_idx]; }
virtual size_t obj_size() const { return sizeof(psort_var); }
sort * instantiate(pdecl_manager & m, sort * const * s) override { return s[m_idx]; }
size_t obj_size() const override { return sizeof(psort_var); }
public:
virtual ~psort_var() {}
virtual char const * hcons_kind() const { return "psort_var"; }
virtual unsigned hcons_hash() const { return hash_u_u(m_num_params, m_idx); }
virtual bool hcons_eq(psort const * other) const {
~psort_var() override {}
char const * hcons_kind() const override { return "psort_var"; }
unsigned hcons_hash() const override { return hash_u_u(m_num_params, m_idx); }
bool hcons_eq(psort const * other) const override {
return
other->hcons_kind() == hcons_kind() &&
get_num_params() == other->get_num_params() &&
m_idx == static_cast<psort_var const *>(other)->m_idx;
}
virtual void display(std::ostream & out) const {
void display(std::ostream & out) const override {
out << "s_" << m_idx;
}
unsigned idx() const { return m_idx; }
@ -196,13 +196,13 @@ class psort_app : public psort {
DEBUG_CODE(if (num_args == num_params) { for (unsigned i = 0; i < num_params; i++) args[i]->check_num_params(this); });
}
virtual void finalize(pdecl_manager & m) {
void finalize(pdecl_manager & m) override {
m.lazy_dec_ref(m_decl);
m.lazy_dec_ref(m_args.size(), m_args.c_ptr());
psort::finalize(m);
}
virtual size_t obj_size() const { return sizeof(psort_app); }
size_t obj_size() const override { return sizeof(psort_app); }
struct khasher {
unsigned operator()(psort_app const * d) const { return d->m_decl->hash(); }
@ -212,7 +212,7 @@ class psort_app : public psort {
unsigned operator()(psort_app const * d, unsigned idx) const { return d->m_args[idx]->hash(); }
};
virtual sort * instantiate(pdecl_manager & m, sort * const * s) {
sort * instantiate(pdecl_manager & m, sort * const * s) override {
sort * r = find(s);
if (r)
return r;
@ -228,12 +228,12 @@ class psort_app : public psort {
}
public:
virtual ~psort_app() {}
virtual char const * hcons_kind() const { return "psort_app"; }
virtual unsigned hcons_hash() const {
~psort_app() override {}
char const * hcons_kind() const override { return "psort_app"; }
unsigned hcons_hash() const override {
return get_composite_hash<psort_app*, khasher, chasher>(const_cast<psort_app*>(this), m_args.size());
}
virtual bool hcons_eq(psort const * other) const {
bool hcons_eq(psort const * other) const override {
if (other->hcons_kind() != hcons_kind())
return false;
if (get_num_params() != other->get_num_params())
@ -249,7 +249,7 @@ public:
}
return true;
}
virtual void display(std::ostream & out) const {
void display(std::ostream & out) const override {
if (m_args.empty()) {
out << m_decl->get_name();
}
@ -752,16 +752,16 @@ struct pdecl_manager::app_sort_info : public pdecl_manager::sort_info {
m.m().inc_array_ref(n, s);
}
virtual ~app_sort_info() {}
~app_sort_info() override {}
virtual unsigned obj_size() const { return sizeof(app_sort_info); }
unsigned obj_size() const override { return sizeof(app_sort_info); }
virtual void finalize(pdecl_manager & m) {
void finalize(pdecl_manager & m) override {
sort_info::finalize(m);
m.m().dec_array_ref(m_args.size(), m_args.c_ptr());
}
virtual void display(std::ostream & out, pdecl_manager const & m) const {
void display(std::ostream & out, pdecl_manager const & m) const override {
if (m_args.empty()) {
out << m_decl->get_name();
}
@ -775,7 +775,7 @@ struct pdecl_manager::app_sort_info : public pdecl_manager::sort_info {
}
}
virtual format * pp(pdecl_manager const & m) const {
format * pp(pdecl_manager const & m) const override {
if (m_args.empty()) {
return mk_string(m.m(), m_decl->get_name().str().c_str());
}
@ -796,11 +796,11 @@ struct pdecl_manager::indexed_sort_info : public pdecl_manager::sort_info {
m_indices(n, s) {
}
virtual ~indexed_sort_info() {}
~indexed_sort_info() override {}
virtual unsigned obj_size() const { return sizeof(indexed_sort_info); }
unsigned obj_size() const override { return sizeof(indexed_sort_info); }
virtual void display(std::ostream & out, pdecl_manager const & m) const {
void display(std::ostream & out, pdecl_manager const & m) const override {
if (m_indices.empty()) {
out << m_decl->get_name();
}
@ -813,7 +813,7 @@ struct pdecl_manager::indexed_sort_info : public pdecl_manager::sort_info {
}
}
virtual format * pp(pdecl_manager const & m) const {
format * pp(pdecl_manager const & m) const override {
if (m_indices.empty()) {
return mk_string(m.m(), m_decl->get_name().str().c_str());
}

74
src/cmd_context/pdecl.h
View file

@ -65,9 +65,9 @@ protected:
psort_inst_cache * m_inst_cache;
friend class pdecl_manager;
psort(unsigned id, unsigned num_params):pdecl(id, num_params), m_inst_cache(0) {}
virtual bool is_psort() const { return true; }
virtual void finalize(pdecl_manager & m);
virtual ~psort() {}
bool is_psort() const override { return true; }
void finalize(pdecl_manager & m) override;
~psort() override {}
virtual void cache(pdecl_manager & m, sort * const * s, sort * r);
virtual sort * find(sort * const * s) const;
public:
@ -77,7 +77,7 @@ public:
virtual char const * hcons_kind() const = 0;
virtual unsigned hcons_hash() const = 0;
virtual bool hcons_eq(psort const * other) const = 0;
virtual void reset_cache(pdecl_manager& m);
void reset_cache(pdecl_manager& m) override;
};
// for hash consing
@ -98,8 +98,8 @@ protected:
void cache(pdecl_manager & m, sort * const * s, sort * r);
sort * find(sort * const * s);
psort_decl(unsigned id, unsigned num_params, pdecl_manager & m, symbol const & n);
virtual void finalize(pdecl_manager & m);
virtual ~psort_decl() {}
void finalize(pdecl_manager & m) override;
~psort_decl() override {}
public:
virtual sort * instantiate(pdecl_manager & m, unsigned n, sort * const * s) = 0;
virtual sort * instantiate(pdecl_manager & m, unsigned n, unsigned const * s) { return 0; }
@ -108,7 +108,7 @@ public:
// Only builtin declarations can have a variable number of parameters.
bool has_var_params() const { return m_num_params == PSORT_DECL_VAR_PARAMS; }
symbol const & get_name() const { return m_name; }
virtual void reset_cache(pdecl_manager& m);
void reset_cache(pdecl_manager& m) override;
bool is_user_decl() const { return m_psort_kind == PSORT_USER; }
bool is_builtin_decl() const { return m_psort_kind == PSORT_BUILTIN; }
bool is_dt_decl() const { return m_psort_kind == PSORT_DT; }
@ -119,12 +119,12 @@ protected:
friend class pdecl_manager;
psort * m_def;
psort_user_decl(unsigned id, unsigned num_params, pdecl_manager & m, symbol const & n, psort * p);
virtual size_t obj_size() const { return sizeof(psort_user_decl); }
virtual void finalize(pdecl_manager & m);
virtual ~psort_user_decl() {}
size_t obj_size() const override { return sizeof(psort_user_decl); }
void finalize(pdecl_manager & m) override;
~psort_user_decl() override {}
public:
virtual sort * instantiate(pdecl_manager & m, unsigned n, sort * const * s);
virtual void display(std::ostream & out) const;
sort * instantiate(pdecl_manager & m, unsigned n, sort * const * s) override;
void display(std::ostream & out) const override;
};
class psort_builtin_decl : public psort_decl {
@ -133,23 +133,23 @@ protected:
family_id m_fid;
decl_kind m_kind;
psort_builtin_decl(unsigned id, pdecl_manager & m, symbol const & n, family_id fid, decl_kind k);
virtual size_t obj_size() const { return sizeof(psort_builtin_decl); }
virtual ~psort_builtin_decl() {}
size_t obj_size() const override { return sizeof(psort_builtin_decl); }
~psort_builtin_decl() override {}
public:
virtual sort * instantiate(pdecl_manager & m, unsigned n, sort * const * s);
virtual sort * instantiate(pdecl_manager & m, unsigned n, unsigned const * s);
virtual void display(std::ostream & out) const;
sort * instantiate(pdecl_manager & m, unsigned n, sort * const * s) override;
sort * instantiate(pdecl_manager & m, unsigned n, unsigned const * s) override;
void display(std::ostream & out) const override;
};
class psort_dt_decl : public psort_decl {
protected:
friend class pdecl_manager;
psort_dt_decl(unsigned id, unsigned num_params, pdecl_manager & m, symbol const & n);
virtual size_t obj_size() const { return sizeof(psort_dt_decl); }
virtual ~psort_dt_decl() {}
size_t obj_size() const override { return sizeof(psort_dt_decl); }
~psort_dt_decl() override {}
public:
virtual sort * instantiate(pdecl_manager & m, unsigned n, sort * const * s);
virtual void display(std::ostream & out) const;
sort * instantiate(pdecl_manager & m, unsigned n, sort * const * s) override;
void display(std::ostream & out) const override;
};
@ -190,16 +190,16 @@ class paccessor_decl : public pdecl {
symbol m_name;
ptype m_type;
paccessor_decl(unsigned id, unsigned num_params, pdecl_manager & m, symbol const & n, ptype const & r);
virtual void finalize(pdecl_manager & m);
virtual size_t obj_size() const { return sizeof(paccessor_decl); }
void finalize(pdecl_manager & m) override;
size_t obj_size() const override { return sizeof(paccessor_decl); }
bool has_missing_refs(symbol & missing) const;
bool fix_missing_refs(dictionary<int> const & symbol2idx, symbol & missing);
accessor_decl * instantiate_decl(pdecl_manager & m, sort * const * s);
symbol const & get_name() const { return m_name; }
ptype const & get_type() const { return m_type; }
virtual ~paccessor_decl() {}
~paccessor_decl() override {}
public:
virtual void display(std::ostream & out) const { pdecl::display(out); }
void display(std::ostream & out) const override { pdecl::display(out); }
void display(std::ostream & out, pdatatype_decl const * const * dts) const;
};
@ -211,16 +211,16 @@ class pconstructor_decl : public pdecl {
ptr_vector<paccessor_decl> m_accessors;
pconstructor_decl(unsigned id, unsigned num_params, pdecl_manager & m,
symbol const & n, symbol const & r, unsigned num_accessors, paccessor_decl * const * accessors);
virtual void finalize(pdecl_manager & m);
virtual size_t obj_size() const { return sizeof(pconstructor_decl); }
void finalize(pdecl_manager & m) override;
size_t obj_size() const override { return sizeof(pconstructor_decl); }
bool has_missing_refs(symbol & missing) const;
bool fix_missing_refs(dictionary<int> const & symbol2idx, symbol & missing);
symbol const & get_name() const { return m_name; }
symbol const & get_recognizer_name() const { return m_recogniser_name; }
constructor_decl * instantiate_decl(pdecl_manager & m, sort * const * s);
virtual ~pconstructor_decl() {}
~pconstructor_decl() override {}
public:
virtual void display(std::ostream & out) const { pdecl::display(out); }
void display(std::ostream & out) const override { pdecl::display(out); }
void display(std::ostream & out, pdatatype_decl const * const * dts) const;
};
@ -231,14 +231,14 @@ class pdatatype_decl : public psort_decl {
pdatatypes_decl * m_parent;
pdatatype_decl(unsigned id, unsigned num_params, pdecl_manager & m, symbol const & n,
unsigned num_constructors, pconstructor_decl * const * constructors);
virtual void finalize(pdecl_manager & m);
virtual size_t obj_size() const { return sizeof(pdatatype_decl); }
void finalize(pdecl_manager & m) override;
size_t obj_size() const override { return sizeof(pdatatype_decl); }
bool fix_missing_refs(dictionary<int> const & symbol2idx, symbol & missing);
datatype_decl * instantiate_decl(pdecl_manager & m, sort * const * s);
virtual ~pdatatype_decl() {}
~pdatatype_decl() override {}
public:
sort * instantiate(pdecl_manager & m, unsigned n, sort * const * s);
virtual void display(std::ostream & out) const;
sort * instantiate(pdecl_manager & m, unsigned n, sort * const * s) override;
void display(std::ostream & out) const override;
bool has_missing_refs(symbol & missing) const;
bool has_duplicate_accessors(symbol & repeated) const;
bool commit(pdecl_manager& m);
@ -252,11 +252,11 @@ class pdatatypes_decl : public pdecl {
friend class pdatatype_decl;
ptr_vector<pdatatype_decl> m_datatypes;
pdatatypes_decl(unsigned id, unsigned num_params, pdecl_manager & m, unsigned num_datatypes, pdatatype_decl * const * dts);
virtual void finalize(pdecl_manager & m);
virtual size_t obj_size() const { return sizeof(pdatatypes_decl); }
void finalize(pdecl_manager & m) override;
size_t obj_size() const override { return sizeof(pdatatypes_decl); }
bool fix_missing_refs(symbol & missing);
bool instantiate(pdecl_manager & m, sort * const * s);
virtual ~pdatatypes_decl() {}
~pdatatypes_decl() override {}
public:
pdatatype_decl const * const * children() const { return m_datatypes.c_ptr(); }
pdatatype_decl * const * begin() const { return m_datatypes.begin(); }

18
src/cmd_context/simplify_cmd.cpp
View file

@ -36,7 +36,7 @@ class simplify_cmd : public parametric_cmd {
public:
th_solver(cmd_context& ctx): m_ctx(ctx) {}
virtual lbool check_sat(expr* e) {
lbool check_sat(expr* e) override {
if (!m_solver) {
m_solver = m_ctx.get_solver_factory()(m_ctx.m(), m_params, false, true, false, symbol::null);
}
@ -52,13 +52,13 @@ class simplify_cmd : public parametric_cmd {
public:
simplify_cmd(char const * name = "simplify"):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 "simplify the given term using builtin theory simplification rules.";
}
virtual void init_pdescrs(cmd_context & ctx, param_descrs & p) {
void init_pdescrs(cmd_context & ctx, param_descrs & p) override {
th_rewriter::get_param_descrs(p);
insert_timeout(p);
p.insert("print", CPK_BOOL, "(default: true) print the simplified term.");
@ -66,24 +66,24 @@ public:
p.insert("print_statistics", CPK_BOOL, "(default: false) print statistics.");
}
virtual ~simplify_cmd() {
~simplify_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 {
if (m_target == 0)
throw cmd_exception("invalid simplify command, argument expected");
expr_ref r(ctx.m());

40
src/cmd_context/tactic_cmds.cpp
View file

@ -58,17 +58,17 @@ public:
m_decl(0) {
}
virtual char const * get_usage() const { return "<symbol> <tactic>"; }
virtual char const * get_descr(cmd_context & ctx) const { return "declare a new tactic, use (help-tactic) for the tactic language syntax."; }
virtual unsigned get_arity() const { return 2; }
virtual void prepare(cmd_context & ctx) { m_name = symbol::null; m_decl = 0; }
virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const {
char const * get_usage() const override { return "<symbol> <tactic>"; }
char const * get_descr(cmd_context & ctx) const override { return "declare a new tactic, use (help-tactic) for the tactic language syntax."; }
unsigned get_arity() const override { return 2; }
void prepare(cmd_context & ctx) override { m_name = symbol::null; m_decl = 0; }
cmd_arg_kind next_arg_kind(cmd_context & ctx) const override {
if (m_name == symbol::null) return CPK_SYMBOL;
return CPK_SEXPR;
}
virtual void set_next_arg(cmd_context & ctx, symbol const & s) { m_name = s; }
virtual void set_next_arg(cmd_context & ctx, sexpr * n) { m_decl = n; }
virtual void execute(cmd_context & ctx) {
void set_next_arg(cmd_context & ctx, symbol const & s) override { m_name = s; }
void set_next_arg(cmd_context & ctx, sexpr * n) override { m_decl = n; }
void execute(cmd_context & ctx) override {
tactic_ref t = sexpr2tactic(ctx, m_decl); // make sure the tactic is well formed.
ctx.insert_user_tactic(m_name, m_decl);
}
@ -133,23 +133,23 @@ public:
parametric_cmd(name) {
}
virtual char const * get_usage() const { return "<tactic> (<keyword> <value>)*"; }
char const * get_usage() const override { return "<tactic> (<keyword> <value>)*"; }
virtual void prepare(cmd_context & ctx) {
void prepare(cmd_context & ctx) override {
parametric_cmd::prepare(ctx);
m_tactic = 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_tactic == 0) return CPK_SEXPR;
return parametric_cmd::next_arg_kind(ctx);
}
virtual void set_next_arg(cmd_context & ctx, sexpr * arg) {
void set_next_arg(cmd_context & ctx, sexpr * arg) override {
m_tactic = arg;
}
virtual void init_pdescrs(cmd_context & ctx, param_descrs & p) {
void init_pdescrs(cmd_context & ctx, param_descrs & p) override {
insert_timeout(p);
insert_max_memory(p);
p.insert("print_statistics", CPK_BOOL, "(default: false) print statistics.");
@ -172,7 +172,7 @@ public:
check_sat_tactic_result(ast_manager & m) : simple_check_sat_result(m) {
}
virtual void get_labels(svector<symbol> & r) {
void get_labels(svector<symbol> & r) override {
r.append(labels);
}
@ -187,16 +187,16 @@ public:
exec_given_tactic_cmd("check-sat-using") {
}
virtual char const * get_main_descr() const { return "check if the current context is satisfiable using the given tactic, use (help-tactic) for the tactic language syntax."; }
char const * get_main_descr() const override { return "check if the current context is satisfiable using the given tactic, use (help-tactic) for the tactic language syntax."; }
virtual void init_pdescrs(cmd_context & ctx, param_descrs & p) {
void init_pdescrs(cmd_context & ctx, param_descrs & p) override {
exec_given_tactic_cmd::init_pdescrs(ctx, p);
p.insert("print_unsat_core", CPK_BOOL, "(default: false) print unsatisfiable core.");
p.insert("print_proof", CPK_BOOL, "(default: false) print proof.");
p.insert("print_model", CPK_BOOL, "(default: false) print model.");
}
virtual void execute(cmd_context & ctx) {
void execute(cmd_context & ctx) override {
if (!m_tactic) {
throw cmd_exception("check-sat-using needs a tactic argument");
}
@ -295,9 +295,9 @@ public:
exec_given_tactic_cmd("apply") {
}
virtual char const * get_main_descr() const { return "apply the given tactic to the current context, and print the resultant set of goals."; }
char const * get_main_descr() const override { return "apply the given tactic to the current context, and print the resultant set of goals."; }
virtual void init_pdescrs(cmd_context & ctx, param_descrs & p) {
void init_pdescrs(cmd_context & ctx, param_descrs & p) override {
p.insert("print", CPK_BOOL, "(default: true) print resultant goals.");
#ifndef _EXTERNAL_RELEASE
p.insert("print_proof", CPK_BOOL, "(default: false) print proof associated with each assertion.");
@ -308,7 +308,7 @@ public:
exec_given_tactic_cmd::init_pdescrs(ctx, p);
}
virtual void execute(cmd_context & ctx) {
void execute(cmd_context & ctx) override {
if (!m_tactic) {
throw cmd_exception("apply needs a tactic argument");
}

36
src/duality/duality.h
View file

@ -248,14 +248,14 @@ namespace Duality {
TermTree *&interpolants,
model &_model,
TermTree *goals = 0,
bool weak = false)
bool weak = false) override
{
literals _labels;
islvr->SetWeakInterpolants(weak);
return islvr->interpolate_tree(assumptions,interpolants,_model,_labels,true);
}
void assert_axiom(const expr &axiom){
void assert_axiom(const expr &axiom) override {
#if 1
// HACK: large "distict" predicates can kill the legacy SMT solver.
// encode them with a UIF
@ -280,11 +280,11 @@ namespace Duality {
islvr->AssertInterpolationAxiom(axiom);
}
const std::vector<expr> &get_axioms() {
const std::vector<expr> &get_axioms() override {
return islvr->GetInterpolationAxioms();
}
std::string profile(){
std::string profile() override {
return islvr->profile();
}
@ -307,31 +307,31 @@ namespace Duality {
void write_interpolation_problem(const std::string &file_name,
const std::vector<expr> &assumptions,
const std::vector<expr> &theory
){
) override {
#if 0
islvr->write_interpolation_problem(file_name,assumptions,theory);
#endif
}
void cancel(){islvr->cancel();}
void cancel() override {islvr->cancel();}
/** Declare a constant in the background theory. */
virtual void declare_constant(const func_decl &f){
void declare_constant(const func_decl &f) override {
bckg.insert(f);
}
/** Is this a background constant? */
virtual bool is_constant(const func_decl &f){
bool is_constant(const func_decl &f) override {
return bckg.find(f) != bckg.end();
}
/** Get the constants in the background vocabulary */
virtual hash_set<func_decl> &get_constants(){
hash_set<func_decl> &get_constants() override {
return bckg;
}
~iZ3LogicSolver(){
~iZ3LogicSolver() override {
// delete ictx;
delete islvr;
}
@ -1274,7 +1274,7 @@ namespace Duality {
virtual void AssertEdge(Edge *e, int persist = 0, bool with_children = false, bool underapprox = false);
#endif
virtual ~RPFP_caching(){}
~RPFP_caching() override {}
protected:
hash_map<ast,expr> AssumptionLits;
@ -1320,21 +1320,21 @@ namespace Duality {
void FilterCore(std::vector<expr> &core, std::vector<expr> &full_core);
void ConstrainEdgeLocalizedCache(Edge *e, const Term &tl, std::vector<expr> &lits);
virtual void slvr_add(const expr &e);
void slvr_add(const expr &e) override;
virtual void slvr_pop(int i);
void slvr_pop(int i) override;
virtual void slvr_push();
void slvr_push() override;
virtual check_result slvr_check(unsigned n = 0, expr * const assumptions = 0, unsigned *core_size = 0, expr *core = 0);
check_result slvr_check(unsigned n = 0, expr * const assumptions = 0, unsigned *core_size = 0, expr *core = 0) override;
virtual lbool ls_interpolate_tree(TermTree *assumptions,
lbool ls_interpolate_tree(TermTree *assumptions,
TermTree *&interpolants,
model &_model,
TermTree *goals = 0,
bool weak = false);
bool weak = false) override;
virtual bool proof_core_contains(const expr &e);
bool proof_core_contains(const expr &e) override;
void GetTermTreeAssertionLiterals(TermTree *assumptions);

76
src/duality/duality_solver.cpp
View file

@ -151,7 +151,7 @@ namespace Duality {
}
}
~Duality(){
~Duality() override {
#ifdef USE_RPFP_CLONE
delete clone_rpfp;
#endif
@ -321,7 +321,7 @@ namespace Duality {
#endif
/** Solve the problem. */
virtual bool Solve(){
bool Solve() override {
PreSolve();
bool res = SolveMain(); // does the actual work
PostSolve();
@ -398,7 +398,7 @@ namespace Duality {
}
void Cancel(){
void Cancel() override {
// TODO
}
@ -418,7 +418,7 @@ namespace Duality {
}
#endif
virtual void LearnFrom(Solver *other_solver){
void LearnFrom(Solver *other_solver) override {
// get the counterexample as a guide
cex.swap(other_solver->GetCounterexample());
@ -429,7 +429,7 @@ namespace Duality {
}
/** Return a reference to the counterexample */
virtual Counterexample &GetCounterexample(){
Counterexample &GetCounterexample() override {
return cex;
}
@ -462,7 +462,7 @@ namespace Duality {
}
/** Set options (not currently used) */
virtual bool SetOption(const std::string &option, const std::string &value){
bool SetOption(const std::string &option, const std::string &value) override {
if(option == "full_expand"){
return SetBoolOption(FullExpand,value);
}
@ -828,7 +828,7 @@ namespace Duality {
}
}
bool IsResultRecursionBounded(){
bool IsResultRecursionBounded() override {
return recursionBounded;
}
@ -2186,7 +2186,7 @@ namespace Duality {
struct DoRestart {};
virtual bool Build(){
bool Build() override {
restart_interval = 3;
while (true) {
try {
@ -2499,7 +2499,7 @@ namespace Duality {
hash_map<Node *, std::vector<Node *> > node_map;
std::list<Node *> updated_nodes;
virtual void ExpandNode(RPFP::Node *p){
void ExpandNode(RPFP::Node *p) override {
stack.push_back(stack_entry());
stack.back().level = tree->slvr().get_scope_level();
stack.back().expansions.push_back(p);
@ -2990,13 +2990,13 @@ namespace Duality {
old_cex.swap(_old_cex); // take ownership from caller
}
~ReplayHeuristic(){
~ReplayHeuristic() override {
}
// Maps nodes of derivation tree into old cex
hash_map<Node *, Node*> cex_map;
void Done() {
void Done() override {
cex_map.clear();
old_cex.clear();
}
@ -3045,7 +3045,7 @@ namespace Duality {
return cex_map[node];
}
int UseNode(Node *node){
int UseNode(Node *node) override {
if (!old_cex.get_tree())
return 0;
Node *old_node = MatchNode(node);
@ -3054,7 +3054,7 @@ namespace Duality {
return old_cex.get_tree()->Empty(old_node) ? -1 : 1;
}
virtual void ChooseExpand(const std::set<RPFP::Node *> &choices, std::set<RPFP::Node *> &best, bool high_priority, bool best_only){
void ChooseExpand(const std::set<RPFP::Node *> &choices, std::set<RPFP::Node *> &best, bool high_priority, bool best_only) override {
if(cex_map.empty())
cex_map[*(choices.begin())] = old_cex.get_root(); // match the root nodes
if(!high_priority || !old_cex.get_tree()){
@ -3099,7 +3099,7 @@ namespace Duality {
// Maps nodes of derivation tree into old subtree
hash_map<Node *, Node*> cex_map;
virtual void ChooseExpand(const std::set<RPFP::Node *> &choices, std::set<RPFP::Node *> &best, bool, bool){
void ChooseExpand(const std::set<RPFP::Node *> &choices, std::set<RPFP::Node *> &best, bool, bool) override {
if(old_node == 0){
Heuristic::ChooseExpand(choices,best);
return;
@ -3200,11 +3200,11 @@ namespace Duality {
}
}
virtual std::vector<RPFP::Transformer> &Propose(Node *node){
std::vector<RPFP::Transformer> &Propose(Node *node) override {
return conjectures[node->map];
}
virtual ~HistoryProposer(){
~HistoryProposer() override {
};
private:
@ -3273,68 +3273,68 @@ namespace Duality {
}
s << "[" << event++ << "]" ;
}
virtual void Extend(RPFP::Node *node){
void Extend(RPFP::Node *node) override {
ev(); s << "node " << node->number << ": " << node->Name.name();
std::vector<RPFP::Node *> &rps = node->Outgoing->Children;
for(unsigned i = 0; i < rps.size(); i++)
s << " " << rps[i]->number;
s << std::endl;
}
virtual void Update(RPFP::Node *node, const RPFP::Transformer &update, bool eager){
void Update(RPFP::Node *node, const RPFP::Transformer &update, bool eager) override {
ev(); s << "update " << node->number << " " << node->Name.name() << ": ";
rpfp->Summarize(update.Formula);
if(depth > 0) s << " (depth=" << depth << ")";
if(eager) s << " (eager)";
s << std::endl;
}
virtual void Bound(RPFP::Node *node){
void Bound(RPFP::Node *node) override {
ev(); s << "check " << node->number << std::endl;
}
virtual void Expand(RPFP::Edge *edge){
void Expand(RPFP::Edge *edge) override {
RPFP::Node *node = edge->Parent;
ev(); s << "expand " << node->map->number << " " << node->Name.name();
if(depth > 0) s << " (depth=" << depth << ")";
s << std::endl;
}
virtual void Depth(int d){
void Depth(int d) override {
depth = d;
}
virtual void AddCover(RPFP::Node *covered, std::vector<RPFP::Node *> &covering){
void AddCover(RPFP::Node *covered, std::vector<RPFP::Node *> &covering) override {
ev(); s << "cover " << covered->Name.name() << ": " << covered->number << " by ";
for(unsigned i = 0; i < covering.size(); i++)
s << covering[i]->number << " ";
s << std::endl;
}
virtual void RemoveCover(RPFP::Node *covered, RPFP::Node *covering){
void RemoveCover(RPFP::Node *covered, RPFP::Node *covering) override {
ev(); s << "uncover " << covered->Name.name() << ": " << covered->number << " by " << covering->number << std::endl;
}
virtual void Forcing(RPFP::Node *covered, RPFP::Node *covering){
void Forcing(RPFP::Node *covered, RPFP::Node *covering) override {
ev(); s << "forcing " << covered->Name.name() << ": " << covered->number << " by " << covering->number << std::endl;
}
virtual void Conjecture(RPFP::Node *node, const RPFP::Transformer &t){
void Conjecture(RPFP::Node *node, const RPFP::Transformer &t) override {
ev(); s << "conjecture " << node->number << " " << node->Name.name() << ": ";
rpfp->Summarize(t.Formula);
s << std::endl;
}
virtual void Dominates(RPFP::Node *node, RPFP::Node *other){
void Dominates(RPFP::Node *node, RPFP::Node *other) override {
ev(); s << "dominates " << node->Name.name() << ": " << node->number << " > " << other->number << std::endl;
}
virtual void InductionFailure(RPFP::Edge *edge, const std::vector<RPFP::Node *> &children){
void InductionFailure(RPFP::Edge *edge, const std::vector<RPFP::Node *> &children) override {
ev(); s << "induction failure: " << edge->Parent->Name.name() << ", children =";
for(unsigned i = 0; i < children.size(); i++)
s << " " << children[i]->number;
s << std::endl;
}
virtual void UpdateUnderapprox(RPFP::Node *node, const RPFP::Transformer &update){
void UpdateUnderapprox(RPFP::Node *node, const RPFP::Transformer &update) override {
ev(); s << "underapprox " << node->number << " " << node->Name.name() << ": " << update.Formula << std::endl;
}
virtual void Reject(RPFP::Edge *edge, const std::vector<RPFP::Node *> &children){
void Reject(RPFP::Edge *edge, const std::vector<RPFP::Node *> &children) override {
ev(); s << "reject " << edge->Parent->number << " " << edge->Parent->Name.name() << ": ";
for(unsigned i = 0; i < children.size(); i++)
s << " " << children[i]->number;
s << std::endl;
}
virtual void Message(const std::string &msg){
void Message(const std::string &msg) override {
ev(); s << "msg " << msg << std::endl;
}
@ -3356,12 +3356,12 @@ namespace Duality {
duality = alloc(Duality,drpfp);
}
~DualityDepthBounded(){
~DualityDepthBounded() override {
dealloc(duality);
delete drpfp;
}
bool Solve(){
bool Solve() override {
int depth_bound = 10;
bool res;
SetMaxDepthRPFP(depth_bound);
@ -3382,26 +3382,26 @@ namespace Duality {
return res;
}
Counterexample &GetCounterexample(){
Counterexample &GetCounterexample() override {
return cex;
}
bool SetOption(const std::string &option, const std::string &value){
bool SetOption(const std::string &option, const std::string &value) override {
return duality->SetOption(option,value);
}
virtual void LearnFrom(Solver *old_solver){
void LearnFrom(Solver *old_solver) override {
DualityDepthBounded *old = dynamic_cast<DualityDepthBounded *>(old_solver);
if(old){
duality->LearnFrom(old->duality);
}
}
bool IsResultRecursionBounded(){
bool IsResultRecursionBounded() override {
return duality->IsResultRecursionBounded();
}
void Cancel(){
void Cancel() override {
duality->Cancel();
}
@ -3580,7 +3580,7 @@ namespace Duality {
public:
ConjectureFileReporter(RPFP *_rpfp, const std::string &fname)
: Reporter(_rpfp), s(fname.c_str()) {}
virtual void Update(RPFP::Node *node, const RPFP::Transformer &update, bool eager){
void Update(RPFP::Node *node, const RPFP::Transformer &update, bool eager) override {
s << "(define-fun " << node->Name.name() << " (";
for(unsigned i = 0; i < update.IndParams.size(); i++){
if(i != 0)

2
src/math/automata/boolean_algebra.h
View file

@ -39,7 +39,7 @@ public:
template<class T>
class boolean_algebra : public positive_boolean_algebra<T> {
public:
virtual ~boolean_algebra() {}
~boolean_algebra() override {}
virtual T mk_not(T x) = 0;
};

6
src/math/polynomial/polynomial_var2value.h
View file

@ -32,9 +32,9 @@ namespace polynomial {
public:
simple_var2value(ValManager & m):m_vs(m) {}
void push_back(var x, typename ValManager::numeral const & v) { m_xs.push_back(x); m_vs.push_back(v); }
virtual ValManager & m() const { return m_vs.m(); }
virtual bool contains(var x) const { return std::find(m_xs.begin(), m_xs.end(), x) != m_xs.end(); }
virtual typename ValManager::numeral const & operator()(var x) const {
ValManager & m() const override { return m_vs.m(); }
bool contains(var x) const override { return std::find(m_xs.begin(), m_xs.end(), x) != m_xs.end(); }
typename ValManager::numeral const & operator()(var x) const override {
for (unsigned i = 0; i < m_xs.size(); i++)
if (m_xs[i] == x)
return m_vs[i];

2
src/model/model.cpp
View file

@ -93,7 +93,7 @@ bool model::eval(expr * e, expr_ref & result, bool model_completion) {
struct model::value_proc : public some_value_proc {
model & m_model;
value_proc(model & m):m_model(m) {}
virtual expr * operator()(sort * s) {
expr * operator()(sort * s) override {
ptr_vector<expr> * u = 0;
if (m_model.m_usort2universe.find(s, u)) {
if (u->size() > 0)

12
src/model/model.h
View file

@ -33,7 +33,7 @@ protected:
public:
model(ast_manager & m);
virtual ~model();
~model() override;
void copy_func_interps(model const & source);
void copy_const_interps(model const & source);
@ -44,11 +44,11 @@ public:
bool eval(func_decl * f, expr_ref & r) const { return model_core::eval(f, r); }
bool eval(expr * e, expr_ref & result, bool model_completion = false);
virtual expr * get_some_value(sort * s);
virtual ptr_vector<expr> const & get_universe(sort * s) const;
virtual unsigned get_num_uninterpreted_sorts() const;
virtual sort * get_uninterpreted_sort(unsigned idx) const;
bool has_uninterpreted_sort(sort * s) const;
expr * get_some_value(sort * s) override;
ptr_vector<expr> const & get_universe(sort * s) const override;
unsigned get_num_uninterpreted_sorts() const override;
sort * get_uninterpreted_sort(unsigned idx) const override;
bool has_uninterpreted_sort(sort * s) const;
//
// Primitives for building models

12
src/nlsat/nlsat_assignment.h
View file

@ -66,9 +66,9 @@ namespace nlsat {
void reset() { m_assigned.reset(); }
bool is_assigned(var x) const { return m_assigned.get(x, false); }
anum const & value(var x) const { return m_values[x]; }
virtual anum_manager & m() const { return am(); }
virtual bool contains(var x) const { return is_assigned(x); }
virtual anum const & operator()(var x) const { SASSERT(is_assigned(x)); return value(x); }
anum_manager & m() const override { return am(); }
bool contains(var x) const override { return is_assigned(x); }
anum const & operator()(var x) const override { SASSERT(is_assigned(x)); return value(x); }
void swap(var x, var y) {
SASSERT(x < m_values.size() && y < m_values.size());
std::swap(m_assigned[x], m_assigned[y]);
@ -95,9 +95,9 @@ namespace nlsat {
var m_y;
public:
undef_var_assignment(assignment const & a, var y):m_assignment(a), m_y(y) {}
virtual anum_manager & m() const { return m_assignment.am(); }
virtual bool contains(var x) const { return x != m_y && m_assignment.is_assigned(x); }
virtual anum const & operator()(var x) const { return m_assignment.value(x); }
anum_manager & m() const override { return m_assignment.am(); }
bool contains(var x) const override { return x != m_y && m_assignment.is_assigned(x); }
anum const & operator()(var x) const override { return m_assignment.value(x); }
};
};

4
src/nlsat/nlsat_solver.cpp
View file

@ -112,7 +112,7 @@ namespace nlsat {
m_perm(perm),
m_proc(0) {
}
std::ostream& operator()(std::ostream & out, var x) const {
std::ostream& operator()(std::ostream & out, var x) const override {
if (m_proc == 0)
m_default_display_var(out, x);
else
@ -2699,7 +2699,7 @@ namespace nlsat {
var m_x;
public:
mathematica_var_proc(var x):m_x(x) {}
virtual std::ostream& operator()(std::ostream & out, var x) const {
std::ostream& operator()(std::ostream & out, var x) const override {
if (m_x == x)
return out << "#1";
else

4
src/nlsat/tactic/goal2nlsat.cpp
View file

@ -41,11 +41,11 @@ struct goal2nlsat::imp {
m_solver(s) {
}
virtual bool is_int(polynomial::var x) const {
bool is_int(polynomial::var x) const override {
return m_solver.is_int(x);
}
virtual polynomial::var mk_var(bool is_int) {
polynomial::var mk_var(bool is_int) override {
return m_solver.mk_var(is_int);
}
};

26
src/nlsat/tactic/nlsat_tactic.cpp
View file

@ -32,7 +32,7 @@ class nlsat_tactic : public tactic {
ast_manager & m;
expr_ref_vector m_var2expr;
expr_display_var_proc(ast_manager & _m):m(_m), m_var2expr(_m) {}
virtual std::ostream& operator()(std::ostream & out, nlsat::var x) const {
std::ostream& operator()(std::ostream & out, nlsat::var x) const override {
if (x < m_var2expr.size())
return out << mk_ismt2_pp(m_var2expr.get(x), m);
else
@ -214,29 +214,29 @@ public:
m_imp = 0;
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(nlsat_tactic, m_params);
}
virtual ~nlsat_tactic() {
~nlsat_tactic() override {
SASSERT(m_imp == 0);
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_params = p;
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
goal2nlsat::collect_param_descrs(r);
nlsat::solver::collect_param_descrs(r);
algebraic_numbers::manager::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 {
try {
imp local_imp(in->m(), m_params);
scoped_set_imp setter(*this, local_imp);
@ -251,13 +251,13 @@ public:
}
}
virtual void cleanup() {}
void cleanup() override {}
virtual void collect_statistics(statistics & st) const {
void collect_statistics(statistics & st) const override {
st.copy(m_stats);
}
virtual void reset_statistics() {
void reset_statistics() override {
m_stats.reset();
}
};

18
src/solver/check_sat_result.h
View file

@ -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

58
src/solver/combined_solver.cpp
View file

@ -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);

2
src/solver/solver.h
View file

@ -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.

28
src/solver/solver2tactic.cpp
View file

@ -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));
}
};

22
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;
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;

38
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);
@ -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);

48
src/solver/tactic2solver.cpp
View file

@ -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);
}

18
src/tactic/aig/aig_tactic.cpp
View file

@ -46,7 +46,7 @@ public:
updt_params(p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
aig_tactic * t = alloc(aig_tactic);
t->m_max_memory = m_max_memory;
t->m_aig_gate_encoding = m_aig_gate_encoding;
@ -54,13 +54,13 @@ public:
return t;
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_max_memory = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX));
m_aig_gate_encoding = p.get_bool("aig_default_gate_encoding", true);
m_aig_per_assertion = p.get_bool("aig_per_assertion", true);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
insert_max_memory(r);
r.insert("aig_per_assertion", CPK_BOOL, "(default: true) process one assertion at a time.");
}
@ -90,11 +90,11 @@ public:
SASSERT(g->is_well_sorted());
}
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) {
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) override {
fail_if_proof_generation("aig", g);
mc = 0; pc = 0; core = 0;
operator()(g);
@ -102,7 +102,7 @@ public:
result.push_back(g.get());
}
virtual void cleanup() {}
void cleanup() override {}
};

24
src/tactic/arith/add_bounds_tactic.cpp
View file

@ -48,10 +48,10 @@ bool is_unbounded(goal const & g) {
class is_unbounded_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_unbounded(g);
}
virtual ~is_unbounded_probe() {}
~is_unbounded_probe() override {}
};
probe * mk_is_unbounded_probe() {
@ -142,33 +142,33 @@ public:
m_imp = alloc(imp, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(add_bounds_tactic, m, m_params);
}
virtual ~add_bounds_tactic() {
~add_bounds_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("add_bound_lower", CPK_NUMERAL, "(default: -2) lower bound to be added to unbounded variables.");
r.insert("add_bound_upper", CPK_NUMERAL, "(default: 2) upper bound to be added to unbounded variables.");
}
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) {
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) override {
(*m_imp)(g, result, mc, pc, core);
}
virtual void cleanup() {
void cleanup() override {
imp * d = alloc(imp, m_imp->m, m_params);
std::swap(d, m_imp);
dealloc(d);

14
src/tactic/arith/arith_bounds_tactic.cpp
View file

@ -23,15 +23,15 @@ struct arith_bounds_tactic : public tactic {
ast_manager& get_manager() { return m; }
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 {
bounds_arith_subsumption(in, result);
}
virtual tactic* translate(ast_manager & mgr) {
tactic* translate(ast_manager & mgr) override {
return alloc(arith_bounds_tactic, mgr);
}
@ -146,7 +146,7 @@ struct arith_bounds_tactic : public tactic {
TRACE("arith_subsumption", s->display(tout); );
}
virtual void cleanup() {}
void cleanup() override {}
};

20
src/tactic/arith/card2bv_tactic.cpp
View file

@ -36,26 +36,26 @@ public:
m_params(p) {
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(card2bv_tactic, m, m_params);
}
virtual ~card2bv_tactic() {
~card2bv_tactic() override {
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_params = p;
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
}
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) {
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) override {
TRACE("card2bv-before", g->display(tout););
SASSERT(g->is_well_sorted());
mc = 0; pc = 0; core = 0; result.reset();
@ -101,7 +101,7 @@ public:
SASSERT(g->is_well_sorted());
}
virtual void cleanup() {
void cleanup() override {
}
};

16
src/tactic/arith/degree_shift_tactic.cpp
View file

@ -297,23 +297,23 @@ public:
m_imp = alloc(imp, m);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(degree_shift_tactic, m);
}
virtual ~degree_shift_tactic() {
~degree_shift_tactic() override {
dealloc(m_imp);
}
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);
}
virtual void cleanup() {
void cleanup() override {
imp * d = alloc(imp, m_imp->m);
std::swap(d, m_imp);
dealloc(d);

24
src/tactic/arith/diff_neq_tactic.cpp
View file

@ -354,28 +354,28 @@ public:
m_imp = alloc(imp, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(diff_neq_tactic, m, m_params);
}
virtual ~diff_neq_tactic() {
~diff_neq_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("diff_neq_max_k", CPK_UINT, "(default: 1024) maximum variable upper bound for diff neq solver.");
}
virtual void collect_statistics(statistics & st) const {
void collect_statistics(statistics & st) const override {
st.update("conflicts", m_imp->m_num_conflicts);
}
virtual void reset_statistics() {
void reset_statistics() override {
m_imp->m_num_conflicts = 0;
}
@ -383,15 +383,15 @@ public:
\brief Fix a DL variable in s to 0.
If s is not really in the difference logic fragment, then this is a NOOP.
*/
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);
}
virtual void cleanup() {
void cleanup() override {
imp * d = alloc(imp, m_imp->m, m_params);
d->m_num_conflicts = m_imp->m_num_conflicts;
std::swap(d, m_imp);

22
src/tactic/arith/elim01_tactic.cpp
View file

@ -41,7 +41,7 @@ public:
m_refs(m)
{}
virtual void operator()(model_ref & old_model, unsigned goal_idx) {
void operator()(model_ref & old_model, unsigned goal_idx) override {
SASSERT(goal_idx == 0);
model * new_model = alloc(model, m);
unsigned num = old_model->get_num_constants();
@ -106,7 +106,7 @@ public:
}
}
virtual model_converter * translate(ast_translation & translator) {
model_converter * translate(ast_translation & translator) override {
bool2int_model_converter* mc = alloc(bool2int_model_converter, translator.to());
for (unsigned i = 0; i < m_nums_as_int.size(); ++i) {
mc->insert(m_nums_as_int[i], m_nums_as_bool[i].size(), m_nums_as_bool[i].c_ptr());
@ -134,24 +134,24 @@ public:
m_max_hi(rational(m_max_hi_default)) {
}
virtual ~elim01_tactic() {
~elim01_tactic() override {
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_max_hi = rational(p.get_uint("max_coefficient", m_max_hi_default));
m_params = p;
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
r.insert("max_coefficient", CPK_UINT, "(default: 1) maximal upper bound for finite range -> Bool conversion");
}
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) {
expr_dependency_ref & core) override {
SASSERT(g->is_well_sorted());
mc = 0; pc = 0; core = 0;
@ -211,11 +211,11 @@ public:
// TBD: support proof conversion (or not..)
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(elim01_tactic, m, m_params);
}
virtual void cleanup() {}
void cleanup() override {}
void add_variable(bool2int_model_converter* b2i,
expr_safe_replace& sub,

25
src/tactic/arith/eq2bv_tactic.cpp
View file

@ -82,7 +82,7 @@ class eq2bv_tactic : public tactic {
m_map.insert(c_new, c_old);
}
virtual void operator()(model_ref& mdl) {
void operator()(model_ref& mdl) override {
ast_manager& m = mdl->get_manager();
bv_util bv(m);
arith_util a(m);
@ -105,7 +105,7 @@ class eq2bv_tactic : public tactic {
mdl = new_m;
}
virtual model_converter* translate(ast_translation & translator) {
model_converter* translate(ast_translation & translator) override {
bvmc* v = alloc(bvmc);
obj_map<func_decl, func_decl*>::iterator it = m_map.begin(), end = m_map.end();
for (; it != end; ++it) {
@ -136,19 +136,18 @@ public:
m_bounds(m) {
}
virtual ~eq2bv_tactic() {
~eq2bv_tactic() override {
}
void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
}
virtual void operator()(
goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) {
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) override {
SASSERT(g->is_well_sorted());
mc = 0; pc = 0; core = 0;
m_trail.reset();
@ -213,14 +212,14 @@ public:
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(eq2bv_tactic, m);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
}
virtual void cleanup() {
void cleanup() override {
}
void cleanup_fd(ref<bvmc>& mc) {

20
src/tactic/arith/factor_tactic.cpp
View file

@ -293,30 +293,30 @@ public:
m_imp = alloc(imp, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(factor_tactic, m, m_params);
}
virtual ~factor_tactic() {
~factor_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->m_rw.cfg().updt_params(p);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
r.insert("split_factors", CPK_BOOL,
"(default: true) apply simplifications such as (= (* p1 p2) 0) --> (or (= p1 0) (= p2 0)).");
polynomial::factor_params::get_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 {
try {
(*m_imp)(in, result, mc, pc, core);
}
@ -328,7 +328,7 @@ public:
}
}
virtual void cleanup() {
void cleanup() override {
imp * d = alloc(imp, m_imp->m, m_params);
std::swap(d, m_imp);
dealloc(d);

20
src/tactic/arith/fix_dl_var_tactic.cpp
View file

@ -303,28 +303,28 @@ public:
m_imp = alloc(imp, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(fix_dl_var_tactic, m, m_params);
}
virtual ~fix_dl_var_tactic() {
~fix_dl_var_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 {
th_rewriter::get_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 {
try {
(*m_imp)(in, result, mc, pc, core);
}
@ -333,7 +333,7 @@ public:
}
}
virtual void cleanup() {
void cleanup() override {
imp * d = alloc(imp, m_imp->m, m_params);
std::swap(d, m_imp);
dealloc(d);

28
src/tactic/arith/fm_tactic.cpp
View file

@ -164,7 +164,7 @@ class fm_tactic : public tactic {
public:
fm_model_converter(ast_manager & _m):m(_m) {}
virtual ~fm_model_converter() {
~fm_model_converter() override {
m.dec_array_ref(m_xs.size(), m_xs.c_ptr());
vector<clauses>::iterator it = m_clauses.begin();
vector<clauses>::iterator end = m_clauses.end();
@ -180,7 +180,7 @@ class fm_tactic : public tactic {
m_clauses.back().swap(c);
}
virtual void operator()(model_ref & md, unsigned goal_idx) {
void operator()(model_ref & md, unsigned goal_idx) override {
TRACE("fm_mc", model_v2_pp(tout, *md); display(tout););
model_evaluator ev(*(md.get()));
ev.set_model_completion(true);
@ -244,7 +244,7 @@ class fm_tactic : public tactic {
}
virtual void display(std::ostream & out) {
void display(std::ostream & out) override {
out << "(fm-model-converter";
SASSERT(m_xs.size() == m_clauses.size());
unsigned sz = m_xs.size();
@ -261,7 +261,7 @@ class fm_tactic : public tactic {
out << ")\n";
}
virtual model_converter * translate(ast_translation & translator) {
model_converter * translate(ast_translation & translator) override {
ast_manager & to_m = translator.to();
fm_model_converter * res = alloc(fm_model_converter, to_m);
unsigned sz = m_xs.size();
@ -1643,20 +1643,20 @@ public:
m_imp = alloc(imp, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(fm_tactic, m, m_params);
}
virtual ~fm_tactic() {
~fm_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 {
insert_produce_models(r);
insert_max_memory(r);
r.insert("fm_real_only", CPK_BOOL, "(default: true) consider only real variables for fourier-motzkin elimination.");
@ -1668,17 +1668,17 @@ public:
}
virtual void cleanup() {
void cleanup() override {
imp * d = alloc(imp, m_imp->m, m_params);
std::swap(d, m_imp);
dealloc(d);
}
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);
}
};

18
src/tactic/arith/lia2card_tactic.cpp
View file

@ -148,21 +148,21 @@ public:
m_compile_equality(false) {
}
virtual ~lia2card_tactic() {
~lia2card_tactic() override {
dealloc(m_todo);
dealloc(m_01s);
}
void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_params = p;
m_compile_equality = p.get_bool("compile_equality", false);
}
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) {
expr_dependency_ref & core) override {
SASSERT(g->is_well_sorted());
mc = 0; pc = 0; core = 0;
m_01s->reset();
@ -389,16 +389,16 @@ public:
}
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(lia2card_tactic, m, m_params);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
r.insert("compile_equality", CPK_BOOL,
"(default:false) compile equalities into pseudo-Boolean equality");
}
virtual void cleanup() {
void cleanup() override {
expr_set* d = alloc(expr_set);
ptr_vector<expr>* todo = alloc(ptr_vector<expr>);
std::swap(m_01s, d);

20
src/tactic/arith/lia2pb_tactic.cpp
View file

@ -313,30 +313,30 @@ public:
m_imp = alloc(imp, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(lia2pb_tactic, m, m_params);
}
virtual ~lia2pb_tactic() {
~lia2pb_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("lia2pb_partial", CPK_BOOL, "(default: false) partial lia2pb conversion.");
r.insert("lia2pb_max_bits", CPK_UINT, "(default: 32) maximum number of bits to be used (per variable) in lia2pb.");
r.insert("lia2pb_total_bits", CPK_UINT, "(default: 2048) total number of bits to be used (per problem) in lia2pb.");
}
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 {
try {
(*m_imp)(in, result, mc, pc, core);
}
@ -345,7 +345,7 @@ public:
}
}
virtual void cleanup() {
void cleanup() override {
imp * d = alloc(imp, m_imp->m, m_params);
std::swap(d, m_imp);
dealloc(d);

20
src/tactic/arith/nla2bv_tactic.cpp
View file

@ -418,18 +418,18 @@ public:
m_imp(0) {
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(nla2bv_tactic, m_params);
}
virtual ~nla2bv_tactic() {
~nla2bv_tactic() override {
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_params = p;
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
r.insert("nla2bv_max_bv_size", CPK_UINT, "(default: inf) maximum bit-vector size used by nla2bv tactic");
r.insert("nla2bv_bv_size", CPK_UINT, "(default: 4) default bit-vector size used by nla2bv tactic.");
r.insert("nla2bv_root", CPK_UINT, "(default: 2) nla2bv tactic encodes reals into bit-vectors using expressions of the form a+b*sqrt(c), this parameter sets the value of c used in the encoding.");
@ -441,11 +441,11 @@ public:
arithmetic in place of non-linear integer arithmetic.
\return false if transformation is not possible.
*/
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) {
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) override {
SASSERT(g->is_well_sorted());
fail_if_proof_generation("nla2bv", g);
fail_if_unsat_core_generation("nla2bv", g);
@ -459,7 +459,7 @@ public:
SASSERT(g->is_well_sorted());
}
virtual void cleanup(void) {
void cleanup(void) override {
}
};

20
src/tactic/arith/normalize_bounds_tactic.cpp
View file

@ -156,28 +156,28 @@ public:
m_imp = alloc(imp, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(normalize_bounds_tactic, m, m_params);
}
virtual ~normalize_bounds_tactic() {
~normalize_bounds_tactic() override {
dealloc(m_imp);
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_imp->updt_params(p);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
insert_produce_models(r);
r.insert("norm_int_only", CPK_BOOL, "(default: true) normalize only the bounds of integer constants.");
}
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 {
try {
(*m_imp)(in, result, mc, pc, core);
}
@ -186,7 +186,7 @@ public:
}
}
virtual void cleanup() {
void cleanup() override {
ast_manager & m = m_imp->m;
imp * d = alloc(imp, m, m_params);
std::swap(d, m_imp);

10
src/tactic/arith/pb2bv_model_converter.h
View file

@ -30,11 +30,11 @@ class pb2bv_model_converter : public model_converter {
public:
pb2bv_model_converter(ast_manager & _m);
pb2bv_model_converter(ast_manager & _m, obj_map<func_decl, expr*> const & c2bit, bound_manager const & bm);
virtual ~pb2bv_model_converter();
virtual void operator()(model_ref & md);
virtual void operator()(model_ref & md, unsigned goal_idx);
virtual void display(std::ostream & out);
virtual model_converter * translate(ast_translation & translator);
~pb2bv_model_converter() override;
void operator()(model_ref & md) override;
void operator()(model_ref & md, unsigned goal_idx) override;
void display(std::ostream & out) override;
model_converter * translate(ast_translation & translator) override;
};
#endif

22
src/tactic/arith/pb2bv_tactic.cpp
View file

@ -983,32 +983,32 @@ public:
m_imp = alloc(imp, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(pb2bv_tactic, m, m_params);
}
virtual ~pb2bv_tactic() {
~pb2bv_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 {
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);
}
virtual void cleanup() {
void cleanup() override {
ast_manager & m = m_imp->m;
imp * d = alloc(imp, m, m_params);
std::swap(d, m_imp);
@ -1023,7 +1023,7 @@ tactic * mk_pb2bv_tactic(ast_manager & m, params_ref const & p) {
}
struct is_pb_probe : public probe {
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
try {
ast_manager & m = g.m();
bound_manager bm(m);

34
src/tactic/arith/probe_arith.cpp
View file

@ -74,7 +74,7 @@ class arith_degree_probe : public probe {
public:
arith_degree_probe(bool avg):m_avg(avg) {}
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
proc p(g.m());
for_each_expr_at(p, g);
if (m_avg)
@ -117,7 +117,7 @@ class arith_bw_probe : public probe {
public:
arith_bw_probe(bool avg):m_avg(avg) {}
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
proc p(g.m());
for_each_expr_at(p, g);
if (m_avg)
@ -269,14 +269,14 @@ static bool is_qfauflia(goal const & g) {
class is_qflia_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_qflia(g);
}
};
class is_qfauflia_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_qfauflia(g);
}
};
@ -288,7 +288,7 @@ static bool is_qflra(goal const & g) {
class is_qflra_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_qflra(g);
}
};
@ -300,7 +300,7 @@ static bool is_qflira(goal const & g) {
class is_qflira_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_qflira(g);
}
};
@ -344,14 +344,14 @@ static bool is_mip(goal const & g) {
class is_ilp_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_ilp(g);
}
};
class is_mip_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_mip(g);
}
};
@ -583,56 +583,56 @@ struct is_non_qfufnra_functor {
class is_qfnia_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_qfnia(g);
}
};
class is_qfnra_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_qfnra(g);
}
};
class is_nia_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_nia(g);
}
};
class is_nra_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_nra(g);
}
};
class is_nira_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_nira(g);
}
};
class is_lia_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_lia(g);
}
};
class is_lra_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_lra(g);
}
};
class is_lira_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_lira(g);
}
};
@ -644,7 +644,7 @@ static bool is_qfufnra(goal const& g) {
class is_qfufnra_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_qfufnra(g);
}
};

12
src/tactic/arith/propagate_ineqs_tactic.cpp
View file

@ -43,18 +43,18 @@ class propagate_ineqs_tactic : public tactic {
public:
propagate_ineqs_tactic(ast_manager & m, params_ref const & p);
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(propagate_ineqs_tactic, m, m_params);
}
virtual ~propagate_ineqs_tactic();
~propagate_ineqs_tactic() 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 operator()(goal_ref const & g, goal_ref_buffer & result, model_converter_ref & mc, proof_converter_ref & pc, expr_dependency_ref & core);
void operator()(goal_ref const & g, goal_ref_buffer & result, model_converter_ref & mc, proof_converter_ref & pc, expr_dependency_ref & core) override;
virtual void cleanup();
void cleanup() override;
};
tactic * mk_propagate_ineqs_tactic(ast_manager & m, params_ref const & p) {

20
src/tactic/arith/purify_arith_tactic.cpp
View file

@ -802,18 +802,18 @@ public:
m_params(p) {
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(purify_arith_tactic, m, m_params);
}
virtual ~purify_arith_tactic() {
~purify_arith_tactic() override {
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_params = p;
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
r.insert("complete", CPK_BOOL,
"(default: true) add constraints to make sure that any interpretation of a underspecified arithmetic operators is a function. The result will include additional uninterpreted functions/constants: /0, div0, mod0, 0^0, neg-root");
r.insert("elim_root_objects", CPK_BOOL,
@ -823,11 +823,11 @@ public:
th_rewriter::get_param_descrs(r);
}
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) {
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) override {
try {
SASSERT(g->is_well_sorted());
mc = 0; pc = 0; core = 0;
@ -852,7 +852,7 @@ public:
}
}
virtual void cleanup() {
void cleanup() override {
}
};

18
src/tactic/arith/recover_01_tactic.cpp
View file

@ -390,29 +390,29 @@ public:
m_imp = alloc(imp, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(recover_01_tactic, m, m_params);
}
virtual ~recover_01_tactic() {
~recover_01_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 {
th_rewriter::get_param_descrs(r);
r.insert("recover_01_max_bits", CPK_UINT, "(default: 10) maximum number of bits to consider in a clause.");
}
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) {
expr_dependency_ref & core) override {
try {
(*m_imp)(g, result, mc, pc, core);
}
@ -421,7 +421,7 @@ public:
}
}
virtual void cleanup() {
void cleanup() override {
imp * d = alloc(imp, m_imp->m, m_params);
std::swap(d, m_imp);
dealloc(d);

10
src/tactic/bv/bit_blaster_model_converter.cpp
View file

@ -46,7 +46,7 @@ struct bit_blaster_model_converter : public model_converter {
}
}
virtual ~bit_blaster_model_converter() {
~bit_blaster_model_converter() override {
}
void collect_bits(obj_hashtable<func_decl> & bits) {
@ -142,7 +142,7 @@ struct bit_blaster_model_converter : public model_converter {
}
}
virtual void operator()(model_ref & md, unsigned goal_idx) {
void operator()(model_ref & md, unsigned goal_idx) override {
SASSERT(goal_idx == 0);
model * new_model = alloc(model, m());
obj_hashtable<func_decl> bits;
@ -152,11 +152,11 @@ struct bit_blaster_model_converter : public model_converter {
md = new_model;
}
virtual void operator()(model_ref & md) {
void operator()(model_ref & md) override {
operator()(md, 0);
}
virtual void display(std::ostream & out) {
void display(std::ostream & out) override {
out << "(bit-blaster-model-converter";
unsigned sz = m_vars.size();
for (unsigned i = 0; i < sz; i++) {
@ -171,7 +171,7 @@ protected:
bit_blaster_model_converter(ast_manager & m):m_vars(m), m_bits(m) { }
public:
virtual model_converter * translate(ast_translation & translator) {
model_converter * translate(ast_translation & translator) override {
bit_blaster_model_converter * res = alloc(bit_blaster_model_converter, translator.to());
for (unsigned i = 0; i < m_vars.size(); i++)
res->m_vars.push_back(translator(m_vars[i].get()));

20
src/tactic/bv/bit_blaster_tactic.cpp
View file

@ -111,21 +111,21 @@ public:
m_imp = alloc(imp, m, m_rewriter, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
SASSERT(!m_rewriter); // assume translation isn't used where rewriter is external.
return alloc(bit_blaster_tactic, m, 0, m_params);
}
virtual ~bit_blaster_tactic() {
~bit_blaster_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 {
insert_max_memory(r);
insert_max_steps(r);
r.insert("blast_mul", CPK_BOOL, "(default: true) bit-blast multipliers (and dividers, remainders).");
@ -134,11 +134,11 @@ public:
r.insert("blast_full", CPK_BOOL, "(default: false) bit-blast any term with bit-vector sort, this option will make E-matching ineffective in any pattern containing bit-vector terms.");
}
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) {
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) override {
try {
(*m_imp)(g, result, mc, pc, core);
}
@ -147,7 +147,7 @@ public:
}
}
virtual void cleanup() {
void cleanup() override {
imp * d = alloc(imp, m_imp->m(), m_rewriter, m_params);
std::swap(d, m_imp);
dealloc(d);

22
src/tactic/bv/bv1_blaster_tactic.cpp
View file

@ -426,20 +426,20 @@ public:
m_imp = alloc(imp, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(bv1_blaster_tactic, m, m_params);
}
virtual ~bv1_blaster_tactic() {
~bv1_blaster_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->m_rw.cfg().updt_params(p);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
insert_max_memory(r);
insert_max_steps(r);
}
@ -454,15 +454,15 @@ public:
It also does not support quantifiers.
Return a model_converter that converts any model for the updated set into a model for the old set.
*/
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) {
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) override {
(*m_imp)(g, result, mc, pc, core);
}
virtual void cleanup() {
void cleanup() override {
imp * d = alloc(imp, m_imp->m(), m_params);
std::swap(d, m_imp);
dealloc(d);
@ -480,7 +480,7 @@ tactic * mk_bv1_blaster_tactic(ast_manager & m, params_ref const & p) {
class is_qfbv_eq_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
bv1_blaster_tactic t(g.m());
return t.is_target(g);

16
src/tactic/bv/bv_bound_chk_tactic.cpp
View file

@ -111,7 +111,7 @@ struct bv_bound_chk_rewriter : public rewriter_tpl<bv_bound_chk_rewriter_cfg> {
updt_params(p);
}
virtual ~bv_bound_chk_rewriter() {}
~bv_bound_chk_rewriter() override {}
void updt_params(params_ref const & _p) {
m_cfg.updt_params(_p);
@ -135,17 +135,17 @@ class bv_bound_chk_tactic : public tactic {
bv_bound_chk_stats m_stats;
public:
bv_bound_chk_tactic(ast_manager & m, params_ref const & p);
virtual ~bv_bound_chk_tactic();
~bv_bound_chk_tactic() override;
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core);
virtual tactic * translate(ast_manager & m);
virtual void updt_params(params_ref const & p);
void cleanup();
void collect_statistics(statistics & st) const;
void reset_statistics();
expr_dependency_ref & core) override;
tactic * translate(ast_manager & m) override;
void updt_params(params_ref const & p) override;
void cleanup() override;
void collect_statistics(statistics & st) const override;
void reset_statistics() override;
};
class bv_bound_chk_tactic::imp {

28
src/tactic/bv/bv_bounds_tactic.cpp
View file

@ -305,7 +305,7 @@ namespace {
updt_params(p);
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_propagate_eq = p.get_bool("propagate_eq", false);
}
@ -313,7 +313,7 @@ namespace {
r.insert("propagate-eq", CPK_BOOL, "(default: false) propagate equalities from inequalities");
}
virtual ~bv_bounds_simplifier() {
~bv_bounds_simplifier() override {
for (unsigned i = 0, e = m_expr_vars.size(); i < e; ++i) {
dealloc(m_expr_vars[i]);
}
@ -322,7 +322,7 @@ namespace {
}
}
virtual bool assert_expr(expr * t, bool sign) {
bool assert_expr(expr * t, bool sign) override {
while (m.is_not(t, t)) {
sign = !sign;
}
@ -353,7 +353,7 @@ namespace {
return true;
}
virtual bool simplify(expr* t, expr_ref& result) {
bool simplify(expr* t, expr_ref& result) override {
expr* t1;
interval b;
@ -465,7 +465,7 @@ namespace {
return false;
}
virtual bool may_simplify(expr* t) {
bool may_simplify(expr* t) override {
if (m_bv.is_numeral(t))
return false;
@ -504,7 +504,7 @@ namespace {
return false;
}
virtual void pop(unsigned num_scopes) {
void pop(unsigned num_scopes) override {
TRACE("bv", tout << "pop: " << num_scopes << "\n";);
if (m_scopes.empty())
return;
@ -526,11 +526,11 @@ namespace {
m_scopes.shrink(target);
}
virtual simplifier * translate(ast_manager & m) {
simplifier * translate(ast_manager & m) override {
return alloc(bv_bounds_simplifier, m, m_params);
}
virtual unsigned scope_level() const {
unsigned scope_level() const override {
return m_scopes.size();
}
};
@ -622,7 +622,7 @@ namespace {
r.insert("propagate-eq", CPK_BOOL, "(default: false) propagate equalities from inequalities");
}
virtual ~dom_bv_bounds_simplifier() {
~dom_bv_bounds_simplifier() override {
for (unsigned i = 0, e = m_expr_vars.size(); i < e; ++i) {
dealloc(m_expr_vars[i]);
}
@ -631,7 +631,7 @@ namespace {
}
}
virtual bool assert_expr(expr * t, bool sign) {
bool assert_expr(expr * t, bool sign) override {
while (m.is_not(t, t)) {
sign = !sign;
}
@ -662,7 +662,7 @@ namespace {
return true;
}
virtual void operator()(expr_ref& r) {
void operator()(expr_ref& r) override {
expr* t1, * t = r;
interval b;
@ -781,7 +781,7 @@ namespace {
return false;
}
virtual void pop(unsigned num_scopes) {
void pop(unsigned num_scopes) override {
TRACE("bv", tout << "pop: " << num_scopes << "\n";);
if (m_scopes.empty())
return;
@ -803,11 +803,11 @@ namespace {
m_scopes.shrink(target);
}
virtual dom_simplifier * translate(ast_manager & m) {
dom_simplifier * translate(ast_manager & m) override {
return alloc(dom_bv_bounds_simplifier, m, m_params);
}
virtual unsigned scope_level() const {
unsigned scope_level() const override {
return m_scopes.size();
}

8
src/tactic/bv/bv_size_reduction_tactic.cpp
View file

@ -34,15 +34,15 @@ class bv_size_reduction_tactic : public tactic {
public:
bv_size_reduction_tactic(ast_manager & m);
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(bv_size_reduction_tactic, m);
}
virtual ~bv_size_reduction_tactic();
~bv_size_reduction_tactic() override;
virtual void operator()(goal_ref const & g, goal_ref_buffer & result, model_converter_ref & mc, proof_converter_ref & pc, expr_dependency_ref & core);
void operator()(goal_ref const & g, goal_ref_buffer & result, model_converter_ref & mc, proof_converter_ref & pc, expr_dependency_ref & core) override;
virtual void cleanup();
void cleanup() override;
};
tactic * mk_bv_size_reduction_tactic(ast_manager & m, params_ref const & p) {

20
src/tactic/bv/bvarray2uf_tactic.cpp
View file

@ -113,32 +113,32 @@ public:
m_imp = alloc(imp, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(bvarray2uf_tactic, m, m_params);
}
virtual ~bvarray2uf_tactic() {
~bvarray2uf_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 {
insert_produce_models(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);
}
virtual void cleanup() {
void cleanup() override {
ast_manager & m = m_imp->m();
imp * d = alloc(imp, m, m_params);
std::swap(d, m_imp);

22
src/tactic/bv/dt2bv_tactic.cpp
View file

@ -95,8 +95,8 @@ class dt2bv_tactic : public tactic {
struct sort_pred : public i_sort_pred {
dt2bv_tactic& m_t;
sort_pred(dt2bv_tactic& t): m_t(t) {}
virtual ~sort_pred() {}
virtual bool operator()(sort* s) {
~sort_pred() override {}
bool operator()(sort* s) override {
return m_t.m_fd_sorts.contains(s);
}
};
@ -107,21 +107,21 @@ public:
dt2bv_tactic(ast_manager& m, params_ref const& p):
m(m), m_params(p), m_dt(m), m_bv(m), m_is_fd(*this) {}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(dt2bv_tactic, m, m_params);
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
}
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) {
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) override {
mc = 0; pc = 0; core = 0;
bool produce_proofs = g->proofs_enabled();
tactic_report report("dt2bv", *g);
@ -177,7 +177,7 @@ public:
SASSERT(g->is_well_sorted());
}
virtual void cleanup() {
void cleanup() override {
m_fd_sorts.reset();
m_non_fd_sorts.reset();
}

14
src/tactic/bv/elim_small_bv_tactic.cpp
View file

@ -268,34 +268,34 @@ public:
m_imp = alloc(imp, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(elim_small_bv_tactic, m, m_params);
}
virtual ~elim_small_bv_tactic() {
~elim_small_bv_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->m_rw.cfg().updt_params(p);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
insert_max_memory(r);
insert_max_steps(r);
r.insert("max_bits", CPK_UINT, "(default: 4) maximum bit-vector size of quantified bit-vectors to be eliminated.");
}
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 cleanup() {
void cleanup() override {
ast_manager & m = m_imp->m;
m_imp->~imp();
m_imp = new (m_imp) imp(m, m_params);

20
src/tactic/bv/max_bv_sharing_tactic.cpp
View file

@ -278,35 +278,35 @@ public:
m_imp = alloc(imp, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(max_bv_sharing_tactic, m, m_params);
}
virtual ~max_bv_sharing_tactic() {
~max_bv_sharing_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->m_rw.cfg().updt_params(p);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
insert_max_memory(r);
insert_max_steps(r);
r.insert("max_args", CPK_UINT,
"(default: 128) maximum number of arguments (per application) that will be considered by the greedy (quadratic) heuristic.");
}
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);
}
virtual void cleanup() {
void cleanup() override {
ast_manager & m = m_imp->m();
params_ref p = std::move(m_params);
m_imp->~imp();

12
src/tactic/converter.h
View file

@ -58,16 +58,16 @@ protected:
public:
concat_converter(T * c1, T * c2):m_c1(c1), m_c2(c2) {}
virtual ~concat_converter() {}
~concat_converter() override {}
virtual void cancel() {
void cancel() override {
m_c2->cancel();
m_c1->cancel();
}
virtual char const * get_name() const = 0;
virtual void display(std::ostream & out) {
void display(std::ostream & out) override {
out << "(" << get_name() << "\n";
m_c1->display(out);
m_c2->display(out);
@ -104,7 +104,7 @@ public:
}
}
virtual ~concat_star_converter() {
~concat_star_converter() override {
unsigned sz = m_c2s.size();
for (unsigned i = 0; i < sz; i++) {
T * c2 = m_c2s[i];
@ -113,7 +113,7 @@ public:
}
}
virtual void cancel() {
void cancel() override {
if (m_c1)
m_c1->cancel();
unsigned num = m_c2s.size();
@ -125,7 +125,7 @@ public:
virtual char const * get_name() const = 0;
virtual void display(std::ostream & out) {
void display(std::ostream & out) override {
out << "(" << get_name() << "\n";
if (m_c1)
m_c1->display(out);

20
src/tactic/core/blast_term_ite_tactic.cpp
View file

@ -152,35 +152,35 @@ public:
m_imp = alloc(imp, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(blast_term_ite_tactic, m, m_params);
}
virtual ~blast_term_ite_tactic() {
~blast_term_ite_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->m_rw.cfg().updt_params(p);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
insert_max_memory(r);
insert_max_steps(r);
r.insert("max_args", CPK_UINT,
"(default: 128) maximum number of arguments (per application) that will be considered by the greedy (quadratic) heuristic.");
}
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);
}
virtual void cleanup() {
void cleanup() override {
ast_manager & m = m_imp->m;
dealloc(m_imp);
m_imp = alloc(imp, m, m_params);

20
src/tactic/core/cofactor_term_ite_tactic.cpp
View file

@ -46,19 +46,19 @@ public:
m_elim_ite(m, p) {
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(cofactor_term_ite_tactic, m, m_params);
}
virtual ~cofactor_term_ite_tactic() {}
virtual void updt_params(params_ref const & p) { m_params = p; m_elim_ite.updt_params(p); }
virtual void collect_param_descrs(param_descrs & r) { m_elim_ite.collect_param_descrs(r); }
~cofactor_term_ite_tactic() override {}
void updt_params(params_ref const & p) override { m_params = p; m_elim_ite.updt_params(p); }
void collect_param_descrs(param_descrs & r) override { m_elim_ite.collect_param_descrs(r); }
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) {
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) override {
SASSERT(g->is_well_sorted());
fail_if_proof_generation("cofactor-term-ite", g);
fail_if_unsat_core_generation("cofactor-term-ite", g);
@ -71,7 +71,7 @@ public:
SASSERT(g->is_well_sorted());
}
virtual void cleanup() { return m_elim_ite.cleanup(); }
void cleanup() override { return m_elim_ite.cleanup(); }
};

22
src/tactic/core/collect_statistics_tactic.cpp
View file

@ -51,21 +51,21 @@ public:
m_params(p) {
}
virtual ~collect_statistics_tactic() {}
~collect_statistics_tactic() override {}
virtual tactic * translate(ast_manager & m_) {
tactic * translate(ast_manager & m_) override {
return alloc(collect_statistics_tactic, m_, m_params);
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_params = p;
}
virtual void collect_param_descrs(param_descrs & r) {}
void collect_param_descrs(param_descrs & r) override {}
virtual void operator()(goal_ref const & g, goal_ref_buffer & result,
model_converter_ref & mc, proof_converter_ref & pc,
expr_dependency_ref & core) {
void operator()(goal_ref const & g, goal_ref_buffer & result,
model_converter_ref & mc, proof_converter_ref & pc,
expr_dependency_ref & core) override {
mc = 0;
tactic_report report("collect-statistics", *g);
@ -86,13 +86,13 @@ public:
result.push_back(g.get());
}
virtual void cleanup() {}
void cleanup() override {}
virtual void collect_statistics(statistics & st) const {
void collect_statistics(statistics & st) const override {
}
virtual void reset_statistics() { reset(); }
virtual void reset() { cleanup(); }
void reset_statistics() override { reset(); }
void reset() override { cleanup(); }
protected:
class collect_proc {

12
src/tactic/core/ctx_simplify_tactic.cpp
View file

@ -33,13 +33,13 @@ class ctx_propagate_assertions : public ctx_simplify_tactic::simplifier {
void assert_eq_core(expr * t, app * val);
public:
ctx_propagate_assertions(ast_manager& m);
virtual ~ctx_propagate_assertions() {}
virtual bool assert_expr(expr * t, bool sign);
virtual bool simplify(expr* t, expr_ref& result);
~ctx_propagate_assertions() override {}
bool assert_expr(expr * t, bool sign) override;
bool simplify(expr* t, expr_ref& result) override;
void push();
virtual void pop(unsigned num_scopes);
virtual unsigned scope_level() const { return m_scopes.size(); }
virtual simplifier * translate(ast_manager & m);
void pop(unsigned num_scopes) override;
unsigned scope_level() const override { return m_scopes.size(); }
simplifier * translate(ast_manager & m) override;
};

20
src/tactic/core/ctx_simplify_tactic.h
View file

@ -46,21 +46,21 @@ protected:
public:
ctx_simplify_tactic(ast_manager & m, simplifier* simp, params_ref const & p = params_ref());
virtual tactic * translate(ast_manager & m);
tactic * translate(ast_manager & m) override;
virtual ~ctx_simplify_tactic();
~ctx_simplify_tactic() override;
virtual void updt_params(params_ref const & p);
void updt_params(params_ref const & p) override;
static void get_param_descrs(param_descrs & r);
virtual void collect_param_descrs(param_descrs & r) { get_param_descrs(r); }
void collect_param_descrs(param_descrs & r) override { get_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;
virtual void cleanup();
void cleanup() override;
};
tactic * mk_ctx_simplify_tactic(ast_manager & m, params_ref const & p = params_ref());

16
src/tactic/core/der_tactic.cpp
View file

@ -65,26 +65,26 @@ public:
m_imp = alloc(imp, m);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(der_tactic, m);
}
virtual ~der_tactic() {
~der_tactic() override {
dealloc(m_imp);
}
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 {
mc = 0; pc = 0; core = 0;
(*m_imp)(*(in.get()));
in->inc_depth();
result.push_back(in.get());
}
virtual void cleanup() {
void cleanup() override {
ast_manager & m = m_imp->m();
imp * d = alloc(imp, m);
std::swap(d, m_imp);

14
src/tactic/core/distribute_forall_tactic.cpp
View file

@ -95,15 +95,15 @@ class distribute_forall_tactic : public tactic {
public:
distribute_forall_tactic():m_rw(0) {}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(distribute_forall_tactic);
}
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) {
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) override {
SASSERT(g->is_well_sorted());
ast_manager & m = g->m();
bool produce_proofs = g->proofs_enabled();
@ -134,7 +134,7 @@ public:
m_rw = 0;
}
virtual void cleanup() {}
void cleanup() override {}
};
tactic * mk_distribute_forall_tactic(ast_manager & m, params_ref const & p) {

32
src/tactic/core/dom_simplify_tactic.h
View file

@ -130,20 +130,20 @@ public:
m_dominators(m), m_depth(0), m_max_depth(1024), m_forward(true) {}
virtual ~dom_simplify_tactic();
~dom_simplify_tactic() override;
virtual tactic * translate(ast_manager & m);
virtual void updt_params(params_ref const & p) {}
tactic * translate(ast_manager & m) override;
void updt_params(params_ref const & p) override {}
static void get_param_descrs(param_descrs & r) {}
virtual void collect_param_descrs(param_descrs & r) { get_param_descrs(r); }
void collect_param_descrs(param_descrs & r) override { get_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;
virtual void cleanup();
void cleanup() override;
};
class expr_substitution_simplifier : public dom_simplifier {
@ -160,18 +160,18 @@ class expr_substitution_simplifier : public dom_simplifier {
public:
expr_substitution_simplifier(ast_manager& m): m(m), m_subst(m), m_scoped_substitution(m_subst), m_trail(m) {}
virtual ~expr_substitution_simplifier() {}
virtual bool assert_expr(expr * t, bool sign);
~expr_substitution_simplifier() override {}
bool assert_expr(expr * t, bool sign) override;
void update_substitution(expr* n, proof* pr);
virtual void operator()(expr_ref& r) { r = m_scoped_substitution.find(r); }
void operator()(expr_ref& r) override { r = m_scoped_substitution.find(r); }
virtual void pop(unsigned num_scopes) { m_scoped_substitution.pop(num_scopes); }
void pop(unsigned num_scopes) override { m_scoped_substitution.pop(num_scopes); }
virtual unsigned scope_level() const { return m_scoped_substitution.scope_level(); }
unsigned scope_level() const override { return m_scoped_substitution.scope_level(); }
virtual dom_simplifier * translate(ast_manager & m) {
dom_simplifier * translate(ast_manager & m) override {
SASSERT(m_subst.empty());
return alloc(expr_substitution_simplifier, m);
}

20
src/tactic/core/elim_term_ite_tactic.cpp
View file

@ -141,35 +141,35 @@ public:
m_imp = alloc(imp, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(elim_term_ite_tactic, m, m_params);
}
virtual ~elim_term_ite_tactic() {
~elim_term_ite_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->m_rw.cfg().updt_params(p);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
insert_max_memory(r);
insert_max_steps(r);
r.insert("max_args", CPK_UINT,
"(default: 128) maximum number of arguments (per application) that will be considered by the greedy (quadratic) heuristic.");
}
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);
}
virtual void cleanup() {
void cleanup() override {
ast_manager & m = m_imp->m;
m_imp->~imp();
m_imp = new (m_imp) imp(m, m_params);

24
src/tactic/core/elim_uncnstr_tactic.cpp
View file

@ -915,34 +915,34 @@ public:
m_imp = alloc(imp, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(elim_uncnstr_tactic, m, m_params);
}
virtual ~elim_uncnstr_tactic() {
~elim_uncnstr_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 {
insert_max_memory(r);
insert_max_steps(r);
}
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) {
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) override {
(*m_imp)(g, result, mc, pc, core);
report_tactic_progress(":num-elim-apps", get_num_elim_apps());
}
virtual void cleanup() {
void cleanup() override {
unsigned num_elim_apps = get_num_elim_apps();
ast_manager & m = m_imp->m_manager;
imp * d = alloc(imp, m, m_params);
@ -955,11 +955,11 @@ public:
return m_imp->m_num_elim_apps;
}
virtual void collect_statistics(statistics & st) const {
void collect_statistics(statistics & st) const override {
st.update("eliminated applications", get_num_elim_apps());
}
virtual void reset_statistics() {
void reset_statistics() override {
m_imp->m_num_elim_apps = 0;
}

20
src/tactic/core/injectivity_tactic.cpp
View file

@ -250,31 +250,31 @@ public:
m_eq = alloc(rewriter_eq, m, *m_map, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(injectivity_tactic, m, m_params);
}
virtual ~injectivity_tactic() {
~injectivity_tactic() override {
dealloc(m_finder);
dealloc(m_eq);
dealloc(m_map);
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_params = p;
m_finder->updt_params(p);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
insert_max_memory(r);
insert_produce_models(r);
}
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) {
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) override {
(*m_finder)(g, result, mc, pc, core);
for (unsigned i = 0; i < g->size(); ++i) {
@ -287,7 +287,7 @@ public:
result.push_back(g.get());
}
virtual void cleanup() {
void cleanup() override {
InjHelper * m = alloc(InjHelper, m_manager);
finder * f = alloc(finder, m_manager, *m, m_params);
rewriter_eq * r = alloc(rewriter_eq, m_manager, *m, m_params);

20
src/tactic/core/nnf_tactic.cpp
View file

@ -43,21 +43,21 @@ public:
TRACE("nnf", tout << "nnf_tactic constructor: " << p << "\n";);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(nnf_tactic, m_params);
}
virtual ~nnf_tactic() {}
~nnf_tactic() override {}
virtual void updt_params(params_ref const & p) { m_params = p; }
void updt_params(params_ref const & p) override { m_params = p; }
virtual void collect_param_descrs(param_descrs & r) { nnf::get_param_descrs(r); }
void collect_param_descrs(param_descrs & r) override { nnf::get_param_descrs(r); }
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) {
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) override {
TRACE("nnf", tout << "params: " << m_params << "\n"; g->display(tout););
SASSERT(g->is_well_sorted());
mc = 0; pc = 0; core = 0;
@ -106,7 +106,7 @@ public:
SASSERT(g->is_well_sorted());
}
virtual void cleanup() {}
void cleanup() override {}
};
tactic * mk_snf_tactic(ast_manager & m, params_ref const & p) {

20
src/tactic/core/occf_tactic.cpp
View file

@ -199,26 +199,26 @@ public:
m_imp = alloc(imp, m);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(occf_tactic, m);
}
virtual ~occf_tactic() {
~occf_tactic() override {
dealloc(m_imp);
}
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 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);
}
virtual void cleanup() {
void cleanup() override {
imp * d = alloc(imp, m_imp->m);
std::swap(d, m_imp);
dealloc(d);

Some files were not shown because too many files have changed in this diff Show more