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

remove ast_manager get_sort method entirely

Browse source
This commit is contained in:
Nikolaj Bjorner 2021-02-02 13:57:01 -08:00
parent 489df0760f
commit 8f577d3943
72 changed files with 209 additions and 208 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/muz/base/bind_variables.cpp
View file

@ -79,9 +79,9 @@ expr_ref bind_variables::abstract(expr* term, cache_t& cache, unsigned scope) {
var* v = w->get_data().m_value;
if (!v) {
// allocate a bound index.
v = m.mk_var(m_names.size(), m.get_sort(a));
v = m.mk_var(m_names.size(), a->get_sort());
m_names.push_back(a->get_decl()->get_name());
m_bound.push_back(m.get_sort(a));
m_bound.push_back(a->get_sort());
w->get_data().m_value = v;
m_pinned.push_back(v);
}

2
src/muz/base/dl_rule.cpp
View file

@ -396,7 +396,7 @@ namespace datalog {
m_args.push_back(e);
}
else {
var* v = m.mk_var(num_bound++, m.get_sort(b));
var* v = m.mk_var(num_bound++, b->get_sort());
m_args.push_back(v);
body.push_back(m.mk_eq(v, b));
}

2
src/muz/base/dl_rule.h
View file

@ -62,7 +62,7 @@ namespace datalog {
m_func = n->get_decl();
}
else if (m_dt.is_accessor(n)) {
sort* s = m.get_sort(n->get_arg(0));
sort* s = n->get_arg(0)->get_sort();
SASSERT(m_dt.is_datatype(s));
if (m_dt.get_datatype_constructors(s)->size() > 1) {
m_found = true;

2
src/muz/base/rule_properties.cpp
View file

@ -216,7 +216,7 @@ void rule_properties::operator()(app* n) {
m_uninterp_funs.insert(f, m_rule);
}
else if (m_dt.is_accessor(n)) {
sort* s = m.get_sort(n->get_arg(0));
sort* s = n->get_arg(0)->get_sort();
SASSERT(m_dt.is_datatype(s));
if (m_dt.get_datatype_constructors(s)->size() > 1) {
bool found = false;

12
src/muz/bmc/dl_bmc_engine.cpp
View file

@ -293,7 +293,7 @@ namespace datalog {
sub[j] = vl;
}
else {
sub[j] = m.mk_var(j, m.get_sort(sub[j].get()));
sub[j] = m.mk_var(j, sub[j]->get_sort());
}
}
svector<std::pair<unsigned, unsigned> > positions;
@ -811,7 +811,7 @@ namespace datalog {
datatype_util dtu(m);
ptr_vector<sort> sorts;
func_decl* p = r.get_decl();
ptr_vector<func_decl> const& succs = *dtu.get_datatype_constructors(m.get_sort(path));
ptr_vector<func_decl> const& succs = *dtu.get_datatype_constructors(path->get_sort());
// populate substitution of bound variables.
r.get_vars(m, sorts);
sub.reset();
@ -928,11 +928,11 @@ namespace datalog {
ptr_vector<sort> q_sorts;
vector<symbol> names;
for (unsigned i = 0; i < vars.size(); ++i) {
q_sorts.push_back(m.get_sort(vars[i].get()));
q_sorts.push_back(vars[i]->get_sort());
names.push_back(symbol(i+1));
}
vars.push_back(path_var);
q_sorts.push_back(m.get_sort(path_var));
q_sorts.push_back(path_var->get_sort());
names.push_back(symbol("path"));
SASSERT(names.size() == q_sorts.size());
SASSERT(vars.size() == names.size());
@ -1039,7 +1039,7 @@ namespace datalog {
proof_ref get_proof(model_ref& md, app* trace, app* path) {
datatype_util dtu(m);
rule_manager& rm = b.m_ctx.get_rule_manager();
sort* trace_sort = m.get_sort(trace);
sort* trace_sort = trace->get_sort();
func_decl* p = m_sort2pred.find(trace_sort);
datalog::rule_vector const& rules = b.m_rules.get_predicate_rules(p);
ptr_vector<func_decl> const& cnstrs = *dtu.get_datatype_constructors(trace_sort);
@ -1226,7 +1226,7 @@ namespace datalog {
sub[j] = vl;
}
else {
sub[j] = m.mk_var(j, m.get_sort(sub[j].get()));
sub[j] = m.mk_var(j, sub[j]->get_sort());
}
}
svector<std::pair<unsigned, unsigned> > positions;

4
src/muz/ddnf/ddnf.cpp
View file

@ -723,7 +723,7 @@ namespace datalog {
func_decl* d = p->get_decl();
SASSERT(d->get_family_id() == null_family_id);
for (unsigned i = 0; i < p->get_num_args(); ++i) {
domain.push_back(compile_sort(m.get_sort(p->get_arg(i))));
domain.push_back(compile_sort(p->get_arg(i)->get_sort()));
}
func_decl_ref fn(m);
fn = m.mk_func_decl(d->get_name(), domain.size(), domain.c_ptr(), m.mk_bool_sort());
@ -850,7 +850,7 @@ namespace datalog {
ddnf_nodes const& ns = m_ddnfs.lookup(num_bits, *t);
ddnf_nodes::iterator it = ns.begin(), end = ns.end();
expr_ref_vector eqs(m);
sort* s = m.get_sort(w);
sort* s = w->get_sort();
for (; it != end; ++it) {
eqs.push_back(m.mk_eq(w, bv.mk_numeral(rational((*it)->get_id()), s)));
}

6
src/muz/fp/datalog_parser.cpp
View file

@ -805,10 +805,10 @@ protected:
return unexpected(tok3, "at least one argument should be a variable");
}
if (v1) {
s = m.get_sort(v1);
s = v1->get_sort();
}
else {
s = m.get_sort(v2);
s = v2->get_sort();
}
if (!v1) {
v1 = mk_const(td1, s);
@ -850,7 +850,7 @@ protected:
unsigned arity = args.size();
ptr_vector<sort> domain;
for (unsigned i = 0; i < arity; ++i) {
domain.push_back(m.get_sort(args[i].get()));
domain.push_back(args[i]->get_sort());
}
f = m.mk_func_decl(s, domain.size(), domain.c_ptr(), m.mk_bool_sort());

2
src/muz/rel/dl_external_relation.cpp
View file

@ -84,7 +84,7 @@ namespace datalog {
ast_manager& m = m_rel.get_manager();
family_id fid = get_plugin().get_family_id();
expr* rel = m_rel.get();
expr_ref res(m.mk_fresh_const("T", m.get_sort(rel)), m);
expr_ref res(m.mk_fresh_const("T", rel->get_sort()), m);
expr* rel_out = res.get();
func_decl_ref fn(m.mk_func_decl(fid, OP_RA_CLONE,0,nullptr, 1, &rel), m);
get_plugin().reduce_assign(fn, 1, &rel, 1, &rel_out);

2
src/muz/rel/dl_external_relation.h
View file

@ -117,7 +117,7 @@ namespace datalog {
unsigned size() const { return get_signature().size(); }
sort* get_sort() const { return m_rel.get_manager().get_sort(m_rel); }
sort* get_sort() const { return m_rel->get_sort(); }
void mk_accessor(decl_kind k, func_decl_ref& fn, const relation_fact& f, bool destructive, expr_ref& res) const;

2
src/muz/rel/dl_mk_explanations.cpp
View file

@ -185,7 +185,7 @@ namespace datalog {
void to_formula(expr_ref& fml) const override {
ast_manager& m = fml.get_manager();
fml = m.mk_eq(m.mk_var(0, m.get_sort(m_data[0])), m_data[0]);
fml = m.mk_eq(m.mk_var(0, m_data[0]->get_sort()), m_data[0]);
}
bool is_undefined(unsigned col_idx) const {

2
src/muz/rel/udoc_relation.h
View file

@ -105,7 +105,7 @@ namespace datalog {
static udoc_relation const & get(relation_base const& r);
void mk_union(doc_manager& dm, udoc& dst, udoc const& src, udoc* delta);
bool is_numeral(expr* e, rational& r, unsigned& num_bits);
unsigned num_sort_bits(expr* e) const { return num_sort_bits(get_ast_manager().get_sort(e)); }
unsigned num_sort_bits(expr* e) const { return num_sort_bits(e->get_sort()); }
unsigned num_sort_bits(sort* s) const;
bool is_finite_sort(sort* s) const;
unsigned num_signature_bits(relation_signature const& sig);

4
src/muz/spacer/spacer_antiunify.cpp
View file

@ -91,7 +91,7 @@ struct var_abs_rewriter : public default_rewriter_cfg {
bool get_subst(expr * s, expr * & t, proof * & t_pr) {
if (m_util.is_numeral(s)) {
t = m.mk_var(m_var_index++, m.get_sort(s));
t = m.mk_var(m_var_index++, s->get_sort());
m_substitution.insert(t, s);
m_pinned.push_back(t);
m_has_num.mark(s, true);
@ -396,7 +396,7 @@ struct mk_num_pat_rewriter : public default_rewriter_cfg {
bool get_subst(expr * s, expr * & t, proof * & t_pr) {
if (m_arith.is_numeral(s)) {
t = m.mk_var(m_subs.size(), m.get_sort(s));
t = m.mk_var(m_subs.size(), s->get_sort());
m_pinned.push_back(t);
m_subs.push_back(to_app(s));

2
src/muz/spacer/spacer_legacy_mev.cpp
View file

@ -467,7 +467,7 @@ void model_evaluator::eval_array_eq(app* e, expr* arg1, expr* arg2)
set_true(e);
return;
}
sort* s = m.get_sort(arg1);
sort* s = arg1->get_sort();
sort* r = get_array_range(s);
// give up evaluating finite domain/range arrays
if (!r->is_infinite() && !r->is_very_big() && !s->is_infinite() && !s->is_very_big()) {

2
src/muz/spacer/spacer_mev_array.cpp
View file

@ -110,7 +110,7 @@ void model_evaluator_array_util::eval_array_eq(model& mdl, app* e, expr* arg1, e
res = m.mk_true ();
return;
}
sort* s = m.get_sort(arg1);
sort* s = arg1->get_sort();
sort* r = get_array_range(s);
// give up evaluating finite domain/range arrays
if (!r->is_infinite() && !r->is_very_big() && !s->is_infinite() && !s->is_very_big()) {

2
src/muz/spacer/spacer_proof_utils.cpp
View file

@ -124,7 +124,7 @@ namespace spacer {
return false;
}
SASSERT(lit->get_num_args() == 2);
sort* s = m.get_sort(lit->get_arg(0));
sort* s = lit->get_arg(0)->get_sort();
bool is_int = m_arith.is_int(s);
if (!is_int && m_arith.is_int_expr(lit->get_arg(0))) {
is_int = true;

26
src/muz/spacer/spacer_qe_project.cpp
View file

@ -101,7 +101,7 @@ peq::peq (app* p, ast_manager& m):
VERIFY (is_partial_eq (p));
SASSERT (m_arr_u.is_array (m_lhs) &&
m_arr_u.is_array (m_rhs) &&
ast_eq_proc() (m.get_sort (m_lhs), m.get_sort (m_rhs)));
ast_eq_proc() (m_lhs->get_sort (), m_rhs->get_sort ()));
for (unsigned i = 2; i < p->get_num_args (); i++) {
m_diff_indices.push_back (p->get_arg (i));
}
@ -120,12 +120,12 @@ peq::peq (expr* lhs, expr* rhs, unsigned num_indices, expr * const * diff_indice
{
SASSERT (m_arr_u.is_array (lhs) &&
m_arr_u.is_array (rhs) &&
ast_eq_proc() (m.get_sort (lhs), m.get_sort (rhs)));
ast_eq_proc() (lhs->get_sort (), rhs->get_sort ()));
ptr_vector<sort> sorts;
sorts.push_back (m.get_sort (m_lhs));
sorts.push_back (m.get_sort (m_rhs));
sorts.push_back (m_lhs->get_sort ());
sorts.push_back (m_rhs->get_sort ());
for (unsigned i = 0; i < num_indices; i++) {
sorts.push_back (m.get_sort (diff_indices [i]));
sorts.push_back (diff_indices[i]->get_sort ());
m_diff_indices.push_back (diff_indices [i]);
}
m_decl = m.mk_func_decl (symbol (PARTIAL_EQ), sorts.size (), sorts.c_ptr (), m.mk_bool_sort ());
@ -161,7 +161,7 @@ void peq::mk_eq (app_ref_vector& aux_consts, app_ref& result, bool stores_on_rhs
std::swap (lhs, rhs);
}
// lhs = (...(store (store rhs i0 v0) i1 v1)...)
sort* val_sort = get_array_range (m.get_sort (lhs));
sort* val_sort = get_array_range (lhs->get_sort ());
expr_ref_vector::iterator end = m_diff_indices.end ();
for (expr_ref_vector::iterator it = m_diff_indices.begin ();
it != end; it++) {
@ -241,7 +241,7 @@ namespace spacer_qe {
res = is_linear(-mul, t1, c, ts);
}
else if (a.is_numeral(t, mul1)) {
ts.push_back(a.mk_numeral(mul*mul1, m.get_sort(t)));
ts.push_back(a.mk_numeral(mul*mul1, t->get_sort()));
}
else if ((*m_var)(t)) {
IF_VERBOSE(2, verbose_stream() << "can't project:" << mk_pp(t, m) << "\n";);
@ -252,7 +252,7 @@ namespace spacer_qe {
ts.push_back(t);
}
else {
ts.push_back(a.mk_mul(a.mk_numeral(mul, m.get_sort(t)), t));
ts.push_back(a.mk_mul(a.mk_numeral(mul, t->get_sort()), t));
}
return res;
}
@ -411,7 +411,7 @@ namespace spacer_qe {
expr_ref cx (m), cxt (m), z (m), result (m);
cx = mk_mul (m_coeffs[i], eq_term);
cxt = mk_add (cx, m_terms.get(i));
z = a.mk_numeral(rational(0), m.get_sort(eq_term));
z = a.mk_numeral(rational(0), eq_term->get_sort());
if (m_eq[i]) {
// c*x + t = 0
result = a.mk_eq (cxt, z);
@ -842,7 +842,7 @@ namespace spacer_qe {
bt = mk_mul(abs(bc), t);
as = mk_mul(abs(ac), s);
ts = mk_add(bt, as);
z = a.mk_numeral(rational(0), m.get_sort(t));
z = a.mk_numeral(rational(0), t->get_sort());
expr_ref result1(m), result2(m);
if (m_strict[i] || m_strict[j]) {
result1 = a.mk_lt(ts, z);
@ -898,7 +898,7 @@ namespace spacer_qe {
return a.mk_add(t1, t2);
}
expr* mk_mul(rational const& r, expr* t2) {
expr* t1 = a.mk_numeral(r, m.get_sort(t2));
expr* t1 = a.mk_numeral(r, t2->get_sort());
return a.mk_mul(t1, t2);
}
@ -1407,7 +1407,7 @@ namespace spacer_qe {
// if a_new is select on m_v, introduce new constant
if (m_arr_u.is_select (a) &&
(args.get (0) == m_v || m_has_stores_v.is_marked (args.get (0)))) {
sort* val_sort = get_array_range (m.get_sort (m_v));
sort* val_sort = get_array_range (m_v->get_sort());
app_ref val_const (m.mk_fresh_const ("sel", val_sort), m);
m_aux_vars.push_back (val_const);
// extend M to include val_const
@ -2073,7 +2073,7 @@ namespace spacer_qe {
if (sel_terms.empty ()) return;
expr* v = sel_terms.get (0)->get_arg (0); // array variable
sort* v_sort = m.get_sort (v);
sort* v_sort = v->get_sort ();
sort* val_sort = get_array_range (v_sort);
sort* idx_sort = get_array_domain (v_sort, 0);
(void) idx_sort;

8
src/muz/tab/tab_context.cpp
View file

@ -1216,9 +1216,9 @@ namespace tb {
func_decl_ref delta(m);
sort_ref_vector dom(m);
for (unsigned j = 0; j < 1; ++j) {
for (unsigned i = 0; i < zs.size(); ++i) {
dom.push_back(m.get_sort(zs[i].get()));
zszs.push_back(zs[i].get());
for (expr* arg : zs) {
dom.push_back(arg->get_sort());
zszs.push_back(arg);
}
}
app_ref_vector preds(m);
@ -1282,7 +1282,7 @@ namespace tb {
app* p = g.get_head();
unsigned num_vars = g.get_num_vars();
for (unsigned i = 0; i < p->get_num_args(); ++i) {
result.push_back(m.mk_var(num_vars+i, m.get_sort(p->get_arg(i))));
result.push_back(m.mk_var(num_vars+i, p->get_arg(i)->get_sort()));
}
return result;
}

8
src/muz/transforms/dl_mk_coalesce.cpp
View file

@ -48,10 +48,10 @@ namespace datalog {
for (unsigned i = 0; i < sz; ++i) {
expr* a = p1->get_arg(i);
expr* b = p2->get_arg(i);
SASSERT(m.get_sort(a) == m.get_sort(b));
SASSERT(a->get_sort() == b->get_sort());
m_sub1.push_back(a);
m_sub2.push_back(b);
args.push_back(m.mk_var(m_idx++, m.get_sort(a)));
args.push_back(m.mk_var(m_idx++, a->get_sort()));
}
pred = m.mk_app(p1->get_decl(), args.size(), args.c_ptr());
}
@ -80,14 +80,14 @@ namespace datalog {
}
else {
SASSERT(revsub[v].get());
SASSERT(m.get_sort(revsub[v].get()) == s);
SASSERT(revsub[v]->get_sort() == s);
conjs.push_back(m.mk_eq(revsub[v].get(), w));
}
}
}
else {
SASSERT(m.is_value(e));
SASSERT(e->get_sort() == m.get_sort(w));
SASSERT(e->get_sort() == w->get_sort());
conjs.push_back(m.mk_eq(e, w));
}
}

2
src/muz/transforms/dl_mk_elim_term_ite.cpp
View file

@ -95,7 +95,7 @@ namespace datalog {
continue;
if (!m_ground.get(i))
m_ground[i] = m.mk_fresh_const("c", fv[i]);
SASSERT(m.get_sort(m_ground.get(i)) == fv[i]);
SASSERT(m_ground[i]->get_sort() == fv[i]);
}
var_subst vsub(m, false);
return vsub(e, m_ground);

4
src/muz/transforms/dl_mk_quantifier_abstraction.cpp
View file

@ -95,7 +95,7 @@ namespace datalog {
// the original predicate.
expr_safe_replace rep(m);
for (unsigned i = 0; i < sub.size(); ++i) {
rep.insert(m.mk_var(i, m.get_sort(sub[i])), sub[i]);
rep.insert(m.mk_var(i, sub[i]->get_sort()), sub[i]);
}
rep(body);
rep.reset();
@ -130,7 +130,7 @@ namespace datalog {
// 4. replace remaining constants by variables.
unsigned j = 0;
for (expr* f : _free) {
rep.insert(f, m.mk_var(j++, m.get_sort(f)));
rep.insert(f, m.mk_var(j++, f->get_sort()));
}
rep(body);