mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-14 21:08:46 +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
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/ackermannization/ackr_model_converter.cpp
View file

@ -133,7 +133,7 @@ void ackr_model_converter::add_entry(model_evaluator & evaluator,
app* A = to_app(term->get_arg(0)); app* A = to_app(term->get_arg(0));
expr * e = nullptr, *c = nullptr; expr * e = nullptr, *c = nullptr;
if (!array_interpretations.find(A, e)) { if (!array_interpretations.find(A, e)) {
e = autil.mk_const_array(m.get_sort(A), value); e = autil.mk_const_array(A->get_sort(), value);
} }
else { else {
// avoid storing the same as the default value. // avoid storing the same as the default value.

8
src/ackermannization/lackr.cpp
View file

@ -175,12 +175,12 @@ void lackr::abstract_fun(fun2terms_map const& apps) {
for (auto const& kv : apps) { for (auto const& kv : apps) {
func_decl* fd = kv.m_key; func_decl* fd = kv.m_key;
for (app * t : kv.m_value->var_args) { for (app * t : kv.m_value->var_args) {
app * fc = m.mk_fresh_const(fd->get_name(), m.get_sort(t)); app * fc = m.mk_fresh_const(fd->get_name(), t->get_sort());
SASSERT(t->get_decl() == fd); SASSERT(t->get_decl() == fd);
m_info->set_abstr(t, fc); m_info->set_abstr(t, fc);
} }
for (app * t : kv.m_value->const_args) { for (app * t : kv.m_value->const_args) {
app * fc = m.mk_fresh_const(fd->get_name(), m.get_sort(t)); app * fc = m.mk_fresh_const(fd->get_name(), t->get_sort());
SASSERT(t->get_decl() == fd); SASSERT(t->get_decl() == fd);
m_info->set_abstr(t, fc); m_info->set_abstr(t, fc);
} }
@ -192,11 +192,11 @@ void lackr::abstract_sel(sel2terms_map const& apps) {
for (auto const& kv : apps) { for (auto const& kv : apps) {
func_decl * fd = kv.m_key->get_decl(); func_decl * fd = kv.m_key->get_decl();
for (app * t : kv.m_value->const_args) { for (app * t : kv.m_value->const_args) {
app * fc = m.mk_fresh_const(fd->get_name(), m.get_sort(t)); app * fc = m.mk_fresh_const(fd->get_name(), t->get_sort());
m_info->set_abstr(t, fc); m_info->set_abstr(t, fc);
} }
for (app * t : kv.m_value->var_args) { for (app * t : kv.m_value->var_args) {
app * fc = m.mk_fresh_const(fd->get_name(), m.get_sort(t)); app * fc = m.mk_fresh_const(fd->get_name(), t->get_sort());
m_info->set_abstr(t, fc); m_info->set_abstr(t, fc);
} }
} }

2
src/ackermannization/lackr_model_constructor.cpp
View file

@ -325,7 +325,7 @@ private:
if (k == OP_EQ) { if (k == OP_EQ) {
// theory dispatch for = // theory dispatch for =
SASSERT(num == 2); SASSERT(num == 2);
family_id s_fid = m.get_sort(values.get(0))->get_family_id(); family_id s_fid = values[0]->get_sort()->get_family_id();
if (s_fid == m_bv_rw.get_fid()) if (s_fid == m_bv_rw.get_fid())
m_bv_rw.mk_eq_core(values.get(0), values.get(1), result); m_bv_rw.mk_eq_core(values.get(0), values.get(1), result);
} else { } else {

8
src/ast/fpa/fpa2bv_converter.cpp
View file

@ -2415,7 +2415,7 @@ void fpa2bv_converter::mk_to_fp(func_decl * f, unsigned num, expr * const * args
} }
else if (num == 2 && else if (num == 2 &&
m_util.is_rm(args[0]) && m_util.is_rm(args[0]) &&
m_util.is_float(m.get_sort(args[1]))) { m_util.is_float(args[1]->get_sort())) {
// rm + float -> float // rm + float -> float
mk_to_fp_float(f, f->get_range(), args[0], args[1], result); mk_to_fp_float(f, f->get_range(), args[0], args[1], result);
} }
@ -3223,7 +3223,7 @@ void fpa2bv_converter::mk_to_ieee_bv_unspecified(func_decl * f, unsigned num, ex
else { else {
expr_ref nw = nan_wrap(args[0]); expr_ref nw = nan_wrap(args[0]);
sort * domain[1] = { m.get_sort(nw) }; sort * domain[1] = { nw->get_sort() };
func_decl * f_bv = mk_bv_uf(f, domain, f->get_range()); func_decl * f_bv = mk_bv_uf(f, domain, f->get_range());
result = m.mk_app(f_bv, nw); result = m.mk_app(f_bv, nw);
@ -3439,7 +3439,7 @@ void fpa2bv_converter::mk_to_bv_unspecified(func_decl * f, unsigned num, expr *
else { else {
expr * rm_bv = to_app(args[0])->get_arg(0); expr * rm_bv = to_app(args[0])->get_arg(0);
expr_ref nw = nan_wrap(args[1]); expr_ref nw = nan_wrap(args[1]);
sort * domain[2] = { m.get_sort(rm_bv), m.get_sort(nw) }; sort * domain[2] = { rm_bv->get_sort(), nw->get_sort() };
func_decl * f_bv = mk_bv_uf(f, domain, f->get_range()); func_decl * f_bv = mk_bv_uf(f, domain, f->get_range());
result = m.mk_app(f_bv, rm_bv, nw); result = m.mk_app(f_bv, rm_bv, nw);
} }
@ -3456,7 +3456,7 @@ void fpa2bv_converter::mk_to_real_unspecified(func_decl * f, unsigned num, expr
else { else {
expr * n = args[0]; expr * n = args[0];
expr_ref nw = nan_wrap(n); expr_ref nw = nan_wrap(n);
sort * domain[1] = { m.get_sort(nw) }; sort * domain[1] = { nw->get_sort() };
func_decl * f_bv = mk_bv_uf(f, domain, f->get_range()); func_decl * f_bv = mk_bv_uf(f, domain, f->get_range());
result = m.mk_app(f_bv, nw); result = m.mk_app(f_bv, nw);
} }

4
src/ast/rewriter/enum2bv_rewriter.cpp
View file

@ -64,9 +64,9 @@ struct enum2bv_rewriter::imp {
unsigned bv_size = get_bv_size(s); unsigned bv_size = get_bv_size(s);
sort_ref bv_sort(m_bv.mk_sort(bv_size), m); sort_ref bv_sort(m_bv.mk_sort(bv_size), m);
if (is_unate(s)) if (is_unate(s))
return m_bv.mk_numeral(rational((1 << idx) - 1), bv_sort); return m_bv.mk_numeral(rational((1 << idx) - 1), bv_sort.get());
else else
return m_bv.mk_numeral(rational(idx), bv_sort); return m_bv.mk_numeral(rational(idx), bv_sort.get());
} }
void constrain_domain(expr* x, sort* s, sort* bv_sort) { void constrain_domain(expr* x, sort* s, sort* bv_sort) {

2
src/ast/rewriter/expr_safe_replace.cpp
View file

@ -99,7 +99,7 @@ void expr_safe_replace::operator()(expr* e, expr_ref& res) {
if (d) { if (d) {
m_args.push_back(d); m_args.push_back(d);
arg_differs |= arg != d; arg_differs |= arg != d;
SASSERT(arg->get_sort() == m.get_sort(d)); SASSERT(arg->get_sort() == d->get_sort());
} }
else { else {
m_todo.push_back(arg); m_todo.push_back(arg);

2
src/ast/rewriter/func_decl_replace.cpp
View file

@ -43,7 +43,7 @@ expr_ref func_decl_replace::operator()(expr* e) {
if (m_cache.find(arg, d)) { if (m_cache.find(arg, d)) {
m_args.push_back(d); m_args.push_back(d);
arg_differs |= arg != d; arg_differs |= arg != d;
SASSERT(arg->get_sort() == m.get_sort(d)); SASSERT(arg->get_sort() == d->get_sort());
} }
else { else {
m_todo.push_back(arg); m_todo.push_back(arg);

4
src/cmd_context/cmd_context.cpp
View file

@ -327,7 +327,7 @@ bool cmd_context::macros_find(symbol const& s, unsigned n, expr*const* args, exp
bool eq = true; bool eq = true;
coerced_args.reset(); coerced_args.reset();
for (unsigned i = 0; eq && i < n; ++i) { for (unsigned i = 0; eq && i < n; ++i) {
if (d.m_domain[i] == m().get_sort(args[i])) { if (d.m_domain[i] == args[i]->get_sort()) {
coerced_args.push_back(args[i]); coerced_args.push_back(args[i]);
continue; continue;
} }
@ -1132,7 +1132,7 @@ void cmd_context::mk_app(symbol const & s, unsigned num_args, expr * const * arg
bool first = true; bool first = true;
for (unsigned i = 0; i < num_args; ++i, first = false) { for (unsigned i = 0; i < num_args; ++i, first = false) {
if (!first) buffer << " "; if (!first) buffer << " ";
buffer << mk_pp(m().get_sort(args[i]), m()); buffer << mk_pp(args[i]->get_sort(), m());
} }
buffer << ") "; buffer << ") ";
if (range) buffer << mk_pp(range, m()) << " "; if (range) buffer << mk_pp(range, m()) << " ";

2
src/cmd_context/extra_cmds/dbg_cmds.cpp
View file

@ -293,7 +293,7 @@ public:
throw cmd_exception("invalid command, mismatch between the number of quantified variables and the number of arguments."); throw cmd_exception("invalid command, mismatch between the number of quantified variables and the number of arguments.");
unsigned i = num; unsigned i = num;
while (i-- > 0) { while (i-- > 0) {
sort * s = ctx.m().get_sort(ts[i]); sort * s = ts[i]->get_sort();
if (s != m_q->get_decl_sort(i)) { if (s != m_q->get_decl_sort(i)) {
std::ostringstream buffer; std::ostringstream buffer;
buffer << "invalid command, sort mismatch at position " << i; buffer << "invalid command, sort mismatch at position " << i;

18
src/opt/opt_lns.cpp
View file

@ -65,6 +65,12 @@ namespace opt {
void lns::setup_assumptions(model_ref& mdl, expr_ref_vector const& asms) { void lns::setup_assumptions(model_ref& mdl, expr_ref_vector const& asms) {
m_hardened.reset(); m_hardened.reset();
m_soft.reset(); m_soft.reset();
std::cout << "disjoint cores: " << m_cores.size() << "\n";
for (auto const& c : m_cores)
std::cout << c.size() << "\n";
m_was_flipped.reset();
m_in_core.reset();
m_cores.reset();
for (expr* a : asms) { for (expr* a : asms) {
if (mdl->is_true(a)) if (mdl->is_true(a))
m_hardened.push_back(a); m_hardened.push_back(a);
@ -118,6 +124,7 @@ namespace opt {
m_hardened.push_back(m.mk_not(soft(i))); m_hardened.push_back(m.mk_not(soft(i)));
for (unsigned k = i; k + 1 < m_soft.size(); ++k) for (unsigned k = i; k + 1 < m_soft.size(); ++k)
m_soft[k] = soft(k + 1); m_soft[k] = soft(k + 1);
m_was_flipped.mark(m_hardened.back());
m_soft.pop_back(); m_soft.pop_back();
--i; --i;
break; break;
@ -157,9 +164,14 @@ namespace opt {
if (r == l_false) { if (r == l_false) {
expr_ref_vector core(m); expr_ref_vector core(m);
s.get_unsat_core(core); s.get_unsat_core(core);
std::cout << "core size " << core.size() << "\n"; bool was_flipped = false;
if (core.size() == 4) for (expr* c : core)
std::cout << core << "\n"; was_flipped |= m_was_flipped.is_marked(c);
if (!was_flipped) {
for (expr* c : core)
m_in_core.mark(c, true);
m_cores.push_back(core);
}
} }
#endif #endif
return r; return r;

5
src/opt/opt_lns.h
View file

@ -33,6 +33,11 @@ namespace opt {
expr_ref_vector m_soft; expr_ref_vector m_soft;
unsigned m_max_conflicts { 1000 }; unsigned m_max_conflicts { 1000 };
unsigned m_num_improves { 0 }; unsigned m_num_improves { 0 };
vector<expr_ref_vector> m_cores;
expr_mark m_in_core;
expr_mark m_was_flipped;
std::function<void(model_ref& m)> m_update_model; std::function<void(model_ref& m)> m_update_model;
expr* soft(unsigned i) const { return m_soft[i]; } expr* soft(unsigned i) const { return m_soft[i]; }

10
src/parsers/smt2/smt2parser.cpp
View file

@ -1444,7 +1444,7 @@ namespace smt2 {
// compute match condition and substitution // compute match condition and substitution
// t is shifted by size of subst. // t is shifted by size of subst.
expr_ref bind_match(expr* t, expr* pattern, expr_ref_vector& subst) { expr_ref bind_match(expr* t, expr* pattern, expr_ref_vector& subst) {
if (t->get_sort() != m().get_sort(pattern)) { if (t->get_sort() != pattern->get_sort()) {
std::ostringstream str; std::ostringstream str;
str << "sorts of pattern " << expr_ref(pattern, m()) << " and term " str << "sorts of pattern " << expr_ref(pattern, m()) << " and term "
<< expr_ref(t, m()) << " are not aligned"; << expr_ref(t, m()) << " are not aligned";
@ -2271,7 +2271,7 @@ namespace smt2 {
unsigned num_vars = parse_sorted_vars(); unsigned num_vars = parse_sorted_vars();
parse_sort("Invalid function definition"); parse_sort("Invalid function definition");
parse_expr(); parse_expr();
if (m().get_sort(expr_stack().back()) != sort_stack().back()) if (expr_stack().back()->get_sort() != sort_stack().back())
throw parser_exception("invalid function/constant definition, sort mismatch"); throw parser_exception("invalid function/constant definition, sort mismatch");
sort* const* sorts = sort_stack().c_ptr() + sort_spos; sort* const* sorts = sort_stack().c_ptr() + sort_spos;
expr* t = expr_stack().back(); expr* t = expr_stack().back();
@ -2427,11 +2427,11 @@ namespace smt2 {
symbol_stack().shrink(sym_spos); symbol_stack().shrink(sym_spos);
m_env.end_scope(); m_env.end_scope();
m_num_bindings = 0; m_num_bindings = 0;
if (m().get_sort(body) != f->get_range()) { if (body->get_sort() != f->get_range()) {
std::ostringstream buffer; std::ostringstream buffer;
buffer << "invalid function definition, sort mismatch. Expcected " buffer << "invalid function definition, sort mismatch. Expcected "
<< mk_pp(f->get_range(), m()) << " but function body has sort " << mk_pp(f->get_range(), m()) << " but function body has sort "
<< mk_pp(m().get_sort(body), m()); << mk_pp(body->get_sort(), m());
throw parser_exception(buffer.str()); throw parser_exception(buffer.str());
} }
m_ctx.insert_rec_fun(f, bindings, ids, body); m_ctx.insert_rec_fun(f, bindings, ids, body);
@ -2448,7 +2448,7 @@ namespace smt2 {
next(); next();
parse_sort("Invalid constant definition"); parse_sort("Invalid constant definition");
parse_expr(); parse_expr();
if (m().get_sort(expr_stack().back()) != sort_stack().back()) if (expr_stack().back()->get_sort() != sort_stack().back())
throw parser_exception("invalid constant definition, sort mismatch"); throw parser_exception("invalid constant definition, sort mismatch");
m_ctx.insert(id, 0, nullptr, expr_stack().back()); m_ctx.insert(id, 0, nullptr, expr_stack().back());
check_rparen("invalid constant definition, ')' expected"); check_rparen("invalid constant definition, ')' expected");

4
src/qe/mbp/mbp_arrays.cpp
View file

@ -1257,7 +1257,7 @@ namespace mbp {
if (s == m_var->x()) { if (s == m_var->x()) {
expr_ref result(t, m); expr_ref result(t, m);
expr_ref_vector args(m); expr_ref_vector args(m);
sort* range = get_array_range(m.get_sort(s)); sort* range = get_array_range(s->get_sort());
for (unsigned i = 0; i < idxs.size(); ++i) { for (unsigned i = 0; i < idxs.size(); ++i) {
app_ref var(m), sel(m); app_ref var(m), sel(m);
expr_ref val(m); expr_ref val(m);
@ -1559,7 +1559,7 @@ namespace mbp {
lits.push_back(m.mk_eq(a1, a2)); lits.push_back(m.mk_eq(a1, a2));
} }
else { else {
sort* s = m.get_sort(store->get_arg(indices.size() + 1)); sort* s = store->get_arg(indices.size() + 1)->get_sort();
for (app* idx : *m_indices[s]) { for (app* idx : *m_indices[s]) {
indices.push_back(idx); indices.push_back(idx);
assert_store_select(indices, store, mdl, tg, lits); assert_store_select(indices, store, mdl, tg, lits);

2
src/qe/nlarith_util.cpp
View file

@ -67,7 +67,7 @@ namespace nlarith {
ast_manager& m = m_lits.get_manager(); ast_manager& m = m_lits.get_manager();
std::string name = m_x->get_decl()->get_name().str(); std::string name = m_x->get_decl()->get_name().str();
name += suffix; name += suffix;
sort* r = m.get_sort(m_x); sort* r = m_x->get_sort();
v= m.mk_const(symbol(name.c_str()), r); v= m.mk_const(symbol(name.c_str()), r);
} }
}; };

2
src/qe/qe.cpp
View file

@ -2075,7 +2075,7 @@ namespace qe {
for (unsigned i = 0; i < num_vars; ++i) { for (unsigned i = 0; i < num_vars; ++i) {
contains_app contains_x(m, vars[i]); contains_app contains_x(m, vars[i]);
if (contains_x(fml)) { if (contains_x(fml)) {
sorts.push_back(m.get_sort(vars[i])); sorts.push_back(vars[i]->get_sort());
names.push_back(vars[i]->get_decl()->get_name()); names.push_back(vars[i]->get_decl()->get_name());
free_vars.push_back(vars[i]); free_vars.push_back(vars[i]);
} }

2
src/qe/qe_arith_plugin.cpp
View file

@ -1037,7 +1037,7 @@ namespace qe {
app_ref x(m_ctx.get_var(index-1), m); app_ref x(m_ctx.get_var(index-1), m);
app_ref z(m); app_ref z(m);
expr_ref p1(m); expr_ref p1(m);
sort* s = m.get_sort(p); sort* s = p->get_sort();
if (is_aux) { if (is_aux) {
// An auxiliary variable was introduced in lieu of 'x'. // An auxiliary variable was introduced in lieu of 'x'.
// it has coefficient 'm' = values[index]. // it has coefficient 'm' = values[index].

6
src/qe/qe_array_plugin.cpp
View file

@ -92,7 +92,7 @@ namespace qe {
for (unsigned i = 0; i < sz; ++i) { for (unsigned i = 0; i < sz; ++i) {
expr_ref save(m); expr_ref save(m);
save = lhs = args[i].get(); save = lhs = args[i].get();
args[i] = arith.mk_numeral(rational(0), m.get_sort(lhs)); args[i] = arith.mk_numeral(rational(0), lhs->get_sort());
rhs = arith.mk_uminus(arith.mk_add(args.size(), args.c_ptr())); rhs = arith.mk_uminus(arith.mk_add(args.size(), args.c_ptr()));
if (arith.is_mul(lhs, e1, e2) && if (arith.is_mul(lhs, e1, e2) &&
arith.is_numeral(e1, r) && arith.is_numeral(e1, r) &&
@ -165,7 +165,7 @@ namespace qe {
expr_ref store_B_i_t(m); expr_ref store_B_i_t(m);
unsigned num_args = args[0].size(); unsigned num_args = args[0].size();
B = m.mk_fresh_const("B", m.get_sort(A)); B = m.mk_fresh_const("B", A->get_sort());
ptr_buffer<expr> args2; ptr_buffer<expr> args2;
args2.push_back(B); args2.push_back(B);
for (unsigned i = 0; i < num_args; ++i) { for (unsigned i = 0; i < num_args; ++i) {
@ -232,7 +232,7 @@ namespace qe {
for (unsigned i = args.size(); i > 0; ) { for (unsigned i = args.size(); i > 0; ) {
--i; --i;
args2.reset(); args2.reset();
w = m.mk_fresh_const("w", m.get_sort(args[i].back())); w = m.mk_fresh_const("w", args[i].back()->get_sort());
args2.push_back(store_T); args2.push_back(store_T);
args2.append(args[i]); args2.append(args[i]);

6
src/qe/qe_dl_plugin.cpp
View file

@ -116,12 +116,12 @@ namespace qe {
private: private:
bool is_small_domain(contains_app& x, eq_atoms& eqs, uint64_t& domain_size) { bool is_small_domain(contains_app& x, eq_atoms& eqs, uint64_t& domain_size) {
VERIFY(m_util.try_get_size(m.get_sort(x.x()), domain_size)); VERIFY(m_util.try_get_size(x.x()->get_sort(), domain_size));
return domain_size < eqs.num_eqs() + eqs.num_neqs(); return domain_size < eqs.num_eqs() + eqs.num_neqs();
} }
void assign_small_domain(contains_app & x,eq_atoms& eqs, unsigned value) { void assign_small_domain(contains_app & x,eq_atoms& eqs, unsigned value) {
expr_ref vl(m_util.mk_numeral(value, m.get_sort(x.x())), m); expr_ref vl(m_util.mk_numeral(value, x.x()->get_sort()), m);
expr_ref eq(m.mk_eq(x.x(), vl), m); expr_ref eq(m.mk_eq(x.x(), vl), m);
m_ctx.add_constraint(true, eq); m_ctx.add_constraint(true, eq);
} }
@ -145,7 +145,7 @@ namespace qe {
} }
void subst_small_domain(contains_app & x,eq_atoms& eqs, unsigned v,expr_ref & fml) { void subst_small_domain(contains_app & x,eq_atoms& eqs, unsigned v,expr_ref & fml) {
expr_ref vl(m_util.mk_numeral(v, m.get_sort(x.x())), m); expr_ref vl(m_util.mk_numeral(v, x.x()->get_sort()), m);
m_replace.apply_substitution(x.x(), vl, fml); m_replace.apply_substitution(x.x(), vl, fml);
} }

2
src/qe/qe_lite.cpp
View file

@ -2307,7 +2307,7 @@ public:
ptr_vector<sort> sorts; ptr_vector<sort> sorts;
svector<symbol> names; svector<symbol> names;
for (unsigned i = 0; i < vars.size(); ++i) { for (unsigned i = 0; i < vars.size(); ++i) {
sorts.push_back(m.get_sort(vars[i].get())); sorts.push_back(vars[i]->get_sort());
names.push_back(vars[i]->get_decl()->get_name()); names.push_back(vars[i]->get_decl()->get_name());
} }
q = m.mk_exists(vars.size(), sorts.c_ptr(), names.c_ptr(), tmp, 1, qe_lite); q = m.mk_exists(vars.size(), sorts.c_ptr(), names.c_ptr(), tmp, 1, qe_lite);

4
src/qe/qe_mbp.cpp
View file

@ -55,7 +55,7 @@ class mbproj::impl {
} }
mbp::project_plugin* get_plugin(app* var) { mbp::project_plugin* get_plugin(app* var) {
family_id fid = m.get_sort(var)->get_family_id(); family_id fid = var->get_sort()->get_family_id();
return m_plugins.get(fid, nullptr); return m_plugins.get(fid, nullptr);
} }
@ -168,7 +168,7 @@ class mbproj::impl {
expr* e1, * e2; expr* e1, * e2;
if (m_array.is_select(n)) { if (m_array.is_select(n)) {
for (expr* arg : *n) { for (expr* arg : *n) {
if (arg->get_sort() == m.get_sort(m_var) && arg != m_var) if (arg->get_sort() == m_var->get_sort() && arg != m_var)
m_res.push_back(arg); m_res.push_back(arg);
} }
} }

4
src/sat/smt/arith_solver.cpp
View file

@ -313,7 +313,7 @@ namespace arith {
expr* e2 = n2->get_expr(); expr* e2 = n2->get_expr();
if (m.is_ite(e1) || m.is_ite(e2)) if (m.is_ite(e1) || m.is_ite(e2))
return; return;
if (e1->get_sort() != m.get_sort(e2)) if (e1->get_sort() != e2->get_sort())
return; return;
reset_evidence(); reset_evidence();
for (auto const& ev : e) for (auto const& ev : e)
@ -612,7 +612,7 @@ namespace arith {
SASSERT("integer variables should have integer values: " && (!a.is_int(o) || r.is_int() || m.limit().is_canceled())); SASSERT("integer variables should have integer values: " && (!a.is_int(o) || r.is_int() || m.limit().is_canceled()));
if (a.is_int(o) && !r.is_int()) if (a.is_int(o) && !r.is_int())
r = floor(r); r = floor(r);
value = a.mk_numeral(r, m.get_sort(o)); value = a.mk_numeral(r, o->get_sort());
} }
else if (a.is_arith_expr(o)) { else if (a.is_arith_expr(o)) {
expr_ref_vector args(m); expr_ref_vector args(m);

6
src/sat/smt/array_axioms.cpp
View file

@ -425,7 +425,7 @@ namespace array {
bool solver::has_unitary_domain(app* array_term) { bool solver::has_unitary_domain(app* array_term) {
SASSERT(a.is_array(array_term)); SASSERT(a.is_array(array_term));
sort* s = m.get_sort(array_term); sort* s = array_term->get_sort();
unsigned dim = get_array_arity(s); unsigned dim = get_array_arity(s);
for (unsigned i = 0; i < dim; ++i) { for (unsigned i = 0; i < dim; ++i) {
sort* d = get_array_domain(s, i); sort* d = get_array_domain(s, i);
@ -437,7 +437,7 @@ namespace array {
bool solver::has_large_domain(expr* array_term) { bool solver::has_large_domain(expr* array_term) {
SASSERT(a.is_array(array_term)); SASSERT(a.is_array(array_term));
sort* s = m.get_sort(array_term); sort* s = array_term->get_sort();
unsigned dim = get_array_arity(s); unsigned dim = get_array_arity(s);
rational sz(1); rational sz(1);
for (unsigned i = 0; i < dim; ++i) { for (unsigned i = 0; i < dim; ++i) {
@ -504,7 +504,7 @@ namespace array {
for (unsigned j = i; j-- > 0; ) { for (unsigned j = i; j-- > 0; ) {
theory_var v2 = roots[j]; theory_var v2 = roots[j];
expr* e2 = var2expr(v2); expr* e2 = var2expr(v2);
if (e1->get_sort() != m.get_sort(e2)) if (e1->get_sort() != e2->get_sort())
continue; continue;
if (have_different_model_values(v1, v2)) if (have_different_model_values(v1, v2))
continue; continue;

2
src/sat/smt/dt_solver.cpp
View file

@ -511,7 +511,7 @@ namespace dt {
}; };
for (enode* arg : euf::enode_args(parentc)) { for (enode* arg : euf::enode_args(parentc)) {
add(arg); add(arg);
sort* s = m.get_sort(arg->get_expr()); sort* s = arg->get_expr()->get_sort();
if (m_autil.is_array(s) && dt.is_datatype(get_array_range(s))) if (m_autil.is_array(s) && dt.is_datatype(get_array_range(s)))
for (enode* aarg : get_array_args(arg)) for (enode* aarg : get_array_args(arg))
add(aarg); add(aarg);

2
src/sat/smt/q_mbi.cpp
View file

@ -553,7 +553,7 @@ namespace q {
} }
mbp::project_plugin* mbqi::get_plugin(app* var) { mbp::project_plugin* mbqi::get_plugin(app* var) {
family_id fid = m.get_sort(var)->get_family_id(); family_id fid = var->get_sort()->get_family_id();
return m_plugins.get(fid, nullptr); return m_plugins.get(fid, nullptr);
} }

2
src/sat/smt/q_solver.cpp
View file

@ -181,7 +181,7 @@ namespace q {
if (!m_unit_table.empty()) if (!m_unit_table.empty())
return; return;
for (euf::enode* n : ctx.get_egraph().nodes()) { for (euf::enode* n : ctx.get_egraph().nodes()) {
if (!n->interpreted() && !m.is_uninterp(m.get_sort(n->get_expr()))) if (!n->interpreted() && !m.is_uninterp(n->get_expr()->get_sort()))
continue; continue;
expr* e = n->get_expr(); expr* e = n->get_expr();
sort* s = e->get_sort(); sort* s = e->get_sort();

2
src/smt/arith_eq_adapter.cpp
View file

@ -170,7 +170,7 @@ namespace smt {
ge = m_util.mk_ge(t1, t2); ge = m_util.mk_ge(t1, t2);
} }
else { 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 minus_one(m_util.mk_numeral(rational::minus_one(), st), m);
app_ref zero(m_util.mk_numeral(rational::zero(), st), m); app_ref zero(m_util.mk_numeral(rational::zero(), st), m);
app_ref t3(m_util.mk_mul(minus_one, t2), 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)); add_axiom(lit, s_gt_t, ~mk_eq(y, s));
#else #else
sort* char_sort = nullptr; 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 x = m_sk.mk("seq.suffix.x", s, t);
expr_ref y = m_sk.mk("seq.suffix.y", s, t); expr_ref y = m_sk.mk("seq.suffix.y", s, t);
expr_ref z = m_sk.mk("seq.suffix.z", 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 #else
sort* char_sort = nullptr; 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 x = m_sk.mk("seq.prefix.x", s, t);
expr_ref y = m_sk.mk("seq.prefix.y", s, t); expr_ref y = m_sk.mk("seq.prefix.y", s, t);
expr_ref z = m_sk.mk("seq.prefix.z", 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_ref seq_skolem::mk_unit_inv(expr* n) {
expr* u = nullptr; expr* u = nullptr;
VERIFY(seq.str.is_unit(n, u)); 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); 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); return expr_ref(seq.str.mk_char(str, str.length()-1), m);
} }
sort* char_sort = nullptr; 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); 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_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_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_last(expr* s);
expr_ref mk_first(expr* s); expr_ref mk_first(expr* s);
expr_ref mk_pre(expr* s, expr* i) { return mk(m_pre, s, i); } 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 { else {
if (!pushed) pushed = true, push(); 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); expr_ref eq(m.mk_eq(c, a), m);
assert_expr(eq); assert_expr(eq);
assumptions.push_back(c); 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) { 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(); family_id fid = s->get_family_id();
theory * th = get_theory(fid); theory * th = get_theory(fid);
if (th == nullptr) 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) { void partition_terms(unsigned num_terms, expr* const* terms, sort2term_ids& termids) {
for (unsigned i = 0; i < num_terms; ++i) { 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()); term_ids& vec = termids.insert_if_not_there(s, term_ids());
vec.push_back(term_id(expr_ref(terms[i],m), i)); vec.push_back(term_id(expr_ref(terms[i],m), i));
} }
@ -148,7 +148,7 @@ namespace {
SASSERT(!terms.empty()); 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)) { if (m_array_util.is_array(srt)) {
@ -249,7 +249,7 @@ namespace {
void assert_relevant(unsigned num_terms, expr* const* terms) { void assert_relevant(unsigned num_terms, expr* const* terms) {
for (unsigned i = 0; i < num_terms; ++i) { 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)) { 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])); 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) { void assert_relevant(term_ids& terms) {
for (unsigned i = 0; i < terms.size(); ++i) { for (unsigned i = 0; i < terms.size(); ++i) {
expr* t = terms[i].term; expr* t = terms[i].term;
sort* srt = m.get_sort(t); sort* srt = t->get_sort();
if (!m_array_util.is_array(srt)) { 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)); 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) { bool induction_lemmas::viable_induction_term(enode* p, enode* n) {
return 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_parent(p, n) &&
viable_induction_children(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) { 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)) { for (func_decl* c : *m_dt.get_datatype_constructors(ys)) {
func_decl* is_c = m_dt.get_constructor_recognizer(c); func_decl* is_c = m_dt.get_constructor_recognizer(c);
conds.push_back(m.mk_app(is_c, y)); 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)) { for (enode* n : induction_positions(r)) {
expr* t = n->get_owner(); expr* t = n->get_owner();
if (is_uninterp_const(t)) { // for now, to avoid overlapping terms 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); expr_ref sk(m.mk_fresh_const("sk", s), m);
sks.push_back(sk); sks.push_back(sk);
rep.insert(t, sk); rep.insert(t, sk);
@ -460,7 +460,7 @@ void induction_lemmas::apply_induction(literal lit, induction_positions_t const
if (term2skolem.contains(t)) if (term2skolem.contains(t))
continue; continue;
if (i == sks.size()) { 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); sks.push_back(sk);
} }
else { else {

6
src/smt/smt_internalizer.cpp
View file

@ -315,7 +315,7 @@ namespace smt {
assert_default(n, pr); assert_default(n, pr);
return; 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); 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); func_decl_ref f(m.mk_fresh_func_decl("distinct-aux-f", "", 1, &s, u), m);
for (expr * arg : *n) { for (expr * arg : *n) {
@ -448,7 +448,7 @@ namespace smt {
d.set_eq_flag(); d.set_eq_flag();
TRACE("internalize", tout << mk_pp(n, m) << " " << literal(v, false) << "\n";); 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()); theory * th = m_theories.get_plugin(s->get_family_id());
if (th) if (th)
th->internalize_eq_eh(n, v); th->internalize_eq_eh(n, v);
@ -582,7 +582,7 @@ namespace smt {
if (e_internalized(q)) { if (e_internalized(q)) {
return; 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); app_ref eq(m), lam_app(m);
expr_ref_vector vars(m); expr_ref_vector vars(m);
vars.push_back(lam_name); 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. Remark: this method uses get_fresh_value, so it may fail.
*/ */
expr* get_k_interp(app* k) { expr* get_k_interp(app* k) {
sort* s = m.get_sort(k); sort* s = k->get_sort();
SASSERT(is_infinite(s)); SASSERT(is_infinite(s));
func_decl* k_decl = k->get_decl(); func_decl* k_decl = k->get_decl();
expr* r = m_model->get_const_interp(k_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 (is_var_and_ground(to_app(atom)->get_arg(0), to_app(atom)->get_arg(1), v, tmp, inv)) {
if (inv) if (inv)
le = !le; le = !le;
sort* s = m.get_sort(tmp); sort* s = tmp->get_sort();
expr_ref one(m); expr_ref one(m);
one = mk_one(s); one = mk_one(s);
if (le) if (le)

2
src/smt/smt_model_generator.cpp
View file

@ -307,7 +307,7 @@ namespace smt {
enode * n = curr.get_enode(); enode * n = curr.get_enode();
SASSERT(n->get_root() == n); SASSERT(n->get_root() == n);
tout << mk_pp(n->get_owner(), m) << "\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 << curr << " " << mk_pp(s, m);
tout << " is_fresh: " << root2proc[n]->is_fresh() << "\n"; 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(); m_candidate_vectors[i].reset();
sort * s = q->get_decl_sort(i); sort * s = q->get_decl_sort(i);
for (unsigned j = 0; j < num_candidates; j++) { 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]; expr * n = candidates[j];
m_context.internalize(n, false); m_context.internalize(n, false);
enode * e = m_context.get_enode(n); 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";); ", is_store: " << is_store(n) << "\n";);
d->m_is_array = is_array_sort(n); d->m_is_array = is_array_sort(n);
if (d->m_is_array) 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); d->m_is_select = is_select(n);
if (is_store(n)) if (is_store(n))
d->m_stores.push_back(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) { 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); unsigned num_params = get_dimension(s);
parameter const* params = s->get_info()->get_parameters(); parameter const* params = s->get_info()->get_parameters();
return m.mk_app(get_family_id(), OP_ARRAY_DEFAULT, num_params, params, 1, & a); 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";); TRACE("array_bug", tout << "mk_interface_eqs: processing: v" << *it1 << "\n";);
theory_var v1 = *it1; theory_var v1 = *it1;
enode * n1 = get_enode(v1); 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; sbuffer<theory_var>::iterator it2 = it1;
++it2; ++it2;
for (; it2 != end1; ++it2) { for (; it2 != end1; ++it2) {
theory_var v2 = *it2; theory_var v2 = *it2;
enode * n2 = get_enode(v2); 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)) { if (s1 == s2 && !ctx.is_diseq(n1, n2)) {
app * eq = mk_eq_atom(n1->get_owner(), n2->get_owner()); app * eq = mk_eq_atom(n1->get_owner(), n2->get_owner());
if (!ctx.b_internalized(eq) || !ctx.is_relevant(eq)) { if (!ctx.b_internalized(eq) || !ctx.is_relevant(eq)) {
@ -983,7 +983,7 @@ namespace smt {
SASSERT(ctx.is_relevant(n)); SASSERT(ctx.is_relevant(n));
theory_var v = n->get_th_var(get_id()); theory_var v = n->get_th_var(get_id());
SASSERT(v != null_theory_var); 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); enode * else_val_n = get_default(v);
array_value_proc * result = nullptr; 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_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_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(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_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); } 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) { bool theory_array_full::has_unitary_domain(app* array_term) {
SASSERT(is_array_sort(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); unsigned dim = get_dimension(s);
parameter const * params = s->get_info()->get_parameters(); parameter const * params = s->get_info()->get_parameters();
for (unsigned i = 0; i < dim; ++i) { for (unsigned i = 0; i < dim; ++i) {
@ -593,7 +593,7 @@ namespace smt {
bool theory_array_full::has_large_domain(app* array_term) { bool theory_array_full::has_large_domain(app* array_term) {
SASSERT(is_array_sort(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); unsigned dim = get_dimension(s);
parameter const * params = s->get_info()->get_parameters(); parameter const * params = s->get_info()->get_parameters();
rational sz(1); rational sz(1);

2
src/smt/theory_bv.cpp
View file

@ -478,7 +478,7 @@ namespace smt {
VERIFY(get_fixed_value(v, val)); VERIFY(get_fixed_value(v, val));
enode* n = get_enode(v); enode* n = get_enode(v);
if (ctx.watches_fixed(n)) { 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; literal_vector& lits = m_tmp_literals;
lits.reset(); lits.reset();
for (literal b : m_bits[v]) { 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(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(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)); } 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(enode const* n) const { return is_bv(n->get_owner()); }
bool is_bv(theory_var v) const { return is_bv(get_enode(v)); } bool is_bv(theory_var v) const { return is_bv(get_enode(v)); }
region & get_region() { return m_trail_stack.get_region(); } 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); assert_update_field_axioms(n);
} }
else { 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) { if (m_util.get_datatype_num_constructors(s) == 1) {
func_decl * c = m_util.get_datatype_constructors(s)->get(0); func_decl * c = m_util.get_datatype_constructors(s)->get(0);
assert_is_constructor_axiom(n, c, null_literal); assert_is_constructor_axiom(n, c, null_literal);
@ -333,7 +333,7 @@ namespace smt {
// //
for (unsigned i = 0; i < num_args; i++) { for (unsigned i = 0; i < num_args; i++) {
enode * arg = e->get_arg(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))) { 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); app_ref def(m_autil.mk_default(arg->get_owner()), m);
if (!ctx.e_internalized(def)) { if (!ctx.e_internalized(def)) {
@ -528,7 +528,7 @@ namespace smt {
} }
found = true; 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))) { if (m_autil.is_array(s) && m_util.is_datatype(get_array_range(s))) {
for (enode* aarg : get_array_args(arg)) { for (enode* aarg : get_array_args(arg)) {
if (aarg->get_root() == child->get_root()) { if (aarg->get_root() == child->get_root()) {
@ -864,7 +864,7 @@ namespace smt {
unsigned num_unassigned = 0; unsigned num_unassigned = 0;
unsigned unassigned_idx = UINT_MAX; unsigned unassigned_idx = UINT_MAX;
enode * n = get_enode(v); 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]; var_data * d = m_var_data[v];
if (d->m_recognizers.empty()) { if (d->m_recognizers.empty()) {
theory_var w = recognizer->get_arg(0)->get_th_var(get_id()); 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) { void theory_datatype::mk_split(theory_var v) {
v = m_find.find(v); v = m_find.find(v);
enode * n = get_enode(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); func_decl * non_rec_c = m_util.get_non_rec_constructor(s);
unsigned non_rec_idx = m_util.get_constructor_idx(non_rec_c); unsigned non_rec_idx = m_util.get_constructor_idx(non_rec_c);
var_data * d = m_var_data[v]; 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); enode * n = get_enode(v);
if (m_autil.is_zero(n->get_owner()) && !m_assignment[v].is_zero()) { if (m_autil.is_zero(n->get_owner()) && !m_assignment[v].is_zero()) {
numeral val = m_assignment[v]; 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. // adjust the value of all variables that have the same sort.
for (int v2 = 0; v2 < num_vars; ++v2) { for (int v2 = 0; v2 < num_vars; ++v2) {
enode * n2 = get_enode(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) { 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) << 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); app_ref owner(m);
owner = get_ite_value(n->get_owner()); 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) { theory_var theory_str::mk_var(enode* n) {
TRACE("str", tout << "mk_var for " << mk_pp(n->get_owner(), get_manager()) << std::endl;); TRACE("str", tout << "mk_var for " << mk_pp(n->get_owner(), get_manager()) << std::endl;);
ast_manager & m = get_manager(); 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; return null_theory_var;
} }
if (is_attached_to_var(n)) { 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(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(); void init_zero();

6
src/tactic/arith/eq2bv_tactic.cpp
View file

@ -35,7 +35,7 @@ class eq2bv_tactic : public tactic {
expr* z; expr* z;
rational r; rational r;
if (t.m_fd.find(x, z) && t.a.is_numeral(y, r)) { if (t.m_fd.find(x, z) && t.a.is_numeral(y, r)) {
result = m.mk_eq(z, t.bv.mk_numeral(r, m.get_sort(z))); result = m.mk_eq(z, t.bv.mk_numeral(r, z->get_sort()));
return true; return true;
} }
else { else {
@ -249,13 +249,13 @@ public:
if (m_bounds.has_lower(c, r, strict) && !r.is_neg()) { if (m_bounds.has_lower(c, r, strict) && !r.is_neg()) {
SASSERT(!strict); SASSERT(!strict);
expr* d = m_fd.find(c); expr* d = m_fd.find(c);
fml = bv.mk_ule(bv.mk_numeral(r, m.get_sort(d)), d); fml = bv.mk_ule(bv.mk_numeral(r, d->get_sort()), d);
g->assert_expr(fml, m_bounds.lower_dep(c)); g->assert_expr(fml, m_bounds.lower_dep(c));
} }
if (m_bounds.has_upper(c, r, strict) && !r.is_neg()) { if (m_bounds.has_upper(c, r, strict) && !r.is_neg()) {
SASSERT(!strict); SASSERT(!strict);
expr* d = m_fd.find(c); expr* d = m_fd.find(c);
fml = bv.mk_ule(d, bv.mk_numeral(r, m.get_sort(d))); fml = bv.mk_ule(d, bv.mk_numeral(r, d->get_sort()));
g->assert_expr(fml, m_bounds.upper_dep(c)); g->assert_expr(fml, m_bounds.upper_dep(c));
} }
} }

11
src/tactic/bv/bv_bounds_tactic.cpp
View file

@ -331,11 +331,12 @@ namespace {
} else if (m_bound.find(t1, ctx)) { } else if (m_bound.find(t1, ctx)) {
if (ctx.implies(b)) { if (ctx.implies(b)) {
result = m.mk_true(); result = m.mk_true();
} else if (!b.intersect(ctx, intr)) { }
else if (!b.intersect(ctx, intr)) {
result = m.mk_false(); result = m.mk_false();
} else if (m_propagate_eq && intr.is_singleton()) { }
result = m.mk_eq(t1, m_bv.mk_numeral(rational(intr.l, rational::ui64()), else if (m_propagate_eq && intr.is_singleton()) {
m.get_sort(t1))); result = m.mk_eq(t1, m_bv.mk_numeral(rational(intr.l, rational::ui64()), t1->get_sort()));
} }
} }
@ -630,7 +631,7 @@ namespace {
} }
else if (m_propagate_eq && intr.is_singleton()) { else if (m_propagate_eq && intr.is_singleton()) {
r = m.mk_eq(t1, m_bv.mk_numeral(rational(intr.l, rational::ui64()), r = m.mk_eq(t1, m_bv.mk_numeral(rational(intr.l, rational::ui64()),
m.get_sort(t1))); t1->get_sort()));
} }
else { else {
was_updated = false; was_updated = false;

4
src/tactic/bv/bvarray2uf_rewriter.cpp
View file

@ -144,7 +144,7 @@ br_status bvarray2uf_rewriter_cfg::reduce_app(func_decl * f, unsigned num, expr
func_decl_ref f_t(mk_uf_for_array(args[0]), m_manager); func_decl_ref f_t(mk_uf_for_array(args[0]), m_manager);
func_decl_ref f_s(mk_uf_for_array(args[1]), m_manager); func_decl_ref f_s(mk_uf_for_array(args[1]), m_manager);
sort * sorts[1] = { get_index_sort(m_manager.get_sort(args[0])) }; sort * sorts[1] = { get_index_sort(args[0]->get_sort()) };
symbol names[1] = { symbol("x") }; symbol names[1] = { symbol("x") };
var_ref x(m_manager.mk_var(0, sorts[0]), m_manager); var_ref x(m_manager.mk_var(0, sorts[0]), m_manager);
@ -167,7 +167,7 @@ br_status bvarray2uf_rewriter_cfg::reduce_app(func_decl * f, unsigned num, expr
TRACE("bvarray2uf_rw", tout << "(ite " << c << ", " << f_t->get_name() TRACE("bvarray2uf_rw", tout << "(ite " << c << ", " << f_t->get_name()
<< ", " << f_f->get_name() << ")" << std::endl;); << ", " << f_f->get_name() << ")" << std::endl;);
sort * sorts[1] = { get_index_sort(m_manager.get_sort(args[1])) }; sort * sorts[1] = { get_index_sort(args[1]->get_sort()) };
symbol names[1] = { symbol("x") }; symbol names[1] = { symbol("x") };
var_ref x(m_manager.mk_var(0, sorts[0]), m_manager); var_ref x(m_manager.mk_var(0, sorts[0]), m_manager);

2
src/tactic/core/symmetry_reduce_tactic.cpp
View file

@ -258,7 +258,7 @@ private:
m_manager(m), m_app2sortid(app2sort), m_max_id(0) {} m_manager(m), m_app2sortid(app2sort), m_max_id(0) {}
void operator()(app* n) { void operator()(app* n) {
sort* s = m_manager.get_sort(n); sort* s = n->get_sort();
unsigned id; unsigned id;
if (!m_sort2id.find(s, id)) { if (!m_sort2id.find(s, id)) {
id = m_max_id++; id = m_max_id++;

54
src/tactic/fd_solver/smtfd_solver.cpp
View file

@ -178,7 +178,7 @@ namespace smtfd {
return m.mk_fresh_const(name, m.mk_bool_sort()); return m.mk_fresh_const(name, m.mk_bool_sort());
} }
else if (m_butil.is_bv(t)) { else if (m_butil.is_bv(t)) {
return m.mk_fresh_const(name, m.get_sort(t)); return m.mk_fresh_const(name, t->get_sort());
} }
else { else {
++m_nv; ++m_nv;
@ -690,7 +690,7 @@ namespace smtfd {
for (unsigned i = 0; i < a.m_t->get_num_args(); ++i) { for (unsigned i = 0; i < a.m_t->get_num_args(); ++i) {
if (p.values().get(a.m_val_offset+i) != p.values().get(b.m_val_offset+i)) if (p.values().get(a.m_val_offset+i) != p.values().get(b.m_val_offset+i))
return false; return false;
if (p.get_manager().get_sort(a.m_t->get_arg(i)) != p.get_manager().get_sort(b.m_t->get_arg(i))) if (a.m_t->get_arg(i)->get_sort() != b.m_t->get_arg(i)->get_sort())
return false; return false;
} }
return true; return true;
@ -793,7 +793,7 @@ namespace smtfd {
{} {}
void check_term(expr* t, unsigned round) override { void check_term(expr* t, unsigned round) override {
sort* s = m.get_sort(t); sort* s = t->get_sort();
if (round == 0 && is_uf(t)) { if (round == 0 && is_uf(t)) {
TRACE("smtfd_verbose", tout << "check-term: " << mk_bounded_pp(t, m, 2) << "\n";); TRACE("smtfd_verbose", tout << "check-term: " << mk_bounded_pp(t, m, 2) << "\n";);
enforce_congruence(to_app(t)->get_decl(), to_app(t), s); enforce_congruence(to_app(t)->get_decl(), to_app(t), s);
@ -816,7 +816,7 @@ namespace smtfd {
} }
bool term_covered(expr* t) override { bool term_covered(expr* t) override {
sort* s = m.get_sort(t); sort* s = t->get_sort();
if (sort_covered(s)) { if (sort_covered(s)) {
val2elem_t& v2e = get_table(s); val2elem_t& v2e = get_table(s);
expr_ref v = eval_abs(t); expr_ref v = eval_abs(t);
@ -864,7 +864,7 @@ namespace smtfd {
mdl->register_decl(fn, fi); mdl->register_decl(fn, fi);
} }
for (expr* t : subterms(terms)) { for (expr* t : subterms(terms)) {
if (is_uninterp_const(t) && sort_covered(m.get_sort(t))) { if (is_uninterp_const(t) && sort_covered(t->get_sort())) {
expr_ref val = model_value(t); expr_ref val = model_value(t);
mdl->register_decl(to_app(t)->get_decl(), val); mdl->register_decl(to_app(t)->get_decl(), val);
} }
@ -872,7 +872,7 @@ namespace smtfd {
} }
expr_ref model_value_core(expr* t) override { expr_ref model_value_core(expr* t) override {
sort* s = m.get_sort(t); sort* s = t->get_sort();
if (sort_covered(s)) { if (sort_covered(s)) {
auto& v2e = ensure_table(s); auto& v2e = ensure_table(s);
return expr_ref(v2e[eval_abs(t)], m); return expr_ref(v2e[eval_abs(t)], m);
@ -922,14 +922,14 @@ namespace smtfd {
void insert_select(app* t) { void insert_select(app* t) {
expr* a = t->get_arg(0); expr* a = t->get_arg(0);
expr_ref vA = eval_abs(a); expr_ref vA = eval_abs(a);
check_congruence(vA, t, m.get_sort(a)); check_congruence(vA, t, a->get_sort());
} }
void check_select(app* t) { void check_select(app* t) {
expr* a = t->get_arg(0); expr* a = t->get_arg(0);
expr_ref vA = eval_abs(a); expr_ref vA = eval_abs(a);
TRACE("smtfd", tout << mk_bounded_pp(t, m, 2) << "\n";); TRACE("smtfd", tout << mk_bounded_pp(t, m, 2) << "\n";);
enforce_congruence(vA, t, m.get_sort(a)); enforce_congruence(vA, t, a->get_sort());
} }
// check that (select(t, t.args) = t.value) // check that (select(t, t.args) = t.value)
@ -1018,7 +1018,7 @@ namespace smtfd {
expr_ref vT = eval_abs(t); expr_ref vT = eval_abs(t);
expr_ref vA = eval_abs(arg); expr_ref vA = eval_abs(arg);
table& tT = ast2table(vT, m.get_sort(t)); // select table of t table& tT = ast2table(vT, t->get_sort()); // select table of t
table& tA = ast2table(vA, arg->get_sort()); // select table of arg table& tA = ast2table(vA, arg->get_sort()); // select table of arg
if (vT == vA) { if (vT == vA) {
@ -1049,7 +1049,7 @@ namespace smtfd {
if (m_context.at_max()) { if (m_context.at_max()) {
break; break;
} }
if (m.get_sort(t) != m.get_sort(fA.m_t->get_arg(0))) { if (t->get_sort() != fA.m_t->get_arg(0)->get_sort()) {
continue; continue;
} }
if (!tT.find(fA, fT) || (value_of(fA) != value_of(fT) && !eq(m_vargs, fA))) { if (!tT.find(fA, fT) || (value_of(fA) != value_of(fT) && !eq(m_vargs, fA))) {
@ -1064,7 +1064,7 @@ namespace smtfd {
if (m_context.at_max()) { if (m_context.at_max()) {
break; break;
} }
if (!tA.find(fT, fA) && m.get_sort(t) == m.get_sort(fT.m_t->get_arg(0))) { if (!tA.find(fT, fA) && t->get_sort() == m.get_sort(fT.m_t->get_arg(0))) {
TRACE("smtfd", tout << "not found\n";); TRACE("smtfd", tout << "not found\n";);
add_select_store_axiom(t, fT); add_select_store_axiom(t, fT);
++r; ++r;
@ -1080,7 +1080,7 @@ namespace smtfd {
for (expr* arg : *f.m_t) { for (expr* arg : *f.m_t) {
m_args.push_back(arg); m_args.push_back(arg);
} }
SASSERT(m.get_sort(t) == m.get_sort(a)); SASSERT(t->get_sort() == a->get_sort());
TRACE("smtfd", tout << mk_bounded_pp(t, m, 2) << " " << mk_bounded_pp(f.m_t, m, 2) << "\n";); TRACE("smtfd", tout << mk_bounded_pp(t, m, 2) << " " << mk_bounded_pp(f.m_t, m, 2) << "\n";);
expr_ref eq = mk_eq_idxs(t, f.m_t); expr_ref eq = mk_eq_idxs(t, f.m_t);
m_args[0] = t; m_args[0] = t;
@ -1094,7 +1094,7 @@ namespace smtfd {
} }
bool same_array_sort(f_app const& fA, f_app const& fT) const { bool same_array_sort(f_app const& fA, f_app const& fT) const {
return m.get_sort(fA.m_t->get_arg(0)) == m.get_sort(fT.m_t->get_arg(0)); return fA.m_t->get_arg(0)->get_sort() == fT.m_t->get_arg(0)->get_sort();
} }
/** /**
@ -1105,9 +1105,9 @@ namespace smtfd {
m_autil.is_const(t) || m_autil.is_const(t) ||
is_lambda(t)) { is_lambda(t)) {
expr_ref vT = eval_abs(t); expr_ref vT = eval_abs(t);
table& tT = ast2table(vT, m.get_sort(t)); table& tT = ast2table(vT, t->get_sort());
for (f_app & f : tT) { for (f_app & f : tT) {
if (m.get_sort(t) != m.get_sort(f.m_t->get_arg(0))) if (t->get_sort() != f.m_t->get_arg(0)->get_sort())
continue; continue;
if (m_context.at_max()) if (m_context.at_max())
break; break;
@ -1165,7 +1165,7 @@ namespace smtfd {
} }
void enforce_extensionality(expr* a, expr* b) { void enforce_extensionality(expr* a, expr* b) {
sort* s = m.get_sort(a); sort* s = a->get_sort();
unsigned arity = get_array_arity(s); unsigned arity = get_array_arity(s);
expr_ref_vector args(m); expr_ref_vector args(m);
args.push_back(a); args.push_back(a);
@ -1190,7 +1190,7 @@ namespace smtfd {
SASSERT(m_autil.is_select(f.m_t)); SASSERT(m_autil.is_select(f.m_t));
expr_ref v = model_value(f.m_t); expr_ref v = model_value(f.m_t);
if (!value) { if (!value) {
sort* s = m.get_sort(f.m_t->get_arg(0)); sort* s = f.m_t->get_arg(0)->get_sort();
default_value = v; default_value = v;
value = m_autil.mk_const_array(s, default_value); value = m_autil.mk_const_array(s, default_value);
} }
@ -1256,7 +1256,7 @@ namespace smtfd {
if (m_autil.is_select(t)) { if (m_autil.is_select(t)) {
expr* a = to_app(t)->get_arg(0); expr* a = to_app(t)->get_arg(0);
expr_ref vA = eval_abs(a); expr_ref vA = eval_abs(a);
insert(mk_app(vA, to_app(t), m.get_sort(a))); insert(mk_app(vA, to_app(t), a->get_sort()));
} }
return return
@ -1285,9 +1285,9 @@ namespace smtfd {
expr_ref model_value_core(expr* t) override { expr_ref model_value_core(expr* t) override {
if (m_autil.is_array(t)) { if (m_autil.is_array(t)) {
expr_ref vT = eval_abs(t); expr_ref vT = eval_abs(t);
table& tb = ast2table(vT, m.get_sort(t)); table& tb = ast2table(vT, t->get_sort());
if (tb.empty()) { if (tb.empty()) {
return model_value_core(m.get_sort(t)); return model_value_core(t->get_sort());
} }
else { else {
return mk_array_value(tb); return mk_array_value(tb);
@ -1345,7 +1345,7 @@ namespace smtfd {
for (unsigned j = i + 1; !m_context.at_max() && j < shared.size(); ++j) { for (unsigned j = i + 1; !m_context.at_max() && j < shared.size(); ++j) {
expr* s2 = shared.get(j); expr* s2 = shared.get(j);
expr* v2 = sharedvals.get(j); expr* v2 = sharedvals.get(j);
if (v1 != v2 && m.get_sort(s1) == m.get_sort(s2) && same_table(v1, m.get_sort(s1), v2, m.get_sort(s2))) { if (v1 != v2 && s1->get_sort() == s2->get_sort() && same_table(v1, s1->get_sort(), v2, s2->get_sort())) {
enforce_extensionality(s1, s2); enforce_extensionality(s1, s2);
} }
} }
@ -1533,8 +1533,8 @@ namespace smtfd {
void init_term(expr* t) { void init_term(expr* t) {
if (!m.is_bool(t) && is_ground(t)) { if (!m.is_bool(t) && is_ground(t)) {
expr_ref v = eval_abs(t); expr_ref v = eval_abs(t);
if (!m_val2term.contains(v, m.get_sort(t))) { if (!m_val2term.contains(v, t->get_sort())) {
m_val2term.insert(v, m.get_sort(t), t); m_val2term.insert(v, t->get_sort(), t);
m_val2term_trail.push_back(v); m_val2term_trail.push_back(v);
} }
} }
@ -1725,7 +1725,7 @@ namespace smtfd {
} }
} }
for (expr* t : subterms(terms)) { for (expr* t : subterms(terms)) {
if (!is_forall(t) && !is_exists(t) && (!m_context.term_covered(t) || !m_context.sort_covered(m.get_sort(t)))) { if (!is_forall(t) && !is_exists(t) && (!m_context.term_covered(t) || !m_context.sort_covered(t->get_sort()))) {
is_decided = l_false; is_decided = l_false;
} }
} }
@ -1739,9 +1739,9 @@ namespace smtfd {
if (is_ground(a) && val0 != val1 && m.get_sort(val0) == m.get_sort(val1)) { if (is_ground(a) && val0 != val1 && m.get_sort(val0) == m.get_sort(val1)) {
tout << mk_bounded_pp(a, m, 2) << " := " << val0 << " " << val1 << "\n"; tout << mk_bounded_pp(a, m, 2) << " := " << val0 << " " << val1 << "\n";
} }
if (!is_forall(a) && !is_exists(a) && (!m_context.term_covered(a) || !m_context.sort_covered(m.get_sort(a)))) { if (!is_forall(a) && !is_exists(a) && (!m_context.term_covered(a) || !m_context.sort_covered(a->get_sort()))) {
tout << "not covered: " << mk_pp(a, m) << " " << mk_pp(m.get_sort(a), m) << " "; tout << "not covered: " << mk_pp(a, m) << " " << mk_pp(a->get_sort(), m) << " ";
tout << m_context.term_covered(a) << " " << m_context.sort_covered(m.get_sort(a)) << "\n"; tout << m_context.term_covered(a) << " " << m_context.sort_covered(a->get_sort()) << "\n";
} }
} }
tout << "has quantifier: " << has_q << "\n" << core << "\n"; tout << "has quantifier: " << has_q << "\n" << core << "\n";