mirror of
https://github.com/Z3Prover/z3
synced 2025-05-08 00:05:46 +00:00
merge with master
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner
commit
c513f3ca09
883 changed files with 13979 additions and 16480 deletions
|
|
@ -49,14 +49,14 @@ 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) {
|
||||
if (c == nullptr) {
|
||||
std::string err_msg("unknown command '");
|
||||
err_msg = err_msg + s.bare_str() + "'";
|
||||
throw cmd_exception(err_msg);
|
||||
|
|
@ -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,25 +101,26 @@ 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 {
|
||||
model_ref m;
|
||||
if (ctx.ignore_check())
|
||||
return;
|
||||
if (!ctx.is_model_available(m) || ctx.get_check_sat_result() == 0)
|
||||
if (!ctx.is_model_available(m) || !ctx.get_check_sat_result())
|
||||
throw cmd_exception("model is not available");
|
||||
if (m_index > 0 && ctx.get_opt()) {
|
||||
ctx.get_opt()->get_box_model(m, m_index);
|
||||
}
|
||||
ctx.display_model(m);
|
||||
}
|
||||
virtual void reset(cmd_context& ctx) {
|
||||
void reset(cmd_context& ctx) override {
|
||||
m_index = 0;
|
||||
}
|
||||
};
|
||||
|
|
@ -164,10 +165,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());
|
||||
}
|
||||
};
|
||||
|
|
@ -358,7 +359,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 {}
|
||||
|
||||
};
|
||||
|
||||
|
|
@ -475,19 +476,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;
|
||||
}
|
||||
|
|
@ -496,7 +497,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));
|
||||
}
|
||||
|
|
@ -515,7 +516,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);
|
||||
}
|
||||
|
|
@ -530,7 +531,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
|
||||
|
|
@ -555,11 +556,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());
|
||||
}
|
||||
|
|
@ -649,11 +650,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;
|
||||
|
|
@ -705,16 +706,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;
|
||||
}
|
||||
|
|
@ -735,7 +736,7 @@ public:
|
|||
}
|
||||
}
|
||||
}
|
||||
virtual void execute(cmd_context & ctx) {
|
||||
void execute(cmd_context & ctx) override {
|
||||
ctx.print_success();
|
||||
}
|
||||
};
|
||||
|
|
@ -758,32 +759,32 @@ 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 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)
|
||||
if (array_sort == nullptr)
|
||||
throw cmd_exception("Array sort is not available");
|
||||
ptr_vector<sort> & array_sort_args = m_domain;
|
||||
sort_ref_buffer domain(ctx.m());
|
||||
|
|
@ -811,11 +812,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;
|
||||
|
|
@ -824,8 +825,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());
|
||||
|
|
@ -833,12 +834,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
|
||||
|
|
@ -848,8 +849,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; }
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -890,7 +891,7 @@ void install_ext_basic_cmds(cmd_context & ctx) {
|
|||
ctx.insert(alloc(echo_cmd));
|
||||
ctx.insert(alloc(labels_cmd));
|
||||
ctx.insert(alloc(declare_map_cmd));
|
||||
ctx.insert(alloc(builtin_cmd, "reset", 0, "reset the shell (all declarations and assertions will be erased)"));
|
||||
ctx.insert(alloc(builtin_cmd, "reset", nullptr, "reset the shell (all declarations and assertions will be erased)"));
|
||||
install_simplify_cmd(ctx);
|
||||
install_eval_cmd(ctx);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -328,17 +328,17 @@ struct check_logic::imp {
|
|||
|
||||
bool is_offset(app * t) {
|
||||
while (true) {
|
||||
expr * non_numeral = 0;
|
||||
expr * non_numeral = nullptr;
|
||||
unsigned num_args = t->get_num_args();
|
||||
for (unsigned i = 0; i < num_args; i++) {
|
||||
expr * arg = t->get_arg(i);
|
||||
if (is_numeral(arg))
|
||||
continue;
|
||||
if (non_numeral != 0)
|
||||
if (non_numeral != nullptr)
|
||||
return false;
|
||||
non_numeral = arg;
|
||||
}
|
||||
if (non_numeral == 0)
|
||||
if (non_numeral == nullptr)
|
||||
return true;
|
||||
if (is_diff_var(non_numeral))
|
||||
return true;
|
||||
|
|
@ -501,7 +501,7 @@ struct check_logic::imp {
|
|||
};
|
||||
|
||||
check_logic::check_logic() {
|
||||
m_imp = 0;
|
||||
m_imp = nullptr;
|
||||
}
|
||||
|
||||
check_logic::~check_logic() {
|
||||
|
|
@ -512,7 +512,7 @@ check_logic::~check_logic() {
|
|||
void check_logic::reset() {
|
||||
if (m_imp)
|
||||
dealloc(m_imp);
|
||||
m_imp = 0;
|
||||
m_imp = nullptr;
|
||||
}
|
||||
|
||||
void check_logic::set_logic(ast_manager & m, symbol const & logic) {
|
||||
|
|
|
|||
|
|
@ -68,7 +68,7 @@ void func_decls::finalize(ast_manager & m) {
|
|||
}
|
||||
dealloc(fs);
|
||||
}
|
||||
m_decls = 0;
|
||||
m_decls = nullptr;
|
||||
}
|
||||
|
||||
bool func_decls::signatures_collide(func_decl* f, func_decl* g) const {
|
||||
|
|
@ -117,7 +117,7 @@ bool func_decls::insert(ast_manager & m, func_decl * f) {
|
|||
if (contains(f))
|
||||
return false;
|
||||
m.inc_ref(f);
|
||||
if (m_decls == 0) {
|
||||
if (m_decls == nullptr) {
|
||||
m_decls = TAG(func_decl*, f, 0);
|
||||
}
|
||||
else if (GET_TAG(m_decls) == 0) {
|
||||
|
|
@ -138,7 +138,7 @@ void func_decls::erase(ast_manager & m, func_decl * f) {
|
|||
return;
|
||||
if (GET_TAG(m_decls) == 0) {
|
||||
m.dec_ref(f);
|
||||
m_decls = 0;
|
||||
m_decls = nullptr;
|
||||
}
|
||||
else {
|
||||
func_decl_set * fs = UNTAG(func_decl_set *, m_decls);
|
||||
|
|
@ -146,7 +146,7 @@ void func_decls::erase(ast_manager & m, func_decl * f) {
|
|||
m.dec_ref(f);
|
||||
if (fs->empty()) {
|
||||
dealloc(fs);
|
||||
m_decls = 0;
|
||||
m_decls = nullptr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -155,7 +155,7 @@ void func_decls::erase(ast_manager & m, func_decl * f) {
|
|||
\brief Return true if func_decls contains a declaration different from f, but with the same domain.
|
||||
*/
|
||||
bool func_decls::clash(func_decl * f) const {
|
||||
if (m_decls == 0)
|
||||
if (m_decls == nullptr)
|
||||
return false;
|
||||
if (GET_TAG(m_decls) == 0)
|
||||
return false;
|
||||
|
|
@ -177,15 +177,15 @@ bool func_decls::clash(func_decl * f) const {
|
|||
}
|
||||
|
||||
bool func_decls::more_than_one() const {
|
||||
if (m_decls == 0 || GET_TAG(m_decls) == 0)
|
||||
if (m_decls == nullptr || GET_TAG(m_decls) == 0)
|
||||
return false;
|
||||
func_decl_set * fs = UNTAG(func_decl_set *, m_decls);
|
||||
return fs->size() > 1;
|
||||
}
|
||||
|
||||
func_decl * func_decls::first() const {
|
||||
if (m_decls == 0)
|
||||
return 0;
|
||||
if (m_decls == nullptr)
|
||||
return nullptr;
|
||||
if (GET_TAG(m_decls) == 0)
|
||||
return UNTAG(func_decl*, m_decls);
|
||||
func_decl_set * fs = UNTAG(func_decl_set *, m_decls);
|
||||
|
|
@ -198,7 +198,7 @@ func_decl * func_decls::find(unsigned arity, sort * const * domain, sort * range
|
|||
return first();
|
||||
func_decl_set * fs = UNTAG(func_decl_set *, m_decls);
|
||||
for (func_decl * f : *fs) {
|
||||
if (range != 0 && f->get_range() != range)
|
||||
if (range != nullptr && f->get_range() != range)
|
||||
continue;
|
||||
if (f->get_arity() != arity)
|
||||
continue;
|
||||
|
|
@ -210,7 +210,7 @@ func_decl * func_decls::find(unsigned arity, sort * const * domain, sort * range
|
|||
if (i == arity)
|
||||
return f;
|
||||
}
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
func_decl * func_decls::find(ast_manager & m, unsigned num_args, expr * const * args, sort * range) const {
|
||||
|
|
@ -258,7 +258,7 @@ bool macro_decls::insert(ast_manager& m, unsigned arity, sort *const* domain, ex
|
|||
}
|
||||
|
||||
expr* macro_decls::find(unsigned arity, sort *const* domain) const {
|
||||
if (!m_decls) return 0;
|
||||
if (!m_decls) return nullptr;
|
||||
for (auto v : *m_decls) {
|
||||
if (v.m_domain.size() != arity) continue;
|
||||
bool eq = true;
|
||||
|
|
@ -267,7 +267,7 @@ expr* macro_decls::find(unsigned arity, sort *const* domain) const {
|
|||
}
|
||||
if (eq) return v.m_body;
|
||||
}
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void macro_decls::erase_last(ast_manager& m) {
|
||||
|
|
@ -292,7 +292,7 @@ bool cmd_context::contains_macro(symbol const& s, func_decl* f) const {
|
|||
|
||||
bool cmd_context::contains_macro(symbol const& s, unsigned arity, sort *const* domain) const {
|
||||
macro_decls decls;
|
||||
return m_macros.find(s, decls) && 0 != decls.find(arity, domain);
|
||||
return m_macros.find(s, decls) && nullptr != decls.find(arity, domain);
|
||||
}
|
||||
|
||||
void cmd_context::insert_macro(symbol const& s, unsigned arity, sort*const* domain, expr* t) {
|
||||
|
|
@ -321,7 +321,7 @@ bool cmd_context::macros_find(symbol const& s, unsigned n, expr*const* args, exp
|
|||
if (d.m_domain.size() != n) continue;
|
||||
bool eq = true;
|
||||
for (unsigned i = 0; eq && i < n; ++i) {
|
||||
eq = d.m_domain[i] == m().get_sort(args[i]);
|
||||
eq = m().compatible_sorts(d.m_domain[i], m().get_sort(args[i]));
|
||||
}
|
||||
if (eq) {
|
||||
t = d.m_body;
|
||||
|
|
@ -340,6 +340,13 @@ void ast_object_ref::finalize(cmd_context & ctx) {
|
|||
ctx.m().dec_ref(m_ast);
|
||||
}
|
||||
|
||||
void stream_ref::set(std::ostream& out) {
|
||||
reset();
|
||||
m_owner = false;
|
||||
m_name = "caller-owned";
|
||||
m_stream = &out;
|
||||
}
|
||||
|
||||
void stream_ref::set(char const * name) {
|
||||
if (!name) {
|
||||
throw cmd_exception("invalid stream name");
|
||||
|
|
@ -408,25 +415,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)) {
|
||||
|
|
@ -437,7 +444,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)) {
|
||||
|
|
@ -466,11 +473,11 @@ cmd_context::cmd_context(bool main_ctx, ast_manager * m, symbol const & l):
|
|||
m_processing_pareto(false),
|
||||
m_exit_on_error(false),
|
||||
m_manager(m),
|
||||
m_own_manager(m == 0),
|
||||
m_own_manager(m == nullptr),
|
||||
m_manager_initialized(false),
|
||||
m_rec_fun_declared(false),
|
||||
m_pmanager(0),
|
||||
m_sexpr_manager(0),
|
||||
m_pmanager(nullptr),
|
||||
m_sexpr_manager(nullptr),
|
||||
m_regular("stdout", std::cout),
|
||||
m_diagnostic("stderr", std::cerr) {
|
||||
SASSERT(m != 0 || !has_manager());
|
||||
|
|
@ -492,9 +499,9 @@ cmd_context::~cmd_context() {
|
|||
finalize_tactic_cmds();
|
||||
finalize_probes();
|
||||
reset(true);
|
||||
m_mc0 = 0;
|
||||
m_solver = 0;
|
||||
m_check_sat_result = 0;
|
||||
m_mc0 = nullptr;
|
||||
m_solver = nullptr;
|
||||
m_check_sat_result = nullptr;
|
||||
}
|
||||
|
||||
void cmd_context::set_cancel(bool f) {
|
||||
|
|
@ -588,7 +595,7 @@ bool cmd_context::validate_model_enabled() const {
|
|||
}
|
||||
|
||||
cmd_context::check_sat_state cmd_context::cs_state() const {
|
||||
if (m_check_sat_result.get() == 0)
|
||||
if (m_check_sat_result.get() == nullptr)
|
||||
return css_clear;
|
||||
switch (m_check_sat_result->status()) {
|
||||
case l_true: return css_sat;
|
||||
|
|
@ -714,6 +721,7 @@ void cmd_context::init_manager_core(bool new_manager) {
|
|||
m_dt_eh = alloc(dt_eh, *this);
|
||||
m_pmanager->set_new_datatype_eh(m_dt_eh.get());
|
||||
if (!has_logic()) {
|
||||
TRACE("cmd_context", tout << "init manager\n";);
|
||||
// add list type only if the logic is not specified.
|
||||
// it prevents clashes with builtin types.
|
||||
insert(pm().mk_plist_decl());
|
||||
|
|
@ -736,7 +744,7 @@ void cmd_context::init_manager() {
|
|||
else {
|
||||
m_manager_initialized = true;
|
||||
SASSERT(m_pmanager == 0);
|
||||
m_check_sat_result = 0;
|
||||
m_check_sat_result = nullptr;
|
||||
m_manager = m_params.mk_ast_manager();
|
||||
m_pmanager = alloc(pdecl_manager, *m_manager);
|
||||
init_manager_core(true);
|
||||
|
|
@ -766,7 +774,7 @@ bool cmd_context::set_logic(symbol const & s) {
|
|||
}
|
||||
|
||||
std::string cmd_context::reason_unknown() const {
|
||||
if (m_check_sat_result.get() == 0)
|
||||
if (m_check_sat_result.get() == nullptr)
|
||||
return "state of the most recent check-sat command is not known";
|
||||
return m_check_sat_result->reason_unknown();
|
||||
}
|
||||
|
|
@ -856,7 +864,7 @@ void cmd_context::insert_user_tactic(symbol const & s, sexpr * d) {
|
|||
|
||||
void cmd_context::insert(symbol const & s, object_ref * r) {
|
||||
r->inc_ref(*this);
|
||||
object_ref * old_r = 0;
|
||||
object_ref * old_r = nullptr;
|
||||
if (m_object_refs.find(s, old_r)) {
|
||||
old_r->dec_ref(*this);
|
||||
}
|
||||
|
|
@ -917,8 +925,8 @@ func_decl * cmd_context::find_func_decl(symbol const & s) const {
|
|||
try {
|
||||
// Remark: ignoring m_next of d. We do not allow two different theories to define the same constant name.
|
||||
func_decl * f;
|
||||
f = m().mk_func_decl(d.m_fid, d.m_decl, 0, 0, 0, static_cast<sort*const*>(0), 0);
|
||||
if (f != 0)
|
||||
f = m().mk_func_decl(d.m_fid, d.m_decl, 0, nullptr, 0, static_cast<sort*const*>(nullptr), nullptr);
|
||||
if (f != nullptr)
|
||||
return f;
|
||||
}
|
||||
catch (ast_exception &) {
|
||||
|
|
@ -935,7 +943,7 @@ func_decl * cmd_context::find_func_decl(symbol const & s) const {
|
|||
return fs.first();
|
||||
}
|
||||
throw cmd_exception("invalid function declaration reference, unknown function ", s);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -948,7 +956,7 @@ func_decl * cmd_context::find_func_decl(symbol const & s) const {
|
|||
*/
|
||||
static builtin_decl const & peek_builtin_decl(builtin_decl const & first, family_id target_id) {
|
||||
builtin_decl const * curr = &first;
|
||||
while (curr != 0) {
|
||||
while (curr != nullptr) {
|
||||
if (curr->m_fid == target_id)
|
||||
return *curr;
|
||||
curr = curr->m_next;
|
||||
|
|
@ -970,7 +978,7 @@ func_decl * cmd_context::find_func_decl(symbol const & s, unsigned num_indices,
|
|||
}
|
||||
func_decl * f;
|
||||
if (num_indices == 0) {
|
||||
f = m().mk_func_decl(fid, k, 0, 0, arity, domain, range);
|
||||
f = m().mk_func_decl(fid, k, 0, nullptr, arity, domain, range);
|
||||
}
|
||||
else {
|
||||
buffer<parameter> ps;
|
||||
|
|
@ -978,7 +986,7 @@ func_decl * cmd_context::find_func_decl(symbol const & s, unsigned num_indices,
|
|||
ps.push_back(parameter(indices[i]));
|
||||
f = m().mk_func_decl(fid, k, num_indices, ps.c_ptr(), arity, domain, range);
|
||||
}
|
||||
if (f == 0)
|
||||
if (f == nullptr)
|
||||
throw cmd_exception("invalid function declaration reference, invalid builtin reference ", s);
|
||||
return f;
|
||||
}
|
||||
|
|
@ -989,46 +997,46 @@ func_decl * cmd_context::find_func_decl(symbol const & s, unsigned num_indices,
|
|||
if (num_indices > 0)
|
||||
throw cmd_exception("invalid indexed function declaration reference, unknown builtin function ", s);
|
||||
|
||||
func_decl * f = 0;
|
||||
func_decl * f = nullptr;
|
||||
func_decls fs;
|
||||
if (m_func_decls.find(s, fs)) {
|
||||
f = fs.find(arity, domain, range);
|
||||
}
|
||||
if (f == 0)
|
||||
if (f == nullptr)
|
||||
throw cmd_exception("invalid function declaration reference, unknown function ", s);
|
||||
return f;
|
||||
}
|
||||
|
||||
psort_decl * cmd_context::find_psort_decl(symbol const & s) const {
|
||||
psort_decl * p = 0;
|
||||
psort_decl * p = nullptr;
|
||||
m_psort_decls.find(s, p);
|
||||
return p;
|
||||
}
|
||||
|
||||
|
||||
cmd * cmd_context::find_cmd(symbol const & s) const {
|
||||
cmd * c = 0;
|
||||
cmd * c = nullptr;
|
||||
m_cmds.find(s, c);
|
||||
return c;
|
||||
}
|
||||
|
||||
sexpr * cmd_context::find_user_tactic(symbol const & s) const {
|
||||
sexpr * n = 0;
|
||||
sexpr * n = nullptr;
|
||||
m_user_tactic_decls.find(s, n);
|
||||
return n;
|
||||
}
|
||||
|
||||
object_ref * cmd_context::find_object_ref(symbol const & s) const {
|
||||
object_ref * r = 0;
|
||||
object_ref * r = nullptr;
|
||||
m_object_refs.find(s, r);
|
||||
if (r == 0) throw cmd_exception("unknown global variable ", s);
|
||||
if (r == nullptr) throw cmd_exception("unknown global variable ", s);
|
||||
return r;
|
||||
}
|
||||
|
||||
#define CHECK_SORT(T) if (well_sorted_check_enabled()) m().check_sorts_core(T)
|
||||
|
||||
void cmd_context::mk_const(symbol const & s, expr_ref & result) const {
|
||||
mk_app(s, 0, 0, 0, 0, 0, result);
|
||||
mk_app(s, 0, nullptr, 0, nullptr, nullptr, result);
|
||||
}
|
||||
|
||||
void cmd_context::mk_app(symbol const & s, unsigned num_args, expr * const * args, unsigned num_indices, parameter const * indices, sort * range,
|
||||
|
|
@ -1044,12 +1052,12 @@ void cmd_context::mk_app(symbol const & s, unsigned num_args, expr * const * arg
|
|||
k = d2.m_decl;
|
||||
}
|
||||
if (num_indices == 0) {
|
||||
result = m().mk_app(fid, k, 0, 0, num_args, args, range);
|
||||
result = m().mk_app(fid, k, 0, nullptr, num_args, args, range);
|
||||
}
|
||||
else {
|
||||
result = m().mk_app(fid, k, num_indices, indices, num_args, args, range);
|
||||
}
|
||||
if (result.get() == 0)
|
||||
if (result.get() == nullptr)
|
||||
throw cmd_exception("invalid builtin application ", s);
|
||||
CHECK_SORT(result.get());
|
||||
return;
|
||||
|
|
@ -1078,11 +1086,11 @@ void cmd_context::mk_app(symbol const & s, unsigned num_args, expr * const * arg
|
|||
throw cmd_exception("unknown function/constant ", s);
|
||||
}
|
||||
|
||||
if (num_args == 0 && range == 0) {
|
||||
if (num_args == 0 && range == nullptr) {
|
||||
if (fs.more_than_one())
|
||||
throw cmd_exception("ambiguous constant reference, more than one constant with the same sort, use a qualified expression (as <symbol> <sort>) to disumbiguate ", s);
|
||||
func_decl * f = fs.first();
|
||||
if (f == 0) {
|
||||
if (f == nullptr) {
|
||||
throw cmd_exception("unknown constant ", s);
|
||||
}
|
||||
if (f->get_arity() != 0)
|
||||
|
|
@ -1091,7 +1099,7 @@ void cmd_context::mk_app(symbol const & s, unsigned num_args, expr * const * arg
|
|||
}
|
||||
else {
|
||||
func_decl * f = fs.find(m(), num_args, args, range);
|
||||
if (f == 0) {
|
||||
if (f == nullptr) {
|
||||
std::ostringstream buffer;
|
||||
buffer << "unknown constant " << s << " ";
|
||||
buffer << " (";
|
||||
|
|
@ -1185,7 +1193,7 @@ void cmd_context::erase_user_tactic(symbol const & s) {
|
|||
}
|
||||
|
||||
void cmd_context::erase_object_ref(symbol const & s) {
|
||||
object_ref * r = 0;
|
||||
object_ref * r = nullptr;
|
||||
if (m_object_refs.find(s, r)) {
|
||||
r->dec_ref(*this);
|
||||
m_object_refs.erase(s);
|
||||
|
|
@ -1254,7 +1262,7 @@ void cmd_context::insert_aux_pdecl(pdecl * p) {
|
|||
void cmd_context::reset(bool finalize) {
|
||||
m_processing_pareto = false;
|
||||
m_logic = symbol::null;
|
||||
m_check_sat_result = 0;
|
||||
m_check_sat_result = nullptr;
|
||||
m_numeral_as_real = false;
|
||||
m_builtin_decls.reset();
|
||||
m_extra_builtin_decls.reset();
|
||||
|
|
@ -1266,18 +1274,18 @@ void cmd_context::reset(bool finalize) {
|
|||
reset_macros();
|
||||
reset_func_decls();
|
||||
restore_assertions(0);
|
||||
m_solver = 0;
|
||||
m_mc0 = 0;
|
||||
m_solver = nullptr;
|
||||
m_mc0 = nullptr;
|
||||
m_scopes.reset();
|
||||
m_opt = 0;
|
||||
m_pp_env = 0;
|
||||
m_dt_eh = 0;
|
||||
m_opt = nullptr;
|
||||
m_pp_env = nullptr;
|
||||
m_dt_eh = nullptr;
|
||||
if (m_manager) {
|
||||
dealloc(m_pmanager);
|
||||
m_pmanager = 0;
|
||||
m_pmanager = nullptr;
|
||||
if (m_own_manager) {
|
||||
dealloc(m_manager);
|
||||
m_manager = 0;
|
||||
m_manager = nullptr;
|
||||
m_manager_initialized = false;
|
||||
}
|
||||
else {
|
||||
|
|
@ -1291,7 +1299,7 @@ void cmd_context::reset(bool finalize) {
|
|||
}
|
||||
if (m_sexpr_manager) {
|
||||
dealloc(m_sexpr_manager);
|
||||
m_sexpr_manager = 0;
|
||||
m_sexpr_manager = nullptr;
|
||||
}
|
||||
SASSERT(!m_own_manager || !has_manager());
|
||||
}
|
||||
|
|
@ -1300,7 +1308,7 @@ void cmd_context::assert_expr(expr * t) {
|
|||
m_processing_pareto = false;
|
||||
if (!m_check_logic(t))
|
||||
throw cmd_exception(m_check_logic.get_last_error());
|
||||
m_check_sat_result = 0;
|
||||
m_check_sat_result = nullptr;
|
||||
m().inc_ref(t);
|
||||
m_assertions.push_back(t);
|
||||
if (produce_unsat_cores())
|
||||
|
|
@ -1317,7 +1325,7 @@ void cmd_context::assert_expr(symbol const & name, expr * t) {
|
|||
assert_expr(t);
|
||||
return;
|
||||
}
|
||||
m_check_sat_result = 0;
|
||||
m_check_sat_result = nullptr;
|
||||
m().inc_ref(t);
|
||||
m_assertions.push_back(t);
|
||||
expr * ans = m().mk_const(name, m().mk_bool_sort());
|
||||
|
|
@ -1328,7 +1336,7 @@ void cmd_context::assert_expr(symbol const & name, expr * t) {
|
|||
}
|
||||
|
||||
void cmd_context::push() {
|
||||
m_check_sat_result = 0;
|
||||
m_check_sat_result = nullptr;
|
||||
init_manager();
|
||||
m_scopes.push_back(scope());
|
||||
scope & s = m_scopes.back();
|
||||
|
|
@ -1374,7 +1382,7 @@ void cmd_context::restore_psort_decls(unsigned old_sz) {
|
|||
svector<symbol>::iterator end = m_psort_decls_stack.end();
|
||||
for (; it != end; ++it) {
|
||||
symbol const & s = *it;
|
||||
psort_decl * d = 0;
|
||||
psort_decl * d = nullptr;
|
||||
VERIFY(m_psort_decls.find(s, d));
|
||||
pm().dec_ref(d);
|
||||
m_psort_decls.erase(s);
|
||||
|
|
@ -1432,7 +1440,7 @@ void cmd_context::restore_assertions(unsigned old_sz) {
|
|||
}
|
||||
|
||||
void cmd_context::pop(unsigned n) {
|
||||
m_check_sat_result = 0;
|
||||
m_check_sat_result = nullptr;
|
||||
m_processing_pareto = false;
|
||||
if (n == 0)
|
||||
return;
|
||||
|
|
@ -1568,10 +1576,10 @@ void cmd_context::reset_assertions() {
|
|||
}
|
||||
|
||||
if (m_opt) {
|
||||
m_opt = 0;
|
||||
m_opt = nullptr;
|
||||
}
|
||||
if (m_solver) {
|
||||
m_solver = 0;
|
||||
m_solver = nullptr;
|
||||
mk_solver();
|
||||
}
|
||||
restore_assertions(0);
|
||||
|
|
@ -1786,7 +1794,7 @@ void cmd_context::validate_model() {
|
|||
for (; it != end; ++it) {
|
||||
expr * a = *it;
|
||||
if (is_ground(a)) {
|
||||
r = 0;
|
||||
r = nullptr;
|
||||
evaluator(a, r);
|
||||
TRACE("model_validate", tout << "checking\n" << mk_ismt2_pp(a, m()) << "\nresult:\n" << mk_ismt2_pp(r, m()) << "\n";);
|
||||
if (m().is_true(r))
|
||||
|
|
@ -1839,8 +1847,8 @@ void cmd_context::set_interpolating_solver_factory(solver_factory * f) {
|
|||
|
||||
void cmd_context::set_solver_factory(solver_factory * f) {
|
||||
m_solver_factory = f;
|
||||
m_check_sat_result = 0;
|
||||
if (has_manager() && f != 0) {
|
||||
m_check_sat_result = nullptr;
|
||||
if (has_manager() && f != nullptr) {
|
||||
mk_solver();
|
||||
// assert formulas and create scopes in the new solver.
|
||||
unsigned lim = 0;
|
||||
|
|
@ -1899,7 +1907,7 @@ bool cmd_context::is_model_available(model_ref& md) const {
|
|||
(cs_state() == css_sat || cs_state() == css_unknown)) {
|
||||
get_check_sat_result()->get_model(md);
|
||||
complete_model(md);
|
||||
return md.get() != 0;
|
||||
return md.get() != nullptr;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
|
@ -1910,7 +1918,7 @@ format_ns::format * cmd_context::pp(sort * s) const {
|
|||
}
|
||||
|
||||
cmd_context::pp_env & cmd_context::get_pp_env() const {
|
||||
if (m_pp_env.get() == 0) {
|
||||
if (m_pp_env.get() == nullptr) {
|
||||
const_cast<cmd_context*>(this)->m_pp_env = alloc(pp_env, *const_cast<cmd_context*>(this));
|
||||
}
|
||||
return *(m_pp_env.get());
|
||||
|
|
@ -1922,7 +1930,7 @@ void cmd_context::pp(expr * n, unsigned num_vars, char const * var_prefix, forma
|
|||
|
||||
void cmd_context::pp(expr * n, format_ns::format_ref & r) const {
|
||||
sbuffer<symbol> buf;
|
||||
pp(n, 0, 0, r, buf);
|
||||
pp(n, 0, nullptr, r, buf);
|
||||
}
|
||||
|
||||
void cmd_context::pp(func_decl * f, format_ns::format_ref & r) const {
|
||||
|
|
@ -1947,7 +1955,7 @@ void cmd_context::display(std::ostream & out, expr * n, unsigned indent, unsigne
|
|||
|
||||
void cmd_context::display(std::ostream & out, expr * n, unsigned indent) const {
|
||||
sbuffer<symbol> buf;
|
||||
display(out, n, indent, 0, 0, buf);
|
||||
display(out, n, indent, 0, nullptr, buf);
|
||||
}
|
||||
|
||||
void cmd_context::display(std::ostream & out, func_decl * d, unsigned indent) const {
|
||||
|
|
@ -2024,7 +2032,7 @@ void cmd_context::dt_eh::operator()(sort * dt, pdecl* pd) {
|
|||
m_owner.insert(c);
|
||||
func_decl * r = m_dt_util.get_constructor_recognizer(c);
|
||||
m_owner.insert(r);
|
||||
TRACE("new_dt_eh", tout << "new recognizer: " << r->get_name() << "\n";);
|
||||
// TRACE("new_dt_eh", tout << "new recognizer: " << r->get_name() << "\n";);
|
||||
for (func_decl * a : *m_dt_util.get_constructor_accessors(c)) {
|
||||
TRACE("new_dt_eh", tout << "new accessor: " << a->get_name() << "\n";);
|
||||
m_owner.insert(a);
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ class func_decls {
|
|||
bool signatures_collide(func_decl* f, func_decl* g) const;
|
||||
bool signatures_collide(unsigned n, sort*const* domain, sort* range, func_decl* g) const;
|
||||
public:
|
||||
func_decls():m_decls(0) {}
|
||||
func_decls():m_decls(nullptr) {}
|
||||
func_decls(ast_manager & m, func_decl * f);
|
||||
void finalize(ast_manager & m);
|
||||
bool contains(func_decl * f) const;
|
||||
|
|
@ -55,7 +55,7 @@ public:
|
|||
void erase(ast_manager & m, func_decl * f);
|
||||
bool more_than_one() const;
|
||||
bool clash(func_decl * f) const;
|
||||
bool empty() const { return m_decls == 0; }
|
||||
bool empty() const { return m_decls == nullptr; }
|
||||
func_decl * first() const;
|
||||
func_decl * find(unsigned arity, sort * const * domain, sort * range) const;
|
||||
func_decl * find(ast_manager & m, unsigned num_args, expr * const * args, sort * range) const;
|
||||
|
|
@ -77,7 +77,7 @@ struct macro_decl {
|
|||
class macro_decls {
|
||||
vector<macro_decl>* m_decls;
|
||||
public:
|
||||
macro_decls() { m_decls = 0; }
|
||||
macro_decls() { m_decls = nullptr; }
|
||||
void finalize(ast_manager& m);
|
||||
bool insert(ast_manager& m, unsigned arity, sort *const* domain, expr* body);
|
||||
expr* find(unsigned arity, sort *const* domain) const;
|
||||
|
|
@ -113,10 +113,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 {
|
||||
|
|
@ -126,9 +126,10 @@ class stream_ref {
|
|||
std::ostream * m_stream;
|
||||
bool m_owner;
|
||||
public:
|
||||
stream_ref(std::string n, std::ostream & d):m_default_name(n), m_default(d), m_name(n), m_stream(&d), m_owner(false) {}
|
||||
stream_ref(const std::string& n, std::ostream & d):m_default_name(n), m_default(d), m_name(n), m_stream(&d), m_owner(false) {}
|
||||
~stream_ref() { reset(); }
|
||||
void set(char const * name);
|
||||
void set(std::ostream& strm);
|
||||
void reset();
|
||||
std::ostream & operator*() { return *m_stream; }
|
||||
char const * name() const { return m_name.c_str(); }
|
||||
|
|
@ -138,8 +139,8 @@ struct builtin_decl {
|
|||
family_id m_fid;
|
||||
decl_kind m_decl;
|
||||
builtin_decl * m_next;
|
||||
builtin_decl():m_fid(null_family_id), m_decl(0), m_next(0) {}
|
||||
builtin_decl(family_id fid, decl_kind k, builtin_decl * n = 0):m_fid(fid), m_decl(k), m_next(n) {}
|
||||
builtin_decl():m_fid(null_family_id), m_decl(0), m_next(nullptr) {}
|
||||
builtin_decl(family_id fid, decl_kind k, builtin_decl * n = nullptr):m_fid(fid), m_decl(k), m_next(n) {}
|
||||
};
|
||||
|
||||
class opt_wrapper : public check_sat_result {
|
||||
|
|
@ -251,8 +252,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,8 +308,8 @@ protected:
|
|||
|
||||
|
||||
public:
|
||||
cmd_context(bool main_ctx = true, ast_manager * m = 0, symbol const & l = symbol::null);
|
||||
~cmd_context();
|
||||
cmd_context(bool main_ctx = true, ast_manager * m = nullptr, symbol const & l = symbol::null);
|
||||
~cmd_context() override;
|
||||
void set_cancel(bool f);
|
||||
context_params & params() { return m_params; }
|
||||
solver_factory &get_solver_factory() { return *m_solver_factory; }
|
||||
|
|
@ -354,9 +355,9 @@ public:
|
|||
status get_status() const { return m_status; }
|
||||
std::string reason_unknown() const;
|
||||
|
||||
bool has_manager() const { return m_manager != 0; }
|
||||
bool has_manager() const { return m_manager != nullptr; }
|
||||
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; }
|
||||
|
||||
|
|
@ -409,9 +410,11 @@ public:
|
|||
void reset_object_refs();
|
||||
void reset_user_tactics();
|
||||
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(std::ostream& out) { m_diagnostic.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;
|
||||
|
|
@ -467,14 +470,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;
|
||||
|
|
@ -483,8 +486,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);
|
||||
|
|
|
|||
|
|
@ -33,14 +33,14 @@ void assert_exprs_from(cmd_context const & ctx, goal & t) {
|
|||
ptr_vector<expr>::const_iterator it2 = ctx.begin_assertion_names();
|
||||
SASSERT(end - it == ctx.end_assertion_names() - it2);
|
||||
for (; it != end; ++it, ++it2) {
|
||||
t.assert_expr(*it, proofs_enabled ? m.mk_asserted(*it) : 0, m.mk_leaf(*it2));
|
||||
t.assert_expr(*it, proofs_enabled ? m.mk_asserted(*it) : nullptr, m.mk_leaf(*it2));
|
||||
}
|
||||
}
|
||||
else {
|
||||
ptr_vector<expr>::const_iterator it = ctx.begin_assertions();
|
||||
ptr_vector<expr>::const_iterator end = ctx.end_assertions();
|
||||
for (; it != end; ++it) {
|
||||
t.assert_expr(*it, proofs_enabled ? m.mk_asserted(*it) : 0, 0);
|
||||
t.assert_expr(*it, proofs_enabled ? m.mk_asserted(*it) : nullptr, nullptr);
|
||||
}
|
||||
SASSERT(ctx.begin_assertion_names() == ctx.end_assertion_names());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -62,7 +62,7 @@ void context_params::set_uint(unsigned & opt, char const * param, char const * v
|
|||
}
|
||||
|
||||
if (is_uint) {
|
||||
long val = strtol(value, 0, 10);
|
||||
long val = strtol(value, nullptr, 10);
|
||||
opt = static_cast<unsigned>(val);
|
||||
}
|
||||
else {
|
||||
|
|
@ -198,7 +198,7 @@ void context_params::get_solver_params(ast_manager const & m, params_ref & p, bo
|
|||
ast_manager * context_params::mk_ast_manager() {
|
||||
ast_manager * r = alloc(ast_manager,
|
||||
m_proof ? PGM_ENABLED : PGM_DISABLED,
|
||||
m_trace ? m_trace_file_name.c_str() : 0);
|
||||
m_trace ? m_trace_file_name.c_str() : nullptr);
|
||||
if (m_smtlib2_compliant)
|
||||
r->enable_int_real_coercions(false);
|
||||
if (m_debug_ref_count)
|
||||
|
|
|
|||
|
|
@ -27,8 +27,8 @@ 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) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result) override {
|
||||
#pragma omp critical (echo_tactic)
|
||||
{
|
||||
m_ctx.regular_stream() << m_msg;
|
||||
|
|
@ -54,12 +54,12 @@ 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) {
|
||||
void operator()(goal_ref const & in,
|
||||
goal_ref_buffer & result) override {
|
||||
double val = (*m_p)(*(in.get())).get_value();
|
||||
#pragma omp critical (probe_value_tactic)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
m_target = nullptr;
|
||||
}
|
||||
|
||||
virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const {
|
||||
if (m_target == 0) return CPK_EXPR;
|
||||
cmd_arg_kind next_arg_kind(cmd_context & ctx) const override {
|
||||
if (m_target == nullptr) 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 {
|
||||
model_ref md;
|
||||
if (!ctx.is_model_available(md))
|
||||
throw cmd_exception("model is not available");
|
||||
|
|
|
|||
|
|
@ -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 = nullptr; }
|
||||
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) {
|
||||
if (m_t1 == 0)
|
||||
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 = nullptr; }
|
||||
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 == nullptr)
|
||||
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 = nullptr; m_args.reset(); }
|
||||
|
||||
virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const {
|
||||
if (m_q == 0) return CPK_EXPR;
|
||||
cmd_arg_kind next_arg_kind(cmd_context & ctx) const override {
|
||||
if (m_q == nullptr) 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(); }
|
||||
};
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -104,7 +104,7 @@ class poly_isolate_roots_cmd : public cmd {
|
|||
}
|
||||
|
||||
void set_next_arg(cmd_context & ctx, expr * arg) {
|
||||
if (m_p.get() == 0) {
|
||||
if (m_p.get() == nullptr) {
|
||||
scoped_mpz d(m_qm);
|
||||
if (!m_expr2poly.to_polynomial(arg, m_p, d))
|
||||
throw cmd_exception("expression is not a polynomial");
|
||||
|
|
@ -132,7 +132,7 @@ class poly_isolate_roots_cmd : public cmd {
|
|||
}
|
||||
|
||||
void execute(cmd_context & ctx) {
|
||||
if (m_p.get() == 0)
|
||||
if (m_p.get() == nullptr)
|
||||
throw cmd_exception("polynomial expected");
|
||||
polynomial::var_vector xs;
|
||||
m_pm.vars(m_p, xs);
|
||||
|
|
@ -162,37 +162,37 @@ class poly_isolate_roots_cmd : public cmd {
|
|||
scoped_ptr<context> m_ctx;
|
||||
|
||||
public:
|
||||
poly_isolate_roots_cmd(char const * name = "poly/isolate-roots"):cmd(name), m_ctx(0) {}
|
||||
poly_isolate_roots_cmd(char const * name = "poly/isolate-roots"):cmd(name), m_ctx(nullptr) {}
|
||||
|
||||
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) {
|
||||
m_ctx = 0;
|
||||
void finalize(cmd_context & ctx) override {
|
||||
m_ctx = nullptr;
|
||||
}
|
||||
|
||||
virtual void failure_cleanup(cmd_context & ctx) {
|
||||
m_ctx = 0;
|
||||
void failure_cleanup(cmd_context & ctx) override {
|
||||
m_ctx = nullptr;
|
||||
}
|
||||
|
||||
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;
|
||||
m_ctx = nullptr;
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -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;
|
||||
m_target = nullptr;
|
||||
}
|
||||
|
||||
virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const {
|
||||
if (m_target == 0) return CPK_EXPR;
|
||||
cmd_arg_kind next_arg_kind(cmd_context & ctx) const override {
|
||||
if (m_target == nullptr) 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);
|
||||
|
|
|
|||
|
|
@ -117,7 +117,7 @@ static void get_interpolant_and_maybe_check(cmd_context & ctx, expr * t, params_
|
|||
ptr_vector<ast> interps;
|
||||
|
||||
try {
|
||||
iz3interpolate(ctx.m(),pr.get(),cnsts,t,interps,0);
|
||||
iz3interpolate(ctx.m(),pr.get(),cnsts,t,interps,nullptr);
|
||||
}
|
||||
catch (iz3_bad_tree &) {
|
||||
throw cmd_exception("interpolation pattern contains non-asserted formula");
|
||||
|
|
@ -160,7 +160,7 @@ static void compute_interpolant_and_maybe_check(cmd_context & ctx, expr * t, par
|
|||
|
||||
lbool res;
|
||||
try {
|
||||
res = iz3interpolate(_m, *sp.get(), t, cnsts, interps, m, 0);
|
||||
res = iz3interpolate(_m, *sp.get(), t, cnsts, interps, m, nullptr);
|
||||
}
|
||||
catch (iz3_incompleteness &) {
|
||||
throw cmd_exception("incompleteness in interpolator");
|
||||
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ Notes:
|
|||
#include "cmd_context/parametric_cmd.h"
|
||||
|
||||
char const * parametric_cmd::get_descr(cmd_context & ctx) const {
|
||||
if (m_descr == 0) {
|
||||
if (m_descr == nullptr) {
|
||||
const_cast<parametric_cmd*>(this)->m_descr = alloc(string_buffer<>);
|
||||
m_descr->append(get_main_descr());
|
||||
m_descr->append("\nThe following options are available:\n");
|
||||
|
|
|
|||
|
|
@ -30,49 +30,49 @@ public:
|
|||
params_ref m_params;
|
||||
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(char const * name):cmd(name), m_descr(nullptr) {}
|
||||
~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
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@ class psort_inst_cache {
|
|||
sort * m_const;
|
||||
obj_map<sort, void *> m_map; // if m_num_params == 1 value is a sort, otherwise it is a reference to another inst_cache
|
||||
public:
|
||||
psort_inst_cache(unsigned num_params):m_num_params(num_params), m_const(0) {
|
||||
psort_inst_cache(unsigned num_params):m_num_params(num_params), m_const(nullptr) {
|
||||
}
|
||||
|
||||
~psort_inst_cache() { SASSERT(m_map.empty()); SASSERT(m_const == 0); }
|
||||
|
|
@ -36,7 +36,7 @@ public:
|
|||
SASSERT(m_map.empty());
|
||||
if (m_const)
|
||||
m.m().dec_ref(m_const);
|
||||
m_const = 0;
|
||||
m_const = nullptr;
|
||||
}
|
||||
else {
|
||||
SASSERT(m_const == 0);
|
||||
|
|
@ -72,7 +72,7 @@ public:
|
|||
m.m().inc_ref(r);
|
||||
return;
|
||||
}
|
||||
void * next = 0;
|
||||
void * next = nullptr;
|
||||
if (!curr->m_map.find(*s, next)) {
|
||||
next = new (m.a().allocate(sizeof(psort_inst_cache))) psort_inst_cache(curr->m_num_params-1);
|
||||
curr->m_map.insert(*s, next);
|
||||
|
|
@ -91,22 +91,22 @@ public:
|
|||
psort_inst_cache const * curr = this;
|
||||
while (true) {
|
||||
if (curr->m_num_params == 1) {
|
||||
void * r = 0;
|
||||
void * r = nullptr;
|
||||
curr->m_map.find(*s, r);
|
||||
return static_cast<sort*>(r);
|
||||
}
|
||||
else {
|
||||
void * next = 0;
|
||||
void * next = nullptr;
|
||||
curr->m_map.find(*s, next);
|
||||
if (next == 0)
|
||||
return 0;
|
||||
if (next == nullptr)
|
||||
return nullptr;
|
||||
s++;
|
||||
curr = static_cast<psort_inst_cache*>(next);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool empty() const { return m_num_params == 0 ? m_const == 0 : m_map.empty(); }
|
||||
bool empty() const { return m_num_params == 0 ? m_const == nullptr : m_map.empty(); }
|
||||
};
|
||||
|
||||
void psort::cache(pdecl_manager & m, sort * const * s, sort * r) {
|
||||
|
|
@ -117,7 +117,7 @@ void psort::cache(pdecl_manager & m, sort * const * s, sort * r) {
|
|||
|
||||
sort * psort::find(sort * const * s) const {
|
||||
if (!m_inst_cache)
|
||||
return 0;
|
||||
return nullptr;
|
||||
return m_inst_cache->find(s);
|
||||
}
|
||||
|
||||
|
|
@ -127,7 +127,7 @@ void psort::finalize(pdecl_manager & m) {
|
|||
|
||||
void psort::reset_cache(pdecl_manager& m) {
|
||||
m.del_inst_cache(m_inst_cache);
|
||||
m_inst_cache = 0;
|
||||
m_inst_cache = nullptr;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -137,25 +137,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();
|
||||
}
|
||||
};
|
||||
|
|
@ -164,19 +164,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; }
|
||||
|
|
@ -197,13 +197,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(); }
|
||||
|
|
@ -213,7 +213,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;
|
||||
|
|
@ -229,12 +229,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())
|
||||
|
|
@ -250,7 +250,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();
|
||||
}
|
||||
|
|
@ -270,7 +270,7 @@ psort_decl::psort_decl(unsigned id, unsigned num_params, pdecl_manager & m, symb
|
|||
pdecl(id, num_params),
|
||||
m_name(n),
|
||||
m_psort_kind(PSORT_BASE),
|
||||
m_inst_cache(0) {
|
||||
m_inst_cache(nullptr) {
|
||||
}
|
||||
|
||||
void psort_decl::finalize(pdecl_manager & m) {
|
||||
|
|
@ -279,7 +279,7 @@ void psort_decl::finalize(pdecl_manager & m) {
|
|||
|
||||
void psort_decl::reset_cache(pdecl_manager& m) {
|
||||
m.del_inst_cache(m_inst_cache);
|
||||
m_inst_cache = 0;
|
||||
m_inst_cache = nullptr;
|
||||
}
|
||||
|
||||
void psort_decl::cache(pdecl_manager & m, sort * const * s, sort * r) {
|
||||
|
|
@ -290,7 +290,7 @@ void psort_decl::cache(pdecl_manager & m, sort * const * s, sort * r) {
|
|||
|
||||
sort * psort_decl::find(sort * const * s) {
|
||||
if (!m_inst_cache)
|
||||
return 0;
|
||||
return nullptr;
|
||||
return m_inst_cache->find(s);
|
||||
}
|
||||
|
||||
|
|
@ -304,7 +304,7 @@ psort_user_decl::psort_user_decl(unsigned id, unsigned num_params, pdecl_manager
|
|||
|
||||
void psort_user_decl::finalize(pdecl_manager & m) {
|
||||
m.dec_ref(m_def);
|
||||
m_def = 0;
|
||||
m_def = nullptr;
|
||||
psort_decl::finalize(m);
|
||||
}
|
||||
|
||||
|
|
@ -313,7 +313,7 @@ sort * psort_user_decl::instantiate(pdecl_manager & m, unsigned n, sort * const
|
|||
sort * r = find(s);
|
||||
if (r)
|
||||
return r;
|
||||
if (m_def == 0) {
|
||||
if (m_def == nullptr) {
|
||||
buffer<parameter> ps;
|
||||
for (unsigned i = 0; i < n; i++)
|
||||
ps.push_back(parameter(s[i]));
|
||||
|
|
@ -463,7 +463,7 @@ accessor_decl * paccessor_decl::instantiate_decl(pdecl_manager & m, sort * const
|
|||
default:
|
||||
// missing refs must have been eliminated.
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -523,7 +523,7 @@ pdatatype_decl::pdatatype_decl(unsigned id, unsigned num_params, pdecl_manager &
|
|||
symbol const & n, unsigned num_constructors, pconstructor_decl * const * constructors):
|
||||
psort_decl(id, num_params, m, n),
|
||||
m_constructors(num_constructors, constructors),
|
||||
m_parent(0) {
|
||||
m_parent(nullptr) {
|
||||
m.inc_ref(num_constructors, constructors);
|
||||
}
|
||||
|
||||
|
|
@ -634,7 +634,7 @@ bool pdatatype_decl::commit(pdecl_manager& m) {
|
|||
TRACE("datatype", tout << m_name << "\n";);
|
||||
sort_ref_vector ps(m.m());
|
||||
for (unsigned i = 0; i < m_num_params; ++i) {
|
||||
ps.push_back(m.m().mk_uninterpreted_sort(symbol(i), 0, 0));
|
||||
ps.push_back(m.m().mk_uninterpreted_sort(symbol(i), 0, nullptr));
|
||||
}
|
||||
datatype_decl_buffer dts;
|
||||
dts.m_buffer.push_back(instantiate_decl(m, ps.c_ptr()));
|
||||
|
|
@ -713,7 +713,7 @@ bool pdatatypes_decl::commit(pdecl_manager& m) {
|
|||
for (pdatatype_decl* d : m_datatypes) {
|
||||
sort_ref_vector ps(m.m());
|
||||
for (unsigned i = 0; i < d->get_num_params(); ++i) {
|
||||
ps.push_back(m.m().mk_uninterpreted_sort(symbol(i), 0, 0));
|
||||
ps.push_back(m.m().mk_uninterpreted_sort(symbol(i), 0, nullptr));
|
||||
}
|
||||
dts.m_buffer.push_back(d->instantiate_decl(m, ps.c_ptr()));
|
||||
}
|
||||
|
|
@ -753,16 +753,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();
|
||||
}
|
||||
|
|
@ -776,7 +776,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());
|
||||
}
|
||||
|
|
@ -797,11 +797,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();
|
||||
}
|
||||
|
|
@ -814,7 +814,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());
|
||||
}
|
||||
|
|
@ -835,7 +835,7 @@ void pdecl_manager::init_list() {
|
|||
ptype ListT(0);
|
||||
paccessor_decl * as[2] = { mk_paccessor_decl(1, symbol("head"), T),
|
||||
mk_paccessor_decl(1, symbol("tail"), ListT) };
|
||||
pconstructor_decl * cs[2] = { mk_pconstructor_decl(1, symbol("nil"), symbol("is-nil"), 0, 0),
|
||||
pconstructor_decl * cs[2] = { mk_pconstructor_decl(1, symbol("nil"), symbol("is-nil"), 0, nullptr),
|
||||
mk_pconstructor_decl(1, symbol("insert"), symbol("is-insert"), 2, as) };
|
||||
m_list = mk_pdatatype_decl(1, symbol("List"), 2, cs);
|
||||
inc_ref(m_list);
|
||||
|
|
@ -845,8 +845,8 @@ void pdecl_manager::init_list() {
|
|||
pdecl_manager::pdecl_manager(ast_manager & m):
|
||||
m_manager(m),
|
||||
m_allocator(m.get_allocator()),
|
||||
m_new_dt_eh(0) {
|
||||
m_list = 0;
|
||||
m_new_dt_eh(nullptr) {
|
||||
m_list = nullptr;
|
||||
m_datatype_fid = m.mk_family_id("datatype");
|
||||
}
|
||||
|
||||
|
|
@ -858,7 +858,7 @@ pdecl_manager::~pdecl_manager() {
|
|||
}
|
||||
|
||||
psort * pdecl_manager::mk_psort_cnst(sort * s) {
|
||||
psort * r = 0;
|
||||
psort * r = nullptr;
|
||||
if (m_sort2psort.find(s, r))
|
||||
return r;
|
||||
r = new (a().allocate(sizeof(psort_sort))) psort_sort(m_id_gen.mk(), *this, s);
|
||||
|
|
@ -907,9 +907,9 @@ psort * pdecl_manager::mk_psort_app(unsigned num_params, psort_decl * d, unsigne
|
|||
|
||||
psort * pdecl_manager::mk_psort_app(psort_decl * d) {
|
||||
SASSERT(d->get_num_params() == 0 || d->get_num_params() == PSORT_DECL_VAR_PARAMS);
|
||||
sort * s = d->instantiate(*this, 0, static_cast<sort*const*>(0));
|
||||
if (s == 0)
|
||||
return 0;
|
||||
sort * s = d->instantiate(*this, 0, static_cast<sort*const*>(nullptr));
|
||||
if (s == nullptr)
|
||||
return nullptr;
|
||||
return mk_psort_cnst(s);
|
||||
}
|
||||
|
||||
|
|
@ -1011,7 +1011,7 @@ void pdecl_manager::reset_sort_info() {
|
|||
}
|
||||
|
||||
void pdecl_manager::display(std::ostream & out, sort * s) const {
|
||||
sort_info * info = 0;
|
||||
sort_info * info = nullptr;
|
||||
if (m_sort2info.find(s, info)) {
|
||||
info->display(out, *this);
|
||||
return;
|
||||
|
|
@ -1020,7 +1020,7 @@ void pdecl_manager::display(std::ostream & out, sort * s) const {
|
|||
}
|
||||
|
||||
format * pdecl_manager::pp(sort * s) const {
|
||||
sort_info * info = 0;
|
||||
sort_info * info = nullptr;
|
||||
if (m_sort2info.find(s, info)) {
|
||||
return info->pp(*this);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -64,20 +64,20 @@ class psort : public pdecl {
|
|||
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() {}
|
||||
psort(unsigned id, unsigned num_params):pdecl(id, num_params), m_inst_cache(nullptr) {}
|
||||
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:
|
||||
virtual bool is_sort_wrapper() const { return false; }
|
||||
virtual sort * instantiate(pdecl_manager & m, sort * const * s) { return 0; }
|
||||
virtual sort * instantiate(pdecl_manager & m, sort * const * s) { return nullptr; }
|
||||
// we use hash-consing for psorts.
|
||||
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,17 +98,17 @@ 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; }
|
||||
virtual sort * instantiate(pdecl_manager & m) { return instantiate(m, 0, static_cast<sort*const*>(0)); }
|
||||
virtual sort * instantiate(pdecl_manager & m, unsigned n, unsigned const * s) { return nullptr; }
|
||||
virtual sort * instantiate(pdecl_manager & m) { return instantiate(m, 0, static_cast<sort*const*>(nullptr)); }
|
||||
// return true if the declaration accepts a variable number of parameters.
|
||||
// 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;
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -172,7 +172,7 @@ class ptype {
|
|||
};
|
||||
symbol m_missing_ref;
|
||||
public:
|
||||
ptype():m_kind(PTR_PSORT), m_sort(0) {}
|
||||
ptype():m_kind(PTR_PSORT), m_sort(nullptr) {}
|
||||
ptype(int idx):m_kind(PTR_REC_REF), m_idx(idx) {}
|
||||
ptype(psort * s):m_kind(PTR_PSORT), m_sort(s) {}
|
||||
ptype(symbol const & s):m_kind(PTR_MISSING_REF), m_missing_ref(s) {}
|
||||
|
|
@ -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(); }
|
||||
|
|
|
|||
|
|
@ -36,13 +36,13 @@ 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);
|
||||
}
|
||||
m_solver->push();
|
||||
m_solver->assert_expr(e);
|
||||
lbool r = m_solver->check_sat(0,0);
|
||||
lbool r = m_solver->check_sat(0,nullptr);
|
||||
m_solver->pop(1);
|
||||
return r;
|
||||
}
|
||||
|
|
@ -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,25 +66,25 @@ 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;
|
||||
m_target = nullptr;
|
||||
}
|
||||
|
||||
virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const {
|
||||
if (m_target == 0) return CPK_EXPR;
|
||||
cmd_arg_kind next_arg_kind(cmd_context & ctx) const override {
|
||||
if (m_target == nullptr) 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) {
|
||||
if (m_target == 0)
|
||||
void execute(cmd_context & ctx) override {
|
||||
if (m_target == nullptr)
|
||||
throw cmd_exception("invalid simplify command, argument expected");
|
||||
expr_ref r(ctx.m());
|
||||
proof_ref pr(ctx.m());
|
||||
|
|
|
|||
|
|
@ -55,20 +55,20 @@ class declare_tactic_cmd : public cmd {
|
|||
public:
|
||||
declare_tactic_cmd():
|
||||
cmd("declare-tactic"),
|
||||
m_decl(0) {
|
||||
m_decl(nullptr) {
|
||||
}
|
||||
|
||||
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 = nullptr; }
|
||||
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;
|
||||
m_tactic = nullptr;
|
||||
}
|
||||
|
||||
virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const {
|
||||
if (m_tactic == 0) return CPK_SEXPR;
|
||||
cmd_arg_kind next_arg_kind(cmd_context & ctx) const override {
|
||||
if (m_tactic == nullptr) 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");
|
||||
}
|
||||
|
|
@ -297,9 +297,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.");
|
||||
|
|
@ -310,7 +310,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");
|
||||
}
|
||||
|
|
@ -596,9 +596,9 @@ static tactic * mk_echo(cmd_context & ctx, sexpr * n) {
|
|||
if (curr->is_string())
|
||||
t = mk_echo_tactic(ctx, curr->get_string().c_str(), last);
|
||||
else
|
||||
t = mk_probe_value_tactic(ctx, 0, sexpr2probe(ctx, curr), last);
|
||||
t = mk_probe_value_tactic(ctx, nullptr, sexpr2probe(ctx, curr), last);
|
||||
tactic * new_res;
|
||||
if (res.get() == 0)
|
||||
if (res.get() == nullptr)
|
||||
new_res = t;
|
||||
else
|
||||
new_res = and_then(res.get(), t);
|
||||
|
|
@ -607,7 +607,7 @@ static tactic * mk_echo(cmd_context & ctx, sexpr * n) {
|
|||
res = new_res;
|
||||
}
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
static tactic * mk_fail_if_branching(cmd_context & ctx, sexpr * n) {
|
||||
|
|
@ -664,10 +664,10 @@ static tactic * mk_skip_if_failed(cmd_context & ctx, sexpr * n) {
|
|||
tactic * sexpr2tactic(cmd_context & ctx, sexpr * n) {
|
||||
if (n->is_symbol()) {
|
||||
tactic_cmd * cmd = ctx.find_tactic_cmd(n->get_symbol());
|
||||
if (cmd != 0)
|
||||
if (cmd != nullptr)
|
||||
return cmd->mk(ctx.m());
|
||||
sexpr * decl = ctx.find_user_tactic(n->get_symbol());
|
||||
if (decl != 0)
|
||||
if (decl != nullptr)
|
||||
return sexpr2tactic(ctx, decl);
|
||||
throw cmd_exception("invalid tactic, unknown tactic ", n->get_symbol(), n->get_line(), n->get_pos());
|
||||
}
|
||||
|
|
@ -777,7 +777,7 @@ MK_NARY_PROBE(mk_mul);
|
|||
probe * sexpr2probe(cmd_context & ctx, sexpr * n) {
|
||||
if (n->is_symbol()) {
|
||||
probe_info * pinfo = ctx.find_probe(n->get_symbol());
|
||||
if (pinfo != 0)
|
||||
if (pinfo != nullptr)
|
||||
return pinfo->get();
|
||||
throw cmd_exception("invalid probe, unknown builtin probe ", n->get_symbol(), n->get_line(), n->get_pos());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -38,13 +38,13 @@ void tactic_manager::insert(probe_info * p) {
|
|||
}
|
||||
|
||||
tactic_cmd * tactic_manager::find_tactic_cmd(symbol const & s) const {
|
||||
tactic_cmd * c = 0;
|
||||
tactic_cmd * c = nullptr;
|
||||
m_name2tactic.find(s, c);
|
||||
return c;
|
||||
}
|
||||
|
||||
probe_info * tactic_manager::find_probe(symbol const & s) const {
|
||||
probe_info * p = 0;
|
||||
probe_info * p = nullptr;
|
||||
m_name2probe.find(s, p);
|
||||
return p;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue