mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-11-03 21:09:11 +00:00
Code Activity

call it data instead of c_ptr for approaching C++11 std::vector convention.

Browse source
This commit is contained in:
Nikolaj Bjorner 2021-04-13 18:17:10 -07:00
parent 524dcd35f9
commit 4a6083836a
456 changed files with 2802 additions and 2802 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -151,7 +151,7 @@ void anti_unifier::operator()(expr *e1, expr *e2, expr_ref &res,
if (m_todo.size() > todo_sz) {continue;}
expr_ref u(m);
u = m.mk_app(n1->get_decl(), kids.size(), kids.c_ptr());
u = m.mk_app(n1->get_decl(), kids.size(), kids.data());
m_pinned.push_back(u);
m_cache.insert(n1, n2, u);
}

40
src/muz/spacer/spacer_context.cpp
View file

@ -224,7 +224,7 @@ void derivation::exist_skolemize(expr* fml, app_ref_vector& vars, expr_ref& res)
return;
}
std::stable_sort(vars.c_ptr(), vars.c_ptr() + vars.size(), sk_lt_proc());
std::stable_sort(vars.data(), vars.data() + vars.size(), sk_lt_proc());
unsigned j = 1;
for (unsigned i = 1; i < vars.size(); ++i)
if (vars.get(i) != vars.get(j - 1))
@ -396,7 +396,7 @@ pob *derivation::create_next_child ()
m_trans = mk_and (summaries);
// variables to eliminate
vars.append (rf->aux_vars ().size (), rf->aux_vars ().c_ptr ());
vars.append (rf->aux_vars ().size (), rf->aux_vars ().data ());
for (unsigned i = 0, sz = pt.head ()->get_arity (); i < sz; ++i) {
vars.push_back(m.mk_const(pm.o2n(pt.sig(i), 0)));
}
@ -537,7 +537,7 @@ void lemma::mk_expr_core() {
zks.append(m_zks);
zks.reverse();
m_body = expr_abstract(m, 0,
zks.size(), (expr* const*)zks.c_ptr(), m_body);
zks.size(), (expr* const*)zks.data(), m_body);
ptr_buffer<sort> sorts;
svector<symbol> names;
for (app* z : zks) {
@ -545,8 +545,8 @@ void lemma::mk_expr_core() {
names.push_back(z->get_decl()->get_name());
}
m_body = m.mk_quantifier(forall_k, zks.size(),
sorts.c_ptr(),
names.c_ptr(),
sorts.data(),
names.data(),
m_body, 15, symbol(m_body->get_id()));
}
SASSERT(m_body);
@ -568,7 +568,7 @@ void lemma::mk_cube_core() {
m_cube.push_back(m.mk_true());
}
else {
std::sort(m_cube.c_ptr(), m_cube.c_ptr() + m_cube.size(), ast_lt_proc());
std::sort(m_cube.data(), m_cube.data() + m_cube.size(), ast_lt_proc());
}
}
else {
@ -669,7 +669,7 @@ void lemma::mk_insts(expr_ref_vector &out, expr* e)
unsigned num_decls = to_quantifier(lem)->get_num_decls();
expr_ref inst(m);
for (unsigned off = 0, sz = m_bindings.size(); off < sz; off += num_decls) {
instantiate((expr * const *) m_bindings.c_ptr() + off, inst, e);
instantiate((expr * const *) m_bindings.data() + off, inst, e);
out.push_back(inst);
inst.reset();
}
@ -1100,7 +1100,7 @@ expr_ref pred_transformer::get_reachable()
const ptr_vector<app> &aux = f->aux_vars();
if (!aux.empty()) {
// -- existentially quantify auxiliary variables
r = mk_exists (m, aux.size(), aux.c_ptr(), r);
r = mk_exists (m, aux.size(), aux.data(), r);
// XXX not sure how this interacts with variable renaming later on.
// XXX For now, simply dissallow existentially quantified auxiliaries
NOT_IMPLEMENTED_YET();
@ -1503,7 +1503,7 @@ bool pred_transformer::is_invariant(unsigned level, lemma* lem,
if (ctx.use_bg_invs()) get_pred_bg_invs(conj);
lbool r = m_solver->check_assumptions (cand, aux, m_transition_clause,
conj.size(), conj.c_ptr(), 1);
conj.size(), conj.data(), 1);
if (r == l_false) {
solver_level = m_solver->uses_level ();
lem->reset_ctp();
@ -1538,7 +1538,7 @@ bool pred_transformer::check_inductive(unsigned level, expr_ref_vector& state,
conj.push_back (m_extend_lit);
lbool res = m_solver->check_assumptions (state, aux,
m_transition_clause,
conj.size (), conj.c_ptr (), 1);
conj.size (), conj.data (), 1);
if (res == l_false) {
state.reset();
state.append(core);
@ -1682,7 +1682,7 @@ void pred_transformer::init_rule(decl2rel const& pts, datalog::rule const& rule)
ground_free_vars(trans, var_reprs, aux_vars, ut_size == 0);
// SASSERT(is_all_non_null(var_reprs));
expr_ref tmp = var_subst(m, false)(trans, var_reprs.size (), (expr*const*)var_reprs.c_ptr());
expr_ref tmp = var_subst(m, false)(trans, var_reprs.size (), (expr*const*)var_reprs.data());
flatten_and (tmp, side);
trans = mk_and(side);
side.reset ();
@ -2068,7 +2068,7 @@ void pred_transformer::frames::sort ()
if (m_sorted) { return; }
m_sorted = true;
std::sort(m_lemmas.c_ptr(), m_lemmas.c_ptr() + m_lemmas.size (), m_lt);
std::sort(m_lemmas.data(), m_lemmas.data() + m_lemmas.size (), m_lt);
}
bool pred_transformer::frames::propagate_to_next_level (unsigned level)
@ -2565,7 +2565,7 @@ bool context::validate() {
for (unsigned j = utsz; j < tsz; ++j) {
fmls.push_back(r.get_tail(j));
}
tmp = m.mk_and(fmls.size(), fmls.c_ptr());
tmp = m.mk_and(fmls.size(), fmls.data());
svector<symbol> names;
expr_free_vars fv;
fv (tmp);
@ -2576,7 +2576,7 @@ bool context::validate() {
}
if (!fv.empty()) {
fv.reverse ();
tmp = m.mk_exists(fv.size(), fv.c_ptr(), names.c_ptr(), tmp);
tmp = m.mk_exists(fv.size(), fv.data(), names.data(), tmp);
}
ref<solver> sol =
mk_smt_solver(m, params_ref::get_empty(), symbol::null);
@ -3779,7 +3779,7 @@ reach_fact *pred_transformer::mk_rf(pob& n, model &mdl, const datalog::rule& r)
// collect aux vars to eliminate
ptr_vector<app>& aux_vars = get_aux_vars (r);
bool elim_aux = ctx.elim_aux();
if (elim_aux) { vars.append(aux_vars.size(), aux_vars.c_ptr()); }
if (elim_aux) { vars.append(aux_vars.size(), aux_vars.data()); }
res = mk_and (path_cons);
@ -3860,7 +3860,7 @@ bool context::create_children(pob& n, datalog::rule const& r,
}
// local variables of the rule
ptr_vector<app>& aux_vars = pt.get_aux_vars(r);
vars.append(aux_vars.size(), aux_vars.c_ptr());
vars.append(aux_vars.size(), aux_vars.data());
// skolems of the pob
n.get_skolems(vars);
@ -3892,7 +3892,7 @@ bool context::create_children(pob& n, datalog::rule const& r,
kid_order.reverse();
}
else if (m_children_order == CO_RANDOM) {
shuffle(kid_order.size(), kid_order.c_ptr(), m_random);
shuffle(kid_order.size(), kid_order.data(), m_random);
}
for (unsigned i = 0, sz = preds.size(); i < sz; ++i) {
@ -4036,7 +4036,7 @@ bool context::check_invariant(unsigned lvl, func_decl* fn)
if (m.is_true(inv)) { return true; }
pt.add_premises(m_rels, lvl, conj);
conj.push_back(m.mk_not(inv));
expr_ref fml(m.mk_and(conj.size(), conj.c_ptr()), m);
expr_ref fml(m.mk_and(conj.size(), conj.data()), m);
ctx->assert_expr(fml);
lbool result = ctx->check_sat(0, nullptr);
TRACE("spacer", tout << "Check invariant level: " << lvl << " " << result
@ -4061,7 +4061,7 @@ expr_ref context::get_constraints (unsigned level)
{ args.push_back(m.mk_const(m_pm.o2n(r.sig(i), 0))); }
expr_ref pred(m);
pred = m.mk_app(r.head (), r.sig_size(), args.c_ptr());
pred = m.mk_app(r.head (), r.sig_size(), args.data());
constraints.push_back(m.mk_implies(pred, c));
}
@ -4107,7 +4107,7 @@ void context::new_lemma_eh(pred_transformer &pt, lemma *lem) {
for (unsigned i = 0; i < pt.sig_size(); ++i) {
args.push_back(m.mk_const(pt.get_manager().o2n(pt.sig(i), 0)));
}
expr *app = m.mk_app(pt.head(), pt.sig_size(), args.c_ptr());
expr *app = m.mk_app(pt.head(), pt.sig_size(), args.data());
expr *lemma = m.mk_implies(app, lem->get_expr());
for (unsigned i = 0; i < m_callbacks.size(); i++) {
if (m_callbacks[i]->new_lemma())

2
src/muz/spacer/spacer_context.h
View file

@ -458,7 +458,7 @@ public:
func_decl* head() const {return m_head;}
ptr_vector<datalog::rule> const& rules() const {return m_rules;}
func_decl* sig(unsigned i) const {return m_sig[i];} // signature
func_decl* const* sig() {return m_sig.c_ptr();}
func_decl* const* sig() {return m_sig.data();}
unsigned sig_size() const {return m_sig.size();}
expr* transition() const {return m_transition;}
expr* init() const {return m_init;}

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

@ -374,7 +374,7 @@ void farkas_learner::get_lemmas(proof* root, expr_set const& bs, expr_ref_vector
SASSERT(coeffs.size() == lits.size());
if (num_b_pures > 0) {
expr_ref res(m);
combine_constraints(coeffs.size(), lits.c_ptr(), coeffs.c_ptr(), res);
combine_constraints(coeffs.size(), lits.data(), coeffs.data(), res);
TRACE("farkas_learner2", tout << "Add: " << mk_pp(res, m) << "\n";);
INSERT(res);
b_closed.mark(p, true);

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

@ -121,7 +121,7 @@ namespace spacer {
lbool iuc_solver::check_sat_cc(const expr_ref_vector &cube,
vector<expr_ref_vector> const & clauses) {
if (clauses.empty())
return check_sat(cube.size(), cube.c_ptr());
return check_sat(cube.size(), cube.data());
// -- remove any old assumptions
m_assumptions.shrink(m_first_assumption);

2
src/muz/spacer/spacer_iuc_solver.h
View file

@ -103,7 +103,7 @@ public:
void get_full_unsat_core(ptr_vector<expr> &core) {
expr_ref_vector _core(m);
m_solver.get_unsat_core(_core);
core.append(_core.size(), _core.c_ptr());
core.append(_core.size(), _core.data());
}
/* solver interface */

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

@ -506,10 +506,10 @@ void model_evaluator::eval_array_eq(app* e, expr* arg1, expr* arg2)
for (unsigned i = 0; i < store.size(); ++i) {
args1.resize(1);
args2.resize(1);
args1.append(store[i].size() - 1, store[i].c_ptr());
args2.append(store[i].size() - 1, store[i].c_ptr());
s1 = m_array.mk_select(args1.size(), args1.c_ptr());
s2 = m_array.mk_select(args2.size(), args2.c_ptr());
args1.append(store[i].size() - 1, store[i].data());
args2.append(store[i].size() - 1, store[i].data());
s1 = m_array.mk_select(args1.size(), args1.data());
s2 = m_array.mk_select(args2.size(), args2.data());
w1 = (*m_model)(s1);
w2 = (*m_model)(s2);
if (w1 == w2) {

2
src/muz/spacer/spacer_manager.h
View file

@ -46,7 +46,7 @@ struct relation_info {
func_decl_ref_vector m_vars;
expr_ref m_body;
relation_info(ast_manager& m, func_decl* pred, ptr_vector<func_decl> const& vars, expr* b):
m_pred(pred, m), m_vars(m, vars.size(), vars.c_ptr()), m_body(b, m) {}
m_pred(pred, m), m_vars(m, vars.size(), vars.data()), m_body(b, m) {}
};
class unknown_exception {};

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

@ -151,8 +151,8 @@ void model_evaluator_array_util::eval_array_eq(model& mdl, app* e, expr* arg1, e
for (unsigned i = 0; i < store.size(); ++i) {
args1.resize(1);
args2.resize(1);
args1.append(store[i].size()-1, store[i].c_ptr());
args2.append(store[i].size()-1, store[i].c_ptr());
args1.append(store[i].size()-1, store[i].data());
args2.append(store[i].size()-1, store[i].data());
s1 = m_array.mk_select(args1);
s2 = m_array.mk_select(args2);
eval (mdl, s1, w1);

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

@ -340,7 +340,7 @@ bool context::gpdr_create_split_children(pob &n, const datalog::rule &r,
kid_order.reverse();
}
else if (m_children_order == CO_RANDOM) {
shuffle(kid_order.size(), kid_order.c_ptr(), m_random);
shuffle(kid_order.size(), kid_order.data(), m_random);
}

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

@ -219,8 +219,8 @@ namespace spacer {
proof_ref pf(m);
pf = m.mk_th_lemma(tid, m.mk_false(),
parents.size(), parents.c_ptr(),
v.size(), v.c_ptr());
parents.size(), parents.data(),
v.size(), v.data());
return pf;
}
@ -345,8 +345,8 @@ namespace spacer {
proof_ref pf(m);
pf = m.mk_th_lemma(tid, m.mk_false(),
parents.size(), parents.c_ptr(),
v.size(), v.c_ptr());
parents.size(), parents.data(),
v.size(), v.data());
SASSERT(is_arith_lemma(m, pf));
TRACE("spacer.fkab", tout << mk_pp(pf, m) << "\n";);
@ -447,7 +447,7 @@ namespace spacer {
SASSERT(p->get_decl()->get_arity() == args.size());
proof* res = m.mk_app(p->get_decl(),
args.size(), (expr * const*)args.c_ptr());
args.size(), (expr * const*)args.data());
m_pinned.push_back(res);
m_cache.insert(p, res);
}
@ -734,7 +734,7 @@ namespace spacer {
}
expr_ref lemma(m);
lemma = mk_or(m, args.size(), args.c_ptr());
lemma = mk_or(m, args.size(), args.data());
proof* res;
res = m.mk_lemma(premise, lemma);
@ -816,7 +816,7 @@ namespace spacer {
// expr_ref tmp(m);
// tmp = mk_or(m, pf_fact.size(), pf_fact.c_ptr());
// proof* res = m.mk_unit_resolution(pf_args.size(), pf_args.c_ptr(), tmp);
proof *res = m.mk_unit_resolution(pf_args.size(), pf_args.c_ptr());
proof *res = m.mk_unit_resolution(pf_args.size(), pf_args.data());
m_pinned.push_back(res);
return res;
@ -839,7 +839,7 @@ namespace spacer {
SASSERT(old->get_decl()->get_arity() == args.size());
proof* res = m.mk_app(old->get_decl(), args.size(),
(expr * const*)args.c_ptr());
(expr * const*)args.data());
m_pinned.push_back(res);
return res;
}

8
src/muz/spacer/spacer_prop_solver.cpp
View file

@ -143,7 +143,7 @@ lbool prop_solver::mss(expr_ref_vector &hard, expr_ref_vector &soft) {
iuc_solver::scoped_mk_proxy _p_(*m_ctx, hard);
unsigned hard_sz = hard.size();
lbool res = m_ctx->check_sat(hard.size(), hard.c_ptr());
lbool res = m_ctx->check_sat(hard.size(), hard.data());
// bail out if hard constraints are not sat, or if there are no
// soft constraints
if (res != l_true || soft.empty()) {return res;}
@ -202,7 +202,7 @@ lbool prop_solver::mss(expr_ref_vector &hard, expr_ref_vector &soft) {
// -- grow the set of backbone literals
for (;j < hard.size(); ++j) {
res = m_ctx->check_sat(j+1, hard.c_ptr());
res = m_ctx->check_sat(j+1, hard.data());
if (res == l_false) {
// -- flip non-true literal to be false
hard[j] = mk_not(m, hard.get(j));
@ -363,10 +363,10 @@ lbool prop_solver::check_assumptions(const expr_ref_vector & _hard,
// current clients expect that flattening of HARD is
// done implicitly during check_assumptions
expr_ref_vector hard(m);
hard.append(_hard.size(), _hard.c_ptr());
hard.append(_hard.size(), _hard.data());
flatten_and(hard);
shuffle(hard.size(), hard.c_ptr(), m_random);
shuffle(hard.size(), hard.data(), m_random);
m_ctx = m_contexts [solver_id == 0 ? 0 : 0 /* 1 */].get();

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

@ -128,7 +128,7 @@ peq::peq (expr* lhs, expr* rhs, unsigned num_indices, expr * const * diff_indice
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 ());
m_decl = m.mk_func_decl (symbol (PARTIAL_EQ), sorts.size (), sorts.data (), m.mk_bool_sort ());
}
void peq::lhs (expr_ref& result) { result = m_lhs; }
@ -149,7 +149,7 @@ void peq::mk_peq (app_ref& result) {
for (unsigned i = 0; i < m_num_indices; i++) {
args.push_back (m_diff_indices.get (i));
}
m_peq = m.mk_app (m_decl, args.size (), args.c_ptr ());
m_peq = m.mk_app (m_decl, args.size (), args.data ());
}
result = m_peq;
}
@ -326,7 +326,7 @@ namespace spacer_qe {
t = ts.get (0);
}
else {
t = a.mk_add(ts.size(), ts.c_ptr());
t = a.mk_add(ts.size(), ts.data());
}
return true;
@ -947,7 +947,7 @@ namespace spacer_qe {
// all args processed; make new term
func_decl* d = ap->get_decl ();
expr_ref new_term (m);
new_term = m.mk_app (d, args.size (), args.c_ptr ());
new_term = m.mk_app (d, args.size (), args.data ());
// check for mod and introduce new var
if (a.is_mod (ap)) {
app_ref new_var (m);
@ -976,7 +976,7 @@ namespace spacer_qe {
if (new_fml) {
fml = new_fml;
// add in eqs
fml = m.mk_and (fml, m.mk_and (eqs.size (), eqs.c_ptr ()));
fml = m.mk_and (fml, m.mk_and (eqs.size (), eqs.data ()));
}
else {
// unchanged
@ -1045,7 +1045,7 @@ namespace spacer_qe {
// t2 < abs (num_val)
lits.push_back (a.mk_lt (t2, a.mk_numeral (abs (num_val), a.mk_int ())));
new_fml = m.mk_and (lits.size (), lits.c_ptr ());
new_fml = m.mk_and (lits.size (), lits.data ());
}
}
else if (!is_app (fml)) {
@ -1060,7 +1060,7 @@ namespace spacer_qe {
mod2div (ch, map);
children.push_back (ch);
}
new_fml = m.mk_app (a->get_decl (), children.size (), children.c_ptr ());
new_fml = m.mk_app (a->get_decl (), children.size (), children.data ());
}
map.insert (fml, new_fml, nullptr);
@ -1402,7 +1402,7 @@ namespace spacer_qe {
if (!all_done) continue;
todo.pop_back ();
expr_ref a_new (m.mk_app (a->get_decl (), args.size (), args.c_ptr ()), m);
expr_ref a_new (m.mk_app (a->get_decl (), args.size (), args.data ()), m);
// if a_new is select on m_v, introduce new constant
if (m_arr_u.is_select (a) &&
@ -1457,7 +1457,7 @@ namespace spacer_qe {
ptr_vector<expr> sel_args;
sel_args.push_back (arr);
sel_args.push_back (I.get (i));
expr_ref val_term (m_arr_u.mk_select (sel_args.size (), sel_args.c_ptr ()), m);
expr_ref val_term (m_arr_u.mk_select (sel_args.size (), sel_args.data ()), m);
// evaluate and assign to ith diff_val_const
m_mev.eval (*M, val_term, val);
M->register_decl (diff_val_consts.get (i)->get_decl (), val);
@ -1537,7 +1537,7 @@ namespace spacer_qe {
);
// arr0 ==I arr1
mk_peq (arr0, arr1, I.size (), I.c_ptr (), p_exp);
mk_peq (arr0, arr1, I.size (), I.data (), p_exp);
TRACE ("qe",
tout << "new peq:\n";
@ -1548,7 +1548,7 @@ namespace spacer_qe {
m_idx_lits_v.append (idx_diseq);
// arr0 ==I+idx arr1
I.push_back (idx);
mk_peq (arr0, arr1, I.size (), I.c_ptr (), p_exp);
mk_peq (arr0, arr1, I.size (), I.data (), p_exp);
TRACE ("qe",
tout << "new peq:\n";
@ -1559,7 +1559,7 @@ namespace spacer_qe {
ptr_vector<expr> sel_args;
sel_args.push_back (arr1);
sel_args.push_back (idx);
expr_ref arr1_idx (m_arr_u.mk_select (sel_args.size (), sel_args.c_ptr ()), m);
expr_ref arr1_idx (m_arr_u.mk_select (sel_args.size (), sel_args.data ()), m);
expr_ref eq (m.mk_eq (arr1_idx, x), m);
m_aux_lits_v.push_back (eq);
@ -1737,7 +1737,7 @@ namespace spacer_qe {
lits.append (m_idx_lits_v);
lits.append (m_aux_lits_v);
lits.push_back (fml);
fml = m.mk_and (lits.size (), lits.c_ptr ());
fml = m.mk_and (lits.size (), lits.data ());
if (m_subst_term_v) {
m_true_sub_v.insert (m_v, m_subst_term_v);
@ -1899,7 +1899,7 @@ namespace spacer_qe {
todo.pop_back ();
if (dirty) {
r = m.mk_app (a->get_decl (), args.size (), args.c_ptr ());
r = m.mk_app (a->get_decl (), args.size (), args.data ());
m_pinned.push_back (r);
}
else r = a;
@ -1954,7 +1954,7 @@ namespace spacer_qe {
expr_ref_vector lits (m);
lits.append (m_idx_lits);
lits.push_back (fml);
fml = m.mk_and (lits.size (), lits.c_ptr ());
fml = m.mk_and (lits.size (), lits.data ());
// simplify all trivial expressions introduced
m_rw (fml);
@ -2153,7 +2153,7 @@ namespace spacer_qe {
expr_ref_vector lits (m);
lits.append (m_idx_lits);
lits.push_back (fml);
fml = m.mk_and (lits.size (), lits.c_ptr ());
fml = m.mk_and (lits.size (), lits.data ());
// substitute for sel terms
m_sub (fml);

6
src/muz/spacer/spacer_quant_generalizer.cpp
View file

@ -184,7 +184,7 @@ void lemma_quantifier_generalizer::find_candidates(expr *e,
}
}
std::sort(candidates.c_ptr(), candidates.c_ptr() + candidates.size(),
std::sort(candidates.data(), candidates.data() + candidates.size(),
index_lt_proc(m));
// keep actual select indices in the order found at the back of
// candidate list. There is no particular reason for this order
@ -276,8 +276,8 @@ void lemma_quantifier_generalizer::cleanup(expr_ref_vector &cube,
}
if (!found) continue;
rep = arith.mk_add(kids.size(), kids.c_ptr());
bind = arith.mk_add(kids_bind.size(), kids_bind.c_ptr());
rep = arith.mk_add(kids.size(), kids.data());
bind = arith.mk_add(kids_bind.size(), kids_bind.data());
TRACE("spacer_qgen",
tout << "replace " << mk_pp(idx, m) << " with " << mk_pp(rep, m) << "\n"
<< "bind is: " << bind << "\n";);

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

@ -24,7 +24,7 @@ struct ground_sat_answer_op::frame {
ast_manager &m = pt.get_ast_manager();
spacer::manager &pm = pt.get_manager();
m_fact = m.mk_app(head(), m_gnd_subst.size(), m_gnd_subst.c_ptr());
m_fact = m.mk_app(head(), m_gnd_subst.size(), m_gnd_subst.data());
// compute ground equalities implied by the fact
SASSERT(m_gnd_subst.size() == pt.head()->get_arity());
@ -193,7 +193,7 @@ proof *ground_sat_answer_op::mk_proof_step(frame &fr) {
substs.push_back(expr_ref_vector(m));
}
m_pinned.push_back(m.mk_hyper_resolve(premises.size(),
premises.c_ptr(),
premises.data(),
fr.fact(),
positions, substs));
TRACE("spacer_sat", tout << "pf step:\n"

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

@ -732,7 +732,7 @@ namespace spacer {
egraph.to_lits(v);
}
// sort arguments of the top-level and
std::stable_sort(v.c_ptr(), v.c_ptr() + v.size(), ast_lt_proc());
std::stable_sort(v.data(), v.data() + v.size(), ast_lt_proc());
TRACE("spacer_normalize",
tout << "Normalized:\n"
@ -857,7 +857,7 @@ namespace spacer {
sort* s = fv[i] ? fv[i] : m.mk_bool_sort();
vars[i] = mk_zk_const(m, i, s);
var_subst vs(m, false);
out = vs(e, vars.size(), (expr**)vars.c_ptr());
out = vs(e, vars.size(), (expr**)vars.data());
}
}