mirror of
https://github.com/Z3Prover/z3
synced 2025-04-29 20:05:51 +00:00
Use nullptr.
This commit is contained in:
Bruce Mitchener
parent
f01328c65f
commit
76eb7b9ede
625 changed files with 4639 additions and 4639 deletions
|
|
@ -87,7 +87,7 @@ bool theory_seq::solution_map::is_root(expr* e) const {
|
|||
|
||||
// e1 -> ... x, e2 -> ... x
|
||||
void theory_seq::solution_map::find_rec(expr* e, svector<std::pair<expr*, dependency*> >& finds) {
|
||||
dependency* d = 0;
|
||||
dependency* d = nullptr;
|
||||
std::pair<expr*, dependency*> value(e, d);
|
||||
do {
|
||||
e = value.first;
|
||||
|
|
@ -111,7 +111,7 @@ bool theory_seq::solution_map::find1(expr* e, expr*& r, dependency*& d) {
|
|||
|
||||
expr* theory_seq::solution_map::find(expr* e, dependency*& d) {
|
||||
std::pair<expr*, dependency*> value;
|
||||
d = 0;
|
||||
d = nullptr;
|
||||
expr* result = e;
|
||||
while (m_map.find(result, value)) {
|
||||
d = m_dm.mk_join(d, value.second);
|
||||
|
|
@ -199,12 +199,12 @@ theory_seq::theory_seq(ast_manager& m):
|
|||
m_reset_cache(false),
|
||||
m_eq_id(0),
|
||||
m_find(*this),
|
||||
m_factory(0),
|
||||
m_factory(nullptr),
|
||||
m_exclude(m),
|
||||
m_axioms(m),
|
||||
m_axioms_head(0),
|
||||
m_int_string(m),
|
||||
m_mg(0),
|
||||
m_mg(nullptr),
|
||||
m_rewrite(m),
|
||||
m_seq_rewrite(m),
|
||||
m_util(m),
|
||||
|
|
@ -381,7 +381,7 @@ bool theory_seq::branch_binary_variable(eq const& e) {
|
|||
// |x| - |y| = |ys| - |xs|
|
||||
expr_ref a(mk_sub(m_util.str.mk_length(x), m_util.str.mk_length(y)), m);
|
||||
expr_ref b(m_autil.mk_int(ys.size()-xs.size()), m);
|
||||
propagate_lit(e.dep(), 0, 0, mk_eq(a, b, false));
|
||||
propagate_lit(e.dep(), 0, nullptr, mk_eq(a, b, false));
|
||||
return true;
|
||||
}
|
||||
if (lenX <= rational(ys.size())) {
|
||||
|
|
@ -456,7 +456,7 @@ void theory_seq::branch_unit_variable(dependency* dep, expr* X, expr_ref_vector
|
|||
if (lenX > rational(units.size())) {
|
||||
expr_ref le(m_autil.mk_le(m_util.str.mk_length(X), m_autil.mk_int(units.size())), m);
|
||||
TRACE("seq", tout << "propagate length on " << mk_pp(X, m) << "\n";);
|
||||
propagate_lit(dep, 0, 0, mk_literal(le));
|
||||
propagate_lit(dep, 0, nullptr, mk_literal(le));
|
||||
return;
|
||||
}
|
||||
SASSERT(lenX.is_unsigned());
|
||||
|
|
@ -1003,7 +1003,7 @@ bool theory_seq::fixed_length(expr* e) {
|
|||
*/
|
||||
void theory_seq::propagate_non_empty(literal lit, expr* s) {
|
||||
SASSERT(get_context().get_assignment(lit) == l_true);
|
||||
propagate_lit(0, 1, &lit, ~mk_eq_empty(s));
|
||||
propagate_lit(nullptr, 1, &lit, ~mk_eq_empty(s));
|
||||
}
|
||||
|
||||
bool theory_seq::propagate_is_conc(expr* e, expr* conc) {
|
||||
|
|
@ -1011,7 +1011,7 @@ bool theory_seq::propagate_is_conc(expr* e, expr* conc) {
|
|||
context& ctx = get_context();
|
||||
literal lit = ~mk_eq_empty(e);
|
||||
if (ctx.get_assignment(lit) == l_true) {
|
||||
propagate_lit(0, 1, &lit, mk_eq(e, conc, false));
|
||||
propagate_lit(nullptr, 1, &lit, mk_eq(e, conc, false));
|
||||
expr_ref e1(e, m), e2(conc, m);
|
||||
new_eq_eh(m_dm.mk_leaf(assumption(lit)), ctx.get_enode(e1), ctx.get_enode(e2));
|
||||
return true;
|
||||
|
|
@ -1060,9 +1060,9 @@ bool theory_seq::is_post(expr* e, expr*& s, expr*& i) {
|
|||
|
||||
|
||||
expr_ref theory_seq::mk_nth(expr* s, expr* idx) {
|
||||
sort* char_sort = 0;
|
||||
sort* char_sort = nullptr;
|
||||
VERIFY(m_util.is_seq(m.get_sort(s), char_sort));
|
||||
return mk_skolem(m_nth, s, idx, 0, char_sort);
|
||||
return mk_skolem(m_nth, s, idx, nullptr, char_sort);
|
||||
}
|
||||
|
||||
expr_ref theory_seq::mk_sk_ite(expr* c, expr* t, expr* e) {
|
||||
|
|
@ -1074,9 +1074,9 @@ expr_ref theory_seq::mk_last(expr* s) {
|
|||
if (m_util.str.is_string(s, str) && str.length() > 0) {
|
||||
return expr_ref(m_util.str.mk_char(str, str.length()-1), m);
|
||||
}
|
||||
sort* char_sort = 0;
|
||||
sort* char_sort = nullptr;
|
||||
VERIFY(m_util.is_seq(m.get_sort(s), char_sort));
|
||||
return mk_skolem(m_seq_last, s, 0, 0, char_sort);
|
||||
return mk_skolem(m_seq_last, s, nullptr, nullptr, char_sort);
|
||||
}
|
||||
|
||||
expr_ref theory_seq::mk_first(expr* s) {
|
||||
|
|
@ -1089,7 +1089,7 @@ expr_ref theory_seq::mk_first(expr* s) {
|
|||
|
||||
|
||||
void theory_seq::mk_decompose(expr* e, expr_ref& head, expr_ref& tail) {
|
||||
expr* e1 = 0, *e2 = 0;
|
||||
expr* e1 = nullptr, *e2 = nullptr;
|
||||
zstring s;
|
||||
if (m_util.str.is_empty(e)) {
|
||||
head = m_util.str.mk_unit(mk_nth(e, m_autil.mk_int(0)));
|
||||
|
|
@ -1136,7 +1136,7 @@ bool theory_seq::check_extensionality() {
|
|||
continue;
|
||||
}
|
||||
if (!seqs.empty() && ctx.is_relevant(n1) && m_util.is_seq(o1) && ctx.is_shared(n1)) {
|
||||
dependency* dep = 0;
|
||||
dependency* dep = nullptr;
|
||||
expr_ref e1 = canonize(o1, dep);
|
||||
for (unsigned i = 0; i < seqs.size(); ++i) {
|
||||
enode* n2 = get_enode(seqs[i]);
|
||||
|
|
@ -1237,7 +1237,7 @@ bool theory_seq::linearize(dependency* dep, enode_pair_vector& eqs, literal_vect
|
|||
lits.push_back(a.lit);
|
||||
asserted &= ctx.get_assignment(a.lit) == l_true;
|
||||
}
|
||||
if (a.n1 != 0) {
|
||||
if (a.n1 != nullptr) {
|
||||
eqs.push_back(enode_pair(a.n1, a.n2));
|
||||
}
|
||||
}
|
||||
|
|
@ -1286,7 +1286,7 @@ void theory_seq::set_conflict(dependency* dep, literal_vector const& _lits) {
|
|||
ctx.set_conflict(
|
||||
ctx.mk_justification(
|
||||
ext_theory_conflict_justification(
|
||||
get_id(), ctx.get_region(), lits.size(), lits.c_ptr(), eqs.size(), eqs.c_ptr(), 0, 0)));
|
||||
get_id(), ctx.get_region(), lits.size(), lits.c_ptr(), eqs.size(), eqs.c_ptr(), 0, nullptr)));
|
||||
}
|
||||
|
||||
void theory_seq::propagate_eq(dependency* dep, enode* n1, enode* n2) {
|
||||
|
|
@ -1438,7 +1438,7 @@ bool theory_seq::occurs(expr* a, expr* b) {
|
|||
// true if a occurs under an interpreted function or under left/right selector.
|
||||
SASSERT(is_var(a));
|
||||
SASSERT(m_todo.empty());
|
||||
expr* e1 = 0, *e2 = 0;
|
||||
expr* e1 = nullptr, *e2 = nullptr;
|
||||
m_todo.push_back(b);
|
||||
while (!m_todo.empty()) {
|
||||
b = m_todo.back();
|
||||
|
|
@ -1508,7 +1508,7 @@ bool theory_seq::solve_eq(expr_ref_vector const& l, expr_ref_vector const& r, de
|
|||
expr_ref_vector& ls = m_ls;
|
||||
expr_ref_vector& rs = m_rs;
|
||||
rs.reset(); ls.reset();
|
||||
dependency* dep2 = 0;
|
||||
dependency* dep2 = nullptr;
|
||||
bool change = canonize(l, ls, dep2);
|
||||
change = canonize(r, rs, dep2) || change;
|
||||
deps = m_dm.mk_join(dep2, deps);
|
||||
|
|
@ -1545,7 +1545,7 @@ bool theory_seq::propagate_max_length(expr* l, expr* r, dependency* deps) {
|
|||
}
|
||||
rational hi;
|
||||
if (is_tail(l, s, idx) && has_length(s) && m_util.str.is_empty(r) && !upper_bound(s, hi)) {
|
||||
propagate_lit(deps, 0, 0, mk_literal(m_autil.mk_le(m_util.str.mk_length(s), m_autil.mk_int(idx+1))));
|
||||
propagate_lit(deps, 0, nullptr, mk_literal(m_autil.mk_le(m_util.str.mk_length(s), m_autil.mk_int(idx+1))));
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
|
|
@ -1737,7 +1737,7 @@ bool theory_seq::solve_binary_eq(expr_ref_vector const& ls, expr_ref_vector cons
|
|||
}
|
||||
ctx.mark_as_relevant(eq);
|
||||
if (sz == 1) {
|
||||
propagate_lit(dep, 0, 0, eq);
|
||||
propagate_lit(dep, 0, nullptr, eq);
|
||||
return true;
|
||||
}
|
||||
m_new_propagation = true;
|
||||
|
|
@ -1885,7 +1885,7 @@ bool theory_seq::solve_ne(unsigned idx) {
|
|||
expr_ref_vector& lhs = m_lhs;
|
||||
expr_ref_vector& rhs = m_rhs;
|
||||
ls.reset(); rs.reset(); lhs.reset(); rhs.reset();
|
||||
dependency* deps = 0;
|
||||
dependency* deps = nullptr;
|
||||
bool change = false;
|
||||
change = canonize(n.ls(i), ls, deps) || change;
|
||||
change = canonize(n.rs(i), rs, deps) || change;
|
||||
|
|
@ -1991,7 +1991,7 @@ bool theory_seq::solve_ne(unsigned idx) {
|
|||
if (num_undef_lits == 0 && new_ls.empty()) {
|
||||
TRACE("seq", tout << "conflict\n";);
|
||||
|
||||
dependency* deps1 = 0;
|
||||
dependency* deps1 = nullptr;
|
||||
if (explain_eq(n.l(), n.r(), deps1)) {
|
||||
literal diseq = mk_eq(n.l(), n.r(), false);
|
||||
if (ctx.get_assignment(diseq) == l_false) {
|
||||
|
|
@ -2034,10 +2034,10 @@ bool theory_seq::solve_nc(unsigned idx) {
|
|||
return true;
|
||||
}
|
||||
|
||||
expr* e1 = 0, *e2 = 0;
|
||||
expr* e1 = nullptr, *e2 = nullptr;
|
||||
if (m.is_eq(c, e1, e2)) {
|
||||
literal eq = mk_eq(e1, e2, false);
|
||||
propagate_lit(deps, 0, 0, ~eq);
|
||||
propagate_lit(deps, 0, nullptr, ~eq);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -2059,7 +2059,7 @@ theory_seq::cell* theory_seq::mk_cell(cell* p, expr* e, dependency* d) {
|
|||
}
|
||||
|
||||
void theory_seq::unfold(cell* c, ptr_vector<cell>& cons) {
|
||||
dependency* dep = 0;
|
||||
dependency* dep = nullptr;
|
||||
expr* a, *e1, *e2;
|
||||
if (m_rep.find1(c->m_expr, a, dep)) {
|
||||
cell* c1 = mk_cell(c, a, m_dm.mk_join(dep, c->m_dep));
|
||||
|
|
@ -2067,7 +2067,7 @@ void theory_seq::unfold(cell* c, ptr_vector<cell>& cons) {
|
|||
}
|
||||
else if (m_util.str.is_concat(c->m_expr, e1, e2)) {
|
||||
cell* c1 = mk_cell(c, e1, c->m_dep);
|
||||
cell* c2 = mk_cell(0, e2, 0);
|
||||
cell* c2 = mk_cell(nullptr, e2, nullptr);
|
||||
unfold(c1, cons);
|
||||
unfold(c2, cons);
|
||||
}
|
||||
|
|
@ -2085,7 +2085,7 @@ void theory_seq::unfold(cell* c, ptr_vector<cell>& cons) {
|
|||
|
||||
void theory_seq::display_explain(std::ostream& out, unsigned indent, expr* e) {
|
||||
expr* e1, *e2, *a;
|
||||
dependency* dep = 0;
|
||||
dependency* dep = nullptr;
|
||||
smt2_pp_environment_dbg env(m);
|
||||
params_ref p;
|
||||
for (unsigned i = 0; i < indent; ++i) out << " ";
|
||||
|
|
@ -2109,8 +2109,8 @@ bool theory_seq::explain_eq(expr* e1, expr* e2, dependency*& dep) {
|
|||
expr* a1, *a2;
|
||||
ptr_vector<cell> v1, v2;
|
||||
unsigned cells_sz = m_all_cells.size();
|
||||
cell* c1 = mk_cell(0, e1, 0);
|
||||
cell* c2 = mk_cell(0, e2, 0);
|
||||
cell* c1 = mk_cell(nullptr, e1, nullptr);
|
||||
cell* c2 = mk_cell(nullptr, e2, nullptr);
|
||||
unfold(c1, v1);
|
||||
unfold(c2, v2);
|
||||
unsigned i = 0, j = 0;
|
||||
|
|
@ -2300,7 +2300,7 @@ bool theory_seq::internalize_term(app* term) {
|
|||
ctx.mark_as_relevant(bv);
|
||||
}
|
||||
|
||||
enode* e = 0;
|
||||
enode* e = nullptr;
|
||||
if (ctx.e_internalized(term)) {
|
||||
e = ctx.get_enode(term);
|
||||
}
|
||||
|
|
@ -2358,7 +2358,7 @@ bool theory_seq::check_int_string() {
|
|||
|
||||
bool theory_seq::add_stoi_axiom(expr* e) {
|
||||
context& ctx = get_context();
|
||||
expr* n = 0;
|
||||
expr* n = nullptr;
|
||||
rational val;
|
||||
TRACE("seq", tout << mk_pp(e, m) << "\n";);
|
||||
VERIFY(m_util.str.is_stoi(e, n));
|
||||
|
|
@ -2426,7 +2426,7 @@ bool theory_seq::add_stoi_axiom(expr* e) {
|
|||
|
||||
literal theory_seq::is_digit(expr* ch) {
|
||||
bv_util bv(m);
|
||||
literal isd = mk_literal(mk_skolem(symbol("seq.is_digit"), ch, 0, 0, m.mk_bool_sort()));
|
||||
literal isd = mk_literal(mk_skolem(symbol("seq.is_digit"), ch, nullptr, nullptr, m.mk_bool_sort()));
|
||||
expr_ref d2i = digit2int(ch);
|
||||
expr_ref _lo(bv.mk_ule(bv.mk_numeral(rational('0'), bv.mk_sort(8)), ch), m);
|
||||
expr_ref _hi(bv.mk_ule(ch, bv.mk_numeral(rational('9'), bv.mk_sort(8))), m);
|
||||
|
|
@ -2442,13 +2442,13 @@ literal theory_seq::is_digit(expr* ch) {
|
|||
}
|
||||
|
||||
expr_ref theory_seq::digit2int(expr* ch) {
|
||||
return expr_ref(mk_skolem(symbol("seq.digit2int"), ch, 0, 0, m_autil.mk_int()), m);
|
||||
return expr_ref(mk_skolem(symbol("seq.digit2int"), ch, nullptr, nullptr, m_autil.mk_int()), m);
|
||||
}
|
||||
|
||||
bool theory_seq::add_itos_axiom(expr* e) {
|
||||
context& ctx = get_context();
|
||||
rational val;
|
||||
expr* n = 0;
|
||||
expr* n = nullptr;
|
||||
TRACE("seq", tout << mk_pp(e, m) << "\n";);
|
||||
VERIFY(m_util.str.is_itos(e, n));
|
||||
if (get_num_value(n, val)) {
|
||||
|
|
@ -2656,7 +2656,7 @@ void theory_seq::init_search_eh() {
|
|||
void theory_seq::init_model(expr_ref_vector const& es) {
|
||||
expr_ref new_s(m);
|
||||
for (expr* e : es) {
|
||||
dependency* eqs = 0;
|
||||
dependency* eqs = nullptr;
|
||||
expr_ref s = canonize(e, eqs);
|
||||
if (is_var(s)) {
|
||||
new_s = m_factory->get_fresh_value(m.get_sort(s));
|
||||
|
|
@ -2734,7 +2734,7 @@ public:
|
|||
break;
|
||||
}
|
||||
case string_source: {
|
||||
dependency* deps = 0;
|
||||
dependency* deps = nullptr;
|
||||
expr_ref tmp = th.canonize(m_strings[k], deps);
|
||||
zstring zs;
|
||||
if (th.m_util.str.is_string(tmp, zs)) {
|
||||
|
|
@ -2848,7 +2848,7 @@ app* theory_seq::mk_value(app* e) {
|
|||
}
|
||||
m_factory->add_trail(result);
|
||||
TRACE("seq", tout << mk_pp(e, m) << " -> " << result << "\n";);
|
||||
m_rep.update(e, result, 0);
|
||||
m_rep.update(e, result, nullptr);
|
||||
return to_app(result);
|
||||
}
|
||||
|
||||
|
|
@ -2944,7 +2944,7 @@ expr_ref theory_seq::expand1(expr* e0, dependency*& eqs) {
|
|||
expr_ref result(m);
|
||||
result = try_expand(e0, eqs);
|
||||
if (result) return result;
|
||||
dependency* deps = 0;
|
||||
dependency* deps = nullptr;
|
||||
expr* e = m_rep.find(e0, deps);
|
||||
expr* e1, *e2, *e3;
|
||||
expr_ref arg1(m), arg2(m);
|
||||
|
|
@ -3074,7 +3074,7 @@ expr_ref theory_seq::expand1(expr* e0, dependency*& eqs) {
|
|||
result = e;
|
||||
}
|
||||
if (result == e0) {
|
||||
deps = 0;
|
||||
deps = nullptr;
|
||||
}
|
||||
expr_dep edr(result, deps);
|
||||
m_rep.add_cache(e0, edr);
|
||||
|
|
@ -3204,7 +3204,7 @@ void theory_seq::tightest_prefix(expr* s, expr* x) {
|
|||
(len(s) <= len(t) -> i <= len(t)-len(s))
|
||||
*/
|
||||
void theory_seq::add_indexof_axiom(expr* i) {
|
||||
expr* s = 0, *t = 0, *offset = 0;
|
||||
expr* s = nullptr, *t = nullptr, *offset = nullptr;
|
||||
rational r;
|
||||
VERIFY(m_util.str.is_index(i, t, s) ||
|
||||
m_util.str.is_index(i, t, s, offset));
|
||||
|
|
@ -3289,7 +3289,7 @@ void theory_seq::add_indexof_axiom(expr* i) {
|
|||
*/
|
||||
void theory_seq::add_replace_axiom(expr* r) {
|
||||
context& ctx = get_context();
|
||||
expr* a = 0, *s = 0, *t = 0;
|
||||
expr* a = nullptr, *s = nullptr, *t = nullptr;
|
||||
VERIFY(m_util.str.is_replace(r, a, s, t));
|
||||
expr_ref x = mk_skolem(m_indexof_left, a, s);
|
||||
expr_ref y = mk_skolem(m_indexof_right, a, s);
|
||||
|
|
@ -3319,7 +3319,7 @@ void theory_seq::add_elim_string_axiom(expr* n) {
|
|||
result = mk_concat(m_util.str.mk_unit(m_util.str.mk_char(s, i)), result);
|
||||
}
|
||||
add_axiom(mk_eq(n, result, false));
|
||||
m_rep.update(n, result, 0);
|
||||
m_rep.update(n, result, nullptr);
|
||||
m_new_solution = true;
|
||||
}
|
||||
|
||||
|
|
@ -3335,7 +3335,7 @@ void theory_seq::add_elim_string_axiom(expr* n) {
|
|||
*/
|
||||
void theory_seq::add_length_axiom(expr* n) {
|
||||
context& ctx = get_context();
|
||||
expr* x = 0;
|
||||
expr* x = nullptr;
|
||||
VERIFY(m_util.str.is_length(n, x));
|
||||
if (m_util.str.is_concat(x) ||
|
||||
m_util.str.is_unit(x) ||
|
||||
|
|
@ -3358,7 +3358,7 @@ void theory_seq::add_length_axiom(expr* n) {
|
|||
}
|
||||
|
||||
void theory_seq::add_itos_length_axiom(expr* len) {
|
||||
expr* x = 0, *n = 0;
|
||||
expr* x = nullptr, *n = nullptr;
|
||||
VERIFY(m_util.str.is_length(len, x));
|
||||
VERIFY(m_util.str.is_itos(x, n));
|
||||
|
||||
|
|
@ -3423,7 +3423,7 @@ void theory_seq::add_itos_length_axiom(expr* len) {
|
|||
|
||||
void theory_seq::propagate_in_re(expr* n, bool is_true) {
|
||||
TRACE("seq", tout << mk_pp(n, m) << " <- " << (is_true?"true":"false") << "\n";);
|
||||
expr* e1 = 0, *e2 = 0;
|
||||
expr* e1 = nullptr, *e2 = nullptr;
|
||||
VERIFY(m_util.str.is_in_re(n, e1, e2));
|
||||
|
||||
expr_ref tmp(n, m);
|
||||
|
|
@ -3432,7 +3432,7 @@ void theory_seq::propagate_in_re(expr* n, bool is_true) {
|
|||
if (!is_true) {
|
||||
literal_vector lits;
|
||||
lits.push_back(mk_literal(n));
|
||||
set_conflict(0, lits);
|
||||
set_conflict(nullptr, lits);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
|
@ -3440,7 +3440,7 @@ void theory_seq::propagate_in_re(expr* n, bool is_true) {
|
|||
if (is_true) {
|
||||
literal_vector lits;
|
||||
lits.push_back(~mk_literal(n));
|
||||
set_conflict(0, lits);
|
||||
set_conflict(nullptr, lits);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
|
@ -3474,7 +3474,7 @@ void theory_seq::propagate_in_re(expr* n, bool is_true) {
|
|||
lits.push_back(mk_accept(e1, zero, e3, states[i]));
|
||||
}
|
||||
if (lits.size() == 2) {
|
||||
propagate_lit(0, 1, &lit, lits[1]);
|
||||
propagate_lit(nullptr, 1, &lit, lits[1]);
|
||||
}
|
||||
else {
|
||||
TRACE("seq", ctx.display_literals_verbose(tout, lits); tout << "\n";);
|
||||
|
|
@ -3506,7 +3506,7 @@ static T* get_th_arith(context& ctx, theory_id afid, expr* e) {
|
|||
return dynamic_cast<T*>(th);
|
||||
}
|
||||
else {
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -3566,7 +3566,7 @@ bool theory_seq::get_length(expr* e, rational& val) const {
|
|||
context& ctx = get_context();
|
||||
rational val1;
|
||||
expr_ref len(m), len_val(m);
|
||||
expr* e1 = 0, *e2 = 0;
|
||||
expr* e1 = nullptr, *e2 = nullptr;
|
||||
ptr_vector<expr> todo;
|
||||
todo.push_back(e);
|
||||
val.reset();
|
||||
|
|
@ -3638,7 +3638,7 @@ this translates to:
|
|||
|
||||
void theory_seq::add_extract_axiom(expr* e) {
|
||||
TRACE("seq", tout << mk_pp(e, m) << "\n";);
|
||||
expr* s = 0, *i = 0, *l = 0;
|
||||
expr* s = nullptr, *i = nullptr, *l = nullptr;
|
||||
VERIFY(m_util.str.is_extract(e, s, i, l));
|
||||
if (is_tail(s, i, l)) {
|
||||
add_tail_axiom(e, s);
|
||||
|
|
@ -3769,7 +3769,7 @@ void theory_seq::add_extract_suffix_axiom(expr* e, expr* s, expr* i) {
|
|||
|
||||
*/
|
||||
void theory_seq::add_at_axiom(expr* e) {
|
||||
expr* s = 0, *i = 0;
|
||||
expr* s = nullptr, *i = nullptr;
|
||||
VERIFY(m_util.str.is_at(e, s, i));
|
||||
expr_ref len_e(m_util.str.mk_length(e), m);
|
||||
expr_ref len_s(m_util.str.mk_length(s), m);
|
||||
|
|
@ -3798,17 +3798,17 @@ void theory_seq::add_at_axiom(expr* e) {
|
|||
*/
|
||||
void theory_seq::propagate_step(literal lit, expr* step) {
|
||||
SASSERT(get_context().get_assignment(lit) == l_true);
|
||||
expr* re = 0, *acc = 0, *s = 0, *idx = 0, *i = 0, *j = 0;
|
||||
expr* re = nullptr, *acc = nullptr, *s = nullptr, *idx = nullptr, *i = nullptr, *j = nullptr;
|
||||
VERIFY(is_step(step, s, idx, re, i, j, acc));
|
||||
TRACE("seq", tout << mk_pp(step, m) << " -> " << mk_pp(acc, m) << "\n";);
|
||||
propagate_lit(0, 1, &lit, mk_simplified_literal(acc));
|
||||
propagate_lit(nullptr, 1, &lit, mk_simplified_literal(acc));
|
||||
rational lo;
|
||||
rational _idx;
|
||||
if (lower_bound(s, lo) && lo.is_unsigned() && m_autil.is_numeral(idx, _idx) && lo >= _idx) {
|
||||
// skip
|
||||
}
|
||||
else {
|
||||
propagate_lit(0, 1, &lit, ~mk_literal(m_autil.mk_le(m_util.str.mk_length(s), idx)));
|
||||
propagate_lit(nullptr, 1, &lit, ~mk_literal(m_autil.mk_le(m_util.str.mk_length(s), idx)));
|
||||
}
|
||||
ensure_nth(lit, s, idx);
|
||||
}
|
||||
|
|
@ -3854,7 +3854,7 @@ literal theory_seq::mk_literal(expr* _e) {
|
|||
|
||||
literal theory_seq::mk_seq_eq(expr* a, expr* b) {
|
||||
SASSERT(m_util.is_seq(a));
|
||||
return mk_literal(mk_skolem(m_eq, a, b, 0, m.mk_bool_sort()));
|
||||
return mk_literal(mk_skolem(m_eq, a, b, nullptr, m.mk_bool_sort()));
|
||||
}
|
||||
|
||||
literal theory_seq::mk_eq_empty(expr* _e, bool phase) {
|
||||
|
|
@ -3927,7 +3927,7 @@ theory_seq::dependency* theory_seq::mk_join(dependency* deps, literal_vector con
|
|||
void theory_seq::propagate_eq(literal lit, expr* e1, expr* e2, bool add_to_eqs) {
|
||||
literal_vector lits;
|
||||
lits.push_back(lit);
|
||||
propagate_eq(0, lits, e1, e2, add_to_eqs);
|
||||
propagate_eq(nullptr, lits, e1, e2, add_to_eqs);
|
||||
}
|
||||
|
||||
void theory_seq::propagate_eq(dependency* deps, literal_vector const& _lits, expr* e1, expr* e2, bool add_to_eqs) {
|
||||
|
|
@ -3966,7 +3966,7 @@ void theory_seq::propagate_eq(dependency* deps, literal_vector const& _lits, exp
|
|||
void theory_seq::assign_eh(bool_var v, bool is_true) {
|
||||
context & ctx = get_context();
|
||||
expr* e = ctx.bool_var2expr(v);
|
||||
expr* e1 = 0, *e2 = 0;
|
||||
expr* e1 = nullptr, *e2 = nullptr;
|
||||
expr_ref f(m);
|
||||
bool change = false;
|
||||
literal lit(v, !is_true);
|
||||
|
|
@ -4231,7 +4231,7 @@ void theory_seq::relevant_eh(app* n) {
|
|||
|
||||
|
||||
eautomaton* theory_seq::get_automaton(expr* re) {
|
||||
eautomaton* result = 0;
|
||||
eautomaton* result = nullptr;
|
||||
if (m_re2aut.find(re, result)) {
|
||||
return result;
|
||||
}
|
||||
|
|
@ -4312,9 +4312,9 @@ expr_ref theory_seq::mk_step(expr* s, expr* idx, expr* re, unsigned i, unsigned
|
|||
rej(s, idx, re, i) -> len(s) > idx if i is final
|
||||
*/
|
||||
void theory_seq::propagate_acc_rej_length(literal lit, expr* e) {
|
||||
expr *s = 0, *idx = 0, *re = 0;
|
||||
expr *s = nullptr, *idx = nullptr, *re = nullptr;
|
||||
unsigned src;
|
||||
eautomaton* aut = 0;
|
||||
eautomaton* aut = nullptr;
|
||||
bool is_acc;
|
||||
is_acc = is_accept(e, s, idx, re, src, aut);
|
||||
if (!is_acc) {
|
||||
|
|
@ -4324,15 +4324,15 @@ void theory_seq::propagate_acc_rej_length(literal lit, expr* e) {
|
|||
SASSERT(m_autil.is_numeral(idx));
|
||||
SASSERT(get_context().get_assignment(lit) == l_true);
|
||||
if (aut->is_sink_state(src)) {
|
||||
propagate_lit(0, 1, &lit, false_literal);
|
||||
propagate_lit(nullptr, 1, &lit, false_literal);
|
||||
return;
|
||||
}
|
||||
bool is_final = aut->is_final_state(src);
|
||||
if (is_final == is_acc) {
|
||||
propagate_lit(0, 1, &lit, mk_literal(m_autil.mk_ge(m_util.str.mk_length(s), idx)));
|
||||
propagate_lit(nullptr, 1, &lit, mk_literal(m_autil.mk_ge(m_util.str.mk_length(s), idx)));
|
||||
}
|
||||
else {
|
||||
propagate_lit(0, 1, &lit, ~mk_literal(m_autil.mk_le(m_util.str.mk_length(s), idx)));
|
||||
propagate_lit(nullptr, 1, &lit, ~mk_literal(m_autil.mk_le(m_util.str.mk_length(s), idx)));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -4345,10 +4345,10 @@ bool theory_seq::add_accept2step(expr* acc, bool& change) {
|
|||
|
||||
TRACE("seq", tout << mk_pp(acc, m) << "\n";);
|
||||
SASSERT(ctx.get_assignment(acc) == l_true);
|
||||
expr *e = 0, *idx = 0, *re = 0;
|
||||
expr *e = nullptr, *idx = nullptr, *re = nullptr;
|
||||
expr_ref step(m);
|
||||
unsigned src;
|
||||
eautomaton* aut = 0;
|
||||
eautomaton* aut = nullptr;
|
||||
VERIFY(is_accept(acc, e, idx, re, src, aut));
|
||||
if (!aut || m_util.str.is_length(idx)) {
|
||||
return false;
|
||||
|
|
@ -4401,7 +4401,7 @@ bool theory_seq::add_accept2step(expr* acc, bool& change) {
|
|||
for (unsigned i = 0; i < lits.size(); ++i) {
|
||||
lits[i].neg();
|
||||
}
|
||||
propagate_lit(0, lits.size(), lits.c_ptr(), lit);
|
||||
propagate_lit(nullptr, lits.size(), lits.c_ptr(), lit);
|
||||
return false;
|
||||
}
|
||||
if (has_undef) {
|
||||
|
|
@ -4412,7 +4412,7 @@ bool theory_seq::add_accept2step(expr* acc, bool& change) {
|
|||
SASSERT(ctx.get_assignment(lits[i]) == l_false);
|
||||
lits[i].neg();
|
||||
}
|
||||
set_conflict(0, lits);
|
||||
set_conflict(nullptr, lits);
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -4424,7 +4424,7 @@ bool theory_seq::add_accept2step(expr* acc, bool& change) {
|
|||
bool theory_seq::add_step2accept(expr* step, bool& change) {
|
||||
context& ctx = get_context();
|
||||
SASSERT(ctx.get_assignment(step) == l_true);
|
||||
expr* re = 0, *_acc = 0, *s = 0, *idx = 0, *i = 0, *j = 0;
|
||||
expr* re = nullptr, *_acc = nullptr, *s = nullptr, *idx = nullptr, *i = nullptr, *j = nullptr;
|
||||
VERIFY(is_step(step, s, idx, re, i, j, _acc));
|
||||
literal acc1 = mk_accept(s, idx, re, i);
|
||||
switch (ctx.get_assignment(acc1)) {
|
||||
|
|
@ -4445,12 +4445,12 @@ bool theory_seq::add_step2accept(expr* step, bool& change) {
|
|||
lits.push_back(~acc2);
|
||||
switch (ctx.get_assignment(acc2)) {
|
||||
case l_undef:
|
||||
propagate_lit(0, 2, lits.c_ptr(), acc2);
|
||||
propagate_lit(nullptr, 2, lits.c_ptr(), acc2);
|
||||
break;
|
||||
case l_true:
|
||||
break;
|
||||
case l_false:
|
||||
set_conflict(0, lits);
|
||||
set_conflict(nullptr, lits);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
|
|
@ -4473,10 +4473,10 @@ Recall we also have:
|
|||
bool theory_seq::add_reject2reject(expr* rej, bool& change) {
|
||||
context& ctx = get_context();
|
||||
SASSERT(ctx.get_assignment(rej) == l_true);
|
||||
expr* s = 0, *idx = 0, *re = 0;
|
||||
expr* s = nullptr, *idx = nullptr, *re = nullptr;
|
||||
unsigned src;
|
||||
rational r;
|
||||
eautomaton* aut = 0;
|
||||
eautomaton* aut = nullptr;
|
||||
VERIFY(is_reject(rej, s, idx, re, src, aut));
|
||||
if (!aut || m_util.str.is_length(idx)) return false;
|
||||
VERIFY(m_autil.is_numeral(idx, r) && r.is_unsigned());
|
||||
|
|
@ -4535,7 +4535,7 @@ bool theory_seq::add_reject2reject(expr* rej, bool& change) {
|
|||
|
||||
void theory_seq::propagate_not_prefix(expr* e) {
|
||||
context& ctx = get_context();
|
||||
expr* e1 = 0, *e2 = 0;
|
||||
expr* e1 = nullptr, *e2 = nullptr;
|
||||
VERIFY(m_util.str.is_prefix(e, e1, e2));
|
||||
literal lit = ctx.get_literal(e);
|
||||
SASSERT(ctx.get_assignment(lit) == l_false);
|
||||
|
|
@ -4545,13 +4545,13 @@ void theory_seq::propagate_not_prefix(expr* e) {
|
|||
propagate_non_empty(~lit, e1);
|
||||
expr_ref emp(m_util.str.mk_empty(m.get_sort(e1)), m);
|
||||
literal e2_is_emp = mk_seq_eq(e2, emp);
|
||||
sort* char_sort = 0;
|
||||
sort* char_sort = nullptr;
|
||||
VERIFY(m_util.is_seq(m.get_sort(e1), char_sort));
|
||||
expr_ref x = mk_skolem(symbol("seq.prefix.x"), e1, e2);
|
||||
expr_ref y = mk_skolem(symbol("seq.prefix.y"), e1, e2);
|
||||
expr_ref z = mk_skolem(symbol("seq.prefix.z"), e1, e2);
|
||||
expr_ref c = mk_skolem(symbol("seq.prefix.c"), e1, e2, 0, char_sort);
|
||||
expr_ref d = mk_skolem(symbol("seq.prefix.d"), e1, e2, 0, char_sort);
|
||||
expr_ref c = mk_skolem(symbol("seq.prefix.c"), e1, e2, nullptr, char_sort);
|
||||
expr_ref d = mk_skolem(symbol("seq.prefix.d"), e1, e2, nullptr, char_sort);
|
||||
add_axiom(lit, e2_is_emp, mk_seq_eq(e1, mk_concat(x, m_util.str.mk_unit(c), y)));
|
||||
add_axiom(lit, e2_is_emp, mk_seq_eq(e2, mk_concat(x, m_util.str.mk_unit(d), z)), mk_seq_eq(e2, x));
|
||||
add_axiom(lit, e2_is_emp, ~mk_eq(c, d, false), mk_seq_eq(e2, x));
|
||||
|
|
@ -4564,7 +4564,7 @@ void theory_seq::propagate_not_prefix(expr* e) {
|
|||
|
||||
void theory_seq::propagate_not_prefix2(expr* e) {
|
||||
context& ctx = get_context();
|
||||
expr* e1 = 0, *e2 = 0;
|
||||
expr* e1 = nullptr, *e2 = nullptr;
|
||||
VERIFY(m_util.str.is_prefix(e, e1, e2));
|
||||
literal lit = ctx.get_literal(e);
|
||||
SASSERT(ctx.get_assignment(lit) == l_false);
|
||||
|
|
@ -4591,7 +4591,7 @@ void theory_seq::propagate_not_prefix2(expr* e) {
|
|||
|
||||
void theory_seq::propagate_not_suffix(expr* e) {
|
||||
context& ctx = get_context();
|
||||
expr* e1 = 0, *e2 = 0;
|
||||
expr* e1 = nullptr, *e2 = nullptr;
|
||||
VERIFY(m_util.str.is_suffix(e, e1, e2));
|
||||
literal lit = ctx.get_literal(e);
|
||||
SASSERT(ctx.get_assignment(lit) == l_false);
|
||||
|
|
@ -4602,13 +4602,13 @@ void theory_seq::propagate_not_suffix(expr* e) {
|
|||
|
||||
expr_ref emp(m_util.str.mk_empty(m.get_sort(e1)), m);
|
||||
literal e2_is_emp = mk_seq_eq(e2, emp);
|
||||
sort* char_sort = 0;
|
||||
sort* char_sort = nullptr;
|
||||
VERIFY(m_util.is_seq(m.get_sort(e1), char_sort));
|
||||
expr_ref x = mk_skolem(symbol("seq.suffix.x"), e1, e2);
|
||||
expr_ref y = mk_skolem(symbol("seq.suffix.y"), e1, e2);
|
||||
expr_ref z = mk_skolem(symbol("seq.suffix.z"), e1, e2);
|
||||
expr_ref c = mk_skolem(symbol("seq.suffix.c"), e1, e2, 0, char_sort);
|
||||
expr_ref d = mk_skolem(symbol("seq.suffix.d"), e1, e2, 0, char_sort);
|
||||
expr_ref c = mk_skolem(symbol("seq.suffix.c"), e1, e2, nullptr, char_sort);
|
||||
expr_ref d = mk_skolem(symbol("seq.suffix.d"), e1, e2, nullptr, char_sort);
|
||||
add_axiom(lit, e2_is_emp, mk_seq_eq(e1, mk_concat(y, m_util.str.mk_unit(c), x)));
|
||||
add_axiom(lit, e2_is_emp, mk_seq_eq(e2, mk_concat(z, m_util.str.mk_unit(d), x)), mk_seq_eq(e2, x));
|
||||
add_axiom(lit, e2_is_emp, ~mk_eq(c, d, false), mk_seq_eq(e2, x));
|
||||
|
|
@ -4620,7 +4620,7 @@ void theory_seq::propagate_not_suffix(expr* e) {
|
|||
*/
|
||||
bool theory_seq::add_prefix2prefix(expr* e, bool& change) {
|
||||
context& ctx = get_context();
|
||||
expr* e1 = 0, *e2 = 0;
|
||||
expr* e1 = nullptr, *e2 = nullptr;
|
||||
VERIFY(m_util.str.is_prefix(e, e1, e2));
|
||||
SASSERT(ctx.get_assignment(e) == l_false);
|
||||
if (canonizes(false, e)) {
|
||||
|
|
@ -4682,7 +4682,7 @@ bool theory_seq::add_prefix2prefix(expr* e, bool& change) {
|
|||
lits.push_back(~ctx.get_literal(e));
|
||||
lits.push_back(~e2_is_emp);
|
||||
lits.push_back(lit);
|
||||
propagate_lit(0, lits.size(), lits.c_ptr(), ~mk_literal(m_util.str.mk_prefix(tail1, tail2)));
|
||||
propagate_lit(nullptr, lits.size(), lits.c_ptr(), ~mk_literal(m_util.str.mk_prefix(tail1, tail2)));
|
||||
TRACE("seq", tout << mk_pp(e, m) << " saturate: " << tail1 << " = " << tail2 << "\n";);
|
||||
return false;
|
||||
}
|
||||
|
|
@ -4692,7 +4692,7 @@ bool theory_seq::add_prefix2prefix(expr* e, bool& change) {
|
|||
*/
|
||||
bool theory_seq::add_suffix2suffix(expr* e, bool& change) {
|
||||
context& ctx = get_context();
|
||||
expr* e1 = 0, *e2 = 0;
|
||||
expr* e1 = nullptr, *e2 = nullptr;
|
||||
VERIFY(m_util.str.is_suffix(e, e1, e2));
|
||||
SASSERT(ctx.get_assignment(e) == l_false);
|
||||
if (canonizes(false, e)) {
|
||||
|
|
@ -4746,21 +4746,21 @@ bool theory_seq::add_suffix2suffix(expr* e, bool& change) {
|
|||
lits.push_back(~ctx.get_literal(e));
|
||||
lits.push_back(~e2_is_emp);
|
||||
lits.push_back(last_eq);
|
||||
propagate_lit(0, lits.size(), lits.c_ptr(), ~mk_literal(m_util.str.mk_suffix(first1, first2)));
|
||||
propagate_lit(nullptr, lits.size(), lits.c_ptr(), ~mk_literal(m_util.str.mk_suffix(first1, first2)));
|
||||
TRACE("seq", tout << mk_pp(e, m) << " saturate\n";);
|
||||
return false;
|
||||
}
|
||||
|
||||
bool theory_seq::canonizes(bool sign, expr* e) {
|
||||
context& ctx = get_context();
|
||||
dependency* deps = 0;
|
||||
dependency* deps = nullptr;
|
||||
expr_ref cont = canonize(e, deps);
|
||||
TRACE("seq", tout << mk_pp(e, m) << " -> " << cont << "\n";
|
||||
if (deps) display_deps(tout, deps););
|
||||
if ((m.is_true(cont) && !sign) ||
|
||||
(m.is_false(cont) && sign)) {
|
||||
TRACE("seq", display(tout); tout << ctx.get_assignment(ctx.get_literal(e)) << "\n";);
|
||||
propagate_lit(deps, 0, 0, ctx.get_literal(e));
|
||||
propagate_lit(deps, 0, nullptr, ctx.get_literal(e));
|
||||
return true;
|
||||
}
|
||||
if ((m.is_false(cont) && !sign) ||
|
||||
|
|
@ -4778,7 +4778,7 @@ bool theory_seq::canonizes(bool sign, expr* e) {
|
|||
|
||||
bool theory_seq::add_contains2contains(expr* e, bool& change) {
|
||||
context& ctx = get_context();
|
||||
expr* e1 = 0, *e2 = 0;
|
||||
expr* e1 = nullptr, *e2 = nullptr;
|
||||
VERIFY(m_util.str.is_contains(e, e1, e2));
|
||||
SASSERT(ctx.get_assignment(e) == l_false);
|
||||
if (canonizes(false, e)) {
|
||||
|
|
@ -4803,7 +4803,7 @@ bool theory_seq::add_contains2contains(expr* e, bool& change) {
|
|||
propagate_eq(~e1_is_emp, e1, conc, true);
|
||||
|
||||
literal lits[2] = { ~ctx.get_literal(e), ~e1_is_emp };
|
||||
propagate_lit(0, 2, lits, ~mk_literal(m_util.str.mk_contains(tail, e2)));
|
||||
propagate_lit(nullptr, 2, lits, ~mk_literal(m_util.str.mk_contains(tail, e2)));
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -4848,7 +4848,7 @@ bool theory_seq::propagate_automata() {
|
|||
}
|
||||
|
||||
void theory_seq::get_concat(expr* e, ptr_vector<expr>& concats) {
|
||||
expr* e1 = 0, *e2 = 0;
|
||||
expr* e1 = nullptr, *e2 = nullptr;
|
||||
while (true) {
|
||||
e = m_rep.find(e);
|
||||
if (m_util.str.is_concat(e, e1, e2)) {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue