mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-24 17:45:32 +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

14
src/tactic/aig/aig.cpp
View file

@ -870,7 +870,7 @@ struct aig_manager::imp {
add_child(left(t));
add_child(right(t));
}
expr * r = ast_mng.mk_not(ast_mng.mk_or(m_and_children.size(), m_and_children.c_ptr()));
expr * r = ast_mng.mk_not(ast_mng.mk_or(m_and_children.size(), m_and_children.data()));
cache_result(n, r);
TRACE("aig2expr", tout << "caching AND "; m.display_ref(tout, n); tout << "\n";);
}
@ -1059,7 +1059,7 @@ struct aig_manager::imp {
}
void reset_saved() {
m.dec_array_ref(m_saved.size(), m_saved.c_ptr());
m.dec_array_ref(m_saved.size(), m_saved.data());
m_saved.finalize();
}
@ -1600,7 +1600,7 @@ public:
}
}
}
unmark(queue.size(), queue.c_ptr());
unmark(queue.size(), queue.data());
}
void display_smt2_ref(std::ostream & out, aig_lit const & r) const {
@ -1635,9 +1635,9 @@ public:
bool visited = true;
for (unsigned i = 0; i < 2; i++) {
aig_lit c = t->m_children[i];
aig * c_ptr = c.ptr();
if (!c_ptr->m_mark) {
todo.push_back(c_ptr);
aig * data = c.ptr();
if (!data->m_mark) {
todo.push_back(data);
visited = false;
}
}
@ -1656,7 +1656,7 @@ public:
out << "(assert ";
display_smt2_ref(out, r);
out << ")\n";
unmark(to_unmark.size(), to_unmark.c_ptr());
unmark(to_unmark.size(), to_unmark.data());
}
unsigned get_num_aigs() const {

2
src/tactic/arith/bv2int_rewriter.h
View file

@ -40,7 +40,7 @@ public:
void reset() { m_side_conditions.reset(); m_trail.reset(); m_power2.reset(); }
void add_side_condition(expr* e) { m_side_conditions.push_back(e); }
unsigned num_side_conditions() const { return m_side_conditions.size(); }
expr* const* side_conditions() const { return m_side_conditions.c_ptr(); }
expr* const* side_conditions() const { return m_side_conditions.data(); }
unsigned get_max_num_bits() const { return m_max_size; }
void collect_power2(goal const & s);

2
src/tactic/arith/bv2real_rewriter.h
View file

@ -110,7 +110,7 @@ public:
void add_side_condition(expr* e) { m_side_conditions.push_back(e); }
unsigned num_side_conditions() const { return m_side_conditions.size(); }
expr* const* side_conditions() const { return m_side_conditions.c_ptr(); }
expr* const* side_conditions() const { return m_side_conditions.data(); }
bool is_zero(expr* e);

12
src/tactic/arith/factor_tactic.cpp
View file

@ -63,7 +63,7 @@ class factor_tactic : public tactic {
m_expr2poly.to_expr(fs[i], true, arg);
args.push_back(arg);
}
result = m.mk_eq(mk_mul(args.size(), args.c_ptr()), mk_zero_for(arg));
result = m.mk_eq(mk_mul(args.size(), args.data()), mk_zero_for(arg));
}
// p1^k1 * p2^k2 = 0 --> p1 = 0 or p2 = 0
@ -77,7 +77,7 @@ class factor_tactic : public tactic {
if (args.size() == 1)
result = args[0];
else
result = m.mk_or(args.size(), args.c_ptr());
result = m.mk_or(args.size(), args.data());
}
decl_kind flip(decl_kind k) {
@ -106,7 +106,7 @@ class factor_tactic : public tactic {
arg = m_util.mk_power(arg, m_util.mk_numeral(rational(2), m_util.is_int(arg)));
args.push_back(arg);
}
expr * lhs = mk_mul(args.size(), args.c_ptr());
expr * lhs = mk_mul(args.size(), args.data());
result = m.mk_app(m_util.get_family_id(), k, lhs, mk_zero_for(lhs));
}
@ -155,15 +155,15 @@ class factor_tactic : public tactic {
}
}
else {
args.push_back(m.mk_app(m_util.get_family_id(), k, mk_mul(odd_factors.size(), odd_factors.c_ptr()), mk_zero_for(odd_factors[0])));
args.push_back(m.mk_app(m_util.get_family_id(), k, mk_mul(odd_factors.size(), odd_factors.data()), mk_zero_for(odd_factors[0])));
}
SASSERT(!args.empty());
if (args.size() == 1)
result = args[0];
else if (strict)
result = m.mk_and(args.size(), args.c_ptr());
result = m.mk_and(args.size(), args.data());
else
result = m.mk_or(args.size(), args.c_ptr());
result = m.mk_or(args.size(), args.data());
}
br_status factor(func_decl * f, expr * lhs, expr * rhs, expr_ref & result) {

28
src/tactic/arith/fm_tactic.cpp
View file

@ -162,16 +162,16 @@ class fm_tactic : public tactic {
fm_model_converter(ast_manager & _m):m(_m) {}
~fm_model_converter() override {
m.dec_array_ref(m_xs.size(), m_xs.c_ptr());
m.dec_array_ref(m_xs.size(), m_xs.data());
vector<clauses>::iterator it = m_clauses.begin();
vector<clauses>::iterator end = m_clauses.end();
for (; it != end; ++it)
m.dec_array_ref(it->size(), it->c_ptr());
m.dec_array_ref(it->size(), it->data());
}
void insert(func_decl * x, clauses & c) {
m.inc_ref(x);
m.inc_array_ref(c.size(), c.c_ptr());
m.inc_array_ref(c.size(), c.data());
m_xs.push_back(x);
m_clauses.push_back(clauses());
m_clauses.back().swap(c);
@ -531,7 +531,7 @@ class fm_tactic : public tactic {
}
void reset_constraints() {
del_constraints(m_constraints.size(), m_constraints.c_ptr());
del_constraints(m_constraints.size(), m_constraints.data());
m_constraints.reset();
}
@ -897,7 +897,7 @@ class fm_tactic : public tactic {
if (c.m_num_vars == 1)
lhs = ms[0];
else
lhs = m_util.mk_add(ms.size(), ms.c_ptr());
lhs = m_util.mk_add(ms.size(), ms.data());
expr * rhs = m_util.mk_numeral(c.m_c, int_cnstr);
if (c.m_strict) {
ineq = m.mk_not(m_util.mk_ge(lhs, rhs));
@ -927,7 +927,7 @@ class fm_tactic : public tactic {
if (lits.size() == 1)
return to_app(lits[0]);
else
return m.mk_or(lits.size(), lits.c_ptr());
return m.mk_or(lits.size(), lits.data());
}
var mk_var(expr * t) {
@ -1060,7 +1060,7 @@ class fm_tactic : public tactic {
if (!is_int(xs.back()))
all_int = false;
}
mk_int(as.size(), as.c_ptr(), c);
mk_int(as.size(), as.data(), c);
if (all_int && strict) {
strict = false;
c--;
@ -1071,10 +1071,10 @@ class fm_tactic : public tactic {
TRACE("to_var_bug", tout << "before mk_constraint: "; for (unsigned i = 0; i < xs.size(); i++) tout << " " << xs[i]; tout << "\n";);
constraint * new_c = mk_constraint(lits.size(),
lits.c_ptr(),
lits.data(),
xs.size(),
xs.c_ptr(),
as.c_ptr(),
xs.data(),
as.data(),
c,
strict,
dep);
@ -1428,10 +1428,10 @@ class fm_tactic : public tactic {
}
constraint * new_cnstr = mk_constraint(new_lits.size(),
new_lits.c_ptr(),
new_lits.data(),
new_xs.size(),
new_xs.c_ptr(),
new_as.c_ptr(),
new_xs.data(),
new_as.data(),
new_c,
new_strict,
new_dep);
@ -1488,7 +1488,7 @@ class fm_tactic : public tactic {
for (unsigned j = 0; j < num_uppers; j++) {
if (m_inconsistent || num_new_cnstrs > limit) {
TRACE("fm", tout << "too many new constraints: " << num_new_cnstrs << "\n";);
del_constraints(new_constraints.size(), new_constraints.c_ptr());
del_constraints(new_constraints.size(), new_constraints.data());
return false;
}
constraint const & l_c = *(l[i]);

8
src/tactic/arith/lia2card_tactic.cpp
View file

@ -57,7 +57,7 @@ class lia2card_tactic : public tactic {
bool is_le(expr* x, expr* y, expr_ref& result) {
if (is_pb(x, y, args, coeffs, coeff)) {
result = t.mk_le(coeffs.size(), coeffs.c_ptr(), args.c_ptr(), -coeff);
result = t.mk_le(coeffs.size(), coeffs.data(), args.data(), -coeff);
return true;
}
else {
@ -77,7 +77,7 @@ class lia2card_tactic : public tactic {
result = m.mk_not(result);
}
else if (m.is_eq(f) && is_pb(es[0], es[1], args, coeffs, coeff)) {
result = t.mk_eq(coeffs.size(), coeffs.c_ptr(), args.c_ptr(), -coeff);
result = t.mk_eq(coeffs.size(), coeffs.data(), args.data(), -coeff);
}
else {
return BR_FAILED;
@ -158,7 +158,7 @@ public:
m_mc->hide(v);
last_v = v;
}
expr* r = a.mk_add(xs.size(), xs.c_ptr());
expr* r = a.mk_add(xs.size(), xs.data());
m_mc->add(x->get_decl(), r);
return expr_ref(r, m);
}
@ -329,7 +329,7 @@ public:
if (!m.is_true(e)) {
es.push_back(e);
}
result = mk_and(m, es.size(), es.c_ptr());
result = mk_and(m, es.size(), es.data());
if (!m.is_true(e)) {
es.pop_back();
}

2
src/tactic/arith/lia2pb_tactic.cpp
View file

@ -248,7 +248,7 @@ class lia2pb_tactic : public tactic {
a *= rational(2);
}
SASSERT(def_args.size() > 1);
expr * def = m_util.mk_add(def_args.size(), def_args.c_ptr());
expr * def = m_util.mk_add(def_args.size(), def_args.data());
expr_dependency * dep = nullptr;
if (m_produce_unsat_cores) {
dep = m.mk_join(m_bm.lower_dep(x), m_bm.upper_dep(x));

4
src/tactic/arith/linear_equation.cpp
View file

@ -80,7 +80,7 @@ linear_equation * linear_equation_manager::mk(unsigned sz, mpq * as, var * xs, b
m_int_buffer.push_back(as[i].numerator());
}
linear_equation * new_eq = mk(sz, m_int_buffer.c_ptr(), xs, normalized);
linear_equation * new_eq = mk(sz, m_int_buffer.data(), xs, normalized);
m.del(r);
m.del(l);
@ -266,7 +266,7 @@ linear_equation * linear_equation_manager::mk(mpz const & b1, linear_equation co
SASSERT(m_int_buffer.size() == m_var_buffer.size());
if (m_int_buffer.empty())
return nullptr;
return mk_core(m_int_buffer.size(), m_int_buffer.c_ptr(), m_var_buffer.c_ptr());
return mk_core(m_int_buffer.size(), m_int_buffer.data(), m_var_buffer.data());
}
void linear_equation_manager::del(linear_equation * eq) {

12
src/tactic/arith/pb2bv_tactic.cpp
View file

@ -293,7 +293,7 @@ private:
switch (m_cls.size()) {
case 0: m_result.push_back(m.mk_false()); break;
case 1: m_result.push_back(m_cls[0]); break;
default: m_result.push_back(m.mk_or(m_cls.size(), m_cls.c_ptr()));
default: m_result.push_back(m.mk_or(m_cls.size(), m_cls.data()));
}
return;
}
@ -311,7 +311,7 @@ private:
init_sums(m_p);
init_lits(m_p);
process(0, m_c);
m_owner.m_b_rw.mk_and(m_result.size(), m_result.c_ptr(), r);
m_owner.m_b_rw.mk_and(m_result.size(), m_result.data(), r);
}
};
@ -380,7 +380,7 @@ private:
for (unsigned i = 0; i < m_p.size(); i++) {
args.push_back(mon_lit2lit(m_p[i]));
}
r = m.mk_or(args.size(), args.c_ptr());
r = m.mk_or(args.size(), args.data());
return;
}
@ -389,7 +389,7 @@ private:
for (unsigned i = 0; i < m_p.size(); i++) {
args.push_back(mon_lit2lit(m_p[i]));
}
m_b_rw.mk_and(args.size(), args.c_ptr(), r);
m_b_rw.mk_and(args.size(), args.data(), r);
return;
}
@ -468,7 +468,7 @@ private:
lhs_args.push_back(bv_monom);
}
expr * lhs = m.mk_app(m_bv_util.get_family_id(), OP_BADD, lhs_args.size(), lhs_args.c_ptr());
expr * lhs = m.mk_app(m_bv_util.get_family_id(), OP_BADD, lhs_args.size(), lhs_args.data());
expr * rhs = m_bv_util.mk_numeral(m_c, bits);
r = m_bv_util.mk_ule(rhs, lhs);
@ -808,7 +808,7 @@ private:
app * y_i = to_app(m_p[i+1].m_lit.var());
eqs.push_back(m.mk_eq(int2lit(x_i), int2lit(y_i)));
}
m_b_rw.mk_and(eqs.size(), eqs.c_ptr(), r);
m_b_rw.mk_and(eqs.size(), eqs.data(), r);
if (!pos)
m_b_rw.mk_not(r, r);
return;

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

@ -166,7 +166,7 @@ struct propagate_ineqs_tactic::imp {
expr2linear_pol(t, m_num_buffer, m_var_buffer);
m_num_buffer.push_back(mpq(-1));
m_var_buffer.push_back(x);
bp.mk_eq(m_num_buffer.size(), m_num_buffer.c_ptr(), m_var_buffer.c_ptr());
bp.mk_eq(m_num_buffer.size(), m_num_buffer.data(), m_var_buffer.data());
}
return x;
}
@ -278,7 +278,7 @@ struct propagate_ineqs_tactic::imp {
mpq implied_k;
bool implied_strict;
bool result =
bp.lower(m_var_buffer.size(), m_num_buffer.c_ptr(), m_var_buffer.c_ptr(), implied_k, implied_strict) &&
bp.lower(m_var_buffer.size(), m_num_buffer.data(), m_var_buffer.data(), implied_k, implied_strict) &&
(nm.gt(implied_k, k) || (nm.eq(implied_k, k) && (!strict || implied_strict)));
nm.del(implied_k);
return result;
@ -293,7 +293,7 @@ struct propagate_ineqs_tactic::imp {
mpq implied_k;
bool implied_strict;
bool result =
bp.upper(m_var_buffer.size(), m_num_buffer.c_ptr(), m_var_buffer.c_ptr(), implied_k, implied_strict) &&
bp.upper(m_var_buffer.size(), m_num_buffer.data(), m_var_buffer.data(), implied_k, implied_strict) &&
(nm.lt(implied_k, k) || (nm.eq(implied_k, k) && (!strict || implied_strict)));
nm.del(implied_k);
return result;

2
src/tactic/arith/purify_arith_tactic.cpp
View file

@ -540,7 +540,7 @@ struct purify_arith_proc {
}
}
SASSERT(args.size() >= 2);
push_cnstr(EQ(u().mk_add(args.size(), args.c_ptr()), mk_real_zero()));
push_cnstr(EQ(u().mk_add(args.size(), args.data()), mk_real_zero()));
push_cnstr_pr(result_pr);
push_cnstr(u().mk_lt(u().mk_numeral(lower, false), k));
push_cnstr_pr(result_pr);

2
src/tactic/arith/recover_01_tactic.cpp
View file

@ -281,7 +281,7 @@ class recover_01_tactic : public tactic {
if (def_args.size() == 1)
x_def = def_args[0];
else
x_def = m_util.mk_add(def_args.size(), def_args.c_ptr());
x_def = m_util.mk_add(def_args.size(), def_args.data());
TRACE("recover_01", tout << x->get_name() << " --> " << mk_ismt2_pp(x_def, m) << "\n";);
subst->insert(m.mk_const(x), x_def);

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

@ -159,11 +159,11 @@ struct bit_blaster_model_converter : public model_converter {
if (TO_BOOL) {
SASSERT(is_app_of(bs, m().get_family_id("bv"), OP_MKBV));
result = util.mk_bv(bv_sz, args.c_ptr());
result = util.mk_bv(bv_sz, args.data());
}
else {
SASSERT(is_app_of(bs, m().get_family_id("bv"), OP_CONCAT));
result = util.mk_concat(bv_sz, args.c_ptr());
result = util.mk_concat(bv_sz, args.data());
}
return result;
}

18
src/tactic/bv/bv1_blaster_tactic.cpp
View file

@ -109,7 +109,7 @@ class bv1_blaster_tactic : public tactic {
bits.push_back(m().mk_fresh_const(nullptr, b));
m_newbits.push_back(to_app(bits.back())->get_decl());
}
r = butil().mk_concat(bits.size(), bits.c_ptr());
r = butil().mk_concat(bits.size(), bits.data());
m_saved.push_back(r);
m_const2bits.insert(f, r);
result = r;
@ -127,7 +127,7 @@ class bv1_blaster_tactic : public tactic {
--i;
bits.push_back(butil().mk_extract(i, i, t));
}
result = butil().mk_concat(bits.size(), bits.c_ptr());
result = butil().mk_concat(bits.size(), bits.data());
}
void reduce_eq(expr * arg1, expr * arg2, expr_ref & result) {
@ -142,7 +142,7 @@ class bv1_blaster_tactic : public tactic {
--i;
new_eqs.push_back(m().mk_eq(bits1[i], bits2[i]));
}
result = mk_and(m(), new_eqs.size(), new_eqs.c_ptr());
result = mk_and(m(), new_eqs.size(), new_eqs.data());
}
void reduce_ite(expr * c, expr * t, expr * e, expr_ref & result) {
@ -155,7 +155,7 @@ class bv1_blaster_tactic : public tactic {
unsigned num = t_bits.size();
for (unsigned i = 0; i < num; i++)
new_ites.push_back(t_bits[i] == e_bits[i] ? t_bits[i] : m().mk_ite(c, t_bits[i], e_bits[i]));
result = butil().mk_concat(new_ites.size(), new_ites.c_ptr());
result = butil().mk_concat(new_ites.size(), new_ites.data());
}
void reduce_num(func_decl * f, expr_ref & result) {
@ -174,7 +174,7 @@ class bv1_blaster_tactic : public tactic {
v = div(v, two);
}
std::reverse(bits.begin(), bits.end());
result = butil().mk_concat(bits.size(), bits.c_ptr());
result = butil().mk_concat(bits.size(), bits.data());
}
void reduce_extract(func_decl * f, expr * arg, expr_ref & result) {
@ -190,7 +190,7 @@ class bv1_blaster_tactic : public tactic {
for (unsigned i = start; i <= end; i++) {
bits.push_back(arg_bits[i]);
}
result = butil().mk_concat(bits.size(), bits.c_ptr());
result = butil().mk_concat(bits.size(), bits.data());
}
void reduce_concat(unsigned num, expr * const * args, expr_ref & result) {
@ -200,9 +200,9 @@ class bv1_blaster_tactic : public tactic {
expr * arg = args[i];
arg_bits.reset();
get_bits(arg, arg_bits);
bits.append(arg_bits.size(), arg_bits.c_ptr());
bits.append(arg_bits.size(), arg_bits.data());
}
result = butil().mk_concat(bits.size(), bits.c_ptr());
result = butil().mk_concat(bits.size(), bits.data());
}
void reduce_bin_xor(expr * arg1, expr * arg2, expr_ref & result) {
@ -216,7 +216,7 @@ class bv1_blaster_tactic : public tactic {
for (unsigned i = 0; i < num; i++) {
new_bits.push_back(m().mk_ite(m().mk_eq(bits1[i], bits2[i]), m_bit0, m_bit1));
}
result = butil().mk_concat(new_bits.size(), new_bits.c_ptr());
result = butil().mk_concat(new_bits.size(), new_bits.data());
}
void reduce_xor(unsigned num_args, expr * const * args, expr_ref & result) {

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

@ -296,7 +296,7 @@ br_status bvarray2uf_rewriter_cfg::reduce_app(func_decl * f, unsigned num, expr
expr_ref body(m_manager);
body = m_manager.mk_eq(m_manager.mk_app(f_t, x.get()),
m_manager.mk_app(map_f, num, new_args.c_ptr()));
m_manager.mk_app(map_f, num, new_args.data()));
expr_ref frllx(m_manager.mk_forall(1, sorts, names, body), m_manager);
extra_assertions.push_back(frllx);

8
src/tactic/bv/elim_small_bv_tactic.cpp
View file

@ -84,7 +84,7 @@ class elim_small_bv_tactic : public tactic {
// (VAR num_decls) ... (VAR num_decls+sz-1); are in positions num_decls .. num_decls+sz-1
std::reverse(substitution.c_ptr(), substitution.c_ptr() + substitution.size());
std::reverse(substitution.data(), substitution.data() + substitution.size());
// (VAR 0) should be in the last position of substitution.
@ -98,7 +98,7 @@ class elim_small_bv_tactic : public tactic {
});
var_subst vsbst(m);
res = vsbst(e, substitution.size(), substitution.c_ptr());
res = vsbst(e, substitution.size(), substitution.data());
SASSERT(is_well_sorted(m, res));
proof_ref pr(m);
@ -171,8 +171,8 @@ class elim_small_bv_tactic : public tactic {
for (unsigned k = 0; k < new_bodies.size(); k++)
tout << mk_ismt2_pp(new_bodies[k].get(), m) << std::endl; );
body = is_forall(q) ? m.mk_and(new_bodies.size(), new_bodies.c_ptr()) :
m.mk_or(new_bodies.size(), new_bodies.c_ptr());
body = is_forall(q) ? m.mk_and(new_bodies.size(), new_bodies.data()) :
m.mk_or(new_bodies.size(), new_bodies.data());
SASSERT(is_well_sorted(m, body));
proof_ref pr(m);

2
src/tactic/converter.h
View file

@ -86,7 +86,7 @@ protected:
ptr_buffer<T> t2s;
for (T* c : m_c2s)
t2s.push_back(c ? c->translate(translator) : nullptr);
return alloc(T2, t1, m_c2s.size(), t2s.c_ptr(), m_szs.c_ptr());
return alloc(T2, t1, m_c2s.size(), t2s.data(), m_szs.data());
}
public:

4
src/tactic/core/blast_term_ite_tactic.cpp
View file

@ -80,14 +80,14 @@ class blast_term_ite_tactic : public tactic {
expr_ref e1(m), e2(m);
ptr_vector<expr> args1(num_args, args);
args1[i] = t;
e1 = m.mk_app(f, num_args, args1.c_ptr());
e1 = m.mk_app(f, num_args, args1.data());
if (m.are_equal(t, e)) {
result = e1;
return BR_REWRITE1;
}
else {
args1[i] = e;
e2 = m.mk_app(f, num_args, args1.c_ptr());
e2 = m.mk_app(f, num_args, args1.data());
result = m.mk_ite(c, e1, e2);
++m_num_fresh;
return BR_REWRITE3;

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

@ -617,7 +617,7 @@ struct cofactor_elim_term_ite::imp {
has_term_ite = true;
expr_ref new_t(m);
if (has_new_args)
new_t = m.mk_app(to_app(t)->get_decl(), num, new_args.c_ptr());
new_t = m.mk_app(to_app(t)->get_decl(), num, new_args.data());
else
new_t = t;
if (has_term_ite && is_atom(new_t)) {

6
src/tactic/core/ctx_simplify_tactic.cpp
View file

@ -420,8 +420,8 @@ struct ctx_simplify_tactic::imp {
r = new_new_args[0];
}
else {
std::reverse(new_new_args.c_ptr(), new_new_args.c_ptr() + new_new_args.size());
m_mk_app(t->get_decl(), new_new_args.size(), new_new_args.c_ptr(), r);
std::reverse(new_new_args.data(), new_new_args.data() + new_new_args.size());
m_mk_app(t->get_decl(), new_new_args.size(), new_new_args.data(), r);
}
cache(t, r);
}
@ -495,7 +495,7 @@ struct ctx_simplify_tactic::imp {
r = t;
}
else {
m_mk_app(t->get_decl(), new_args.size(), new_args.c_ptr(), r);
m_mk_app(t->get_decl(), new_args.size(), new_args.data(), r);
}
}

4
src/tactic/core/distribute_forall_tactic.cpp
View file

@ -52,7 +52,7 @@ class distribute_forall_tactic : public tactic {
tmp_q = m.update_quantifier(old_q, not_arg);
new_args.push_back(elim_unused_vars(m, tmp_q, params_ref()));
}
result = m.mk_and(new_args.size(), new_args.c_ptr());
result = m.mk_and(new_args.size(), new_args.data());
if (m.proofs_enabled()) {
result_pr = m.mk_push_quant(old_q, result);
}
@ -73,7 +73,7 @@ class distribute_forall_tactic : public tactic {
tmp_q = m.update_quantifier(old_q, arg);
new_args.push_back(elim_unused_vars(m, tmp_q, params_ref()));
}
result = m.mk_and(new_args.size(), new_args.c_ptr());
result = m.mk_and(new_args.size(), new_args.data());
if (m.proofs_enabled()) {
result_pr = m.mk_push_quant(old_q, result);
}

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

@ -290,7 +290,7 @@ expr_ref dom_simplify_tactic::simplify_rec(expr * e0) {
// for fn applications.
m_args.push_back(m.is_bool(arg) ? arg : simplify_arg(arg));
}
r = m.mk_app(to_app(e)->get_decl(), m_args.size(), m_args.c_ptr());
r = m.mk_app(to_app(e)->get_decl(), m_args.size(), m_args.data());
}
else {
r = e;

12
src/tactic/core/elim_uncnstr_tactic.cpp
View file

@ -161,12 +161,12 @@ class elim_uncnstr_tactic : public tactic {
for (unsigned i = 0; i < arity; i++)
new_args.push_back(m().get_some_value(get_array_domain(s, i)));
expr_ref sel(m());
sel = m().mk_app(fid, OP_SELECT, new_args.size(), new_args.c_ptr());
sel = m().mk_app(fid, OP_SELECT, new_args.size(), new_args.data());
expr_ref diff_sel(m());
if (!mk_diff(sel, diff_sel))
return false;
new_args.push_back(diff_sel);
r = m().mk_app(fid, OP_STORE, new_args.size(), new_args.c_ptr());
r = m().mk_app(fid, OP_STORE, new_args.size(), new_args.data());
return true;
}
if (fid == m_dt_util.get_family_id()) {
@ -197,7 +197,7 @@ class elim_uncnstr_tactic : public tactic {
new_args.push_back(m().get_some_value(constructor->get_domain(i)));
}
}
r = m().mk_app(constructor, new_args.size(), new_args.c_ptr());
r = m().mk_app(constructor, new_args.size(), new_args.data());
return true;
}
// TODO: handle more cases.
@ -396,7 +396,7 @@ class elim_uncnstr_tactic : public tactic {
if (new_args.size() == 1)
rest = new_args[0];
else
rest = m().mk_app(fid, add_k, new_args.size(), new_args.c_ptr());
rest = m().mk_app(fid, add_k, new_args.size(), new_args.data());
add_def(v, m().mk_app(fid, sub_k, u, rest));
}
return u;
@ -503,7 +503,7 @@ class elim_uncnstr_tactic : public tactic {
args.push_back(r);
if (low > 0)
args.push_back(m_bv_util.mk_numeral(rational(0), low));
add_def(arg, m_bv_util.mk_concat(args.size(), args.c_ptr()));
add_def(arg, m_bv_util.mk_concat(args.size(), args.data()));
}
return r;
}
@ -698,7 +698,7 @@ class elim_uncnstr_tactic : public tactic {
else
new_args.push_back(m().get_some_value(c->get_domain(i)));
}
add_def(args[0], m().mk_app(c, new_args.size(), new_args.c_ptr()));
add_def(args[0], m().mk_app(c, new_args.size(), new_args.data()));
return u;
}
}

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

@ -175,7 +175,7 @@ class occf_tactic : public tactic {
}
if (keep != nullptr)
new_lits.push_back(keep);
g->update(i, m.mk_or(new_lits.size(), new_lits.c_ptr()), nullptr, d);
g->update(i, m.mk_or(new_lits.size(), new_lits.data()), nullptr, d);
}
g->inc_depth();
result.push_back(g.get());

8
src/tactic/core/pb_preprocess_tactic.cpp
View file

@ -256,7 +256,7 @@ private:
coeffs.push_back(pb.get_coeff(r, j));
args.push_back(negate(to_app(r)->get_arg(j)));
}
tmp = pb.mk_ge(args.size(), coeffs.c_ptr(), args.c_ptr(), sum - k + rational::one());
tmp = pb.mk_ge(args.size(), coeffs.data(), args.data(), sum - k + rational::one());
g->update(i, tmp, g->pr(i), g->dep(i));
}
}
@ -293,7 +293,7 @@ private:
start = end;
TRACE("pb", tout << fml1 << "\n";);
}
fml2 = pb.mk_ge(cut_args.size(), cut_coeffs.c_ptr(), cut_args.c_ptr(), pb.get_k(e));
fml2 = pb.mk_ge(cut_args.size(), cut_coeffs.data(), cut_args.data(), pb.get_k(e));
g->update(i, fml2, nullptr, g->dep(i));
TRACE("pb", tout << fml2 << "\n";);
}
@ -350,7 +350,7 @@ private:
cut_args.push_back(z);
j <<= 1;
}
fml1 = pb.mk_ge(args.size(), coeffs.c_ptr(), args.c_ptr(), rational(0));
fml1 = pb.mk_ge(args.size(), coeffs.data(), args.data(), rational(0));
m_r(fml1, fml);
return fml;
}
@ -519,7 +519,7 @@ private:
set_value(mc, arg, j != min_index);
}
tmp1 = pb.mk_ge(args2.size(), coeffs2.c_ptr(), args2.c_ptr(), k2);
tmp1 = pb.mk_ge(args2.size(), coeffs2.data(), args2.data(), k2);
IF_VERBOSE(3, verbose_stream() << " " << tmp1 << "\n";
for (unsigned i = 0; i < args2.size(); ++i) {
verbose_stream() << mk_pp(args2[i].get(), m) << " ";

8
src/tactic/core/reduce_args_tactic.cpp
View file

@ -372,7 +372,7 @@ struct reduce_args_tactic::imp {
if (!bv.get(i))
domain.push_back(f->get_domain(i));
}
new_f = m.mk_fresh_func_decl(f->get_name(), symbol::null, domain.size(), domain.c_ptr(), f->get_range());
new_f = m.mk_fresh_func_decl(f->get_name(), symbol::null, domain.size(), domain.data(), f->get_range());
m.inc_ref(tmp);
m.inc_ref(new_f);
}
@ -382,7 +382,7 @@ struct reduce_args_tactic::imp {
if (!bv.get(i))
new_args.push_back(args[i]);
}
result = m.mk_app(new_f, new_args.size(), new_args.c_ptr());
result = m.mk_app(new_f, new_args.size(), new_args.data());
return BR_DONE;
}
};
@ -421,7 +421,7 @@ struct reduce_args_tactic::imp {
func_decl * new_def = it2->m_value;
f_mc->hide(new_def);
SASSERT(new_def->get_arity() == new_args.size());
app * new_t = m_manager.mk_app(new_def, new_args.size(), new_args.c_ptr());
app * new_t = m_manager.mk_app(new_def, new_args.size(), new_args.data());
if (def == nullptr) {
def = new_t;
}
@ -436,7 +436,7 @@ struct reduce_args_tactic::imp {
if (new_eqs.size() == 1)
cond = new_eqs[0];
else
cond = m_manager.mk_and(new_eqs.size(), new_eqs.c_ptr());
cond = m_manager.mk_and(new_eqs.size(), new_eqs.data());
def = m_manager.mk_ite(cond, new_t, def);
}
}

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

