mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-23 09:05:31 +00:00
Code Activity

fix build, refactor

Browse source
This commit is contained in:
Nikolaj Bjorner 2021-02-02 05:26:57 -08:00
parent 3ae4c6e9de
commit 937b61fc88
53 changed files with 145 additions and 127 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/smt/arith_eq_adapter.cpp
View file

@ -170,7 +170,7 @@ namespace smt {
ge = m_util.mk_ge(t1, t2);
}
else {
sort * st = m.get_sort(t1);
sort * st = t1->get_sort();
app_ref minus_one(m_util.mk_numeral(rational::minus_one(), st), m);
app_ref zero(m_util.mk_numeral(rational::zero(), st), m);
app_ref t3(m_util.mk_mul(minus_one, t2), m);

4
src/smt/seq_axioms.cpp
View file

@ -870,7 +870,7 @@ void seq_axioms::add_suffix_axiom(expr* e) {
add_axiom(lit, s_gt_t, ~mk_eq(y, s));
#else
sort* char_sort = nullptr;
VERIFY(seq.is_seq(m.get_sort(s), char_sort));
VERIFY(seq.is_seq(s->get_sort(), char_sort));
expr_ref x = m_sk.mk("seq.suffix.x", s, t);
expr_ref y = m_sk.mk("seq.suffix.y", s, t);
expr_ref z = m_sk.mk("seq.suffix.z", s, t);
@ -899,7 +899,7 @@ void seq_axioms::add_prefix_axiom(expr* e) {
#else
sort* char_sort = nullptr;
VERIFY(seq.is_seq(m.get_sort(s), char_sort));
VERIFY(seq.is_seq(s->get_sort(), char_sort));
expr_ref x = m_sk.mk("seq.prefix.x", s, t);
expr_ref y = m_sk.mk("seq.prefix.y", s, t);
expr_ref z = m_sk.mk("seq.prefix.z", s, t);

4
src/smt/seq_skolem.cpp
View file

@ -169,7 +169,7 @@ bool seq_skolem::is_post(expr* e, expr*& s, expr*& start) {
expr_ref seq_skolem::mk_unit_inv(expr* n) {
expr* u = nullptr;
VERIFY(seq.str.is_unit(n, u));
sort* s = m.get_sort(u);
sort* s = u->get_sort();
return mk(symbol("seq.unit-inv"), n, s);
}
@ -180,7 +180,7 @@ expr_ref seq_skolem::mk_last(expr* s) {
return expr_ref(seq.str.mk_char(str, str.length()-1), m);
}
sort* char_sort = nullptr;
VERIFY(seq.is_seq(m.get_sort(s), char_sort));
VERIFY(seq.is_seq(s->get_sort(), char_sort));
return mk(m_seq_last, s, char_sort);
}

2
src/smt/seq_skolem.h
View file

@ -82,7 +82,7 @@ namespace smt {
expr_ref mk_tail(expr* s, expr* i) { return mk(m_tail, s, i); }
expr_ref mk_post(expr* s, expr* i) { return mk(m_post, s, i); }
expr_ref mk_ite(expr* c, expr* t, expr* e) { return mk(symbol("seq.if"), c, t, e, nullptr, m.get_sort(t)); }
expr_ref mk_ite(expr* c, expr* t, expr* e) { return mk(symbol("seq.if"), c, t, e, nullptr, t->get_sort()); }
expr_ref mk_last(expr* s);
expr_ref mk_first(expr* s);
expr_ref mk_pre(expr* s, expr* i) { return mk(m_pre, s, i); }

2
src/smt/smt_consequences.cpp
View file

@ -318,7 +318,7 @@ namespace smt {
}
else {
if (!pushed) pushed = true, push();
expr_ref c(m.mk_fresh_const("a", m.get_sort(a)), m);
expr_ref c(m.mk_fresh_const("a", a->get_sort()), m);
expr_ref eq(m.mk_eq(c, a), m);
assert_expr(eq);
assumptions.push_back(c);

2
src/smt/smt_context.cpp
View file

@ -4487,7 +4487,7 @@ namespace smt {
}
bool context::get_value(enode * n, expr_ref & value) {
sort * s = m.get_sort(n->get_owner());
sort * s = n->get_owner()->get_sort();
family_id fid = s->get_family_id();
theory * th = get_theory(fid);
if (th == nullptr)

8
src/smt/smt_implied_equalities.cpp
View file

@ -57,7 +57,7 @@ namespace {
void partition_terms(unsigned num_terms, expr* const* terms, sort2term_ids& termids) {
for (unsigned i = 0; i < num_terms; ++i) {
sort* s = m.get_sort(terms[i]);
sort* s = terms[i]->get_sort();
term_ids& vec = termids.insert_if_not_there(s, term_ids());
vec.push_back(term_id(expr_ref(terms[i],m), i));
}
@ -148,7 +148,7 @@ namespace {
SASSERT(!terms.empty());
sort* srt = m.get_sort(terms[0].term);
sort* srt = terms[0].term->get_sort();
if (m_array_util.is_array(srt)) {
@ -249,7 +249,7 @@ namespace {
void assert_relevant(unsigned num_terms, expr* const* terms) {
for (unsigned i = 0; i < num_terms; ++i) {
sort* srt = m.get_sort(terms[i]);
sort* srt = terms[i]->get_sort();
if (!m_array_util.is_array(srt)) {
m_solver.assert_expr(m.mk_app(m.mk_func_decl(symbol("Relevant!"), 1, &srt, m.mk_bool_sort()), terms[i]));
}
@ -259,7 +259,7 @@ namespace {
void assert_relevant(term_ids& terms) {
for (unsigned i = 0; i < terms.size(); ++i) {
expr* t = terms[i].term;
sort* srt = m.get_sort(t);
sort* srt = t->get_sort();
if (!m_array_util.is_array(srt)) {
m_solver.assert_expr(m.mk_app(m.mk_func_decl(symbol("Relevant!"), 1, &srt, m.mk_bool_sort()), t));
}

8
src/smt/smt_induction.cpp
View file

@ -136,7 +136,7 @@ bool induction_lemmas::viable_induction_children(enode* n) {
bool induction_lemmas::viable_induction_term(enode* p, enode* n) {
return
viable_induction_sort(m.get_sort(n->get_owner())) &&
viable_induction_sort(n->get_owner()->get_sort()) &&
viable_induction_parent(p, n) &&
viable_induction_children(n);
}
@ -281,7 +281,7 @@ void induction_lemmas::mk_hypothesis_substs(unsigned depth, expr* x, cond_substs
}
void induction_lemmas::mk_hypothesis_substs_rec(unsigned depth, sort* s, expr* y, expr_ref_vector& conds, cond_substs_t& subst) {
sort* ys = m.get_sort(y);
sort* ys = y->get_sort();
for (func_decl* c : *m_dt.get_datatype_constructors(ys)) {
func_decl* is_c = m_dt.get_constructor_recognizer(c);
conds.push_back(m.mk_app(is_c, y));
@ -417,7 +417,7 @@ bool induction_lemmas::operator()(literal lit) {
for (enode* n : induction_positions(r)) {
expr* t = n->get_owner();
if (is_uninterp_const(t)) { // for now, to avoid overlapping terms
sort* s = m.get_sort(t);
sort* s = t->get_sort();
expr_ref sk(m.mk_fresh_const("sk", s), m);
sks.push_back(sk);
rep.insert(t, sk);
@ -460,7 +460,7 @@ void induction_lemmas::apply_induction(literal lit, induction_positions_t const
if (term2skolem.contains(t))
continue;
if (i == sks.size()) {
sk = m.mk_fresh_const("sk", m.get_sort(t));
sk = m.mk_fresh_const("sk", t->get_sort());
sks.push_back(sk);
}
else {

6
src/smt/smt_internalizer.cpp
View file

@ -315,7 +315,7 @@ namespace smt {
assert_default(n, pr);
return;
}
sort * s = m.get_sort(n->get_arg(0));
sort * s = n->get_arg(0)->get_sort();
sort_ref u(m.mk_fresh_sort("distinct-elems"), m);
func_decl_ref f(m.mk_fresh_func_decl("distinct-aux-f", "", 1, &s, u), m);
for (expr * arg : *n) {
@ -448,7 +448,7 @@ namespace smt {
d.set_eq_flag();
TRACE("internalize", tout << mk_pp(n, m) << " " << literal(v, false) << "\n";);
sort * s = m.get_sort(n->get_arg(0));
sort * s = n->get_arg(0)->get_sort();
theory * th = m_theories.get_plugin(s->get_family_id());
if (th)
th->internalize_eq_eh(n, v);
@ -582,7 +582,7 @@ namespace smt {
if (e_internalized(q)) {
return;
}
app_ref lam_name(m.mk_fresh_const("lambda", m.get_sort(q)), m);
app_ref lam_name(m.mk_fresh_const("lambda", q->get_sort()), m);
app_ref eq(m), lam_app(m);
expr_ref_vector vars(m);
vars.push_back(lam_name);

4
src/smt/smt_model_finder.cpp
View file

@ -654,7 +654,7 @@ namespace smt {
Remark: this method uses get_fresh_value, so it may fail.
*/
expr* get_k_interp(app* k) {
sort* s = m.get_sort(k);
sort* s = k->get_sort();
SASSERT(is_infinite(s));
func_decl* k_decl = k->get_decl();
expr* r = m_model->get_const_interp(k_decl);
@ -1914,7 +1914,7 @@ namespace smt {
if (is_var_and_ground(to_app(atom)->get_arg(0), to_app(atom)->get_arg(1), v, tmp, inv)) {
if (inv)
le = !le;
sort* s = m.get_sort(tmp);
sort* s = tmp->get_sort();
expr_ref one(m);
one = mk_one(s);
if (le)

2
src/smt/smt_model_generator.cpp
View file

@ -307,7 +307,7 @@ namespace smt {
enode * n = curr.get_enode();
SASSERT(n->get_root() == n);
tout << mk_pp(n->get_owner(), m) << "\n";
sort * s = m.get_sort(n->get_owner());
sort * s = n->get_owner()->get_sort();
tout << curr << " " << mk_pp(s, m);
tout << " is_fresh: " << root2proc[n]->is_fresh() << "\n";
}

2
src/smt/smt_quick_checker.cpp
View file

@ -186,7 +186,7 @@ namespace smt {
m_candidate_vectors[i].reset();
sort * s = q->get_decl_sort(i);
for (unsigned j = 0; j < num_candidates; j++) {
if (m_manager.get_sort(candidates[j]) == s) {
if (candidates[j]->get_sort() == s) {
expr * n = candidates[j];
m_context.internalize(n, false);
enode * e = m_context.get_enode(n);

2
src/smt/theory_array.cpp
View file

@ -72,7 +72,7 @@ namespace smt {
", is_store: " << is_store(n) << "\n";);
d->m_is_array = is_array_sort(n);
if (d->m_is_array)
register_sort(m.get_sort(n->get_owner()));
register_sort(n->get_owner()->get_sort());
d->m_is_select = is_select(n);
if (is_store(n))
d->m_stores.push_back(n);

8
src/smt/theory_array_base.cpp
View file

@ -59,7 +59,7 @@ namespace smt {
}
app * theory_array_base::mk_default(expr * a) {
sort * s = m.get_sort(a);
sort * s = a->get_sort();
unsigned num_params = get_dimension(s);
parameter const* params = s->get_info()->get_parameters();
return m.mk_app(get_family_id(), OP_ARRAY_DEFAULT, num_params, params, 1, & a);
@ -564,13 +564,13 @@ namespace smt {
TRACE("array_bug", tout << "mk_interface_eqs: processing: v" << *it1 << "\n";);
theory_var v1 = *it1;
enode * n1 = get_enode(v1);
sort * s1 = m.get_sort(n1->get_owner());
sort * s1 = n1->get_owner()->get_sort();
sbuffer<theory_var>::iterator it2 = it1;
++it2;
for (; it2 != end1; ++it2) {
theory_var v2 = *it2;
enode * n2 = get_enode(v2);
sort * s2 = m.get_sort(n2->get_owner());
sort * s2 = n2->get_owner()->get_sort();
if (s1 == s2 && !ctx.is_diseq(n1, n2)) {
app * eq = mk_eq_atom(n1->get_owner(), n2->get_owner());
if (!ctx.b_internalized(eq) || !ctx.is_relevant(eq)) {
@ -983,7 +983,7 @@ namespace smt {
SASSERT(ctx.is_relevant(n));
theory_var v = n->get_th_var(get_id());
SASSERT(v != null_theory_var);
sort * s = m.get_sort(n->get_owner());
sort * s = n->get_owner()->get_sort();
enode * else_val_n = get_default(v);
array_value_proc * result = nullptr;

2
src/smt/theory_array_base.h
View file

@ -46,7 +46,7 @@ namespace smt {
bool is_array_ext(app const * n) const { return n->is_app_of(get_id(), OP_ARRAY_EXT); }
bool is_as_array(app const * n) const { return n->is_app_of(get_id(), OP_AS_ARRAY); }
bool is_array_sort(sort const* s) const { return s->is_sort_of(get_id(), ARRAY_SORT); }
bool is_array_sort(app const* n) const { return is_array_sort(get_manager().get_sort(n)); }
bool is_array_sort(app const* n) const { return is_array_sort(n->get_sort()); }
bool is_set_has_size(app const* n) const { return n->is_app_of(get_id(), OP_SET_HAS_SIZE); }
bool is_set_card(app const* n) const { return n->is_app_of(get_id(), OP_SET_CARD); }

4
src/smt/theory_array_full.cpp
View file

@ -579,7 +579,7 @@ namespace smt {
bool theory_array_full::has_unitary_domain(app* array_term) {
SASSERT(is_array_sort(array_term));
sort* s = m.get_sort(array_term);
sort* s = array_term->get_sort();
unsigned dim = get_dimension(s);
parameter const * params = s->get_info()->get_parameters();
for (unsigned i = 0; i < dim; ++i) {
@ -593,7 +593,7 @@ namespace smt {
bool theory_array_full::has_large_domain(app* array_term) {
SASSERT(is_array_sort(array_term));
sort* s = m.get_sort(array_term);
sort* s = array_term->get_sort();
unsigned dim = get_dimension(s);
parameter const * params = s->get_info()->get_parameters();
rational sz(1);

2
src/smt/theory_bv.cpp
View file

@ -478,7 +478,7 @@ namespace smt {
VERIFY(get_fixed_value(v, val));
enode* n = get_enode(v);
if (ctx.watches_fixed(n)) {
expr_ref num(m_util.mk_numeral(val, m.get_sort(n->get_owner())), m);
expr_ref num(m_util.mk_numeral(val, n->get_owner()->get_sort()), m);
literal_vector& lits = m_tmp_literals;
lits.reset();
for (literal b : m_bits[v]) {

2
src/smt/theory_bv.h
View file

@ -147,7 +147,7 @@ namespace smt {
unsigned get_bv_size(app const * n) const { return m_util.get_bv_size(n); }
unsigned get_bv_size(enode const * n) const { return m_util.get_bv_size(n->get_owner()); }
unsigned get_bv_size(theory_var v) const { return get_bv_size(get_enode(v)); }
bool is_bv(app const* n) const { return m_util.is_bv_sort(get_manager().get_sort(n)); }
bool is_bv(app const* n) const { return m_util.is_bv_sort(n->get_sort()); }
bool is_bv(enode const* n) const { return is_bv(n->get_owner()); }
bool is_bv(theory_var v) const { return is_bv(get_enode(v)); }
region & get_region() { return m_trail_stack.get_region(); }

10
src/smt/theory_datatype.cpp
View file

@ -274,7 +274,7 @@ namespace smt {
assert_update_field_axioms(n);
}
else {
sort * s = m.get_sort(n->get_owner());
sort * s = n->get_owner()->get_sort();
if (m_util.get_datatype_num_constructors(s) == 1) {
func_decl * c = m_util.get_datatype_constructors(s)->get(0);
assert_is_constructor_axiom(n, c, null_literal);
@ -333,7 +333,7 @@ namespace smt {
//
for (unsigned i = 0; i < num_args; i++) {
enode * arg = e->get_arg(i);
sort * s = m.get_sort(arg->get_owner());
sort * s = arg->get_owner()->get_sort();
if (m_autil.is_array(s) && m_util.is_datatype(get_array_range(s))) {
app_ref def(m_autil.mk_default(arg->get_owner()), m);
if (!ctx.e_internalized(def)) {
@ -528,7 +528,7 @@ namespace smt {
}
found = true;
}
sort * s = m.get_sort(arg->get_owner());
sort * s = arg->get_owner()->get_sort();
if (m_autil.is_array(s) && m_util.is_datatype(get_array_range(s))) {
for (enode* aarg : get_array_args(arg)) {
if (aarg->get_root() == child->get_root()) {
@ -864,7 +864,7 @@ namespace smt {
unsigned num_unassigned = 0;
unsigned unassigned_idx = UINT_MAX;
enode * n = get_enode(v);
sort * dt = m.get_sort(n->get_owner());
sort * dt = n->get_owner()->get_sort();
var_data * d = m_var_data[v];
if (d->m_recognizers.empty()) {
theory_var w = recognizer->get_arg(0)->get_th_var(get_id());
@ -947,7 +947,7 @@ namespace smt {
void theory_datatype::mk_split(theory_var v) {
v = m_find.find(v);
enode * n = get_enode(v);
sort * s = m.get_sort(n->get_owner());
sort * s = n->get_owner()->get_sort();
func_decl * non_rec_c = m_util.get_non_rec_constructor(s);
unsigned non_rec_idx = m_util.get_constructor_idx(non_rec_c);
var_data * d = m_var_data[v];

2
src/smt/theory_dense_diff_logic_def.h
View file

@ -804,7 +804,7 @@ namespace smt {
enode * n = get_enode(v);
if (m_autil.is_zero(n->get_owner()) && !m_assignment[v].is_zero()) {
numeral val = m_assignment[v];
sort * s = m.get_sort(n->get_owner());
sort * s = n->get_owner()->get_sort();
// adjust the value of all variables that have the same sort.
for (int v2 = 0; v2 < num_vars; ++v2) {
enode * n2 = get_enode(v2);

2
src/smt/theory_fpa.cpp
View file

@ -533,7 +533,7 @@ namespace smt {
model_value_proc * theory_fpa::mk_value(enode * n, model_generator & mg) {
TRACE("t_fpa", tout << "mk_value for: " << mk_ismt2_pp(n->get_owner(), m) <<
" (sort " << mk_ismt2_pp(m.get_sort(n->get_owner()), m) << ")\n";);
" (sort " << mk_ismt2_pp(n->get_owner()->get_sort(), m) << ")\n";);
app_ref owner(m);
owner = get_ite_value(n->get_owner());

2
src/smt/theory_str.cpp
View file

@ -319,7 +319,7 @@ namespace smt {
theory_var theory_str::mk_var(enode* n) {
TRACE("str", tout << "mk_var for " << mk_pp(n->get_owner(), get_manager()) << std::endl;);
ast_manager & m = get_manager();
if (!(m.get_sort(n->get_owner()) == u.str.mk_string_sort())) {
if (!(n->get_owner()->get_sort() == u.str.mk_string_sort())) {
return null_theory_var;
}
if (is_attached_to_var(n)) {

2
src/smt/theory_utvpi.h
View file

@ -328,7 +328,7 @@ namespace smt {
th_var get_zero(sort* s) { return a.is_int(s) ? m_izero : m_rzero; }
th_var get_zero(expr* e) { return get_zero(get_manager().get_sort(e)); }
th_var get_zero(expr* e) { return get_zero(e->get_sort()); }
void init_zero();