mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-08-12 22:20:54 +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

46
src/ast/rewriter/arith_rewriter.cpp
View file

@ -168,7 +168,7 @@ bool arith_rewriter::div_polynomial(expr * t, numeral const & g, const_treatment
switch (new_args.size()) {
case 0: result = m_util.mk_numeral(numeral(0), true); return true;
case 1: result = new_args[0]; return true;
default: result = m_util.mk_add(new_args.size(), new_args.c_ptr()); return true;
default: result = m_util.mk_add(new_args.size(), new_args.data()); return true;
}
}
@ -405,7 +405,7 @@ bool arith_rewriter::elim_to_real_mon(expr * monomial, expr_ref & new_monomial)
return false;
new_vars.push_back(new_var);
}
new_monomial = m_util.mk_mul(new_vars.size(), new_vars.c_ptr());
new_monomial = m_util.mk_mul(new_vars.size(), new_vars.data());
return true;
}
else {
@ -422,7 +422,7 @@ bool arith_rewriter::elim_to_real_pol(expr * p, expr_ref & new_p) {
return false;
new_monomials.push_back(new_monomial);
}
new_p = m_util.mk_add(new_monomials.size(), new_monomials.c_ptr());
new_p = m_util.mk_add(new_monomials.size(), new_monomials.data());
return true;
}
else {
@ -496,7 +496,7 @@ expr * arith_rewriter::reduce_power(expr * arg, bool is_eq) {
if (new_args.size() == 1)
return new_args[0];
else
return m_util.mk_mul(new_args.size(), new_args.c_ptr());
return m_util.mk_mul(new_args.size(), new_args.data());
}
br_status arith_rewriter::reduce_power(expr * arg1, expr * arg2, op_kind kind, expr_ref & result) {
@ -724,7 +724,7 @@ expr_ref arith_rewriter::neg_monomial(expr* e) const {
return expr_ref(args.back(), m());
}
else {
return expr_ref(m_util.mk_mul(args.size(), args.c_ptr()), m());
return expr_ref(m_util.mk_mul(args.size(), args.data()), m());
}
}
@ -745,7 +745,7 @@ bool arith_rewriter::is_neg_poly(expr* t, expr_ref& neg) const {
for (expr* e1 : *to_app(t)) {
args1.push_back(neg_monomial(e1));
}
neg = m_util.mk_add(args1.size(), args1.c_ptr());
neg = m_util.mk_add(args1.size(), args1.data());
return true;
}
return false;
@ -810,9 +810,9 @@ br_status arith_rewriter::mk_add_core(unsigned num_args, expr * const * args, ex
}
new_args.push_back(m_util.mk_numeral(am, r, false));
br_status st = poly_rewriter<arith_rewriter_core>::mk_add_core(new_args.size(), new_args.c_ptr(), result);
br_status st = poly_rewriter<arith_rewriter_core>::mk_add_core(new_args.size(), new_args.data(), result);
if (st == BR_FAILED) {
result = m().mk_app(get_fid(), OP_ADD, new_args.size(), new_args.c_ptr());
result = m().mk_app(get_fid(), OP_ADD, new_args.size(), new_args.data());
return BR_DONE;
}
return st;
@ -859,9 +859,9 @@ br_status arith_rewriter::mk_mul_core(unsigned num_args, expr * const * args, ex
}
new_args.push_back(m_util.mk_numeral(am, r, false));
br_status st = poly_rewriter<arith_rewriter_core>::mk_mul_core(new_args.size(), new_args.c_ptr(), result);
br_status st = poly_rewriter<arith_rewriter_core>::mk_mul_core(new_args.size(), new_args.data(), result);
if (st == BR_FAILED) {
result = m().mk_app(get_fid(), OP_MUL, new_args.size(), new_args.c_ptr());
result = m().mk_app(get_fid(), OP_MUL, new_args.size(), new_args.data());
return BR_DONE;
}
return st;
@ -1031,7 +1031,7 @@ br_status arith_rewriter::mk_idiv_core(expr * arg1, expr * arg2, expr_ref & resu
}
}
if (change) {
result = m_util.mk_idiv(m().mk_app(to_app(arg1)->get_decl(), args.size(), args.c_ptr()), arg2);
result = m_util.mk_idiv(m().mk_app(to_app(arg1)->get_decl(), args.size(), args.data()), arg2);
result = m_util.mk_add(m_util.mk_numeral(add, true), result);
TRACE("div_bug", tout << "mk_div result: " << result << "\n";);
return BR_REWRITE3;
@ -1083,8 +1083,8 @@ bool arith_rewriter::divides(expr* num, expr* den, expr_ref& result) {
break;
}
}
num = m_util.mk_mul(args1.size(), args1.c_ptr());
den = m_util.mk_mul(args2.size(), args2.c_ptr());
num = m_util.mk_mul(args1.size(), args1.data());
den = m_util.mk_mul(args2.size(), args2.data());
result = m_util.mk_idiv(num, den);
return true;
}
@ -1099,8 +1099,8 @@ expr_ref arith_rewriter::remove_divisor(expr* arg, expr* num, expr* den) {
remove_divisor(arg, args1);
remove_divisor(arg, args2);
expr_ref zero(m_util.mk_int(0), m());
num = args1.empty() ? m_util.mk_int(1) : m_util.mk_mul(args1.size(), args1.c_ptr());
den = args2.empty() ? m_util.mk_int(1) : m_util.mk_mul(args2.size(), args2.c_ptr());
num = args1.empty() ? m_util.mk_int(1) : m_util.mk_mul(args1.size(), args1.data());
den = args2.empty() ? m_util.mk_int(1) : m_util.mk_mul(args2.size(), args2.data());
expr_ref d(m_util.mk_idiv(num, den), m());
expr_ref nd(m_util.mk_idiv(m_util.mk_uminus(num), m_util.mk_uminus(den)), m());
return expr_ref(m().mk_ite(m().mk_eq(zero, arg),
@ -1194,7 +1194,7 @@ br_status arith_rewriter::mk_mod_core(expr * arg1, expr * arg2, expr_ref & resul
if (!change) {
return BR_FAILED; // did not find any target for applying simplification
}
result = m_util.mk_mod(m().mk_app(to_app(arg1)->get_decl(), args.size(), args.c_ptr()), arg2);
result = m_util.mk_mod(m().mk_app(to_app(arg1)->get_decl(), args.size(), args.data()), arg2);
TRACE("mod_bug", tout << "mk_mod result: " << mk_ismt2_pp(result, m()) << "\n";);
return BR_REWRITE3;
}
@ -1355,7 +1355,7 @@ br_status arith_rewriter::mk_power_core(expr * arg1, expr * arg2, expr_ref & res
for (unsigned i = 0; i < k; i++) {
args.push_back(arg1);
}
result = ensure_real(m_util.mk_mul(args.size(), args.c_ptr()));
result = ensure_real(m_util.mk_mul(args.size(), args.data()));
return BR_REWRITE2;
}
@ -1468,17 +1468,17 @@ br_status arith_rewriter::mk_to_int_core(expr * arg, expr_ref & result) {
return BR_FAILED;
if (real_args.empty()) {
result = m().mk_app(get_fid(), to_app(arg)->get_decl()->get_decl_kind(), int_args.size(), int_args.c_ptr());
result = m().mk_app(get_fid(), to_app(arg)->get_decl()->get_decl_kind(), int_args.size(), int_args.data());
return BR_REWRITE1;
}
if (!int_args.empty() && m_util.is_add(arg)) {
decl_kind k = to_app(arg)->get_decl()->get_decl_kind();
expr_ref t1(m().mk_app(get_fid(), k, int_args.size(), int_args.c_ptr()), m());
expr_ref t2(m().mk_app(get_fid(), k, real_args.size(), real_args.c_ptr()), m());
expr_ref t1(m().mk_app(get_fid(), k, int_args.size(), int_args.data()), m());
expr_ref t2(m().mk_app(get_fid(), k, real_args.size(), real_args.data()), m());
int_args.reset();
int_args.push_back(t1);
int_args.push_back(m_util.mk_to_int(t2));
result = m().mk_app(get_fid(), k, int_args.size(), int_args.c_ptr());
result = m().mk_app(get_fid(), k, int_args.size(), int_args.data());
return BR_REWRITE3;
}
}
@ -1498,9 +1498,9 @@ br_status arith_rewriter::mk_to_real_core(expr * arg, expr_ref & result) {
for (expr* e : *to_app(arg))
new_args.push_back(m_util.mk_to_real(e));
if (m_util.is_add(arg))
result = m().mk_app(get_fid(), OP_ADD, new_args.size(), new_args.c_ptr());
result = m().mk_app(get_fid(), OP_ADD, new_args.size(), new_args.data());
else
result = m().mk_app(get_fid(), OP_MUL, new_args.size(), new_args.c_ptr());
result = m().mk_app(get_fid(), OP_MUL, new_args.size(), new_args.data());
return BR_REWRITE2;
}
}

44
src/ast/rewriter/array_rewriter.cpp
View file

@ -113,7 +113,7 @@ br_status array_rewriter::mk_store_core(unsigned num_args, expr * const * args,
new_args.push_back(to_app(args[0])->get_arg(0));
new_args.append(num_args-1, args+1);
SASSERT(new_args.size() == num_args);
result = m().mk_app(get_fid(), OP_STORE, num_args, new_args.c_ptr());
result = m().mk_app(get_fid(), OP_STORE, num_args, new_args.data());
return BR_DONE;
}
case l_false:
@ -126,11 +126,11 @@ br_status array_rewriter::mk_store_core(unsigned num_args, expr * const * args,
ptr_buffer<expr> new_args;
new_args.push_back(to_app(args[0])->get_arg(0));
new_args.append(num_args-1, args+1);
expr * nested_store = m().mk_app(get_fid(), OP_STORE, num_args, new_args.c_ptr());
expr * nested_store = m().mk_app(get_fid(), OP_STORE, num_args, new_args.data());
new_args.reset();
new_args.push_back(nested_store);
new_args.append(num_args - 1, to_app(args[0])->get_args() + 1);
result = m().mk_app(get_fid(), OP_STORE, num_args, new_args.c_ptr());
result = m().mk_app(get_fid(), OP_STORE, num_args, new_args.data());
return BR_REWRITE2;
}
break;
@ -176,7 +176,7 @@ br_status array_rewriter::mk_select_core(unsigned num_args, expr * const * args,
ptr_buffer<expr> new_args;
new_args.push_back(to_app(args[0])->get_arg(0));
new_args.append(num_args-1, args+1);
result = m().mk_app(get_fid(), OP_SELECT, num_args, new_args.c_ptr());
result = m().mk_app(get_fid(), OP_SELECT, num_args, new_args.data());
return BR_REWRITE1;
}
default:
@ -185,7 +185,7 @@ br_status array_rewriter::mk_select_core(unsigned num_args, expr * const * args,
ptr_buffer<expr> new_args;
new_args.push_back(to_app(args[0])->get_arg(0));
new_args.append(num_args-1, args+1);
expr * sel_a_j = m().mk_app(get_fid(), OP_SELECT, num_args, new_args.c_ptr());
expr * sel_a_j = m().mk_app(get_fid(), OP_SELECT, num_args, new_args.data());
expr * v = to_app(args[0])->get_arg(num_args);
ptr_buffer<expr> eqs;
unsigned num_indices = num_args-1;
@ -223,7 +223,7 @@ br_status array_rewriter::mk_select_core(unsigned num_args, expr * const * args,
sh(args[i], num_args-1, result);
_args.push_back(result);
}
result = subst(q->get_expr(), _args.size(), _args.c_ptr());
result = subst(q->get_expr(), _args.size(), _args.data());
inv_var_shifter invsh(m());
invsh(result, _args.size(), result);
return BR_REWRITE_FULL;
@ -238,9 +238,9 @@ br_status array_rewriter::mk_select_core(unsigned num_args, expr * const * args,
ptr_vector<expr> args1;
args1.push_back(arg);
args1.append(num_args-1, args + 1);
args0.push_back(m_util.mk_select(args1.size(), args1.c_ptr()));
args0.push_back(m_util.mk_select(args1.size(), args1.data()));
}
result = m().mk_app(f0, args0.size(), args0.c_ptr());
result = m().mk_app(f0, args0.size(), args0.data());
return BR_REWRITE2;
}
@ -259,7 +259,7 @@ br_status array_rewriter::mk_select_core(unsigned num_args, expr * const * args,
args1.append(num_args-1, args + 1);
args2.push_back(el);
args2.append(num_args-1, args + 1);
result = m().mk_ite(c, m_util.mk_select(num_args, args1.c_ptr()), m_util.mk_select(num_args, args2.c_ptr()));
result = m().mk_ite(c, m_util.mk_select(num_args, args1.data()), m_util.mk_select(num_args, args2.data()));
return BR_REWRITE2;
}
@ -271,7 +271,7 @@ sort_ref array_rewriter::get_map_array_sort(func_decl* f, unsigned num_args, exp
unsigned sz = get_array_arity(s0);
ptr_vector<sort> domain;
for (unsigned i = 0; i < sz; ++i) domain.push_back(get_array_domain(s0, i));
return sort_ref(m_util.mk_array_sort(sz, domain.c_ptr(), f->get_range()), m());
return sort_ref(m_util.mk_array_sort(sz, domain.data(), f->get_range()), m());
}
br_status array_rewriter::mk_map_core(func_decl * f, unsigned num_args, expr * const * args, expr_ref & result) {
@ -317,13 +317,13 @@ br_status array_rewriter::mk_map_core(func_decl * f, unsigned num_args, expr * c
}
if (store_expr) {
ptr_buffer<expr> new_args;
new_args.push_back(m_util.mk_map(f, arrays.size(), arrays.c_ptr()));
new_args.push_back(m_util.mk_map(f, arrays.size(), arrays.data()));
new_args.append(num_indices, store_expr->get_args() + 1);
new_args.push_back(m().mk_app(f, values.size(), values.c_ptr()));
result = m().mk_app(get_fid(), OP_STORE, new_args.size(), new_args.c_ptr());
new_args.push_back(m().mk_app(f, values.size(), values.data()));
result = m().mk_app(get_fid(), OP_STORE, new_args.size(), new_args.data());
}
else {
expr_ref value(m().mk_app(f, values.size(), values.c_ptr()), m());
expr_ref value(m().mk_app(f, values.size(), values.data()), m());
sort_ref s = get_map_array_sort(f, num_args, args);
result = m_util.mk_const_array(s, value);
}
@ -358,10 +358,10 @@ br_status array_rewriter::mk_map_core(func_decl * f, unsigned num_args, expr * c
for (unsigned i = 0; i < n; ++i) {
sel.push_back(m().mk_var(n - i - 1, lam->get_decl_sort(i)));
}
args1.push_back(m_util.mk_select(sel.size(), sel.c_ptr()));
args1.push_back(m_util.mk_select(sel.size(), sel.data()));
}
}
result = m().mk_app(f, args1.size(), args1.c_ptr());
result = m().mk_app(f, args1.size(), args1.data());
result = m().update_quantifier(lam, result);
return BR_REWRITE3;
}
@ -423,7 +423,7 @@ br_status array_rewriter::mk_map_core(func_decl * f, unsigned num_args, expr * c
gs.shrink(k);
if (and_change) {
std::sort(gs.begin(), gs.end(), [](expr* a, expr* b) { return a->get_id() < b->get_id(); });
expr* arg = m_util.mk_map_assoc(f, gs.size(), gs.c_ptr());
expr* arg = m_util.mk_map_assoc(f, gs.size(), gs.data());
es[j] = m_util.mk_map(m().mk_not_decl(), 1, &arg);
}
}
@ -432,7 +432,7 @@ br_status array_rewriter::mk_map_core(func_decl * f, unsigned num_args, expr * c
}
if (change) {
std::sort(es.begin(), es.end(), [](expr* a, expr* b) { return a->get_id() < b->get_id(); });
result = m_util.mk_map_assoc(f, es.size(), es.c_ptr());
result = m_util.mk_map_assoc(f, es.size(), es.data());
return BR_REWRITE2;
}
}
@ -466,7 +466,7 @@ br_status array_rewriter::mk_map_core(func_decl * f, unsigned num_args, expr * c
}
}
if (change) {
result = m_util.mk_map_assoc(f, es.size(), es.c_ptr());
result = m_util.mk_map_assoc(f, es.size(), es.data());
return BR_REWRITE1;
}
}
@ -545,9 +545,9 @@ void array_rewriter::mk_eq(expr* e, expr* lhs, expr* rhs, expr_ref_vector& fmls)
args.reset();
args.push_back(lhs);
args.append(args0);
mk_select(args.size(), args.c_ptr(), tmp1);
mk_select(args.size(), args.data(), tmp1);
args[0] = rhs;
mk_select(args.size(), args.c_ptr(), tmp2);
mk_select(args.size(), args.data(), tmp2);
fmls.push_back(m().mk_eq(tmp1, tmp2));
e = a;
}
@ -686,7 +686,7 @@ expr_ref array_rewriter::expand_store(expr* s) {
sh(st->get_arg(args.size()), arity, tmp);
result = m().mk_ite(mk_and(eqs), tmp, result);
}
result = m().mk_lambda(sorts.size(), sorts.c_ptr(), names.c_ptr(), result);
result = m().mk_lambda(sorts.size(), sorts.data(), names.data(), result);
return result;
}

