mirror of
https://github.com/Z3Prover/z3
synced 2025-04-26 10:35:33 +00:00
Use nullptr.
This commit is contained in:
Bruce Mitchener
parent
f01328c65f
commit
76eb7b9ede
625 changed files with 4639 additions and 4639 deletions
224
src/ast/ast.cpp
224
src/ast/ast.cpp
|
|
@ -405,7 +405,7 @@ sort * get_sort(expr const * n) {
|
|||
break;
|
||||
default:
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -434,18 +434,18 @@ bool compare_nodes(ast const * n1, ast const * n2) {
|
|||
}
|
||||
switch (n1->get_kind()) {
|
||||
case AST_SORT:
|
||||
if ((to_sort(n1)->get_info() == 0) != (to_sort(n2)->get_info() == 0)) {
|
||||
if ((to_sort(n1)->get_info() == nullptr) != (to_sort(n2)->get_info() == nullptr)) {
|
||||
return false;
|
||||
}
|
||||
if (to_sort(n1)->get_info() != 0 && !(*to_sort(n1)->get_info() == *to_sort(n2)->get_info())) {
|
||||
if (to_sort(n1)->get_info() != nullptr && !(*to_sort(n1)->get_info() == *to_sort(n2)->get_info())) {
|
||||
return false;
|
||||
}
|
||||
return to_sort(n1)->get_name() == to_sort(n2)->get_name();
|
||||
case AST_FUNC_DECL:
|
||||
if ((to_func_decl(n1)->get_info() == 0) != (to_func_decl(n2)->get_info() == 0)) {
|
||||
if ((to_func_decl(n1)->get_info() == nullptr) != (to_func_decl(n2)->get_info() == nullptr)) {
|
||||
return false;
|
||||
}
|
||||
if (to_func_decl(n1)->get_info() != 0 && !(*to_func_decl(n1)->get_info() == *to_func_decl(n2)->get_info())) {
|
||||
if (to_func_decl(n1)->get_info() != nullptr && !(*to_func_decl(n1)->get_info() == *to_func_decl(n2)->get_info())) {
|
||||
return false;
|
||||
}
|
||||
return
|
||||
|
|
@ -549,13 +549,13 @@ unsigned get_node_hash(ast const * n) {
|
|||
|
||||
switch (n->get_kind()) {
|
||||
case AST_SORT:
|
||||
if (to_sort(n)->get_info() == 0)
|
||||
if (to_sort(n)->get_info() == nullptr)
|
||||
return to_sort(n)->get_name().hash();
|
||||
else
|
||||
return combine_hash(to_sort(n)->get_name().hash(), to_sort(n)->get_info()->hash());
|
||||
case AST_FUNC_DECL:
|
||||
return ast_array_hash(to_func_decl(n)->get_domain(), to_func_decl(n)->get_arity(),
|
||||
to_func_decl(n)->get_info() == 0 ?
|
||||
to_func_decl(n)->get_info() == nullptr ?
|
||||
to_func_decl(n)->get_name().hash() : combine_hash(to_func_decl(n)->get_name().hash(), to_func_decl(n)->get_info()->hash()));
|
||||
case AST_APP:
|
||||
return ast_array_hash(to_app(n)->get_args(),
|
||||
|
|
@ -587,13 +587,13 @@ void ast_table::erase(ast * n) {
|
|||
unsigned idx = h & mask;
|
||||
cell * c = m_table + idx;
|
||||
SASSERT(!c->is_free());
|
||||
cell * prev = 0;
|
||||
cell * prev = nullptr;
|
||||
while (true) {
|
||||
if (c->m_data == n) {
|
||||
m_size--;
|
||||
if (prev == 0) {
|
||||
if (prev == nullptr) {
|
||||
cell * next = c->m_next;
|
||||
if (next == 0) {
|
||||
if (next == nullptr) {
|
||||
m_used_slots--;
|
||||
c->mark_free();
|
||||
SASSERT(c->is_free());
|
||||
|
|
@ -638,49 +638,49 @@ func_decl * decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, para
|
|||
// -----------------------------------
|
||||
|
||||
basic_decl_plugin::basic_decl_plugin():
|
||||
m_bool_sort(0),
|
||||
m_true_decl(0),
|
||||
m_false_decl(0),
|
||||
m_and_decl(0),
|
||||
m_or_decl(0),
|
||||
m_iff_decl(0),
|
||||
m_xor_decl(0),
|
||||
m_not_decl(0),
|
||||
m_interp_decl(0),
|
||||
m_implies_decl(0),
|
||||
m_bool_sort(nullptr),
|
||||
m_true_decl(nullptr),
|
||||
m_false_decl(nullptr),
|
||||
m_and_decl(nullptr),
|
||||
m_or_decl(nullptr),
|
||||
m_iff_decl(nullptr),
|
||||
m_xor_decl(nullptr),
|
||||
m_not_decl(nullptr),
|
||||
m_interp_decl(nullptr),
|
||||
m_implies_decl(nullptr),
|
||||
|
||||
m_proof_sort(0),
|
||||
m_undef_decl(0),
|
||||
m_true_pr_decl(0),
|
||||
m_asserted_decl(0),
|
||||
m_goal_decl(0),
|
||||
m_modus_ponens_decl(0),
|
||||
m_reflexivity_decl(0),
|
||||
m_symmetry_decl(0),
|
||||
m_transitivity_decl(0),
|
||||
m_quant_intro_decl(0),
|
||||
m_and_elim_decl(0),
|
||||
m_not_or_elim_decl(0),
|
||||
m_rewrite_decl(0),
|
||||
m_pull_quant_decl(0),
|
||||
m_pull_quant_star_decl(0),
|
||||
m_push_quant_decl(0),
|
||||
m_elim_unused_vars_decl(0),
|
||||
m_der_decl(0),
|
||||
m_quant_inst_decl(0),
|
||||
m_proof_sort(nullptr),
|
||||
m_undef_decl(nullptr),
|
||||
m_true_pr_decl(nullptr),
|
||||
m_asserted_decl(nullptr),
|
||||
m_goal_decl(nullptr),
|
||||
m_modus_ponens_decl(nullptr),
|
||||
m_reflexivity_decl(nullptr),
|
||||
m_symmetry_decl(nullptr),
|
||||
m_transitivity_decl(nullptr),
|
||||
m_quant_intro_decl(nullptr),
|
||||
m_and_elim_decl(nullptr),
|
||||
m_not_or_elim_decl(nullptr),
|
||||
m_rewrite_decl(nullptr),
|
||||
m_pull_quant_decl(nullptr),
|
||||
m_pull_quant_star_decl(nullptr),
|
||||
m_push_quant_decl(nullptr),
|
||||
m_elim_unused_vars_decl(nullptr),
|
||||
m_der_decl(nullptr),
|
||||
m_quant_inst_decl(nullptr),
|
||||
|
||||
m_hypothesis_decl(0),
|
||||
m_iff_true_decl(0),
|
||||
m_iff_false_decl(0),
|
||||
m_commutativity_decl(0),
|
||||
m_def_axiom_decl(0),
|
||||
m_lemma_decl(0),
|
||||
m_hypothesis_decl(nullptr),
|
||||
m_iff_true_decl(nullptr),
|
||||
m_iff_false_decl(nullptr),
|
||||
m_commutativity_decl(nullptr),
|
||||
m_def_axiom_decl(nullptr),
|
||||
m_lemma_decl(nullptr),
|
||||
|
||||
m_def_intro_decl(0),
|
||||
m_iff_oeq_decl(0),
|
||||
m_skolemize_decl(0),
|
||||
m_mp_oeq_decl(0),
|
||||
m_hyper_res_decl0(0) {
|
||||
m_def_intro_decl(nullptr),
|
||||
m_iff_oeq_decl(nullptr),
|
||||
m_skolemize_decl(nullptr),
|
||||
m_mp_oeq_decl(nullptr),
|
||||
m_hyper_res_decl0(nullptr) {
|
||||
}
|
||||
|
||||
bool basic_decl_plugin::check_proof_sorts(basic_op_kind k, unsigned arity, sort * const * domain) const {
|
||||
|
|
@ -790,7 +790,7 @@ func_decl * basic_decl_plugin::mk_proof_decl(basic_op_kind k, unsigned num_param
|
|||
}
|
||||
default:
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -852,7 +852,7 @@ func_decl * basic_decl_plugin::mk_proof_decl(basic_op_kind k, unsigned num_paren
|
|||
case PR_HYPER_RESOLVE: return mk_proof_decl("hyper-res", k, num_parents, m_hyper_res_decl0);
|
||||
default:
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1067,10 +1067,10 @@ func_decl * basic_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters
|
|||
case OP_IFF: return m_iff_decl;
|
||||
case OP_IMPLIES: return m_implies_decl;
|
||||
case OP_XOR: return m_xor_decl;
|
||||
case OP_ITE: return arity == 3 ? mk_ite_decl(join(domain[1], domain[2])) : 0;
|
||||
case OP_ITE: return arity == 3 ? mk_ite_decl(join(domain[1], domain[2])) : nullptr;
|
||||
// eq and oeq must have at least two arguments, they can have more since they are chainable
|
||||
case OP_EQ: return arity >= 2 ? mk_eq_decl_core("=", OP_EQ, join(arity, domain), m_eq_decls) : 0;
|
||||
case OP_OEQ: return arity >= 2 ? mk_eq_decl_core("~", OP_OEQ, join(arity, domain), m_oeq_decls) : 0;
|
||||
case OP_EQ: return arity >= 2 ? mk_eq_decl_core("=", OP_EQ, join(arity, domain), m_eq_decls) : nullptr;
|
||||
case OP_OEQ: return arity >= 2 ? mk_eq_decl_core("~", OP_OEQ, join(arity, domain), m_oeq_decls) : nullptr;
|
||||
case OP_DISTINCT: {
|
||||
func_decl_info info(m_family_id, OP_DISTINCT);
|
||||
info.set_pairwise();
|
||||
|
|
@ -1110,10 +1110,10 @@ func_decl * basic_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters
|
|||
case OP_IFF: return m_iff_decl;
|
||||
case OP_IMPLIES: return m_implies_decl;
|
||||
case OP_XOR: return m_xor_decl;
|
||||
case OP_ITE: return num_args == 3 ? mk_ite_decl(join(m_manager->get_sort(args[1]), m_manager->get_sort(args[2]))): 0;
|
||||
case OP_ITE: return num_args == 3 ? mk_ite_decl(join(m_manager->get_sort(args[1]), m_manager->get_sort(args[2]))): nullptr;
|
||||
// eq and oeq must have at least two arguments, they can have more since they are chainable
|
||||
case OP_EQ: return num_args >= 2 ? mk_eq_decl_core("=", OP_EQ, join(num_args, args), m_eq_decls) : 0;
|
||||
case OP_OEQ: return num_args >= 2 ? mk_eq_decl_core("~", OP_OEQ, join(num_args, args), m_oeq_decls) : 0;
|
||||
case OP_EQ: return num_args >= 2 ? mk_eq_decl_core("=", OP_EQ, join(num_args, args), m_eq_decls) : nullptr;
|
||||
case OP_OEQ: return num_args >= 2 ? mk_eq_decl_core("~", OP_OEQ, join(num_args, args), m_oeq_decls) : nullptr;
|
||||
case OP_DISTINCT:
|
||||
return decl_plugin::mk_func_decl(k, num_parameters, parameters, num_args, args, range);
|
||||
default:
|
||||
|
|
@ -1134,7 +1134,7 @@ func_decl * basic_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters
|
|||
expr * basic_decl_plugin::get_some_value(sort * s) {
|
||||
if (s == m_bool_sort)
|
||||
return m_manager->mk_false();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
bool basic_recognizers::is_ite(expr const * n, expr * & t1, expr * & t2, expr * & t3) const {
|
||||
|
|
@ -1168,7 +1168,7 @@ void label_decl_plugin::set_manager(ast_manager * m, family_id id) {
|
|||
|
||||
sort * label_decl_plugin::mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) {
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
func_decl * label_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
|
|
@ -1176,12 +1176,12 @@ func_decl * label_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters
|
|||
if (k == OP_LABEL) {
|
||||
if (arity != 1 || num_parameters < 2 || !parameters[0].is_int() || !parameters[1].is_symbol() || !m_manager->is_bool(domain[0])) {
|
||||
m_manager->raise_exception("invalid label declaration");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
for (unsigned i = 2; i < num_parameters; i++) {
|
||||
if (!parameters[i].is_symbol()) {
|
||||
m_manager->raise_exception("invalid label declaration");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
return m_manager->mk_func_decl(parameters[0].get_int() ? m_lblpos : m_lblneg, arity, domain, domain[0],
|
||||
|
|
@ -1191,15 +1191,15 @@ func_decl * label_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters
|
|||
SASSERT(k == OP_LABEL_LIT);
|
||||
if (arity != 0) {
|
||||
m_manager->raise_exception("invalid label literal declaration");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
for (unsigned i = 0; i < num_parameters; i++) {
|
||||
if (!parameters[i].is_symbol()) {
|
||||
m_manager->raise_exception("invalid label literal declaration");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
return m_manager->mk_func_decl(m_lbllit, 0, static_cast<sort * const *>(0), m_manager->mk_bool_sort(),
|
||||
return m_manager->mk_func_decl(m_lbllit, 0, static_cast<sort * const *>(nullptr), m_manager->mk_bool_sort(),
|
||||
func_decl_info(m_family_id, OP_LABEL_LIT, num_parameters, parameters));
|
||||
}
|
||||
}
|
||||
|
|
@ -1212,7 +1212,7 @@ func_decl * label_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters
|
|||
|
||||
sort * pattern_decl_plugin::mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) {
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
func_decl * pattern_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
|
|
@ -1230,7 +1230,7 @@ func_decl * pattern_decl_plugin::mk_func_decl(decl_kind k, unsigned num_paramete
|
|||
|
||||
sort * model_value_decl_plugin::mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) {
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
func_decl * model_value_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
|
|
@ -1239,7 +1239,7 @@ func_decl * model_value_decl_plugin::mk_func_decl(decl_kind k, unsigned num_para
|
|||
if (arity != 0 || num_parameters != 2 || !parameters[0].is_int() || !parameters[1].is_ast() || !is_sort(parameters[1].get_ast())) {
|
||||
UNREACHABLE();
|
||||
m_manager->raise_exception("invalid model value");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
int idx = parameters[0].get_int();
|
||||
sort * s = to_sort(parameters[1].get_ast());
|
||||
|
|
@ -1247,7 +1247,7 @@ func_decl * model_value_decl_plugin::mk_func_decl(decl_kind k, unsigned num_para
|
|||
buffer << s->get_name().bare_str() << "!val!" << idx;
|
||||
func_decl_info info(m_family_id, k, num_parameters, parameters);
|
||||
info.m_private_parameters = true;
|
||||
return m_manager->mk_func_decl(symbol(buffer.c_str()), 0, static_cast<sort * const *>(0), s, info);
|
||||
return m_manager->mk_func_decl(symbol(buffer.c_str()), 0, static_cast<sort * const *>(nullptr), s, info);
|
||||
}
|
||||
|
||||
bool model_value_decl_plugin::is_value(app* n) const {
|
||||
|
|
@ -1274,7 +1274,7 @@ sort * user_sort_plugin::mk_sort(decl_kind k, unsigned num_parameters, parameter
|
|||
func_decl * user_sort_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
unsigned arity, sort * const * domain, sort * range) {
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
decl_kind user_sort_plugin::register_name(symbol s) {
|
||||
|
|
@ -1307,7 +1307,7 @@ ast_manager::ast_manager(proof_gen_mode m, char const * trace_file, bool is_form
|
|||
m_expr_dependency_manager(*this, m_alloc),
|
||||
m_expr_dependency_array_manager(*this, m_alloc),
|
||||
m_proof_mode(m),
|
||||
m_trace_stream(0),
|
||||
m_trace_stream(nullptr),
|
||||
m_trace_stream_owner(false),
|
||||
m_rec_fun(":rec-fun") {
|
||||
|
||||
|
|
@ -1319,7 +1319,7 @@ ast_manager::ast_manager(proof_gen_mode m, char const * trace_file, bool is_form
|
|||
if (!is_format_manager)
|
||||
m_format_manager = alloc(ast_manager, PGM_DISABLED, m_trace_stream, true);
|
||||
else
|
||||
m_format_manager = 0;
|
||||
m_format_manager = nullptr;
|
||||
init();
|
||||
}
|
||||
|
||||
|
|
@ -1336,7 +1336,7 @@ ast_manager::ast_manager(proof_gen_mode m, std::fstream * trace_stream, bool is_
|
|||
if (!is_format_manager)
|
||||
m_format_manager = alloc(ast_manager, PGM_DISABLED, trace_stream, true);
|
||||
else
|
||||
m_format_manager = 0;
|
||||
m_format_manager = nullptr;
|
||||
init();
|
||||
}
|
||||
|
||||
|
|
@ -1361,7 +1361,7 @@ void ast_manager::init() {
|
|||
m_fresh_id = 0;
|
||||
m_expr_id_gen.reset(0);
|
||||
m_decl_id_gen.reset(c_first_decl_id);
|
||||
m_some_value_proc = 0;
|
||||
m_some_value_proc = nullptr;
|
||||
m_basic_family_id = mk_family_id("basic");
|
||||
m_label_family_id = mk_family_id("label");
|
||||
m_pattern_family_id = mk_family_id("pattern");
|
||||
|
|
@ -1427,14 +1427,14 @@ ast_manager::~ast_manager() {
|
|||
switch (n->get_kind()) {
|
||||
case AST_SORT: {
|
||||
sort_info* info = to_sort(n)->get_info();
|
||||
if (info != 0) {
|
||||
if (info != nullptr) {
|
||||
mark_array_ref(mark, info->get_num_parameters(), info->get_parameters());
|
||||
}
|
||||
break;
|
||||
}
|
||||
case AST_FUNC_DECL: {
|
||||
func_decl_info* info = to_func_decl(n)->get_info();
|
||||
if (info != 0) {
|
||||
if (info != nullptr) {
|
||||
mark_array_ref(mark, info->get_num_parameters(), info->get_parameters());
|
||||
}
|
||||
mark_array_ref(mark, to_func_decl(n)->get_arity(), to_func_decl(n)->get_domain());
|
||||
|
|
@ -1476,14 +1476,14 @@ ast_manager::~ast_manager() {
|
|||
delete_node(a);
|
||||
}
|
||||
}
|
||||
if (m_format_manager != 0)
|
||||
if (m_format_manager != nullptr)
|
||||
dealloc(m_format_manager);
|
||||
if (m_trace_stream_owner) {
|
||||
std::fstream & tmp = * m_trace_stream;
|
||||
tmp << "[eof]\n";
|
||||
tmp.close();
|
||||
dealloc(m_trace_stream);
|
||||
m_trace_stream = 0;
|
||||
m_trace_stream = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1587,7 +1587,7 @@ decl_plugin * ast_manager::get_plugin(family_id fid) const {
|
|||
|
||||
|
||||
bool ast_manager::is_value(expr* e) const {
|
||||
decl_plugin const * p = 0;
|
||||
decl_plugin const * p = nullptr;
|
||||
if (is_app(e)) {
|
||||
p = get_plugin(to_app(e)->get_family_id());
|
||||
return p && p->is_value(to_app(e));
|
||||
|
|
@ -1596,7 +1596,7 @@ bool ast_manager::is_value(expr* e) const {
|
|||
}
|
||||
|
||||
bool ast_manager::is_unique_value(expr* e) const {
|
||||
decl_plugin const * p = 0;
|
||||
decl_plugin const * p = nullptr;
|
||||
if (is_app(e)) {
|
||||
p = get_plugin(to_app(e)->get_family_id());
|
||||
return p && p->is_unique_value(to_app(e));
|
||||
|
|
@ -1698,13 +1698,13 @@ ast * ast_manager::register_node_core(ast * n) {
|
|||
// increment reference counters
|
||||
switch (n->get_kind()) {
|
||||
case AST_SORT:
|
||||
if (to_sort(n)->m_info != 0) {
|
||||
if (to_sort(n)->m_info != nullptr) {
|
||||
to_sort(n)->m_info = alloc(sort_info, *(to_sort(n)->get_info()));
|
||||
to_sort(n)->m_info->init_eh(*this);
|
||||
}
|
||||
break;
|
||||
case AST_FUNC_DECL:
|
||||
if (to_func_decl(n)->m_info != 0) {
|
||||
if (to_func_decl(n)->m_info != nullptr) {
|
||||
to_func_decl(n)->m_info = alloc(func_decl_info, *(to_func_decl(n)->get_info()));
|
||||
to_func_decl(n)->m_info->init_eh(*this);
|
||||
}
|
||||
|
|
@ -1807,14 +1807,14 @@ void ast_manager::delete_node(ast * n) {
|
|||
#endif
|
||||
switch (n->get_kind()) {
|
||||
case AST_SORT:
|
||||
if (to_sort(n)->m_info != 0 && !m_debug_ref_count) {
|
||||
if (to_sort(n)->m_info != nullptr && !m_debug_ref_count) {
|
||||
sort_info * info = to_sort(n)->get_info();
|
||||
info->del_eh(*this);
|
||||
dealloc(info);
|
||||
}
|
||||
break;
|
||||
case AST_FUNC_DECL:
|
||||
if (to_func_decl(n)->m_info != 0 && !m_debug_ref_count) {
|
||||
if (to_func_decl(n)->m_info != nullptr && !m_debug_ref_count) {
|
||||
func_decl_info * info = to_func_decl(n)->get_info();
|
||||
info->del_eh(*this);
|
||||
dealloc(info);
|
||||
|
|
@ -1849,7 +1849,7 @@ sort * ast_manager::mk_sort(family_id fid, decl_kind k, unsigned num_parameters,
|
|||
decl_plugin * p = get_plugin(fid);
|
||||
if (p)
|
||||
return p->mk_sort(k, num_parameters, parameters);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
func_decl * ast_manager::mk_func_decl(family_id fid, decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
|
|
@ -1857,7 +1857,7 @@ func_decl * ast_manager::mk_func_decl(family_id fid, decl_kind k, unsigned num_p
|
|||
decl_plugin * p = get_plugin(fid);
|
||||
if (p)
|
||||
return p->mk_func_decl(k, num_parameters, parameters, arity, domain, range);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
func_decl * ast_manager::mk_func_decl(family_id fid, decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
|
|
@ -1865,33 +1865,33 @@ func_decl * ast_manager::mk_func_decl(family_id fid, decl_kind k, unsigned num_p
|
|||
decl_plugin * p = get_plugin(fid);
|
||||
if (p)
|
||||
return p->mk_func_decl(k, num_parameters, parameters, num_args, args, range);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
app * ast_manager::mk_app(family_id fid, decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
unsigned num_args, expr * const * args, sort * range) {
|
||||
func_decl * decl = mk_func_decl(fid, k, num_parameters, parameters, num_args, args, range);
|
||||
if (decl != 0)
|
||||
if (decl != nullptr)
|
||||
return mk_app(decl, num_args, args);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
app * ast_manager::mk_app(family_id fid, decl_kind k, unsigned num_args, expr * const * args) {
|
||||
return mk_app(fid, k, 0, 0, num_args, args);
|
||||
return mk_app(fid, k, 0, nullptr, num_args, args);
|
||||
}
|
||||
|
||||
app * ast_manager::mk_app(family_id fid, decl_kind k, expr * arg) {
|
||||
return mk_app(fid, k, 0, 0, 1, &arg);
|
||||
return mk_app(fid, k, 0, nullptr, 1, &arg);
|
||||
}
|
||||
|
||||
app * ast_manager::mk_app(family_id fid, decl_kind k, expr * arg1, expr * arg2) {
|
||||
expr * args[2] = { arg1, arg2 };
|
||||
return mk_app(fid, k, 0, 0, 2, args);
|
||||
return mk_app(fid, k, 0, nullptr, 2, args);
|
||||
}
|
||||
|
||||
app * ast_manager::mk_app(family_id fid, decl_kind k, expr * arg1, expr * arg2, expr * arg3) {
|
||||
expr * args[3] = { arg1, arg2, arg3 };
|
||||
return mk_app(fid, k, 0, 0, 3, args);
|
||||
return mk_app(fid, k, 0, nullptr, 3, args);
|
||||
}
|
||||
|
||||
sort * ast_manager::mk_sort(symbol const & name, sort_info * info) {
|
||||
|
|
@ -2062,8 +2062,8 @@ bool ast_manager::coercion_needed(func_decl * decl, unsigned num_args, expr * co
|
|||
}
|
||||
|
||||
app * ast_manager::mk_app_core(func_decl * decl, unsigned num_args, expr * const * args) {
|
||||
app * r = 0;
|
||||
app * new_node = 0;
|
||||
app * r = nullptr;
|
||||
app * new_node = nullptr;
|
||||
unsigned sz = app::get_obj_size(num_args);
|
||||
void * mem = allocate_node(sz);
|
||||
|
||||
|
|
@ -2171,7 +2171,7 @@ app * ast_manager::mk_app(func_decl * decl, unsigned num_args, expr * const * ar
|
|||
<< ") passed to function " << mk_pp(decl, *this);
|
||||
throw ast_exception(buffer.str().c_str());
|
||||
}
|
||||
app * r = 0;
|
||||
app * r = nullptr;
|
||||
if (num_args == 1 && decl->is_chainable() && decl->get_arity() == 2) {
|
||||
r = mk_true();
|
||||
}
|
||||
|
|
@ -2200,7 +2200,7 @@ app * ast_manager::mk_app(func_decl * decl, unsigned num_args, expr * const * ar
|
|||
r = mk_and(new_args.size(), new_args.c_ptr());
|
||||
}
|
||||
}
|
||||
if (r == 0) {
|
||||
if (r == nullptr) {
|
||||
r = mk_app_core(decl, num_args, args);
|
||||
}
|
||||
SASSERT(r != 0);
|
||||
|
|
@ -2287,7 +2287,7 @@ app * ast_manager::mk_label_lit(unsigned num_names, symbol const * names) {
|
|||
buffer<parameter> p;
|
||||
for (unsigned i = 0; i < num_names; i++)
|
||||
p.push_back(parameter(names[i]));
|
||||
return mk_app(m_label_family_id, OP_LABEL_LIT, p.size(), p.c_ptr(), 0, 0);
|
||||
return mk_app(m_label_family_id, OP_LABEL_LIT, p.size(), p.c_ptr(), 0, nullptr);
|
||||
}
|
||||
|
||||
app * ast_manager::mk_label_lit(symbol const & name) {
|
||||
|
|
@ -2309,7 +2309,7 @@ app * ast_manager::mk_pattern(unsigned num_exprs, app * const * exprs) {
|
|||
for (unsigned i = 0; i < num_exprs; ++i) {
|
||||
SASSERT(is_app(exprs[i]));
|
||||
}});
|
||||
return mk_app(m_pattern_family_id, OP_PATTERN, 0, 0, num_exprs, (expr*const*)exprs);
|
||||
return mk_app(m_pattern_family_id, OP_PATTERN, 0, nullptr, num_exprs, (expr*const*)exprs);
|
||||
}
|
||||
|
||||
bool ast_manager::is_pattern(expr const * n) const {
|
||||
|
|
@ -2406,7 +2406,7 @@ quantifier * ast_manager::update_quantifier(quantifier * q, unsigned num_pattern
|
|||
num_patterns,
|
||||
patterns,
|
||||
num_patterns == 0 ? q->get_num_no_patterns() : 0,
|
||||
num_patterns == 0 ? q->get_no_patterns() : 0);
|
||||
num_patterns == 0 ? q->get_no_patterns() : nullptr);
|
||||
}
|
||||
|
||||
quantifier * ast_manager::update_quantifier(quantifier * q, unsigned num_patterns, expr * const * patterns, unsigned num_no_patterns, expr * const * no_patterns, expr * body) {
|
||||
|
|
@ -2492,7 +2492,7 @@ quantifier * ast_manager::update_quantifier(quantifier * q, bool is_forall, unsi
|
|||
num_patterns,
|
||||
patterns,
|
||||
num_patterns == 0 ? q->get_num_no_patterns() : 0,
|
||||
num_patterns == 0 ? q->get_no_patterns() : 0);
|
||||
num_patterns == 0 ? q->get_no_patterns() : nullptr);
|
||||
}
|
||||
|
||||
app * ast_manager::mk_distinct(unsigned num_args, expr * const * args) {
|
||||
|
|
@ -2524,14 +2524,14 @@ app * ast_manager::mk_distinct_expanded(unsigned num_args, expr * const * args)
|
|||
// -----------------------------------
|
||||
|
||||
expr_dependency * ast_manager::mk_leaf(expr * t) {
|
||||
if (t == 0)
|
||||
return 0;
|
||||
if (t == nullptr)
|
||||
return nullptr;
|
||||
else
|
||||
return m_expr_dependency_manager.mk_leaf(t);
|
||||
}
|
||||
|
||||
expr_dependency * ast_manager::mk_join(unsigned n, expr * const * ts) {
|
||||
expr_dependency * d = 0;
|
||||
expr_dependency * d = nullptr;
|
||||
for (unsigned i = 0; i < n; i++)
|
||||
d = mk_join(d, mk_leaf(ts[i]));
|
||||
return d;
|
||||
|
|
@ -2550,7 +2550,7 @@ void ast_manager::linearize(expr_dependency * d, ptr_vector<expr> & ts) {
|
|||
|
||||
app * ast_manager::mk_model_value(unsigned idx, sort * s) {
|
||||
parameter p[2] = { parameter(idx), parameter(s) };
|
||||
return mk_app(m_model_value_family_id, OP_MODEL_VALUE, 2, p, 0, static_cast<expr * const *>(0));
|
||||
return mk_app(m_model_value_family_id, OP_MODEL_VALUE, 2, p, 0, static_cast<expr * const *>(nullptr));
|
||||
}
|
||||
|
||||
expr * ast_manager::get_some_value(sort * s, some_value_proc * p) {
|
||||
|
|
@ -2559,17 +2559,17 @@ expr * ast_manager::get_some_value(sort * s, some_value_proc * p) {
|
|||
}
|
||||
|
||||
expr * ast_manager::get_some_value(sort * s) {
|
||||
expr * v = 0;
|
||||
expr * v = nullptr;
|
||||
if (m_some_value_proc)
|
||||
v = (*m_some_value_proc)(s);
|
||||
if (v != 0)
|
||||
if (v != nullptr)
|
||||
return v;
|
||||
family_id fid = s->get_family_id();
|
||||
if (fid != null_family_id) {
|
||||
decl_plugin * p = get_plugin(fid);
|
||||
if (p != 0) {
|
||||
if (p != nullptr) {
|
||||
v = p->get_some_value(s);
|
||||
if (v != 0)
|
||||
if (v != nullptr)
|
||||
return v;
|
||||
}
|
||||
}
|
||||
|
|
@ -2582,7 +2582,7 @@ bool ast_manager::is_fully_interp(sort * s) const {
|
|||
family_id fid = s->get_family_id();
|
||||
SASSERT(fid != null_family_id);
|
||||
decl_plugin * p = get_plugin(fid);
|
||||
if (p != 0)
|
||||
if (p != nullptr)
|
||||
return p->is_fully_interp(s);
|
||||
return false;
|
||||
}
|
||||
|
|
@ -2780,14 +2780,14 @@ proof * ast_manager::mk_congruence(app * f1, app * f2, unsigned num_proofs, proo
|
|||
SASSERT(get_sort(f1) == get_sort(f2));
|
||||
sort * s = get_sort(f1);
|
||||
sort * d[2] = { s, s };
|
||||
return mk_monotonicity(mk_func_decl(m_basic_family_id, get_eq_op(f1), 0, 0, 2, d), f1, f2, num_proofs, proofs);
|
||||
return mk_monotonicity(mk_func_decl(m_basic_family_id, get_eq_op(f1), 0, nullptr, 2, d), f1, f2, num_proofs, proofs);
|
||||
}
|
||||
|
||||
proof * ast_manager::mk_oeq_congruence(app * f1, app * f2, unsigned num_proofs, proof * const * proofs) {
|
||||
SASSERT(get_sort(f1) == get_sort(f2));
|
||||
sort * s = get_sort(f1);
|
||||
sort * d[2] = { s, s };
|
||||
return mk_monotonicity(mk_func_decl(m_basic_family_id, OP_OEQ, 0, 0, 2, d), f1, f2, num_proofs, proofs);
|
||||
return mk_monotonicity(mk_func_decl(m_basic_family_id, OP_OEQ, 0, nullptr, 2, d), f1, f2, num_proofs, proofs);
|
||||
}
|
||||
|
||||
proof * ast_manager::mk_quant_intro(quantifier * q1, quantifier * q2, proof * p) {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue