mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-23 09:05:31 +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

8
src/smt/arith_eq_adapter.cpp
View file

@ -209,9 +209,9 @@ namespace smt {
if (m.proofs_enabled() && m_proof_hint.empty()) {
m_proof_hint.push_back(parameter(symbol("triangle-eq")));
}
ctx.mk_th_axiom(tid, ~t1_eq_t2_lit, le_lit, m_proof_hint.size(), m_proof_hint.c_ptr());
ctx.mk_th_axiom(tid, ~t1_eq_t2_lit, ge_lit, m_proof_hint.size(), m_proof_hint.c_ptr());
ctx.mk_th_axiom(tid, t1_eq_t2_lit, ~le_lit, ~ge_lit, m_proof_hint.size(), m_proof_hint.c_ptr());
ctx.mk_th_axiom(tid, ~t1_eq_t2_lit, le_lit, m_proof_hint.size(), m_proof_hint.data());
ctx.mk_th_axiom(tid, ~t1_eq_t2_lit, ge_lit, m_proof_hint.size(), m_proof_hint.data());
ctx.mk_th_axiom(tid, t1_eq_t2_lit, ~le_lit, ~ge_lit, m_proof_hint.size(), m_proof_hint.data());
TRACE("arith_eq_adapter", tout << "internalizing: "
<< " " << mk_pp(le, m) << ": " << le_lit
<< " " << mk_pp(ge, m) << ": " << ge_lit
@ -219,7 +219,7 @@ namespace smt {
if (m_owner.get_fparams().m_arith_add_binary_bounds) {
TRACE("arith_eq_adapter", tout << "adding binary bounds...\n";);
ctx.mk_th_axiom(tid, le_lit, ge_lit, m_proof_hint.size(), m_proof_hint.c_ptr());
ctx.mk_th_axiom(tid, le_lit, ge_lit, m_proof_hint.size(), m_proof_hint.data());
}
if (ctx.relevancy()) {
relevancy_eh * eh = ctx.mk_relevancy_eh(arith_eq_relevancy_eh(n1->get_expr(), n2->get_expr(), t1_eq_t2, le, ge));

2
src/smt/arith_eq_solver.cpp
View file

@ -64,7 +64,7 @@ void arith_eq_solver::prop_mod_const(expr * e, unsigned depth, numeral const& k,
prop_mod_const(a->get_arg(i), depth - 1, k, tmp);
args.push_back(tmp);
}
m_arith_rewriter.mk_app(a->get_decl(), args.size(), args.c_ptr(), result);
m_arith_rewriter.mk_app(a->get_decl(), args.size(), args.data(), result);
}
else if (m_util.is_numeral(e, n, is_int) && is_int) {
result = m_util.mk_numeral(mod(n, k), true);

2
src/smt/diff_logic.h
View file

@ -640,7 +640,7 @@ public:
}
);
if (!check_explanation(edges.size(), edges.c_ptr())) {
if (!check_explanation(edges.size(), edges.data())) {
throw default_exception("edges are not inconsistent");
}

6
src/smt/dyn_ack.cpp
View file

@ -87,7 +87,7 @@ namespace smt {
}
}
app_ref eq(m.mk_eq(m_app1, m_app2), m);
proof_ref a1(m.mk_congruence(m_app1, m_app2, prs.size(), prs.c_ptr()), m);
proof_ref a1(m.mk_congruence(m_app1, m_app2, prs.size(), prs.data()), m);
proof_ref a2(mk_hypothesis(m, eq, true, m_app1, m_app2), m);
proof * antecedents[2] = { a1.get(), a2.get() };
proof_ref false_pr(m.mk_unit_resolution(2, antecedents), m);
@ -432,7 +432,7 @@ namespace smt {
justification * js = nullptr;
if (m.proofs_enabled())
js = alloc(dyn_ack_cc_justification, n1, n2);
clause * cls = m_context.mk_clause(lits.size(), lits.c_ptr(), js, CLS_TH_LEMMA, del_eh);
clause * cls = m_context.mk_clause(lits.size(), lits.data(), js, CLS_TH_LEMMA, del_eh);
if (!cls) {
dealloc(del_eh);
return;
@ -488,7 +488,7 @@ namespace smt {
m.mk_eq(n2, r),
m.mk_eq(n1, n2));
}
clause * cls = ctx.mk_clause(lits.size(), lits.c_ptr(), js, CLS_TH_LEMMA, del_eh);
clause * cls = ctx.mk_clause(lits.size(), lits.data(), js, CLS_TH_LEMMA, del_eh);
if (!cls) {
dealloc(del_eh);
return;

4
src/smt/expr_context_simplifier.cpp
View file

@ -231,10 +231,10 @@ void expr_context_simplifier::reduce_and_or(bool is_and, unsigned num_args, expr
clean_trail(trail_size);
if (is_and) {
m_simp.mk_and(args1.size(), args1.c_ptr(), result);
m_simp.mk_and(args1.size(), args1.data(), result);
}
else {
m_simp.mk_or(args1.size(), args1.c_ptr(), result);
m_simp.mk_or(args1.size(), args1.data(), result);
}
}

2
src/smt/fingerprints.cpp
View file

@ -48,7 +48,7 @@ namespace smt {
m_dummy.m_data = data;
m_dummy.m_data_hash = data_hash;
m_dummy.m_num_args = num_args;
m_dummy.m_args = m_tmp.c_ptr();
m_dummy.m_args = m_tmp.data();
return &m_dummy;
}

12
src/smt/mam.cpp
View file

@ -999,7 +999,7 @@ namespace {
SASSERT(m_vars[to_var(arg)->get_idx()] != -1);
iregs.push_back(m_vars[to_var(arg)->get_idx()]);
}
m_seq.push_back(m_ct_manager.mk_is_cgr(lbl, first_app_reg, num_args, iregs.c_ptr()));
m_seq.push_back(m_ct_manager.mk_is_cgr(lbl, first_app_reg, num_args, iregs.data()));
}
else {
// Generate a BIND operation for this application.
@ -1080,7 +1080,7 @@ namespace {
}
unsigned oreg = m_tree->m_num_regs;
m_tree->m_num_regs += 1;
m_seq.push_back(m_ct_manager.mk_get_cgr(n->get_decl(), oreg, num_args, iregs.c_ptr()));
m_seq.push_back(m_ct_manager.mk_get_cgr(n->get_decl(), oreg, num_args, iregs.data()));
return oreg;
}
@ -1194,7 +1194,7 @@ namespace {
}
}
SASSERT(joints.size() == num_args);
m_seq.push_back(m_ct_manager.mk_cont(lbl, num_args, oreg, s, joints.c_ptr()));
m_seq.push_back(m_ct_manager.mk_cont(lbl, num_args, oreg, s, joints.data()));
m_num_choices++;
while (!m_todo.empty())
linearise_core();
@ -2592,7 +2592,7 @@ namespace {
case GET_CGR1:
#define GET_CGR_COMMON() \
m_n1 = m_context.get_enode_eq_to(static_cast<const get_cgr *>(m_pc)->m_label, static_cast<const get_cgr *>(m_pc)->m_num_args, m_args.c_ptr()); \
m_n1 = m_context.get_enode_eq_to(static_cast<const get_cgr *>(m_pc)->m_label, static_cast<const get_cgr *>(m_pc)->m_num_args, m_args.data()); \
if (m_n1 == 0 || !m_context.is_relevant(m_n1)) \
goto backtrack; \
update_max_generation(m_n1, nullptr); \
@ -3653,8 +3653,8 @@ namespace {
recycle(t->m_todo);
t->m_todo = nullptr;
// remove both marks.
unmark_enodes(to_unmark->size(), to_unmark->c_ptr());
unmark_enodes2(to_unmark2->size(), to_unmark2->c_ptr());
unmark_enodes(to_unmark->size(), to_unmark->data());
unmark_enodes2(to_unmark2->size(), to_unmark2->data());
to_unmark->reset();
to_unmark2->reset();
}

4
src/smt/proto_model/proto_model.cpp
View file

@ -173,7 +173,7 @@ expr* proto_model::cleanup_expr(expr_ref_vector& trail, expr* fi_else, func_decl
TRACE("model_bug", tout << f->get_name() << "\n";);
found_aux_fs.insert(f);
}
new_t = m_rewrite.mk_app(f, args.size(), args.c_ptr());
new_t = m_rewrite.mk_app(f, args.size(), args.data());
if (t != new_t.get())
trail.push_back(new_t);
todo.pop_back();
@ -400,7 +400,7 @@ model * proto_model::mk_model() {
sort * s = get_uninterpreted_sort(i);
TRACE("proto_model", tout << "copying uninterpreted sorts...\n" << mk_pp(s, m) << "\n";);
ptr_vector<expr> const& buf = get_universe(s);
mdl->register_usort(s, buf.size(), buf.c_ptr());
mdl->register_usort(s, buf.size(), buf.data());
}
return mdl;

8
src/smt/qi_queue.cpp
View file

@ -121,7 +121,7 @@ namespace smt {
float qi_queue::get_cost(quantifier * q, app * pat, unsigned generation, unsigned min_top_generation, unsigned max_top_generation) {
q::quantifier_stat * stat = set_values(q, pat, generation, min_top_generation, max_top_generation, 0);
float r = m_evaluator(m_cost_function, m_vals.size(), m_vals.c_ptr());
float r = m_evaluator(m_cost_function, m_vals.size(), m_vals.data());
stat->update_max_cost(r);
return r;
}
@ -129,7 +129,7 @@ namespace smt {
unsigned qi_queue::get_new_gen(quantifier * q, unsigned generation, float cost) {
// max_top_generation and min_top_generation are not available for computing inc_gen
set_values(q, nullptr, generation, 0, 0, cost);
float r = m_evaluator(m_new_gen_function, m_vals.size(), m_vals.c_ptr());
float r = m_evaluator(m_new_gen_function, m_vals.size(), m_vals.data());
return std::max(generation + 1, static_cast<unsigned>(r));
}
@ -254,7 +254,7 @@ namespace smt {
ptr_vector<expr> args;
args.push_back(m.mk_not(q));
args.append(to_app(s_instance)->get_num_args(), to_app(s_instance)->get_args());
lemma = m.mk_or(args.size(), args.c_ptr());
lemma = m.mk_or(args.size(), args.data());
}
else if (m.is_false(s_instance)) {
lemma = m.mk_not(q);
@ -274,7 +274,7 @@ namespace smt {
bindings_e.push_back(bindings[i]->get_expr());
}
app * bare_lemma = m.mk_or(m.mk_not(q), instance);
proof * qi_pr = m.mk_quant_inst(bare_lemma, num_bindings, bindings_e.c_ptr());
proof * qi_pr = m.mk_quant_inst(bare_lemma, num_bindings, bindings_e.data());
proof_id = qi_pr->get_id();
if (bare_lemma == lemma) {
pr1 = qi_pr;

32
src/smt/seq_eq_solver.cpp
View file

@ -195,9 +195,9 @@ bool theory_seq::len_based_split(depeq const& e) {
TRACE("seq", display_equation(tout, e););
sort* srt = ls[0]->get_sort();
expr_ref x11 = expr_ref(ls[0], m);
expr_ref x12 = mk_concat(ls.size()-1, ls.c_ptr()+1, srt);
expr_ref x12 = mk_concat(ls.size()-1, ls.data()+1, srt);
expr_ref y11 = expr_ref(rs[0], m);
expr_ref y12 = mk_concat(rs.size()-1, rs.c_ptr()+1, srt);
expr_ref y12 = mk_concat(rs.size()-1, rs.data()+1, srt);
expr_ref lenX11 = mk_len(x11);
expr_ref lenY11 = mk_len(y11);
@ -457,7 +457,7 @@ bool theory_seq::branch_binary_variable(depeq const& e) {
}
if (lenX <= rational(ys.size())) {
expr_ref_vector Ys(m);
Ys.append(ys.size(), ys.c_ptr());
Ys.append(ys.size(), ys.data());
m_eq_deps = e.dep();
if (m_eq.branch_unit_variable(x, Ys))
return true;
@ -675,9 +675,9 @@ bool theory_seq::branch_quat_variable(depeq const& e) {
if (xs == ys) {
expr_ref_vector xs1(m), xs2(m);
xs1.reset();
xs1.append(xs.size()-1, xs.c_ptr()+1);
xs1.append(xs.size()-1, xs.data()+1);
xs2.reset();
xs2.append(xs.size()-1, xs.c_ptr());
xs2.append(xs.size()-1, xs.data());
if (xs1.empty() || xs2.empty())
cond = true;
else if (!can_align_from_lhs(xs2, ys) && !can_align_from_rhs(xs1, ys))
@ -759,22 +759,22 @@ bool theory_seq::branch_quat_variable(depeq const& e) {
if (ctx.get_assignment(lit1) == l_false && ctx.get_assignment(lit2) == l_true) {
lits.push_back(~lit1);
lits.push_back(lit2);
return propagate_lit(nullptr, lits.size(), lits.c_ptr(), false_literal);
return propagate_lit(nullptr, lits.size(), lits.data(), false_literal);
}
if (ctx.get_assignment(lit1) == l_true && ctx.get_assignment(lit3) == l_true) {
lits.push_back(lit1);
lits.push_back(lit3);
return propagate_lit(nullptr, lits.size(), lits.c_ptr(), false_literal);
return propagate_lit(nullptr, lits.size(), lits.data(), false_literal);
}
if (ctx.get_assignment(lit1) == l_true && ctx.get_assignment(lit2) == l_false) {
lits.push_back(lit1);
lits.push_back(~lit2);
return propagate_lit(dep, lits.size(), lits.c_ptr(), false_literal);
return propagate_lit(dep, lits.size(), lits.data(), false_literal);
}
if (ctx.get_assignment(lit1) == l_false && ctx.get_assignment(lit3) == l_false) {
lits.push_back(~lit1);
lits.push_back(~lit3);
return propagate_lit(dep, lits.size(), lits.c_ptr(), false_literal);
return propagate_lit(dep, lits.size(), lits.data(), false_literal);
}
UNREACHABLE();
return false;
@ -838,7 +838,7 @@ bool theory_seq::find_branch_candidate(unsigned& start, dependency* dep, expr_re
expr_ref v0(m);
v0 = m_util.str.mk_empty(l->get_sort());
if (can_be_equal(ls.size() - 1, ls.c_ptr() + 1, rs.size(), rs.c_ptr())) {
if (can_be_equal(ls.size() - 1, ls.data() + 1, rs.size(), rs.data())) {
if (assume_equality(l, v0)) {
TRACE("seq", tout << mk_pp(l, m) << " " << v0 << "\n";);
return true;
@ -851,10 +851,10 @@ bool theory_seq::find_branch_candidate(unsigned& start, dependency* dep, expr_re
if (l == rs.get(j)) {
return false;
}
if (!can_be_equal(ls.size() - 1, ls.c_ptr() + 1, rs.size() - j - 1, rs.c_ptr() + j + 1)) {
if (!can_be_equal(ls.size() - 1, ls.data() + 1, rs.size() - j - 1, rs.data() + j + 1)) {
continue;
}
v0 = mk_concat(j + 1, rs.c_ptr());
v0 = mk_concat(j + 1, rs.data());
if (assume_equality(l, v0)) {
TRACE("seq", tout << mk_pp(l, m) << " " << v0 << "\n";);
++start;
@ -870,8 +870,8 @@ bool theory_seq::find_branch_candidate(unsigned& start, dependency* dep, expr_re
literal_vector lits;
lits.push_back(~mk_eq_empty(l));
for (unsigned i = 0; i < rs.size(); ++i) {
if (can_be_equal(ls.size() - 1, ls.c_ptr() + 1, rs.size() - i - 1, rs.c_ptr() + i + 1)) {
v0 = mk_concat(i + 1, rs.c_ptr());
if (can_be_equal(ls.size() - 1, ls.data() + 1, rs.size() - i - 1, rs.data() + i + 1)) {
v0 = mk_concat(i + 1, rs.data());
lits.push_back(~mk_eq(l, v0, false));
}
}
@ -981,7 +981,7 @@ bool theory_seq::propagate_length_coherence(expr* e) {
}
expr_ref emp(m_util.str.mk_empty(e->get_sort()), m);
elems.push_back(seq);
tail = mk_concat(elems.size(), elems.c_ptr());
tail = mk_concat(elems.size(), elems.data());
// len(e) >= low => e = tail;
expr_ref lo_e(m_autil.mk_numeral(lo, true), m);
expr_ref len_e_ge_lo(m_autil.mk_ge(mk_len(e), lo_e), m);
@ -1135,7 +1135,7 @@ bool theory_seq::solve_nth_eq(expr_ref_vector const& ls, expr_ref_vector const&
expr_ref_vector ls1(m), rs1(m);
expr_ref idx1(m_autil.mk_add(idx, m_autil.mk_int(1)), m);
m_rewrite(idx1);
expr_ref rhs = mk_concat(rs.size(), rs.c_ptr(), ls[0]->get_sort());
expr_ref rhs = mk_concat(rs.size(), rs.data(), ls[0]->get_sort());
if (m_nth_eq2_cache.contains(std::make_pair(rhs, ls[0])))
return false;
m_nth_eq2_cache.insert(std::make_pair(rhs, ls[0]));

2
src/smt/seq_ne_solver.cpp
View file

@ -108,7 +108,7 @@ bool theory_seq::propagate_ne2lit(unsigned idx) {
}
else {
TRACE("seq", tout << "propagate: " << undef_lit << "\n";);
propagate_lit(n.dep(), lits.size(), lits.c_ptr(), ~undef_lit);
propagate_lit(n.dep(), lits.size(), lits.data(), ~undef_lit);
}
return true;
}

2
src/smt/smt_checker.cpp
View file

@ -127,7 +127,7 @@ namespace smt {
return nullptr;
buffer.push_back(arg);
}
enode * e = m_context.get_enode_eq_to(n->get_decl(), num, buffer.c_ptr());
enode * e = m_context.get_enode_eq_to(n->get_decl(), num, buffer.data());
if (e == nullptr)
return nullptr;
return m_context.is_relevant(e) ? e : nullptr;

2
src/smt/smt_clause.cpp
View file

@ -122,7 +122,7 @@ namespace smt {
args.push_back(bool_var2expr_map[lit.var()]);
if (lit.sign()) args[args.size()-1] = m.mk_not(args.back());
}
expr_ref disj(m.mk_or(args.size(), args.c_ptr()), m);
expr_ref disj(m.mk_or(args.size(), args.data()), m);
return out << mk_pp(disj, m, 3);
}

2
src/smt/smt_clause_proof.cpp
View file

@ -149,7 +149,7 @@ namespace smt {
else {
ps.push_back(m.mk_const("clause-trail-end", m.mk_bool_sort()));
}
return proof_ref(m.mk_clause_trail(ps.size(), ps.c_ptr()), m);
return proof_ref(m.mk_clause_trail(ps.size(), ps.data()), m);
}
std::ostream& operator<<(std::ostream& out, clause_proof::status st) {

10
src/smt/smt_conflict_resolution.cpp
View file

@ -881,7 +881,7 @@ namespace smt {
app * e2_prime = m.mk_app(e2->get_decl(), e2->get_arg(1), e2->get_arg(0));
proof * pr1 = nullptr;
if (!prs.empty()) {
pr1 = m.mk_congruence(e1, e2_prime, prs.size(), prs.c_ptr());
pr1 = m.mk_congruence(e1, e2_prime, prs.size(), prs.data());
m_new_proofs.push_back(pr1);
}
else {
@ -908,7 +908,7 @@ namespace smt {
}
if (!visited)
return nullptr;
proof * pr = m.mk_congruence(n1->get_expr(), n2->get_expr(), prs.size(), prs.c_ptr());
proof * pr = m.mk_congruence(n1->get_expr(), n2->get_expr(), prs.size(), prs.data());
m_new_proofs.push_back(pr);
return pr;
}
@ -1042,7 +1042,7 @@ namespace smt {
tout << l.index() << " " << true_literal.index() << " " << false_literal.index() << " ";
m_ctx.display_literal(tout, l); tout << " --->\n";
tout << mk_ll_pp(l_exr, m););
pr = m.mk_unit_resolution(prs.size(), prs.c_ptr(), l_exr);
pr = m.mk_unit_resolution(prs.size(), prs.data(), l_exr);
m_new_proofs.push_back(pr);
return pr;
}
@ -1250,7 +1250,7 @@ namespace smt {
for (unsigned i = 0; i < sz; i++) {
tout << mk_ll_pp(prs1[i], m) << "\n";
});
pr = m.mk_transitivity(prs1.size(), prs1.c_ptr(), lhs->get_expr(), rhs->get_expr());
pr = m.mk_transitivity(prs1.size(), prs1.data(), lhs->get_expr(), rhs->get_expr());
}
m_new_proofs.push_back(pr);
TRACE("proof_gen_bug", tout << "eq2pr_saved: #" << lhs->get_owner_id() << " #" << rhs->get_owner_id() << "\n";);
@ -1346,7 +1346,7 @@ namespace smt {
switch (lits.size()) {
case 0: fact = nullptr; break;
case 1: fact = lits[0]; break;
default: fact = m.mk_or(lits.size(), lits.c_ptr());
default: fact = m.mk_or(lits.size(), lits.data());
}
if (fact == nullptr)
m_lemma_proof = pr;

4
src/smt/smt_conflict_resolution.h
View file

@ -233,11 +233,11 @@ namespace smt {
}
literal * get_lemma_literals() {
return m_lemma.c_ptr();
return m_lemma.data();
}
expr * * get_lemma_atoms() {
return m_lemma_atoms.c_ptr();
return m_lemma_atoms.data();
}
void release_lemma_atoms() {

6
src/smt/smt_consequences.cpp
View file

@ -244,8 +244,8 @@ namespace smt {
literal lit = mk_diseq(k, v);
literals.push_back(lit);
mk_clause(literals.size(), literals.c_ptr(), nullptr);
TRACE("context", display_literals_verbose(tout, literals.size(), literals.c_ptr()););
mk_clause(literals.size(), literals.data(), nullptr);
TRACE("context", display_literals_verbose(tout, literals.size(), literals.data()););
}
}
for (expr* e : to_delete) {
@ -330,7 +330,7 @@ namespace smt {
m_assumption2orig.insert(lit.var(), a);
}
lbool is_sat = check(assumptions.size(), assumptions.c_ptr());
lbool is_sat = check(assumptions.size(), assumptions.data());
if (is_sat != l_true) {
TRACE("context", tout << is_sat << "\n";);

22
src/smt/smt_context.cpp
View file

@ -2547,9 +2547,9 @@ namespace smt {
new_js = mk_justification(unit_resolution_justification(m_region,
js,
simp_lits.size(),
simp_lits.c_ptr()));
simp_lits.data()));
else
new_js = alloc(unit_resolution_justification, js, simp_lits.size(), simp_lits.c_ptr());
new_js = alloc(unit_resolution_justification, js, simp_lits.size(), simp_lits.data());
cls.set_justification(new_js);
}
return false;
@ -2605,10 +2605,10 @@ namespace smt {
js = mk_justification(unit_resolution_justification(m_region,
cls_js,
simp_lits.size(),
simp_lits.c_ptr()));
simp_lits.data()));
}
else {
js = alloc(unit_resolution_justification, cls_js, simp_lits.size(), simp_lits.c_ptr());
js = alloc(unit_resolution_justification, cls_js, simp_lits.size(), simp_lits.data());
// js took ownership of the justification object.
cls->set_justification(nullptr);
m_justifications.push_back(js);
@ -3081,7 +3081,7 @@ namespace smt {
literal l2 = *set_it;
if (l2 != l) {
b_justification js(l);
TRACE("theory_case_split", tout << "case split literal "; l2.display(tout, m, m_bool_var2expr.c_ptr()); tout << std::endl;);
TRACE("theory_case_split", tout << "case split literal "; l2.display(tout, m, m_bool_var2expr.data()); tout << std::endl;);
if (l2 == true_literal || l2 == false_literal || l2 == null_literal) continue;
assign(~l2, js);
if (inconsistent()) {
@ -3206,10 +3206,10 @@ namespace smt {
if (lits.size() >= 2) {
justification* js = nullptr;
if (m.proofs_enabled()) {
proof * pr = mk_clause_def_axiom(lits.size(), lits.c_ptr(), nullptr);
proof * pr = mk_clause_def_axiom(lits.size(), lits.data(), nullptr);
js = mk_justification(justification_proof_wrapper(*this, pr));
}
clausep = clause::mk(m, lits.size(), lits.c_ptr(), CLS_AUX, js);
clausep = clause::mk(m, lits.size(), lits.data(), CLS_AUX, js);
}
m_tmp_clauses.push_back(std::make_pair(clausep, lits));
}
@ -3238,7 +3238,7 @@ namespace smt {
}
if (unassigned != null_literal) {
shuffle(lits.size(), lits.c_ptr(), m_random);
shuffle(lits.size(), lits.data(), m_random);
push_scope();
assign(unassigned, b_justification::mk_axiom(), true);
return l_undef;
@ -3347,7 +3347,7 @@ namespace smt {
reset_assumptions();
pop_to_base_lvl(); // undo the push_scope() performed by init_assumptions
m_search_lvl = m_base_lvl;
std::sort(m_unsat_core.c_ptr(), m_unsat_core.c_ptr() + m_unsat_core.size(), ast_lt_proc());
std::sort(m_unsat_core.data(), m_unsat_core.data() + m_unsat_core.size(), ast_lt_proc());
TRACE("unsat_core_bug", tout << "unsat core:\n" << m_unsat_core << "\n";);
validate_unsat_core();
// theory validation of unsat core
@ -4188,7 +4188,7 @@ namespace smt {
for (unsigned i = 0; i < num_lits; i++) {
display_literal(tout, v[i]);
tout << "\n";
v[i].display(tout, m, m_bool_var2expr.c_ptr());
v[i].display(tout, m, m_bool_var2expr.data());
tout << "\n\n";
}
tout << "\n";);
@ -4601,7 +4601,7 @@ namespace smt {
subst.push_back(m.mk_var(i, f->get_domain(i)));
}
var_subst sub(m, true);
expr_ref bodyr = sub(rhs, subst.size(), subst.c_ptr());
expr_ref bodyr = sub(rhs, subst.size(), subst.data());
fi->set_else(bodyr);
m_model->register_decl(f, fi);

16
src/smt/smt_context.h
View file

@ -910,7 +910,7 @@ namespace smt {
void mk_th_axiom(theory_id tid, literal l1, literal l2, literal l3, unsigned num_params = 0, parameter * params = nullptr);
void mk_th_axiom(theory_id tid, literal_vector const& ls, unsigned num_params = 0, parameter * params = nullptr) {
mk_th_axiom(tid, ls.size(), ls.c_ptr(), num_params, params);
mk_th_axiom(tid, ls.size(), ls.data(), num_params, params);
}
void mk_th_lemma(theory_id tid, literal l1, literal l2, unsigned num_params = 0, parameter * params = nullptr) {
@ -928,7 +928,7 @@ namespace smt {
}
void mk_th_lemma(theory_id tid, literal_vector const& ls, unsigned num_params = 0, parameter * params = nullptr) {
mk_th_lemma(tid, ls.size(), ls.c_ptr(), num_params, params);
mk_th_lemma(tid, ls.size(), ls.data(), num_params, params);
}
/*
@ -1357,14 +1357,14 @@ namespace smt {
std::ostream& display_literal(std::ostream & out, literal l) const;
std::ostream& display_detailed_literal(std::ostream & out, literal l) const { l.display(out, m, m_bool_var2expr.c_ptr()); return out; }
std::ostream& display_detailed_literal(std::ostream & out, literal l) const { l.display(out, m, m_bool_var2expr.data()); return out; }
void display_literal_info(std::ostream & out, literal l) const;
std::ostream& display_literals(std::ostream & out, unsigned num_lits, literal const * lits) const;
std::ostream& display_literals(std::ostream & out, literal_vector const& lits) const {
return display_literals(out, lits.size(), lits.c_ptr());
return display_literals(out, lits.size(), lits.data());
}
std::ostream& display_literal_smt2(std::ostream& out, literal lit) const;
@ -1373,14 +1373,14 @@ namespace smt {
std::ostream& display_literals_smt2(std::ostream& out, unsigned num_lits, literal const* lits) const;
std::ostream& display_literals_smt2(std::ostream& out, literal_vector const& ls) const { return display_literals_smt2(out, ls.size(), ls.c_ptr()); }
std::ostream& display_literals_smt2(std::ostream& out, literal_vector const& ls) const { return display_literals_smt2(out, ls.size(), ls.data()); }
std::ostream& display_literal_verbose(std::ostream & out, literal lit) const;
std::ostream& display_literals_verbose(std::ostream & out, unsigned num_lits, literal const * lits) const;
std::ostream& display_literals_verbose(std::ostream & out, literal_vector const& lits) const {
return display_literals_verbose(out, lits.size(), lits.c_ptr());
return display_literals_verbose(out, lits.size(), lits.data());
}
void display_watch_list(std::ostream & out, literal l) const;
@ -1733,7 +1733,7 @@ namespace smt {
void assign_fixed(enode* n, expr* val, unsigned sz, literal const* explain);
void assign_fixed(enode* n, expr* val, literal_vector const& explain) {
assign_fixed(n, val, explain.size(), explain.c_ptr());
assign_fixed(n, val, explain.size(), explain.data());
}
void assign_fixed(enode* n, expr* val, literal explain) {
@ -1778,7 +1778,7 @@ namespace smt {
literal const *lits;
unsigned len;
pp_lits(context & ctx, unsigned len, literal const *lits) : ctx(ctx), lits(lits), len(len) {}
pp_lits(context & ctx, literal_vector const& ls) : ctx(ctx), lits(ls.c_ptr()), len(ls.size()) {}
pp_lits(context & ctx, literal_vector const& ls) : ctx(ctx), lits(ls.data()), len(ls.size()) {}
};
inline std::ostream & operator<<(std::ostream & out, pp_lits const & pp) {

12
src/smt/smt_context_pp.cpp
View file

@ -89,11 +89,11 @@ namespace smt {
}
std::ostream& context::display_literal(std::ostream & out, literal l) const {
l.display_compact(out, m_bool_var2expr.c_ptr()); return out;
l.display_compact(out, m_bool_var2expr.data()); return out;
}
std::ostream& context::display_literals(std::ostream & out, unsigned num_lits, literal const * lits) const {
display_compact(out, num_lits, lits, m_bool_var2expr.c_ptr()); return out;
display_compact(out, num_lits, lits, m_bool_var2expr.data()); return out;
}
std::ostream& context::display_literal_verbose(std::ostream & out, literal lit) const {
@ -101,7 +101,7 @@ namespace smt {
}
std::ostream& context::display_literals_verbose(std::ostream & out, unsigned num_lits, literal const * lits) const {
display_verbose(out, m, num_lits, lits, m_bool_var2expr.c_ptr(), "\n"); return out;
display_verbose(out, m, num_lits, lits, m_bool_var2expr.data(), "\n"); return out;
}
std::ostream& context::display_literal_smt2(std::ostream& out, literal l) const {
@ -120,7 +120,7 @@ namespace smt {
}
void context::display_literal_info(std::ostream & out, literal l) const {
l.display_compact(out, m_bool_var2expr.c_ptr());
l.display_compact(out, m_bool_var2expr.data());
display_literal_smt2(out, l);
out << "relevant: " << is_relevant(bool_var2expr(l.var())) << ", val: " << get_assignment(l) << "\n";
}
@ -171,7 +171,7 @@ namespace smt {
}
std::ostream& context::display_clause(std::ostream & out, clause const * cls) const {
cls->display_compact(out, m, m_bool_var2expr.c_ptr());
cls->display_compact(out, m, m_bool_var2expr.data());
return out;
}
@ -229,7 +229,7 @@ namespace smt {
display_literal(out << lit << " ", lit);
if (!is_relevant(lit)) out << " n ";
out << ": ";
display_verbose(out, m, 1, &lit, m_bool_var2expr.c_ptr());
display_verbose(out, m, 1, &lit, m_bool_var2expr.data());
if (level > 0) {
auto j = get_justification(lit.var());
display(out << " ", j);

2
src/smt/smt_farkas_util.cpp
View file

@ -347,7 +347,7 @@ namespace smt {
lits.push_back(extract_consequence(lo, hi));
lo = hi;
}
bool_rewriter(m).mk_or(lits.size(), lits.c_ptr(), res);
bool_rewriter(m).mk_or(lits.size(), lits.data(), res);
IF_VERBOSE(2, { if (lits.size() > 1) { verbose_stream() << "combined lemma: " << res << "\n"; } });
}
else {

2
src/smt/smt_implied_equalities.cpp
View file

@ -163,7 +163,7 @@ namespace {
}
for (unsigned i = 0; i < terms.size(); ++i) {
args[0] = terms[i].term;
terms[i].term = m.mk_app(m_array_util.get_family_id(), OP_SELECT, 0, nullptr, args.size(), args.c_ptr());
terms[i].term = m.mk_app(m_array_util.get_family_id(), OP_SELECT, 0, nullptr, args.size(), args.data());
}
assert_relevant(terms);
VERIFY(m_solver.check_sat(0,nullptr) != l_false);

6
src/smt/smt_induction.cpp
View file

@ -383,7 +383,7 @@ void induction_lemmas::create_hypotheses(unsigned depth, expr_ref_vector const&
void induction_lemmas::add_th_lemma(literal_vector const& lits) {
IF_VERBOSE(0, ctx.display_literals_verbose(verbose_stream() << "lemma:\n", lits) << "\n");
ctx.mk_clause(lits.size(), lits.c_ptr(), nullptr, smt::CLS_TH_AXIOM);
ctx.mk_clause(lits.size(), lits.data(), nullptr, smt::CLS_TH_AXIOM);
// CLS_TH_LEMMA, but then should re-instance if GC'ed
++m_num_lemmas;
}
@ -451,7 +451,7 @@ void induction_lemmas::apply_induction(literal lit, induction_positions_t const
induction_term_and_position_t itp(alpha, positions);
bool found = m_skolems.find(itp, itp);
if (found) {
sks.append(itp.m_skolems.size(), itp.m_skolems.c_ptr());
sks.append(itp.m_skolems.size(), itp.m_skolems.data());
}
unsigned i = 0;
@ -470,7 +470,7 @@ void induction_lemmas::apply_induction(literal lit, induction_positions_t const
++i;
}
if (!found) {
itp.m_skolems.append(sks.size(), sks.c_ptr());
itp.m_skolems.append(sks.size(), sks.data());
m_trail.push_back(alpha);
m_trail.append(sks);
m_skolems.insert(itp);

16
src/smt/smt_internalizer.cpp
View file

@ -248,7 +248,7 @@ namespace smt {
internalize_rec(arg, true);
lits.push_back(get_literal(arg));
}
mk_root_clause(lits.size(), lits.c_ptr(), pr);
mk_root_clause(lits.size(), lits.data(), pr);
add_or_rel_watches(to_app(n));
break;
}
@ -592,7 +592,7 @@ namespace smt {
vars.push_back(m.mk_var(sz - i - 1, q->get_decl_sort(i)));
}
array_util autil(m);
lam_app = autil.mk_select(vars.size(), vars.c_ptr());
lam_app = autil.mk_select(vars.size(), vars.data());
eq = m.mk_eq(lam_app, q->get_expr());
quantifier_ref fa(m);
expr * patterns[1] = { m.mk_pattern(lam_app) };
@ -1369,7 +1369,7 @@ namespace smt {
}
DEBUG_CODE(for (literal lit : simp_lits) SASSERT(get_assignment(lit) == l_true););
if (!simp_lits.empty()) {
j = mk_justification(unit_resolution_justification(m_region, j, simp_lits.size(), simp_lits.c_ptr()));
j = mk_justification(unit_resolution_justification(m_region, j, simp_lits.size(), simp_lits.data()));
}
break;
}
@ -1429,7 +1429,7 @@ namespace smt {
bool save_atoms = lemma && iscope_lvl > m_base_lvl;
bool reinit = save_atoms;
SASSERT(!lemma || j == 0 || !j->in_region());
clause * cls = clause::mk(m, num_lits, lits, k, j, del_eh, save_atoms, m_bool_var2expr.c_ptr());
clause * cls = clause::mk(m, num_lits, lits, k, j, del_eh, save_atoms, m_bool_var2expr.data());
m_clause_proof.add(*cls);
if (lemma) {
cls->set_activity(activity);
@ -1506,7 +1506,7 @@ namespace smt {
literal_buffer tmp;
neg_literals(num_lits, lits, tmp);
SASSERT(tmp.size() == num_lits);
display_lemma_as_smt_problem(tmp.size(), tmp.c_ptr(), false_literal, m_fparams.m_logic);
display_lemma_as_smt_problem(tmp.size(), tmp.data(), false_literal, m_fparams.m_logic);
}
mk_clause(num_lits, lits, js, k);
}
@ -1532,7 +1532,7 @@ namespace smt {
if (root_gate)
new_lits.push_back(m.mk_not(root_gate));
SASSERT(num_lits > 1);
expr * fact = m.mk_or(new_lits.size(), new_lits.c_ptr());
expr * fact = m.mk_or(new_lits.size(), new_lits.data());
return m.mk_def_axiom(fact);
}
@ -1644,7 +1644,7 @@ namespace smt {
mk_gate_clause(~l, l_arg);
buffer.push_back(~l_arg);
}
mk_gate_clause(buffer.size(), buffer.c_ptr());
mk_gate_clause(buffer.size(), buffer.data());
}
void context::mk_or_cnstr(app * n) {
@ -1656,7 +1656,7 @@ namespace smt {
mk_gate_clause(l, ~l_arg);
buffer.push_back(l_arg);
}
mk_gate_clause(buffer.size(), buffer.c_ptr());
mk_gate_clause(buffer.size(), buffer.data());
}
void context::mk_iff_cnstr(app * n, bool sign) {

22
src/smt/smt_justification.cpp
View file

@ -98,7 +98,7 @@ namespace smt {
TRACE("unit_resolution_justification_bug",
tout << "in mk_proof\n" << literal_vector(m_num_literals, m_literals) << "\n";
for (proof* p : prs) tout << mk_ll_pp(m.get_fact(p), m););
return m.mk_unit_resolution(prs.size(), prs.c_ptr());
return m.mk_unit_resolution(prs.size(), prs.data());
}
void eq_conflict_justification::get_antecedents(conflict_resolution & cr) {
@ -141,7 +141,7 @@ namespace smt {
expr * lhs = m_node1->get_root()->get_expr();
expr * rhs = m_node2->get_root()->get_expr();
proof * pr1 = m.mk_transitivity(prs.size(), prs.c_ptr(), lhs, rhs);
proof * pr1 = m.mk_transitivity(prs.size(), prs.data(), lhs, rhs);
proof * pr2 = m.mk_rewrite(m.mk_eq(lhs, rhs), m.mk_false());
return m.mk_modus_ponens(pr1, pr2);
}
@ -275,9 +275,9 @@ namespace smt {
lits.push_back(std::move(l));
}
if (lits.size() == 1)
return m.mk_th_lemma(m_th_id, lits.get(0), 0, nullptr, m_params.size(), m_params.c_ptr());
return m.mk_th_lemma(m_th_id, lits.get(0), 0, nullptr, m_params.size(), m_params.data());
else
return m.mk_th_lemma(m_th_id, m.mk_or(lits.size(), lits.c_ptr()), 0, nullptr, m_params.size(), m_params.c_ptr());
return m.mk_th_lemma(m_th_id, m.mk_or(lits.size(), lits.data()), 0, nullptr, m_params.size(), m_params.data());
}
proof * theory_propagation_justification::mk_proof(conflict_resolution & cr) {
@ -288,7 +288,7 @@ namespace smt {
ast_manager & m = cr.get_manager();
expr_ref fact(m);
ctx.literal2expr(m_consequent, fact);
return m.mk_th_lemma(m_th_id, fact, prs.size(), prs.c_ptr(), m_params.size(), m_params.c_ptr());
return m.mk_th_lemma(m_th_id, fact, prs.size(), prs.data(), m_params.size(), m_params.data());
}
proof * theory_conflict_justification::mk_proof(conflict_resolution & cr) {
@ -296,7 +296,7 @@ namespace smt {
if (!antecedent2proof(cr, prs))
return nullptr;
ast_manager & m = cr.get_manager();
return m.mk_th_lemma(m_th_id, m.mk_false(), prs.size(), prs.c_ptr(), m_params.size(), m_params.c_ptr());
return m.mk_th_lemma(m_th_id, m.mk_false(), prs.size(), prs.data(), m_params.size(), m_params.data());
}
ext_simple_justification::ext_simple_justification(region & r, unsigned num_lits, literal const * lits, unsigned num_eqs, enode_pair const * eqs):
@ -340,7 +340,7 @@ namespace smt {
ast_manager & m = cr.get_manager();
expr_ref fact(m);
ctx.literal2expr(m_consequent, fact);
return m.mk_th_lemma(m_th_id, fact, prs.size(), prs.c_ptr(), m_params.size(), m_params.c_ptr());
return m.mk_th_lemma(m_th_id, fact, prs.size(), prs.data(), m_params.size(), m_params.data());
}
proof * ext_theory_conflict_justification::mk_proof(conflict_resolution & cr) {
@ -348,7 +348,7 @@ namespace smt {
if (!antecedent2proof(cr, prs))
return nullptr;
ast_manager & m = cr.get_manager();
return m.mk_th_lemma(m_th_id, m.mk_false(), prs.size(), prs.c_ptr(), m_params.size(), m_params.c_ptr());
return m.mk_th_lemma(m_th_id, m.mk_false(), prs.size(), prs.data(), m_params.size(), m_params.data());
}
proof * ext_theory_eq_propagation_justification::mk_proof(conflict_resolution & cr) {
@ -358,7 +358,7 @@ namespace smt {
ast_manager & m = cr.get_manager();
context & ctx = cr.get_context();
expr * fact = ctx.mk_eq_atom(m_lhs->get_expr(), m_rhs->get_expr());
return m.mk_th_lemma(m_th_id, fact, prs.size(), prs.c_ptr(), m_params.size(), m_params.c_ptr());
return m.mk_th_lemma(m_th_id, fact, prs.size(), prs.data(), m_params.size(), m_params.data());
}
@ -401,9 +401,9 @@ namespace smt {
lits.push_back(sign ? m.mk_not(v) : v);
}
if (lits.size() == 1)
return m.mk_th_lemma(m_th_id, lits.get(0), 0, nullptr, m_params.size(), m_params.c_ptr());
return m.mk_th_lemma(m_th_id, lits.get(0), 0, nullptr, m_params.size(), m_params.data());
else
return m.mk_th_lemma(m_th_id, m.mk_or(lits.size(), lits.c_ptr()), 0, nullptr, m_params.size(), m_params.c_ptr());
return m.mk_th_lemma(m_th_id, m.mk_or(lits.size(), lits.data()), 0, nullptr, m_params.size(), m_params.data());
}
};

4
src/smt/smt_kernel.h
View file

@ -128,9 +128,9 @@ namespace smt {
*/
lbool check(unsigned num_assumptions = 0, expr * const * assumptions = nullptr);
lbool check(expr_ref_vector const& asms) { return check(asms.size(), asms.c_ptr()); }
lbool check(expr_ref_vector const& asms) { return check(asms.size(), asms.data()); }
lbool check(app_ref_vector const& asms) { return check(asms.size(), (expr* const*)asms.c_ptr()); }
lbool check(app_ref_vector const& asms) { return check(asms.size(), (expr* const*)asms.data()); }
lbool check(expr_ref_vector const& cube, vector<expr_ref_vector> const& clauses);

14
src/smt/smt_model_checker.cpp
View file

@ -85,7 +85,7 @@ namespace smt {
for (expr* arg : *to_app(val)) {
args.push_back(get_type_compatible_term(arg));
}
fresh_term = m.mk_app(to_app(val)->get_decl(), args.size(), args.c_ptr());
fresh_term = m.mk_app(to_app(val)->get_decl(), args.size(), args.data());
}
else {
expr * sk_term = get_term_from_ctx(val);
@ -152,7 +152,7 @@ namespace smt {
for (expr * e : universe) {
eqs.push_back(m.mk_eq(sk, e));
}
expr_ref fml(m.mk_or(eqs.size(), eqs.c_ptr()), m);
expr_ref fml(m.mk_or(eqs.size(), eqs.data()), m);
m_aux_context->assert_expr(fml);
}
@ -186,7 +186,7 @@ namespace smt {
}
var_subst s(m);
expr_ref sk_body = s(tmp, subst_args.size(), subst_args.c_ptr());
expr_ref sk_body = s(tmp, subst_args.size(), subst_args.data());
expr_ref r(m);
r = m.mk_not(sk_body);
TRACE("model_checker", tout << "mk_neg_q_m:\n" << mk_ismt2_pp(r, m) << "\n";);
@ -249,7 +249,7 @@ namespace smt {
}
defined_names dn(m);
body = replace_value_from_ctx(body);
body = m.mk_lambda(sorts.size(), sorts.c_ptr(), names.c_ptr(), body);
body = m.mk_lambda(sorts.size(), sorts.data(), names.data(), body);
// sk_value = m.mk_fresh_const(0, m.get_sort(sk_value)); // get rid of as-array
body = dn.mk_definition(body, to_app(sk_value));
defs.push_back(body);
@ -309,7 +309,7 @@ namespace smt {
diseqs.push_back(m.mk_not(m.mk_eq(sk, sk_value)));
}
expr_ref blocking_clause(m);
blocking_clause = m.mk_or(diseqs.size(), diseqs.c_ptr());
blocking_clause = m.mk_or(diseqs.size(), diseqs.data());
TRACE("model_checker", tout << "blocking clause:\n" << mk_ismt2_pp(blocking_clause, m) << "\n";);
m_aux_context->assert_expr(blocking_clause);
return true;
@ -557,8 +557,8 @@ namespace smt {
TRACE("model_checker_bug_detail", tout << "instantiating... q:\n" << mk_pp(q, m) << "\n";
tout << "inconsistent: " << m_context->inconsistent() << "\n";
tout << "bindings:\n" << expr_ref_vector(m, num_decls, m_pinned_exprs.c_ptr() + offset) << "\n";);
m_context->add_instance(q, nullptr, num_decls, bindings.c_ptr(), inst.m_def, gen, gen, gen, dummy);
tout << "bindings:\n" << expr_ref_vector(m, num_decls, m_pinned_exprs.data() + offset) << "\n";);
m_context->add_instance(q, nullptr, num_decls, bindings.data(), inst.m_def, gen, gen, gen, dummy);
TRACE("model_checker_bug_detail", tout << "after instantiating, inconsistent: " << m_context->inconsistent() << "\n";);
}
}

4
src/smt/smt_model_finder.cpp
View file

@ -1076,7 +1076,7 @@ namespace smt {
// f_aux will be assigned to the old interpretation of f.
func_decl* f_aux = m.mk_fresh_func_decl(f->get_name(), symbol::null, arity, f->get_domain(), f->get_range());
func_interp* new_fi = alloc(func_interp, m, arity);
new_fi->set_else(m.mk_app(f_aux, args.size(), args.c_ptr()));
new_fi->set_else(m.mk_app(f_aux, args.size(), args.data()));
TRACE("model_finder", tout << "Setting new interpretation for " << f->get_name() << "\n" <<
mk_pp(new_fi->get_else(), m) << "\n";
tout << "old interpretation: " << mk_pp(fi->get_interp(), m) << "\n";);
@ -2551,7 +2551,7 @@ namespace smt {
eqs.push_back(m.mk_eq(sk, val));
}
expr_ref new_cnstr(m);
new_cnstr = m.mk_or(eqs.size(), eqs.c_ptr());
new_cnstr = m.mk_or(eqs.size(), eqs.data());
TRACE("model_finder", tout << "assert_restriction:\n" << mk_pp(new_cnstr, m) << "\n";);
aux_ctx->assert_expr(new_cnstr);
asserted_something = true;

4
src/smt/smt_model_generator.cpp
View file

@ -437,8 +437,8 @@ namespace smt {
}
tout << "\n";
tout << "value: #" << n->get_owner_id() << "\n" << mk_ismt2_pp(result, m) << "\n";);
if (fi->get_entry(args.c_ptr()) == nullptr)
fi->insert_new_entry(args.c_ptr(), result);
if (fi->get_entry(args.data()) == nullptr)
fi->insert_new_entry(args.data(), result);
}
}
}

4
src/smt/smt_parallel.cpp
View file

@ -50,7 +50,7 @@ namespace smt {
// try first sequential with a low conflict budget to make super easy problems cheap
unsigned max_c = std::min(thread_max_conflicts, 40u);
flet<unsigned> _mc(ctx.get_fparams().m_max_conflicts, max_c);
result = ctx.check(asms.size(), asms.c_ptr());
result = ctx.check(asms.size(), asms.data());
if (result != l_undef || ctx.m_num_conflicts < max_c) {
return result;
}
@ -156,7 +156,7 @@ namespace smt {
if (num_rounds > 0) verbose_stream() << " :round " << num_rounds;
if (c) verbose_stream() << " :cube " << mk_bounded_pp(c, pm, 3);
verbose_stream() << ")\n";);
lbool r = pctx.check(lasms.size(), lasms.c_ptr());
lbool r = pctx.check(lasms.size(), lasms.data());
if (r == l_undef && pctx.m_num_conflicts >= max_conflicts) {
// no-op

12
src/smt/smt_quick_checker.cpp
View file

@ -222,7 +222,7 @@ namespace smt {
do {
for (unsigned i = 0; i < m_num_bindings; i++)
m_bindings[m_num_bindings - i - 1] = m_candidate_vectors[i][it[i]];
if (!m_context.contains_instance(q, m_num_bindings, m_bindings.c_ptr())) {
if (!m_context.contains_instance(q, m_num_bindings, m_bindings.data())) {
bool is_candidate = false;
TRACE("quick_checker", tout << "processing bindings:";
for (unsigned i = 0; i < m_num_bindings; i++) tout << " #" << m_bindings[i]->get_owner_id();
@ -235,8 +235,8 @@ namespace smt {
TRACE("quick_checker", tout << "found new candidate\n";);
TRACE("quick_checker_sizes", tout << "found new candidate\n";
for (unsigned i = 0; i < m_num_bindings; i++) tout << "#" << m_bindings[i]->get_owner_id() << " "; tout << "\n";);
unsigned max_generation = get_max_generation(m_num_bindings, m_bindings.c_ptr());
if (m_context.add_instance(q, nullptr /* no pattern was used */, m_num_bindings, m_bindings.c_ptr(), nullptr,
unsigned max_generation = get_max_generation(m_num_bindings, m_bindings.data());
if (m_context.add_instance(q, nullptr /* no pattern was used */, m_num_bindings, m_bindings.data(), nullptr,
max_generation,
0, // min_top_generation is only available for instances created by the MAM
0, // max_top_generation is only available for instances created by the MAM
@ -245,7 +245,7 @@ namespace smt {
}
}
}
while (product_iterator_next(szs.size(), szs.c_ptr(), it.c_ptr()));
while (product_iterator_next(szs.size(), szs.data(), it.data()));
return result;
}
@ -380,7 +380,7 @@ namespace smt {
has_arg_enodes = false;
}
if (has_arg_enodes) {
enode * e = m_context.get_enode_eq_to(to_app(n)->get_decl(), num_args, new_arg_enodes.c_ptr());
enode * e = m_context.get_enode_eq_to(to_app(n)->get_decl(), num_args, new_arg_enodes.data());
if (e) {
m_canonize_cache.insert(n, e->get_root()->get_expr());
return e->get_root()->get_expr();
@ -398,7 +398,7 @@ namespace smt {
}
}
expr_ref new_expr(m_manager);
new_expr = m_context.get_rewriter().mk_app(to_app(n)->get_decl(), num_args, new_args.c_ptr());
new_expr = m_context.get_rewriter().mk_app(to_app(n)->get_decl(), num_args, new_args.data());
m_new_exprs.push_back(new_expr);
m_canonize_cache.insert(n, new_expr);
return new_expr;

6
src/smt/smt_setup.cpp
View file

@ -150,7 +150,7 @@ namespace smt {
IF_VERBOSE(100, verbose_stream() << "(smt.collecting-features)\n";);
ptr_vector<expr> fmls;
m_context.get_asserted_formulas(fmls);
st.collect(fmls.size(), fmls.c_ptr());
st.collect(fmls.size(), fmls.data());
TRACE("setup", st.display_primitive(tout););
IF_VERBOSE(1000, st.display_primitive(verbose_stream()););
if (m_logic == "QF_UF")
@ -785,7 +785,7 @@ namespace smt {
IF_VERBOSE(100, verbose_stream() << "(smt.collecting-features)\n";);
ptr_vector<expr> fmls;
m_context.get_asserted_formulas(fmls);
st.collect(fmls.size(), fmls.c_ptr());
st.collect(fmls.size(), fmls.data());
IF_VERBOSE(1000, st.display_primitive(verbose_stream()););
bool fixnum = st.arith_k_sum_is_small() && m_params.m_arith_fixnum;
bool int_only = !st.m_has_rational && !st.m_has_real && m_params.m_arith_int_only;
@ -953,7 +953,7 @@ namespace smt {
static_features st(m_manager);
ptr_vector<expr> fmls;
m_context.get_asserted_formulas(fmls);
st.collect(fmls.size(), fmls.c_ptr());
st.collect(fmls.size(), fmls.data());
TRACE("setup", tout << "setup_unknown\n";);
setup_arith();
setup_arrays();

6
src/smt/smt_solver.cpp
View file

@ -264,7 +264,7 @@ namespace {
if (!m_minimizing_core && smt_params_helper(get_params()).core_minimize()) {
scoped_minimize_core scm(*this);
mus mus(*this);
mus.add_soft(r.size(), r.c_ptr());
mus.add_soft(r.size(), r.data());
expr_ref_vector r2(m);
if (l_true == mus.get_mus(r2)) {
r.reset();
@ -297,7 +297,7 @@ namespace {
void get_labels(svector<symbol> & r) override {
buffer<symbol> tmp;
m_context.get_relevant_labels(nullptr, tmp);
r.append(tmp.size(), tmp.c_ptr());
r.append(tmp.size(), tmp.data());
}
ast_manager & get_manager() const override { return m_context.m(); }
@ -435,7 +435,7 @@ namespace {
}
}
core.append(new_core_literals.size(), new_core_literals.c_ptr());
core.append(new_core_literals.size(), new_core_literals.data());
if (new_core_literals.empty())
break;

6
src/smt/tactic/ctx_solver_simplify_tactic.cpp
View file

@ -102,7 +102,7 @@ protected:
return;
ptr_vector<expr> fmls;
g.get_formulas(fmls);
fml = mk_and(m, fmls.size(), fmls.c_ptr());
fml = mk_and(m, fmls.size(), fmls.data());
m_solver.push();
reduce(fml);
m_solver.pop(1);
@ -120,7 +120,7 @@ protected:
// enable_trace("after_search");
m_solver.push();
expr_ref fml1(m);
fml1 = mk_and(m, fmls.size(), fmls.c_ptr());
fml1 = mk_and(m, fmls.size(), fmls.data());
fml1 = m.mk_iff(fml, fml1);
fml1 = m.mk_not(fml1);
m_solver.assert_expr(fml1);
@ -240,7 +240,7 @@ protected:
args.push_back(arg);
}
}
m_mk_app(a->get_decl(), args.size(), args.c_ptr(), res);
m_mk_app(a->get_decl(), args.size(), args.data(), res);
trail.push_back(res);
// child needs to be visited.
if (n2) {

6
src/smt/tactic/smt_tactic_core.cpp
View file

@ -200,7 +200,7 @@ public:
if (assumptions.empty())
r = m_ctx->setup_and_check();
else
r = m_ctx->check(assumptions.size(), assumptions.c_ptr());
r = m_ctx->check(assumptions.size(), assumptions.data());
}
catch(...) {
TRACE("smt_tactic", tout << "exception\n";);
@ -225,7 +225,7 @@ public:
buffer<symbol> r;
m_ctx->get_relevant_labels(nullptr, r);
labels_vec rv;
rv.append(r.size(), r.c_ptr());
rv.append(r.size(), r.data());
model_converter_ref mc;
mc = model_and_labels2model_converter(md.get(), rv);
mc = concat(fmc.get(), mc.get());
@ -288,7 +288,7 @@ public:
buffer<symbol> r;
m_ctx->get_relevant_labels(nullptr, r);
labels_vec rv;
rv.append(r.size(), r.c_ptr());
rv.append(r.size(), r.data());
in->add(model_and_labels2model_converter(md.get(), rv));
}
return;

4
src/smt/theory_arith.h
View file

@ -254,8 +254,8 @@ namespace smt {
void append(unsigned sz, literal const* ls) { m_lits.append(sz, ls); }
void append(unsigned sz, enode_pair const* ps) { m_eqs.append(sz, ps); }
unsigned num_params() const { return empty()?0:m_eq_coeffs.size() + m_lit_coeffs.size() + 1; }
numeral const* lit_coeffs() const { return m_lit_coeffs.c_ptr(); }
numeral const* eq_coeffs() const { return m_eq_coeffs.c_ptr(); }
numeral const* lit_coeffs() const { return m_lit_coeffs.data(); }
numeral const* eq_coeffs() const { return m_eq_coeffs.data(); }
parameter* params(char const* name);
std::ostream& display(theory_arith& th, std::ostream& out) const;
};

6
src/smt/theory_arith_aux.h
View file

@ -359,7 +359,7 @@ namespace smt {
if (empty()) return nullptr;
init();
m_params[0] = parameter(symbol(name));
return m_params.c_ptr();
return m_params.data();
}
// -----------------------------------
@ -746,8 +746,8 @@ namespace smt {
a.push_eq(e, coeff, proofs_enabled);
}
else {
a.append(m_lits.size(), m_lits.c_ptr());
a.append(m_eqs.size(), m_eqs.c_ptr());
a.append(m_lits.size(), m_lits.data());
a.append(m_eqs.size(), m_eqs.data());
}
}

24
src/smt/theory_arith_core.h
View file

@ -888,7 +888,7 @@ namespace smt {
void theory_arith<Ext>::normalize_quasi_base_row(unsigned r_id) {
buffer<linear_monomial> to_add;
collect_vars(r_id, QUASI_BASE, to_add);
add_rows(r_id, to_add.size(), to_add.c_ptr());
add_rows(r_id, to_add.size(), to_add.data());
SASSERT(!has_var_kind(r_id, QUASI_BASE));
}
@ -910,7 +910,7 @@ namespace smt {
display_row_info(tout, get_var_row(v));
tout << "\n";
});
add_rows(r_id, to_add.size(), to_add.c_ptr());
add_rows(r_id, to_add.size(), to_add.data());
theory_var s = m_rows[r_id].get_base_var();
set_var_kind(s, BASE);
inf_numeral tmp;
@ -2942,8 +2942,8 @@ namespace smt {
void theory_arith<Ext>::dump_lemmas(literal l, antecedents const& ante) {
if (dump_lemmas()) {
TRACE("arith", ante.display(tout) << " --> "; ctx.display_detailed_literal(tout, l); tout << "\n";);
ctx.display_lemma_as_smt_problem(ante.lits().size(), ante.lits().c_ptr(),
ante.eqs().size(), ante.eqs().c_ptr(), l);
ctx.display_lemma_as_smt_problem(ante.lits().size(), ante.lits().data(),
ante.eqs().size(), ante.eqs().data(), l);
}
}
@ -2951,8 +2951,8 @@ namespace smt {
template<typename Ext>
void theory_arith<Ext>::dump_lemmas(literal l, derived_bound const& ante) {
if (dump_lemmas()) {
ctx.display_lemma_as_smt_problem(ante.lits().size(), ante.lits().c_ptr(),
ante.eqs().size(), ante.eqs().c_ptr(), l);
ctx.display_lemma_as_smt_problem(ante.lits().size(), ante.lits().data(),
ante.eqs().size(), ante.eqs().data(), l);
}
}
@ -2978,17 +2978,17 @@ namespace smt {
lits.push_back(~(*it));
justification * js = nullptr;
if (proofs_enabled()) {
js = alloc(theory_lemma_justification, get_id(), ctx, lits.size(), lits.c_ptr(),
js = alloc(theory_lemma_justification, get_id(), ctx, lits.size(), lits.data(),
ante.num_params(), ante.params("assign-bounds"));
}
ctx.mk_clause(lits.size(), lits.c_ptr(), js, CLS_TH_LEMMA, nullptr);
ctx.mk_clause(lits.size(), lits.data(), js, CLS_TH_LEMMA, nullptr);
}
else {
region & r = ctx.get_region();
ctx.assign(l, ctx.mk_justification(
ext_theory_propagation_justification(
get_id(), r, ante.lits().size(), ante.lits().c_ptr(),
ante.eqs().size(), ante.eqs().c_ptr(), l,
get_id(), r, ante.lits().size(), ante.lits().data(),
ante.eqs().size(), ante.eqs().data(), l,
ante.num_params(), ante.params("assign-bounds"))));
}
}
@ -3049,13 +3049,13 @@ namespace smt {
template<typename Ext>
void theory_arith<Ext>::set_conflict(antecedents const& ante, antecedents& bounds, char const* proof_rule) {
set_conflict(ante.lits().size(), ante.lits().c_ptr(), ante.eqs().size(), ante.eqs().c_ptr(), bounds, proof_rule);
set_conflict(ante.lits().size(), ante.lits().data(), ante.eqs().size(), ante.eqs().data(), bounds, proof_rule);
dump_lemmas(false_literal, ante);
}
template<typename Ext>
void theory_arith<Ext>::set_conflict(derived_bound const& ante, antecedents& bounds, char const* proof_rule) {
set_conflict(ante.lits().size(), ante.lits().c_ptr(), ante.eqs().size(), ante.eqs().c_ptr(), bounds, proof_rule);
set_conflict(ante.lits().size(), ante.lits().data(), ante.eqs().size(), ante.eqs().data(), bounds, proof_rule);
dump_lemmas(false_literal, ante);
}

4
src/smt/theory_arith_eq.h
View file

@ -337,8 +337,8 @@ namespace smt {
ctx.mk_justification(
ext_theory_eq_propagation_justification(
get_id(), r,
lits.size(), lits.c_ptr(),
eqs.size(), eqs.c_ptr(),
lits.size(), lits.data(),
eqs.size(), eqs.data(),
_x, _y,
antecedents.num_params(), antecedents.params("eq-propagate")));
TRACE("arith_eq", tout << "detected equality: #" << _x->get_owner_id() << " = #" << _y->get_owner_id() << "\n";

18
src/smt/theory_arith_int.h
View file

@ -371,11 +371,11 @@ namespace smt {
}
expr_ref p1(get_manager()), p2(get_manager());
mk_polynomial_ge(pol.size(), pol.c_ptr(), -unsat_row[0]+rational(1), p1);
mk_polynomial_ge(pol.size(), pol.data(), -unsat_row[0]+rational(1), p1);
for (unsigned i = 0; i < pol.size(); ++i) {
pol[i].m_coeff.neg();
}
mk_polynomial_ge(pol.size(), pol.c_ptr(), unsat_row[0]+rational(1), p2);
mk_polynomial_ge(pol.size(), pol.data(), unsat_row[0]+rational(1), p2);
{
std::function<expr*(void)> fn = [&]() { return m.mk_or(p1, p2); };
@ -475,7 +475,7 @@ namespace smt {
}
expr_ref pol(m);
pol = m_util.mk_add(_args.size(), _args.c_ptr());
pol = m_util.mk_add(_args.size(), _args.data());
result = m_util.mk_ge(pol, m_util.mk_numeral(k, all_int));
TRACE("arith_mk_polynomial", tout << "before simplification:\n" << result << "\n";);
proof_ref pr(m);
@ -663,7 +663,7 @@ namespace smt {
}
tout << "k: " << k << "\n";);
}
mk_polynomial_ge(pol.size(), pol.c_ptr(), k.to_rational(), bound);
mk_polynomial_ge(pol.size(), pol.data(), k.to_rational(), bound);
}
TRACE("gomory_cut", tout << "new cut:\n" << bound << "\n"; ante.display(tout););
literal l = null_literal;
@ -680,8 +680,8 @@ namespace smt {
auto js = ctx.mk_justification(
gomory_cut_justification(
get_id(), ctx.get_region(),
ante.lits().size(), ante.lits().c_ptr(),
ante.eqs().size(), ante.eqs().c_ptr(), ante, l));
ante.lits().size(), ante.lits().data(),
ante.eqs().size(), ante.eqs().data(), ante, l));
if (l == false_literal) {
ctx.mk_clause(0, nullptr, js, CLS_TH_LEMMA, nullptr);
@ -760,8 +760,8 @@ namespace smt {
ctx.set_conflict(
ctx.mk_justification(
ext_theory_conflict_justification(
get_id(), ctx.get_region(), ante.lits().size(), ante.lits().c_ptr(),
ante.eqs().size(), ante.eqs().c_ptr(),
get_id(), ctx.get_region(), ante.lits().size(), ante.lits().data(),
ante.eqs().size(), ante.eqs().data(),
ante.num_params(), ante.params("gcd-test"))));
return false;
}
@ -841,7 +841,7 @@ namespace smt {
ctx.mk_justification(
ext_theory_conflict_justification(
get_id(), ctx.get_region(),
ante.lits().size(), ante.lits().c_ptr(), ante.eqs().size(), ante.eqs().c_ptr(),
ante.lits().size(), ante.lits().data(), ante.eqs().size(), ante.eqs().data(),
ante.num_params(), ante.params("gcd-test"))));
return false;
}

16
src/smt/theory_arith_nl.h
View file

@ -1184,7 +1184,7 @@ expr_ref theory_arith<Ext>::p2expr(buffer<coeff_expr> & p) {
}
}
SASSERT(!args.empty());
expr_ref r(mk_nary_add(args.size(), args.c_ptr()), get_manager());
expr_ref r(mk_nary_add(args.size(), args.data()), get_manager());
m_nl_new_exprs.push_back(r);
return r;
}
@ -1367,7 +1367,7 @@ expr * theory_arith<Ext>::factor(expr * m, expr * var, unsigned d) {
insert(m);
SASSERT(idx == d);
TRACE("factor_bug", tout << "new_args:\n"; for(unsigned i = 0; i < new_args.size(); i++) tout << mk_pp(new_args[i], get_manager()) << "\n";);
expr * result = mk_nary_mul(new_args.size(), new_args.c_ptr(), m_util.is_int(var));
expr * result = mk_nary_mul(new_args.size(), new_args.data(), m_util.is_int(var));
m_nl_new_exprs.push_back(result);
TRACE("factor", tout << "result: " << mk_pp(result, get_manager()) << "\n";);
return result;
@ -1720,7 +1720,7 @@ grobner::monomial * theory_arith<Ext>::mk_gb_monomial(rational const & _coeff, e
proc_var(m);
if (!coeff.is_zero())
return gb.mk_monomial(coeff, vars.size(), vars.c_ptr());
return gb.mk_monomial(coeff, vars.size(), vars.data());
else
return nullptr;
}
@ -1748,7 +1748,7 @@ void theory_arith<Ext>::add_row_to_gb(row const & r, grobner & gb) {
monomials.push_back(new_m);
}
}
gb.assert_eq_0(monomials.size(), monomials.c_ptr(), dep);
gb.assert_eq_0(monomials.size(), monomials.data(), dep);
}
/**
@ -1776,7 +1776,7 @@ void theory_arith<Ext>::add_monomial_def_to_gb(theory_var v, grobner & gb) {
else {
monomials.push_back(gb.mk_monomial(coeff, 1, &m));
}
gb.assert_eq_0(monomials.size(), monomials.c_ptr(), dep);
gb.assert_eq_0(monomials.size(), monomials.data(), dep);
}
/**
@ -2059,7 +2059,7 @@ bool theory_arith<Ext>::is_inconsistent2(grobner::equation const * eq, grobner &
if (monomials.size() == num)
return false; // didn't find any perfect square.
interval ge_zero(m_dep_manager, rational(0), false, true, nullptr);
if (is_inconsistent(ge_zero, monomials.size(), monomials.c_ptr(), eq->get_dependency())) {
if (is_inconsistent(ge_zero, monomials.size(), monomials.data(), eq->get_dependency())) {
TRACE("non_linear", tout << "found conflict\n"; gb.display_equation(tout, *eq););
return true;
}
@ -2074,7 +2074,7 @@ expr * theory_arith<Ext>::monomial2expr(grobner::monomial const * m, bool is_int
args.push_back(m_util.mk_numeral(m->get_coeff(), is_int));
for (unsigned j = 0; j < num_vars; j++)
args.push_back(m->get_var(j));
return mk_nary_mul(args.size(), args.c_ptr(), is_int);
return mk_nary_mul(args.size(), args.data(), is_int);
}
/**
@ -2104,7 +2104,7 @@ bool theory_arith<Ext>::internalize_gb_eq(grobner::equation const * eq) {
th_rewriter& s = ctx.get_rewriter();
expr_ref pol(get_manager());
SASSERT(!args.empty());
pol = mk_nary_add(args.size(), args.c_ptr());
pol = mk_nary_add(args.size(), args.data());
expr_ref s_pol(get_manager());
proof_ref pr(get_manager());
TRACE("gb_bug", tout << mk_ll_pp(pol, get_manager()) << "\n";);

2
src/smt/theory_arith_pp.h
View file

@ -418,7 +418,7 @@ namespace smt {
template<typename Ext>
std::ostream& theory_arith<Ext>::antecedents_t::display(theory_arith& th, std::ostream & out) const {
th.get_context().display_literals_verbose(out, lits().size(), lits().c_ptr());
th.get_context().display_literals_verbose(out, lits().size(), lits().data());
if (!lits().empty()) out << "\n";
ast_manager& m = th.get_manager();
for (auto const& e : m_eqs) {

6
src/smt/theory_array.cpp
View file

@ -454,11 +454,11 @@ namespace smt {
out << std::right;
out << " is_array: " << d->m_is_array << " is_select: " << d->m_is_select << " upward: " << d->m_prop_upward;
out << " stores: {";
display_ids(out, d->m_stores.size(), d->m_stores.c_ptr());
display_ids(out, d->m_stores.size(), d->m_stores.data());
out << "} p_stores: {";
display_ids(out, d->m_parent_stores.size(), d->m_parent_stores.c_ptr());
display_ids(out, d->m_parent_stores.size(), d->m_parent_stores.data());
out << "} p_selects: {";
display_ids(out, d->m_parent_selects.size(), d->m_parent_selects.c_ptr());
display_ids(out, d->m_parent_selects.size(), d->m_parent_selects.data());
out << "}";
out << "\n";
}

4
src/smt/theory_array_bapa.cpp
View file

@ -430,13 +430,13 @@ namespace smt {
lits.push_back(mk_eq(args[0], args[1]));
}
else {
expr_ref diff(m.mk_distinct_expanded(args.size(), args.c_ptr()), m);
expr_ref diff(m.mk_distinct_expanded(args.size(), args.data()), m);
lits.push_back(~mk_literal(diff));
}
}
expr_ref ge(m_arith.mk_ge(sz->get_arg(1), m_arith.mk_int(info.m_selects.size())), m);
lits.push_back(mk_literal(ge));
mk_th_axiom(lits.size(), lits.c_ptr());
mk_th_axiom(lits.size(), lits.data());
return l_false;
}
return l_true;

28
src/smt/theory_array_base.cpp
View file

@ -104,7 +104,7 @@ namespace smt {
sel_args.push_back(to_app(n->get_arg(i)));
}
expr_ref sel(m);
sel = mk_select(sel_args.size(), sel_args.c_ptr());
sel = mk_select(sel_args.size(), sel_args.data());
expr * val = n->get_arg(num_args - 1);
TRACE("array", tout << mk_bounded_pp(sel, m) << " = " << mk_bounded_pp(val, m) << "\n";);
if (m.proofs_enabled()) {
@ -167,8 +167,8 @@ namespace smt {
}
if (!init) {
sel1 = mk_select(sel1_args.size(), sel1_args.c_ptr());
sel2 = mk_select(sel2_args.size(), sel2_args.c_ptr());
sel1 = mk_select(sel1_args.size(), sel1_args.data());
sel2 = mk_select(sel2_args.size(), sel2_args.data());
if (sel1 == sel2) {
TRACE("array_bug", tout << "sel1 and sel2 are equal:\n";);
break;
@ -331,8 +331,8 @@ namespace smt {
args1.push_back(k);
args2.push_back(k);
}
expr_ref sel1(mk_select(args1.size(), args1.c_ptr()), m);
expr_ref sel2(mk_select(args2.size(), args2.c_ptr()), m);
expr_ref sel1(mk_select(args1.size(), args1.data()), m);
expr_ref sel2(mk_select(args2.size(), args2.data()), m);
TRACE("ext", tout << mk_bounded_pp(sel1, m) << "\n" << mk_bounded_pp(sel2, m) << "\n";);
literal n1_eq_n2 = mk_eq(e1, e2, true);
literal sel1_eq_sel2 = mk_eq(sel1, sel2, true);
@ -370,10 +370,10 @@ namespace smt {
args1.push_back(k);
args2.push_back(k);
}
expr * sel1 = mk_select(dimension+1, args1.c_ptr());
expr * sel2 = mk_select(dimension+1, args2.c_ptr());
expr * sel1 = mk_select(dimension+1, args1.data());
expr * sel2 = mk_select(dimension+1, args2.data());
expr * eq = m.mk_eq(sel1, sel2);
expr_ref q(m.mk_forall(dimension, sorts.c_ptr(), names.c_ptr(), eq), m);
expr_ref q(m.mk_forall(dimension, sorts.data(), names.data(), eq), m);
ctx.get_rewriter()(q);
if (!ctx.b_internalized(q)) {
ctx.internalize(q, true);
@ -401,7 +401,7 @@ namespace smt {
}
es[j++] = e->get_arg(i);
}
f = sub(q, es.size(), es.c_ptr());
f = sub(q, es.size(), es.data());
}
return f;
}
@ -545,8 +545,8 @@ namespace smt {
r->set_mark();
to_unmark.push_back(r);
}
TRACE("array", tout << "collecting shared vars...\n" << unsigned_vector(result.size(), (unsigned*)result.c_ptr()) << "\n";);
unmark_enodes(to_unmark.size(), to_unmark.c_ptr());
TRACE("array", tout << "collecting shared vars...\n" << unsigned_vector(result.size(), (unsigned*)result.data()) << "\n";);
unmark_enodes(to_unmark.size(), to_unmark.data());
}
#endif
@ -934,7 +934,7 @@ namespace smt {
}
void get_dependencies(buffer<model_value_dependency> & result) override {
result.append(m_dependencies.size(), m_dependencies.c_ptr());
result.append(m_dependencies.size(), m_dependencies.data());
}
app * mk_value(model_generator & mg, expr_ref_vector const & values) override {
@ -967,7 +967,7 @@ namespace smt {
args.push_back(values[idx]);
expr * result = values[idx];
idx++;
fi->insert_entry(args.c_ptr(), result);
fi->insert_entry(args.data(), result);
}
parameter p[1] = { parameter(f) };
@ -1034,7 +1034,7 @@ namespace smt {
for (unsigned j = 1; j < num; ++j)
args.push_back(select->get_arg(j));
SASSERT(ctx.is_relevant(select));
result->add_entry(args.size(), args.c_ptr(), select);
result->add_entry(args.size(), args.data(), select);
}
}
TRACE("array",

2
src/smt/theory_array_base.h
View file

@ -62,7 +62,7 @@ namespace smt {
bool is_select_arg(enode* r);
app * mk_select(unsigned num_args, expr * const * args);
app * mk_select(expr_ref_vector const& args) { return mk_select(args.size(), args.c_ptr()); }
app * mk_select(expr_ref_vector const& args) { return mk_select(args.size(), args.data()); }
app * mk_store(unsigned num_args, expr * const * args);
app * mk_default(expr* a);

20
src/smt/theory_array_full.cpp
View file

@ -210,11 +210,11 @@ namespace smt {
theory_array::display_var(out, v);
var_data_full const * d = m_var_data_full[v];
out << " maps: {";
display_ids(out, d->m_maps.size(), d->m_maps.c_ptr());
display_ids(out, d->m_maps.size(), d->m_maps.data());
out << "} p_parent_maps: {";
display_ids(out, d->m_parent_maps.size(), d->m_parent_maps.c_ptr());
display_ids(out, d->m_parent_maps.size(), d->m_parent_maps.data());
out << "} p_const: {";
display_ids(out, d->m_consts.size(), d->m_consts.c_ptr());
display_ids(out, d->m_consts.size(), d->m_consts.data());
out << "}\n";
}
@ -486,13 +486,13 @@ namespace smt {
args1.push_back(arg);
}
for (unsigned j = 0; j < num_arrays; ++j) {
expr* sel = mk_select(args2l[j].size(), args2l[j].c_ptr());
expr* sel = mk_select(args2l[j].size(), args2l[j].data());
args2.push_back(sel);
}
expr_ref sel1(m), sel2(m);
sel1 = mk_select(args1.size(), args1.c_ptr());
sel2 = m.mk_app(f, args2.size(), args2.c_ptr());
sel1 = mk_select(args1.size(), args1.data());
sel2 = m.mk_app(f, args2.size(), args2.data());
ctx.get_rewriter()(sel2);
ctx.internalize(sel1, false);
ctx.internalize(sel2, false);
@ -528,7 +528,7 @@ namespace smt {
args2.push_back(mk_default(arg));
}
expr_ref def2(m.mk_app(f, args2.size(), args2.c_ptr()), m);
expr_ref def2(m.mk_app(f, args2.size(), args2.data()), m);
ctx.get_rewriter()(def2);
expr* def1 = mk_default(map);
ctx.internalize(def1, false);
@ -630,7 +630,7 @@ namespace smt {
for (unsigned short i = 1; i < num_args; ++i) {
sel_args.push_back(select->get_expr()->get_arg(i));
}
expr * sel = mk_select(sel_args.size(), sel_args.c_ptr());
expr * sel = mk_select(sel_args.size(), sel_args.data());
expr * val = cnst->get_expr()->get_arg(0);
TRACE("array", tout << "new select-const axiom...\n";
tout << "const: " << mk_bounded_pp(cnst->get_expr(), m) << "\n";
@ -664,9 +664,9 @@ namespace smt {
for (unsigned short i = 1; i < num_args; ++i) {
sel_args.push_back(select->get_expr()->get_arg(i));
}
expr * sel = mk_select(sel_args.size(), sel_args.c_ptr());
expr * sel = mk_select(sel_args.size(), sel_args.data());
func_decl * f = array_util(m).get_as_array_func_decl(arr->get_expr());
expr_ref val(m.mk_app(f, sel_args.size()-1, sel_args.c_ptr()+1), m);
expr_ref val(m.mk_app(f, sel_args.size()-1, sel_args.data()+1), m);
TRACE("array", tout << "new select-as-array axiom...\n";
tout << "as-array: " << mk_bounded_pp(arr->get_expr(), m) << "\n";
tout << "select: " << mk_bounded_pp(select->get_expr(), m) << "\n";

32
src/smt/theory_bv.cpp
View file

@ -55,7 +55,7 @@ namespace smt {
for (unsigned i = 0; i < bv_size; i++) {
m_bits_expr.push_back(mk_bit2bool(owner, i));
}
ctx.internalize(m_bits_expr.c_ptr(), bv_size, true);
ctx.internalize(m_bits_expr.data(), bv_size, true);
for (unsigned i = 0; i < bv_size; i++) {
bool_var b = ctx.get_bool_var(m_bits_expr[i]);
@ -325,7 +325,7 @@ namespace smt {
SASSERT(get_bv_size(n) == sz);
m_bits[v].reset();
ctx.internalize(bits.c_ptr(), sz, true);
ctx.internalize(bits.data(), sz, true);
for (unsigned i = 0; i < sz; i++) {
expr * bit = bits.get(i);
@ -420,7 +420,7 @@ namespace smt {
return nullptr;
expr * fact = ctx.mk_eq_atom(m_th.get_enode(m_var1)->get_expr(), m_th.get_enode(m_var2)->get_expr());
ast_manager & m = ctx.get_manager();
return m.mk_th_lemma(get_from_theory(), fact, prs.size(), prs.c_ptr());
return m.mk_th_lemma(get_from_theory(), fact, prs.size(), prs.data());
}
theory_id get_from_theory() const override {
@ -471,7 +471,7 @@ namespace smt {
eqs.push_back(~eq);
}
eqs.push_back(oeq);
ctx.mk_th_axiom(get_id(), eqs.size(), eqs.c_ptr());
ctx.mk_th_axiom(get_id(), eqs.size(), eqs.data());
}
void theory_bv::fixed_var_eh(theory_var v) {
@ -634,7 +634,7 @@ namespace smt {
args.push_back(m.mk_ite(b, n, zero));
num *= numeral(2);
}
expr_ref sum(m_autil.mk_add(sz, args.c_ptr()), m);
expr_ref sum(m_autil.mk_add(sz, args.data()), m);
th_rewriter rw(m);
rw(sum);
literal l(mk_eq(n, sum, false));
@ -727,7 +727,7 @@ namespace smt {
enode * e = mk_enode(n); \
expr_ref_vector arg1_bits(m), bits(m); \
get_arg_bits(e, 0, arg1_bits); \
m_bb.BLAST_OP(arg1_bits.size(), arg1_bits.c_ptr(), bits); \
m_bb.BLAST_OP(arg1_bits.size(), arg1_bits.data(), bits); \
init_bits(e, bits); \
}
@ -741,7 +741,7 @@ namespace smt {
get_arg_bits(e, 0, arg1_bits); \
get_arg_bits(e, 1, arg2_bits); \
SASSERT(arg1_bits.size() == arg2_bits.size()); \
m_bb.BLAST_OP(arg1_bits.size(), arg1_bits.c_ptr(), arg2_bits.c_ptr(), bits); \
m_bb.BLAST_OP(arg1_bits.size(), arg1_bits.data(), arg2_bits.data(), bits); \
init_bits(e, bits); \
}
@ -764,7 +764,7 @@ namespace smt {
get_arg_bits(e, i, arg_bits); \
SASSERT(arg_bits.size() == bits.size()); \
new_bits.reset(); \
m_bb.BLAST_OP(arg_bits.size(), arg_bits.c_ptr(), bits.c_ptr(), new_bits); \
m_bb.BLAST_OP(arg_bits.size(), arg_bits.data(), bits.data(), new_bits); \
bits.swap(new_bits); \
} \
init_bits(e, bits); \
@ -781,7 +781,7 @@ namespace smt {
get_arg_bits(e, 1, arg2_bits);
SASSERT(arg1_bits.size() == arg2_bits.size());
expr_ref carry(m);
m_bb.mk_subtracter(arg1_bits.size(), arg1_bits.c_ptr(), arg2_bits.c_ptr(), bits, carry);
m_bb.mk_subtracter(arg1_bits.size(), arg1_bits.data(), arg2_bits.data(), bits, carry);
init_bits(e, bits);
}
@ -818,7 +818,7 @@ namespace smt {
expr_ref_vector arg1_bits(m), bits(m); \
get_arg_bits(e, 0, arg1_bits); \
unsigned param = n->get_decl()->get_parameter(0).get_int(); \
m_bb.BLAST_OP(arg1_bits.size(), arg1_bits.c_ptr(), param, bits); \
m_bb.BLAST_OP(arg1_bits.size(), arg1_bits.data(), param, bits); \
init_bits(e, bits); \
}
@ -939,7 +939,7 @@ namespace smt {
get_arg_bits(n, 0, arg1_bits); \
get_arg_bits(n, 1, arg2_bits); \
expr_ref out(m); \
m_bb.OP(arg1_bits.size(), arg1_bits.c_ptr(), arg2_bits.c_ptr(), out); \
m_bb.OP(arg1_bits.size(), arg1_bits.data(), arg2_bits.data(), out); \
expr_ref s_out(m); \
simplify_bit(out, s_out); \
ctx.internalize(s_out, true); \
@ -973,9 +973,9 @@ namespace smt {
get_arg_bits(n, 1, arg2_bits);
expr_ref le(m);
if (Signed)
m_bb.mk_sle(arg1_bits.size(), arg1_bits.c_ptr(), arg2_bits.c_ptr(), le);
m_bb.mk_sle(arg1_bits.size(), arg1_bits.data(), arg2_bits.data(), le);
else
m_bb.mk_ule(arg1_bits.size(), arg1_bits.c_ptr(), arg2_bits.c_ptr(), le);
m_bb.mk_ule(arg1_bits.size(), arg1_bits.data(), arg2_bits.data(), le);
expr_ref s_le(m);
simplify_bit(le, s_le);
ctx.internalize(s_le, true);
@ -1197,7 +1197,7 @@ namespace smt {
m_stats.m_num_diseq_dynamic++;
scoped_trace_stream st(*this, lits);
ctx.mk_th_axiom(get_id(), lits.size(), lits.c_ptr());
ctx.mk_th_axiom(get_id(), lits.size(), lits.data());
}
void theory_bv::assign_eh(bool_var v, bool is_true) {
@ -1313,7 +1313,7 @@ namespace smt {
ctx.mark_as_relevant(lits[2]);
{
scoped_trace_stream _sts(*this, lits);
ctx.mk_th_axiom(get_id(), lits.size(), lits.c_ptr());
ctx.mk_th_axiom(get_id(), lits.size(), lits.data());
}
}
@ -1623,7 +1623,7 @@ namespace smt {
ast_manager & m = cr.get_manager();
expr_ref fact(m);
ctx.literal2expr(m_consequent, fact);
return m.mk_th_lemma(get_from_theory(), fact, prs.size(), prs.c_ptr());
return m.mk_th_lemma(get_from_theory(), fact, prs.size(), prs.data());
}
theory_id get_from_theory() const override {

14
src/smt/theory_char.cpp
View file

@ -121,12 +121,12 @@ namespace smt {
else {
for (unsigned i = 0; i < seq.num_bits(); ++i)
ebits.push_back(seq.mk_char_bit(e, i));
ctx.internalize(ebits.c_ptr(), ebits.size(), true);
ctx.internalize(ebits.data(), ebits.size(), true);
for (expr* arg : ebits)
bits.push_back(literal(ctx.get_bool_var(arg)));
for (literal bit : bits)
ctx.mark_as_relevant(bit);
expr_ref bits2char(seq.mk_skolem(m_bits2char, ebits.size(), ebits.c_ptr(), e->get_sort()), m);
expr_ref bits2char(seq.mk_skolem(m_bits2char, ebits.size(), ebits.data(), e->get_sort()), m);
ctx.mark_as_relevant(bits2char.get());
enode* n1 = ensure_enode(e);
enode* n2 = ensure_enode(bits2char);
@ -148,7 +148,7 @@ namespace smt {
auto const& b1 = get_ebits(v1);
auto const& b2 = get_ebits(v2);
expr_ref e(m);
m_bb.mk_ule(b1.size(), b1.c_ptr(), b2.c_ptr(), e);
m_bb.mk_ule(b1.size(), b1.data(), b2.data(), e);
literal le = mk_literal(e);
ctx.mark_as_relevant(le);
ctx.mk_th_axiom(get_id(), ~lit, le);
@ -170,8 +170,8 @@ namespace smt {
auto const& zv = get_ebits(z);
auto const& nv = get_ebits(n);
expr_ref le1(m), le2(m);
m_bb.mk_ule(bv.size(), zv.c_ptr(), bv.c_ptr(), le1);
m_bb.mk_ule(bv.size(), bv.c_ptr(), nv.c_ptr(), le2);
m_bb.mk_ule(bv.size(), zv.data(), bv.data(), le1);
m_bb.mk_ule(bv.size(), bv.data(), nv.data(), le2);
literal lit1 = mk_literal(le1);
literal lit2 = mk_literal(le2);
ctx.mk_th_axiom(get_id(), ~lit, lit1);
@ -353,7 +353,7 @@ namespace smt {
auto const& mbits = get_ebits(w);
auto const& bits = get_ebits(v);
expr_ref le(m);
m_bb.mk_ule(bits.size(), bits.c_ptr(), mbits.c_ptr(), le);
m_bb.mk_ule(bits.size(), bits.data(), mbits.data(), le);
ctx.assign(mk_literal(le), nullptr);
++m_stats.m_num_bounds;
}
@ -378,7 +378,7 @@ namespace smt {
}
// a = b => eq
lits.push_back(eq);
ctx.mk_th_axiom(get_id(), lits.size(), lits.c_ptr());
ctx.mk_th_axiom(get_id(), lits.size(), lits.data());
++m_stats.m_num_ackerman;
}

18
src/smt/theory_datatype.cpp
View file

@ -50,8 +50,8 @@ namespace smt {
}
void theory_datatype::clear_mark() {
unmark_enodes(m_to_unmark.size(), m_to_unmark.c_ptr());
unmark_enodes2(m_to_unmark2.size(), m_to_unmark2.c_ptr());
unmark_enodes(m_to_unmark.size(), m_to_unmark.data());
unmark_enodes2(m_to_unmark2.size(), m_to_unmark2.data());
m_to_unmark.reset();
m_to_unmark2.reset();
}
@ -185,7 +185,7 @@ namespace smt {
std::function<void(void)> fn = [&]() {
app_ref body(m);
body = m.mk_eq(arg->get_expr(), acc_app);
log_axiom_instantiation(body, base_id + 3*i, bindings.size(), bindings.c_ptr(), base_id - 3, used_enodes);
log_axiom_instantiation(body, base_id + 3*i, bindings.size(), bindings.data(), base_id - 3, used_enodes);
};
scoped_trace_stream _st(m, fn);
assert_eq_axiom(arg, acc_app, null_literal);
@ -670,7 +670,7 @@ namespace smt {
// m_used_eqs should contain conflict
region & r = ctx.get_region();
clear_mark();
ctx.set_conflict(ctx.mk_justification(ext_theory_conflict_justification(get_id(), r, 0, nullptr, m_used_eqs.size(), m_used_eqs.c_ptr())));
ctx.set_conflict(ctx.mk_justification(ext_theory_conflict_justification(get_id(), r, 0, nullptr, m_used_eqs.size(), m_used_eqs.data())));
}
return res;
}
@ -760,11 +760,11 @@ namespace smt {
void add_dependency(enode * n) { m_dependencies.push_back(model_value_dependency(n)); }
~datatype_value_proc() override {}
void get_dependencies(buffer<model_value_dependency> & result) override {
result.append(m_dependencies.size(), m_dependencies.c_ptr());
result.append(m_dependencies.size(), m_dependencies.data());
}
app * mk_value(model_generator & mg, expr_ref_vector const & values) override {
SASSERT(values.size() == m_dependencies.size());
return mg.get_manager().mk_app(m_constructor, values.size(), values.c_ptr());
return mg.get_manager().mk_app(m_constructor, values.size(), values.data());
}
};
@ -917,7 +917,7 @@ namespace smt {
for (auto const& p : eqs) {
tout << enode_eq_pp(p, ctx);
});
ctx.set_conflict(ctx.mk_justification(ext_theory_conflict_justification(get_id(), reg, lits.size(), lits.c_ptr(), eqs.size(), eqs.c_ptr())));
ctx.set_conflict(ctx.mk_justification(ext_theory_conflict_justification(get_id(), reg, lits.size(), lits.data(), eqs.size(), eqs.data())));
}
else if (num_unassigned == 1) {
// propagate remaining recognizer
@ -937,8 +937,8 @@ namespace smt {
ctx.mark_as_relevant(consequent);
region & reg = ctx.get_region();
ctx.assign(consequent,
ctx.mk_justification(ext_theory_propagation_justification(get_id(), reg, lits.size(), lits.c_ptr(),
eqs.size(), eqs.c_ptr(), consequent)));
ctx.mk_justification(ext_theory_propagation_justification(get_id(), reg, lits.size(), lits.data(),
eqs.size(), eqs.data(), consequent)));
}
else {
// there are more than 2 unassigned recognizers...

14
src/smt/theory_dense_diff_logic_def.h
View file

@ -539,7 +539,7 @@ namespace smt {
literal_vector & antecedents = m_tmp_literals;
antecedents.reset();
get_antecedents(source, target, antecedents);
ctx.assign(l, ctx.mk_justification(theory_propagation_justification(get_id(), ctx.get_region(), antecedents.size(), antecedents.c_ptr(), l)));
ctx.assign(l, ctx.mk_justification(theory_propagation_justification(get_id(), ctx.get_region(), antecedents.size(), antecedents.data(), l)));
}
template<typename Ext>
@ -592,10 +592,10 @@ namespace smt {
if (l != null_literal)
antecedents.push_back(l);
region & r = ctx.get_region();
ctx.set_conflict(ctx.mk_justification(theory_conflict_justification(get_id(), r, antecedents.size(), antecedents.c_ptr())));
ctx.set_conflict(ctx.mk_justification(theory_conflict_justification(get_id(), r, antecedents.size(), antecedents.data())));
if (dump_lemmas()) {
ctx.display_lemma_as_smt_problem(antecedents.size(), antecedents.c_ptr(), false_literal);
ctx.display_lemma_as_smt_problem(antecedents.size(), antecedents.data(), false_literal);
}
return;
@ -962,7 +962,7 @@ namespace smt {
vars[0] = e.m_target;
vars[1] = e.m_source;
vars[2] = base_var;
S.add_row(base_var, 3, vars.c_ptr(), coeffs.c_ptr());
S.add_row(base_var, 3, vars.data(), coeffs.data());
// t - s <= w
// =>
// t - s - b = 0, b <= w
@ -984,7 +984,7 @@ namespace smt {
}
coeffs.push_back(mpq(1));
vars.push_back(w);
Simplex::row row = S.add_row(w, vars.size(), vars.c_ptr(), coeffs.c_ptr());
Simplex::row row = S.add_row(w, vars.size(), vars.data(), coeffs.data());
TRACE("opt", S.display(tout); display(tout););
@ -1098,7 +1098,7 @@ namespace smt {
else {
//
expr_ref_vector const& core = m_objective_assignments[v];
f = m.mk_and(core.size(), core.c_ptr());
f = m.mk_and(core.size(), core.data());
if (is_strict) {
f = m.mk_not(f);
}
@ -1114,7 +1114,7 @@ namespace smt {
}
else {
expr_ref_vector const& core = m_objective_assignments[v];
f = m.mk_and(core.size(), core.c_ptr());
f = m.mk_and(core.size(), core.data());
}
}
else {

22
src/smt/theory_diff_logic_def.h
View file

@ -651,7 +651,7 @@ void theory_diff_logic<Ext>::new_edge(dl_var src, dl_var dst, unsigned num_edges
TRACE("dl_activity",
tout << mk_pp(le, m) << "\n";
tout << "edge: " << a->get_pos() << "\n";
ctx.display_literals_verbose(tout, lits.size(), lits.c_ptr());
ctx.display_literals_verbose(tout, lits.size(), lits.data());
tout << "\n";
);
@ -661,13 +661,13 @@ void theory_diff_logic<Ext>::new_edge(dl_var src, dl_var dst, unsigned num_edges
params.push_back(parameter(symbol("farkas")));
params.resize(lits.size()+1, parameter(rational(1)));
js = new (ctx.get_region()) theory_lemma_justification(get_id(), ctx,
lits.size(), lits.c_ptr(),
params.size(), params.c_ptr());
lits.size(), lits.data(),
params.size(), params.data());
}
ctx.mk_clause(lits.size(), lits.c_ptr(), js, CLS_TH_LEMMA, nullptr);
ctx.mk_clause(lits.size(), lits.data(), js, CLS_TH_LEMMA, nullptr);
if (dump_lemmas()) {
symbol logic(m_lia_or_lra == is_lia ? "QF_LIA" : "QF_LRA");
ctx.display_lemma_as_smt_problem(lits.size(), lits.c_ptr(), false_literal, logic);
ctx.display_lemma_as_smt_problem(lits.size(), lits.data(), false_literal, logic);
}
#if 0
@ -709,7 +709,7 @@ void theory_diff_logic<Ext>::set_neg_cycle_conflict() {
if (dump_lemmas()) {
symbol logic(m_lia_or_lra == is_lia ? "QF_LIA" : "QF_LRA");
ctx.display_lemma_as_smt_problem(lits.size(), lits.c_ptr(), false_literal, logic);
ctx.display_lemma_as_smt_problem(lits.size(), lits.data(), false_literal, logic);
}
vector<parameter> params;
@ -724,7 +724,7 @@ void theory_diff_logic<Ext>::set_neg_cycle_conflict() {
ctx.mk_justification(
ext_theory_conflict_justification(
get_id(), ctx.get_region(),
lits.size(), lits.c_ptr(), 0, nullptr, params.size(), params.c_ptr())));
lits.size(), lits.data(), 0, nullptr, params.size(), params.data())));
}
@ -1182,7 +1182,7 @@ void theory_diff_logic<Ext>::update_simplex(Simplex& S) {
vars[0] = node2simplex(e.get_target());
vars[1] = node2simplex(e.get_source());
vars[2] = base_var;
S.add_row(base_var, 3, vars.c_ptr(), coeffs.c_ptr());
S.add_row(base_var, 3, vars.data(), coeffs.data());
}
m_num_simplex_edges = es.size();
for (unsigned i = 0; i < es.size(); ++i) {
@ -1214,7 +1214,7 @@ void theory_diff_logic<Ext>::update_simplex(Simplex& S) {
}
coeffs.push_back(mpq(1));
vars.push_back(w);
Simplex::row row = S.add_row(w, vars.size(), vars.c_ptr(), coeffs.c_ptr());
Simplex::row row = S.add_row(w, vars.size(), vars.data(), coeffs.data());
m_objective_rows.push_back(row);
}
}
@ -1362,7 +1362,7 @@ expr_ref theory_diff_logic<Ext>::mk_ineq(theory_var v, inf_eps const& val, bool
else {
//
expr_ref_vector const& core = m_objective_assignments[v];
f = m.mk_and(core.size(), core.c_ptr());
f = m.mk_and(core.size(), core.data());
if (is_strict) {
f = m.mk_not(f);
}
@ -1378,7 +1378,7 @@ expr_ref theory_diff_logic<Ext>::mk_ineq(theory_var v, inf_eps const& val, bool
}
else {
expr_ref_vector const& core = m_objective_assignments[v];
f = m.mk_and(core.size(), core.c_ptr());
f = m.mk_and(core.size(), core.data());
}
}
else {

50
src/smt/theory_lra.cpp
View file

@ -515,7 +515,7 @@ class theory_lra::imp {
vars.push_back(register_theory_var_in_lar_solver(w));
ensure_nla();
m_solver->register_existing_terms();
m_nla->add_monic(register_theory_var_in_lar_solver(v), vars.size(), vars.c_ptr());
m_nla->add_monic(register_theory_var_in_lar_solver(v), vars.size(), vars.data());
return v;
}
@ -537,7 +537,7 @@ class theory_lra::imp {
TRACE("arith", tout << "v" << v << " := " << mk_pp(t, m) << "\n" << vars << "\n";);
m_solver->register_existing_terms();
ensure_nla();
m_nla->add_monic(register_theory_var_in_lar_solver(v), vars.size(), vars.c_ptr());
m_nla->add_monic(register_theory_var_in_lar_solver(v), vars.size(), vars.data());
}
return v;
}
@ -1326,7 +1326,7 @@ public:
}
if (m.has_trace_stream()) {
app_ref body(m);
body = m.mk_or(exprs.size(), exprs.c_ptr());
body = m.mk_or(exprs.size(), exprs.data());
th.log_axiom_instantiation(body);
}
ctx().mk_th_axiom(get_id(), lits.size(), lits.begin());
@ -1455,7 +1455,7 @@ public:
}
tout << "\n"; );
if (!vars.empty()) {
lp().random_update(vars.size(), vars.c_ptr());
lp().random_update(vars.size(), vars.data());
}
}
@ -1813,7 +1813,7 @@ public:
t = ts.back();
}
else {
t = a.mk_add(ts.size(), ts.c_ptr());
t = a.mk_add(ts.size(), ts.data());
}
return t;
}
@ -1827,11 +1827,11 @@ public:
ts.push_back(multerm(cv.first, var2expr(cv.second)));
}
switch (c.kind()) {
case lp::LE: fml = a.mk_le(a.mk_add(ts.size(), ts.c_ptr()), a.mk_numeral(rhs, true)); break;
case lp::LT: fml = a.mk_lt(a.mk_add(ts.size(), ts.c_ptr()), a.mk_numeral(rhs, true)); break;
case lp::GE: fml = a.mk_ge(a.mk_add(ts.size(), ts.c_ptr()), a.mk_numeral(rhs, true)); break;
case lp::GT: fml = a.mk_gt(a.mk_add(ts.size(), ts.c_ptr()), a.mk_numeral(rhs, true)); break;
case lp::EQ: fml = m.mk_eq(a.mk_add(ts.size(), ts.c_ptr()), a.mk_numeral(rhs, true)); break;
case lp::LE: fml = a.mk_le(a.mk_add(ts.size(), ts.data()), a.mk_numeral(rhs, true)); break;
case lp::LT: fml = a.mk_lt(a.mk_add(ts.size(), ts.data()), a.mk_numeral(rhs, true)); break;
case lp::GE: fml = a.mk_ge(a.mk_add(ts.size(), ts.data()), a.mk_numeral(rhs, true)); break;
case lp::GT: fml = a.mk_gt(a.mk_add(ts.size(), ts.data()), a.mk_numeral(rhs, true)); break;
case lp::EQ: fml = m.mk_eq(a.mk_add(ts.size(), ts.data()), a.mk_numeral(rhs, true)); break;
case lp::NE:
SASSERT(false); // unexpected
break;
@ -1931,7 +1931,7 @@ public:
TRACE("arith", dump_cut_lemma(tout, m_lia->get_term(), m_lia->get_offset(), m_explanation, m_lia->is_upper()););
literal lit(ctx().get_bool_var(b), false);
TRACE("arith",
ctx().display_lemma_as_smt_problem(tout << "new cut:\n", m_core.size(), m_core.c_ptr(), m_eqs.size(), m_eqs.c_ptr(), lit);
ctx().display_lemma_as_smt_problem(tout << "new cut:\n", m_core.size(), m_core.data(), m_eqs.size(), m_eqs.data(), lit);
display(tout););
assign(lit, m_core, m_eqs, m_params);
lia_check = l_false;
@ -2297,17 +2297,17 @@ public:
m_core2.push_back(lit);
justification * js = nullptr;
if (proofs_enabled()) {
js = alloc(theory_lemma_justification, get_id(), ctx(), m_core2.size(), m_core2.c_ptr(),
params.size(), params.c_ptr());
js = alloc(theory_lemma_justification, get_id(), ctx(), m_core2.size(), m_core2.data(),
params.size(), params.data());
}
ctx().mk_clause(m_core2.size(), m_core2.c_ptr(), js, CLS_TH_LEMMA, nullptr);
ctx().mk_clause(m_core2.size(), m_core2.data(), js, CLS_TH_LEMMA, nullptr);
}
else {
ctx().assign(
lit, ctx().mk_justification(
ext_theory_propagation_justification(
get_id(), ctx().get_region(), core.size(), core.c_ptr(),
eqs.size(), eqs.c_ptr(), lit, params.size(), params.c_ptr())));
get_id(), ctx().get_region(), core.size(), core.data(),
eqs.size(), eqs.data(), lit, params.size(), params.data())));
}
}
@ -3037,7 +3037,7 @@ public:
justification* js =
ctx().mk_justification(
ext_theory_eq_propagation_justification(
get_id(), ctx().get_region(), m_core.size(), m_core.c_ptr(), m_eqs.size(), m_eqs.c_ptr(), x, y));
get_id(), ctx().get_region(), m_core.size(), m_core.data(), m_eqs.size(), m_eqs.data(), x, y));
TRACE("arith",
for (auto c : m_core)
@ -3170,8 +3170,8 @@ public:
ctx().mk_justification(
ext_theory_conflict_justification(
get_id(), ctx().get_region(),
m_core.size(), m_core.c_ptr(),
m_eqs.size(), m_eqs.c_ptr(), m_params.size(), m_params.c_ptr())));
m_core.size(), m_core.data(),
m_eqs.size(), m_eqs.data(), m_params.size(), m_params.data())));
}
else {
for (auto const& eq : m_eqs) {
@ -3192,7 +3192,7 @@ public:
// The lemmas can come in batches
// and the same literal can appear in several lemmas in a batch: it becomes l_true
// in earlier processing, but it was not so when the lemma was produced
ctx().mk_th_axiom(get_id(), m_core.size(), m_core.c_ptr());
ctx().mk_th_axiom(get_id(), m_core.size(), m_core.data());
}
}
@ -3377,7 +3377,7 @@ public:
void dump_conflict(literal_vector const& core, svector<enode_pair> const& eqs) {
if (dump_lemmas()) {
ctx().display_lemma_as_smt_problem(core.size(), core.c_ptr(), eqs.size(), eqs.c_ptr(), false_literal);
ctx().display_lemma_as_smt_problem(core.size(), core.data(), eqs.size(), eqs.data(), false_literal);
}
}
@ -3389,13 +3389,13 @@ public:
cancel_eh<reslimit> eh(m.limit());
scoped_timer timer(1000, &eh);
bool result = l_true != nctx.check();
CTRACE("arith", !result, ctx().display_lemma_as_smt_problem(tout, core.size(), core.c_ptr(), eqs.size(), eqs.c_ptr(), false_literal););
CTRACE("arith", !result, ctx().display_lemma_as_smt_problem(tout, core.size(), core.data(), eqs.size(), eqs.data(), false_literal););
return result;
}
void dump_assign(literal lit, literal_vector const& core, svector<enode_pair> const& eqs) {
if (dump_lemmas()) {
unsigned id = ctx().display_lemma_as_smt_problem(core.size(), core.c_ptr(), eqs.size(), eqs.c_ptr(), lit);
unsigned id = ctx().display_lemma_as_smt_problem(core.size(), core.data(), eqs.size(), eqs.data(), lit);
(void)id;
}
}
@ -3410,7 +3410,7 @@ public:
cancel_eh<reslimit> eh(m.limit());
scoped_timer timer(1000, &eh);
bool result = l_true != nctx.check();
CTRACE("arith", !result, ctx().display_lemma_as_smt_problem(tout, core.size(), core.c_ptr(), eqs.size(), eqs.c_ptr(), lit);
CTRACE("arith", !result, ctx().display_lemma_as_smt_problem(tout, core.size(), core.data(), eqs.size(), eqs.data(), lit);
display(tout););
return result;
}
@ -3586,7 +3586,7 @@ public:
case 1:
return app_ref(to_app(args[0].get()), m);
default:
return app_ref(a.mk_add(args.size(), args.c_ptr()), m);
return app_ref(a.mk_add(args.size(), args.data()), m);
}
}

46
src/smt/theory_pb.cpp
View file

@ -145,10 +145,10 @@ namespace smt {
}
pb_util pb(m);
if (is_eq) {
result = pb.mk_eq(coeffs.size(), coeffs.c_ptr(), args.c_ptr(), k());
result = pb.mk_eq(coeffs.size(), coeffs.data(), args.data(), k());
}
else {
result = pb.mk_ge(coeffs.size(), coeffs.c_ptr(), args.c_ptr(), k());
result = pb.mk_ge(coeffs.size(), coeffs.data(), args.data(), k());
}
return result;
}
@ -243,7 +243,7 @@ namespace smt {
for (unsigned i = 0; i < size(); ++i) {
args.push_back(th.literal2expr(m_args[i]));
}
return app_ref(th.pb.mk_at_least_k(args.size(), args.c_ptr(), k()), m);
return app_ref(th.pb.mk_at_least_k(args.size(), args.data(), k()), m);
}
lbool theory_pb::card::assign(theory_pb& th, literal alit) {
@ -500,8 +500,8 @@ namespace smt {
// -ax - by - cz >= -k
// <=>
// a(1-x) + b(1-y) + c(1-z) >= a + b + c - k
expr_ref le(pb.mk_ge(num_args, coeffs.c_ptr(), nargs.c_ptr(), sum - k), m);
expr_ref ge(pb.mk_ge(num_args, coeffs.c_ptr(), args.c_ptr(), k), m);
expr_ref le(pb.mk_ge(num_args, coeffs.data(), nargs.data(), sum - k), m);
expr_ref ge(pb.mk_ge(num_args, coeffs.data(), args.data(), k), m);
ctx.internalize(le, false);
ctx.internalize(ge, false);
literal le_lit = ctx.get_literal(le);
@ -568,7 +568,7 @@ namespace smt {
SASSERT(c->coeff(i).is_one());
ctx.mk_th_axiom(get_id(), lit, ~c->lit(i));
}
ctx.mk_th_axiom(get_id(), lits.size(), lits.c_ptr());
ctx.mk_th_axiom(get_id(), lits.size(), lits.data());
return true;
}
@ -765,7 +765,7 @@ namespace smt {
return nullptr;
}
else {
return m.mk_th_lemma(m_fid, fact, prs.size(), prs.c_ptr());
return m.mk_th_lemma(m_fid, fact, prs.size(), prs.data());
}
}
};
@ -844,7 +844,7 @@ namespace smt {
lits.push_back(~c.lit(i));
}
lits.push_back(lit);
ctx.mk_th_axiom(get_id(), lits.size(), lits.c_ptr());
ctx.mk_th_axiom(get_id(), lits.size(), lits.data());
for (unsigned i = 0; i < c.size(); ++i) {
literal lits2[2] = { ~lit, c.lit(i) };
ctx.mk_th_axiom(get_id(), 2, lits2);
@ -858,7 +858,7 @@ namespace smt {
lits.push_back(c.lit(i));
}
lits.push_back(~lit);
ctx.mk_th_axiom(get_id(), lits.size(), lits.c_ptr());
ctx.mk_th_axiom(get_id(), lits.size(), lits.data());
for (unsigned i = 0; i < c.size(); ++i) {
literal lits2[2] = { lit, ~c.lit(i) };
ctx.mk_th_axiom(get_id(), 2, lits2);
@ -934,9 +934,9 @@ namespace smt {
c.inc_propagations(*this);
if (!resolve_conflict(c, lits)) {
if (proofs_enabled()) {
js = alloc(theory_lemma_justification, get_id(), ctx, lits.size(), lits.c_ptr());
js = alloc(theory_lemma_justification, get_id(), ctx, lits.size(), lits.data());
}
ctx.mk_clause(lits.size(), lits.c_ptr(), js, CLS_TH_LEMMA, nullptr);
ctx.mk_clause(lits.size(), lits.data(), js, CLS_TH_LEMMA, nullptr);
}
SASSERT(ctx.inconsistent());
}
@ -1280,7 +1280,7 @@ namespace smt {
ctx.literal2expr(lits[i], tmp);
es.push_back(tmp);
}
tmp = m.mk_or(es.size(), es.c_ptr());
tmp = m.mk_or(es.size(), es.data());
bool_var v = ctx.b_internalized(tmp)?ctx.get_bool_var(tmp):ctx.mk_bool_var(tmp);
return literal(v);
}
@ -1292,7 +1292,7 @@ namespace smt {
ctx.literal2expr(lits[i], tmp);
es.push_back(tmp);
}
tmp = m.mk_and(es.size(), es.c_ptr());
tmp = m.mk_and(es.size(), es.data());
bool_var v = ctx.b_internalized(tmp)?ctx.get_bool_var(tmp):ctx.mk_bool_var(tmp);
return literal(v);
}
@ -1301,7 +1301,7 @@ namespace smt {
void mk_clause(unsigned n, literal const* ls) {
literal_vector tmp(n, ls);
ctx.mk_clause(n, tmp.c_ptr(), th.justify(tmp), CLS_AUX, nullptr);
ctx.mk_clause(n, tmp.data(), th.justify(tmp), CLS_AUX, nullptr);
}
literal mk_false() { return false_literal; }
@ -1504,7 +1504,7 @@ namespace smt {
SASSERT(validate_antecedents(lits));
ctx.assign(l, ctx.mk_justification(
pb_justification(
c, get_id(), ctx.get_region(), lits.size(), lits.c_ptr(), l)));
c, get_id(), ctx.get_region(), lits.size(), lits.data(), l)));
}
@ -1516,9 +1516,9 @@ namespace smt {
display(tout, c, true););
justification* js = nullptr;
if (proofs_enabled()) {
js = alloc(theory_lemma_justification, get_id(), ctx, lits.size(), lits.c_ptr());
js = alloc(theory_lemma_justification, get_id(), ctx, lits.size(), lits.data());
}
ctx.mk_clause(lits.size(), lits.c_ptr(), js, CLS_TH_LEMMA, nullptr);
ctx.mk_clause(lits.size(), lits.data(), js, CLS_TH_LEMMA, nullptr);
}
@ -1622,7 +1622,7 @@ namespace smt {
literal lit = cls.get_literal(i);
args.push_back(literal2expr(lit));
}
result = m.mk_or(args.size(), args.c_ptr());
result = m.mk_or(args.size(), args.data());
break;
}
case b_justification::BIN_CLAUSE:
@ -2005,7 +2005,7 @@ namespace smt {
SASSERT(validate_antecedents(m_antecedents));
TRACE("pb", tout << "assign " << m_antecedents << " ==> " << alit << "\n";);
ctx.assign(alit, ctx.mk_justification(theory_propagation_justification(get_id(), ctx.get_region(), m_antecedents.size(), m_antecedents.c_ptr(), alit, 0, nullptr)));
ctx.assign(alit, ctx.mk_justification(theory_propagation_justification(get_id(), ctx.get_region(), m_antecedents.size(), m_antecedents.data(), alit, 0, nullptr)));
DEBUG_CODE(
m_antecedents.push_back(~alit);
@ -2013,7 +2013,7 @@ namespace smt {
for (literal lit : m_antecedents) {
args.push_back(literal2expr(lit));
}
B = m.mk_not(m.mk_and(args.size(), args.c_ptr()));
B = m.mk_not(m.mk_and(args.size(), args.data()));
validate_implies(A, B); );
return true;
}
@ -2034,7 +2034,7 @@ namespace smt {
justification* theory_pb::justify(literal_vector const& lits) {
justification* js = nullptr;
if (proofs_enabled()) {
js = ctx.mk_justification(theory_axiom_justification(get_id(), ctx.get_region(), lits.size(), lits.c_ptr()));
js = ctx.mk_justification(theory_axiom_justification(get_id(), ctx.get_region(), lits.size(), lits.data()));
}
return js;
}
@ -2188,7 +2188,7 @@ namespace smt {
coeffs.push_back(rational(get_abs_coeff(v)));
}
rational k(m_bound);
return app_ref(pb.mk_ge(args.size(), coeffs.c_ptr(), args.c_ptr(), k), m);
return app_ref(pb.mk_ge(args.size(), coeffs.data(), args.data(), k), m);
}
// display methods
@ -2296,7 +2296,7 @@ namespace smt {
}
void get_dependencies(buffer<model_value_dependency> & result) override {
result.append(m_dependencies.size(), m_dependencies.c_ptr());
result.append(m_dependencies.size(), m_dependencies.data());
}
app * mk_value(model_generator & mg, expr_ref_vector const& values) override {

32
src/smt/theory_seq.cpp
View file

@ -495,7 +495,7 @@ bool theory_seq::fixed_length(expr* len_e, bool is_zero) {
elems.push_back(head);
seq = tail;
}
seq = mk_concat(elems.size(), elems.c_ptr());
seq = mk_concat(elems.size(), elems.data());
}
TRACE("seq", tout << "Fixed: " << mk_bounded_pp(e, m, 2) << " " << lo << "\n";);
literal a = mk_eq(len_e, m_autil.mk_numeral(lo, true), false);
@ -753,7 +753,7 @@ bool theory_seq::propagate_lit(dependency* dep, unsigned n, literal const* _lits
justification* js =
ctx.mk_justification(
ext_theory_propagation_justification(
get_id(), ctx.get_region(), lits.size(), lits.c_ptr(), eqs.size(), eqs.c_ptr(), lit));
get_id(), ctx.get_region(), lits.size(), lits.data(), eqs.size(), eqs.data(), lit));
m_new_propagation = true;
ctx.assign(lit, js);
@ -774,7 +774,7 @@ void theory_seq::set_conflict(enode_pair_vector const& eqs, literal_vector const
ctx.set_conflict(
ctx.mk_justification(
ext_theory_conflict_justification(
get_id(), ctx.get_region(), lits.size(), lits.c_ptr(), eqs.size(), eqs.c_ptr(), 0, nullptr)));
get_id(), ctx.get_region(), lits.size(), lits.data(), eqs.size(), eqs.data(), 0, nullptr)));
validate_conflict(eqs, lits);
}
@ -799,7 +799,7 @@ bool theory_seq::propagate_eq(dependency* dep, enode* n1, enode* n2) {
justification* js = ctx.mk_justification(
ext_theory_eq_propagation_justification(
get_id(), ctx.get_region(), lits.size(), lits.c_ptr(), eqs.size(), eqs.c_ptr(), n1, n2));
get_id(), ctx.get_region(), lits.size(), lits.data(), eqs.size(), eqs.data(), n1, n2));
{
std::function<expr*(void)> fn = [&]() { return m.mk_eq(n1->get_expr(), n2->get_expr()); };
@ -997,8 +997,8 @@ bool theory_seq::reduce_length_eq(expr_ref_vector const& ls, expr_ref_vector con
expr_ref l(ls[0], m), r(rs[0], m);
if (reduce_length(l, r, lits)) {
expr_ref_vector lhs(m), rhs(m);
lhs.append(ls.size()-1, ls.c_ptr() + 1);
rhs.append(rs.size()-1, rs.c_ptr() + 1);
lhs.append(ls.size()-1, ls.data() + 1);
rhs.append(rs.size()-1, rs.data() + 1);
SASSERT(!lhs.empty() || !rhs.empty());
deps = mk_join(deps, lits);
m_eqs.push_back(depeq(m_eq_id++, lhs, rhs, deps));
@ -1010,8 +1010,8 @@ bool theory_seq::reduce_length_eq(expr_ref_vector const& ls, expr_ref_vector con
l = ls.back(); r = rs.back();
if (reduce_length(l, r, lits)) {
expr_ref_vector lhs(m), rhs(m);
lhs.append(ls.size()-1, ls.c_ptr());
rhs.append(rs.size()-1, rs.c_ptr());
lhs.append(ls.size()-1, ls.data());
rhs.append(rs.size()-1, rs.data());
SASSERT(!lhs.empty() || !rhs.empty());
deps = mk_join(deps, lits);
TRACE("seq", tout << "Propagate equal lengths " << l << " " << r << "\n" << "ls: " << ls << "\nrs: " << rs << "\n";);
@ -1065,10 +1065,10 @@ bool theory_seq::reduce_length_eq(expr_ref_vector const& ls, expr_ref_vector con
}
bool theory_seq::reduce_length(unsigned i, unsigned j, bool front, expr_ref_vector const& ls, expr_ref_vector const& rs, dependency* deps) {
expr* const* ls1 = ls.c_ptr();
expr* const* ls2 = ls.c_ptr()+i;
expr* const* rs1 = rs.c_ptr();
expr* const* rs2 = rs.c_ptr()+j;
expr* const* ls1 = ls.data();
expr* const* ls2 = ls.data()+i;
expr* const* rs1 = rs.data();
expr* const* rs2 = rs.data()+j;
unsigned l1 = i;
unsigned l2 = ls.size()-i;
unsigned r1 = j;
@ -1785,7 +1785,7 @@ public:
m_source.push_back(string_source);
}
void get_dependencies(buffer<model_value_dependency> & result) override {
result.append(m_dependencies.size(), m_dependencies.c_ptr());
result.append(m_dependencies.size(), m_dependencies.data());
}
void add_buffer(svector<unsigned>& sbuffer, zstring const& zs) {
@ -1845,7 +1845,7 @@ public:
}
// TRACE("seq", tout << src << " " << sbuffer << "\n";);
}
result = th.m_util.str.mk_string(zstring(sbuffer.size(), sbuffer.c_ptr()));
result = th.m_util.str.mk_string(zstring(sbuffer.size(), sbuffer.data()));
}
else {
for (source_t src : m_source) {
@ -2745,7 +2745,7 @@ void theory_seq::add_axiom(literal_vector & lits) {
scoped_trace_stream _sts(*this, lits);
validate_axiom(lits);
ctx.mk_th_axiom(get_id(), lits.size(), lits.c_ptr());
ctx.mk_th_axiom(get_id(), lits.size(), lits.data());
}
@ -2797,7 +2797,7 @@ bool theory_seq::propagate_eq(dependency* deps, literal_vector const& _lits, exp
justification* js =
ctx.mk_justification(
ext_theory_eq_propagation_justification(
get_id(), ctx.get_region(), lits.size(), lits.c_ptr(), eqs.size(), eqs.c_ptr(), n1, n2));
get_id(), ctx.get_region(), lits.size(), lits.data(), eqs.size(), eqs.data(), n1, n2));
m_new_propagation = true;

6
src/smt/theory_seq.h
View file

@ -476,9 +476,9 @@ namespace smt {
expr_ref mk_empty(sort* s) { return expr_ref(m_util.str.mk_empty(s), m); }
expr_ref mk_concat(unsigned n, expr*const* es) { return expr_ref(m_util.str.mk_concat(n, es, es[0]->get_sort()), m); }
expr_ref mk_concat(unsigned n, expr*const* es, sort* s) { return expr_ref(m_util.str.mk_concat(n, es, s), m); }
expr_ref mk_concat(expr_ref_vector const& es, sort* s) { return mk_concat(es.size(), es.c_ptr(), s); }
expr_ref mk_concat(expr_ref_vector const& es) { SASSERT(!es.empty()); return expr_ref(m_util.str.mk_concat(es.size(), es.c_ptr(), es[0]->get_sort()), m); }
expr_ref mk_concat(ptr_vector<expr> const& es) { SASSERT(!es.empty()); return mk_concat(es.size(), es.c_ptr(), es[0]->get_sort()); }
expr_ref mk_concat(expr_ref_vector const& es, sort* s) { return mk_concat(es.size(), es.data(), s); }
expr_ref mk_concat(expr_ref_vector const& es) { SASSERT(!es.empty()); return expr_ref(m_util.str.mk_concat(es.size(), es.data(), es[0]->get_sort()), m); }
expr_ref mk_concat(ptr_vector<expr> const& es) { SASSERT(!es.empty()); return mk_concat(es.size(), es.data(), es[0]->get_sort()); }
expr_ref mk_concat(expr* e1, expr* e2) { return expr_ref(m_util.str.mk_concat(e1, e2), m); }
expr_ref mk_concat(expr* e1, expr* e2, expr* e3) { return expr_ref(m_util.str.mk_concat(e1, e2, e3), m); }
bool solve_nqs(unsigned i);

4
src/smt/theory_special_relations.cpp
View file

@ -472,7 +472,7 @@ namespace smt {
ctx.mk_justification(
ext_theory_conflict_justification(
get_id(), ctx.get_region(),
lits.size(), lits.c_ptr(), 0, 0, params.size(), params.c_ptr())));
lits.size(), lits.data(), 0, 0, params.size(), params.data())));
}
lbool theory_special_relations::final_check(relation& r) {
@ -534,7 +534,7 @@ namespace smt {
literal_vector const& lits = r.m_explanation;
TRACE("special_relations", ctx.display_literals_verbose(tout << mk_pp(x->get_expr(), m) << " = " << mk_pp(y->get_expr(), m) << "\n", lits) << "\n";);
IF_VERBOSE(20, ctx.display_literals_verbose(verbose_stream() << mk_pp(x->get_expr(), m) << " = " << mk_pp(y->get_expr(), m) << "\n", lits) << "\n";);
eq_justification js(ctx.mk_justification(ext_theory_eq_propagation_justification(get_id(), ctx.get_region(), lits.size(), lits.c_ptr(), 0, nullptr,
eq_justification js(ctx.mk_justification(ext_theory_eq_propagation_justification(get_id(), ctx.get_region(), lits.size(), lits.data(), 0, nullptr,
x, y)));
ctx.assign_eq(x, y, js);
}

28
src/smt/theory_str.cpp
View file

@ -750,7 +750,7 @@ namespace smt {
for (auto el : childrenVector) {
items.push_back(mk_strlen(el));
}
expr_ref lenAssert(ctx.mk_eq_atom(concat_length, m_autil.mk_add(items.size(), items.c_ptr())), m);
expr_ref lenAssert(ctx.mk_eq_atom(concat_length, m_autil.mk_add(items.size(), items.data())), m);
assert_axiom(lenAssert);
}
return concatAst;
@ -1143,7 +1143,7 @@ namespace smt {
innerItems.push_back(ctx.mk_eq_atom(expr->get_arg(1), mk_concat(ts0, ts1)));
innerItems.push_back(ctx.mk_eq_atom(mk_strlen(ts0), mk_strlen(expr->get_arg(0))));
innerItems.push_back(m.mk_ite(ctx.mk_eq_atom(ts0, expr->get_arg(0)), expr, mk_not(m, expr)));
expr_ref then1(m.mk_and(innerItems.size(), innerItems.c_ptr()), m);
expr_ref then1(m.mk_and(innerItems.size(), innerItems.data()), m);
SASSERT(then1);
// the top-level condition is Length(arg0) >= Length(arg1)
@ -1179,7 +1179,7 @@ namespace smt {
innerItems.push_back(ctx.mk_eq_atom(expr->get_arg(1), mk_concat(ts0, ts1)));
innerItems.push_back(ctx.mk_eq_atom(mk_strlen(ts1), mk_strlen(expr->get_arg(0))));
innerItems.push_back(m.mk_ite(ctx.mk_eq_atom(ts1, expr->get_arg(0)), expr, mk_not(m, expr)));
expr_ref then1(m.mk_and(innerItems.size(), innerItems.c_ptr()), m);
expr_ref then1(m.mk_and(innerItems.size(), innerItems.data()), m);
SASSERT(then1);
// the top-level condition is Length(arg0) >= Length(arg1)
@ -1546,9 +1546,9 @@ namespace smt {
expr_ref_vector elseItems(m);
elseItems.push_back(ctx.mk_eq_atom(indexAst, mk_int(-1)));
items.push_back(m.mk_ite(condAst, m.mk_and(thenItems.size(), thenItems.c_ptr()), m.mk_and(elseItems.size(), elseItems.c_ptr())));
items.push_back(m.mk_ite(condAst, m.mk_and(thenItems.size(), thenItems.data()), m.mk_and(elseItems.size(), elseItems.data())));
expr_ref breakdownAssert(m.mk_and(items.size(), items.c_ptr()), m);
expr_ref breakdownAssert(m.mk_and(items.size(), items.data()), m);
SASSERT(breakdownAssert);
expr_ref reduceToIndex(ctx.mk_eq_atom(expr, indexAst), m);
@ -2503,7 +2503,7 @@ namespace smt {
l_items.push_back(ctx.mk_eq_atom(mk_strlen(arg1), mk_int(arg1_len)));
}
expr_ref axl(m.mk_and(l_items.size(), l_items.c_ptr()), m);
expr_ref axl(m.mk_and(l_items.size(), l_items.data()), m);
rational nnLen = arg0_len + arg1_len;
expr_ref axr(ctx.mk_eq_atom(mk_strlen(n), mk_int(nnLen)), m);
TRACE("str", tout << "inferred (Length " << mk_pp(n, m) << ") = " << nnLen << std::endl;);
@ -2564,7 +2564,7 @@ namespace smt {
}
if (axr) {
expr_ref axl(m.mk_and(l_items.size(), l_items.c_ptr()), m);
expr_ref axl(m.mk_and(l_items.size(), l_items.data()), m);
assert_implication(axl, axr);
}
}
@ -2640,7 +2640,7 @@ namespace smt {
literal l = ctx.get_literal(e);
ls.push_back(l);
}
ctx.mk_th_case_split(ls.size(), ls.c_ptr());
ctx.mk_th_case_split(ls.size(), ls.data());
}
void theory_str::print_cut_var(expr * node, std::ofstream & xout) {
@ -3960,7 +3960,7 @@ namespace smt {
zstring suffixStr = strValue.extract(prefixLen.get_unsigned(), str_sub_prefix.get_unsigned());
expr_ref prefixAst(mk_string(prefixStr), mgr);
expr_ref suffixAst(mk_string(suffixStr), mgr);
expr_ref ax_l(mgr.mk_and(litems.size(), litems.c_ptr()), mgr);
expr_ref ax_l(mgr.mk_and(litems.size(), litems.data()), mgr);
expr_ref suf_n_concat(mk_concat(suffixAst, n), mgr);
if (can_two_nodes_eq(x, prefixAst) && can_two_nodes_eq(y, suf_n_concat)) {
@ -4009,7 +4009,7 @@ namespace smt {
tmpLen = x_len - str_len;
litems.push_back(ctx.mk_eq_atom(mk_strlen(x), mk_int(x_len)));
}
expr_ref ax_l(mgr.mk_and(litems.size(), litems.c_ptr()), mgr);
expr_ref ax_l(mgr.mk_and(litems.size(), litems.data()), mgr);
expr_ref str_temp1(mk_concat(strAst, temp1), mgr);
expr_ref temp1_y(mk_concat(temp1, y), mgr);
@ -8421,7 +8421,7 @@ namespace smt {
expr_ref lenEqNum(ctx.mk_eq_atom(nodeWithLenExpr, varLenExpr), m);
l_items.push_back(lenEqNum);
expr_ref axl(m.mk_and(l_items.size(), l_items.c_ptr()), m);
expr_ref axl(m.mk_and(l_items.size(), l_items.data()), m);
expr_ref varLen(mk_strlen(var), m);
expr_ref axr(ctx.mk_eq_atom(varLen, mk_int(varLen)), m);
assert_implication(axl, axr);
@ -8474,7 +8474,7 @@ namespace smt {
}
}
if (allLeafResolved) {
expr_ref axl(m.mk_and(l_items.size(), l_items.c_ptr()), m);
expr_ref axl(m.mk_and(l_items.size(), l_items.data()), m);
expr_ref lenValueExpr (mk_int(lenValue), m);
expr_ref axr(ctx.mk_eq_atom(concatlenExpr, lenValueExpr), m);
assert_implication(axl, axr);
@ -9268,10 +9268,10 @@ namespace smt {
diseqs.push_back(extra_right_cond);
}
if (extra_deps.size() > 0) {
diseqs.push_back(m.mk_and(extra_deps.size(), extra_deps.c_ptr()));
diseqs.push_back(m.mk_and(extra_deps.size(), extra_deps.data()));
TRACE("str", tout << "extra_deps " << mk_pp(diseqs.get(diseqs.size()-1), m) << std::endl;);
}
expr* final_diseq = m.mk_and(diseqs.size(), diseqs.c_ptr());
expr* final_diseq = m.mk_and(diseqs.size(), diseqs.data());
TRACE("str", tout << "learning not " << mk_pp(final_diseq, m) << std::endl;);
return final_diseq;
}

4
src/smt/theory_str_mc.cpp
View file

@ -1292,7 +1292,7 @@ namespace smt {
assignment.push_back((unsigned)'?');
}
}
zstring strValue(assignment.size(), assignment.c_ptr());
zstring strValue(assignment.size(), assignment.data());
model.insert(var, strValue);
subst.insert(var, mk_string(strValue));
}
@ -1313,7 +1313,7 @@ namespace smt {
assignment.push_back((unsigned)'?');
}
}
zstring strValue(assignment.size(), assignment.c_ptr());
zstring strValue(assignment.size(), assignment.data());
model.insert(var, strValue);
subst.insert(var, mk_string(strValue));
}

2
src/smt/theory_str_regex.cpp
View file

@ -1314,7 +1314,7 @@ namespace smt {
SASSERT(new_arg);
rewritten_args.push_back(new_arg);
}
retval = m.mk_app(a_cond->get_decl(), rewritten_args.c_ptr());
retval = m.mk_app(a_cond->get_decl(), rewritten_args.data());
TRACE("str", tout << "final rewritten term is " << mk_pp(retval, m) << std::endl;);
return retval;
} else {

4
src/smt/theory_utvpi_def.h
View file

@ -208,7 +208,7 @@ namespace smt {
if (m_params.m_arith_dump_lemmas) {
symbol logic(m_lra ? (m_lia?"QF_LIRA":"QF_LRA") : "QF_LIA");
ctx.display_lemma_as_smt_problem(lits.size(), lits.c_ptr(), false_literal, logic);
ctx.display_lemma_as_smt_problem(lits.size(), lits.data(), false_literal, logic);
}
vector<parameter> params;
@ -223,7 +223,7 @@ namespace smt {
ctx.mk_justification(
ext_theory_conflict_justification(
get_id(), ctx.get_region(),
lits.size(), lits.c_ptr(), 0, nullptr, params.size(), params.c_ptr())));
lits.size(), lits.data(), 0, nullptr, params.size(), params.data())));
m_nc_functor.reset();
}

8
src/smt/theory_wmaxsat.cpp
View file

@ -254,7 +254,7 @@ namespace smt {
//ctx.display(tout);
);
}
expr_ref result(m.mk_or(disj.size(), disj.c_ptr()), m);
expr_ref result(m.mk_or(disj.size(), disj.data()), m);
TRACE("opt",
tout << result << " weight: " << weight << "\n";
tout << "cost: " << m_zcost << " min-cost: " << m_zmin_cost << "\n";);
@ -283,7 +283,7 @@ namespace smt {
ctx.set_conflict(
ctx.mk_justification(
ext_theory_conflict_justification(get_id(), ctx.get_region(), lits.size(), lits.c_ptr(), 0, nullptr, 0, nullptr)));
ext_theory_conflict_justification(get_id(), ctx.get_region(), lits.size(), lits.data(), 0, nullptr, 0, nullptr)));
}
bool theory_wmaxsat::max_unassigned_is_blocked() {
@ -325,13 +325,13 @@ namespace smt {
lits.push_back(literal(w));
}
TRACE("opt",
ctx.display_literals_verbose(tout, lits.size(), lits.c_ptr());
ctx.display_literals_verbose(tout, lits.size(), lits.data());
ctx.display_literal_verbose(tout << " --> ", lit););
region& r = ctx.get_region();
ctx.assign(lit, ctx.mk_justification(
ext_theory_propagation_justification(
get_id(), r, lits.size(), lits.c_ptr(), 0, nullptr, lit, 0, nullptr)));
get_id(), r, lits.size(), lits.data(), 0, nullptr, lit, 0, nullptr)));
}

4
src/smt/user_propagator.cpp
View file

@ -129,14 +129,14 @@ void user_propagator::propagate() {
if (m.is_false(prop.m_conseq)) {
js = ctx.mk_justification(
ext_theory_conflict_justification(
get_id(), ctx.get_region(), m_lits.size(), m_lits.c_ptr(), m_eqs.size(), m_eqs.c_ptr(), 0, nullptr));
get_id(), ctx.get_region(), m_lits.size(), m_lits.data(), m_eqs.size(), m_eqs.data(), 0, nullptr));
ctx.set_conflict(js);
}
else {
literal lit = mk_literal(prop.m_conseq);
js = ctx.mk_justification(
ext_theory_propagation_justification(
get_id(), ctx.get_region(), m_lits.size(), m_lits.c_ptr(), m_eqs.size(), m_eqs.c_ptr(), lit));
get_id(), ctx.get_region(), m_lits.size(), m_lits.data(), m_eqs.size(), m_eqs.data(), lit));
ctx.assign(lit, js);
}
++m_stats.m_num_propagations;