@ -490,7 +490,7 @@ private:
}
if (has_new_var) {
sub(new_body, result);
result = m.mk_quantifier(old_q->get_kind(), new_sorts.size(), new_sorts.c_ptr(), old_q->get_decl_names(), result, old_q->get_weight());
result = m.mk_quantifier(old_q->get_kind(), new_sorts.size(), new_sorts.data(), old_q->get_decl_names(), result, old_q->get_weight());
result_pr = nullptr;
return true;
}

6
src/tactic/core/solve_eqs_tactic.cpp
View file

@ -230,7 +230,7 @@ class solve_eqs_tactic : public tactic {
for (unsigned k = 0; k < n; ++k) {
if (k != j) args.push_back(arg->get_arg(k));
}
div = m_a_util.mk_mul(args.size(), args.c_ptr());
div = m_a_util.mk_mul(args.size(), args.data());
return true;
}
return false;
@ -248,7 +248,7 @@ class solve_eqs_tactic : public tactic {
for (unsigned k = 0; k < num; ++k) {
if (k != i) args.push_back(lhs->get_arg(k));
}
def = m_a_util.mk_sub(rhs, m_a_util.mk_add(args.size(), args.c_ptr()));
def = m_a_util.mk_sub(rhs, m_a_util.mk_add(args.size(), args.data()));
def = m_a_util.mk_div(def, div);
if (m_produce_proofs)
pr = m().mk_rewrite(eq, m().mk_eq(var, def));
@ -311,7 +311,7 @@ class solve_eqs_tactic : public tactic {
def = m_a_util.mk_sub(rhs, other_args[0]);
break;
default:
def = m_a_util.mk_sub(rhs, m_a_util.mk_add(other_args.size(), other_args.c_ptr()));
def = m_a_util.mk_sub(rhs, m_a_util.mk_add(other_args.size(), other_args.data()));
break;
}
if (m_produce_proofs)

6
src/tactic/core/split_clause_tactic.cpp
View file

@ -67,7 +67,7 @@ class split_clause_tactic : public tactic {
expr * not_li = m.mk_not(m_clause->get_arg(i));
prs.push_back(m.mk_lemma(pr_i, not_li));
}
return proof_ref(m.mk_unit_resolution(prs.size(), prs.c_ptr()), m);
return proof_ref(m.mk_unit_resolution(prs.size(), prs.data()), m);
}
proof_converter * translate(ast_translation & translator) override {
@ -124,8 +124,8 @@ public:
subgoal_i->inc_depth();
result.push_back(subgoal_i);
}
in->set(concat(in->pc(), result.size(), result.c_ptr()));
in->add(dependency_converter::concat(result.size(), result.c_ptr()));
in->set(concat(in->pc(), result.size(), result.data()));
in->add(dependency_converter::concat(result.size(), result.data()));
}
void cleanup() override {

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

@ -164,7 +164,7 @@ private:
for (unsigned i = 0; i < g.size(); ++i) {
conjs.push_back(g.form(i));
}
fml = m().mk_and(conjs.size(), conjs.c_ptr());
fml = m().mk_and(conjs.size(), conjs.data());
normalize(fml);
}
@ -613,7 +613,7 @@ private:
for (unsigned i = 0; i < C.size(); ++i) {
eqs.push_back(m().mk_eq(t, C[i]));
}
return m().mk_or(eqs.size(), eqs.c_ptr());
return m().mk_or(eqs.size(), eqs.data());
}
};

