mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-10-25 00:44:36 +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

6
src/muz/base/bind_variables.cpp
View file

@ -38,7 +38,7 @@ expr_ref bind_variables::operator()(expr* fml, bool is_forall) {
if (!m_names.empty()) {
m_bound.reverse();
m_names.reverse();
result = m.mk_quantifier(is_forall ? forall_k : exists_k, m_bound.size(), m_bound.c_ptr(), m_names.c_ptr(), result);
result = m.mk_quantifier(is_forall ? forall_k : exists_k, m_bound.size(), m_bound.data(), m_names.data(), result);
}
m_pinned.reset();
m_cache.reset();
@ -114,7 +114,7 @@ expr_ref bind_variables::abstract(expr* term, cache_t& cache, unsigned scope) {
}
if (all_visited) {
if (some_diff) {
b = m.mk_app(a->get_decl(), m_args.size(), m_args.c_ptr());
b = m.mk_app(a->get_decl(), m_args.size(), m_args.data());
m_pinned.push_back(b);
}
else {
@ -135,7 +135,7 @@ expr_ref bind_variables::abstract(expr* term, cache_t& cache, unsigned scope) {
patterns.push_back(abstract(q->get_pattern(i), new_cache, new_scope));
}
result1 = abstract(q->get_expr(), new_cache, new_scope);
b = m.update_quantifier(q, patterns.size(), patterns.c_ptr(), result1.get());
b = m.update_quantifier(q, patterns.size(), patterns.data(), result1.get());
m_pinned.push_back(b);
cache.insert(e, b);
m_todo.pop_back();

4
src/muz/base/dl_boogie_proof.cpp
View file

@ -113,10 +113,10 @@ namespace datalog {
}
}
}
premises[i] = m.mk_hyper_resolve(premises2.size(), premises2.c_ptr(), l2, positions2, substs2);
premises[i] = m.mk_hyper_resolve(premises2.size(), premises2.data(), l2, positions2, substs2);
}
conclusion = conclusion1;
pr = m.mk_hyper_resolve(premises.size(), premises.c_ptr(), conclusion, positions, substs);
pr = m.mk_hyper_resolve(premises.size(), premises.data(), conclusion, positions, substs);
}
}

14
src/muz/base/dl_context.cpp
View file

