mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-11-03 21:09:11 +00:00
Code Activity

Use nullptr.

Browse source
This commit is contained in:
Bruce Mitchener 2018-02-12 14:05:55 +07:00
parent f01328c65f
commit 76eb7b9ede
625 changed files with 4639 additions and 4639 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/muz/pdr/pdr_closure.h
View file

@ -35,8 +35,8 @@ namespace pdr {
expr* m_k;
obj_map<func_decl, expr*>* m_translate;
public:
scaler(ast_manager& m): m(m), a(m), m_translate(0) {}
expr_ref operator()(expr* e, expr* k, obj_map<func_decl, expr*>* translate = 0);
scaler(ast_manager& m): m(m), a(m), m_translate(nullptr) {}
expr_ref operator()(expr* e, expr* k, obj_map<func_decl, expr*>* translate = nullptr);
expr_ref undo_k(expr* e, expr* k);
private:
expr_ref scale(expr* e, bool is_mul);

44
src/muz/pdr/pdr_context.cpp
View file

@ -128,7 +128,7 @@ namespace pdr {
std::stringstream name_stm;
name_stm << m_head->get_name() << '_' << i;
func_decl_ref stm(m);
stm = m.mk_func_decl(symbol(name_stm.str().c_str()), 0, (sort*const*)0, arg_sort);
stm = m.mk_func_decl(symbol(name_stm.str().c_str()), 0, (sort*const*)nullptr, arg_sort);
m_sig.push_back(pm.get_o_pred(stm, 0));
}
}
@ -443,7 +443,7 @@ namespace pdr {
else if (is_sat == l_false) {
uses_level = m_solver.assumes_level();
}
m_solver.set_model(0);
m_solver.set_model(nullptr);
return is_sat;
}
@ -459,7 +459,7 @@ namespace pdr {
tmp = pm.mk_and(conj);
prop_solver::scoped_level _sl(m_solver, level);
m_solver.set_core(core);
m_solver.set_model(0);
m_solver.set_model(nullptr);
lbool r = m_solver.check_conjunction_as_assumptions(tmp);
if (r == l_false) {
assumes_level = m_solver.assumes_level();
@ -477,7 +477,7 @@ namespace pdr {
prop_solver::scoped_level _sl(m_solver, level);
m_solver.set_core(&core);
m_solver.set_subset_based_core(true);
m_solver.set_model(0);
m_solver.set_model(nullptr);
lbool res = m_solver.check_assumptions_and_formula(lits, fml);
if (res == l_false) {
lits.reset();
@ -649,7 +649,7 @@ namespace pdr {
expr_free_vars fv;
fv(e);
while (vars.size() < fv.size()) {
vars.push_back(0);
vars.push_back(nullptr);
}
for (unsigned i = 0; i < fv.size(); ++i) {
if (fv[i] && !vars[i].get()) {
@ -821,7 +821,7 @@ namespace pdr {
datalog::rule const& rl2 = pt().find_rule(*mdl);
SASSERT(is_ini(rl2));
set_rule(&rl2);
pt().get_solver().set_model(0);
pt().get_solver().set_model(nullptr);
return const_cast<datalog::rule*>(m_rule);
}
@ -899,7 +899,7 @@ namespace pdr {
if (this == m_next) {
SASSERT(m_prev == this);
if (root == this) {
root = 0;
root = nullptr;
}
}
else {
@ -910,8 +910,8 @@ namespace pdr {
}
}
TRACE("pdr", tout << "new root: " << root << "\n";);
m_prev = 0;
m_next = 0;
m_prev = nullptr;
m_next = nullptr;
}
@ -938,7 +938,7 @@ namespace pdr {
*/
model_node* model_search::next() {
if (!m_goal) {
return 0;
return nullptr;
}
else {
model_node* result = m_goal;
@ -1161,7 +1161,7 @@ namespace pdr {
todo.push_back(m_root);
while (!todo.empty()) {
model_node* n = todo.back();
model* md = 0;
model* md = nullptr;
if (!n->get_model_ptr()) {
if (models.find(n->state(), md)) {
TRACE("pdr", tout << n->state() << "\n";);
@ -1300,7 +1300,7 @@ namespace pdr {
ptr_vector<model_node> todo;
proof_ref_vector trail(m);
datalog::rule_ref_vector rules_trail(rm);
proof* pr = 0;
proof* pr = nullptr;
unif.set_normalize(true);
todo.push_back(m_root);
update_models();
@ -1416,7 +1416,7 @@ namespace pdr {
erase_children(*m_root, false);
remove_node(*m_root, false);
dealloc(m_root);
m_root = 0;
m_root = nullptr;
}
m_cache.reset();
}
@ -1448,10 +1448,10 @@ namespace pdr {
: m_fparams(fparams),
m_params(params),
m(m),
m_context(0),
m_context(nullptr),
m_pm(m_fparams, params.pdr_max_num_contexts(), m),
m_query_pred(m),
m_query(0),
m_query(nullptr),
m_search(m_params.pdr_bfs_model_search()),
m_last_result(l_undef),
m_inductive_lvl(0),
@ -1479,7 +1479,7 @@ namespace pdr {
reset(m_rels_tmp);
}
m_search.reset();
m_query = 0;
m_query = nullptr;
m_last_result = l_undef;
m_inductive_lvl = 0;
}
@ -1546,7 +1546,7 @@ namespace pdr {
init_rules(rules, m_rels_tmp);
decl2rel::iterator it = m_rels_tmp.begin(), end = m_rels_tmp.end();
for (; it != end; ++it) {
pred_transformer* pt = 0;
pred_transformer* pt = nullptr;
if (m_rels.find(it->m_key, pt)) {
it->m_value->inherit_properties(*pt);
}
@ -1561,7 +1561,7 @@ namespace pdr {
}
unsigned context::get_num_levels(func_decl* p) {
pred_transformer* pt = 0;
pred_transformer* pt = nullptr;
if (m_rels.find(p, pt)) {
return pt->get_num_levels();
}
@ -1572,7 +1572,7 @@ namespace pdr {
}
expr_ref context::get_cover_delta(int level, func_decl* p_orig, func_decl* p) {
pred_transformer* pt = 0;
pred_transformer* pt = nullptr;
if (m_rels.find(p, pt)) {
return pt->get_cover_delta(p_orig, level);
}
@ -1583,7 +1583,7 @@ namespace pdr {
}
void context::add_cover(int level, func_decl* p, expr* property) {
pred_transformer* pt = 0;
pred_transformer* pt = nullptr;
if (!m_rels.find(p, pt)) {
pt = alloc(pred_transformer, *this, get_pdr_manager(), p);
m_rels.insert(p, pt);
@ -2026,7 +2026,7 @@ namespace pdr {
//
bool context::check_reachability(unsigned level) {
expr_ref state(m.mk_true(), m);
model_node* root = alloc(model_node, 0, state, *m_query, level);
model_node* root = alloc(model_node, nullptr, state, *m_query, level);
m_search.set_root(root);
while (model_node* node = m_search.next()) {
@ -2403,7 +2403,7 @@ namespace pdr {
if (m_params.print_boogie_certificate()) {
datalog::boogie_proof bp(m);
bp.set_proof(get_proof());
bp.set_model(0);
bp.set_model(nullptr);
bp.pp(strm);
}
else {

10
src/muz/pdr/pdr_context.h
View file

@ -143,7 +143,7 @@ namespace pdr {
void add_property(expr * lemma, unsigned lvl); // add property 'p' to state at level.
lbool is_reachable(model_node& n, expr_ref_vector* core, bool& uses_level);
bool is_invariant(unsigned level, expr* co_state, bool inductive, bool& assumes_level, expr_ref_vector* core = 0);
bool is_invariant(unsigned level, expr* co_state, bool inductive, bool& assumes_level, expr_ref_vector* core = nullptr);
bool check_inductive(unsigned level, expr_ref_vector& state, bool& assumes_level);
expr_ref get_formulas(unsigned level, bool add_axioms);
@ -199,8 +199,8 @@ namespace pdr {
datalog::rule const* m_rule;
public:
model_node(model_node* parent, expr_ref& state, pred_transformer& pt, unsigned level):
m_parent(parent), m_next(0), m_prev(0), m_pt(pt), m_state(state), m_model(0),
m_level(level), m_orig_level(level), m_depth(0), m_closed(false), m_rule(0) {
m_parent(parent), m_next(nullptr), m_prev(nullptr), m_pt(pt), m_state(state), m_model(nullptr),
m_level(level), m_orig_level(level), m_depth(0), m_closed(false), m_rule(nullptr) {
model_node* p = m_parent;
if (p) {
p->m_children.push_back(this);
@ -253,7 +253,7 @@ namespace pdr {
void dequeue(model_node*& root);
void enqueue(model_node* n);
model_node* next() const { return m_next; }
bool is_goal() const { return 0 != next(); }
bool is_goal() const { return nullptr != next(); }
};
class model_search {
@ -271,7 +271,7 @@ namespace pdr {
unsigned num_goals() const;
public:
model_search(bool bfs): m_bfs(bfs), m_root(0), m_goal(0) {}
model_search(bool bfs): m_bfs(bfs), m_root(nullptr), m_goal(nullptr) {}
~model_search();
void reset();

2
src/muz/pdr/pdr_dl_interface.cpp
View file

@ -38,7 +38,7 @@ dl_interface::dl_interface(datalog::context& ctx) :
m_ctx(ctx),
m_pdr_rules(ctx),
m_old_rules(ctx),
m_context(0),
m_context(nullptr),
m_refs(ctx.get_manager()) {
m_context = alloc(pdr::context, ctx.get_fparams(), ctx.get_params(), ctx.get_manager());
}

2
src/muz/pdr/pdr_farkas_learner.cpp
View file

@ -373,7 +373,7 @@ namespace pdr {
farkas_learner::farkas_learner(smt_params& params, ast_manager& outer_mgr)
: m_proof_params(get_proof_params(params)),
m_pr(PGM_ENABLED),
m_constr(0),
m_constr(nullptr),
m_combine_farkas_coefficients(true),
p2o(m_pr, outer_mgr),
o2p(outer_mgr, m_pr)

10
src/muz/pdr/pdr_generalizers.cpp
View file

@ -189,7 +189,7 @@ namespace pdr {
expr_ref fml1 = mk_and(core);
expr_ref fml2 = n.pt().get_formulas(n.level(), false);
fml1_2.push_back(fml1);
fml1_2.push_back(0);
fml1_2.push_back(nullptr);
flatten_and(fml2, fmls);
for (unsigned i = 0; i < fmls.size(); ++i) {
fml2 = m.mk_not(fmls[i].get());
@ -199,7 +199,7 @@ namespace pdr {
tout << "Check states:\n" << mk_pp(state, m) << "\n";
tout << "Old states:\n" << mk_pp(fml2, m) << "\n";
);
model_node nd(0, state, n.pt(), n.level());
model_node nd(nullptr, state, n.pt(), n.level());
pred_transformer::scoped_farkas sf(n.pt(), true);
bool uses_level1 = uses_level;
if (l_false == n.pt().is_reachable(nd, &conv2, uses_level1)) {
@ -236,7 +236,7 @@ namespace pdr {
n.pt().get_solver().set_consequences(&consequences);
pred_transformer::scoped_farkas sf (n.pt(), true);
VERIFY(l_false == n.pt().is_reachable(n, &core1, uses_level1));
n.pt().get_solver().set_consequences(0);
n.pt().get_solver().set_consequences(nullptr);
}
IF_VERBOSE(0,
verbose_stream() << "Consequences: " << consequences.size() << "\n";
@ -257,7 +257,7 @@ namespace pdr {
cstate.push_back(m.mk_not(consequences[i].get()));
}
tmp = m.mk_and(cstate.size(), cstate.c_ptr());
model_node nd(0, tmp, n.pt(), n.level());
model_node nd(nullptr, tmp, n.pt(), n.level());
pred_transformer::scoped_farkas sf (n.pt(), false);
VERIFY(l_false == n.pt().is_reachable(nd, &core1, uses_level1));
}
@ -752,7 +752,7 @@ namespace pdr {
//
void core_induction_generalizer::operator()(model_node& n, expr_ref_vector& core, bool& uses_level) {
model_node* p = n.parent();
if (p == 0) {
if (p == nullptr) {
return;
}
unsigned depth = 2;

2
src/muz/pdr/pdr_manager.h
View file

@ -289,7 +289,7 @@ namespace pdr {
bg is background knowledge and can be null
*/
bool implication_surely_holds(expr * lhs, expr * rhs, expr * bg=0);
bool implication_surely_holds(expr * lhs, expr * rhs, expr * bg=nullptr);
unsigned get_unique_num() { return m_next_unique_num++; }

14
src/muz/pdr/pdr_prop_solver.cpp
View file

@ -234,9 +234,9 @@ namespace pdr {
m_pos_level_atoms(m),
m_neg_level_atoms(m),
m_proxies(m),
m_core(0),
m_model(0),
m_consequences(0),
m_core(nullptr),
m_model(nullptr),
m_consequences(nullptr),
m_subset_based_core(false),
m_use_farkas(false),
m_in_level(false),
@ -249,7 +249,7 @@ namespace pdr {
unsigned idx = level_cnt();
std::stringstream name;
name << m_name << "#level_" << idx;
func_decl * lev_pred = m.mk_fresh_func_decl(name.str().c_str(), 0, 0,m.mk_bool_sort());
func_decl * lev_pred = m.mk_fresh_func_decl(name.str().c_str(), 0, nullptr,m.mk_bool_sort());
m_aux_symbols.insert(lev_pred);
m_level_preds.push_back(lev_pred);
@ -301,7 +301,7 @@ namespace pdr {
safe_assumptions& safe,
const expr_ref_vector& atoms)
{
flet<bool> _model(m_fparams.m_model, m_model != 0);
flet<bool> _model(m_fparams.m_model, m_model != nullptr);
expr_ref_vector expr_atoms(m);
expr_atoms.append(atoms.size(), atoms.c_ptr());
@ -342,8 +342,8 @@ namespace pdr {
extract_subset_core(safe);
SASSERT(expr_atoms.size() >= m_core->size());
}
m_core = 0;
m_model = 0;
m_core = nullptr;
m_model = nullptr;
m_subset_based_core = false;
return result;
}

2
src/muz/pdr/pdr_reachable_cache.cpp
View file

@ -24,7 +24,7 @@ namespace pdr {
reachable_cache::reachable_cache(pdr::manager & pm, datalog::PDR_CACHE_MODE cm)
: m(pm.get_manager()),
m_pm(pm),
m_ctx(0),
m_ctx(nullptr),
m_ref_holder(m),
m_disj_connector(m),
m_cache_mode(cm) {

2
src/muz/pdr/pdr_smt_context_manager.cpp
View file

@ -130,7 +130,7 @@ namespace pdr {
smt_context* smt_context_manager::mk_fresh() {
++m_num_contexts;
app_ref pred(m);
smt::kernel * ctx = 0;
smt::kernel * ctx = nullptr;
if (m_max_num_contexts == 0) {
m_contexts.push_back(alloc(smt::kernel, m, m_fparams));
pred = m.mk_true();

4
src/muz/pdr/pdr_sym_mux.h
View file

@ -122,7 +122,7 @@ public:
func_decl * try_get_primary_by_prefix(func_decl* prefix) const {
func_decl * res;
if(!m_prefix2prim.find(prefix, res)) {
return 0;
return nullptr;
}
return res;
}
@ -133,7 +133,7 @@ public:
func_decl * try_get_by_prefix(func_decl* prefix, unsigned idx) {
func_decl * prim = try_get_primary_by_prefix(prefix);
if(!prim) {
return 0;
return nullptr;
}
return conv(prim, 0, idx);
}

2
src/muz/pdr/pdr_util.cpp
View file

@ -244,7 +244,7 @@ namespace pdr {
}
bool test_eq(expr* e) const {
expr* lhs = 0, *rhs = 0;
expr* lhs = nullptr, *rhs = nullptr;
VERIFY(m.is_eq(e, lhs, rhs));
if (!a.is_int_real(lhs)) {
return true;