22
src/tactic/core/tseitin_cnf_tactic.cpp
View file

@ -495,7 +495,7 @@ class tseitin_cnf_tactic : public tactic {
inv(lb, nlb);
mk_clause(la, nlb);
}
mk_clause(lits.size(), lits.c_ptr());
mk_clause(lits.size(), lits.data());
return DONE;
}
@ -575,13 +575,13 @@ class tseitin_cnf_tactic : public tactic {
#define MK_ITE_ROOT_CLS(L1, L2) { \
ctx.push_back(L1); ctx.push_back(L2); \
mk_clause(ctx.size(), ctx.c_ptr()); \
mk_clause(ctx.size(), ctx.data()); \
ctx.pop_back(); ctx.pop_back(); \
}
#define MK_ITE_CLS(L1, L2, L3) { \
ctx.push_back(L1); ctx.push_back(L2); ctx.push_back(L3); \
mk_clause(ctx.size(), ctx.c_ptr()); \
mk_clause(ctx.size(), ctx.data()); \
ctx.pop_back(); ctx.pop_back(); ctx.pop_back(); \
}
@ -643,9 +643,9 @@ class tseitin_cnf_tactic : public tactic {
MK_ITE_CLS(nlb, nlc, k);
ex_neg_ctx.push_back(lb); ex_neg_ctx.push_back(lc); ex_neg_ctx.push_back(nk);
mk_clause(ex_neg_ctx.size(), ex_neg_ctx.c_ptr());
mk_clause(ex_neg_ctx.size(), ex_neg_ctx.data());
ex_pos_ctx.push_back(nlb); ex_pos_ctx.push_back(nlc); ex_pos_ctx.push_back(k);
mk_clause(ex_pos_ctx.size(), ex_pos_ctx.c_ptr());
mk_clause(ex_pos_ctx.size(), ex_pos_ctx.data());
}
}
break;
@ -707,7 +707,7 @@ class tseitin_cnf_tactic : public tactic {
lits.push_back(l);
}
if (root) {
mk_clause(lits.size(), lits.c_ptr());
mk_clause(lits.size(), lits.data());
}
else {
for (unsigned i = 0; i < num; i++) {
@ -715,7 +715,7 @@ class tseitin_cnf_tactic : public tactic {
mk_clause(l, k);
}
lits.push_back(nk);
mk_clause(lits.size(), lits.c_ptr());
mk_clause(lits.size(), lits.data());
}
}
else {
@ -745,7 +745,7 @@ class tseitin_cnf_tactic : public tactic {
}
if (!root) {
lits.push_back(k);
mk_clause(lits.size(), lits.c_ptr());
mk_clause(lits.size(), lits.data());
}
continue;
}
@ -761,7 +761,7 @@ class tseitin_cnf_tactic : public tactic {
SASSERT(offsets.size() == num);
sbuffer<expr**> arg_lits;
ptr_buffer<expr> lits;
expr ** buffer_ptr = buffer.c_ptr();
expr ** buffer_ptr = buffer.data();
for (unsigned i = 0; i < num; i++) {
arg_lits.push_back(buffer_ptr + offsets[i]);
}
@ -772,9 +772,9 @@ class tseitin_cnf_tactic : public tactic {
}
if (!root)
lits.push_back(nk);
mk_clause(lits.size(), lits.c_ptr());
mk_clause(lits.size(), lits.data());
}
while (product_iterator_next(szs.size(), szs.c_ptr(), it.c_ptr()));
while (product_iterator_next(szs.size(), szs.data(), it.data()));
}
return DONE;
}

