mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-08-06 19:21:22 +00:00
Code Activity

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

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

2
src/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);