@ -625,7 +625,7 @@ namespace datalog {
m_rel->add_fact(pred, fact);
}
else {
expr_ref rule(m.mk_app(pred, fact.size(), (expr*const*)fact.c_ptr()), m);
expr_ref rule(m.mk_app(pred, fact.size(), (expr*const*)fact.data()), m);
add_rule(rule, symbol::null);
}
}
@ -1125,7 +1125,7 @@ namespace datalog {
ast_pp_util visitor(m);
func_decl_set rels;
unsigned num_axioms = m_background.size();
expr* const* axioms = m_background.c_ptr();
expr* const* axioms = m_background.data();
expr_ref fml(m);
expr_ref_vector rules(m), queries(m);
svector<symbol> names;
@ -1141,8 +1141,8 @@ namespace datalog {
smt2_pp_environment_dbg env(m);
mk_fresh_name fresh_names;
collect_free_funcs(num_axioms, axioms, visitor, fresh_names);
collect_free_funcs(rules.size(), rules.c_ptr(), visitor, fresh_names);
collect_free_funcs(queries.size(), queries.c_ptr(), visitor, fresh_names);
collect_free_funcs(rules.size(), rules.data(), visitor, fresh_names);
collect_free_funcs(queries.size(), queries.data(), visitor, fresh_names);
func_decl_set funcs;
unsigned sz = visitor.coll.get_num_decls();
for (unsigned i = 0; i < sz; ++i) {
@ -1212,7 +1212,7 @@ namespace datalog {
else {
m_free_vars(q);
m_free_vars.set_default_sort(m.mk_bool_sort());
sort* const* domain = m_free_vars.c_ptr();
sort* const* domain = m_free_vars.data();
expr_ref qfn(m);
expr_ref_vector args(m);
fn = m.mk_fresh_func_decl(symbol("q"), symbol(""), m_free_vars.size(), domain, m.mk_bool_sort());
@ -1220,7 +1220,7 @@ namespace datalog {
for (unsigned j = 0; j < m_free_vars.size(); ++j) {
args.push_back(m.mk_var(j, m_free_vars[j]));
}
qfn = m.mk_implies(q, m.mk_app(fn, args.size(), args.c_ptr()));
qfn = m.mk_implies(q, m.mk_app(fn, args.size(), args.data()));
out << "(assert ";
PP(qfn);
@ -1327,7 +1327,7 @@ namespace datalog {
subst.push_back(fresh_vars[vars[max_var]].get());
}
res = vsubst(q->get_expr(), subst.size(), subst.c_ptr());
res = vsubst(q->get_expr(), subst.size(), subst.data());
rules[i] = res.get();
}
}

4
src/muz/base/dl_context.h
View file

@ -94,8 +94,8 @@ namespace datalog {
relation_fact(ast_manager & m, unsigned sz) : app_ref_vector(m) { resize(sz); }
relation_fact(context & ctx);
iterator begin() const { return c_ptr(); }
iterator end() const { return c_ptr()+size(); }
iterator begin() const { return data(); }
iterator end() const { return data()+size(); }
relation_element operator[](unsigned i) const { return get(i); }
el_proxy operator[](unsigned i) { return el_proxy(*this, i); }

4
src/muz/base/dl_engine_base.h
View file

@ -63,9 +63,9 @@ namespace datalog {
}
sorts.reverse();
names.reverse();
q = m.mk_app(r, args.size(), args.c_ptr());
q = m.mk_app(r, args.size(), args.data());
if (!args.empty()) {
q = m.mk_exists(sorts.size(), sorts.c_ptr(), names.c_ptr(), q);
q = m.mk_exists(sorts.size(), sorts.data(), names.data(), q);
}
return query(q);
}

38
src/muz/base/dl_rule.cpp
View file

@ -197,10 +197,10 @@ namespace datalog {
mk_negations(m_body, m_neg);
check_valid_rule(m_head, m_body.size(), m_body.c_ptr());
check_valid_rule(m_head, m_body.size(), m_body.data());
rule_ref r(*this);
r = mk(m_head.get(), m_body.size(), m_body.c_ptr(), m_neg.c_ptr(), name);
r = mk(m_head.get(), m_body.size(), m_body.data(), m_neg.data(), name);
expr_ref fml1(m);
if (p) {
@ -278,7 +278,7 @@ namespace datalog {
qh.pull_quantifier(false, q, nullptr, &names);
// retrieve free variables.
m_free_vars(q);
vars.append(m_free_vars.size(), m_free_vars.c_ptr());
vars.append(m_free_vars.size(), m_free_vars.data());
if (vars.contains(static_cast<sort*>(nullptr))) {
var_subst sub(m, false);
expr_ref_vector args(m);
@ -293,10 +293,10 @@ namespace datalog {
args.push_back(m.mk_var(0, m.mk_bool_sort()));
}
}
q = sub(q, args.size(), args.c_ptr());
q = sub(q, args.size(), args.data());
vars.reset();
m_free_vars(q);
vars.append(m_free_vars.size(), m_free_vars.c_ptr());
vars.append(m_free_vars.size(), m_free_vars.data());
}
SASSERT(!vars.contains(static_cast<sort*>(0)) && "Unused variables have been eliminated");
@ -322,7 +322,7 @@ namespace datalog {
}
vars.reverse();
names.reverse();
func_decl* qpred = m_ctx.mk_fresh_head_predicate(symbol("query"), symbol(), vars.size(), vars.c_ptr(), body_pred);
func_decl* qpred = m_ctx.mk_fresh_head_predicate(symbol("query"), symbol(), vars.size(), vars.data(), body_pred);
m_ctx.register_predicate(qpred, false);
rules.set_output_predicate(qpred);
@ -336,11 +336,11 @@ namespace datalog {
for (unsigned i = 0; i < vars.size(); i++) {
qhead_args.push_back(m.mk_var(vars.size()-i-1, vars[i]));
}
app_ref qhead(m.mk_app(qpred, qhead_args.c_ptr()), m);
app_ref qhead(m.mk_app(qpred, qhead_args.data()), m);
app_ref impl(m.mk_implies(q, qhead), m);
expr_ref rule_expr(impl.get(), m);
if (!vars.empty()) {
rule_expr = m.mk_forall(vars.size(), vars.c_ptr(), names.c_ptr(), impl);
rule_expr = m.mk_forall(vars.size(), vars.data(), names.data(), impl);
}
TRACE("dl", tout << rule_expr << "\n";);
@ -401,7 +401,7 @@ namespace datalog {
body.push_back(m.mk_eq(v, b));
}
}
fml = m.mk_app(fml->get_decl(), m_args.size(), m_args.c_ptr());
fml = m.mk_app(fml->get_decl(), m_args.size(), m_args.data());
TRACE("dl_rule", tout << mk_pp(fml.get(), m) << "\n";);
}
@ -567,7 +567,7 @@ namespace datalog {
switch (body.size()) {
case 0: break;
case 1: fml = m.mk_implies(body[0].get(), fml); break;
default: fml = m.mk_implies(m.mk_and(body.size(), body.c_ptr()), fml); break;
default: fml = m.mk_implies(m.mk_and(body.size(), body.data()), fml); break;
}
m_free_vars.reset();
@ -594,7 +594,7 @@ namespace datalog {
}
}
}
fml = m.mk_forall(m_free_vars.size(), m_free_vars.c_ptr(), names.c_ptr(), fml);
fml = m.mk_forall(m_free_vars.size(), m_free_vars.data(), names.data(), fml);
}
std::ostream& rule_manager::display_smt2(rule const& r, std::ostream & out) {
@ -638,7 +638,7 @@ namespace datalog {
tail.push_back(ensure_app(conjs[i].get()));
}
tail_neg.resize(tail.size(), false);
r = mk(r->get_head(), tail.size(), tail.c_ptr(), tail_neg.c_ptr(), r->name());
r = mk(r->get_head(), tail.size(), tail.data(), tail_neg.data(), r->name());
TRACE("dl", r->display(m_ctx, tout << "reduced rule\n"););
}
}
@ -703,7 +703,7 @@ namespace datalog {
return;
}
expr_ref unbound_tail(m);
bool_rewriter(m).mk_and(tails_with_unbound.size(), tails_with_unbound.c_ptr(), unbound_tail);
bool_rewriter(m).mk_and(tails_with_unbound.size(), tails_with_unbound.data(), unbound_tail);
unsigned q_var_cnt = unbound_vars.num_elems();
@ -743,9 +743,9 @@ namespace datalog {
expr_ref unbound_tail_pre_quant(m), fixed_tail(m), quant_tail(m);
var_subst vs(m, false);
unbound_tail_pre_quant = vs(unbound_tail, subst.size(), subst.c_ptr());
unbound_tail_pre_quant = vs(unbound_tail, subst.size(), subst.data());
quant_tail = m.mk_exists(q_var_cnt, qsorts.c_ptr(), qnames.c_ptr(), unbound_tail_pre_quant);
quant_tail = m.mk_exists(q_var_cnt, qsorts.data(), qnames.data(), unbound_tail_pre_quant);
if (try_quantifier_elimination) {
TRACE("dl_rule_unbound_fix_pre_qe",
@ -783,7 +783,7 @@ namespace datalog {
SASSERT(tail.size()==tail_neg.size());
rule_ref old_r = r;
r = mk(head, tail.size(), tail.c_ptr(), tail_neg.c_ptr(), old_r->name());
r = mk(head, tail.size(), tail.data(), tail_neg.data(), old_r->name());
r->set_accounting_parent_object(m_ctx, old_r);
}
@ -821,7 +821,7 @@ namespace datalog {
new_tail.push_back(to_app(tmp));
tail_neg.push_back(r->is_neg_tail(i));
}
r = mk(new_head.get(), new_tail.size(), new_tail.c_ptr(), tail_neg.c_ptr(), r->name(), false);
r = mk(new_head.get(), new_tail.size(), new_tail.data(), tail_neg.data(), r->name(), false);
// keep old variable indices around so we can compose with substitutions.
// r->norm_vars(*this);
@ -1000,14 +1000,14 @@ namespace datalog {
var_subst vs(m, false);
app_ref new_head_a = rm.ensure_app(vs(m_head, subst_vals.size(), subst_vals.c_ptr()));
app_ref new_head_a = rm.ensure_app(vs(m_head, subst_vals.size(), subst_vals.data()));
m.inc_ref(new_head_a);
m.dec_ref(m_head);
m_head = new_head_a;
for (unsigned i = 0; i < m_tail_size; i++) {
app * old_tail = get_tail(i);
app_ref new_tail_a = rm.ensure_app(vs(old_tail, subst_vals.size(), subst_vals.c_ptr()));
app_ref new_tail_a = rm.ensure_app(vs(old_tail, subst_vals.size(), subst_vals.data()));
bool sign = is_neg_tail(i);
m.inc_ref(new_tail_a);
m.dec_ref(old_tail);

4
src/muz/base/dl_rule_set.cpp
View file

@ -391,8 +391,8 @@ namespace datalog {
\brief Return true if the negation is indeed stratified.
*/
bool rule_set::stratified_negation() {
ptr_vector<rule>::const_iterator it = m_rules.c_ptr();
ptr_vector<rule>::const_iterator end = m_rules.c_ptr() + m_rules.size();
ptr_vector<rule>::const_iterator it = m_rules.data();
ptr_vector<rule>::const_iterator end = m_rules.data() + m_rules.size();
for (; it != end; it++) {
rule * r = *it;
func_decl * head_decl = r->get_decl();

4
src/muz/base/dl_rule_set.h
View file

@ -269,8 +269,8 @@ namespace datalog {
void display_deps(std::ostream & out) const;
typedef rule * const * iterator;
iterator begin() const { return m_rules.c_ptr(); }
iterator end() const { return m_rules.c_ptr()+m_rules.size(); }
iterator begin() const { return m_rules.data(); }
iterator end() const { return m_rules.data()+m_rules.size(); }
decl2rules::iterator begin_grouped_rules() const { return m_head2rules.begin(); }
decl2rules::iterator end_grouped_rules() const { return m_head2rules.end(); }

10
src/muz/base/dl_util.cpp
View file

@ -107,7 +107,7 @@ namespace datalog {
new_args.push_back(new_var);
}
}
new_pred = m.mk_app(pred->get_decl(), new_args.size(), new_args.c_ptr());
new_pred = m.mk_app(pred->get_decl(), new_args.size(), new_args.data());
}
void apply_subst(expr_ref_vector& tgt, expr_ref_vector const& sub) {
@ -116,7 +116,7 @@ namespace datalog {
expr_ref tmp(m);
for (unsigned i = 0; i < tgt.size(); ++i) {
if (tgt[i].get()) {
tgt[i] = vs(tgt[i].get(), sub.size(), sub.c_ptr());
tgt[i] = vs(tgt[i].get(), sub.size(), sub.data());
}
else {
tgt[i] = sub[i];
@ -304,7 +304,7 @@ namespace datalog {
tout << mk_pp(body[i].get(), m) << "\n";
});
mc->insert(r.get_head(), body.size(), body.c_ptr());
mc->insert(r.get_head(), body.size(), body.data());
}
}
@ -343,7 +343,7 @@ namespace datalog {
tout << "\n";
);
pr = m.mk_hyper_resolve(2, premises.c_ptr(), fml3, positions, substs);
pr = m.mk_hyper_resolve(2, premises.data(), fml3, positions, substs);
pc->insert(pr);
}
@ -381,7 +381,7 @@ namespace datalog {
tout << "\n";
);
pr = m.mk_hyper_resolve(2, premises.c_ptr(), fml, positions, substs);
pr = m.mk_hyper_resolve(2, premises.data(), fml, positions, substs);
res.set_proof(m, pr);
}

20
src/muz/base/dl_util.h
View file

@ -159,11 +159,11 @@ namespace datalog {
}
const unsigned * get_cols1() const {
return m_args1.c_ptr();
return m_args1.data();
}
const unsigned * get_cols2() const {
return m_args2.c_ptr();
return m_args2.data();
}
bool empty() const {
@ -290,7 +290,7 @@ namespace datalog {
template<class T>
void project_out_vector_columns(T & container, const unsigned_vector & removed_cols) {
project_out_vector_columns(container, removed_cols.size(), removed_cols.c_ptr());
project_out_vector_columns(container, removed_cols.size(), removed_cols.data());
}
@ -321,7 +321,7 @@ namespace datalog {
if (cycle_len<2) {
return;
}
typename T::data aux = container[permutation_cycle[0]];
auto aux = container[permutation_cycle[0]];
for (unsigned i=1; i<cycle_len; i++) {
container[permutation_cycle[i-1]]=container[permutation_cycle[i]];
}
@ -342,7 +342,7 @@ namespace datalog {
template<class T>
void permutate_by_cycle(T & container, const unsigned_vector & permutation_cycle) {
permutate_by_cycle(container, permutation_cycle.size(), permutation_cycle.c_ptr());
permutate_by_cycle(container, permutation_cycle.size(), permutation_cycle.data());
}
@ -387,9 +387,9 @@ namespace datalog {
if (c1.size()!=c2.size()) {
return false;
}
typename T::data * it1 = c1.c_ptr();
typename T::data * end1 = c1.c_ptr()+c1.size();
typename U::data * it2 = c2.c_ptr();
auto * it1 = c1.data();
auto * end1 = c1.data()+c1.size();
auto * it2 = c2.data();
for (; it1!=end1; ++it1, ++it2) {
if (*it1!=*it2) {
return false;
@ -420,7 +420,7 @@ namespace datalog {
template<class T>
struct svector_hash_proc {
unsigned operator()(const svector<typename T::data> & cont) const {
unsigned operator()(const svector<typename T::data_t> & cont) const {
return svector_hash<T>()(cont);
}
};
@ -477,7 +477,7 @@ namespace datalog {
is not preserved.
*/
template<class T>
bool remove_from_vector(T & v, const typename T::data & el) {
bool remove_from_vector(T & v, const typename T::data_t & el) {
unsigned sz = v.size();
for (unsigned i=0; i<sz; i++) {
if (v[i]==el) {

16
src/muz/base/hnf.cpp
View file

@ -274,7 +274,7 @@ private:
if (premise) {
expr_ref f1 = bind_variables(mk_implies(m_body, head));
expr* f2 = m.mk_and(sz, m_todo.c_ptr()+m_todo.size()-sz);
expr* f2 = m.mk_and(sz, m_todo.data()+m_todo.size()-sz);
proof_ref p2(m), p3(m);
p2 = m.mk_def_axiom(m.mk_iff(f1, f2));
p3 = mk_quant_intro(fml, f1, p);
@ -351,7 +351,7 @@ private:
is_disj = true;
_body.push_back(mk_not(m, e1));
_body.push_back(e2);
disjs = _body.c_ptr();
disjs = _body.data();
num_disj = 2;
negate_args = false;
}
@ -376,7 +376,7 @@ private:
}
}
if (produce_proofs()) {
proof* p = m.mk_apply_defs(body.get(), head, defs.size(), defs.c_ptr());
proof* p = m.mk_apply_defs(body.get(), head, defs.size(), defs.data());
m_refs.push_back(p);
m_memoize_proof.insert(b, p);
}
@ -405,9 +405,9 @@ private:
}
func_decl_ref f(m);
auto str = m_name.str();
f = m.mk_fresh_func_decl(str.c_str(), "", sorts1.size(), sorts1.c_ptr(), m.mk_bool_sort());
f = m.mk_fresh_func_decl(str.c_str(), "", sorts1.size(), sorts1.data(), m.mk_bool_sort());
m_fresh_predicates.push_back(f);
return app_ref(m.mk_app(f, args.size(), args.c_ptr()), m);
return app_ref(m.mk_app(f, args.size(), args.data()), m);
}
void eliminate_disjunctions(expr_ref_vector& body, proof_ref_vector& proofs) {
@ -450,7 +450,7 @@ private:
case 1:
return app_ref(m.mk_implies(body[0], head), m);
default:
return app_ref(m.mk_implies(m.mk_and(body.size(), body.c_ptr()), head), m);
return app_ref(m.mk_implies(m.mk_and(body.size(), body.data()), head), m);
}
}
@ -470,7 +470,7 @@ private:
}
VERIFY (m.is_oeq(fact) || m.is_eq(fact));
app* e2 = to_app(to_app(fact)->get_arg(1));
p2 = m.mk_oeq_congruence(e2, fml, defs.size(), defs.c_ptr());
p2 = m.mk_oeq_congruence(e2, fml, defs.size(), defs.data());
p3 = mk_transitivity(p1, p2);
defs.reset();
return p3;
@ -507,7 +507,7 @@ private:
if (m_sorts.empty()) {
return expr_ref(e, m);
}
return expr_ref(m.mk_forall(m_sorts.size(), m_sorts.c_ptr(), m_names.c_ptr(), e), m);
return expr_ref(m.mk_forall(m_sorts.size(), m_sorts.data(), m_names.data(), e), m);
}
};