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

refactor get_sort

Browse source
This commit is contained in:
Nikolaj Bjorner 2021-02-02 04:45:54 -08:00
parent 4455f6caf8
commit 3ae4c6e9de
129 changed files with 362 additions and 362 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/smt/proto_model/proto_model.cpp
View file

@ -326,7 +326,7 @@ expr * proto_model::get_fresh_value(sort * s) {
}
void proto_model::register_value(expr * n) {
sort * s = m.get_sort(n);
sort * s = n->get_sort();
if (m.is_uninterp(s)) {
m_user_sort_factory->register_value(n);
}

6
src/smt/seq_axioms.cpp
View file

@ -481,7 +481,7 @@ void seq_axioms::add_at_axiom(expr* e) {
m_rewrite(i);
expr_ref zero(a.mk_int(0), m);
expr_ref one(a.mk_int(1), m);
expr_ref emp(seq.str.mk_empty(m.get_sort(e)), m);
expr_ref emp(seq.str.mk_empty(e->get_sort()), m);
expr_ref len_s = mk_len(s);
literal i_ge_0 = mk_ge(i, 0);
literal i_ge_len_s = mk_ge(mk_sub(i, mk_len(s)), 0);
@ -497,7 +497,7 @@ void seq_axioms::add_at_axiom(expr* e) {
}
nth = es.back();
es.push_back(m_sk.mk_tail(s, i));
add_axiom(~i_ge_0, i_ge_len_s, mk_seq_eq(s, seq.str.mk_concat(es, m.get_sort(e))));
add_axiom(~i_ge_0, i_ge_len_s, mk_seq_eq(s, seq.str.mk_concat(es, e->get_sort())));
add_axiom(~i_ge_0, i_ge_len_s, mk_seq_eq(nth, e));
}
else {
@ -746,7 +746,7 @@ void seq_axioms::add_lt_axiom(expr* n) {
expr_ref e1(_e1, m), e2(_e2, m);
m_rewrite(e1);
m_rewrite(e2);
sort* s = m.get_sort(e1);
sort* s = e1->get_sort();
sort* char_sort = nullptr;
VERIFY(seq.is_seq(s, char_sort));
literal lt = mk_literal(n);

10
src/smt/seq_eq_solver.cpp
View file

@ -582,7 +582,7 @@ bool theory_seq::split_lengths(dependency* dep,
if (lenY.is_zero()) {
return set_empty(Y);
}
b = mk_concat(bs, m.get_sort(X));
b = mk_concat(bs, X->get_sort());
SASSERT(X != Y);
@ -738,7 +738,7 @@ bool theory_seq::branch_unit_variable(dependency* dep, expr* X, expr_ref_vector
literal lit = mk_eq(m_autil.mk_int(lX), mk_len(X), false);
switch (ctx.get_assignment(lit)) {
case l_true: {
expr_ref R = mk_concat(lX, units.c_ptr(), m.get_sort(X));
expr_ref R = mk_concat(lX, units.c_ptr(), X->get_sort());
return propagate_eq(dep, lit, X, R);
}
case l_undef:
@ -1314,7 +1314,7 @@ bool theory_seq::propagate_length_coherence(expr* e) {
elems.push_back(head);
seq = tail;
}
expr_ref emp(m_util.str.mk_empty(m.get_sort(e)), m);
expr_ref emp(m_util.str.mk_empty(e->get_sort()), m);
elems.push_back(seq);
tail = mk_concat(elems.size(), elems.c_ptr());
// len(e) >= low => e = tail;
@ -1344,7 +1344,7 @@ bool theory_seq::propagate_length_coherence(expr* e) {
bool theory_seq::check_length_coherence(expr* e) {
if (is_var(e) && m_rep.is_root(e)) {
if (!check_length_coherence0(e)) {
expr_ref emp(m_util.str.mk_empty(m.get_sort(e)), m);
expr_ref emp(m_util.str.mk_empty(e->get_sort()), m);
expr_ref head(m), tail(m);
// e = emp \/ e = unit(head.elem(e))*tail(e)
m_sk.decompose(e, head, tail);
@ -1360,7 +1360,7 @@ bool theory_seq::check_length_coherence(expr* e) {
bool theory_seq::check_length_coherence0(expr* e) {
if (is_var(e) && m_rep.is_root(e)) {
expr_ref emp(m_util.str.mk_empty(m.get_sort(e)), m);
expr_ref emp(m_util.str.mk_empty(e->get_sort()), m);
bool p = propagate_length_coherence(e);
if (p || assume_equality(e, emp)) {

4
src/smt/seq_skolem.cpp
View file

@ -44,7 +44,7 @@ expr_ref seq_skolem::mk(symbol const& s, expr* e1, expr* e2, expr* e3, expr* e4,
expr* es[4] = { e1, e2, e3, e4 };
unsigned len = e4?4:(e3?3:(e2?2:(e1?1:0)));
if (!range) {
range = m.get_sort(e1);
range = e1->get_sort();
}
expr_ref result(seq.mk_skolem(s, len, es, range), m);
if (rw)
@ -93,7 +93,7 @@ decompose_main:
}
else if (seq.str.is_unit(e)) {
head = e;
tail = seq.str.mk_empty(m.get_sort(e));
tail = seq.str.mk_empty(e->get_sort());
m_rewrite(head);
}
else if (seq.str.is_concat(e, e1, e2) && seq.str.is_empty(e1)) {

6
src/smt/smt_arith_value.cpp
View file

@ -134,7 +134,7 @@ namespace smt {
rational lo;
bool s = false;
if ((a.is_int_real(e) || b.is_bv(e)) && get_lo(e, lo, s) && !s) {
return expr_ref(a.mk_numeral(lo, m.get_sort(e)), m);
return expr_ref(a.mk_numeral(lo, e->get_sort()), m);
}
return expr_ref(e, m);
}
@ -143,7 +143,7 @@ namespace smt {
rational up;
bool s = false;
if ((a.is_int_real(e) || b.is_bv(e)) && get_up(e, up, s) && !s) {
return expr_ref(a.mk_numeral(up, m.get_sort(e)), m);
return expr_ref(a.mk_numeral(up, e->get_sort()), m);
}
return expr_ref(e, m);
}
@ -152,7 +152,7 @@ namespace smt {
rational lo, up;
bool s = false;
if (a.is_int_real(e) && get_lo(e, lo, s) && !s && get_up(e, up, s) && !s && lo == up) {
return expr_ref(a.mk_numeral(lo, m.get_sort(e)), m);
return expr_ref(a.mk_numeral(lo, e->get_sort()), m);
}
return expr_ref(e, m);
}

2
src/smt/smt_consequences.cpp
View file

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

2
src/smt/smt_induction.cpp
View file

@ -277,7 +277,7 @@ bool induction_lemmas::positions_dont_overlap(induction_positions_t const& posit
*/
void induction_lemmas::mk_hypothesis_substs(unsigned depth, expr* x, cond_substs_t& subst) {
expr_ref_vector conds(m);
mk_hypothesis_substs_rec(depth, m.get_sort(x), x, conds, subst);
mk_hypothesis_substs_rec(depth, x->get_sort(), x, conds, subst);
}
void induction_lemmas::mk_hypothesis_substs_rec(unsigned depth, sort* s, expr* y, expr_ref_vector& conds, cond_substs_t& subst) {

2
src/smt/smt_value_sort.cpp
View file

@ -68,7 +68,7 @@ namespace smt {
}
bool is_value_sort(ast_manager& m, expr* e) {
return is_value_sort(m, m.get_sort(e));
return is_value_sort(m, e->get_sort());
}
}

2
src/smt/tactic/ctx_solver_simplify_tactic.cpp
View file

@ -230,7 +230,7 @@ protected:
}
}
else if (!n2 && !m.is_value(arg)) {
n2 = mk_fresh(id, m.get_sort(arg));
n2 = mk_fresh(id, arg->get_sort());
trail.push_back(n2);
todo.push_back(expr_pos(self_pos, ++child_id, i, arg));
names.push_back(n2);

4
src/smt/theory_array_base.cpp
View file

@ -317,7 +317,7 @@ namespace smt {
app * e2 = n2->get_owner();
func_decl_ref_vector * funcs = nullptr;
sort * s = m.get_sort(e1);
sort * s = e1->get_sort();
VERIFY(m_sort2skolem.find(s, funcs));
@ -353,7 +353,7 @@ namespace smt {
void theory_array_base::assert_congruent_core(enode * n1, enode * n2) {
app * e1 = n1->get_owner();
app * e2 = n2->get_owner();
sort* s = m.get_sort(e1);
sort* s = e1->get_sort();
unsigned dimension = get_array_arity(s);
literal n1_eq_n2 = mk_eq(e1, e2, true);
ctx.mark_as_relevant(n1_eq_n2);

2
src/smt/theory_array_full.cpp
View file

@ -720,7 +720,7 @@ namespace smt {
for (unsigned i = 1; i + 1 < num_args; ++i) {
expr* arg = store_app->get_arg(i);
sort* srt = m.get_sort(arg);
sort* srt = arg->get_sort();
auto ep = mk_epsilon(srt);
eqs.push_back(m.mk_eq(ep.first, arg));
args1.push_back(m.mk_app(ep.second, arg));

4
src/smt/theory_bv.cpp
View file

@ -602,7 +602,7 @@ namespace smt {
SASSERT(ctx.e_internalized(n));
SASSERT(m_util.is_bv2int(n));
TRACE("bv2int_bug", tout << "bv2int:\n" << mk_pp(n, m) << "\n";);
sort * int_sort = m.get_sort(n);
sort * int_sort = n->get_sort();
app * k = to_app(n->get_arg(0));
SASSERT(m_util.is_bv_sort(m.get_sort(k)));
expr_ref_vector k_bits(m);
@ -1086,7 +1086,7 @@ namespace smt {
unsigned num_args = n->get_num_args();
for (unsigned i = 0; i <= num_args; i++) {
expr* arg = (i == num_args)?n:n->get_arg(i);
sort* s = m.get_sort(arg);
sort* s = arg->get_sort();
if (m_util.is_bv_sort(s) && m_util.get_bv_size(arg) > params().m_bv_blast_max_size) {
if (!m_approximates_large_bvs) {
TRACE("bv", tout << "found large size bit-vector:\n" << mk_pp(n, m) << "\n";);

2
src/smt/theory_char.cpp
View file

@ -121,7 +121,7 @@ namespace smt {
bits.push_back(literal(ctx.get_bool_var(arg)));
for (literal bit : bits)
ctx.mark_as_relevant(bit);
expr_ref bits2char(seq.mk_skolem(m_bits2char, ebits.size(), ebits.c_ptr(), m.get_sort(e)), m);
expr_ref bits2char(seq.mk_skolem(m_bits2char, ebits.size(), ebits.c_ptr(), e->get_sort()), m);
ctx.mark_as_relevant(bits2char.get());
enode* n1 = ensure_enode(e);
enode* n2 = ensure_enode(bits2char);

4
src/smt/theory_datatype.cpp
View file

@ -142,9 +142,9 @@ namespace smt {
<< mk_pp(c, m) << " " << mk_pp(e, m) << "\n";);
m_stats.m_assert_cnstr++;
SASSERT(m_util.is_constructor(c));
SASSERT(m_util.is_datatype(m.get_sort(e)));
SASSERT(m_util.is_datatype(e->get_sort()));
SASSERT(c->get_range() == m.get_sort(e));
SASSERT(c->get_range() == e->get_sort());
ptr_vector<expr> args;
ptr_vector<func_decl> const & accessors = *m_util.get_constructor_accessors(c);
SASSERT(c->get_arity() == accessors.size());

2
src/smt/theory_dense_diff_logic_def.h
View file

@ -45,7 +45,7 @@ namespace smt {
template<typename Ext>
inline app * theory_dense_diff_logic<Ext>::mk_zero_for(expr * n) {
return m_autil.mk_numeral(rational(0), m.get_sort(n));
return m_autil.mk_numeral(rational(0), n->get_sort());
}
template<typename Ext>

2
src/smt/theory_fpa.cpp
View file

@ -459,7 +459,7 @@ namespace smt {
}
else {
expr_ref wu(m);
wu = m.mk_eq(m_converter.unwrap(wrapped, m.get_sort(n)), n);
wu = m.mk_eq(m_converter.unwrap(wrapped, n->get_sort()), n);
TRACE("t_fpa", tout << "w/u eq: " << std::endl << mk_ismt2_pp(wu, m) << std::endl;);
assert_cnstr(wu);
}

2
src/smt/theory_lra.cpp
View file

@ -2295,7 +2295,7 @@ public:
return;
expr* e1 = n1->get_owner();
expr* e2 = n2->get_owner();
if (m.get_sort(e1) != m.get_sort(e2))
if (e1->get_sort() != m.get_sort(e2))
return;
if (m.is_ite(e1) || m.is_ite(e2))
return;

8
src/smt/theory_seq.cpp
View file

@ -482,7 +482,7 @@ bool theory_seq::fixed_length(expr* len_e, bool is_zero) {
expr_ref seq(e, m), head(m), tail(m);
if (lo.is_zero()) {
seq = m_util.str.mk_empty(m.get_sort(e));
seq = m_util.str.mk_empty(e->get_sort());
}
else if (!is_zero) {
unsigned _lo = lo.get_unsigned();
@ -1934,7 +1934,7 @@ model_value_proc * theory_seq::mk_value(enode * n, model_generator & mg) {
expr* x = nullptr, *y = nullptr, *z = nullptr;
if (false && m_util.str.is_concat(e, x, y) && m_util.str.is_unit(x, z) &&
ctx.e_internalized(z) && ctx.e_internalized(y)) {
sort* srt = m.get_sort(e);
sort* srt = e->get_sort();
seq_value_proc* sv = alloc(seq_value_proc, *this, n, srt);
sv->add_unit(ctx.get_enode(z));
sv->add_string(y);
@ -1946,7 +1946,7 @@ model_value_proc * theory_seq::mk_value(enode * n, model_generator & mg) {
SASSERT(m_todo.empty());
m_todo.push_back(e);
get_ite_concat(m_concat, m_todo);
sort* srt = m.get_sort(e);
sort* srt = e->get_sort();
seq_value_proc* sv = alloc(seq_value_proc, *this, n, srt);
unsigned end = m_concat.size();
@ -2753,7 +2753,7 @@ literal theory_seq::mk_eq_empty(expr* _e, bool phase) {
return false_literal;
}
}
emp = m_util.str.mk_empty(m.get_sort(e));
emp = m_util.str.mk_empty(e->get_sort());
literal lit = mk_eq(e, emp, false);
ctx.force_phase(phase?lit:~lit);

4
src/smt/theory_str.cpp
View file

@ -311,7 +311,7 @@ namespace smt {
enode * en = ensure_enode(e);
theory_var v = mk_var(en); (void)v;
TRACE("str", tout << "refresh " << mk_pp(e, get_manager()) << ": v#" << v << std::endl;);
if (m.get_sort(e) == u.str.mk_string_sort()) {
if (e->get_sort() == u.str.mk_string_sort()) {
m_basicstr_axiom_todo.push_back(en);
}
}
@ -6771,7 +6771,7 @@ namespace smt {
bool theory_str::is_var(expr * e) const {
ast_manager & m = get_manager();
sort * ex_sort = m.get_sort(e);
sort * ex_sort = e->get_sort();
sort * str_sort = u.str.mk_string_sort();
// non-string-sort terms cannot be string variables
if (ex_sort != str_sort) return false;