2
src/tactic/dependency_converter.cpp
View file

@ -84,7 +84,7 @@ public:
dependency_converter * translate(ast_translation & translator) override {
goal_ref_buffer goals;
for (goal_ref g : m_goals) goals.push_back(g->translate(translator));
return alloc(goal_dependency_converter, goals.size(), goals.c_ptr());
return alloc(goal_dependency_converter, goals.size(), goals.data());
}
void display(std::ostream& out) override { out << "goal-dep\n"; }

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

@ -317,13 +317,13 @@ namespace smtfd {
r = m.mk_eq(m_args.get(0), m_args.get(1));
}
else if (m.is_distinct(a)) {
r = m.mk_distinct(m_args.size(), m_args.c_ptr());
r = m.mk_distinct(m_args.size(), m_args.data());
}
else if (m.is_ite(a)) {
r = m.mk_ite(m_args.get(0), m_args.get(1), m_args.get(2));
}
else if (bvfid == fid || bfid == fid || pbfid == fid) {
r = m.mk_app(a->get_decl(), m_args.size(), m_args.c_ptr());
r = m.mk_app(a->get_decl(), m_args.size(), m_args.data());
}
else if (is_uninterp_const(t) && m.is_bool(t)) {
r = t;
@ -697,7 +697,7 @@ namespace smtfd {
}
unsigned f_app_hash::operator()(f_app const& a) const {
return get_composite_hash(p.values().c_ptr() + a.m_val_offset, a.m_t->get_num_args(), *this, *this);
return get_composite_hash(p.values().data() + a.m_val_offset, a.m_t->get_num_args(), *this, *this);
}
class basic_plugin : public theory_plugin {
@ -779,7 +779,7 @@ namespace smtfd {
values.push_back(m.mk_model_value(values.size(), s));
m_pinned.push_back(values.back());
}
m_context.get_model().register_usort(s, values.size(), values.c_ptr());
m_context.get_model().register_usort(s, values.size(), values.data());
for (unsigned i = 0; i < keys.size(); ++i) {
v2e.insert(keys[i], values[i]);
}
@ -859,7 +859,7 @@ namespace smtfd {
}
expr_ref val = model_value(f.m_t);
TRACE("smtfd_verbose", tout << mk_bounded_pp(f.m_t, m, 2) << " := " << val << "\n";);
fi->insert_new_entry(args.c_ptr(), val);
fi->insert_new_entry(args.data(), val);
}
mdl->register_decl(fn, fi);
}
@ -1410,7 +1410,7 @@ namespace smtfd {
for (expr* arg : *to_app(e)) {
args.push_back(replace_model_value(arg));
}
return expr_ref(m.mk_app(to_app(e)->get_decl(), args.size(), args.c_ptr()), m);
return expr_ref(m.mk_app(to_app(e)->get_decl(), args.size(), args.data()), m);
}
return expr_ref(e, m);
}
@ -1450,7 +1450,7 @@ namespace smtfd {
}
}
var_subst subst(m);
expr_ref body = subst(tmp, vars.size(), vars.c_ptr());
expr_ref body = subst(tmp, vars.size(), vars.data());
if (is_forall(q)) {
body = m.mk_not(body);
@ -1489,7 +1489,7 @@ namespace smtfd {
}
if (r == l_true) {
body = subst(q->get_expr(), vals.size(), vals.c_ptr());
body = subst(q->get_expr(), vals.size(), vals.data());
m_context.rewrite(body);
TRACE("smtfd", tout << "vals: " << vals << "\n" << body << "\n";);
if (is_forall(q)) {
@ -1518,7 +1518,7 @@ namespace smtfd {
vars[i] = m.mk_fresh_const(q->get_decl_name(i), q->get_decl_sort(i));
}
var_subst subst(m);
expr_ref body = subst(q->get_expr(), vars.size(), vars.c_ptr());
expr_ref body = subst(q->get_expr(), vars.size(), vars.data());
if (is_exists(q)) {
body = m.mk_implies(q, body);
}
@ -1646,7 +1646,7 @@ namespace smtfd {
unsigned sz = m_assertions.size() - m_assertions_qhead;
if (sz > 0) {
m_assertions.push_back(m_toggles.back());
expr_ref fml(m.mk_and(sz + 1, m_assertions.c_ptr() + m_assertions_qhead), m);
expr_ref fml(m.mk_and(sz + 1, m_assertions.data() + m_assertions_qhead), m);
m_assertions.pop_back();
expr* toggle = add_toggle(m.mk_fresh_const("toggle", m.mk_bool_sort()));
m_assertions_qhead = m_assertions.size();
@ -2010,7 +2010,7 @@ namespace smtfd {
}
m_stats.m_num_lemmas += m_context.size();
m_context.reset(m_model);
r = check_abs(core.size(), core.c_ptr());
r = check_abs(core.size(), core.data());
update_reason_unknown(r, m_fd_sat_solver);
switch (r) {
case l_false:

2
src/tactic/fpa/fpa2bv_model_converter.cpp
View file

@ -79,7 +79,7 @@ void fpa2bv_model_converter::convert(model_core * mc, model * float_mdl) {
for (unsigned i = 0; i < sz; i++) {
sort * s = mc->get_uninterpreted_sort(i);
ptr_vector<expr> u = mc->get_universe(s);
float_mdl->register_usort(s, u.size(), u.c_ptr());
float_mdl->register_usort(s, u.size(), u.data());
}
}

4
src/tactic/generic_model_converter.cpp
View file

@ -179,9 +179,9 @@ void generic_model_converter::operator()(expr_ref& fml) {
args.push_back(m.mk_var(i, sorts.back()));
}
// TBD: check if order is correct with respect to quantifier binding ordering
expr_ref lhs(m.mk_app(e.m_f, arity, args.c_ptr()), m);
expr_ref lhs(m.mk_app(e.m_f, arity, args.data()), m);
expr_ref body(m.mk_eq(lhs, e.m_def), m);
fmls.push_back(m.mk_forall(arity, sorts.c_ptr(), names.c_ptr(), body));
fmls.push_back(m.mk_forall(arity, sorts.data(), names.data(), body));
}
if (m_first_idx[e.m_f] == i) {
m_first_idx.remove(e.m_f);

2
src/tactic/goal.cpp
View file

@ -443,7 +443,7 @@ void goal::display_as_and(std::ostream & out) const {
for (unsigned i = 0; i < sz; i++)
args.push_back(form(i));
expr_ref tmp(m());
tmp = m().mk_and(args.size(), args.c_ptr());
tmp = m().mk_and(args.size(), args.data());
out << mk_ismt2_pp(tmp, m()) << "\n";
}

6
src/tactic/horn_subsume_model_converter.cpp
View file

@ -92,11 +92,11 @@ bool horn_subsume_model_converter::mk_horn(
}
}
expr_ref body_expr(m);
body_expr = m.mk_and(conjs.size(), conjs.c_ptr());
body_expr = m.mk_and(conjs.size(), conjs.data());
// substitute variables directly.
if (!subst.empty()) {
body_expr = vs(body_expr, subst.size(), subst.c_ptr());
body_expr = vs(body_expr, subst.size(), subst.data());
}
if (fv.empty()) {
@ -104,7 +104,7 @@ bool horn_subsume_model_converter::mk_horn(
body_res = body_expr;
}
else {
body_res = m.mk_exists(fv.size(), fv.c_ptr(), names.c_ptr(), body_expr.get());
body_res = m.mk_exists(fv.size(), fv.data(), names.data(), body_expr.get());
m_rewrite(body_res);
}

2
src/tactic/model_converter.cpp
View file

@ -137,7 +137,7 @@ public:
}
void operator()(labels_vec & r) override {
r.append(m_labels.size(), m_labels.c_ptr());
r.append(m_labels.size(), m_labels.data());
}
void operator()(expr_ref& fml) override {

4
src/tactic/proof_converter.cpp
View file

@ -71,7 +71,7 @@ public:
proof_converter_ref pc1 = m_pc->translate(tr);
goal_ref_buffer goals;
for (goal_ref g : m_goals) goals.push_back(g->translate(tr));
return alloc(subgoal_proof_converter, pc1.get(), goals.size(), goals.c_ptr());
return alloc(subgoal_proof_converter, pc1.get(), goals.size(), goals.data());
}
void display(std::ostream& out) override {}
@ -133,5 +133,5 @@ proof_ref apply(ast_manager & m, proof_converter_ref & pc1, proof_converter_ref_
pr = pc2s[i]->operator()(m, 0, nullptr);
prs.push_back(pr);
}
return (*pc1)(m, sz, prs.c_ptr());
return (*pc1)(m, sz, prs.data());
}

2
src/tactic/sls/sls_evaluator.h
View file

@ -510,7 +510,7 @@ public:
m_temp_exprs.push_back(m_tracker.mpz2value(arg->get_sort(), v));
}
expr_ref q(m_manager), temp(m_manager);
q = m_manager.mk_app(a->get_decl(), m_temp_exprs.size(), m_temp_exprs.c_ptr());
q = m_manager.mk_app(a->get_decl(), m_temp_exprs.size(), m_temp_exprs.data());
model dummy_model(m_manager);
model_evaluator evaluator(dummy_model);
evaluator(q, temp);

10
src/tactic/tactical.cpp
View file

@ -137,7 +137,7 @@ public:
}
}
else {
result.append(r2.size(), r2.c_ptr());
result.append(r2.size(), r2.data());
}
}
@ -270,7 +270,7 @@ protected:
for (tactic* curr : m_ts) {
new_ts.push_back(curr->translate(m));
}
return alloc(T, new_ts.size(), new_ts.c_ptr());
return alloc(T, new_ts.size(), new_ts.data());
}
};
@ -661,7 +661,7 @@ public:
else {
goal_ref_buffer * new_r2 = alloc(goal_ref_buffer);
goals_vect.set(i, new_r2);
new_r2->append(r2.size(), r2.c_ptr());
new_r2->append(r2.size(), r2.data());
dependency_converter* dc = r1[i]->dc();
if (cores_enabled && dc) {
expr_dependency_ref * new_dep = alloc(expr_dependency_ref, new_m);
@ -707,7 +707,7 @@ public:
}
if (proofs_enabled) {
// update proof converter of r1[i]
r1[i]->set(concat(r1[i]->pc(), result.size() - j, result.c_ptr() + j));
r1[i]->set(concat(r1[i]->pc(), result.size() - j, result.data() + j));
}
expr_dependency_translation td(translator);
if (core_buffer[i] != nullptr) {
@ -852,7 +852,7 @@ class repeat_tactical : public unary_tactical {
}
}
else {
result.append(r2.size(), r2.c_ptr());
result.append(r2.size(), r2.data());
}
}

