mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-06-21 21:33:39 +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

18
src/ast/normal_forms/defined_names.cpp
View file

@ -120,8 +120,8 @@ app * defined_names::impl::gen_name(expr * e, sort_ref_buffer & var_sorts, buffe
}
sort * range = e->get_sort();
func_decl * new_skolem_decl = m.mk_fresh_func_decl(m_z3name, symbol::null, domain.size(), domain.c_ptr(), range);
app * n = m.mk_app(new_skolem_decl, new_args.size(), new_args.c_ptr());
func_decl * new_skolem_decl = m.mk_fresh_func_decl(m_z3name, symbol::null, domain.size(), domain.data(), range);
app * n = m.mk_app(new_skolem_decl, new_args.size(), new_args.data());
if (is_lambda(e)) {
m.add_lambda_def(new_skolem_decl, to_quantifier(e));
}
@ -159,8 +159,8 @@ void defined_names::impl::bound_vars(sort_ref_buffer const & sorts, buffer<symbo
expr * patterns[1] = { m.mk_pattern(name) };
quantifier_ref q(m);
q = m.mk_forall(sorts.size(),
sorts.c_ptr(),
names.c_ptr(),
sorts.data(),
names.data(),
def_conjunct,
1, qid, symbol::null,
1, patterns);
@ -223,10 +223,10 @@ void defined_names::impl::mk_definition(expr * e, app * n, sort_ref_buffer & var
array_util autil(m);
func_decl * f = nullptr;
if (autil.is_as_array(n2, f)) {
n3 = m.mk_app(f, args.size()-1, args.c_ptr() + 1);
n3 = m.mk_app(f, args.size()-1, args.data() + 1);
}
else {
n3 = autil.mk_select(args.size(), args.c_ptr());
n3 = autil.mk_select(args.size(), args.data());
}
bound_vars(var_sorts, var_names, MK_EQ(q->get_expr(), n3), to_app(n3), defs, m.lambda_def_qid());
@ -234,7 +234,7 @@ void defined_names::impl::mk_definition(expr * e, app * n, sort_ref_buffer & var
else {
bound_vars(var_sorts, var_names, MK_EQ(e, n), n, defs);
}
new_def = mk_and(m, defs.size(), defs.c_ptr());
new_def = mk_and(m, defs.size(), defs.data());
}
@ -266,8 +266,8 @@ bool defined_names::impl::mk_name(expr * e, expr_ref & new_def, proof_ref & new_
TRACE("mk_definition_bug", tout << "name: " << mk_ismt2_pp(n, m) << "\n";);
// variables are in reverse order in quantifiers
std::reverse(var_sorts.c_ptr(), var_sorts.c_ptr() + var_sorts.size());
std::reverse(var_names.c_ptr(), var_names.c_ptr() + var_names.size());
std::reverse(var_sorts.data(), var_sorts.data() + var_sorts.size());
std::reverse(var_names.data(), var_names.data() + var_names.size());
mk_definition(e, n, var_sorts, var_names, new_def);

38
src/ast/normal_forms/nnf.cpp
View file

@ -102,8 +102,8 @@ class skolemizer {
for (unsigned i = num_decls; i > 0; ) {
--i;
sort * r = q->get_decl_sort(i);
func_decl * sk_decl = m.mk_fresh_func_decl(q->get_decl_name(i), q->get_skid(), sorts.size(), sorts.c_ptr(), r);
app * sk = m.mk_app(sk_decl, args.size(), args.c_ptr());
func_decl * sk_decl = m.mk_fresh_func_decl(q->get_decl_name(i), q->get_skid(), sorts.size(), sorts.data(), r);
app * sk = m.mk_app(sk_decl, args.size(), args.data());
substitution.push_back(sk);
}
//
@ -121,7 +121,7 @@ class skolemizer {
// (VAR num_decls) ... (VAR num_decls+sz-1)
// are in positions num_decls .. num_decls+sz-1
//
std::reverse(substitution.c_ptr(), substitution.c_ptr() + substitution.size());
std::reverse(substitution.data(), substitution.data() + substitution.size());
//
// (VAR 0) should be in the last position of substitution.
//
@ -464,14 +464,14 @@ struct nnf::imp {
}
app * r;
if (m.is_and(t) == fr.m_pol)
r = m.mk_and(t->get_num_args(), m_result_stack.c_ptr() + fr.m_spos);
r = m.mk_and(t->get_num_args(), m_result_stack.data() + fr.m_spos);
else
r = m.mk_or(t->get_num_args(), m_result_stack.c_ptr() + fr.m_spos);
r = m.mk_or(t->get_num_args(), m_result_stack.data() + fr.m_spos);
m_result_stack.shrink(fr.m_spos);
m_result_stack.push_back(r);
if (proofs_enabled()) {
proof * pr = mk_proof(fr.m_pol, t->get_num_args(), m_result_pr_stack.c_ptr() + fr.m_spos, t, r);
proof * pr = mk_proof(fr.m_pol, t->get_num_args(), m_result_pr_stack.data() + fr.m_spos, t, r);
m_result_pr_stack.shrink(fr.m_spos);
m_result_pr_stack.push_back(pr);
SASSERT(m_result_stack.size() == m_result_pr_stack.size());
@ -516,14 +516,14 @@ struct nnf::imp {
app * r;
if (fr.m_pol)
r = m.mk_or(2, m_result_stack.c_ptr() + fr.m_spos);
r = m.mk_or(2, m_result_stack.data() + fr.m_spos);
else
r = m.mk_and(2, m_result_stack.c_ptr() + fr.m_spos);
r = m.mk_and(2, m_result_stack.data() + fr.m_spos);
m_result_stack.shrink(fr.m_spos);
m_result_stack.push_back(r);
if (proofs_enabled()) {
proof * pr = mk_proof(fr.m_pol, 2, m_result_pr_stack.c_ptr() + fr.m_spos, t, r);
proof * pr = mk_proof(fr.m_pol, 2, m_result_pr_stack.data() + fr.m_spos, t, r);
m_result_pr_stack.shrink(fr.m_spos);
m_result_pr_stack.push_back(pr);
SASSERT(m_result_stack.size() == m_result_pr_stack.size());
@ -554,7 +554,7 @@ struct nnf::imp {
break;
}
expr * const * rs = m_result_stack.c_ptr() + fr.m_spos;
expr * const * rs = m_result_stack.data() + fr.m_spos;
expr * _cond = rs[0];
expr * _not_cond = rs[1];
expr * _then = rs[2];
@ -564,7 +564,7 @@ struct nnf::imp {
m_result_stack.shrink(fr.m_spos);
m_result_stack.push_back(r);
if (proofs_enabled()) {
proof * pr = mk_proof(fr.m_pol, 4, m_result_pr_stack.c_ptr() + fr.m_spos, t, r);
proof * pr = mk_proof(fr.m_pol, 4, m_result_pr_stack.data() + fr.m_spos, t, r);
m_result_pr_stack.shrink(fr.m_spos);
m_result_pr_stack.push_back(pr);
SASSERT(m_result_stack.size() == m_result_pr_stack.size());
@ -598,7 +598,7 @@ struct nnf::imp {
break;
}
expr * const * rs = m_result_stack.c_ptr() + fr.m_spos;
expr * const * rs = m_result_stack.data() + fr.m_spos;
expr * lhs = rs[0];
expr * not_lhs = rs[1];
expr * rhs = rs[2];
@ -612,7 +612,7 @@ struct nnf::imp {
m_result_stack.shrink(fr.m_spos);
m_result_stack.push_back(r);
if (proofs_enabled()) {
proof * pr = mk_proof(fr.m_pol, 4, m_result_pr_stack.c_ptr() + fr.m_spos, t, r);
proof * pr = mk_proof(fr.m_pol, 4, m_result_pr_stack.data() + fr.m_spos, t, r);
m_result_pr_stack.shrink(fr.m_spos);
m_result_pr_stack.push_back(pr);
SASSERT(m_result_stack.size() == m_result_pr_stack.size());
@ -675,11 +675,11 @@ struct nnf::imp {
expr_ref r(m);
proof_ref pr(m);
if (fr.m_pol == pos) {
expr * lbl_lit = m.mk_label_lit(names.size(), names.c_ptr());
expr * lbl_lit = m.mk_label_lit(names.size(), names.data());
r = m.mk_and(arg, lbl_lit);
if (proofs_enabled()) {
expr_ref aux(m);
aux = m.mk_label(true, names.size(), names.c_ptr(), arg);
aux = m.mk_label(true, names.size(), names.data(), arg);
pr = m.mk_transitivity(mk_proof(fr.m_pol, 1, &arg_pr, t, to_app(aux)),
m.mk_iff_oeq(m.mk_rewrite(aux, r)));
}
@ -786,7 +786,7 @@ struct nnf::imp {
quantifier * new_q = nullptr;
proof * new_q_pr = nullptr;
if (fr.m_pol) {
new_q = m.update_quantifier(q, new_patterns.size(), new_patterns.c_ptr(), new_expr);
new_q = m.update_quantifier(q, new_patterns.size(), new_patterns.data(), new_expr);
if (proofs_enabled()) {
new_expr_pr = m.mk_bind_proof(q, new_expr_pr);
new_q_pr = m.mk_nnf_pos(q, new_q, 1, &new_expr_pr);
@ -794,7 +794,7 @@ struct nnf::imp {
}
else {
quantifier_kind k = is_forall(q)? exists_k : forall_k;
new_q = m.update_quantifier(q, k, new_patterns.size(), new_patterns.c_ptr(), new_expr);
new_q = m.update_quantifier(q, k, new_patterns.size(), new_patterns.data(), new_expr);
if (proofs_enabled()) {
new_expr_pr = m.mk_bind_proof(q, new_expr_pr);
new_q_pr = m.mk_nnf_neg(q, new_q, 1, &new_expr_pr);
@ -898,8 +898,8 @@ struct nnf::imp {
new_def_proofs.push_back(new_pr);
}
}
std::reverse(new_defs.c_ptr() + old_sz1, new_defs.c_ptr() + new_defs.size());
std::reverse(new_def_proofs.c_ptr() + old_sz2, new_def_proofs.c_ptr() + new_def_proofs.size());
std::reverse(new_defs.data() + old_sz1, new_defs.data() + new_defs.size());
std::reverse(new_def_proofs.data() + old_sz2, new_def_proofs.data() + new_def_proofs.size());
}
};

16
src/ast/normal_forms/pull_quant.cpp
View file

@ -150,9 +150,9 @@ struct pull_quant::imp {
std::reverse(var_names.begin(), var_names.end());
result = m.mk_quantifier(forall_children ? forall_k : exists_k,
var_sorts.size(),
var_sorts.c_ptr(),
var_names.c_ptr(),
m.mk_app(d, new_adjusted_children.size(), new_adjusted_children.c_ptr()),
var_sorts.data(),
var_names.data(),
m.mk_app(d, new_adjusted_children.size(), new_adjusted_children.data()),
w,
qid);
return true;
@ -184,8 +184,8 @@ struct pull_quant::imp {
// Remark: patterns are ignored.
// See comment in reduce1_app
result = m.mk_forall(var_sorts.size(),
var_sorts.c_ptr(),
var_names.c_ptr(),
var_sorts.data(),
var_names.data(),
nested_q->get_expr(),
std::min(q->get_weight(), nested_q->get_weight()),
q->get_qid());
@ -225,10 +225,10 @@ struct pull_quant::imp {
if (new_arg != arg)
proofs.push_back(m.mk_pull_quant(arg, to_quantifier(new_arg)));
}
pull_quant1(to_app(n)->get_decl(), new_args.size(), new_args.c_ptr(), r);
pull_quant1(to_app(n)->get_decl(), new_args.size(), new_args.data(), r);
if (m.proofs_enabled()) {
app * r1 = m.mk_app(to_app(n)->get_decl(), new_args.size(), new_args.c_ptr());
proof * p1 = proofs.empty() ? nullptr : m.mk_congruence(to_app(n), r1, proofs.size(), proofs.c_ptr());
app * r1 = m.mk_app(to_app(n)->get_decl(), new_args.size(), new_args.data());
proof * p1 = proofs.empty() ? nullptr : m.mk_congruence(to_app(n), r1, proofs.size(), proofs.data());
proof * p2 = r1 == r ? nullptr : m.mk_pull_quant(r1, to_quantifier(r));
pr = m.mk_transitivity(p1, p2);
}