2
src/ast/rewriter/ast_counter.h
View file

@ -51,7 +51,7 @@ public:
*/
counter & count(unsigned sz, const unsigned * els, int delta = 1);
counter & count(const unsigned_vector & els, int delta = 1) {
return count(els.size(), els.c_ptr(), delta);
return count(els.size(), els.data(), delta);
}
void collect_positive(uint_set & acc) const;

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

@ -244,7 +244,7 @@ void bit2int::visit(app* n) {
m_args.push_back(get_cached(arg));
}
expr* const* args = m_args.c_ptr();
expr* const* args = m_args.data();
bool has_b2i =
m_arith_util.is_le(n) || m_arith_util.is_ge(n) || m_arith_util.is_gt(n) ||

16
src/ast/rewriter/bit_blaster/bit_blaster_rewriter.cpp
View file

@ -209,7 +209,7 @@ struct blaster_rewriter_cfg : public default_rewriter_cfg {
template<typename V>
app * mk_mkbv(V const & bits) {
return m().mk_app(butil().get_family_id(), OP_MKBV, bits.size(), bits.c_ptr());
return m().mk_app(butil().get_family_id(), OP_MKBV, bits.size(), bits.data());
}
void mk_const(func_decl * f, expr_ref & result) {
@ -241,7 +241,7 @@ void OP(expr * arg, expr_ref & result) { \
m_in1.reset(); \
get_bits(arg, m_in1); \
m_out.reset(); \
m_blaster.BB_OP(m_in1.size(), m_in1.c_ptr(), m_out); \
m_blaster.BB_OP(m_in1.size(), m_in1.data(), m_out); \
result = mk_mkbv(m_out); \
}
@ -255,7 +255,7 @@ void OP(expr * arg1, expr * arg2, expr_ref & result) { \
get_bits(arg1, m_in1); \
get_bits(arg2, m_in2); \
m_out.reset(); \
m_blaster.BB_OP(m_in1.size(), m_in1.c_ptr(), m_in2.c_ptr(), m_out); \
m_blaster.BB_OP(m_in1.size(), m_in1.data(), m_in2.data(), m_out); \
result = mk_mkbv(m_out); \
}
@ -294,7 +294,7 @@ void OP(expr * arg1, expr * arg2, expr_ref & result) {
m_in1.reset(); m_in2.reset(); \
get_bits(arg1, m_in1); \
get_bits(arg2, m_in2); \
m_blaster.BB_OP(m_in1.size(), m_in1.c_ptr(), m_in2.c_ptr(), result); \
m_blaster.BB_OP(m_in1.size(), m_in1.data(), m_in2.data(), result); \
}
MK_BIN_PRED_REDUCE(reduce_eq, mk_eq);
@ -309,7 +309,7 @@ void OP(expr * arg, unsigned n, expr_ref & result) { \
m_in1.reset(); \
get_bits(arg, m_in1); \
m_out.reset(); \
m_blaster.BB_OP(m_in1.size(), m_in1.c_ptr(), n, m_out); \
m_blaster.BB_OP(m_in1.size(), m_in1.data(), n, m_out); \
result = mk_mkbv(m_out); \
}
@ -321,7 +321,7 @@ MK_PARAMETRIC_UNARY_REDUCE(reduce_sign_extend, mk_sign_extend);
get_bits(arg2, m_in1);
get_bits(arg3, m_in2);
m_out.reset();
m_blaster.mk_multiplexer(arg1, m_in1.size(), m_in1.c_ptr(), m_in2.c_ptr(), m_out);
m_blaster.mk_multiplexer(arg1, m_in1.size(), m_in1.data(), m_in2.data(), m_out);
result = mk_mkbv(m_out);
}
@ -332,7 +332,7 @@ MK_PARAMETRIC_UNARY_REDUCE(reduce_sign_extend, mk_sign_extend);
i--;
m_in1.reset();
get_bits(args[i], m_in1);
m_out.append(m_in1.size(), m_in1.c_ptr());
m_out.append(m_in1.size(), m_in1.data());
}
result = mk_mkbv(m_out);
}
@ -657,7 +657,7 @@ MK_PARAMETRIC_UNARY_REDUCE(reduce_sign_extend, mk_sign_extend);
new_decl_names.push_back(n);
}
}
result = m().mk_quantifier(old_q->get_kind(), new_decl_sorts.size(), new_decl_sorts.c_ptr(), new_decl_names.c_ptr(),
result = m().mk_quantifier(old_q->get_kind(), new_decl_sorts.size(), new_decl_sorts.data(), new_decl_names.data(),
new_body, old_q->get_weight(), old_q->get_qid(), old_q->get_skid(),
old_q->get_num_patterns(), new_patterns, old_q->get_num_no_patterns(), new_no_patterns);
result_pr = nullptr;

108
src/ast/rewriter/bit_blaster/bit_blaster_tpl_def.h
View file

@ -325,7 +325,7 @@ void bit_blaster_tpl<Cfg>::mk_multiplier(unsigned sz, expr * const * a_bits, exp
expr_ref_vector & carry_bits = pps[save_inx+1];
SASSERT(sum_bits.empty() && carry_bits.empty());
carry_bits.push_back(zero);
mk_carry_save_adder(pp1.size(), pp1.c_ptr(), pp2.c_ptr(), pp3.c_ptr(), sum_bits, carry_bits);
mk_carry_save_adder(pp1.size(), pp1.data(), pp2.data(), pp3.data(), sum_bits, carry_bits);
carry_bits.pop_back();
save_inx += 2;
}
@ -345,7 +345,7 @@ void bit_blaster_tpl<Cfg>::mk_multiplier(unsigned sz, expr * const * a_bits, exp
SASSERT(pps.size() == 2);
// Now there are only two numbers to add, we can use a ripple carry adder here.
mk_adder(sz, pps[0].c_ptr(), pps[1].c_ptr(), out_bits);
mk_adder(sz, pps[0].data(), pps[1].data(), out_bits);
}
}
@ -368,7 +368,7 @@ void bit_blaster_tpl<Cfg>::mk_umul_no_overflow(unsigned sz, expr * const * a_bit
// mk_multiplier will simplify output taking into account that
// the most significant bits of ext_a_bits and ext_b_bits are zero.
//
mk_multiplier(1 + sz, ext_a_bits.c_ptr(), ext_b_bits.c_ptr(), mult_cout);
mk_multiplier(1 + sz, ext_a_bits.data(), ext_b_bits.data(), mult_cout);
expr_ref overflow1(m()), overflow2(m()), overflow(m());
//
// ignore bits [0, sz-1] of mult_cout
@ -403,7 +403,7 @@ void bit_blaster_tpl<Cfg>::mk_smul_no_overflow_core(unsigned sz, expr * const *
SASSERT(ext_a_bits.size() == 1 + sz);
SASSERT(ext_b_bits.size() == 1 + sz);
expr_ref_vector mult_cout(m());
mk_multiplier(1 + sz, ext_a_bits.c_ptr(), ext_b_bits.c_ptr(), mult_cout);
mk_multiplier(1 + sz, ext_a_bits.data(), ext_b_bits.data(), mult_cout);
expr_ref overflow1(m()), overflow2(m()), overflow(m());
//
@ -478,7 +478,7 @@ void bit_blaster_tpl<Cfg>::mk_udiv_urem(unsigned sz, expr * const * a_bits, expr
// generate p - b
expr_ref q(m());
t.reset();
mk_subtracter(sz, p.c_ptr(), b_bits, t, q);
mk_subtracter(sz, p.data(), b_bits, t, q);
q_bits.set(sz - i - 1, q);
// update p
@ -549,7 +549,7 @@ void bit_blaster_tpl<Cfg>::mk_abs(unsigned sz, expr * const * a_bits, expr_ref_v
else {
expr_ref_vector neg_a_bits(m());
mk_neg(sz, a_bits, neg_a_bits);
mk_multiplexer(a_msb, sz, neg_a_bits.c_ptr(), a_bits, out_bits);
mk_multiplexer(a_msb, sz, neg_a_bits.data(), a_bits, out_bits);
}
}
@ -584,7 +584,7 @@ void bit_blaster_tpl<Cfg>::mk_sdiv_srem_smod(unsigned sz, expr * const * a_bits,
}
if (!m().is_false(a_msb) && !m().is_true(b_msb)) {
mk_udiv_urem(sz, neg_a_bits.c_ptr(), b_bits, np_q, np_r);
mk_udiv_urem(sz, neg_a_bits.data(), b_bits, np_q, np_r);
}
else {
np_q.resize(sz, m().mk_false());
@ -592,7 +592,7 @@ void bit_blaster_tpl<Cfg>::mk_sdiv_srem_smod(unsigned sz, expr * const * a_bits,
}
if (!m().is_true(a_msb) && !m().is_false(b_msb)) {
mk_udiv_urem(sz, a_bits, neg_b_bits.c_ptr(), pn_q, pn_r);
mk_udiv_urem(sz, a_bits, neg_b_bits.data(), pn_q, pn_r);
}
else {
pn_q.resize(sz, m().mk_false());
@ -600,7 +600,7 @@ void bit_blaster_tpl<Cfg>::mk_sdiv_srem_smod(unsigned sz, expr * const * a_bits,
}
if (!m().is_false(a_msb) && !m().is_false(b_msb)) {
mk_udiv_urem(sz, neg_a_bits.c_ptr(), neg_b_bits.c_ptr(), nn_q, nn_r);
mk_udiv_urem(sz, neg_a_bits.data(), neg_b_bits.data(), nn_q, nn_r);
}
else {
nn_q.resize(sz, m().mk_false());
@ -615,19 +615,19 @@ void bit_blaster_tpl<Cfg>::mk_sdiv_srem_smod(unsigned sz, expr * const * a_bits,
expr_ref_vector & nn_out = nn_q;
if (!m().is_false(a_msb) && !m().is_true(b_msb))
mk_neg(sz, np_q.c_ptr(), np_out);
mk_neg(sz, np_q.data(), np_out);
else
np_out.resize(sz, m().mk_false());
if (!m().is_true(a_msb) && !m().is_false(b_msb))
mk_neg(sz, pn_q.c_ptr(), pn_out);
mk_neg(sz, pn_q.data(), pn_out);
else
pn_out.resize(sz, m().mk_false());
#define MK_MULTIPLEXER() \
mk_multiplexer(b_msb, sz, nn_out.c_ptr(), np_out.c_ptr(), ite1); \
mk_multiplexer(b_msb, sz, pn_out.c_ptr(), pp_out.c_ptr(), ite2); \
mk_multiplexer(a_msb, sz, ite1.c_ptr(), ite2.c_ptr(), out_bits)
mk_multiplexer(b_msb, sz, nn_out.data(), np_out.data(), ite1); \
mk_multiplexer(b_msb, sz, pn_out.data(), pp_out.data(), ite2); \
mk_multiplexer(a_msb, sz, ite1.data(), ite2.data(), out_bits)
MK_MULTIPLEXER();
}
@ -638,12 +638,12 @@ void bit_blaster_tpl<Cfg>::mk_sdiv_srem_smod(unsigned sz, expr * const * a_bits,
expr_ref_vector nn_out(m());
if (!m().is_false(a_msb) && !m().is_true(b_msb))
mk_neg(sz, np_r.c_ptr(), np_out);
mk_neg(sz, np_r.data(), np_out);
else
np_out.resize(sz, m().mk_false());
if (!m().is_false(a_msb) && !m().is_false(b_msb))
mk_neg(sz, nn_r.c_ptr(), nn_out);
mk_neg(sz, nn_r.data(), nn_out);
else
nn_out.resize(sz, m().mk_false());
MK_MULTIPLEXER();
@ -657,18 +657,18 @@ void bit_blaster_tpl<Cfg>::mk_sdiv_srem_smod(unsigned sz, expr * const * a_bits,
if (!m().is_false(a_msb) && !m().is_true(b_msb)) {
expr_ref cout(m());
mk_subtracter(sz, b_bits, np_r.c_ptr(), np_out, cout);
mk_subtracter(sz, b_bits, np_r.data(), np_out, cout);
}
else
np_out.resize(sz, m().mk_false());
if (!m().is_true(a_msb) && !m().is_false(b_msb))
mk_adder(sz, b_bits, pn_r.c_ptr(), pn_out);
mk_adder(sz, b_bits, pn_r.data(), pn_out);
else
pn_out.resize(sz, m().mk_false());
if (!m().is_false(a_msb) && !m().is_false(b_msb))
mk_neg(sz, nn_r.c_ptr(), nn_out);
mk_neg(sz, nn_r.data(), nn_out);
else
nn_out.resize(sz, m().mk_false());
@ -687,22 +687,22 @@ void bit_blaster_tpl<Cfg>::mk_sdiv(unsigned sz, expr * const * a_bits, expr * co
expr_ref_vector neg_b_bits(m());
mk_neg(sz, b_bits, neg_b_bits);
expr_ref_vector tmp(m());
mk_udiv(sz, a_bits, neg_b_bits.c_ptr(), tmp);
mk_neg(sz, tmp.c_ptr(), out_bits);
mk_udiv(sz, a_bits, neg_b_bits.data(), tmp);
mk_neg(sz, tmp.data(), out_bits);
}
else if (m().is_true(a_msb) && m().is_false(b_msb)) {
expr_ref_vector neg_a_bits(m());
mk_neg(sz, a_bits, neg_a_bits);
expr_ref_vector tmp(m());
mk_udiv(sz, neg_a_bits.c_ptr(), b_bits, tmp);
mk_neg(sz, tmp.c_ptr(), out_bits);
mk_udiv(sz, neg_a_bits.data(), b_bits, tmp);
mk_neg(sz, tmp.data(), out_bits);
}
else if (m().is_true(a_msb) && m().is_true(b_msb)) {
expr_ref_vector neg_a_bits(m());
mk_neg(sz, a_bits, neg_a_bits);
expr_ref_vector neg_b_bits(m());
mk_neg(sz, b_bits, neg_b_bits);
mk_udiv(sz, neg_a_bits.c_ptr(), neg_b_bits.c_ptr(), out_bits);
mk_udiv(sz, neg_a_bits.data(), neg_b_bits.data(), out_bits);
}
else {
#if 0
@ -715,12 +715,12 @@ void bit_blaster_tpl<Cfg>::mk_sdiv(unsigned sz, expr * const * a_bits, expr * co
mk_abs(sz, a_bits, abs_a_bits);
mk_abs(sz, b_bits, abs_b_bits);
expr_ref_vector udiv_bits(m());
mk_udiv(sz, abs_a_bits.c_ptr(), abs_b_bits.c_ptr(), udiv_bits);
mk_udiv(sz, abs_a_bits.data(), abs_b_bits.data(), udiv_bits);
expr_ref_vector neg_udiv_bits(m());
mk_neg(sz, udiv_bits.c_ptr(), neg_udiv_bits);
mk_neg(sz, udiv_bits.data(), neg_udiv_bits);
expr_ref c(m());
mk_iff(a_msb, b_msb, c);
mk_multiplexer(c, sz, udiv_bits.c_ptr(), neg_udiv_bits.c_ptr(), out_bits);
mk_multiplexer(c, sz, udiv_bits.data(), neg_udiv_bits.data(), out_bits);
#endif
}
}
@ -735,14 +735,14 @@ void bit_blaster_tpl<Cfg>::mk_srem(unsigned sz, expr * const * a_bits, expr * co
else if (m().is_false(a_msb) && m().is_true(b_msb)) {
expr_ref_vector neg_b_bits(m());
mk_neg(sz, b_bits, neg_b_bits);
mk_urem(sz, a_bits, neg_b_bits.c_ptr(), out_bits);
mk_urem(sz, a_bits, neg_b_bits.data(), out_bits);
}
else if (m().is_true(a_msb) && m().is_false(b_msb)) {
expr_ref_vector neg_a_bits(m());
mk_neg(sz, a_bits, neg_a_bits);
expr_ref_vector tmp(m());
mk_urem(sz, neg_a_bits.c_ptr(), b_bits, tmp);
mk_neg(sz, tmp.c_ptr(), out_bits);
mk_urem(sz, neg_a_bits.data(), b_bits, tmp);
mk_neg(sz, tmp.data(), out_bits);
}
else if (m().is_true(a_msb) && m().is_true(b_msb)) {
expr_ref_vector neg_a_bits(m());
@ -750,8 +750,8 @@ void bit_blaster_tpl<Cfg>::mk_srem(unsigned sz, expr * const * a_bits, expr * co
expr_ref_vector neg_b_bits(m());
mk_neg(sz, b_bits, neg_b_bits);
expr_ref_vector tmp(m());
mk_urem(sz, neg_a_bits.c_ptr(), neg_b_bits.c_ptr(), tmp);
mk_neg(sz, tmp.c_ptr(), out_bits);
mk_urem(sz, neg_a_bits.data(), neg_b_bits.data(), tmp);
mk_neg(sz, tmp.data(), out_bits);
}
else {
#if 0
@ -767,14 +767,14 @@ void bit_blaster_tpl<Cfg>::mk_srem(unsigned sz, expr * const * a_bits, expr * co
numeral n_b;
unsigned shift;
// a urem 2^n -> a & ((2^n)-1)
if (is_numeral(sz, abs_b_bits.c_ptr(), n_b) && n_b.is_power_of_two(shift)) {
mk_zero_extend(shift, abs_a_bits.c_ptr(), sz - shift, urem_bits);
if (is_numeral(sz, abs_b_bits.data(), n_b) && n_b.is_power_of_two(shift)) {
mk_zero_extend(shift, abs_a_bits.data(), sz - shift, urem_bits);
} else {
mk_urem(sz, abs_a_bits.c_ptr(), abs_b_bits.c_ptr(), urem_bits);
mk_urem(sz, abs_a_bits.data(), abs_b_bits.data(), urem_bits);
}
expr_ref_vector neg_urem_bits(m());
mk_neg(sz, urem_bits.c_ptr(), neg_urem_bits);
mk_multiplexer(a_msb, sz, neg_urem_bits.c_ptr(), urem_bits.c_ptr(), out_bits);
mk_neg(sz, urem_bits.data(), neg_urem_bits);
mk_multiplexer(a_msb, sz, neg_urem_bits.data(), urem_bits.data(), out_bits);
#endif
}
}
@ -816,17 +816,17 @@ void bit_blaster_tpl<Cfg>::mk_smod(unsigned sz, expr * const * a_bits, expr * co
mk_abs(sz, a_bits, abs_a_bits);
mk_abs(sz, b_bits, abs_b_bits);
expr_ref_vector u_bits(m());
mk_urem(sz, abs_a_bits.c_ptr(), abs_b_bits.c_ptr(), u_bits);
mk_urem(sz, abs_a_bits.data(), abs_b_bits.data(), u_bits);
expr_ref_vector neg_u_bits(m());
mk_neg(sz, u_bits.c_ptr(), neg_u_bits);
mk_neg(sz, u_bits.data(), neg_u_bits);
expr_ref_vector neg_u_add_b(m());
mk_adder(sz, neg_u_bits.c_ptr(), b_bits, neg_u_add_b);
mk_adder(sz, neg_u_bits.data(), b_bits, neg_u_add_b);
expr_ref_vector u_add_b(m());
mk_adder(sz, u_bits.c_ptr(), b_bits, u_add_b);
mk_adder(sz, u_bits.data(), b_bits, u_add_b);
expr_ref_vector zero(m());
num2bits(numeral(0), sz, zero);
expr_ref u_eq_0(m());
mk_eq(sz, u_bits.c_ptr(), zero.c_ptr(), u_eq_0);
mk_eq(sz, u_bits.data(), zero.data(), u_eq_0);
expr_ref_vector & pp_bits = u_bits; // pos & pos case
expr_ref_vector & pn_bits = u_add_b; // pos & neg case
@ -836,10 +836,10 @@ void bit_blaster_tpl<Cfg>::mk_smod(unsigned sz, expr * const * a_bits, expr * co
expr_ref_vector ite1(m());
expr_ref_vector ite2(m());
expr_ref_vector body(m());
mk_multiplexer(b_msb, sz, nn_bits.c_ptr(), np_bits.c_ptr(), ite1);
mk_multiplexer(b_msb, sz, pn_bits.c_ptr(), pp_bits.c_ptr(), ite2);
mk_multiplexer(a_msb, sz, ite1.c_ptr(), ite2.c_ptr(), body);
mk_multiplexer(u_eq_0, sz, u_bits.c_ptr(), body.c_ptr(), out_bits);
mk_multiplexer(b_msb, sz, nn_bits.data(), np_bits.data(), ite1);
mk_multiplexer(b_msb, sz, pn_bits.data(), pp_bits.data(), ite2);
mk_multiplexer(a_msb, sz, ite1.data(), ite2.data(), body);
mk_multiplexer(u_eq_0, sz, u_bits.data(), body.data(), out_bits);
}
@ -850,7 +850,7 @@ void bit_blaster_tpl<Cfg>::mk_eq(unsigned sz, expr * const * a_bits, expr * cons
mk_iff(a_bits[i], b_bits[i], out);
out_bits.push_back(out);
}
mk_and(out_bits.size(), out_bits.c_ptr(), out);
mk_and(out_bits.size(), out_bits.data(), out);
}
template<typename Cfg>
@ -910,7 +910,7 @@ void bit_blaster_tpl<Cfg>::mk_is_eq(unsigned sz, expr * const * a_bits, unsigned
}
n = n / 2;
}
mk_and(out_bits.size(), out_bits.c_ptr(), out);
mk_and(out_bits.size(), out_bits.data(), out);
}
/**
@ -1078,8 +1078,8 @@ void bit_blaster_tpl<Cfg>::mk_ext_rotate_left_right(unsigned sz, expr * const *
expr_ref_vector eqs(m());
numeral sz_numeral(sz);
num2bits(sz_numeral, sz, sz_bits);
mk_urem(sz, b_bits, sz_bits.c_ptr(), masked_b_bits);
mk_eqs(sz, masked_b_bits.c_ptr(), eqs);
mk_urem(sz, b_bits, sz_bits.data(), masked_b_bits);
mk_eqs(sz, masked_b_bits.data(), eqs);
for (unsigned i = 0; i < sz; i++) {
checkpoint();
expr_ref out(m());
@ -1237,8 +1237,8 @@ void bit_blaster_tpl<Cfg>::mk_const_case_multiplier(bool is_a, unsigned i, unsig
else {
numeral n_a, n_b;
SASSERT(i == sz && !is_a);
VERIFY(is_numeral(sz, a_bits.c_ptr(), n_a));
VERIFY(is_numeral(sz, b_bits.c_ptr(), n_b));
VERIFY(is_numeral(sz, a_bits.data(), n_a));
VERIFY(is_numeral(sz, b_bits.data(), n_b));
n_a *= n_b;
num2bits(n_a, sz, out_bits);
}
@ -1274,12 +1274,12 @@ bool bit_blaster_tpl<Cfg>::mk_const_multiplier(unsigned sz, expr * const * a_bit
tmp.reset();
if (now && !last) {
mk_adder(sz - i, out_bits.c_ptr() + i, minus_b_bits.c_ptr(), tmp);
mk_adder(sz - i, out_bits.data() + i, minus_b_bits.data(), tmp);
for (unsigned j = 0; j < (sz - i); j++)
out_bits.set(i+j, tmp.get(j)); // do not use [], it does not work on Linux.
}
else if (!now && last) {
mk_adder(sz - i, out_bits.c_ptr() + i, b_bits, tmp);
mk_adder(sz - i, out_bits.data() + i, b_bits, tmp);
for (unsigned j = 0; j < (sz - i); j++)
out_bits.set(i+j, tmp.get(j)); // do not use [], it does not work on Linux.
}

14
src/ast/rewriter/bool_rewriter.cpp
View file

@ -80,7 +80,7 @@ void bool_rewriter::mk_and_as_or(unsigned num_args, expr * const * args, expr_re
new_args.push_back(tmp);
}
expr_ref tmp(m());
mk_or(new_args.size(), new_args.c_ptr(), tmp);
mk_or(new_args.size(), new_args.data(), tmp);
mk_not(tmp, result);
}
@ -173,7 +173,7 @@ br_status bool_rewriter::mk_flat_and_core(unsigned num_args, expr * const * args
flat_args.push_back(arg);
}
}
if (mk_nflat_and_core(flat_args.size(), flat_args.c_ptr(), result) == BR_FAILED)
if (mk_nflat_and_core(flat_args.size(), flat_args.data(), result) == BR_FAILED)
result = m().mk_and(flat_args);
return BR_DONE;
}
@ -245,13 +245,13 @@ br_status bool_rewriter::mk_nflat_or_core(unsigned num_args, expr * const * args
return BR_DONE;
default:
if (m_local_ctx && m_local_ctx_cost <= m_local_ctx_limit) {
if (local_ctx_simp(sz, buffer.c_ptr(), result))
if (local_ctx_simp(sz, buffer.data(), result))
return BR_DONE;
}
if (s) {
ast_lt lt;
std::sort(buffer.begin(), buffer.end(), lt);
result = m().mk_or(sz, buffer.c_ptr());
result = m().mk_or(sz, buffer.data());
return BR_DONE;
}
return BR_FAILED;
@ -285,7 +285,7 @@ br_status bool_rewriter::mk_flat_or_core(unsigned num_args, expr * const * args,
prev = arg;
}
}
if (mk_nflat_or_core(flat_args.size(), flat_args.c_ptr(), result) == BR_FAILED) {
if (mk_nflat_or_core(flat_args.size(), flat_args.data(), result) == BR_FAILED) {
if (!ordered) {
ast_lt lt;
std::sort(flat_args.begin(), flat_args.end(), lt);
@ -595,7 +595,7 @@ bool bool_rewriter::local_ctx_simp(unsigned num_args, expr * const * args, expr_
return false; // didn't simplify
}
// preserve the original order...
std::reverse(new_args.c_ptr(), new_args.c_ptr() + new_args.size());
std::reverse(new_args.data(), new_args.data() + new_args.size());
modified = false;
forward = true;
}
@ -604,7 +604,7 @@ bool bool_rewriter::local_ctx_simp(unsigned num_args, expr * const * args, expr_
old_args.reset();
old_args.swap(new_args);
SASSERT(new_args.empty());
args = old_args.c_ptr();
args = old_args.data();
num_args = old_args.size();
}
}

4
src/ast/rewriter/bool_rewriter.h
View file

@ -161,12 +161,12 @@ public:
}
expr_ref mk_or(expr_ref_vector const& args) {
expr_ref result(m());
mk_or(args.size(), args.c_ptr(), result);
mk_or(args.size(), args.data(), result);
return result;
}
expr_ref mk_and(expr_ref_vector const& args) {
expr_ref result(m());
mk_and(args.size(), args.c_ptr(), result);
mk_and(args.size(), args.data(), result);
return result;
}

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

@ -323,8 +323,8 @@ br_status bv_bounds::rewrite(unsigned limit, func_decl * f, unsigned num, expr *
switch (nargs.size()) {
case 0: result = negated ? m_m.mk_false() : m_m.mk_true(); return BR_DONE;
case 1: result = nargs.get(0); return BR_DONE;
default: result = negated ? m_m.mk_or(nargs.size(), nargs.c_ptr())
: m_m.mk_and(nargs.size(), nargs.c_ptr());
default: result = negated ? m_m.mk_or(nargs.size(), nargs.data())
: m_m.mk_and(nargs.size(), nargs.data());
return BR_DONE;
}
}

12
src/ast/rewriter/bv_elim.cpp
View file

@ -58,7 +58,7 @@ bool bv_elim_cfg::reduce_quantifier(quantifier * q,
_sorts.push_back(m.mk_bool_sort());
_names.push_back(symbol(new_name.str()));
}
bv = m.mk_app(bfid, OP_MKBV, 0, nullptr, args.size(), args.c_ptr());
bv = m.mk_app(bfid, OP_MKBV, 0, nullptr, args.size(), args.data());
_subst_map.push_back(bv.get());
}
else {
@ -84,7 +84,7 @@ bool bv_elim_cfg::reduce_quantifier(quantifier * q,
subst_map.push_back(_subst_map[i]);
}
expr* const* sub = subst_map.c_ptr();
expr* const* sub = subst_map.data();
unsigned sub_size = subst_map.size();
new_body = subst(old_body, sub_size, sub);
@ -98,14 +98,14 @@ bool bv_elim_cfg::reduce_quantifier(quantifier * q,
result = m.mk_quantifier(forall_k,
names.size(),
sorts.c_ptr(),
names.c_ptr(),
sorts.data(),
names.data(),
new_body.get(),
q->get_weight(),
q->get_qid(),
q->get_skid(),
pats.size(), pats.c_ptr(),
no_pats.size(), no_pats.c_ptr());
pats.size(), pats.data(),
no_pats.size(), no_pats.data());
result_pr = m.mk_rewrite(q, result);
return true;
}

56
src/ast/rewriter/bv_rewriter.cpp
View file

@ -374,7 +374,7 @@ br_status bv_rewriter::rw_leq_concats(bool is_signed, expr * _a, expr * _b, expr
ptr_buffer<expr> new_args;
new_args.push_back(mk_numeral(af, af_sz - sz_min));
for (unsigned i = 1; i < numa; ++i) new_args.push_back(a->get_arg(i));
new_a = concat(new_args.size(), new_args.c_ptr());
new_a = concat(new_args.size(), new_args.data());
} else {
new_a = concat(numa - 1, a->get_args() + 1);
}
@ -382,7 +382,7 @@ br_status bv_rewriter::rw_leq_concats(bool is_signed, expr * _a, expr * _b, expr
ptr_buffer<expr> new_args;
new_args.push_back(mk_numeral(bf, bf_sz - sz_min));
for (unsigned i = 1; i < numb; ++i) new_args.push_back(b->get_arg(i));
new_b = concat(new_args.size(), new_args.c_ptr());
new_b = concat(new_args.size(), new_args.data());
} else {
new_b = concat(numb - 1, b->get_args() + 1);
}
@ -659,7 +659,7 @@ unsigned bv_rewriter::propagate_extract(unsigned high, expr * arg, expr_ref & re
new_concat_args.push_back(new_first);
for (unsigned j = 1; j < conc_num; ++j)
new_concat_args.push_back(to_app(curr)->get_arg(j));
new_arg = m_util.mk_concat(new_concat_args.size(), new_concat_args.c_ptr());
new_arg = m_util.mk_concat(new_concat_args.size(), new_concat_args.data());
} else {
// remove first element of concat
expr * const * const old_conc_args = to_app(curr)->get_args();
@ -675,7 +675,7 @@ unsigned bv_rewriter::propagate_extract(unsigned high, expr * arg, expr_ref & re
}
if (new_arg) new_args.push_back(new_arg);
}
result = m().mk_app(get_fid(), a->get_decl()->get_decl_kind(), new_args.size(), new_args.c_ptr());
result = m().mk_app(get_fid(), a->get_decl()->get_decl_kind(), new_args.size(), new_args.data());
SASSERT(m_util.is_bv(result));
return removable;
}
@ -755,11 +755,11 @@ br_status bv_rewriter::mk_extract(unsigned high, unsigned low, expr * arg, expr_
}
if (idx == low) {
new_args.push_back(curr);
result = m_util.mk_concat(new_args.size(), new_args.c_ptr());
result = m_util.mk_concat(new_args.size(), new_args.data());
return used_extract ? BR_REWRITE2 : BR_DONE;
}
new_args.push_back(m_mk_extract(curr_sz - 1, low - idx, curr));
result = m_util.mk_concat(new_args.size(), new_args.c_ptr());
result = m_util.mk_concat(new_args.size(), new_args.data());
return BR_REWRITE2;
}
UNREACHABLE();
@ -779,7 +779,7 @@ br_status bv_rewriter::mk_extract(unsigned high, unsigned low, expr * arg, expr_
expr * curr = to_app(arg)->get_arg(i);
new_args.push_back(m_mk_extract(high, low, curr));
}
result = m().mk_app(get_fid(), to_app(arg)->get_decl()->get_decl_kind(), new_args.size(), new_args.c_ptr());
result = m().mk_app(get_fid(), to_app(arg)->get_decl()->get_decl_kind(), new_args.size(), new_args.data());
return BR_REWRITE2;
}
@ -1415,19 +1415,19 @@ br_status bv_rewriter::mk_bv2int(expr * arg, expr_ref & result) {
args[i] = std::move(tmp);
sz += get_bv_size(to_app(arg)->get_arg(i));
}
result = m_autil.mk_add(args.size(), args.c_ptr());
result = m_autil.mk_add(args.size(), args.data());
return BR_REWRITE2;
}
if (is_mul_no_overflow(arg)) {
expr_ref_vector args(m());
for (expr* x : *to_app(arg)) args.push_back(m_util.mk_bv2int(x));
result = m_autil.mk_mul(args.size(), args.c_ptr());
result = m_autil.mk_mul(args.size(), args.data());
return BR_REWRITE2;
}
if (is_add_no_overflow(arg)) {
expr_ref_vector args(m());
for (expr* x : *to_app(arg)) args.push_back(m_util.mk_bv2int(x));
result = m_autil.mk_add(args.size(), args.c_ptr());
result = m_autil.mk_add(args.size(), args.data());
return BR_REWRITE2;
}
@ -1528,7 +1528,7 @@ br_status bv_rewriter::mk_concat(unsigned num_args, expr * const * args, expr_re
result = new_args.back();
return fused_extract ? BR_REWRITE1 : BR_DONE;
}
result = m_util.mk_concat(new_args.size(), new_args.c_ptr());
result = m_util.mk_concat(new_args.size(), new_args.data());
if (fused_extract)
return BR_REWRITE2;
else if (expanded)
@ -1574,7 +1574,7 @@ br_status bv_rewriter::mk_sign_extend(unsigned n, expr * arg, expr_ref & result)
for (unsigned i = 0; i < n; i++)
args.push_back(sign);
args.push_back(arg);
result = m_util.mk_concat(args.size(), args.c_ptr());
result = m_util.mk_concat(args.size(), args.data());
return BR_REWRITE2;
}
@ -1589,7 +1589,7 @@ br_status bv_rewriter::mk_repeat(unsigned n, expr * arg, expr_ref & result) {
ptr_buffer<expr> args;
for (unsigned i = 0; i < n; i++)
args.push_back(arg);
result = m_util.mk_concat(args.size(), args.c_ptr());
result = m_util.mk_concat(args.size(), args.data());
return BR_REWRITE1;
}
@ -1617,7 +1617,7 @@ br_status bv_rewriter::mk_bv_or(unsigned num, expr * const * args, expr_ref & re
if (flat_args.size() != num) {
flattened = true;
num = flat_args.size();
args = flat_args.c_ptr();
args = flat_args.data();
}
}
@ -1696,7 +1696,7 @@ br_status bv_rewriter::mk_bv_or(unsigned num, expr * const * args, expr_ref & re
if (j != high)
non_zero_args.push_back(m_mk_extract(high, j+1, concat1));
}
result = m_util.mk_concat(non_zero_args.size(), non_zero_args.c_ptr());
result = m_util.mk_concat(non_zero_args.size(), non_zero_args.data());
return BR_REWRITE2;
}
}
@ -1732,7 +1732,7 @@ br_status bv_rewriter::mk_bv_or(unsigned num, expr * const * args, expr_ref & re
}
}
std::reverse(exs.begin(), exs.end());
result = m_util.mk_concat(exs.size(), exs.c_ptr());
result = m_util.mk_concat(exs.size(), exs.data());
TRACE("mask_bug",
tout << "(assert (distinct (bvor (_ bv" << old_v1 << " " << sz << ")\n" << mk_ismt2_pp(t, m()) << ")\n";
tout << mk_ismt2_pp(result, m()) << "))\n";);
@ -1757,10 +1757,10 @@ br_status bv_rewriter::mk_bv_or(unsigned num, expr * const * args, expr_ref & re
default:
if (m_bv_sort_ac)
std::sort(new_args.begin(), new_args.end(), ast_to_lt());
if (distribute_concat(OP_BOR, new_args.size(), new_args.c_ptr(), result)) {
if (distribute_concat(OP_BOR, new_args.size(), new_args.data(), result)) {
return BR_REWRITE3;
}
result = m_util.mk_bv_or(new_args.size(), new_args.c_ptr());
result = m_util.mk_bv_or(new_args.size(), new_args.data());
return BR_DONE;
}
}
@ -1789,7 +1789,7 @@ br_status bv_rewriter::mk_bv_xor(unsigned num, expr * const * args, expr_ref & r
if (flat_args.size() != num) {
flattened = true;
num = flat_args.size();
args = flat_args.c_ptr();
args = flat_args.data();
}
}
@ -1877,11 +1877,11 @@ br_status bv_rewriter::mk_bv_xor(unsigned num, expr * const * args, expr_ref & r
low = i;
}
}
std::reverse(exs.c_ptr(), exs.c_ptr() + exs.size());
std::reverse(exs.data(), exs.data() + exs.size());
if (exs.size() == 1)
result = exs[0];
else
result = m_util.mk_concat(exs.size(), exs.c_ptr());
result = m_util.mk_concat(exs.size(), exs.data());
return BR_REWRITE3;
}
@ -1933,10 +1933,10 @@ br_status bv_rewriter::mk_bv_xor(unsigned num, expr * const * args, expr_ref & r
default:
if (m_bv_sort_ac)
std::sort(new_args.begin(), new_args.end(), ast_to_lt());
if (distribute_concat(OP_BXOR, new_args.size(), new_args.c_ptr(), result)) {
if (distribute_concat(OP_BXOR, new_args.size(), new_args.data(), result)) {
return BR_REWRITE3;
}
result = m_util.mk_bv_xor(new_args.size(), new_args.c_ptr());
result = m_util.mk_bv_xor(new_args.size(), new_args.data());
return BR_DONE;
}
}
@ -1953,8 +1953,8 @@ bool bv_rewriter::distribute_concat(decl_kind k, unsigned n, expr* const* args,
args1.push_back(m_mk_extract(sz2 - 1, sz2 - sz1, args[j]));
args2.push_back(m_mk_extract(sz2 - sz1 - 1, 0, args[j]));
}
expr* arg1 = m().mk_app(get_fid(), k, args1.size(), args1.c_ptr());
expr* arg2 = m().mk_app(get_fid(), k, args2.size(), args2.c_ptr());
expr* arg1 = m().mk_app(get_fid(), k, args1.size(), args1.data());
expr* arg2 = m().mk_app(get_fid(), k, args2.size(), args2.data());
result = m_util.mk_concat(arg1, arg2);
return true;
}
@ -1981,7 +1981,7 @@ br_status bv_rewriter::mk_bv_not(expr * arg, expr_ref & result) {
for (expr* a : *to_app(arg)) {
new_args.push_back(m_util.mk_bv_not(a));
}
result = m_util.mk_concat(new_args.size(), new_args.c_ptr());
result = m_util.mk_concat(new_args.size(), new_args.data());
return BR_REWRITE2;
}
@ -2017,7 +2017,7 @@ br_status bv_rewriter::mk_bv_and(unsigned num, expr * const * args, expr_ref & r
new_args.push_back(m_util.mk_bv_not(args[i]));
}
SASSERT(num == new_args.size());
result = m_util.mk_bv_not(m_util.mk_bv_or(new_args.size(), new_args.c_ptr()));
result = m_util.mk_bv_not(m_util.mk_bv_or(new_args.size(), new_args.data()));
return BR_REWRITE3;
}
@ -2026,7 +2026,7 @@ br_status bv_rewriter::mk_bv_nand(unsigned num, expr * const * args, expr_ref &
for (unsigned i = 0; i < num; i++) {
new_args.push_back(m_util.mk_bv_not(args[i]));
}
result = m_util.mk_bv_or(new_args.size(), new_args.c_ptr());
result = m_util.mk_bv_or(new_args.size(), new_args.data());
return BR_REWRITE2;
}

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

@ -88,7 +88,7 @@ br_status datatype_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr
new_args.push_back(a->get_arg(i));
}
}
result = m().mk_app(c_decl, num, new_args.c_ptr());
result = m().mk_app(c_decl, num, new_args.data());
return BR_DONE;
}
default:
@ -137,6 +137,6 @@ br_status datatype_rewriter::mk_eq_core(expr * lhs, expr * rhs, expr_ref & resul
for (unsigned i = 0; i < num; ++i) {
eqs.push_back(m().mk_eq(to_app(lhs)->get_arg(i), to_app(rhs)->get_arg(i)));
}
result = m().mk_and(eqs.size(), eqs.c_ptr());
result = m().mk_and(eqs.size(), eqs.data());
return BR_REWRITE2;
}

14
src/ast/rewriter/der.cpp
View file

@ -319,7 +319,7 @@ void der::create_substitution(unsigned sz) {
expr_ref cur(m_map.get(m_order[i]), m);
// do all the previous substitutions before inserting
expr_ref r = m_subst(cur, m_subst_map.size(), m_subst_map.c_ptr());
expr_ref r = m_subst(cur, m_subst_map.size(), m_subst_map.data());
unsigned inx = sz - m_order[i]- 1;
SASSERT(m_subst_map[inx]==0);
@ -343,22 +343,22 @@ void der::apply_substitution(quantifier * q, expr_ref & r) {
unsigned sz = m_new_args.size();
expr_ref t(m);
t = (sz == 1) ? m_new_args[0] : m.mk_or(sz, m_new_args.c_ptr());
expr_ref new_e = m_subst(t, m_subst_map.size(), m_subst_map.c_ptr());
t = (sz == 1) ? m_new_args[0] : m.mk_or(sz, m_new_args.data());
expr_ref new_e = m_subst(t, m_subst_map.size(), m_subst_map.data());
// don't forget to update the quantifier patterns
expr_ref_buffer new_patterns(m);
expr_ref_buffer new_no_patterns(m);
for (unsigned j = 0; j < q->get_num_patterns(); j++) {
new_patterns.push_back(m_subst(q->get_pattern(j), m_subst_map.size(), m_subst_map.c_ptr()));
new_patterns.push_back(m_subst(q->get_pattern(j), m_subst_map.size(), m_subst_map.data()));
}
for (unsigned j = 0; j < q->get_num_no_patterns(); j++) {
new_no_patterns.push_back(m_subst(q->get_no_pattern(j), m_subst_map.size(), m_subst_map.c_ptr()));
new_no_patterns.push_back(m_subst(q->get_no_pattern(j), m_subst_map.size(), m_subst_map.data()));
}
r = m.update_quantifier(q, new_patterns.size(), new_patterns.c_ptr(),
new_no_patterns.size(), new_no_patterns.c_ptr(), new_e);
r = m.update_quantifier(q, new_patterns.size(), new_patterns.data(),
new_no_patterns.size(), new_no_patterns.data(), new_e);
}

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

@ -92,7 +92,7 @@ void distribute_forall::reduce1_app(app * a) {
}
if (reduced) {
na = m_manager.mk_app(a->get_decl(), num_args, m_new_args.c_ptr());
na = m_manager.mk_app(a->get_decl(), num_args, m_new_args.data());
}
cache_result(a, na);
@ -131,7 +131,7 @@ void distribute_forall::reduce1_quantifier(quantifier * q) {
expr_ref result(m_manager);
// m_bsimp.mk_and actually constructs a (not (or ...)) formula,
// it will also apply basic simplifications.
br.mk_and(new_args.size(), new_args.c_ptr(), result);
br.mk_and(new_args.size(), new_args.data(), result);
cache_result(q, result);
}
else {

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

@ -189,7 +189,7 @@ bool elim_bounds_cfg::reduce_quantifier(quantifier * q,
new_body = atoms[0];
break;
default:
new_body = m.mk_or(atoms.size(), atoms.c_ptr());
new_body = m.mk_or(atoms.size(), atoms.data());
break;
}
quantifier_ref new_q(m);

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

@ -94,7 +94,7 @@ struct enum2bv_rewriter::imp {
return BR_DONE;
}
else if (m.is_distinct(f) && reduce_args(num, args, _args)) {
result = m.mk_distinct(_args.size(), _args.c_ptr());
result = m.mk_distinct(_args.size(), _args.data());
return BR_DONE;
}
else if (m_dt.is_recognizer(f) && reduce_arg(args[0], a0)) {
@ -229,7 +229,7 @@ struct enum2bv_rewriter::imp {
break;
}
}
result = m.mk_quantifier(q->get_kind(), q->get_num_decls(), m_sorts.c_ptr(), q->get_decl_names(), new_body_ref,
result = m.mk_quantifier(q->get_kind(), q->get_num_decls(), m_sorts.data(), q->get_decl_names(), new_body_ref,
q->get_weight(), q->get_qid(), q->get_skid(),
q->get_num_patterns(), new_patterns,
q->get_num_no_patterns(), new_no_patterns);

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

@ -159,7 +159,7 @@ void expr_safe_replace::operator()(expr* e, expr_ref& res) {
}
replace(q->get_expr(), new_body);
}
b = m.update_quantifier(q, pats.size(), pats.c_ptr(), nopats.size(), nopats.c_ptr(), new_body);
b = m.update_quantifier(q, pats.size(), pats.data(), nopats.size(), nopats.data(), new_body);
m_refs.push_back(b);
cached = b;
m_todo.pop_back();

12
src/ast/rewriter/factor_rewriter.cpp
View file

@ -62,7 +62,7 @@ br_status factor_rewriter::mk_eq(expr * arg1, expr * arg2, expr_ref & result) {
expr* e = it->m_key;
eqs.push_back(m().mk_eq(e, a().mk_numeral(rational(0), e->get_sort())));
}
result = m().mk_or(eqs.size(), eqs.c_ptr());
result = m().mk_or(eqs.size(), eqs.data());
return BR_DONE;
}
@ -86,7 +86,7 @@ br_status factor_rewriter::mk_le(expr * arg1, expr * arg2, expr_ref & result) {
expr_ref_vector eqs(m());
mk_is_negative(neg, eqs);
eqs.push_back(neg);
result = m().mk_or(eqs.size(), eqs.c_ptr());
result = m().mk_or(eqs.size(), eqs.data());
TRACE("factor_rewriter",
tout << mk_pp(arg1, m()) << " <= " << mk_pp(arg2, m()) << "\n";
tout << mk_pp(result.get(), m()) << "\n";);
@ -115,7 +115,7 @@ br_status factor_rewriter::mk_lt(expr * arg1, expr * arg2, expr_ref & result) {
eqs[i] = m().mk_not(eqs[i].get());
}
eqs.push_back(neg);
result = m().mk_and(eqs.size(), eqs.c_ptr());
result = m().mk_and(eqs.size(), eqs.data());
TRACE("factor_rewriter", tout << mk_pp(result.get(), m()) << "\n";);
return BR_DONE;
}
@ -254,7 +254,7 @@ bool factor_rewriter::extract_factors() {
SASSERT(!m_muls.empty());
if (m_muls.size() == 1) {
if (m_muls[0].size() > 1) {
m_factors.append(m_muls[0].size(), m_muls[0].c_ptr());
m_factors.append(m_muls[0].size(), m_muls[0].data());
if (!m_adds[0].second) {
bool found_numeral = false;
sort* s = m_muls[0][0]->get_sort();
@ -311,7 +311,7 @@ bool factor_rewriter::extract_factors() {
e = m_muls[i][0];
break;
default:
e = a().mk_mul(m_muls[i].size(), m_muls[i].c_ptr());
e = a().mk_mul(m_muls[i].size(), m_muls[i].data());
break;
}
if (!m_adds[i].second) {
@ -326,7 +326,7 @@ bool factor_rewriter::extract_factors() {
m_factors.push_back(trail[0].get());
break;
default:
m_factors.push_back(a().mk_add(trail.size(), trail.c_ptr()));
m_factors.push_back(a().mk_add(trail.size(), trail.data()));
break;
}
TRACE("factor_rewriter",

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

@ -51,7 +51,7 @@ expr_ref func_decl_replace::operator()(expr* e) {
}
if (m_args.size() == n) {
if (arg_differs) {
b = m.mk_app(c->get_decl(), m_args.size(), m_args.c_ptr());
b = m.mk_app(c->get_decl(), m_args.size(), m_args.data());
m_refs.push_back(b);
SASSERT(a->get_sort() == b->get_sort());
} else {
@ -59,7 +59,7 @@ expr_ref func_decl_replace::operator()(expr* e) {
}
func_decl* f = nullptr;
if (m_subst.find(c->get_decl(), f)) {
b = m.mk_app(f, m_args.size(), m_args.c_ptr());
b = m.mk_app(f, m_args.size(), m_args.data());
m_refs.push_back(b);
}
m_cache.insert(a, b);

8
src/ast/rewriter/inj_axiom.cpp
View file

@ -107,7 +107,7 @@ bool simplify_inj_axiom(ast_manager & m, quantifier * q, expr_ref & result) {
}
}
SASSERT(var != 0);
app * f = m.mk_app(decl, f_args.size(), f_args.c_ptr());
app * f = m.mk_app(decl, f_args.size(), f_args.data());
ptr_vector<sort> domain;
inv_vars.push_back(f);
@ -115,9 +115,9 @@ bool simplify_inj_axiom(ast_manager & m, quantifier * q, expr_ref & result) {
domain.push_back(inv_vars[i]->get_sort());
}
sort * d = decl->get_domain(idx);
func_decl * inv_decl = m.mk_fresh_func_decl("inj", domain.size(), domain.c_ptr(), d);
func_decl * inv_decl = m.mk_fresh_func_decl("inj", domain.size(), domain.data(), d);
expr * proj = m.mk_app(inv_decl, inv_vars.size(), inv_vars.c_ptr());
expr * proj = m.mk_app(inv_decl, inv_vars.size(), inv_vars.data());
expr * eq = m.mk_eq(proj, var);
expr * p = m.mk_pattern(f);
@ -125,7 +125,7 @@ bool simplify_inj_axiom(ast_manager & m, quantifier * q, expr_ref & result) {
// Remark: the sort of the var 0 must be in the last position.
std::reverse(decls.begin(), decls.end());
result = m.mk_forall(decls.size(), decls.c_ptr(), names.c_ptr(), eq,
result = m.mk_forall(decls.size(), decls.data(), names.data(), eq,
0, symbol(), symbol(), 1, &p);
TRACE("inj_axiom", tout << "new axiom:\n" << mk_pp(result, m) << "\n";);
SASSERT(is_well_sorted(m, result));

18
src/ast/rewriter/pb2bv_rewriter.cpp
View file

@ -156,7 +156,7 @@ struct pb2bv_rewriter::imp {
//sort_args();
gcd_reduce<is_le>(m_coeffs, k);
unsigned sz = m_args.size();
expr * const* args = m_args.c_ptr();
expr * const* args = m_args.data();
TRACE("pb",
for (unsigned i = 0; i < sz; ++i) {
tout << m_coeffs[i] << "*" << mk_pp(args[i], m) << " ";
@ -277,7 +277,7 @@ struct pb2bv_rewriter::imp {
rational bound;
flip(sz, args, args1, _k, bound);
if (bound.get_unsigned() < k) {
return mk_ge_tot(sz, args1.c_ptr(), bound, result);
return mk_ge_tot(sz, args1.data(), bound, result);
}
if (k > 20) {
return false;
@ -295,7 +295,7 @@ struct pb2bv_rewriter::imp {
rational bound;
flip(sz, args, args1, _k, bound);
if (bound.get_unsigned() < k) {
return mk_le_tot(sz, args1.c_ptr(), bound, result);
return mk_le_tot(sz, args1.data(), bound, result);
}
if (k > 20) {
return false;
@ -519,7 +519,7 @@ struct pb2bv_rewriter::imp {
tout << "\n";
);
ptr_vector<expr> out;
m_sort.sorting(carry.size(), carry.c_ptr(), out);
m_sort.sorting(carry.size(), carry.data(), out);
expr_ref gt = mod_ge(out, B, d_i + 1);
expr_ref ge = mod_ge(out, B, d_i);
@ -557,13 +557,13 @@ struct pb2bv_rewriter::imp {
}
switch (is_le) {
case l_true:
result = m_sort.le(k.get_unsigned(), coeffs.size(), coeffs.c_ptr(), m_args.c_ptr());
result = m_sort.le(k.get_unsigned(), coeffs.size(), coeffs.data(), m_args.data());
break;
case l_false:
result = m_sort.ge(k.get_unsigned(), coeffs.size(), coeffs.c_ptr(), m_args.c_ptr());
result = m_sort.ge(k.get_unsigned(), coeffs.size(), coeffs.data(), m_args.data());
break;
case l_undef:
result = m_sort.eq(k.get_unsigned(), coeffs.size(), coeffs.c_ptr(), m_args.c_ptr());
result = m_sort.eq(k.get_unsigned(), coeffs.size(), coeffs.data(), m_args.data());
break;
}
return result;
@ -588,7 +588,7 @@ struct pb2bv_rewriter::imp {
expr_ref mk_seg_le(rational const& k) {
sort_args();
unsigned sz = m_args.size();
expr* const* args = m_args.c_ptr();
expr* const* args = m_args.data();
// Create sorted entries.
vector<ptr_vector<expr>> outs;
@ -661,7 +661,7 @@ struct pb2bv_rewriter::imp {
args1.push_back(mk_not(args[i]));
bound += m_coeffs[i];
}
return mk_ge(sz, args1.c_ptr(), bound, result);
return mk_ge(sz, args1.data(), bound, result);
}
bool mk_eq(unsigned sz, expr * const* args, rational const& k, expr_ref& result) {

18
src/ast/rewriter/pb_rewriter.cpp
View file

@ -96,7 +96,7 @@ expr_ref pb_rewriter::translate_pb2lia(obj_map<expr,expr*>& vars, expr* fml) {
tmp = a.mk_numeral(rational(0), true);
}
else {
tmp = a.mk_add(es.size(), es.c_ptr());
tmp = a.mk_add(es.size(), es.data());
}
if (util.is_at_most_k(fml)) {
result = a.mk_le(tmp, a.mk_numeral(util.get_k(fml), false));
@ -113,7 +113,7 @@ expr_ref pb_rewriter::translate_pb2lia(obj_map<expr,expr*>& vars, expr* fml) {
tmp = a.mk_numeral(rational(0), true);
}
else {
tmp = a.mk_add(es.size(), es.c_ptr());
tmp = a.mk_add(es.size(), es.data());
}
rational k = util.get_k(fml);
if (util.is_le(fml)) {
@ -172,7 +172,7 @@ expr_ref pb_rewriter::mk_validate_rewrite(app_ref& e1, app_ref& e2) {
expr_ref fml2 = translate_pb2lia(vars, e2);
tmp = m.mk_not(m.mk_eq(fml1, fml2));
fmls.push_back(tmp);
tmp = m.mk_and(fmls.size(), fmls.c_ptr());
tmp = m.mk_and(fmls.size(), fmls.data());
return tmp;
}
@ -267,23 +267,23 @@ br_status pb_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * cons
result = k.is_zero()?m.mk_true():m.mk_false();
}
else if (k.is_zero()) {
result = mk_not(m, mk_or(m, sz, m_args.c_ptr()));
result = mk_not(m, mk_or(m, sz, m_args.data()));
}
else if (k.is_one() && all_unit && m_args.size() == 1) {
result = m_args.back();
}
else if (slack == k) {
result = mk_and(m, sz, m_args.c_ptr());
result = mk_and(m, sz, m_args.data());
}
else {
result = m_util.mk_eq(sz, m_coeffs.c_ptr(), m_args.c_ptr(), k);
result = m_util.mk_eq(sz, m_coeffs.data(), m_args.data(), k);
}
}
else if (all_unit && k.is_one() && sz < 10) {
result = mk_or(m, sz, m_args.c_ptr());
result = mk_or(m, sz, m_args.data());
}
else if (all_unit && k == rational(sz)) {
result = mk_and(m, sz, m_args.c_ptr());
result = mk_and(m, sz, m_args.data());
}
else {
expr_ref_vector conj(m), disj(m);
@ -309,7 +309,7 @@ br_status pb_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * cons
m_coeffs.shrink(j);
sz = j;
if (sz > 0) {
disj.push_back(m_util.mk_ge(sz, m_coeffs.c_ptr(), m_args.c_ptr(), k));
disj.push_back(m_util.mk_ge(sz, m_coeffs.data(), m_args.data(), k));
}
if (!disj.empty()) {
conj.push_back(mk_or(disj));

60
src/ast/rewriter/poly_rewriter_def.h
View file

@ -116,9 +116,9 @@ expr * poly_rewriter<Config>::mk_mul_app(unsigned num_args, expr * const * args)
else {
numeral a;
if (new_args.size() > 2 && is_numeral(new_args.get(0), a)) {
return mk_mul_app(a, mk_mul_app(new_args.size() - 1, new_args.c_ptr() + 1));
return mk_mul_app(a, mk_mul_app(new_args.size() - 1, new_args.data() + 1));
}
return m().mk_app(get_fid(), mul_decl_kind(), new_args.size(), new_args.c_ptr());
return m().mk_app(get_fid(), mul_decl_kind(), new_args.size(), new_args.data());
}
}
else {
@ -185,7 +185,7 @@ br_status poly_rewriter<Config>::mk_flat_mul_core(unsigned num_args, expr * cons
flat_args.push_back(args[j]);
}
}
br_status st = mk_nflat_mul_core(flat_args.size(), flat_args.c_ptr(), result);
br_status st = mk_nflat_mul_core(flat_args.size(), flat_args.data(), result);
TRACE("poly_rewriter",
tout << "flat mul:\n";
for (unsigned i = 0; i < num_args; i++) tout << mk_bounded_pp(args[i], m()) << "\n";
@ -194,7 +194,7 @@ br_status poly_rewriter<Config>::mk_flat_mul_core(unsigned num_args, expr * cons
tout << st << "\n";
);
if (st == BR_FAILED) {
result = mk_mul_app(flat_args.size(), flat_args.c_ptr());
result = mk_mul_app(flat_args.size(), flat_args.data());
return BR_DONE;
}
return st;
@ -290,7 +290,7 @@ br_status poly_rewriter<Config>::mk_nflat_mul_core(unsigned num_args, expr * con
for (unsigned i = 0; i < num; i++) {
new_add_args.push_back(mk_mul_app(c, to_app(var)->get_arg(i)));
}
result = mk_add_app(new_add_args.size(), new_add_args.c_ptr());
result = mk_add_app(new_add_args.size(), new_add_args.data());
TRACE("mul_bug", tout << "result: " << mk_bounded_pp(result, m(),5) << "\n";);
return BR_REWRITE2;
}
@ -303,7 +303,7 @@ br_status poly_rewriter<Config>::mk_nflat_mul_core(unsigned num_args, expr * con
m_args.push_back(args[i]);
}
}
result = mk_mul_app(c, mk_mul_app(m_args.size(), m_args.c_ptr()));
result = mk_mul_app(c, mk_mul_app(m_args.size(), m_args.data()));
return BR_REWRITE2;
}
@ -344,7 +344,7 @@ br_status poly_rewriter<Config>::mk_nflat_mul_core(unsigned num_args, expr * con
tout << "\n";);
}
SASSERT(new_args.size() >= 2);
result = mk_mul_app(new_args.size(), new_args.c_ptr());
result = mk_mul_app(new_args.size(), new_args.data());
result = mk_mul_app(c, result);
TRACE("poly_rewriter",
for (unsigned i = 0; i < num_args; ++i)
@ -387,10 +387,10 @@ br_status poly_rewriter<Config>::mk_nflat_mul_core(unsigned num_args, expr * con
expr * arg = v[it[i]];
m_args.push_back(arg);
}
sum.push_back(mk_mul_app(m_args.size(), m_args.c_ptr()));
sum.push_back(mk_mul_app(m_args.size(), m_args.data()));
}
while (product_iterator_next(szs.size(), szs.c_ptr(), it.c_ptr()));
result = mk_add_app(sum.size(), sum.c_ptr());
while (product_iterator_next(szs.size(), szs.data(), it.data()));
result = mk_add_app(sum.size(), sum.data());
return BR_REWRITE2;
}
@ -417,9 +417,9 @@ br_status poly_rewriter<Config>::mk_flat_add_core(unsigned num_args, expr * cons
flat_args.push_back(arg);
}
}
br_status st = mk_nflat_add_core(flat_args.size(), flat_args.c_ptr(), result);
br_status st = mk_nflat_add_core(flat_args.size(), flat_args.data(), result);
if (st == BR_FAILED) {
result = mk_add_app(flat_args.size(), flat_args.c_ptr());
result = mk_add_app(flat_args.size(), flat_args.data());
return BR_DONE;
}
return st;
@ -616,11 +616,11 @@ br_status poly_rewriter<Config>::mk_nflat_add_core(unsigned num_args, expr * con
if (m_sort_sums) {
TRACE("rewriter_bug", tout << "new_args.size(): " << new_args.size() << "\n";);
if (c.is_zero())
std::sort(new_args.c_ptr(), new_args.c_ptr() + new_args.size(), mon_lt(*this));
std::sort(new_args.data(), new_args.data() + new_args.size(), mon_lt(*this));
else
std::sort(new_args.c_ptr() + 1, new_args.c_ptr() + new_args.size(), mon_lt(*this));
std::sort(new_args.data() + 1, new_args.data() + new_args.size(), mon_lt(*this));
}
result = mk_add_app(new_args.size(), new_args.c_ptr());
result = mk_add_app(new_args.size(), new_args.data());
TRACE("rewriter", tout << result << "\n";);
if (hoist_multiplication(result)) {
return BR_REWRITE_FULL;
@ -649,11 +649,11 @@ br_status poly_rewriter<Config>::mk_nflat_add_core(unsigned num_args, expr * con
}
if (!ordered) {
if (c.is_zero())
std::sort(new_args.c_ptr(), new_args.c_ptr() + new_args.size(), lt);
std::sort(new_args.data(), new_args.data() + new_args.size(), lt);
else
std::sort(new_args.c_ptr() + 1, new_args.c_ptr() + new_args.size(), lt);
std::sort(new_args.data() + 1, new_args.data() + new_args.size(), lt);
}
result = mk_add_app(new_args.size(), new_args.c_ptr());
result = mk_add_app(new_args.size(), new_args.data());
if (hoist_multiplication(result)) {
return BR_REWRITE_FULL;
}
@ -697,7 +697,7 @@ br_status poly_rewriter<Config>::mk_sub(unsigned num_args, expr * const * args,
expr * aux_args[2] = { minus_one, args[i] };
new_args.push_back(mk_mul_app(2, aux_args));
}
result = mk_add_app(new_args.size(), new_args.c_ptr());
result = mk_add_app(new_args.size(), new_args.data());
return BR_REWRITE2;
}
@ -878,8 +878,8 @@ br_status poly_rewriter<Config>::cancel_monomials(expr * lhs, expr * rhs, bool m
const unsigned rhs_offset = insert_c_rhs ? 0 : 1;
new_rhs_monomials[0] = insert_c_rhs ? mk_numeral(c) : nullptr;
new_lhs_monomials[0] = insert_c_lhs ? mk_numeral(c) : nullptr;
lhs_result = mk_add_app(new_lhs_monomials.size() - lhs_offset, new_lhs_monomials.c_ptr() + lhs_offset);
rhs_result = mk_add_app(new_rhs_monomials.size() - rhs_offset, new_rhs_monomials.c_ptr() + rhs_offset);
lhs_result = mk_add_app(new_lhs_monomials.size() - lhs_offset, new_lhs_monomials.data() + lhs_offset);
rhs_result = mk_add_app(new_rhs_monomials.size() - rhs_offset, new_rhs_monomials.data() + rhs_offset);
TRACE("le_bug", tout << lhs_result << " " << rhs_result << "\n";);
return BR_DONE;
}
@ -938,7 +938,7 @@ bool poly_rewriter<Config>::hoist_multiplication(expr_ref& som) {
return false;
}
som = mk_add_app(adds.size(), adds.c_ptr());
som = mk_add_app(adds.size(), adds.data());
return true;
@ -968,13 +968,13 @@ expr* poly_rewriter<Config>::merge_muls(expr* x, expr* y) {
SASSERT(k > 0);
SASSERT(m1.size() >= k);
SASSERT(m2.size() >= k);
expr* args[2] = { mk_mul_app(m1.size()-k, m1.c_ptr()+k),
mk_mul_app(m2.size()-k, m2.c_ptr()+k) };
expr* args[2] = { mk_mul_app(m1.size()-k, m1.data()+k),
mk_mul_app(m2.size()-k, m2.data()+k) };
if (k == m1.size()) {
m1.push_back(0);
}
m1[k] = mk_add_app(2, args);
return mk_mul_app(k+1, m1.c_ptr());
return mk_mul_app(k+1, m1.data());
}
template<typename Config>
@ -999,7 +999,7 @@ bool poly_rewriter<Config>::hoist_ite(expr_ref& e) {
bs.push_back(apply_hoist(a, g, shared));
if (is_nontrivial_gcd(g)) {
bs.push_back(mk_numeral(g));
bs[0] = mk_mul_app(2, bs.c_ptr());
bs[0] = mk_mul_app(2, bs.data());
bs.pop_back();
}
else {
@ -1007,7 +1007,7 @@ bool poly_rewriter<Config>::hoist_ite(expr_ref& e) {
bs.push_back(s);
}
}
expr* a2 = mk_add_app(bs.size(), bs.c_ptr());
expr* a2 = mk_add_app(bs.size(), bs.data());
if (a != a2) {
adds[i] = a2;
pinned.push_back(a2);
@ -1017,7 +1017,7 @@ bool poly_rewriter<Config>::hoist_ite(expr_ref& e) {
++i;
}
if (!pinned.empty()) {
e = mk_add_app(adds.size(), adds.c_ptr());
e = mk_add_app(adds.size(), adds.data());
return true;
}
return false;
@ -1080,7 +1080,7 @@ expr* poly_rewriter<Config>::apply_hoist(expr* a, numeral const& g, obj_hashtabl
}
}
adds.shrink(i);
return mk_add_app(adds.size(), adds.c_ptr());
return mk_add_app(adds.size(), adds.data());
}
@ -1139,6 +1139,6 @@ bool poly_rewriter<Config>::is_var_plus_ground(expr * n, bool & inv, var * & v,
if (v == nullptr)
return false; // did not find variable
SASSERT(!args.empty());
mk_add(args.size(), args.c_ptr(), t);
mk_add(args.size(), args.data(), t);
return true;
}

10
src/ast/rewriter/quant_hoist.cpp
View file

@ -78,7 +78,7 @@ public:
: m.mk_const (sym, s);
vars.push_back(a);
}
expr * const * exprs = (expr* const*) (vars.c_ptr() + vars.size()- nd);
expr * const * exprs = (expr* const*) (vars.data() + vars.size()- nd);
result = instantiate(m, q, exprs);
}
@ -215,10 +215,10 @@ private:
args.push_back(tmp);
}
if (rewrite_ok) {
m_rewriter.mk_and(args.size(), args.c_ptr(), result);
m_rewriter.mk_and(args.size(), args.data(), result);
}
else {
result = m.mk_and (args.size (), args.c_ptr ());
result = m.mk_and (args.size (), args.data ());
}
}
else if (m.is_or(fml)) {
@ -228,10 +228,10 @@ private:
args.push_back(tmp);
}
if (rewrite_ok) {
m_rewriter.mk_or(args.size(), args.c_ptr(), result);
m_rewriter.mk_or(args.size(), args.data(), result);
}
else {
result = m.mk_or (args.size (), args.c_ptr ());
result = m.mk_or (args.size (), args.data ());
}
}
else if (m.is_not(fml)) {

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

@ -275,7 +275,7 @@ void var_shifter_core::process_app(app * t, frame & fr) {
SASSERT(fr.m_spos + num_args == m_result_stack.size());
expr * new_t;
if (fr.m_new_child) {
expr * const * new_args = m_result_stack.c_ptr() + fr.m_spos;
expr * const * new_args = m_result_stack.data() + fr.m_spos;
new_t = m().mk_app(t->get_decl(), num_args, new_args);
}
else {
@ -305,7 +305,7 @@ void var_shifter_core::process_quantifier(quantifier * q, frame & fr) {
SASSERT(fr.m_spos + num_children == m_result_stack.size());
expr * new_q;
if (fr.m_new_child) {
expr * const * it = m_result_stack.c_ptr() + fr.m_spos;
expr * const * it = m_result_stack.data() + fr.m_spos;
expr * new_expr = *it;
++it;
expr * const * new_pats = it;

14
src/ast/rewriter/rewriter_def.h
View file

@ -284,7 +284,7 @@ void rewriter_tpl<Config>::process_app(app * t, frame & fr) {
}
unsigned new_num_args = result_stack().size() - fr.m_spos;
expr * const * new_args = result_stack().c_ptr() + fr.m_spos;
expr * const * new_args = result_stack().data() + fr.m_spos;
app_ref new_t(m());
if (ProofGen) {
elim_reflex_prs(fr.m_spos);
@ -295,7 +295,7 @@ void rewriter_tpl<Config>::process_app(app * t, frame & fr) {
}
else {
new_t = m().mk_app(f, new_num_args, new_args);
m_pr = m().mk_congruence(t, new_t, num_prs, result_pr_stack().c_ptr() + fr.m_spos);
m_pr = m().mk_congruence(t, new_t, num_prs, result_pr_stack().data() + fr.m_spos);
SASSERT(rewrites_from(t, m_pr));
SASSERT(rewrites_to(new_t, m_pr));
}
@ -537,7 +537,7 @@ void rewriter_tpl<Config>::process_quantifier(quantifier * q, frame & fr) {
}
}
SASSERT(fr.m_spos + num_children == result_stack().size());
expr * const * it = result_stack().c_ptr() + fr.m_spos;
expr * const * it = result_stack().data() + fr.m_spos;
expr * new_body = *it;
unsigned num_pats = q->get_num_patterns();
unsigned num_no_pats = q->get_num_no_patterns();
@ -561,7 +561,7 @@ void rewriter_tpl<Config>::process_quantifier(quantifier * q, frame & fr) {
num_no_pats = j;
}
if (ProofGen) {
quantifier_ref new_q(m().update_quantifier(q, num_pats, new_pats.c_ptr(), num_no_pats, new_no_pats.c_ptr(), new_body), m());
quantifier_ref new_q(m().update_quantifier(q, num_pats, new_pats.data(), num_no_pats, new_no_pats.data(), new_body), m());
m_pr = nullptr;
if (q != new_q) {
m_pr = result_pr_stack().get(fr.m_spos);
@ -575,7 +575,7 @@ void rewriter_tpl<Config>::process_quantifier(quantifier * q, frame & fr) {
}
m_r = new_q;
proof_ref pr2(m());
if (m_cfg.reduce_quantifier(new_q, new_body, new_pats.c_ptr(), new_no_pats.c_ptr(), m_r, pr2)) {
if (m_cfg.reduce_quantifier(new_q, new_body, new_pats.data(), new_no_pats.data(), m_r, pr2)) {
m_pr = m().mk_transitivity(m_pr, pr2);
}
TRACE("reduce_quantifier_bug",if (m_pr) tout << mk_ismt2_pp(m_pr, m()) << "\n"; else tout << "m_pr is_null\n";);
@ -584,9 +584,9 @@ void rewriter_tpl<Config>::process_quantifier(quantifier * q, frame & fr) {
}
else {
TRACE("reduce_quantifier_bug", tout << mk_ismt2_pp(q, m()) << " " << mk_ismt2_pp(new_body, m()) << "\n";);
if (!m_cfg.reduce_quantifier(q, new_body, new_pats.c_ptr(), new_no_pats.c_ptr(), m_r, m_pr)) {
if (!m_cfg.reduce_quantifier(q, new_body, new_pats.data(), new_no_pats.data(), m_r, m_pr)) {
if (fr.m_new_child) {
m_r = m().update_quantifier(q, num_pats, new_pats.c_ptr(), num_no_pats, new_no_pats.c_ptr(), new_body);
m_r = m().update_quantifier(q, num_pats, new_pats.data(), num_no_pats, new_no_pats.data(), new_body);
}
else {
TRACE("rewriter_reuse", tout << "reusing:\n" << mk_ismt2_pp(q, m()) << "\n";);

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

@ -109,7 +109,7 @@ namespace seq {
if (m_trail.size() != 4000)
return;
unsigned new_size = 2000;
expr_ref_vector new_trail(m, new_size, m_trail.c_ptr() + new_size);
expr_ref_vector new_trail(m, new_size, m_trail.data() + new_size);
m_purified.reset();
for (unsigned i = 0; i < new_size; i += 2)
m_purified.insert(new_trail.get(i), new_trail.get(i + 1));

6
src/ast/rewriter/seq_eq_solver.cpp
View file

@ -304,7 +304,7 @@ namespace seq {
expr_ref eq_length(m.mk_eq(a.mk_int(lenX), seq.str.mk_length(X)), m);
expr* val = ctx.expr2rep(eq_length);
if (!m.is_false(val)) {
expr_ref Y(seq.str.mk_concat(lenX.get_unsigned(), units.c_ptr(), X->get_sort()), m);
expr_ref Y(seq.str.mk_concat(lenX.get_unsigned(), units.data(), X->get_sort()), m);
expr_ref eq = m_ax.sk().mk_eq(X, Y);
add_consequence(~eq_length, eq);
return true;
@ -369,12 +369,12 @@ namespace seq {
void eq_solver::set_prefix(expr_ref& x, expr_ref_vector const& xs, unsigned sz) const {
SASSERT(0 < xs.size() && sz <= xs.size());
x = seq.str.mk_concat(sz, xs.c_ptr(), xs[0]->get_sort());
x = seq.str.mk_concat(sz, xs.data(), xs[0]->get_sort());
}
void eq_solver::set_suffix(expr_ref& x, expr_ref_vector const& xs, unsigned sz) const {
SASSERT(0 < xs.size() && sz <= xs.size());
x = seq.str.mk_concat(sz, xs.c_ptr() + xs.size() - sz, xs[0]->get_sort());
x = seq.str.mk_concat(sz, xs.data() + xs.size() - sz, xs[0]->get_sort());
}
unsigned eq_solver::count_units_l2r(expr_ref_vector const& es, unsigned offset) const {

2
src/ast/rewriter/seq_eq_solver.h
View file

@ -102,7 +102,7 @@ namespace seq {
void set_extract(V& dst, expr_ref_vector const& xs, unsigned offset, unsigned sz) const {
SASSERT(offset + sz <= xs.size());
dst.reset();
dst.append(sz, xs.c_ptr() + offset);
dst.append(sz, xs.data() + offset);
}
void set_conflict();

82
src/ast/rewriter/seq_rewriter.cpp
View file

@ -828,7 +828,7 @@ br_status seq_rewriter::mk_seq_length(expr* a, expr_ref& result) {
if (len != 0) {
es.push_back(m_autil.mk_int(len));
}
result = m_autil.mk_add(es.size(), es.c_ptr());
result = m_autil.mk_add(es.size(), es.data());
return BR_REWRITE2;
}
expr* x = nullptr, *y = nullptr, *z = nullptr;
@ -993,7 +993,7 @@ bool seq_rewriter::extract_pop_suffix(expr_ref_vector const& as, expr* b, expr*
len_a1 += len_a2;
}
if (i < as.size()) {
expr* a = str().mk_concat(i, as.c_ptr(), as[0]->get_sort());
expr* a = str().mk_concat(i, as.data(), as[0]->get_sort());
result = str().mk_substr(a, b, c);
return true;
}
@ -1021,7 +1021,7 @@ bool seq_rewriter::extract_push_offset(expr_ref_vector const& as, expr* b, expr*
}
if (i != 0) {
expr_ref t1(m());
t1 = str().mk_concat(as.size() - i, as.c_ptr() + i, as[0]->get_sort());
t1 = str().mk_concat(as.size() - i, as.data() + i, as[0]->get_sort());
expr_ref t2 = mk_len(pos1, lens);
result = str().mk_substr(t1, t2, c);
TRACE("seq", tout << result << "\n";);
@ -1051,16 +1051,16 @@ bool seq_rewriter::extract_push_length(expr_ref_vector& as, expr* b, expr* c, ex
}
}
if (i == as.size()) {
result = str().mk_concat(as.size(), as.c_ptr(), as[0]->get_sort());
result = str().mk_concat(as.size(), as.data(), as[0]->get_sort());
return true;
}
else if (i != 0) {
expr_ref t1(m()), t2(m());
t1 = str().mk_concat(as.size() - i, as.c_ptr() + i, as[0]->get_sort());
t1 = str().mk_concat(as.size() - i, as.data() + i, as[0]->get_sort());
t2 = mk_len(pos, lens);
result = str().mk_substr(t1, b, t2);
as[i] = result;
result = str().mk_concat(i + 1, as.c_ptr(), as[0]->get_sort());
result = str().mk_concat(i + 1, as.data(), as[0]->get_sort());
TRACE("seq", tout << result << "\n";);
return true;
}
@ -1191,7 +1191,7 @@ br_status seq_rewriter::mk_seq_extract(expr* a, expr* b, expr* c, expr_ref& resu
result = str().mk_empty(a->get_sort());
for (unsigned i = 1; i <= as.size(); ++i) {
result = m().mk_ite(m_autil.mk_ge(c, m_autil.mk_int(i)),
str().mk_concat(i, as.c_ptr(), a->get_sort()),
str().mk_concat(i, as.data(), a->get_sort()),
result);
}
return BR_REWRITE_FULL;
@ -1212,11 +1212,11 @@ br_status seq_rewriter::mk_seq_extract(expr* a, expr* b, expr* c, expr_ref& resu
unsigned i = offset;
for (; i < as.size() && str().is_unit(as.get(i)) && i - offset < _len; ++i);
if (i - offset == _len) {
result = str().mk_concat(_len, as.c_ptr() + offset, a->get_sort());
result = str().mk_concat(_len, as.data() + offset, a->get_sort());
return BR_DONE;
}
if (i == as.size()) {
result = str().mk_concat(as.size() - offset, as.c_ptr() + offset, as[0]->get_sort());
result = str().mk_concat(as.size() - offset, as.data() + offset, as[0]->get_sort());
return BR_DONE;
}
}
@ -1225,7 +1225,7 @@ br_status seq_rewriter::mk_seq_extract(expr* a, expr* b, expr* c, expr_ref& resu
}
expr_ref position(m());
position = m_autil.mk_sub(b, m_autil.mk_int(offset));
result = str().mk_concat(as.size() - offset, as.c_ptr() + offset, as[0]->get_sort());
result = str().mk_concat(as.size() - offset, as.data() + offset, as[0]->get_sort());
result = str().mk_substr(result, position, c);
return BR_REWRITE3;
}
@ -1361,7 +1361,7 @@ br_status seq_rewriter::mk_seq_contains(expr* a, expr* b, expr_ref& result) {
}
if (offs > 0 || sz < as.size()) {
SASSERT(sz > offs);
result = str().mk_contains(str().mk_concat(sz-offs, as.c_ptr()+offs, a->get_sort()), b);
result = str().mk_contains(str().mk_concat(sz-offs, as.data()+offs, a->get_sort()), b);
return BR_REWRITE2;
}
@ -1496,7 +1496,7 @@ br_status seq_rewriter::mk_seq_at(expr* a, expr* b, expr_ref& result) {
for (expr* rhs : lens) {
pos = m_autil.mk_add(pos, str().mk_length(rhs));
}
result = str().mk_concat(m_lhs.size() - i , m_lhs.c_ptr() + i, sort_a);
result = str().mk_concat(m_lhs.size() - i , m_lhs.data() + i, sort_a);
result = str().mk_at(result, pos);
return BR_REWRITE2;
}
@ -1658,7 +1658,7 @@ br_status seq_rewriter::mk_seq_index(expr* a, expr* b, expr* c, expr_ref& result
}
if (i > 0) {
expr_ref a1(m());
a1 = str().mk_concat(as.size() - i, as.c_ptr() + i, sort_a);
a1 = str().mk_concat(as.size() - i, as.data() + i, sort_a);
result = str().mk_index(a1, b, m_autil.mk_int(r));
result = m().mk_ite(m_autil.mk_ge(result, zero()), m_autil.mk_add(m_autil.mk_int(i), result), minus_one());
return BR_REWRITE_FULL;
@ -1676,7 +1676,7 @@ br_status seq_rewriter::mk_seq_index(expr* a, expr* b, expr* c, expr_ref& result
}
if (i > 0) {
result = str().mk_index(
str().mk_concat(as.size() - i, as.c_ptr() + i, sort_a), b, c);
str().mk_concat(as.size() - i, as.data() + i, sort_a), b, c);
result = m().mk_ite(m_autil.mk_ge(result, zero()), m_autil.mk_add(m_autil.mk_int(i), result), minus_one());
return BR_REWRITE_FULL;
}
@ -1698,7 +1698,7 @@ br_status seq_rewriter::mk_seq_index(expr* a, expr* b, expr* c, expr_ref& result
break;
}
if (is_zero && !as.empty() && str().is_unit(as.get(0))) {
expr_ref a1(str().mk_concat(as.size() - 1, as.c_ptr() + 1, as[0]->get_sort()), m());
expr_ref a1(str().mk_concat(as.size() - 1, as.data() + 1, as[0]->get_sort()), m());
expr_ref b1(str().mk_index(a1, b, c), m());
result = m().mk_ite(str().mk_prefix(b, a), zero(),
m().mk_ite(m_autil.mk_ge(b1, zero()), m_autil.mk_add(one(), b1), minus_one()));
@ -1797,7 +1797,7 @@ br_status seq_rewriter::mk_seq_replace(expr* a, expr* b, expr* c, expr_ref& resu
// a := b + rest
if (m_lhs.get(0) == b) {
m_lhs[0] = c;
result = str().mk_concat(m_lhs.size(), m_lhs.c_ptr(), sort_a);
result = str().mk_concat(m_lhs.size(), m_lhs.data(), sort_a);
return BR_REWRITE1;
}
@ -1805,7 +1805,7 @@ br_status seq_rewriter::mk_seq_replace(expr* a, expr* b, expr* c, expr_ref& resu
if (str().is_string(b, s2) && str().is_string(c, s3) &&
str().is_string(m_lhs.get(0), s1) && s1.contains(s2) ) {
m_lhs[0] = str().mk_string(s1.replace(s2, s3));
result = str().mk_concat(m_lhs.size(), m_lhs.c_ptr(), sort_a);
result = str().mk_concat(m_lhs.size(), m_lhs.data(), sort_a);
return BR_REWRITE1;
}
m_lhs.reset();
@ -1839,16 +1839,16 @@ br_status seq_rewriter::mk_seq_replace(expr* a, expr* b, expr* c, expr_ref& resu
if (cmp == l_false && str().is_unit(m_lhs.get(i)))
continue;
if (cmp == l_true && m_lhs.size() < i + m_rhs.size()) {
expr_ref a1(str().mk_concat(i, m_lhs.c_ptr(), sort_a), m());
expr_ref a2(str().mk_concat(m_lhs.size()-i, m_lhs.c_ptr()+i, sort_a), m());
expr_ref a1(str().mk_concat(i, m_lhs.data(), sort_a), m());
expr_ref a2(str().mk_concat(m_lhs.size()-i, m_lhs.data()+i, sort_a), m());
result = m().mk_ite(m().mk_eq(a2, b), str().mk_concat(a1, c), a);
return BR_REWRITE_FULL;
}
if (cmp == l_true) {
expr_ref_vector es(m());
es.append(i, m_lhs.c_ptr());
es.append(i, m_lhs.data());
es.push_back(c);
es.append(m_lhs.size()-i-m_rhs.size(), m_lhs.c_ptr()+i+m_rhs.size());
es.append(m_lhs.size()-i-m_rhs.size(), m_lhs.data()+i+m_rhs.size());
result = str().mk_concat(es, sort_a);
return BR_REWRITE_FULL;
}
@ -1856,8 +1856,8 @@ br_status seq_rewriter::mk_seq_replace(expr* a, expr* b, expr* c, expr_ref& resu
}
if (i > 0) {
expr_ref a1(str().mk_concat(i, m_lhs.c_ptr(), sort_a), m());
expr_ref a2(str().mk_concat(m_lhs.size()-i, m_lhs.c_ptr()+i, sort_a), m());
expr_ref a1(str().mk_concat(i, m_lhs.data(), sort_a), m());
expr_ref a2(str().mk_concat(m_lhs.size()-i, m_lhs.data()+i, sort_a), m());
result = str().mk_concat(a1, str().mk_replace(a2, b, c));
return BR_REWRITE_FULL;
}
@ -1941,8 +1941,8 @@ br_status seq_rewriter::mk_seq_prefix(expr* a, expr* b, expr_ref& result) {
SASSERT(as.size() > 1);
s2 = s2.extract(s1.length(), s2.length()-s1.length());
bs[0] = str().mk_string(s2);
result = str().mk_prefix(str().mk_concat(as.size()-1, as.c_ptr()+1, sort_a),
str().mk_concat(bs.size(), bs.c_ptr(), sort_a));
result = str().mk_prefix(str().mk_concat(as.size()-1, as.data()+1, sort_a),
str().mk_concat(bs.size(), bs.data(), sort_a));
TRACE("seq", tout << s1 << " " << s2 << " " << result << "\n";);
return BR_REWRITE_FULL;
}
@ -1964,8 +1964,8 @@ br_status seq_rewriter::mk_seq_prefix(expr* a, expr* b, expr_ref& result) {
SASSERT(bs.size() > 1);
s1 = s1.extract(s2.length(), s1.length() - s2.length());
as[0] = str().mk_string(s1);
result = str().mk_prefix(str().mk_concat(as.size(), as.c_ptr(), sort_a),
str().mk_concat(bs.size()-1, bs.c_ptr()+1, sort_a));
result = str().mk_prefix(str().mk_concat(as.size(), as.data(), sort_a),
str().mk_concat(bs.size()-1, bs.data()+1, sort_a));
TRACE("seq", tout << s1 << " " << s2 << " " << result << "\n";);
return BR_REWRITE_FULL;
}
@ -2011,8 +2011,8 @@ br_status seq_rewriter::mk_seq_prefix(expr* a, expr* b, expr_ref& result) {
}
if (i > 0) {
SASSERT(i < as.size() && i < bs.size());
a = str().mk_concat(as.size() - i, as.c_ptr() + i, sort_a);
b = str().mk_concat(bs.size() - i, bs.c_ptr() + i, sort_a);
a = str().mk_concat(as.size() - i, as.data() + i, sort_a);
b = str().mk_concat(bs.size() - i, bs.data() + i, sort_a);
eqs.push_back(str().mk_prefix(a, b));
result = mk_and(eqs);
TRACE("seq", tout << result << "\n";);
@ -2091,8 +2091,8 @@ br_status seq_rewriter::mk_seq_suffix(expr* a, expr* b, expr_ref& result) {
if (i > 1) {
SASSERT(i <= sza && i <= szb);
a = str().mk_concat(sza - i + 1, as.c_ptr(), sort_a);
b = str().mk_concat(szb - i + 1, bs.c_ptr(), sort_a);
a = str().mk_concat(sza - i + 1, as.data(), sort_a);
b = str().mk_concat(szb - i + 1, bs.data(), sort_a);
eqs.push_back(str().mk_suffix(a, b));
result = mk_and(eqs);
TRACE("seq", tout << result << "\n";);
@ -2294,7 +2294,7 @@ br_status seq_rewriter::mk_str_stoi(expr* a, expr_ref& result) {
// if tail < 0 then tail else
// if stoi(head) >= 0 and then stoi(head)*10+tail else -1
expr_ref tail(str().mk_stoi(as.back()), m());
expr_ref head(str().mk_concat(as.size() - 1, as.c_ptr(), a->get_sort()), m());
expr_ref head(str().mk_concat(as.size() - 1, as.data(), a->get_sort()), m());
expr_ref stoi_head(str().mk_stoi(head), m());
result = m().mk_ite(m_autil.mk_ge(stoi_head, m_autil.mk_int(0)),
m_autil.mk_add(m_autil.mk_mul(m_autil.mk_int(10), stoi_head), tail),
@ -2309,7 +2309,7 @@ br_status seq_rewriter::mk_str_stoi(expr* a, expr_ref& result) {
return BR_REWRITE_FULL;
}
if (str().is_unit(as.get(0), u) && m_util.is_const_char(u, ch) && '0' == ch) {
result = str().mk_concat(as.size() - 1, as.c_ptr() + 1, as[0]->get_sort());
result = str().mk_concat(as.size() - 1, as.data() + 1, as[0]->get_sort());
result = m().mk_ite(str().mk_is_empty(result),
m_autil.mk_int(0),
str().mk_stoi(result));
@ -4686,20 +4686,20 @@ bool seq_rewriter::reduce_contains(expr* a, expr* b, expr_ref_vector& disj) {
for (unsigned j = 0; j < sz; ++j) {
es.push_back(str().mk_unit(str().mk_char(s, j)));
}
es.append(m_lhs.size() - i, m_lhs.c_ptr() + i);
es.append(m_lhs.size() - i, m_lhs.data() + i);
for (unsigned j = 0; j < sz; ++j) {
disj.push_back(str().mk_prefix(b, str().mk_concat(es.size() - j, es.c_ptr() + j, sort_a)));
disj.push_back(str().mk_prefix(b, str().mk_concat(es.size() - j, es.data() + j, sort_a)));
}
continue;
}
if (str().is_unit(e)) {
disj.push_back(str().mk_prefix(b, str().mk_concat(m_lhs.size() - i, m_lhs.c_ptr() + i, sort_a)));
disj.push_back(str().mk_prefix(b, str().mk_concat(m_lhs.size() - i, m_lhs.data() + i, sort_a)));
continue;
}
if (str().is_string(b, s)) {
expr* all = re().mk_full_seq(re().mk_re(b->get_sort()));
disj.push_back(re().mk_in_re(str().mk_concat(m_lhs.size() - i, m_lhs.c_ptr() + i, sort_a),
disj.push_back(re().mk_in_re(str().mk_concat(m_lhs.size() - i, m_lhs.data() + i, sort_a),
re().mk_concat(all, re().mk_concat(re().mk_to_re(b), all))));
return true;
}
@ -4707,7 +4707,7 @@ bool seq_rewriter::reduce_contains(expr* a, expr* b, expr_ref_vector& disj) {
if (i == 0) {
return false;
}
disj.push_back(str().mk_contains(str().mk_concat(m_lhs.size() - i, m_lhs.c_ptr() + i, sort_a), b));
disj.push_back(str().mk_contains(str().mk_concat(m_lhs.size() - i, m_lhs.data() + i, sort_a), b));
return true;
}
disj.push_back(str().mk_is_empty(b));
@ -4882,7 +4882,7 @@ bool seq_rewriter::reduce_itos(expr_ref_vector& ls, expr_ref_vector& rs,
zstring s;
if (ls.size() == 1 &&
str().is_itos(ls.get(0), n) &&
is_string(rs.size(), rs.c_ptr(), s)) {
is_string(rs.size(), rs.data(), s)) {
std::string s1 = s.encode();
rational r(s1.c_str());
if (s1 == r.to_string()) {
@ -4938,14 +4938,14 @@ bool seq_rewriter::reduce_by_length(expr_ref_vector& ls, expr_ref_vector& rs,
if (bounded2 && len2 < len1)
return false;
if (bounded1 && len1 == len2 && len1 > 0) {
if (!set_empty(rs.size(), rs.c_ptr(), false, eqs))
if (!set_empty(rs.size(), rs.data(), false, eqs))
return false;
eqs.push_back(concat_non_empty(ls), concat_non_empty(rs));
ls.reset();
rs.reset();
}
else if (bounded2 && len1 == len2 && len1 > 0) {
if (!set_empty(ls.size(), ls.c_ptr(), false, eqs))
if (!set_empty(ls.size(), ls.data(), false, eqs))
return false;
eqs.push_back(concat_non_empty(ls), concat_non_empty(rs));
ls.reset();

4
src/ast/rewriter/seq_rewriter.h
View file

@ -165,7 +165,7 @@ class seq_rewriter {
length_comparison compare_lengths(expr_ref_vector const& as, expr_ref_vector const& bs) {
return compare_lengths(as.size(), as.c_ptr(), bs.size(), bs.c_ptr());
return compare_lengths(as.size(), as.data(), bs.size(), bs.data());
}
length_comparison compare_lengths(unsigned sza, expr* const* as, unsigned szb, expr* const* bs);
@ -333,7 +333,7 @@ public:
br_status mk_le_core(expr* lhs, expr* rhs, expr_ref& result);
br_status mk_bool_app(func_decl* f, unsigned n, expr* const* args, expr_ref& result);
expr_ref mk_app(func_decl* f, expr_ref_vector const& args) { return mk_app(f, args.size(), args.c_ptr()); }
expr_ref mk_app(func_decl* f, expr_ref_vector const& args) { return mk_app(f, args.size(), args.data()); }
expr_ref mk_app(func_decl* f, unsigned n, expr* const* args) {
expr_ref result(m());
if (f->get_family_id() != u().get_family_id() ||

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

@ -198,6 +198,6 @@ expr_ref skolem::mk_step(expr* s, expr* idx, expr* re, unsigned i, unsigned j, e
args.push_back(a.mk_int(i));
args.push_back(a.mk_int(j));
args.push_back(t);
return expr_ref(seq.mk_skolem(m_aut_step, args.size(), args.c_ptr(), m.mk_bool_sort()), m);
return expr_ref(seq.mk_skolem(m_aut_step, args.size(), args.data(), m.mk_bool_sort()), m);
}

2
src/ast/rewriter/seq_skolem.h
View file

@ -70,7 +70,7 @@ namespace seq {
}
return mk("seq.align.m", e1, e2, e3, e4);
}
expr_ref mk_accept(expr_ref_vector const& args) { return expr_ref(seq.mk_skolem(m_accept, args.size(), args.c_ptr(), m.mk_bool_sort()), m); }
expr_ref mk_accept(expr_ref_vector const& args) { return expr_ref(seq.mk_skolem(m_accept, args.size(), args.data(), m.mk_bool_sort()), m); }
expr_ref mk_accept(expr* s, expr* i, expr* r) { return mk(m_accept, s, i, r, nullptr, m.mk_bool_sort()); }
expr_ref mk_is_non_empty(expr* r, expr* u, expr* n) { return mk(m_is_non_empty, r, u, n, m.mk_bool_sort(), false); }
expr_ref mk_is_empty(expr* r, expr* u, expr* n) { return mk(m_is_empty, r, u, n, m.mk_bool_sort(), false); }

8
src/ast/rewriter/th_rewriter.cpp
View file

@ -511,7 +511,7 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
if (args.size() == 1)
c = args[0];
else
c = m_a_util.mk_add(args.size(), args.c_ptr());
c = m_a_util.mk_add(args.size(), args.data());
return true;
}
@ -722,8 +722,8 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
q1 = m().mk_quantifier(old_q->get_kind(),
sorts.size(),
sorts.c_ptr(),
names.c_ptr(),
sorts.data(),
names.data(),
nested_q->get_expr(),
std::min(old_q->get_weight(), nested_q->get_weight()),
old_q->get_qid(),
@ -757,7 +757,7 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
apply_subst(new_patterns_buf);
q1 = m().update_quantifier(old_q,
new_patterns_buf.size(), new_patterns_buf.c_ptr(), new_no_patterns_buf.size(), new_no_patterns_buf.c_ptr(),
new_patterns_buf.size(), new_patterns_buf.data(), new_no_patterns_buf.size(), new_no_patterns_buf.data(),
new_body);
m_pinned.reset();
TRACE("reduce_quantifier", tout << mk_ismt2_pp(old_q, m()) << "\n----->\n" << mk_ismt2_pp(q1, m()) << "\n";);

16
src/ast/rewriter/var_subst.cpp
View file

@ -134,11 +134,11 @@ expr_ref unused_vars_eliminator::operator()(quantifier* q) {
// (VAR 0) should be in the last position of var_mapping.
// ...
// (VAR (var_mapping.size() - 1)) should be in the first position.
std::reverse(var_mapping.c_ptr(), var_mapping.c_ptr() + var_mapping.size());
std::reverse(var_mapping.data(), var_mapping.data() + var_mapping.size());
expr_ref new_expr(m);
new_expr = m_subst(q->get_expr(), var_mapping.size(), var_mapping.c_ptr());
new_expr = m_subst(q->get_expr(), var_mapping.size(), var_mapping.data());
if (num_removed == num_decls) {
result = new_expr;
@ -149,24 +149,24 @@ expr_ref unused_vars_eliminator::operator()(quantifier* q) {
expr_ref_buffer new_no_patterns(m);
for (unsigned i = 0; i < num_patterns; i++) {
new_patterns.push_back(m_subst(q->get_pattern(i), var_mapping.size(), var_mapping.c_ptr()));
new_patterns.push_back(m_subst(q->get_pattern(i), var_mapping.size(), var_mapping.data()));
}
for (unsigned i = 0; i < num_no_patterns; i++) {
new_no_patterns.push_back(m_subst(q->get_no_pattern(i), var_mapping.size(), var_mapping.c_ptr()));
new_no_patterns.push_back(m_subst(q->get_no_pattern(i), var_mapping.size(), var_mapping.data()));
}
result = m.mk_quantifier(q->get_kind(),
used_decl_sorts.size(),
used_decl_sorts.c_ptr(),
used_decl_names.c_ptr(),
used_decl_sorts.data(),
used_decl_names.data(),
new_expr,
q->get_weight(),
q->get_qid(),
q->get_skid(),
num_patterns,
new_patterns.c_ptr(),
new_patterns.data(),
num_no_patterns,
new_no_patterns.c_ptr());
new_no_patterns.data());
to_quantifier(result)->set_no_unused_vars();
SASSERT(is_well_sorted(m, result));
return result;

10
src/ast/rewriter/var_subst.h
View file

@ -48,10 +48,10 @@ public:
Otherwise, (VAR 0) is stored in the first position, (VAR 1) in the second, and so on.
*/
expr_ref operator()(expr * n, unsigned num_args, expr * const * args);
inline expr_ref operator()(expr * n, expr_ref_vector const& args) { return (*this)(n, args.size(), args.c_ptr()); }
inline expr_ref operator()(expr * n, var_ref_vector const& args) { return (*this)(n, args.size(), (expr*const*)args.c_ptr()); }
inline expr_ref operator()(expr * n, app_ref_vector const& args) { return (*this)(n, args.size(), (expr*const*)args.c_ptr()); }
inline expr_ref operator()(expr * n, ptr_vector<expr> const& args) { return (*this)(n, args.size(), args.c_ptr()); }
inline expr_ref operator()(expr * n, expr_ref_vector const& args) { return (*this)(n, args.size(), args.data()); }
inline expr_ref operator()(expr * n, var_ref_vector const& args) { return (*this)(n, args.size(), (expr*const*)args.data()); }
inline expr_ref operator()(expr * n, app_ref_vector const& args) { return (*this)(n, args.size(), (expr*const*)args.data()); }
inline expr_ref operator()(expr * n, ptr_vector<expr> const& args) { return (*this)(n, args.size(), args.data()); }
void reset() { m_reducer.reset(); }
};
@ -104,7 +104,7 @@ public:
bool contains(unsigned idx) const { return idx < m_sorts.size() && m_sorts[idx] != 0; }
void set_default_sort(sort* s);
void reverse() { m_sorts.reverse(); }
sort*const* c_ptr() const { return m_sorts.c_ptr(); }
sort*const* data() const { return m_sorts.data(); }
};