4
src/tactic/ufbv/ufbv_rewriter.cpp
View file

@ -284,7 +284,7 @@ bool ufbv_rewriter::rewrite1(func_decl * f, expr_ref_vector & m_new_args, expr_r
SASSERT(large->get_decl() == f);
if (m_match_subst(large, l_s.second, m_new_args.c_ptr(), np)) {
if (m_match_subst(large, l_s.second, m_new_args.data(), np)) {
TRACE("demodulator_bug", tout << "succeeded...\n" << mk_pp(l_s.second, m) << "\n===>\n" << mk_pp(np, m) << "\n";);
return true;
}
@ -397,7 +397,7 @@ expr * ufbv_rewriter::rewrite(expr * n) {
if (f->get_family_id() != m.get_basic_family_id())
na = m.mk_app(f, m_new_args);
else
m_bsimp.mk_app(f, m_new_args.size(), m_new_args.c_ptr(), na);
m_bsimp.mk_app(f, m_new_args.size(), m_new_args.data(), na);
TRACE("demodulator_bug", tout << "e:\n" << mk_pp(e, m) << "\nnew_args: \n";
tout << m_new_args << "\n";
tout << "=====>\n";

2
src/tactic/ufbv/ufbv_rewriter_tactic.cpp
View file

@ -59,7 +59,7 @@ public:
proofs.push_back(g->pr(i));
}
dem(forms.size(), forms.c_ptr(), proofs.c_ptr(), new_forms, new_proofs);
dem(forms.size(), forms.data(), proofs.data(), new_forms, new_proofs);
g->reset();
for (unsigned i = 0; i < new_forms.size(); i++)