mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-10-06 07:53:59 +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);
}
};

80
src/muz/bmc/dl_bmc_engine.cpp
View file

@ -110,31 +110,31 @@ namespace datalog {
// apply substitution to body.
var_subst vs(m, false);
for (unsigned k = 0; k < p->get_arity(); ++k) {
trm = vs(r.get_head()->get_arg(k), sub.size(), sub.c_ptr());
trm = vs(r.get_head()->get_arg(k), sub.size(), sub.data());
conjs.push_back(m.mk_eq(trm, mk_q_arg(p, k, true)));
}
for (unsigned j = 0; j < r.get_uninterpreted_tail_size(); ++j) {
func_decl* q = r.get_decl(j);
for (unsigned k = 0; k < q->get_arity(); ++k) {
trm = vs(r.get_tail(j)->get_arg(k), sub.size(), sub.c_ptr());
trm = vs(r.get_tail(j)->get_arg(k), sub.size(), sub.data());
conjs.push_back(m.mk_eq(trm, mk_q_arg(q, k, false)));
}
func_decl_ref qr = mk_q_func_decl(q);
conjs.push_back(m.mk_app(qr, m_bv.mk_bv_sub(var, mk_q_one())));
}
for (unsigned j = r.get_uninterpreted_tail_size(); j < r.get_tail_size(); ++j) {
trm = vs(r.get_tail(j), sub.size(), sub.c_ptr());
trm = vs(r.get_tail(j), sub.size(), sub.data());
conjs.push_back(trm);
}
if (r.get_uninterpreted_tail_size() > 0) {
conjs.push_back(m_bv.mk_ule(mk_q_one(), var));
}
bool_rewriter(m).mk_and(conjs.size(), conjs.c_ptr(), rule_body);
bool_rewriter(m).mk_and(conjs.size(), conjs.data(), rule_body);
trm = m.mk_implies(rule_i, rule_body);
trm = m.mk_forall(1, index_sorts, &tick, trm, 1);
b.assert_expr(trm);
}
bool_rewriter(m).mk_or(rules.size(), rules.c_ptr(), trm);
bool_rewriter(m).mk_or(rules.size(), rules.data(), trm);
trm = m.mk_implies(pred, trm);
trm = m.mk_forall(1, index_sorts, &tick, trm, 1);
SASSERT(is_well_sorted(m, trm));
@ -302,7 +302,7 @@ namespace datalog {
rm.to_formula(*r, fml);
r2 = r;
rm.substitute(r2, sub.size(), sub.c_ptr());
rm.substitute(r2, sub.size(), sub.data());
proof_ref p(m);
if (r0) {
VERIFY(unifier.unify_rules(*r0.get(), 0, *r2.get()));
@ -399,7 +399,7 @@ namespace datalog {
symbol nm(_name.str());
vars.push_back(m.mk_const(nm, level_p->get_domain(i)));
}
return expr_ref(m.mk_app(level_p, vars.size(), vars.c_ptr()), m);
return expr_ref(m.mk_app(level_p, vars.size(), vars.data()), m);
}
void compile(rule_set const& rules, expr_ref_vector& result, unsigned level) {
@ -441,11 +441,11 @@ namespace datalog {
++num_vars;
}
}
head = m.mk_app(rule_i, args.size(), args.c_ptr());
head = m.mk_app(rule_i, args.size(), args.data());
for (unsigned i = 0; i < r.get_tail_size(); ++i) {
conjs.push_back(r.get_tail(i));
}
br.mk_and(conjs.size(), conjs.c_ptr(), body);
br.mk_and(conjs.size(), conjs.data(), body);
replace_by_level_predicates(level, body);
body = skolemize_vars(r, args, rule_vars, body);
@ -453,7 +453,7 @@ namespace datalog {
body = bind_vars(body, head);
result.push_back(body);
}
br.mk_or(rules.size(), rules.c_ptr(), body);
br.mk_or(rules.size(), rules.data(), body);
head = apply_vars(level_pred);
body = m.mk_implies(head, body);
body = bind_vars(body, head);
@ -545,12 +545,12 @@ namespace datalog {
for (unsigned j = 0; j < sz; ++j) {
func_decl* head_j = r->get_decl(j);
app* body_j = r->get_tail(j);
prop_body = vs(body_j, sub.size(), sub.c_ptr());
prop_body = vs(body_j, sub.size(), sub.data());
prs.push_back(get_proof(md, head_j, to_app(prop_body), level-1));
positions.push_back(std::make_pair(j+1,0));
substs.push_back(expr_ref_vector(m));
}
pr = m.mk_hyper_resolve(sz+1, prs.c_ptr(), prop, positions, substs);
pr = m.mk_hyper_resolve(sz+1, prs.data(), prop, positions, substs);
return pr;
}
@ -585,7 +585,7 @@ namespace datalog {
for (unsigned i = 0; i < p->get_arity(); ++i) {
vars.push_back(m.mk_var(i, p->get_domain(i)));
}
return expr_ref(m.mk_app(p, vars.size(), vars.c_ptr()), m);
return expr_ref(m.mk_app(p, vars.size(), vars.data()), m);
}
// remove variables from dst that are in src.
@ -609,7 +609,7 @@ namespace datalog {
for (unsigned i = 0; i < vars.size(); ++i) {
if (vars[i]) {
func_decl_ref f = mk_body_func(r, arg_sorts, i, vars[i]);
binding.push_back(m.mk_app(f, args.size(), args.c_ptr()));
binding.push_back(m.mk_app(f, args.size(), args.data()));
}
else {
binding.push_back(nullptr);
@ -621,14 +621,14 @@ namespace datalog {
expr_ref skolemize_vars(rule& r, expr_ref_vector const& args, ptr_vector<sort> const& vars, expr* e) {
expr_ref_vector binding = mk_skolem_binding(r, vars, args);
var_subst vs(m, false);
return vs(e, binding.size(), binding.c_ptr());
return vs(e, binding.size(), binding.data());
}
func_decl_ref mk_body_func(rule& r, ptr_vector<sort> const& args, unsigned index, sort* s) {
std::stringstream _name;
_name << r.get_decl()->get_name() << "@" << index;
symbol name(_name.str());
func_decl* f = m.mk_func_decl(name, args.size(), args.c_ptr(), s);
func_decl* f = m.mk_func_decl(name, args.size(), args.data(), s);
return func_decl_ref(f, m);
}
@ -654,11 +654,11 @@ namespace datalog {
return expr_ref(e, m);
}
var_subst vs(m, false);
tmp = vs(e, binding.size(), binding.c_ptr());
head = vs(pat, binding.size(), binding.c_ptr());
tmp = vs(e, binding.size(), binding.data());
head = vs(pat, binding.size(), binding.data());
patterns.push_back(m.mk_pattern(to_app(head)));
symbol qid, skid;
return expr_ref(m.mk_forall(sorts.size(), sorts.c_ptr(), names.c_ptr(), tmp, 1, qid, skid, 1, patterns.c_ptr()), m);
return expr_ref(m.mk_forall(sorts.size(), sorts.data(), names.data(), tmp, 1, qid, skid, 1, patterns.data()), m);
}
public:
@ -892,14 +892,14 @@ namespace datalog {
for (unsigned j = 0; j < arity; ++j) {
vars.push_back(m.mk_var(arity-j,cnstr->get_domain(j)));
}
trace_arg = m.mk_app(cnstr, vars.size(), vars.c_ptr());
trace_arg = m.mk_app(cnstr, vars.size(), vars.data());
mk_subst(r, path_var, to_app(trace_arg), sub);
// apply substitution to body.
var_subst vs(m, false);
for (unsigned k = 0; k < p->get_arity(); ++k) {
tmp = vs(r.get_head()->get_arg(k), sub.size(), sub.c_ptr());
tmp = vs(r.get_head()->get_arg(k), sub.size(), sub.data());
expr_ref arg = mk_arg(p, k, path_var, trace_arg);
conjs.push_back(m.mk_eq(tmp, arg));
}
@ -913,7 +913,7 @@ namespace datalog {
}
func_decl* q = r.get_decl(j);
for (unsigned k = 0; k < q->get_arity(); ++k) {
tmp = vs(r.get_tail(j)->get_arg(k), sub.size(), sub.c_ptr());
tmp = vs(r.get_tail(j)->get_arg(k), sub.size(), sub.data());
expr_ref arg = mk_arg(q, k, path_arg, vars[j].get());
conjs.push_back(m.mk_eq(tmp, arg));
}
@ -921,10 +921,10 @@ namespace datalog {
conjs.push_back(m.mk_app(q_pred, vars[j].get(), path_arg));
}
for (unsigned j = r.get_uninterpreted_tail_size(); j < r.get_tail_size(); ++j) {
tmp = vs(r.get_tail(j), sub.size(), sub.c_ptr());
tmp = vs(r.get_tail(j), sub.size(), sub.data());
conjs.push_back(tmp);
}
bool_rewriter(m).mk_and(conjs.size(), conjs.c_ptr(), rule_body);
bool_rewriter(m).mk_and(conjs.size(), conjs.data(), rule_body);
ptr_vector<sort> q_sorts;
vector<symbol> names;
for (unsigned i = 0; i < vars.size(); ++i) {
@ -941,7 +941,7 @@ namespace datalog {
patterns.reset();
patterns.push_back(m.mk_pattern(to_app(tmp)));
fml = m.mk_implies(tmp, rule_body);
fml = m.mk_forall(vars.size(), q_sorts.c_ptr(), names.c_ptr(), fml, 1, qid, skid, 1, patterns.c_ptr());
fml = m.mk_forall(vars.size(), q_sorts.data(), names.data(), fml, 1, qid, skid, 1, patterns.data());
b.assert_expr(fml);
}
}
@ -980,16 +980,16 @@ namespace datalog {
symbol name(_name.str());
_name << '?';
symbol is_name(_name.str());
cnstrs.push_back(mk_constructor_decl(name, is_name, accs.size(), accs.c_ptr()));
cnstrs.push_back(mk_constructor_decl(name, is_name, accs.size(), accs.data()));
}
dts.push_back(mk_datatype_decl(dtu, pred->get_name(), 0, nullptr, cnstrs.size(), cnstrs.c_ptr()));
dts.push_back(mk_datatype_decl(dtu, pred->get_name(), 0, nullptr, cnstrs.size(), cnstrs.data()));
}
sort_ref_vector new_sorts(m);
family_id dfid = m.mk_family_id("datatype");
datatype_decl_plugin* dtp = static_cast<datatype_decl_plugin*>(m.get_plugin(dfid));
VERIFY (dtp->mk_datatypes(dts.size(), dts.c_ptr(), 0, nullptr, new_sorts));
VERIFY (dtp->mk_datatypes(dts.size(), dts.data(), 0, nullptr, new_sorts));
it = b.m_rules.begin_grouped_rules();
for (unsigned i = 0; it != end; ++it, ++i) {
@ -1000,7 +1000,7 @@ namespace datalog {
if (!new_sorts.empty()) {
TRACE("bmc", dtu.display_datatype(new_sorts[0].get(), tout););
}
del_datatype_decls(dts.size(), dts.c_ptr());
del_datatype_decls(dts.size(), dts.data());
// declare path data-type.
{
@ -1028,10 +1028,10 @@ namespace datalog {
ptr_vector<accessor_decl> accs;
type_ref tr(0);
accs.push_back(mk_accessor_decl(m, name, tr));
cnstrs.push_back(mk_constructor_decl(name, is_name, accs.size(), accs.c_ptr()));
cnstrs.push_back(mk_constructor_decl(name, is_name, accs.size(), accs.data()));
}
dts.push_back(mk_datatype_decl(dtu, symbol("Path"), 0, nullptr, cnstrs.size(), cnstrs.c_ptr()));
VERIFY (dtp->mk_datatypes(dts.size(), dts.c_ptr(), 0, nullptr, new_sorts));
dts.push_back(mk_datatype_decl(dtu, symbol("Path"), 0, nullptr, cnstrs.size(), cnstrs.data()));
VERIFY (dtp->mk_datatypes(dts.size(), dts.data(), 0, nullptr, new_sorts));
m_path_sort = new_sorts[0].get();
}
}
@ -1069,7 +1069,7 @@ namespace datalog {
}
rule_ref rl(b.m_ctx.get_rule_manager());
rl = rules[i];
b.m_ctx.get_rule_manager().substitute(rl, sub.size(), sub.c_ptr());
b.m_ctx.get_rule_manager().substitute(rl, sub.size(), sub.data());
substs.push_back(sub);
@ -1086,7 +1086,7 @@ namespace datalog {
substs.push_back(expr_ref_vector(m));
}
head = rl->get_head();
pr = m.mk_hyper_resolve(sz+1, prs.c_ptr(), head, positions, substs);
pr = m.mk_hyper_resolve(sz+1, prs.data(), head, positions, substs);
b.m_rule_trace.push_back(rl.get());
return pr;
}
@ -1235,7 +1235,7 @@ namespace datalog {
rm.to_formula(*r, fml);
r2 = r;
rm.substitute(r2, sub.size(), sub.c_ptr());
rm.substitute(r2, sub.size(), sub.data());
proof_ref p(m);
{
scoped_proof _sp(m);
@ -1405,27 +1405,27 @@ namespace datalog {
// apply substitution to body.
var_subst vs(m, false);
for (unsigned k = 0; k < p->get_arity(); ++k) {
tmp = vs(r.get_head()->get_arg(k), sub.size(), sub.c_ptr());
tmp = vs(r.get_head()->get_arg(k), sub.size(), sub.data());
conjs.push_back(m.mk_eq(tmp, mk_level_arg(p, k, level)));
}
for (unsigned j = 0; j < r.get_uninterpreted_tail_size(); ++j) {
SASSERT(level > 0);
func_decl* q = r.get_decl(j);
for (unsigned k = 0; k < q->get_arity(); ++k) {
tmp = vs(r.get_tail(j)->get_arg(k), sub.size(), sub.c_ptr());
tmp = vs(r.get_tail(j)->get_arg(k), sub.size(), sub.data());
conjs.push_back(m.mk_eq(tmp, mk_level_arg(q, k, level-1)));
}
conjs.push_back(mk_level_predicate(q, level-1));
}
for (unsigned j = r.get_uninterpreted_tail_size(); j < r.get_tail_size(); ++j) {
tmp = vs(r.get_tail(j), sub.size(), sub.c_ptr());
tmp = vs(r.get_tail(j), sub.size(), sub.data());
conjs.push_back(tmp);
}
bool_rewriter(m).mk_and(conjs.size(), conjs.c_ptr(), rule_body);
bool_rewriter(m).mk_and(conjs.size(), conjs.data(), rule_body);
rule_body = m.mk_implies(rule_i, rule_body);
b.assert_expr(rule_body);
}
bool_rewriter(m).mk_or(rules.size(), rules.c_ptr(), tmp);
bool_rewriter(m).mk_or(rules.size(), rules.data(), tmp);
tmp = m.mk_implies(level_pred, tmp);
b.assert_expr(tmp);
}

2
src/muz/clp/clp_context.cpp
View file

@ -120,7 +120,7 @@ namespace datalog {
m_ground[i] = m.mk_fresh_const("c", fv[i]);
}
}
e = m_var_subst(e, m_ground.size(), m_ground.c_ptr());
e = m_var_subst(e, m_ground.size(), m_ground.data());
}
static bool rule_sort_fn(const rule *r1, const rule *r2) {

12
src/muz/ddnf/ddnf.cpp
View file

@ -679,7 +679,7 @@ namespace datalog {
for (; dit != dend; ++dit) {
heads.push_back(dit->m_key);
}
return m_inner_ctx.rel_query(heads.size(), heads.c_ptr());
return m_inner_ctx.rel_query(heads.size(), heads.data());
}
bool compile_rules1(rule_set const& rules, rule_set& new_rules) {
@ -709,7 +709,7 @@ namespace datalog {
compile_expr(r.get_tail(i), tmp);
body.push_back(to_app(tmp));
}
rule* r_new = rm.mk(head, body.size(), body.c_ptr(), nullptr, r.name(), false);
rule* r_new = rm.mk(head, body.size(), body.data(), nullptr, r.name(), false);
new_rules.add_rule(r_new);
IF_VERBOSE(20, r_new->display(m_ctx, verbose_stream()););
if (old_rules.is_output_predicate(r.get_decl())) {
@ -726,7 +726,7 @@ namespace datalog {
domain.push_back(compile_sort(p->get_arg(i)->get_sort()));
}
func_decl_ref fn(m);
fn = m.mk_func_decl(d->get_name(), domain.size(), domain.c_ptr(), m.mk_bool_sort());
fn = m.mk_func_decl(d->get_name(), domain.size(), domain.data(), m.mk_bool_sort());
m_ctx.register_predicate(fn, false);
expr_ref_vector args(m);
expr_ref tmp(m);
@ -734,7 +734,7 @@ namespace datalog {
compile_expr(p->get_arg(i), tmp);
args.push_back(tmp);
}
result = m.mk_app(fn, args.size(), args.c_ptr());
result = m.mk_app(fn, args.size(), args.data());
}
void insert_cache(expr* e, expr* r) {
@ -804,7 +804,7 @@ namespace datalog {
compile_expr(a->get_arg(i), tmp);
args.push_back(tmp);
}
result = m.mk_app(a->get_decl(), args.size(), args.c_ptr());
result = m.mk_app(a->get_decl(), args.size(), args.data());
insert_cache(e, result);
return;
}
@ -863,7 +863,7 @@ namespace datalog {
result = eqs[0].get();
break;
default:
result = m.mk_or(eqs.size(), eqs.c_ptr());
result = m.mk_or(eqs.size(), eqs.data());
break;
}
}

6
src/muz/fp/datalog_parser.cpp
View file

@ -729,7 +729,7 @@ protected:
while (tok != TK_ERROR && tok != TK_EOS) {
if (tok == TK_PERIOD) {
SASSERT(body.size()==polarity_vect.size());
add_rule(head, body.size(), body.c_ptr(), polarity_vect.c_ptr());
add_rule(head, body.size(), body.data(), polarity_vect.data());
return m_lexer->next_token();
}
char const* td = m_lexer->get_token_data();
@ -852,7 +852,7 @@ protected:
for (unsigned i = 0; i < arity; ++i) {
domain.push_back(args[i]->get_sort());
}
f = m.mk_func_decl(s, domain.size(), domain.c_ptr(), m.mk_bool_sort());
f = m.mk_func_decl(s, domain.size(), domain.data(), m.mk_bool_sort());
m_context.register_predicate(f, true);
@ -870,7 +870,7 @@ protected:
}
SASSERT(args.size()==f->get_arity());
//TODO: we do not need to do the mk_app if we're in a declaration
pred = m.mk_app(f, args.size(), args.c_ptr());
pred = m.mk_app(f, args.size(), args.data());
return tok;
}

6
src/muz/fp/dl_cmds.cpp
View file

@ -127,7 +127,7 @@ struct dl_context {
for (unsigned i = 0; i < q->get_arity(); ++i) {
args.push_back(m.mk_var(i, q->get_domain(i)));
}
qr = m.mk_app(q, args.size(), args.c_ptr());
qr = m.mk_app(q, args.size(), args.data());
qr = m_context->bind_vars(qr, false);
m_collected_cmds->m_queries.push_back(qr);
m_trail.push(push_back_vector<expr_ref_vector>(m_collected_cmds->m_queries));
@ -427,9 +427,9 @@ public:
ast_manager& m = ctx.m();
func_decl_ref pred(
m.mk_func_decl(m_rel_name, m_domain.size(), m_domain.c_ptr(), m.mk_bool_sort()), m);
m.mk_func_decl(m_rel_name, m_domain.size(), m_domain.data(), m.mk_bool_sort()), m);
ctx.insert(pred);
m_dl_ctx->register_predicate(pred, m_kinds.size(), m_kinds.c_ptr());
m_dl_ctx->register_predicate(pred, m_kinds.size(), m_kinds.data());
}
};

6
src/muz/fp/horn_tactic.cpp
View file

@ -160,13 +160,13 @@ class horn_tactic : public tactic {
}
if (head) {
if (!is_implication(f)) {
f = m.mk_and(body.size(), body.c_ptr());
f = m.mk_and(body.size(), body.data());
f = m.mk_implies(f, head);
}
return IS_RULE;
}
else {
f = m.mk_and(body.size(), body.c_ptr());
f = m.mk_and(body.size(), body.data());
return IS_QUERY;
}
}
@ -308,7 +308,7 @@ class horn_tactic : public tactic {
for (unsigned i = 0; i < m_free_vars.size(); ++i) {
names.push_back(symbol(m_free_vars.size() - i - 1));
}
f = m.mk_forall(m_free_vars.size(), m_free_vars.c_ptr(), names.c_ptr(), f);
f = m.mk_forall(m_free_vars.size(), m_free_vars.data(), names.data(), f);
}
}

10
src/muz/rel/aig_exporter.cpp
View file

@ -133,7 +133,7 @@ namespace datalog {
exprs.push_back(e);
}
transition_function.push_back(m.mk_and(exprs.size(), exprs.c_ptr()));
transition_function.push_back(m.mk_and(exprs.size(), exprs.data()));
}
}
@ -148,11 +148,11 @@ namespace datalog {
exprs.push_back(m.mk_eq(get_latch_var(i, m_latch_varsp), I->second[i]));
}
transition_function.push_back(m.mk_and(exprs.size(), exprs.c_ptr()));
transition_function.push_back(m.mk_and(exprs.size(), exprs.data()));
}
}
expr *tr = m.mk_or(transition_function.size(), transition_function.c_ptr());
expr *tr = m.mk_or(transition_function.size(), transition_function.data());
aig_ref aig = m_aigm.mk_aig(tr);
expr_ref aig_expr(m);
m_aigm.to_formula(aig, aig_expr);
@ -194,10 +194,10 @@ namespace datalog {
for (func_decl_set::iterator I = preds.begin(), E = preds.end(); I != E; ++I) {
exprs.reset();
assert_pred_id(*I, m_ruleid_var_set, exprs);
output.push_back(m.mk_and(exprs.size(), exprs.c_ptr()));
output.push_back(m.mk_and(exprs.size(), exprs.data()));
}
expr *out = m.mk_or(output.size(), output.c_ptr());
expr *out = m.mk_or(output.size(), output.data());
aig = m_aigm.mk_aig(out);
m_aigm.to_formula(aig, aig_expr);
output_id = expr_to_aig(aig_expr);

42
src/muz/rel/check_relation.cpp
View file

@ -39,7 +39,7 @@ namespace datalog {
for (unsigned i = 0; i < sig.size(); ++i) {
conjs.push_back(m.mk_eq(m.mk_var(i, sig[i]), f[i]));
}
return expr_ref(mk_and(m, conjs.size(), conjs.c_ptr()), m);
return expr_ref(mk_and(m, conjs.size(), conjs.data()), m);
}
expr_ref check_relation::ground(expr* fml) const {
@ -59,7 +59,7 @@ namespace datalog {
for (unsigned i = 0; i < sig.size(); ++i) {
vars.push_back(m.mk_const(symbol(i), sig[i]));
}
return sub(fml, vars.size(), vars.c_ptr());
return sub(fml, vars.size(), vars.data());
}
void check_relation::add_fact(const relation_fact & f) {
@ -290,9 +290,9 @@ namespace datalog {
}
}
var_subst sub(m, false);
fml1 = sub(fml, vars.size(), vars.c_ptr());
fml1 = sub(fml, vars.size(), vars.data());
bound.reverse();
fml1 = m.mk_exists(bound.size(), bound.c_ptr(), names.c_ptr(), fml1);
fml1 = m.mk_exists(bound.size(), bound.data(), names.data(), fml1);
return fml1;
}
@ -331,7 +331,7 @@ namespace datalog {
for (unsigned i = 0; i < sig2.size(); ++i) {
vars.push_back(m.mk_var(i + sig1.size(), sig2[i]));
}
fml2 = sub(fml2, vars.size(), vars.c_ptr());
fml2 = sub(fml2, vars.size(), vars.data());
fml1 = m.mk_and(fml1, fml2);
for (unsigned i = 0; i < cols1.size(); ++i) {
unsigned v1 = cols1[i];
@ -370,14 +370,14 @@ namespace datalog {
expr_ref fml1(m), fml2(m);
src.to_formula(fml1);
dst.to_formula(fml2);
fml1 = subst(fml1, sub.size(), sub.c_ptr());
fml1 = subst(fml1, sub.size(), sub.data());
expr_ref_vector vars(m);
for (unsigned i = 0; i < sig2.size(); ++i) {
vars.push_back(m.mk_const(symbol(i), sig2[i]));
}
fml1 = subst(fml1, vars.size(), vars.c_ptr());
fml2 = subst(fml2, vars.size(), vars.c_ptr());
fml1 = subst(fml1, vars.size(), vars.data());
fml2 = subst(fml2, vars.size(), vars.data());
check_equiv("permutation", fml1, fml2);
}
@ -403,8 +403,8 @@ namespace datalog {
strm << 'x' << i;
vars.push_back(m.mk_const(symbol(strm.str()), sig[i]));
}
fml1 = sub(fml1, vars.size(), vars.c_ptr());
fml2 = sub(fml2, vars.size(), vars.c_ptr());
fml1 = sub(fml1, vars.size(), vars.data());
fml2 = sub(fml2, vars.size(), vars.data());
check_equiv("filter", fml1, fml2);
}
@ -451,8 +451,8 @@ namespace datalog {
strm << 'x' << i;
vars.push_back(m.mk_const(symbol(strm.str()), sig[i]));
}
fml1 = sub(fml1, vars.size(), vars.c_ptr());
fml2 = sub(fml2, vars.size(), vars.c_ptr());
fml1 = sub(fml1, vars.size(), vars.data());
fml2 = sub(fml2, vars.size(), vars.data());
check_equiv("union", fml1, fml2);
@ -464,13 +464,13 @@ namespace datalog {
// dst \ dst0 == delta & dst & \ dst0
expr_ref fml4(m), fml5(m);
fml4 = m.mk_and(fml2, m.mk_not(dst0));
fml4 = sub(fml4, vars.size(), vars.c_ptr());
d = sub(d, vars.size(), vars.c_ptr());
fml4 = sub(fml4, vars.size(), vars.data());
d = sub(d, vars.size(), vars.data());
check_contains("union_delta low", d, fml4);
//
// delta >= delta0
//
d0 = sub(delta0, vars.size(), vars.c_ptr());
d0 = sub(delta0, vars.size(), vars.data());
check_contains("union delta0", d, d0);
//
@ -478,8 +478,8 @@ namespace datalog {
//
fml4 = m.mk_or(fml2, delta0);
fml5 = m.mk_or(d, dst0);
fml4 = sub(fml4, vars.size(), vars.c_ptr());
fml5 = sub(fml5, vars.size(), vars.c_ptr());
fml4 = sub(fml4, vars.size(), vars.data());
fml5 = sub(fml5, vars.size(), vars.data());
check_equiv("union no overflow", fml4, fml5);
}
}
@ -541,7 +541,7 @@ namespace datalog {
unsigned c2 = m_cols[i];
conds.push_back(m.mk_eq(m.mk_var(c1, sig[c1]), m.mk_var(c2, sig[c2])));
}
cond = mk_and(m, conds.size(), conds.c_ptr());
cond = mk_and(m, conds.size(), conds.data());
r.consistent_formula();
(*m_filter)(r.rb());
p.verify_filter(r.m_fml, r.rb(), cond);
@ -733,14 +733,14 @@ namespace datalog {
v2 = m.mk_var(c2, sig2[c2]);
eqs.push_back(m.mk_eq(v1, v2));
}
negf = mk_and(m, eqs.size(), eqs.c_ptr());
ptr_vector<sort> rev_sig2(sig2.size(), sig2.c_ptr());
negf = mk_and(m, eqs.size(), eqs.data());
ptr_vector<sort> rev_sig2(sig2.size(), sig2.data());
rev_sig2.reverse();
svector<symbol> names;
for (unsigned i = 0; i < sig2.size(); ++i) {
names.push_back(symbol(i));
}
negf = m.mk_exists(rev_sig2.size(), rev_sig2.c_ptr(), names.c_ptr(), negf);
negf = m.mk_exists(rev_sig2.size(), rev_sig2.data(), names.data(), negf);
negf = m.mk_and(dst0, m.mk_not(negf));
negf = ground(dst, negf);
dstf = ground(dst, dstf);

6
src/muz/rel/dl_base.cpp
View file

@ -257,7 +257,7 @@ namespace datalog {
k.get_fact(row);
to_remove.push_back(row);
}
remove_facts(to_remove.size(), to_remove.c_ptr());
remove_facts(to_remove.size(), to_remove.data());
}
bool table_base::contains_fact(const table_fact & f) const {
@ -456,9 +456,9 @@ namespace datalog {
for (unsigned i = 0; i < fact.size(); ++i) {
conjs.push_back(m.mk_eq(m.mk_var(i, sig[i]), util.mk_numeral(fact[i], sig[i])));
}
brw.mk_and(conjs.size(), conjs.c_ptr(), fml);
brw.mk_and(conjs.size(), conjs.data(), fml);
disjs.push_back(fml);
}
brw.mk_or(disjs.size(), disjs.c_ptr(), fml);
brw.mk_or(disjs.size(), disjs.data(), fml);
}
}

4
src/muz/rel/dl_base.h
View file

@ -98,7 +98,7 @@ namespace datalog {
if (n!=o.size()) {
return false;
}
return memcmp(this->c_ptr(), o.c_ptr(), n*sizeof(sort))==0;
return memcmp(this->data(), o.data(), n*sizeof(sort))==0;
/*for (unsigned i=0; i<n; i++) {
if ((*this)[i]!=o[i]) {
return false;
@ -1075,7 +1075,7 @@ namespace datalog {
virtual void remove_fact(const table_fact & fact) {
SASSERT(fact.size() == get_signature().size());
remove_fact(fact.c_ptr()); }
remove_fact(fact.data()); }
virtual void remove_fact(table_element const* fact) = 0;
virtual void remove_facts(unsigned fact_cnt, const table_fact * facts);

8
src/muz/rel/dl_bound_relation.cpp
View file

@ -84,7 +84,7 @@ namespace datalog {
bound_relation const& r2 = get(_r2);
bound_relation_plugin& p = r1.get_plugin();
bound_relation* result = dynamic_cast<bound_relation*>(p.mk_full(nullptr, get_result_signature()));
result->mk_join(r1, r2, m_cols1.size(), m_cols1.c_ptr(), m_cols2.c_ptr());
result->mk_join(r1, r2, m_cols1.size(), m_cols1.data(), m_cols2.data());
return result;
}
};
@ -108,7 +108,7 @@ namespace datalog {
bound_relation const& r = get(_r);
bound_relation_plugin& p = r.get_plugin();
bound_relation* result = get(p.mk_full(nullptr, get_result_signature()));
result->mk_project(r, m_removed_cols.size(), m_removed_cols.c_ptr());
result->mk_project(r, m_removed_cols.size(), m_removed_cols.data());
return result;
}
};
@ -128,7 +128,7 @@ namespace datalog {
bound_relation const& r = get(_r);
bound_relation_plugin& p = r.get_plugin();
bound_relation* result = get(p.mk_full(nullptr, get_result_signature()));
result->mk_rename(r, m_cycle.size(), m_cycle.c_ptr());
result->mk_rename(r, m_cycle.size(), m_cycle.data());
return result;
}
};
@ -671,7 +671,7 @@ namespace datalog {
conjs.push_back(arith.mk_le(m.mk_var(i, sig[i]), m.mk_var(*it, sig[*it])));
}
}
bsimp.mk_and(conjs.size(), conjs.c_ptr(), fml);
bsimp.mk_and(conjs.size(), conjs.data(), fml);
}

28
src/muz/rel/dl_compiler.cpp
View file

@ -66,12 +66,12 @@ namespace datalog {
relation_signature sig2 = m_reg_signatures[t2];
relation_signature::from_join(sig1, sig2, vars.size(), vars.get_cols1(), vars.get_cols2(), aux_sig);
relation_signature res_sig;
relation_signature::from_project(aux_sig, removed_cols.size(), removed_cols.c_ptr(),
relation_signature::from_project(aux_sig, removed_cols.size(), removed_cols.data(),
res_sig);
result = get_register(res_sig, reuse_t1, t1);
acc.push_back(instruction::mk_join_project(t1, t2, vars.size(), vars.get_cols1(),
vars.get_cols2(), removed_cols.size(), removed_cols.c_ptr(), result));
vars.get_cols2(), removed_cols.size(), removed_cols.data(), result));
}
void compiler::make_filter_interpreted_and_project(reg_idx src, app_ref & cond,
@ -79,11 +79,11 @@ namespace datalog {
SASSERT(!removed_cols.empty());
relation_signature res_sig;
relation_signature::from_project(m_reg_signatures[src], removed_cols.size(),
removed_cols.c_ptr(), res_sig);
removed_cols.data(), res_sig);
result = get_register(res_sig, reuse, src);
acc.push_back(instruction::mk_filter_interpreted_and_project(src, cond,
removed_cols.size(), removed_cols.c_ptr(), result));
removed_cols.size(), removed_cols.data(), result));
}
void compiler::make_select_equal_and_project(reg_idx src, const relation_element val, unsigned col,
@ -245,7 +245,7 @@ namespace datalog {
removed_cols.push_back(i);
}
}
make_projection(src, removed_cols.size(), removed_cols.c_ptr(), single_col_reg, false, acc);
make_projection(src, removed_cols.size(), removed_cols.data(), single_col_reg, false, acc);
}
variable_intersection vi(m_context.get_manager());
vi.add_pair(col, 0);
@ -311,7 +311,7 @@ namespace datalog {
new_src_col_offset.push_back(src_cols_to_remove.size());
}
if(!src_cols_to_remove.empty()) {
make_projection(curr, src_cols_to_remove.size(), src_cols_to_remove.c_ptr(), curr, dealloc, acc);
make_projection(curr, src_cols_to_remove.size(), src_cols_to_remove.data(), curr, dealloc, acc);
dealloc = true;
curr_sig = & m_reg_signatures[curr];
@ -385,7 +385,7 @@ namespace datalog {
SASSERT(permutation.size()<=col_cnt); //this should not be an infinite loop
} while(next!=i);
make_rename(curr, permutation.size(), permutation.c_ptr(), curr, dealloc, acc);
make_rename(curr, permutation.size(), permutation.data(), curr, dealloc, acc);
dealloc = true;
curr_sig = & m_reg_signatures[curr];
}
@ -594,7 +594,7 @@ namespace datalog {
}
if (!dealloc)
make_clone(filtered_res, filtered_res, acc);
acc.push_back(instruction::mk_filter_identical(filtered_res, indexes.size(), indexes.c_ptr()));
acc.push_back(instruction::mk_filter_identical(filtered_res, indexes.size(), indexes.data()));
dealloc = true;
}
@ -675,13 +675,13 @@ namespace datalog {
if (!dealloc)
make_clone(filtered_res, filtered_res, acc);
acc.push_back(instruction::mk_filter_by_negation(filtered_res, neg_reg, t_cols.size(),
t_cols.c_ptr(), neg_cols.c_ptr()));
t_cols.data(), neg_cols.data()));
dealloc = true;
}
// enforce interpreted tail predicates
if (!tail.empty()) {
app_ref filter_cond(tail.size() == 1 ? to_app(tail.back()) : m.mk_and(tail.size(), tail.c_ptr()), m);
app_ref filter_cond(tail.size() == 1 ? to_app(tail.back()) : m.mk_and(tail.size(), tail.data()), m);
// check if there are any columns to remove
unsigned_vector remove_columns;
@ -725,7 +725,7 @@ namespace datalog {
}
}
expr_ref renamed = m_context.get_var_subst()(filter_cond, binding.size(), binding.c_ptr());
expr_ref renamed = m_context.get_var_subst()(filter_cond, binding.size(), binding.data());
app_ref app_renamed(to_app(renamed), m);
if (remove_columns.empty()) {
if (!dealloc && filtered_res != UINT_MAX)
@ -931,7 +931,7 @@ namespace datalog {
}
if(!input_deltas || all_or_nothing_deltas()) {
compile_rule_evaluation_run(r, head_reg, tail_regs.c_ptr(), output_delta, use_widening, acc);
compile_rule_evaluation_run(r, head_reg, tail_regs.data(), output_delta, use_widening, acc);
}
else {
tail_delta_infos::iterator tdit = tail_deltas.begin();
@ -939,7 +939,7 @@ namespace datalog {
for(; tdit!=tdend; ++tdit) {
tail_delta_info tdinfo = *tdit;
flet<reg_idx> flet_tail_reg(tail_regs[tdinfo.second], tdinfo.first);
compile_rule_evaluation_run(r, head_reg, tail_regs.c_ptr(), output_delta, use_widening, acc);
compile_rule_evaluation_run(r, head_reg, tail_regs.data(), output_delta, use_widening, acc);
}
}
}
@ -1121,7 +1121,7 @@ namespace datalog {
loop_body->set_observer(nullptr);
acc.push_back(instruction::mk_while_loop(loop_control_regs.size(),
loop_control_regs.c_ptr(), loop_body));
loop_control_regs.data(), loop_body));
}
void compiler::compile_dependent_rules(const func_decl_set & head_preds,

16
src/muz/rel/dl_external_relation.cpp
View file

@ -46,14 +46,14 @@ namespace datalog {
args.push_back(f[i]);
}
if (!fn.get()) {
fn = m.mk_func_decl(fid, k, 0, nullptr, args.size(), args.c_ptr());
fn = m.mk_func_decl(fid, k, 0, nullptr, args.size(), args.data());
}
if (destructive) {
get_plugin().reduce_assign(fn, args.size(), args.c_ptr(), 1, args.c_ptr());
get_plugin().reduce_assign(fn, args.size(), args.data(), 1, args.data());
res = m_rel;
}
else {
get_plugin().reduce(fn, args.size(), args.c_ptr(), res);
get_plugin().reduce(fn, args.size(), args.data(), res);
}
}
@ -152,7 +152,7 @@ namespace datalog {
for (unsigned i = 0; i < sig.size(); ++i) {
sorts.push_back(parameter(sig[i]));
}
return m.mk_sort(fid, DL_RELATION_SORT, sorts.size(), sorts.c_ptr());
return m.mk_sort(fid, DL_RELATION_SORT, sorts.size(), sorts.data());
}
sort* external_relation_plugin::get_column_sort(unsigned col, sort* s) {
@ -192,7 +192,7 @@ namespace datalog {
params.push_back(parameter(cols2[i]));
}
sort* domain[2] = { p.get_relation_sort(o1_sig), p.get_relation_sort(o2_sig) };
m_join_fn = m.mk_func_decl(fid, OP_RA_JOIN, params.size(), params.c_ptr(), 2, domain);
m_join_fn = m.mk_func_decl(fid, OP_RA_JOIN, params.size(), params.data(), 2, domain);
}
relation_base * operator()(const relation_base & r1, const relation_base & r2) override {
@ -228,7 +228,7 @@ namespace datalog {
for (unsigned i = 0; i < removed_col_cnt; ++i) {
params.push_back(parameter(removed_cols[i]));
}
m_project_fn = m.mk_func_decl(fid, OP_RA_PROJECT, params.size(), params.c_ptr(), 1, &relation_sort);
m_project_fn = m.mk_func_decl(fid, OP_RA_PROJECT, params.size(), params.data(), 1, &relation_sort);
}
relation_base * operator()(const relation_base & r) override {
@ -262,7 +262,7 @@ namespace datalog {
SASSERT(cycle[i] < orig_sig.size());
params.push_back(parameter(cycle[i]));
}
m_rename_fn = m.mk_func_decl(fid, OP_RA_RENAME, params.size(), params.c_ptr(), 1, &relation_sort);
m_rename_fn = m.mk_func_decl(fid, OP_RA_RENAME, params.size(), params.data(), 1, &relation_sort);
}
relation_base * operator()(const relation_base & r) override {
@ -433,7 +433,7 @@ namespace datalog {
params.push_back(parameter(negated_cols[i]));
}
sort* domain[2] = { get(tgt).get_sort(), get(neg_t).get_sort() };
m_negated_filter_fn = m.mk_func_decl(fid, OP_RA_NEGATION_FILTER, params.size(), params.c_ptr(), 2, domain);
m_negated_filter_fn = m.mk_func_decl(fid, OP_RA_NEGATION_FILTER, params.size(), params.data(), 2, domain);
}
void operator()(relation_base & t, const relation_base & negated_obj) override {

46
src/muz/rel/dl_finite_product_relation.cpp
View file

@ -163,7 +163,7 @@ namespace datalog {
relation_signature candidate_rel_sig;
unsigned rel_sig_ofs = s.size()/2;
unsigned rel_sig_sz = s.size()-rel_sig_ofs;
candidate_rel_sig.append(rel_sig_sz, s.c_ptr()+rel_sig_ofs);
candidate_rel_sig.append(rel_sig_sz, s.data()+rel_sig_ofs);
if(m_inner_plugin.can_handle_signature(candidate_rel_sig)) {
for(unsigned i=rel_sig_ofs; i<s_sz; i++) {
table_columns[i] = false;
@ -172,7 +172,7 @@ namespace datalog {
}
#endif
return mk_empty(s, table_columns.c_ptr());
return mk_empty(s, table_columns.data());
}
finite_product_relation * finite_product_relation_plugin::mk_empty(const relation_signature & s,
@ -199,7 +199,7 @@ namespace datalog {
relation_base * finite_product_relation_plugin::mk_empty(const relation_signature & s, family_id kind) {
rel_spec spec;
m_spec_store.get_relation_spec(s, kind, spec);
return mk_empty(s, spec.m_table_cols.c_ptr(), spec.m_inner_kind);
return mk_empty(s, spec.m_table_cols.data(), spec.m_inner_kind);
}
@ -276,7 +276,7 @@ namespace datalog {
scoped_rel<table_base> res_table = (*join_fun)(t, *idx_singleton);
bool_vector table_cols(sig.size(), true);
finite_product_relation * res = mk_empty(sig, table_cols.c_ptr());
finite_product_relation * res = mk_empty(sig, table_cols.data());
//this one does not need to be deleted -- it will be taken over by \c res in the \c init function
relation_base * inner_rel = get_inner_plugin().mk_full(pred, inner_sig, get_inner_plugin().get_kind());
@ -302,7 +302,7 @@ namespace datalog {
idx_singleton->add_fact(idx_singleton_fact);
bool_vector table_cols(sig.size(), false);
finite_product_relation * res = mk_empty(sig, table_cols.c_ptr());
finite_product_relation * res = mk_empty(sig, table_cols.data());
relation_vector rels;
rels.push_back(r.clone());
@ -426,7 +426,7 @@ namespace datalog {
}
}
m_tjoin_fn = r1.get_manager().mk_join_fn(r1.get_table(), r2.get_table(), m_t_joined_cols1.size(),
m_t_joined_cols1.c_ptr(), m_t_joined_cols2.c_ptr());
m_t_joined_cols1.data(), m_t_joined_cols2.data());
SASSERT(m_tjoin_fn);
@ -482,7 +482,7 @@ namespace datalog {
//It would however need to be somehow inferred for the new signature.
finite_product_relation * res = alloc(finite_product_relation, r1.get_plugin(), get_result_signature(),
m_res_table_columns.c_ptr(), res_table->get_plugin(), res_oplugin, null_family_id);
m_res_table_columns.data(), res_table->get_plugin(), res_oplugin, null_family_id);
res->init(*res_table, joined_orelations, true);
@ -491,7 +491,7 @@ namespace datalog {
//We enforce those equalities here.
if(!m_filter_tr_identities) {
m_filter_tr_identities = plugin.mk_filter_identical_pairs(*res, m_tr_table_joined_cols.size(),
m_tr_table_joined_cols.c_ptr(), m_tr_rel_joined_cols.c_ptr());
m_tr_table_joined_cols.data(), m_tr_rel_joined_cols.data());
SASSERT(m_filter_tr_identities);
}
(*m_filter_tr_identities)(*res);
@ -603,7 +603,7 @@ namespace datalog {
else {
project_reducer * preducer = alloc(project_reducer, *this, res_relations);
scoped_ptr<table_transformer_fn> tproject =
rmgr.mk_project_with_reduce_fn(rtable, m_removed_table_cols.size(), m_removed_table_cols.c_ptr(), preducer);
rmgr.mk_project_with_reduce_fn(rtable, m_removed_table_cols.size(), m_removed_table_cols.data(), preducer);
res_table = (*tproject)(rtable);
}
@ -635,7 +635,7 @@ namespace datalog {
//It would however need to be somehow inferred for the new signature.
finite_product_relation * res = alloc(finite_product_relation, r.get_plugin(), get_result_signature(),
m_res_table_columns.c_ptr(), res_table->get_plugin(), *res_oplugin, null_family_id);
m_res_table_columns.data(), res_table->get_plugin(), *res_oplugin, null_family_id);
res->init(*res_table, res_relations, false);
@ -733,7 +733,7 @@ namespace datalog {
//It would however need to be somehow inferred for the new signature.
finite_product_relation * res = alloc(finite_product_relation, r.get_plugin(), get_result_signature(),
m_res_table_columns.c_ptr(), res_table->get_plugin(), r.m_other_plugin, null_family_id);
m_res_table_columns.data(), res_table->get_plugin(), r.m_other_plugin, null_family_id);
res->init(*res_table, res_relations, false);
@ -1143,7 +1143,7 @@ namespace datalog {
}
if(m_table_cols.size()>1) {
m_table_filter = r.get_manager().mk_filter_identical_fn(r.get_table(), m_table_cols.size(),
m_table_cols.c_ptr());
m_table_cols.data());
SASSERT(m_table_filter);
}
if(!m_table_cols.empty() && !m_rel_cols.empty()) {
@ -1159,7 +1159,7 @@ namespace datalog {
if(m_rel_filter) {
return;
}
m_rel_filter = orel.get_manager().mk_filter_identical_fn(orel, m_rel_cols.size(), m_rel_cols.c_ptr());
m_rel_filter = orel.get_manager().mk_filter_identical_fn(orel, m_rel_cols.size(), m_rel_cols.data());
SASSERT(m_rel_filter);
}
@ -1310,7 +1310,7 @@ namespace datalog {
if(m_rel_cond_columns.empty()) {
expr_ref_vector renaming(m_manager);
get_renaming_args(r.m_sig2table, r.get_signature(), renaming);
expr_ref table_cond = m_subst(condition, renaming.size(), renaming.c_ptr());
expr_ref table_cond = m_subst(condition, renaming.size(), renaming.data());
m_table_filter = rmgr.mk_filter_interpreted_fn(r.get_table(), to_app(table_cond));
}
else {
@ -1359,7 +1359,7 @@ namespace datalog {
continue;
}
if(!m_rel_filter) {
expr_ref inner_cond = m_subst(m_cond, m_renaming_for_inner_rel.size(), m_renaming_for_inner_rel.c_ptr());
expr_ref inner_cond = m_subst(m_cond, m_renaming_for_inner_rel.size(), m_renaming_for_inner_rel.data());
m_rel_filter = rmgr.mk_filter_interpreted_fn(*inner, to_app(inner_cond));
}
(*m_rel_filter)(*inner);
@ -1407,7 +1407,7 @@ namespace datalog {
//create the condition with table values substituted in and relation values properly renamed
expr_ref inner_cond(m_manager);
inner_cond = m_subst(m_cond, m_renaming_for_inner_rel.size(), m_renaming_for_inner_rel.c_ptr());
inner_cond = m_subst(m_cond, m_renaming_for_inner_rel.size(), m_renaming_for_inner_rel.data());
th_rewriter rw(m_manager);
rw(inner_cond);
if (m_manager.is_false(inner_cond)) {
@ -1660,7 +1660,7 @@ namespace datalog {
unsigned_vector removed_cols;
add_sequence_without_set(0, t_sz-1, m_table_cols, removed_cols);
if(!removed_cols.empty()) {
m_tproject_fn = r.get_manager().mk_project_fn(r.get_table(), removed_cols.size(), removed_cols.c_ptr());
m_tproject_fn = r.get_manager().mk_project_fn(r.get_table(), removed_cols.size(), removed_cols.data());
}
}
@ -1744,7 +1744,7 @@ namespace datalog {
SASSERT(filtered_table.get_signature().functional_columns()==1);
unsigned_vector rtable_joined_cols;
rtable_joined_cols.append(selected_col_cnt, selected_columns.c_ptr()); //filtered table cols
rtable_joined_cols.append(selected_col_cnt, selected_columns.data()); //filtered table cols
rtable_joined_cols.push_back(rtable_sig_sz-1); //unfiltered relation indexes
unsigned_vector filtered_joined_cols;
@ -2073,7 +2073,7 @@ namespace datalog {
removed_cols[i] = i;
}
live_rel_collection_reducer * reducer = alloc(live_rel_collection_reducer, m_live_rel_collection_acc);
m_live_rel_collection_project = get_manager().mk_project_with_reduce_fn(get_table(), removed_cols.size(), removed_cols.c_ptr(), reducer);
m_live_rel_collection_project = get_manager().mk_project_with_reduce_fn(get_table(), removed_cols.size(), removed_cols.data(), reducer);
SASSERT(m_live_rel_collection_project);
}
@ -2172,7 +2172,7 @@ namespace datalog {
it = rels.begin();
for(; it!=end; ++it) {
finite_product_relation & rel = **it;
if(!rel.try_modify_specification(table_cols.c_ptr())) {
if(!rel.try_modify_specification(table_cols.data())) {
return false;
}
}
@ -2226,7 +2226,7 @@ namespace datalog {
bool_vector moved_cols_table_flags(moved_cols_sig.size(), false);
scoped_rel<finite_product_relation> moved_cols_rel = get_plugin().mk_empty(moved_cols_sig,
moved_cols_table_flags.c_ptr());
moved_cols_table_flags.data());
scoped_ptr<relation_union_fn> union_fun =
get_manager().mk_union_fn(*moved_cols_rel, *moved_cols_trel);
@ -2369,9 +2369,9 @@ namespace datalog {
}
sh(tmp, fact_sz-1, tmp);
conjs.push_back(tmp);
disjs.push_back(m.mk_and(conjs.size(), conjs.c_ptr()));
disjs.push_back(m.mk_and(conjs.size(), conjs.data()));
}
bool_rewriter(m).mk_or(disjs.size(), disjs.c_ptr(), fml);
bool_rewriter(m).mk_or(disjs.size(), disjs.data(), fml);
}
};

10
src/muz/rel/dl_instruction.cpp
View file

@ -486,7 +486,7 @@ namespace datalog {
relation_mutator_fn * fn;
relation_base & r = *ctx.reg(m_reg);
if (!find_fn(r, fn)) {
fn = r.get_manager().mk_filter_identical_fn(r, m_cols.size(), m_cols.c_ptr());
fn = r.get_manager().mk_filter_identical_fn(r, m_cols.size(), m_cols.data());
if (!fn) {
throw default_exception(default_exception::fmt(),
"trying to perform unsupported filter_identical operation on a relation of kind %s",
@ -590,7 +590,7 @@ namespace datalog {
relation_base & reg = *ctx.reg(m_src);
TRACE("dl_verbose", reg.display(tout <<"pre-filter-interpreted-and-project:\n"););
if (!find_fn(reg, fn)) {
fn = reg.get_manager().mk_filter_interpreted_and_project_fn(reg, m_cond, m_cols.size(), m_cols.c_ptr());
fn = reg.get_manager().mk_filter_interpreted_and_project_fn(reg, m_cond, m_cols.size(), m_cols.data());
if (!fn) {
throw default_exception(default_exception::fmt(),
"trying to perform unsupported filter_interpreted_and_project operation on a relation of kind %s",
@ -766,10 +766,10 @@ namespace datalog {
relation_base & r_src = *ctx.reg(m_src);
if (!find_fn(r_src, fn)) {
if (m_projection) {
fn = r_src.get_manager().mk_project_fn(r_src, m_cols.size(), m_cols.c_ptr());
fn = r_src.get_manager().mk_project_fn(r_src, m_cols.size(), m_cols.data());
}
else {
fn = r_src.get_manager().mk_rename_fn(r_src, m_cols.size(), m_cols.c_ptr());
fn = r_src.get_manager().mk_rename_fn(r_src, m_cols.size(), m_cols.data());
}
if (!fn) {
std::stringstream sstm;
@ -962,7 +962,7 @@ namespace datalog {
relation_base & r1 = *ctx.reg(m_tgt);
const relation_base & r2 = *ctx.reg(m_neg_rel);
if (!find_fn(r1, r2, fn)) {
fn = r1.get_manager().mk_filter_by_negation_fn(r1, r2, m_cols1.size(), m_cols1.c_ptr(), m_cols2.c_ptr());
fn = r1.get_manager().mk_filter_by_negation_fn(r1, r2, m_cols1.size(), m_cols1.data(), m_cols2.data());
if (!fn) {
std::stringstream sstm;
sstm << "trying to perform unsupported filter_by_negation on relations of kinds ";

8
src/muz/rel/dl_interval_relation.cpp
View file

@ -64,7 +64,7 @@ namespace datalog {
interval_relation const& r2 = get(_r2);
interval_relation_plugin& p = r1.get_plugin();
interval_relation* result = dynamic_cast<interval_relation*>(p.mk_full(nullptr, get_result_signature()));
result->mk_join(r1, r2, m_cols1.size(), m_cols1.c_ptr(), m_cols2.c_ptr());
result->mk_join(r1, r2, m_cols1.size(), m_cols1.data(), m_cols2.data());
return result;
}
};
@ -88,7 +88,7 @@ namespace datalog {
interval_relation const& r = get(_r);
interval_relation_plugin& p = r.get_plugin();
interval_relation* result = dynamic_cast<interval_relation*>(p.mk_full(nullptr, get_result_signature()));
result->mk_project(r, m_removed_cols.size(), m_removed_cols.c_ptr());
result->mk_project(r, m_removed_cols.size(), m_removed_cols.data());
return result;
}
};
@ -108,7 +108,7 @@ namespace datalog {
interval_relation const& r = get(_r);
interval_relation_plugin& p = r.get_plugin();
interval_relation* result = dynamic_cast<interval_relation*>(p.mk_full(nullptr, get_result_signature()));
result->mk_rename(r, m_cycle.size(), m_cycle.c_ptr());
result->mk_rename(r, m_cycle.size(), m_cycle.data());
return result;
}
};
@ -402,7 +402,7 @@ namespace datalog {
}
}
bool_rewriter br(m);
br.mk_and(conjs.size(), conjs.c_ptr(), fml);
br.mk_and(conjs.size(), conjs.data(), fml);
}

18
src/muz/rel/dl_lazy_table.cpp
View file

@ -53,7 +53,7 @@ namespace datalog {
table_base* operator()(const table_base& _t1, const table_base& _t2) override {
lazy_table const& t1 = get(_t1);
lazy_table const& t2 = get(_t2);
lazy_table_ref* tr = alloc(lazy_table_join, m_cols1.size(), m_cols1.c_ptr(), m_cols2.c_ptr(), t1, t2, get_result_signature());
lazy_table_ref* tr = alloc(lazy_table_join, m_cols1.size(), m_cols1.data(), m_cols2.data(), t1, t2, get_result_signature());
return alloc(lazy_table, tr);
}
};
@ -113,7 +113,7 @@ namespace datalog {
table_base* operator()(table_base const& _t) override {
lazy_table const& t = get(_t);
return alloc(lazy_table, alloc(lazy_table_project, m_removed_cols.size(), m_removed_cols.c_ptr(), t, get_result_signature()));
return alloc(lazy_table, alloc(lazy_table_project, m_removed_cols.size(), m_removed_cols.data(), t, get_result_signature()));
}
};
@ -139,7 +139,7 @@ namespace datalog {
table_base* operator()(table_base const& _t) override {
lazy_table const& t = get(_t);
return alloc(lazy_table, alloc(lazy_table_rename, m_cycle.size(), m_cycle.c_ptr(), t, get_result_signature()));
return alloc(lazy_table, alloc(lazy_table_rename, m_cycle.size(), m_cycle.data(), t, get_result_signature()));
}
};
@ -165,7 +165,7 @@ namespace datalog {
void operator()(table_base& _t) override {
lazy_table& t = get(_t);
t.set(alloc(lazy_table_filter_identical, m_cols.size(), m_cols.c_ptr(), t));
t.set(alloc(lazy_table_filter_identical, m_cols.size(), m_cols.data(), t));
}
};
@ -326,7 +326,7 @@ namespace datalog {
table_base* t1 = m_t1->eval();
table_base* t2 = m_t2->eval();
verbose_action _t("join");
table_join_fn* join = rm().mk_join_fn(*t1, *t2, m_cols1.size(), m_cols1.c_ptr(), m_cols2.c_ptr());
table_join_fn* join = rm().mk_join_fn(*t1, *t2, m_cols1.size(), m_cols1.data(), m_cols2.data());
m_table = (*join)(*t1, *t2);
dealloc(join);
return m_table.get();
@ -349,7 +349,7 @@ namespace datalog {
}
case LAZY_TABLE_FILTER_INTERPRETED: {
lazy_table_filter_interpreted& src = dynamic_cast<lazy_table_filter_interpreted&>(*m_src);
table_transformer_fn* tr = rm().mk_filter_interpreted_and_project_fn(*src.eval(), src.condition(), m_cols.size(), m_cols.c_ptr());
table_transformer_fn* tr = rm().mk_filter_interpreted_and_project_fn(*src.eval(), src.condition(), m_cols.size(), m_cols.data());
if (tr) {
verbose_action _t("filter_interpreted_project");
m_table = (*tr)(*src.eval());
@ -376,7 +376,7 @@ namespace datalog {
}
table_base* src = m_src->eval();
verbose_action _t("project");
table_transformer_fn* project = rm().mk_project_fn(*src, m_cols.size(), m_cols.c_ptr());
table_transformer_fn* project = rm().mk_project_fn(*src, m_cols.size(), m_cols.data());
SASSERT(project);
m_table = (*project)(*src);
dealloc(project);
@ -387,7 +387,7 @@ namespace datalog {
SASSERT(!m_table);
table_base* src = m_src->eval();
verbose_action _t("rename");
table_transformer_fn* rename = rm().mk_rename_fn(*src, m_cols.size(), m_cols.c_ptr());
table_transformer_fn* rename = rm().mk_rename_fn(*src, m_cols.size(), m_cols.data());
m_table = (*rename)(*src);
dealloc(rename);
return m_table.get();
@ -399,7 +399,7 @@ namespace datalog {
m_src->release_table();
m_src = nullptr;
verbose_action _t("filter_identical");
table_mutator_fn* m = rm().mk_filter_identical_fn(*m_table, m_cols.size(), m_cols.c_ptr());
table_mutator_fn* m = rm().mk_filter_identical_fn(*m_table, m_cols.size(), m_cols.data());
SASSERT(m);
(*m)(*m_table);
dealloc(m);

14
src/muz/rel/dl_mk_explanations.cpp
View file

@ -153,7 +153,7 @@ namespace datalog {
unsigned n=get_signature().size();
SASSERT(f.size()==n);
m_data.reset();
m_data.append(n, f.c_ptr());
m_data.append(n, f.data());
}
void set_undefined() {
m_empty = false;
@ -476,7 +476,7 @@ namespace datalog {
not_handled();
subst_arg[ofs-i] = r.m_data.get(i);
}
expr_ref res = m_subst(m_new_rule, subst_arg.size(), subst_arg.c_ptr());
expr_ref res = m_subst(m_new_rule, subst_arg.size(), subst_arg.data());
r.m_data[m_col_idx] = to_app(res);
}
};
@ -682,7 +682,7 @@ namespace datalog {
e_domain.append(orig_decl->get_arity(), orig_decl->get_domain());
e_domain.push_back(m_e_sort);
func_decl * new_decl = m_context.mk_fresh_head_predicate(orig_decl->get_name(), symbol("expl"),
e_domain.size(), e_domain.c_ptr(), orig_decl);
e_domain.size(), e_domain.data(), orig_decl);
m_pinned.push_back(new_decl);
value = new_decl;
@ -698,7 +698,7 @@ namespace datalog {
func_decl * e_decl = get_e_decl(lit->get_decl());
args.append(lit->get_num_args(), lit->get_args());
args.push_back(m_manager.mk_var(e_var_idx, m_e_sort));
return m_manager.mk_app(e_decl, args.c_ptr());
return m_manager.mk_app(e_decl, args.data());
}
symbol mk_explanations::get_rule_symbol(rule * r) {
@ -753,14 +753,14 @@ namespace datalog {
}
//rule_expr contains rule function with string representation of the rule as symbol and
//for each positive uninterpreted tail it contains its argument values and its explanation term
expr * rule_expr = m_decl_util.mk_rule(rule_repr, rule_expr_args.size(), rule_expr_args.c_ptr());
expr * rule_expr = m_decl_util.mk_rule(rule_repr, rule_expr_args.size(), rule_expr_args.data());
app_ref e_record(m_manager.mk_eq(m_manager.mk_var(head_var, m_e_sort), rule_expr), m_manager);
e_tail.push_back(e_record);
neg_flags.push_back(false);
SASSERT(e_tail.size()==neg_flags.size());
return m_context.get_rule_manager().mk(e_head, e_tail.size(), e_tail.c_ptr(), neg_flags.c_ptr());
return m_context.get_rule_manager().mk(e_head, e_tail.size(), e_tail.data(), neg_flags.data());
}
void mk_explanations::transform_rules(const rule_set & src, rule_set & dst) {
@ -784,7 +784,7 @@ namespace datalog {
for (unsigned i=0; i<arity; i++) {
lit_args.push_back(m_manager.mk_var(i, orig_decl->get_domain(i)));
}
app_ref orig_lit(m_manager.mk_app(orig_decl, lit_args.c_ptr()), m_manager);
app_ref orig_lit(m_manager.mk_app(orig_decl, lit_args.data()), m_manager);
app_ref e_lit(get_e_lit(orig_lit, arity), m_manager);
app * tail[] = { e_lit.get() };
dst.add_rule(m_context.get_rule_manager().mk(orig_lit, 1, tail, nullptr));

10
src/muz/rel/dl_mk_similarity_compressor.cpp
View file

@ -360,7 +360,7 @@ namespace datalog {
symbol const& name_prefix = head_pred->get_name();
std::string name_suffix = "sc_" + to_string(const_cnt);
func_decl * aux_pred = m_context.mk_fresh_head_predicate(name_prefix, symbol(name_suffix.c_str()),
aux_domain.size(), aux_domain.c_ptr(), head_pred);
aux_domain.size(), aux_domain.data(), head_pred);
m_pinned.push_back(aux_pred);
relation_fact val_fact(m_manager, const_cnt);
@ -416,17 +416,17 @@ namespace datalog {
mod_args[inf.arg_index()] = mod_var;
}
app * upd_tail = m_manager.mk_app(mod_tail->get_decl(), mod_args.c_ptr());
app * upd_tail = m_manager.mk_app(mod_tail->get_decl(), mod_args.data());
m_pinned.push_back(upd_tail);
mod_tail = upd_tail;
}
app_ref aux_tail(m_manager.mk_app(aux_pred, aux_vars.c_ptr()), m_manager);
app_ref aux_tail(m_manager.mk_app(aux_pred, aux_vars.data()), m_manager);
new_tail.push_back(aux_tail);
new_negs.push_back(false);
rule * new_rule = m_context.get_rule_manager().mk(new_head, new_tail.size(), new_tail.c_ptr(),
new_negs.c_ptr(), r->name());
rule * new_rule = m_context.get_rule_manager().mk(new_head, new_tail.size(), new_tail.data(),
new_negs.data(), r->name());
m_result_rules.push_back(new_rule);
//TODO: allow for a rule to have multiple parent objects

8
src/muz/rel/dl_mk_simple_joins.cpp
View file

@ -381,9 +381,9 @@ namespace datalog {
func_decl * decl = m_context.mk_fresh_head_predicate(
symbol(parent_name), symbol("split"),
arity, domain.c_ptr(), parent_head);
arity, domain.data(), parent_head);
app_ref head(m.mk_app(decl, arity, args.c_ptr()), m);
app_ref head(m.mk_app(decl, arity, args.data()), m);
app * tail[] = { t1, t2 };
@ -726,8 +726,8 @@ namespace datalog {
negs.push_back(orig_r->is_neg_tail(i));
}
rule * new_rule = rm.mk(orig_r->get_head(), tail.size(), tail.c_ptr(),
negs.c_ptr(), orig_r->name());
rule * new_rule = rm.mk(orig_r->get_head(), tail.size(), tail.data(),
negs.data(), orig_r->name());
new_rule->set_accounting_parent_object(m_context, orig_r);
rm.mk_rule_rewrite_proof(*orig_r, *new_rule);

28
src/muz/rel/dl_product_relation.cpp
View file

@ -178,7 +178,7 @@ namespace datalog {
for(unsigned i=0; i<rel_cnt; i++) {
inner_rels.push_back(get_manager().mk_empty_relation(s, spec[i]));
}
return alloc(product_relation,*this, s, inner_rels.size(), inner_rels.c_ptr());
return alloc(product_relation,*this, s, inner_rels.size(), inner_rels.data());
}
relation_base * product_relation_plugin::mk_full(func_decl* p, const relation_signature & s, family_id kind) {
@ -195,7 +195,7 @@ namespace datalog {
for(unsigned i=0; i<rel_cnt; i++) {
inner_rels.push_back(get_manager().mk_full_relation(s, p, spec[i]));
}
return alloc(product_relation,*this, s, inner_rels.size(), inner_rels.c_ptr());
return alloc(product_relation,*this, s, inner_rels.size(), inner_rels.data());
}
relation_base * product_relation_plugin::mk_full(func_decl* p, const relation_signature & s) {
@ -414,8 +414,8 @@ namespace datalog {
const unsigned * cols1, const unsigned * cols2)
: convenient_relation_join_fn(r1.get_signature(), r2.get_signature(), col_cnt, cols1, cols2),
m_plugin(p) {
init(r1.get_signature(), r1.size(), r1.m_relations.c_ptr(),
r2.get_signature(), r2.size(), r2.m_relations.c_ptr(), col_cnt, cols1, cols2);
init(r1.get_signature(), r1.size(), r1.m_relations.data(),
r2.get_signature(), r2.size(), r2.m_relations.data(), col_cnt, cols1, cols2);
}
join_fn(product_relation_plugin& p, relation_base const& r1, product_relation const& r2, unsigned col_cnt,
@ -423,7 +423,7 @@ namespace datalog {
: convenient_relation_join_fn(r1.get_signature(), r2.get_signature(), col_cnt, cols1, cols2),
m_plugin(p) {
relation_base const* rels1[1] = { &r1 };
init(r1.get_signature(), 1, rels1, r2.get_signature(), r2.size(), r2.m_relations.c_ptr(), col_cnt, cols1, cols2);
init(r1.get_signature(), 1, rels1, r2.get_signature(), r2.size(), r2.m_relations.data(), col_cnt, cols1, cols2);
}
join_fn(product_relation_plugin& p, product_relation const& r1, relation_base const& r2, unsigned col_cnt,
@ -431,7 +431,7 @@ namespace datalog {
: convenient_relation_join_fn(r1.get_signature(), r2.get_signature(), col_cnt, cols1, cols2),
m_plugin(p) {
relation_base const* rels2[1] = { &r2 };
init(r1.get_signature(), r1.size(), r1.m_relations.c_ptr(), r2.get_signature(), 1, rels2, col_cnt, cols1, cols2);
init(r1.get_signature(), r1.size(), r1.m_relations.data(), r2.get_signature(), 1, rels2, col_cnt, cols1, cols2);
}
join_fn(product_relation_plugin& p, relation_base const& r1, relation_base const& r2, unsigned col_cnt,
@ -459,7 +459,7 @@ namespace datalog {
relation_base const& r2 = (m_kind2[i] == T_FULL)?(*m_full[m_offset2[i]]):access(m_offset2[i], _r2);
relations.push_back((*m_joins[i])(r1, r2));
}
result = alloc(product_relation, m_plugin, get_result_signature(), sz, relations.c_ptr());
result = alloc(product_relation, m_plugin, get_result_signature(), sz, relations.data());
TRACE("dl",result->display(tout););
return result;
}
@ -501,7 +501,7 @@ namespace datalog {
for (unsigned i = 0; i < r.size(); ++i) {
relations.push_back((*m_transforms[i])(r[i]));
}
relation_base* result = alloc(product_relation, p, m_sig, relations.size(), relations.c_ptr());
relation_base* result = alloc(product_relation, p, m_sig, relations.size(), relations.data());
TRACE("dl", _r.display(tout); result->display(tout););
return result;
}
@ -517,7 +517,7 @@ namespace datalog {
}
relation_signature s;
relation_signature::from_project(r.get_signature(), col_cnt, removed_cols, s);
return alloc(transform_fn, s, projs.size(), projs.c_ptr());
return alloc(transform_fn, s, projs.size(), projs.data());
}
return nullptr;
}
@ -532,7 +532,7 @@ namespace datalog {
}
relation_signature s;
relation_signature::from_rename(r.get_signature(), cycle_len, permutation_cycle, s);
return alloc(transform_fn, s, trans.size(), trans.c_ptr());
return alloc(transform_fn, s, trans.size(), trans.data());
}
return nullptr;
}
@ -864,7 +864,7 @@ namespace datalog {
if (m) found = true;
}
if (found) {
return alloc(mutator_fn, mutators.size(), mutators.c_ptr());
return alloc(mutator_fn, mutators.size(), mutators.data());
}
}
return nullptr;
@ -882,7 +882,7 @@ namespace datalog {
if (m) found = true;
}
if (found) {
return alloc(mutator_fn, mutators.size(), mutators.c_ptr());
return alloc(mutator_fn, mutators.size(), mutators.data());
}
}
return nullptr;
@ -1086,7 +1086,7 @@ namespace datalog {
relations.push_back((*this)[i].clone());
}
product_relation_plugin& p = get_plugin();
return alloc(product_relation, p, get_signature(), relations.size(), relations.c_ptr());
return alloc(product_relation, p, get_signature(), relations.size(), relations.data());
}
product_relation * product_relation::complement(func_decl*) const {
@ -1119,7 +1119,7 @@ namespace datalog {
m_relations[i]->to_formula(tmp);
conjs.push_back(tmp);
}
bool_rewriter(m).mk_and(conjs.size(), conjs.c_ptr(), fml);
bool_rewriter(m).mk_and(conjs.size(), conjs.data(), fml);
}
void product_relation::display(std::ostream & out) const {

4
src/muz/rel/dl_product_relation.h
View file

@ -43,8 +43,8 @@ namespace datalog {
class filter_identical_fn;
class filter_interpreted_fn;
struct fid_hash {
typedef family_id data;
unsigned operator()(data x) const { return static_cast<unsigned>(x); }
typedef family_id data_t;
unsigned operator()(data_t x) const { return static_cast<unsigned>(x); }
};
rel_spec_store<rel_spec, svector_hash<fid_hash> > m_spec_store;

18
src/muz/rel/dl_relation_manager.cpp
View file

@ -613,7 +613,7 @@ namespace datalog {
(*m_filter)(*t1);
if( !m_project) {
relation_manager & rmgr = t1->get_plugin().get_manager();
m_project = rmgr.mk_project_fn(*t1, m_removed_cols.size(), m_removed_cols.c_ptr());
m_project = rmgr.mk_project_fn(*t1, m_removed_cols.size(), m_removed_cols.data());
if (!m_project) {
throw default_exception("projection does not exist");
}
@ -685,7 +685,7 @@ namespace datalog {
scoped_rel<relation_base> aux = (*m_join)(t1, t2);
if(!m_project) {
relation_manager & rmgr = aux->get_plugin().get_manager();
m_project = rmgr.mk_project_fn(*aux, m_removed_cols.size(), m_removed_cols.c_ptr());
m_project = rmgr.mk_project_fn(*aux, m_removed_cols.size(), m_removed_cols.data());
if(!m_project) {
throw default_exception("projection does not exist");
}
@ -842,7 +842,7 @@ namespace datalog {
unsigned_vector join_removed_cols;
add_sequence(tgt.get_signature().size(), src.get_signature().size(), join_removed_cols);
scoped_rel<relation_join_fn> join_fun = mk_join_project_fn(tgt, src, joined_col_cnt, tgt_cols, src_cols,
join_removed_cols.size(), join_removed_cols.c_ptr(), false);
join_removed_cols.size(), join_removed_cols.data(), false);
if(!join_fun) {
return nullptr;
}
@ -1100,7 +1100,7 @@ namespace datalog {
if(get_result_signature().functional_columns()!=0) {
//to preserve functional columns we need to do the project_with_reduction
unreachable_reducer * reducer = alloc(unreachable_reducer);
m_project = rmgr.mk_project_with_reduce_fn(*aux, m_removed_cols.size(), m_removed_cols.c_ptr(), reducer);
m_project = rmgr.mk_project_with_reduce_fn(*aux, m_removed_cols.size(), m_removed_cols.data(), reducer);
}
else {
m_project = rmgr.mk_project_fn(*aux, m_removed_cols);
@ -1250,11 +1250,11 @@ namespace datalog {
for (table_base::row_interface& a : r) {
a.get_fact(m_row);
if (should_remove(m_row)) {
m_to_remove.append(m_row.size(), m_row.c_ptr());
m_to_remove.append(m_row.size(), m_row.data());
++sz;
}
}
r.remove_facts(sz, m_to_remove.c_ptr());
r.remove_facts(sz, m_to_remove.data());
}
};
@ -1444,7 +1444,7 @@ namespace datalog {
(*m_filter)(*t2);
if (!m_project) {
relation_manager & rmgr = t2->get_plugin().get_manager();
m_project = rmgr.mk_project_fn(*t2, m_removed_cols.size(), m_removed_cols.c_ptr());
m_project = rmgr.mk_project_fn(*t2, m_removed_cols.size(), m_removed_cols.data());
if (!m_project) {
throw default_exception("projection does not exist");
}
@ -1599,7 +1599,7 @@ namespace datalog {
for (table_base::row_interface& a : t) {
a.get_fact(m_curr_fact);
if((*m_mapper)(m_curr_fact.c_ptr()+m_first_functional)) {
if((*m_mapper)(m_curr_fact.data()+m_first_functional)) {
m_aux_table->add_fact(m_curr_fact);
}
}
@ -1683,7 +1683,7 @@ namespace datalog {
for (; it != end; ++it) {
mk_project(it);
if (!res->suggest_fact(m_former_row)) {
(*m_reducer)(m_former_row.c_ptr()+m_res_first_functional, m_row.c_ptr()+m_res_first_functional);
(*m_reducer)(m_former_row.data()+m_res_first_functional, m_row.data()+m_res_first_functional);
res->ensure_fact(m_former_row);
}
}

36
src/muz/rel/dl_relation_manager.h
View file

@ -246,7 +246,7 @@ namespace datalog {
relation_join_fn * mk_join_fn(const relation_base & t1, const relation_base & t2,
const unsigned_vector & cols1, const unsigned_vector & cols2, bool allow_product_relation=true) {
SASSERT(cols1.size()==cols2.size());
return mk_join_fn(t1, t2, cols1.size(), cols1.c_ptr(), cols2.c_ptr(), allow_product_relation);
return mk_join_fn(t1, t2, cols1.size(), cols1.data(), cols2.data(), allow_product_relation);
}
/**
@ -259,7 +259,7 @@ namespace datalog {
const unsigned * removed_cols);
relation_transformer_fn * mk_project_fn(const relation_base & t, const unsigned_vector & removed_cols) {
return mk_project_fn(t, removed_cols.size(), removed_cols.c_ptr());
return mk_project_fn(t, removed_cols.size(), removed_cols.data());
}
/**
@ -272,14 +272,14 @@ namespace datalog {
relation_join_fn * mk_join_project_fn(const relation_base & t1, const relation_base & t2,
const unsigned_vector & cols1, const unsigned_vector & cols2,
const unsigned_vector & removed_cols, bool allow_product_relation_join=true) {
return mk_join_project_fn(t1, t2, cols1.size(), cols1.c_ptr(), cols2.c_ptr(), removed_cols.size(),
removed_cols.c_ptr(), allow_product_relation_join);
return mk_join_project_fn(t1, t2, cols1.size(), cols1.data(), cols2.data(), removed_cols.size(),
removed_cols.data(), allow_product_relation_join);
}
relation_transformer_fn * mk_rename_fn(const relation_base & t, unsigned permutation_cycle_len,
const unsigned * permutation_cycle);
relation_transformer_fn * mk_rename_fn(const relation_base & t, const unsigned_vector & permutation_cycle) {
return mk_rename_fn(t, permutation_cycle.size(), permutation_cycle.c_ptr());
return mk_rename_fn(t, permutation_cycle.size(), permutation_cycle.data());
}
/**
@ -291,7 +291,7 @@ namespace datalog {
relation_transformer_fn * mk_permutation_rename_fn(const relation_base & t,
const unsigned_vector & permutation) {
SASSERT(t.get_signature().size()==permutation.size());
return mk_permutation_rename_fn(t, permutation.c_ptr());
return mk_permutation_rename_fn(t, permutation.data());
}
@ -344,7 +344,7 @@ namespace datalog {
relation_mutator_fn * mk_filter_identical_fn(const relation_base & t, unsigned col_cnt,
const unsigned * identical_cols);
relation_mutator_fn * mk_filter_identical_fn(const relation_base & t, const unsigned_vector & identical_cols) {
return mk_filter_identical_fn(t, identical_cols.size(), identical_cols.c_ptr());
return mk_filter_identical_fn(t, identical_cols.size(), identical_cols.data());
}
relation_mutator_fn * mk_filter_equal_fn(const relation_base & t, const relation_element & value,
@ -378,7 +378,7 @@ namespace datalog {
relation_intersection_filter_fn * mk_filter_by_intersection_fn(const relation_base & tgt,
const relation_base & src, const unsigned_vector & tgt_cols, const unsigned_vector & src_cols) {
SASSERT(tgt_cols.size()==src_cols.size());
return mk_filter_by_intersection_fn(tgt, src, tgt_cols.size(), tgt_cols.c_ptr(), src_cols.c_ptr());
return mk_filter_by_intersection_fn(tgt, src, tgt_cols.size(), tgt_cols.data(), src_cols.data());
}
relation_intersection_filter_fn * mk_filter_by_intersection_fn(const relation_base & tgt,
const relation_base & src);
@ -396,7 +396,7 @@ namespace datalog {
const relation_base & negated_obj, const unsigned_vector & t_cols,
const unsigned_vector & negated_cols) {
SASSERT(t_cols.size()==negated_cols.size());
return mk_filter_by_negation_fn(t, negated_obj, t_cols.size(), t_cols.c_ptr(), negated_cols.c_ptr());
return mk_filter_by_negation_fn(t, negated_obj, t_cols.size(), t_cols.data(), negated_cols.data());
}
@ -413,7 +413,7 @@ namespace datalog {
table_join_fn * mk_join_fn(const table_base & t1, const table_base & t2,
const unsigned_vector & cols1, const unsigned_vector & cols2) {
SASSERT(cols1.size()==cols2.size());
return mk_join_fn(t1, t2, cols1.size(), cols1.c_ptr(), cols2.c_ptr());
return mk_join_fn(t1, t2, cols1.size(), cols1.data(), cols2.data());
}
/**
@ -429,7 +429,7 @@ namespace datalog {
const unsigned * removed_cols);
table_transformer_fn * mk_project_fn(const table_base & t, const unsigned_vector & removed_cols) {
return mk_project_fn(t, removed_cols.size(), removed_cols.c_ptr());
return mk_project_fn(t, removed_cols.size(), removed_cols.data());
}
/**
@ -453,14 +453,14 @@ namespace datalog {
table_join_fn * mk_join_project_fn(const table_base & t1, const table_base & t2,
const unsigned_vector & cols1, const unsigned_vector & cols2,
const unsigned_vector & removed_cols) {
return mk_join_project_fn(t1, t2, cols1.size(), cols1.c_ptr(), cols2.c_ptr(), removed_cols.size(),
removed_cols.c_ptr());
return mk_join_project_fn(t1, t2, cols1.size(), cols1.data(), cols2.data(), removed_cols.size(),
removed_cols.data());
}
table_transformer_fn * mk_rename_fn(const table_base & t, unsigned permutation_cycle_len,
const unsigned * permutation_cycle);
table_transformer_fn * mk_rename_fn(const table_base & t, const unsigned_vector & permutation_cycle) {
return mk_rename_fn(t, permutation_cycle.size(), permutation_cycle.c_ptr());
return mk_rename_fn(t, permutation_cycle.size(), permutation_cycle.data());
}
/**
@ -470,7 +470,7 @@ namespace datalog {
table_transformer_fn * mk_permutation_rename_fn(const table_base & t, const unsigned * permutation);
table_transformer_fn * mk_permutation_rename_fn(const table_base & t, const unsigned_vector & permutation) {
SASSERT(t.get_signature().size()==permutation.size());
return mk_permutation_rename_fn(t, permutation.c_ptr());
return mk_permutation_rename_fn(t, permutation.data());
}
@ -523,7 +523,7 @@ namespace datalog {
table_mutator_fn * mk_filter_identical_fn(const table_base & t, unsigned col_cnt,
const unsigned * identical_cols);
table_mutator_fn * mk_filter_identical_fn(const table_base & t, const unsigned_vector & identical_cols) {
return mk_filter_identical_fn(t, identical_cols.size(), identical_cols.c_ptr());
return mk_filter_identical_fn(t, identical_cols.size(), identical_cols.data());
}
table_mutator_fn * mk_filter_equal_fn(const table_base & t, const table_element & value,
@ -551,7 +551,7 @@ namespace datalog {
table_intersection_filter_fn * mk_filter_by_intersection_fn(const table_base & t,
const table_base & src, const unsigned_vector & t_cols, const unsigned_vector & src_cols) {
SASSERT(t_cols.size()==src_cols.size());
return mk_filter_by_intersection_fn(t, src, t_cols.size(), t_cols.c_ptr(), src_cols.c_ptr());
return mk_filter_by_intersection_fn(t, src, t_cols.size(), t_cols.data(), src_cols.data());
}
/**
@ -565,7 +565,7 @@ namespace datalog {
table_intersection_filter_fn * mk_filter_by_negation_fn(const table_base & t, const table_base & negated_obj,
const unsigned_vector & t_cols, const unsigned_vector & negated_cols) {
SASSERT(t_cols.size()==negated_cols.size());
return mk_filter_by_negation_fn(t, negated_obj, t_cols.size(), t_cols.c_ptr(), negated_cols.c_ptr());
return mk_filter_by_negation_fn(t, negated_obj, t_cols.size(), t_cols.data(), negated_cols.data());
}
/**

18
src/muz/rel/dl_sieve_relation.cpp
View file

@ -63,14 +63,14 @@ namespace datalog {
sieve_relation * sieve_relation::clone() const {
relation_base * new_inner = get_inner().clone();
return get_plugin().mk_from_inner(get_signature(), m_inner_cols.c_ptr(), new_inner);
return get_plugin().mk_from_inner(get_signature(), m_inner_cols.data(), new_inner);
}
relation_base * sieve_relation::complement(func_decl* p) const {
//this is not precisely a complement, because we still treat the ignored columns as
//full, but it should give reasonable results inside the product relation
relation_base * new_inner = get_inner().complement(p);
return get_plugin().mk_from_inner(get_signature(), m_inner_cols.c_ptr(), new_inner);
return get_plugin().mk_from_inner(get_signature(), m_inner_cols.data(), new_inner);
}
void sieve_relation::to_formula(expr_ref& fml) const {
@ -85,7 +85,7 @@ namespace datalog {
s.push_back(m.mk_var(idx, sig[i]));
}
get_inner().to_formula(tmp);
fml = get_plugin().get_context().get_var_subst()(tmp, sz, s.c_ptr());
fml = get_plugin().get_context().get_var_subst()(tmp, sz, s.data());
}
@ -220,7 +220,7 @@ namespace datalog {
relation_signature inner_sig;
collect_inner_signature(s, spec.m_inner_cols, inner_sig);
relation_base * inner = get_manager().mk_empty_relation(inner_sig, spec.m_inner_kind);
return mk_from_inner(s, spec.m_inner_cols.c_ptr(), inner);
return mk_from_inner(s, spec.m_inner_cols.data(), inner);
}
@ -305,7 +305,7 @@ namespace datalog {
relation_base * inner_res = (*m_inner_join_fun)(inner1, inner2);
return m_plugin.mk_from_inner(get_result_signature(), m_result_inner_cols.c_ptr(), inner_res);
return m_plugin.mk_from_inner(get_result_signature(), m_result_inner_cols.data(), inner_res);
}
};
@ -364,7 +364,7 @@ namespace datalog {
relation_base * inner_res = (*m_inner_fun)(r.get_inner());
return plugin.mk_from_inner(get_result_signature(), m_result_inner_cols.c_ptr(), inner_res);
return plugin.mk_from_inner(get_result_signature(), m_result_inner_cols.data(), inner_res);
}
};
@ -400,7 +400,7 @@ namespace datalog {
if(!inner_fun) {
return nullptr;
}
return alloc(transformer_fn, inner_fun, result_sig, result_inner_cols.c_ptr());
return alloc(transformer_fn, inner_fun, result_sig, result_inner_cols.data());
}
relation_transformer_fn * sieve_relation_plugin::mk_rename_fn(const relation_base & r0,
@ -430,7 +430,7 @@ namespace datalog {
if(!inner_fun) {
return nullptr;
}
return alloc(transformer_fn, inner_fun, result_sig, result_inner_cols.c_ptr());
return alloc(transformer_fn, inner_fun, result_sig, result_inner_cols.data());
}
@ -584,7 +584,7 @@ namespace datalog {
}
subst_vect[subst_ofs-i] = m.mk_var(r.m_sig2inner[i], sig[i]);
}
expr_ref inner_cond = get_context().get_var_subst()(condition, subst_vect.size(), subst_vect.c_ptr());
expr_ref inner_cond = get_context().get_var_subst()(condition, subst_vect.size(), subst_vect.data());
relation_mutator_fn * inner_fun = get_manager().mk_filter_interpreted_fn(r.get_inner(), to_app(inner_cond));
if(!inner_fun) {

4
src/muz/rel/dl_sieve_relation.h
View file

@ -91,7 +91,7 @@ namespace datalog {
family_id get_relation_kind(const relation_signature & sig, const bool_vector & inner_columns,
family_id inner_kind) {
SASSERT(sig.size()==inner_columns.size());
return get_relation_kind(sig, inner_columns.c_ptr(), inner_kind);
return get_relation_kind(sig, inner_columns.data(), inner_kind);
}
bool can_handle_signature(const relation_signature & s) override;
@ -110,7 +110,7 @@ namespace datalog {
sieve_relation * mk_from_inner(const relation_signature & s, const bool_vector & inner_columns,
relation_base * inner_rel) {
SASSERT(inner_columns.size()==s.size());
return mk_from_inner(s, inner_columns.c_ptr(), inner_rel);
return mk_from_inner(s, inner_columns.data(), inner_rel);
}
protected:

28
src/muz/rel/dl_sparse_table.cpp
View file

@ -293,7 +293,7 @@ namespace datalog {
void key_to_reserve(const key_value & key) const {
m_keys.ensure_reserve();
m_keys.write_into_reserve((char *)(key.c_ptr()));
m_keys.write_into_reserve((char *)(key.data()));
}
offset_vector & get_matching_offset_vector(const key_value & key) {
@ -416,7 +416,7 @@ namespace datalog {
//We will change the content of the reserve; which does not change the 'high-level'
//content of the table.
sparse_table & t = const_cast<sparse_table&>(m_table);
t.write_into_reserve(m_key_fact.c_ptr());
t.write_into_reserve(m_key_fact.data());
store_offset res;
if (!t.m_data.find_reserve_content(res)) {
@ -514,7 +514,7 @@ namespace datalog {
}
void sparse_table::add_fact(const table_fact & f) {
write_into_reserve(f.c_ptr());
write_into_reserve(f.data());
add_reserve_content();
}
@ -525,7 +525,7 @@ namespace datalog {
bool sparse_table::contains_fact(const table_fact & f) const {
verbose_action _va("contains_fact", 2);
sparse_table & t = const_cast<sparse_table &>(*this);
t.write_into_reserve(f.c_ptr());
t.write_into_reserve(f.data());
unsigned func_col_cnt = get_signature().functional_columns();
if (func_col_cnt == 0) {
return t.m_data.reserve_content_already_present();
@ -554,7 +554,7 @@ namespace datalog {
}
else {
sparse_table & t = const_cast<sparse_table &>(*this);
t.write_into_reserve(f.c_ptr());
t.write_into_reserve(f.data());
store_offset ofs;
if (!t.m_data.find_reserve_content(ofs)) {
return false;
@ -578,7 +578,7 @@ namespace datalog {
add_fact(f);
}
else {
write_into_reserve(f.c_ptr());
write_into_reserve(f.data());
store_offset ofs;
if (!m_data.find_reserve_content(ofs)) {
add_fact(f);
@ -839,12 +839,12 @@ namespace datalog {
//one to be at the outer iteration (then the small one will hopefully fit into
//the cache)
if ( (t1.row_count() > t2.row_count()) == (!m_cols1.empty()) ) {
sparse_table::self_agnostic_join_project(t2, t1, m_cols1.size(), m_cols2.c_ptr(),
m_cols1.c_ptr(), m_removed_cols.c_ptr(), true, *res);
sparse_table::self_agnostic_join_project(t2, t1, m_cols1.size(), m_cols2.data(),
m_cols1.data(), m_removed_cols.data(), true, *res);
}
else {
sparse_table::self_agnostic_join_project(t1, t2, m_cols1.size(), m_cols1.c_ptr(),
m_cols2.c_ptr(), m_removed_cols.c_ptr(), false, *res);
sparse_table::self_agnostic_join_project(t1, t2, m_cols1.size(), m_cols1.data(),
m_cols2.data(), m_removed_cols.data(), false, *res);
}
TRACE("dl_table_relation", tb1.display(tout); tb2.display(tout); res->display(tout); );
return res;
@ -1156,8 +1156,8 @@ namespace datalog {
unsigned joined_col_cnt = m_cols1.size();
unsigned t1_entry_size = t1.m_data.entry_size();
const unsigned * cols1 = tgt_is_first ? m_cols1.c_ptr() : m_cols2.c_ptr();
const unsigned * cols2 = tgt_is_first ? m_cols2.c_ptr() : m_cols1.c_ptr();
const unsigned * cols1 = tgt_is_first ? m_cols1.data() : m_cols2.data();
const unsigned * cols2 = tgt_is_first ? m_cols2.data() : m_cols1.data();
key_value t1_key;
t1_key.resize(joined_col_cnt);
@ -1329,8 +1329,8 @@ namespace datalog {
SASSERT(m_s2_cols.size() == m_t2_cols.size() + m_src1_cols.size());
s1_key.resize(m_s1_cols.size());
s2_key.resize(m_s2_cols.size());
key_indexer & s1_indexer = s1.get_key_indexer(m_s1_cols.size(), m_s1_cols.c_ptr());
key_indexer & s2_indexer = s2.get_key_indexer(m_s2_cols.size(), m_s2_cols.c_ptr());
key_indexer & s1_indexer = s1.get_key_indexer(m_s1_cols.size(), m_s1_cols.data());
key_indexer & s2_indexer = s2.get_key_indexer(m_s2_cols.size(), m_s2_cols.data());
store_offset t_after_last = t.m_data.after_last_offset();
key_indexer::query_result s1_offsets, s2_offsets;

4
src/muz/rel/dl_sparse_table.h
View file

@ -122,7 +122,7 @@ namespace datalog {
offset_hash_proc(storage & s, unsigned unique_entry_sz)
: m_storage(s), m_unique_entry_size(unique_entry_sz) {}
unsigned operator()(store_offset ofs) const {
return string_hash(m_storage.c_ptr()+ofs, m_unique_entry_size, 0);
return string_hash(m_storage.data()+ofs, m_unique_entry_size, 0);
}
};
@ -133,7 +133,7 @@ namespace datalog {
offset_eq_proc(storage & s, unsigned unique_entry_sz)
: m_storage(s), m_unique_entry_size(unique_entry_sz) {}
bool operator()(store_offset o1, store_offset o2) const {
const char * base = m_storage.c_ptr();
const char * base = m_storage.data();
return memcmp(base+o1, base+o2, m_unique_entry_size)==0;
}
};

4
src/muz/rel/dl_table.cpp
View file

@ -274,7 +274,7 @@ namespace datalog {
}
void bitvector_table::add_fact(const table_fact & f) {
m_bv.set(fact2offset(f.c_ptr()));
m_bv.set(fact2offset(f.data()));
}
void bitvector_table::remove_fact(const table_element* fact) {
@ -282,7 +282,7 @@ namespace datalog {
}
bool bitvector_table::contains_fact(const table_fact & f) const {
return m_bv.get(fact2offset(f.c_ptr()));
return m_bv.get(fact2offset(f.data()));
}
table_base::iterator bitvector_table::begin() const {

2
src/muz/rel/doc.cpp
View file

@ -702,7 +702,7 @@ expr_ref doc_manager::to_formula(ast_manager& m, doc const& src) {
for (unsigned i = 0; i < src.neg().size(); ++i) {
conj.push_back(m.mk_not(tbvm().to_formula(m, src.neg()[i])));
}
result = mk_and(m, conj.size(), conj.c_ptr());
result = mk_and(m, conj.size(), conj.data());
return result;
}

10
src/muz/rel/karr_relation.cpp
View file

@ -103,7 +103,7 @@ namespace datalog {
for (unsigned i = 0; i < M.size(); ++i) {
to_formula(M.A[i], M.b[i], M.eq[i], conj);
}
bool_rewriter(m).mk_and(conj.size(), conj.c_ptr(), fml);
bool_rewriter(m).mk_and(conj.size(), conj.data(), fml);
}
}
@ -480,7 +480,7 @@ namespace datalog {
if (!b.is_zero()) {
sum.push_back(a.mk_numeral(b, true));
}
lhs = a.mk_add(sum.size(), sum.c_ptr());
lhs = a.mk_add(sum.size(), sum.data());
if (is_eq) {
conj.push_back(m.mk_eq(lhs, zero));
}
@ -519,7 +519,7 @@ namespace datalog {
karr_relation const& r2 = get(_r2);
karr_relation_plugin& p = r1.get_plugin();
karr_relation* result = dynamic_cast<karr_relation*>(p.mk_full(nullptr, get_result_signature()));
result->mk_join(r1, r2, m_cols1.size(), m_cols1.c_ptr(), m_cols2.c_ptr());
result->mk_join(r1, r2, m_cols1.size(), m_cols1.data(), m_cols2.data());
return result;
}
};
@ -544,7 +544,7 @@ namespace datalog {
karr_relation const& r = get(_r);
karr_relation_plugin& p = r.get_plugin();
karr_relation* result = dynamic_cast<karr_relation*>(p.mk_full(nullptr, get_result_signature()));
result->mk_project(r, m_removed_cols.size(), m_removed_cols.c_ptr());
result->mk_project(r, m_removed_cols.size(), m_removed_cols.data());
return result;
}
};
@ -563,7 +563,7 @@ namespace datalog {
karr_relation const& r = get(_r);
karr_relation_plugin& p = r.get_plugin();
karr_relation* result = dynamic_cast<karr_relation*>(p.mk_full(nullptr, get_result_signature()));
result->mk_rename(r, m_cycle.size(), m_cycle.c_ptr());
result->mk_rename(r, m_cycle.size(), m_cycle.data());
return result;
}
};

2
src/muz/rel/rel_context.cpp
View file

@ -261,7 +261,7 @@ namespace datalog {
}
SASSERT(!m_last_result_relation);
if (some_non_empty) {
m_answer = mk_and(m, ans.size(), ans.c_ptr());
m_answer = mk_and(m, ans.size(), ans.data());
if (is_approx) {
TRACE("dl", tout << "approx\n";);
res = l_undef;

2
src/muz/rel/tbv.cpp
View file

@ -317,7 +317,7 @@ expr_ref tbv_manager::to_formula(ast_manager& m, tbv const& src) {
break;
}
}
result = mk_and(m, conj.size(), conj.c_ptr());
result = mk_and(m, conj.size(), conj.data());
return result;
}

16
src/muz/rel/udoc_relation.cpp
View file

@ -109,7 +109,7 @@ namespace datalog {
for (unsigned i = 0; i < m_elems.size(); ++i) {
disj.push_back(to_formula(m_elems[i]));
}
fml = mk_or(m, disj.size(), disj.c_ptr());
fml = mk_or(m, disj.size(), disj.data());
}
expr_ref udoc_relation::to_formula(doc const& d) const {
ast_manager& m = get_plugin().get_ast_manager();
@ -119,7 +119,7 @@ namespace datalog {
for (unsigned i = 0; i < d.neg().size(); ++i) {
conjs.push_back(m.mk_not(to_formula(d.neg()[i])));
}
result = mk_and(m, conjs.size(), conjs.c_ptr());
result = mk_and(m, conjs.size(), conjs.data());
return result;
}
expr_ref udoc_relation::to_formula(tbv const& t) const {
@ -168,7 +168,7 @@ namespace datalog {
}
}
}
result = mk_and(m, conjs.size(), conjs.c_ptr());
result = mk_and(m, conjs.size(), conjs.data());
return result;
}
@ -472,7 +472,7 @@ namespace datalog {
doc_manager& dm = r.get_dm();
SASSERT(&result->get_dm() == &dm);
for (unsigned i = 0; i < src.size(); ++i) {
dst.push_back(dm.allocate(src[i], m_permutation.c_ptr()));
dst.push_back(dm.allocate(src[i], m_permutation.data()));
}
TRACE("doc", result->display(tout << "result:\n"););
SASSERT(dst.well_formed(dm));
@ -657,8 +657,8 @@ namespace datalog {
rests.push_back(g);
}
}
guard = mk_and(m, guards.size(), guards.c_ptr());
rest = mk_and(m, rests.size(), rests.c_ptr());
guard = mk_and(m, guards.size(), guards.data());
rest = mk_and(m, rests.size(), rests.data());
}
void udoc_relation::extract_equalities(expr* g, expr_ref& rest, subset_ints& equalities,
unsigned_vector& roots) const {
@ -676,7 +676,7 @@ namespace datalog {
conds.pop_back();
}
}
rest = mk_and(m, conds.size(), conds.c_ptr());
rest = mk_and(m, conds.size(), conds.data());
}
void udoc_relation::extract_equalities(
@ -1105,7 +1105,7 @@ namespace datalog {
m_neg_cols(joined_col_cnt, neg_cols),
m_mk_remove_cols(t, neg, m_remove_cols),
m_join_project(t, neg, joined_col_cnt, t_cols, neg_cols,
m_remove_cols.size(), m_remove_cols.c_ptr()),
m_remove_cols.size(), m_remove_cols.data()),
m_is_subtract(false)//,
/*m_is_aliased(true) */{
SASSERT(joined_col_cnt > 0 || neg.get_signature().size() == 0);

2
src/muz/spacer/spacer_antiunify.cpp
View file

@ -151,7 +151,7 @@ void anti_unifier::operator()(expr *e1, expr *e2, expr_ref &res,
if (m_todo.size() > todo_sz) {continue;}
expr_ref u(m);
u = m.mk_app(n1->get_decl(), kids.size(), kids.c_ptr());
u = m.mk_app(n1->get_decl(), kids.size(), kids.data());
m_pinned.push_back(u);
m_cache.insert(n1, n2, u);
}

40
src/muz/spacer/spacer_context.cpp
View file

@ -224,7 +224,7 @@ void derivation::exist_skolemize(expr* fml, app_ref_vector& vars, expr_ref& res)
return;
}
std::stable_sort(vars.c_ptr(), vars.c_ptr() + vars.size(), sk_lt_proc());
std::stable_sort(vars.data(), vars.data() + vars.size(), sk_lt_proc());
unsigned j = 1;
for (unsigned i = 1; i < vars.size(); ++i)
if (vars.get(i) != vars.get(j - 1))
@ -396,7 +396,7 @@ pob *derivation::create_next_child ()
m_trans = mk_and (summaries);
// variables to eliminate
vars.append (rf->aux_vars ().size (), rf->aux_vars ().c_ptr ());
vars.append (rf->aux_vars ().size (), rf->aux_vars ().data ());
for (unsigned i = 0, sz = pt.head ()->get_arity (); i < sz; ++i) {
vars.push_back(m.mk_const(pm.o2n(pt.sig(i), 0)));
}
@ -537,7 +537,7 @@ void lemma::mk_expr_core() {
zks.append(m_zks);
zks.reverse();
m_body = expr_abstract(m, 0,
zks.size(), (expr* const*)zks.c_ptr(), m_body);
zks.size(), (expr* const*)zks.data(), m_body);
ptr_buffer<sort> sorts;
svector<symbol> names;
for (app* z : zks) {
@ -545,8 +545,8 @@ void lemma::mk_expr_core() {
names.push_back(z->get_decl()->get_name());
}
m_body = m.mk_quantifier(forall_k, zks.size(),
sorts.c_ptr(),
names.c_ptr(),
sorts.data(),
names.data(),
m_body, 15, symbol(m_body->get_id()));
}
SASSERT(m_body);
@ -568,7 +568,7 @@ void lemma::mk_cube_core() {
m_cube.push_back(m.mk_true());
}
else {
std::sort(m_cube.c_ptr(), m_cube.c_ptr() + m_cube.size(), ast_lt_proc());
std::sort(m_cube.data(), m_cube.data() + m_cube.size(), ast_lt_proc());
}
}
else {
@ -669,7 +669,7 @@ void lemma::mk_insts(expr_ref_vector &out, expr* e)
unsigned num_decls = to_quantifier(lem)->get_num_decls();
expr_ref inst(m);
for (unsigned off = 0, sz = m_bindings.size(); off < sz; off += num_decls) {
instantiate((expr * const *) m_bindings.c_ptr() + off, inst, e);
instantiate((expr * const *) m_bindings.data() + off, inst, e);
out.push_back(inst);
inst.reset();
}
@ -1100,7 +1100,7 @@ expr_ref pred_transformer::get_reachable()
const ptr_vector<app> &aux = f->aux_vars();
if (!aux.empty()) {
// -- existentially quantify auxiliary variables
r = mk_exists (m, aux.size(), aux.c_ptr(), r);
r = mk_exists (m, aux.size(), aux.data(), r);
// XXX not sure how this interacts with variable renaming later on.
// XXX For now, simply dissallow existentially quantified auxiliaries
NOT_IMPLEMENTED_YET();
@ -1503,7 +1503,7 @@ bool pred_transformer::is_invariant(unsigned level, lemma* lem,
if (ctx.use_bg_invs()) get_pred_bg_invs(conj);
lbool r = m_solver->check_assumptions (cand, aux, m_transition_clause,
conj.size(), conj.c_ptr(), 1);
conj.size(), conj.data(), 1);
if (r == l_false) {
solver_level = m_solver->uses_level ();
lem->reset_ctp();
@ -1538,7 +1538,7 @@ bool pred_transformer::check_inductive(unsigned level, expr_ref_vector& state,
conj.push_back (m_extend_lit);
lbool res = m_solver->check_assumptions (state, aux,
m_transition_clause,
conj.size (), conj.c_ptr (), 1);
conj.size (), conj.data (), 1);
if (res == l_false) {
state.reset();
state.append(core);
@ -1682,7 +1682,7 @@ void pred_transformer::init_rule(decl2rel const& pts, datalog::rule const& rule)
ground_free_vars(trans, var_reprs, aux_vars, ut_size == 0);
// SASSERT(is_all_non_null(var_reprs));
expr_ref tmp = var_subst(m, false)(trans, var_reprs.size (), (expr*const*)var_reprs.c_ptr());
expr_ref tmp = var_subst(m, false)(trans, var_reprs.size (), (expr*const*)var_reprs.data());
flatten_and (tmp, side);
trans = mk_and(side);
side.reset ();
@ -2068,7 +2068,7 @@ void pred_transformer::frames::sort ()
if (m_sorted) { return; }
m_sorted = true;
std::sort(m_lemmas.c_ptr(), m_lemmas.c_ptr() + m_lemmas.size (), m_lt);
std::sort(m_lemmas.data(), m_lemmas.data() + m_lemmas.size (), m_lt);
}
bool pred_transformer::frames::propagate_to_next_level (unsigned level)
@ -2565,7 +2565,7 @@ bool context::validate() {
for (unsigned j = utsz; j < tsz; ++j) {
fmls.push_back(r.get_tail(j));
}
tmp = m.mk_and(fmls.size(), fmls.c_ptr());
tmp = m.mk_and(fmls.size(), fmls.data());
svector<symbol> names;
expr_free_vars fv;
fv (tmp);
@ -2576,7 +2576,7 @@ bool context::validate() {
}
if (!fv.empty()) {
fv.reverse ();
tmp = m.mk_exists(fv.size(), fv.c_ptr(), names.c_ptr(), tmp);
tmp = m.mk_exists(fv.size(), fv.data(), names.data(), tmp);
}
ref<solver> sol =
mk_smt_solver(m, params_ref::get_empty(), symbol::null);
@ -3779,7 +3779,7 @@ reach_fact *pred_transformer::mk_rf(pob& n, model &mdl, const datalog::rule& r)
// collect aux vars to eliminate
ptr_vector<app>& aux_vars = get_aux_vars (r);
bool elim_aux = ctx.elim_aux();
if (elim_aux) { vars.append(aux_vars.size(), aux_vars.c_ptr()); }
if (elim_aux) { vars.append(aux_vars.size(), aux_vars.data()); }
res = mk_and (path_cons);
@ -3860,7 +3860,7 @@ bool context::create_children(pob& n, datalog::rule const& r,
}
// local variables of the rule
ptr_vector<app>& aux_vars = pt.get_aux_vars(r);
vars.append(aux_vars.size(), aux_vars.c_ptr());
vars.append(aux_vars.size(), aux_vars.data());
// skolems of the pob
n.get_skolems(vars);
@ -3892,7 +3892,7 @@ bool context::create_children(pob& n, datalog::rule const& r,
kid_order.reverse();
}
else if (m_children_order == CO_RANDOM) {
shuffle(kid_order.size(), kid_order.c_ptr(), m_random);
shuffle(kid_order.size(), kid_order.data(), m_random);
}
for (unsigned i = 0, sz = preds.size(); i < sz; ++i) {
@ -4036,7 +4036,7 @@ bool context::check_invariant(unsigned lvl, func_decl* fn)
if (m.is_true(inv)) { return true; }
pt.add_premises(m_rels, lvl, conj);
conj.push_back(m.mk_not(inv));
expr_ref fml(m.mk_and(conj.size(), conj.c_ptr()), m);
expr_ref fml(m.mk_and(conj.size(), conj.data()), m);
ctx->assert_expr(fml);
lbool result = ctx->check_sat(0, nullptr);
TRACE("spacer", tout << "Check invariant level: " << lvl << " " << result
@ -4061,7 +4061,7 @@ expr_ref context::get_constraints (unsigned level)
{ args.push_back(m.mk_const(m_pm.o2n(r.sig(i), 0))); }
expr_ref pred(m);
pred = m.mk_app(r.head (), r.sig_size(), args.c_ptr());
pred = m.mk_app(r.head (), r.sig_size(), args.data());
constraints.push_back(m.mk_implies(pred, c));
}
@ -4107,7 +4107,7 @@ void context::new_lemma_eh(pred_transformer &pt, lemma *lem) {
for (unsigned i = 0; i < pt.sig_size(); ++i) {
args.push_back(m.mk_const(pt.get_manager().o2n(pt.sig(i), 0)));
}
expr *app = m.mk_app(pt.head(), pt.sig_size(), args.c_ptr());
expr *app = m.mk_app(pt.head(), pt.sig_size(), args.data());
expr *lemma = m.mk_implies(app, lem->get_expr());
for (unsigned i = 0; i < m_callbacks.size(); i++) {
if (m_callbacks[i]->new_lemma())

2
src/muz/spacer/spacer_context.h
View file

@ -458,7 +458,7 @@ public:
func_decl* head() const {return m_head;}
ptr_vector<datalog::rule> const& rules() const {return m_rules;}
func_decl* sig(unsigned i) const {return m_sig[i];} // signature
func_decl* const* sig() {return m_sig.c_ptr();}
func_decl* const* sig() {return m_sig.data();}
unsigned sig_size() const {return m_sig.size();}
expr* transition() const {return m_transition;}
expr* init() const {return m_init;}

2
src/muz/spacer/spacer_farkas_learner.cpp
View file

@ -374,7 +374,7 @@ void farkas_learner::get_lemmas(proof* root, expr_set const& bs, expr_ref_vector
SASSERT(coeffs.size() == lits.size());
if (num_b_pures > 0) {
expr_ref res(m);
combine_constraints(coeffs.size(), lits.c_ptr(), coeffs.c_ptr(), res);
combine_constraints(coeffs.size(), lits.data(), coeffs.data(), res);
TRACE("farkas_learner2", tout << "Add: " << mk_pp(res, m) << "\n";);
INSERT(res);
b_closed.mark(p, true);

2
src/muz/spacer/spacer_iuc_solver.cpp
View file

@ -121,7 +121,7 @@ namespace spacer {
lbool iuc_solver::check_sat_cc(const expr_ref_vector &cube,
vector<expr_ref_vector> const & clauses) {
if (clauses.empty())
return check_sat(cube.size(), cube.c_ptr());
return check_sat(cube.size(), cube.data());
// -- remove any old assumptions
m_assumptions.shrink(m_first_assumption);

2
src/muz/spacer/spacer_iuc_solver.h
View file

@ -103,7 +103,7 @@ public:
void get_full_unsat_core(ptr_vector<expr> &core) {
expr_ref_vector _core(m);
m_solver.get_unsat_core(_core);
core.append(_core.size(), _core.c_ptr());
core.append(_core.size(), _core.data());
}
/* solver interface */

8
src/muz/spacer/spacer_legacy_mev.cpp
View file

@ -506,10 +506,10 @@ void model_evaluator::eval_array_eq(app* e, expr* arg1, expr* arg2)
for (unsigned i = 0; i < store.size(); ++i) {
args1.resize(1);
args2.resize(1);
args1.append(store[i].size() - 1, store[i].c_ptr());
args2.append(store[i].size() - 1, store[i].c_ptr());
s1 = m_array.mk_select(args1.size(), args1.c_ptr());
s2 = m_array.mk_select(args2.size(), args2.c_ptr());
args1.append(store[i].size() - 1, store[i].data());
args2.append(store[i].size() - 1, store[i].data());
s1 = m_array.mk_select(args1.size(), args1.data());
s2 = m_array.mk_select(args2.size(), args2.data());
w1 = (*m_model)(s1);
w2 = (*m_model)(s2);
if (w1 == w2) {

2
src/muz/spacer/spacer_manager.h
View file

@ -46,7 +46,7 @@ struct relation_info {
func_decl_ref_vector m_vars;
expr_ref m_body;
relation_info(ast_manager& m, func_decl* pred, ptr_vector<func_decl> const& vars, expr* b):
m_pred(pred, m), m_vars(m, vars.size(), vars.c_ptr()), m_body(b, m) {}
m_pred(pred, m), m_vars(m, vars.size(), vars.data()), m_body(b, m) {}
};
class unknown_exception {};

4
src/muz/spacer/spacer_mev_array.cpp
View file

@ -151,8 +151,8 @@ void model_evaluator_array_util::eval_array_eq(model& mdl, app* e, expr* arg1, e
for (unsigned i = 0; i < store.size(); ++i) {
args1.resize(1);
args2.resize(1);
args1.append(store[i].size()-1, store[i].c_ptr());
args2.append(store[i].size()-1, store[i].c_ptr());
args1.append(store[i].size()-1, store[i].data());
args2.append(store[i].size()-1, store[i].data());
s1 = m_array.mk_select(args1);
s2 = m_array.mk_select(args2);
eval (mdl, s1, w1);

2
src/muz/spacer/spacer_pdr.cpp
View file

@ -340,7 +340,7 @@ bool context::gpdr_create_split_children(pob &n, const datalog::rule &r,
kid_order.reverse();
}
else if (m_children_order == CO_RANDOM) {
shuffle(kid_order.size(), kid_order.c_ptr(), m_random);
shuffle(kid_order.size(), kid_order.data(), m_random);
}

16
src/muz/spacer/spacer_proof_utils.cpp
View file

@ -219,8 +219,8 @@ namespace spacer {
proof_ref pf(m);
pf = m.mk_th_lemma(tid, m.mk_false(),
parents.size(), parents.c_ptr(),
v.size(), v.c_ptr());
parents.size(), parents.data(),
v.size(), v.data());
return pf;
}
@ -345,8 +345,8 @@ namespace spacer {
proof_ref pf(m);
pf = m.mk_th_lemma(tid, m.mk_false(),
parents.size(), parents.c_ptr(),
v.size(), v.c_ptr());
parents.size(), parents.data(),
v.size(), v.data());
SASSERT(is_arith_lemma(m, pf));
TRACE("spacer.fkab", tout << mk_pp(pf, m) << "\n";);
@ -447,7 +447,7 @@ namespace spacer {
SASSERT(p->get_decl()->get_arity() == args.size());
proof* res = m.mk_app(p->get_decl(),
args.size(), (expr * const*)args.c_ptr());
args.size(), (expr * const*)args.data());
m_pinned.push_back(res);
m_cache.insert(p, res);
}
@ -734,7 +734,7 @@ namespace spacer {
}
expr_ref lemma(m);
lemma = mk_or(m, args.size(), args.c_ptr());
lemma = mk_or(m, args.size(), args.data());
proof* res;
res = m.mk_lemma(premise, lemma);
@ -816,7 +816,7 @@ namespace spacer {
// expr_ref tmp(m);
// tmp = mk_or(m, pf_fact.size(), pf_fact.c_ptr());
// proof* res = m.mk_unit_resolution(pf_args.size(), pf_args.c_ptr(), tmp);
proof *res = m.mk_unit_resolution(pf_args.size(), pf_args.c_ptr());
proof *res = m.mk_unit_resolution(pf_args.size(), pf_args.data());
m_pinned.push_back(res);
return res;
@ -839,7 +839,7 @@ namespace spacer {
SASSERT(old->get_decl()->get_arity() == args.size());
proof* res = m.mk_app(old->get_decl(), args.size(),
(expr * const*)args.c_ptr());
(expr * const*)args.data());
m_pinned.push_back(res);
return res;
}

8
src/muz/spacer/spacer_prop_solver.cpp
View file

@ -143,7 +143,7 @@ lbool prop_solver::mss(expr_ref_vector &hard, expr_ref_vector &soft) {
iuc_solver::scoped_mk_proxy _p_(*m_ctx, hard);
unsigned hard_sz = hard.size();
lbool res = m_ctx->check_sat(hard.size(), hard.c_ptr());
lbool res = m_ctx->check_sat(hard.size(), hard.data());
// bail out if hard constraints are not sat, or if there are no
// soft constraints
if (res != l_true || soft.empty()) {return res;}
@ -202,7 +202,7 @@ lbool prop_solver::mss(expr_ref_vector &hard, expr_ref_vector &soft) {
// -- grow the set of backbone literals
for (;j < hard.size(); ++j) {
res = m_ctx->check_sat(j+1, hard.c_ptr());
res = m_ctx->check_sat(j+1, hard.data());
if (res == l_false) {
// -- flip non-true literal to be false
hard[j] = mk_not(m, hard.get(j));
@ -363,10 +363,10 @@ lbool prop_solver::check_assumptions(const expr_ref_vector & _hard,
// current clients expect that flattening of HARD is
// done implicitly during check_assumptions
expr_ref_vector hard(m);
hard.append(_hard.size(), _hard.c_ptr());
hard.append(_hard.size(), _hard.data());
flatten_and(hard);
shuffle(hard.size(), hard.c_ptr(), m_random);
shuffle(hard.size(), hard.data(), m_random);
m_ctx = m_contexts [solver_id == 0 ? 0 : 0 /* 1 */].get();

32
src/muz/spacer/spacer_qe_project.cpp
View file

@ -128,7 +128,7 @@ peq::peq (expr* lhs, expr* rhs, unsigned num_indices, expr * const * diff_indice
sorts.push_back (diff_indices[i]->get_sort ());
m_diff_indices.push_back (diff_indices [i]);
}
m_decl = m.mk_func_decl (symbol (PARTIAL_EQ), sorts.size (), sorts.c_ptr (), m.mk_bool_sort ());
m_decl = m.mk_func_decl (symbol (PARTIAL_EQ), sorts.size (), sorts.data (), m.mk_bool_sort ());
}
void peq::lhs (expr_ref& result) { result = m_lhs; }
@ -149,7 +149,7 @@ void peq::mk_peq (app_ref& result) {
for (unsigned i = 0; i < m_num_indices; i++) {
args.push_back (m_diff_indices.get (i));
}
m_peq = m.mk_app (m_decl, args.size (), args.c_ptr ());
m_peq = m.mk_app (m_decl, args.size (), args.data ());
}
result = m_peq;
}
@ -326,7 +326,7 @@ namespace spacer_qe {
t = ts.get (0);
}
else {
t = a.mk_add(ts.size(), ts.c_ptr());
t = a.mk_add(ts.size(), ts.data());
}
return true;
@ -947,7 +947,7 @@ namespace spacer_qe {
// all args processed; make new term
func_decl* d = ap->get_decl ();
expr_ref new_term (m);
new_term = m.mk_app (d, args.size (), args.c_ptr ());
new_term = m.mk_app (d, args.size (), args.data ());
// check for mod and introduce new var
if (a.is_mod (ap)) {
app_ref new_var (m);
@ -976,7 +976,7 @@ namespace spacer_qe {
if (new_fml) {
fml = new_fml;
// add in eqs
fml = m.mk_and (fml, m.mk_and (eqs.size (), eqs.c_ptr ()));
fml = m.mk_and (fml, m.mk_and (eqs.size (), eqs.data ()));
}
else {
// unchanged
@ -1045,7 +1045,7 @@ namespace spacer_qe {
// t2 < abs (num_val)
lits.push_back (a.mk_lt (t2, a.mk_numeral (abs (num_val), a.mk_int ())));
new_fml = m.mk_and (lits.size (), lits.c_ptr ());
new_fml = m.mk_and (lits.size (), lits.data ());
}
}
else if (!is_app (fml)) {
@ -1060,7 +1060,7 @@ namespace spacer_qe {
mod2div (ch, map);
children.push_back (ch);
}
new_fml = m.mk_app (a->get_decl (), children.size (), children.c_ptr ());
new_fml = m.mk_app (a->get_decl (), children.size (), children.data ());
}
map.insert (fml, new_fml, nullptr);
@ -1402,7 +1402,7 @@ namespace spacer_qe {
if (!all_done) continue;
todo.pop_back ();
expr_ref a_new (m.mk_app (a->get_decl (), args.size (), args.c_ptr ()), m);
expr_ref a_new (m.mk_app (a->get_decl (), args.size (), args.data ()), m);
// if a_new is select on m_v, introduce new constant
if (m_arr_u.is_select (a) &&
@ -1457,7 +1457,7 @@ namespace spacer_qe {
ptr_vector<expr> sel_args;
sel_args.push_back (arr);
sel_args.push_back (I.get (i));
expr_ref val_term (m_arr_u.mk_select (sel_args.size (), sel_args.c_ptr ()), m);
expr_ref val_term (m_arr_u.mk_select (sel_args.size (), sel_args.data ()), m);
// evaluate and assign to ith diff_val_const
m_mev.eval (*M, val_term, val);
M->register_decl (diff_val_consts.get (i)->get_decl (), val);
@ -1537,7 +1537,7 @@ namespace spacer_qe {
);
// arr0 ==I arr1
mk_peq (arr0, arr1, I.size (), I.c_ptr (), p_exp);
mk_peq (arr0, arr1, I.size (), I.data (), p_exp);
TRACE ("qe",
tout << "new peq:\n";
@ -1548,7 +1548,7 @@ namespace spacer_qe {
m_idx_lits_v.append (idx_diseq);
// arr0 ==I+idx arr1
I.push_back (idx);
mk_peq (arr0, arr1, I.size (), I.c_ptr (), p_exp);
mk_peq (arr0, arr1, I.size (), I.data (), p_exp);
TRACE ("qe",
tout << "new peq:\n";
@ -1559,7 +1559,7 @@ namespace spacer_qe {
ptr_vector<expr> sel_args;
sel_args.push_back (arr1);
sel_args.push_back (idx);
expr_ref arr1_idx (m_arr_u.mk_select (sel_args.size (), sel_args.c_ptr ()), m);
expr_ref arr1_idx (m_arr_u.mk_select (sel_args.size (), sel_args.data ()), m);
expr_ref eq (m.mk_eq (arr1_idx, x), m);
m_aux_lits_v.push_back (eq);
@ -1737,7 +1737,7 @@ namespace spacer_qe {
lits.append (m_idx_lits_v);
lits.append (m_aux_lits_v);
lits.push_back (fml);
fml = m.mk_and (lits.size (), lits.c_ptr ());
fml = m.mk_and (lits.size (), lits.data ());
if (m_subst_term_v) {
m_true_sub_v.insert (m_v, m_subst_term_v);
@ -1899,7 +1899,7 @@ namespace spacer_qe {
todo.pop_back ();
if (dirty) {
r = m.mk_app (a->get_decl (), args.size (), args.c_ptr ());
r = m.mk_app (a->get_decl (), args.size (), args.data ());
m_pinned.push_back (r);
}
else r = a;
@ -1954,7 +1954,7 @@ namespace spacer_qe {
expr_ref_vector lits (m);
lits.append (m_idx_lits);
lits.push_back (fml);
fml = m.mk_and (lits.size (), lits.c_ptr ());
fml = m.mk_and (lits.size (), lits.data ());
// simplify all trivial expressions introduced
m_rw (fml);
@ -2153,7 +2153,7 @@ namespace spacer_qe {
expr_ref_vector lits (m);
lits.append (m_idx_lits);
lits.push_back (fml);
fml = m.mk_and (lits.size (), lits.c_ptr ());
fml = m.mk_and (lits.size (), lits.data ());
// substitute for sel terms
m_sub (fml);

6
src/muz/spacer/spacer_quant_generalizer.cpp
View file

@ -184,7 +184,7 @@ void lemma_quantifier_generalizer::find_candidates(expr *e,
}
}
std::sort(candidates.c_ptr(), candidates.c_ptr() + candidates.size(),
std::sort(candidates.data(), candidates.data() + candidates.size(),
index_lt_proc(m));
// keep actual select indices in the order found at the back of
// candidate list. There is no particular reason for this order
@ -276,8 +276,8 @@ void lemma_quantifier_generalizer::cleanup(expr_ref_vector &cube,
}
if (!found) continue;
rep = arith.mk_add(kids.size(), kids.c_ptr());
bind = arith.mk_add(kids_bind.size(), kids_bind.c_ptr());
rep = arith.mk_add(kids.size(), kids.data());
bind = arith.mk_add(kids_bind.size(), kids_bind.data());
TRACE("spacer_qgen",
tout << "replace " << mk_pp(idx, m) << " with " << mk_pp(rep, m) << "\n"
<< "bind is: " << bind << "\n";);

4
src/muz/spacer/spacer_sat_answer.cpp
View file

@ -24,7 +24,7 @@ struct ground_sat_answer_op::frame {
ast_manager &m = pt.get_ast_manager();
spacer::manager &pm = pt.get_manager();
m_fact = m.mk_app(head(), m_gnd_subst.size(), m_gnd_subst.c_ptr());
m_fact = m.mk_app(head(), m_gnd_subst.size(), m_gnd_subst.data());
// compute ground equalities implied by the fact
SASSERT(m_gnd_subst.size() == pt.head()->get_arity());
@ -193,7 +193,7 @@ proof *ground_sat_answer_op::mk_proof_step(frame &fr) {
substs.push_back(expr_ref_vector(m));
}
m_pinned.push_back(m.mk_hyper_resolve(premises.size(),
premises.c_ptr(),
premises.data(),
fr.fact(),
positions, substs));
TRACE("spacer_sat", tout << "pf step:\n"

4
src/muz/spacer/spacer_util.cpp
View file

@ -732,7 +732,7 @@ namespace spacer {
egraph.to_lits(v);
}
// sort arguments of the top-level and
std::stable_sort(v.c_ptr(), v.c_ptr() + v.size(), ast_lt_proc());
std::stable_sort(v.data(), v.data() + v.size(), ast_lt_proc());
TRACE("spacer_normalize",
tout << "Normalized:\n"
@ -857,7 +857,7 @@ namespace spacer {
sort* s = fv[i] ? fv[i] : m.mk_bool_sort();
vars[i] = mk_zk_const(m, i, s);
var_subst vs(m, false);
out = vs(e, vars.size(), (expr**)vars.c_ptr());
out = vs(e, vars.size(), (expr**)vars.data());
}
}

46
src/muz/tab/tab_context.cpp
View file

@ -212,7 +212,7 @@ namespace tb {
}
fmls.push_back(m_constraint);
flatten_and(fmls);
bool_rewriter(m).mk_and(fmls.size(), fmls.c_ptr(), fml);
bool_rewriter(m).mk_and(fmls.size(), fmls.data(), fml);
return fml;
}
@ -223,7 +223,7 @@ namespace tb {
fv.accumulate(m_predicates[i]);
}
fv.accumulate(m_constraint);
vars.append(fv.size(), fv.c_ptr());
vars.append(fv.size(), fv.data());
}
expr_ref to_formula() const {
@ -246,7 +246,7 @@ namespace tb {
if (!vars[i]) vars[i] = m.mk_bool_sort();
}
if (!vars.empty()) {
body = m.mk_forall(vars.size(), vars.c_ptr(), names.c_ptr(), body);
body = m.mk_forall(vars.size(), vars.data(), names.data(), body);
}
return body;
}
@ -293,7 +293,7 @@ namespace tb {
fmls.push_back(m_predicates[i]);
}
fmls.push_back(m_constraint);
bool_rewriter(m).mk_and(fmls.size(), fmls.c_ptr(), fml);
bool_rewriter(m).mk_and(fmls.size(), fmls.data(), fml);
if (!m.is_false(m_head)) {
if (m.is_true(fml)) {
fml = m_head;
@ -329,7 +329,7 @@ namespace tb {
for (unsigned i = 0; i < utsz; ++i) {
m_predicates.push_back(r->get_tail(i));
}
bool_rewriter(m).mk_and(fmls.size(), fmls.c_ptr(), m_constraint);
bool_rewriter(m).mk_and(fmls.size(), fmls.data(), m_constraint);
}
// Simplify a clause by applying equalities as substitutions on predicates.
@ -355,7 +355,7 @@ namespace tb {
subst.apply(1, delta, expr_offset(m_predicates[i].get(), 0), tmp);
m_predicates[i] = to_app(tmp);
}
bool_rewriter(m).mk_and(fmls.size(), fmls.c_ptr(), m_constraint);
bool_rewriter(m).mk_and(fmls.size(), fmls.data(), m_constraint);
subst.apply(1, delta, expr_offset(m_constraint, 0), m_constraint);
rw(m_constraint);
}
@ -559,15 +559,15 @@ namespace tb {
}
vars.push_back(m.mk_const(symbol(i), sorts[i]));
}
fml = vs(g.get_head(), vars.size(), vars.c_ptr());
fml = vs(g.get_head(), vars.size(), vars.data());
m_head = to_app(fml);
for (unsigned i = 0; i < g.get_num_predicates(); ++i) {
fml = vs(g.get_predicate(i), vars.size(), vars.c_ptr());
fml = vs(g.get_predicate(i), vars.size(), vars.data());
m_preds.push_back(to_app(fml));
}
fml = vs(g.get_constraint(), vars.size(), vars.c_ptr());
fml = vs(g.get_constraint(), vars.size(), vars.data());
fmls.push_back(fml);
m_precond = m.mk_and(fmls.size(), fmls.c_ptr());
m_precond = m.mk_and(fmls.size(), fmls.data());
IF_VERBOSE(2,
verbose_stream() << "setup-match: ";
for (unsigned i = 0; i < m_preds.size(); ++i) {
@ -661,7 +661,7 @@ namespace tb {
return false;
}
}
m_rw.mk_and(fmls.size(), fmls.c_ptr(), postcond);
m_rw.mk_and(fmls.size(), fmls.data(), postcond);
if (!m.inc()) {
return false;
}
@ -1130,12 +1130,12 @@ namespace tb {
}
}
if (change) {
constraint = m_S2(result->get_constraint(), m_rename.size(), m_rename.c_ptr());
constraint = m_S2(result->get_constraint(), m_rename.size(), m_rename.data());
for (unsigned i = 0; i < result->get_num_predicates(); ++i) {
tmp = m_S2(result->get_predicate(i), m_rename.size(), m_rename.c_ptr());
tmp = m_S2(result->get_predicate(i), m_rename.size(), m_rename.data());
predicates[i] = to_app(tmp);
}
tmp = m_S2(result->get_head(), m_rename.size(), m_rename.c_ptr());
tmp = m_S2(result->get_head(), m_rename.size(), m_rename.data());
head = to_app(tmp);
result->init(head, predicates, constraint);
}
@ -1166,7 +1166,7 @@ namespace tb {
if (vars[i]) {
v = m.mk_var(i, vars[i]);
m_S1.apply(2, delta, expr_offset(v, offset), tmp);
tmp = m_S2(tmp, m_rename.size(), m_rename.c_ptr());
tmp = m_S2(tmp, m_rename.size(), m_rename.data());
insert_subst(offset, tmp);
}
else {
@ -1222,26 +1222,26 @@ namespace tb {
}
}
app_ref_vector preds(m);
delta = m.mk_fresh_func_decl("Delta", dom.size(), dom.c_ptr(), m.mk_bool_sort());
delta = m.mk_fresh_func_decl("Delta", dom.size(), dom.data(), m.mk_bool_sort());
acc = alloc(clause, m);
delta1 = alloc(clause, m);
delta2 = alloc(clause, m);
delta1->init(m.mk_app(delta, zszs.size(), zszs.c_ptr()), preds, m.mk_true());
delta1->init(m.mk_app(delta, zszs.size(), zszs.data()), preds, m.mk_true());
for (unsigned i = 0; i < zs.size(); ++i) {
zszs[i+zs.size()] = p->get_arg(i);
}
app_ref head(m), pred(m);
head = m.mk_app(delta, zszs.size(), zszs.c_ptr());
head = m.mk_app(delta, zszs.size(), zszs.data());
for (unsigned i = 0; i < zs.size(); ++i) {
zszs[i+zs.size()] = q->get_arg(i);
}
pred = m.mk_app(delta, zszs.size(), zszs.c_ptr());
pred = m.mk_app(delta, zszs.size(), zszs.data());
preds.push_back(pred);
for (unsigned i = 1; i < g.get_num_predicates(); ++i) {
preds.push_back(g.get_predicate(i));
}
delta2->init(head, preds, g.get_constraint());
preds.push_back(m.mk_app(q->get_decl(), zs.size(), zs.c_ptr()));
preds.push_back(m.mk_app(q->get_decl(), zs.size(), zs.data()));
acc->init(p, preds, g.get_constraint());
IF_VERBOSE(1,
@ -1598,7 +1598,7 @@ namespace datalog {
pc.invert();
prs.push_back(m.mk_asserted(root));
pr = pc(m, 1, prs.c_ptr());
pr = pc(m, 1, prs.data());
return pr;
}
@ -1610,7 +1610,7 @@ namespace datalog {
}
expr_ref body = clause.get_body();
var_subst vs(m, false);
body = vs(body, subst.size(), subst.c_ptr());
body = vs(body, subst.size(), subst.data());
out << body << "\n";
}
@ -1628,7 +1628,7 @@ namespace datalog {
premises.push_back(m.mk_asserted(r1.to_formula()));
premises.push_back(m.mk_asserted(r2.to_formula()));
positions.push_back(std::make_pair(idx+1, 0));
pr = m.mk_hyper_resolve(2, premises.c_ptr(), fml, positions, substs);
pr = m.mk_hyper_resolve(2, premises.data(), fml, positions, substs);
pc.insert(pr);
}
};

10
src/muz/transforms/dl_mk_array_blast.cpp
View file

@ -170,7 +170,7 @@ namespace datalog {
}
if (valid) {
todo.pop_back();
e1 = m.mk_app(ap->get_decl(), args.size(), args.c_ptr());
e1 = m.mk_app(ap->get_decl(), args.size(), args.data());
trail.push_back(e1);
if (a.is_select(ap)) {
if (m_defs.find(e1, v)) {
@ -195,7 +195,7 @@ namespace datalog {
for (unsigned j = 0; j < s->get_num_args(); ++j) {
args.push_back(cache.find(s->get_arg(j)));
}
e1 = m.mk_app(s->get_decl(), args.size(), args.c_ptr());
e1 = m.mk_app(s->get_decl(), args.size(), args.data());
if (!m_defs.contains(e1) && !insert_def(r, e1, v)) {
return false;
}
@ -230,10 +230,10 @@ namespace datalog {
for (unsigned j = 0; j < args1.size(); ++j) {
eqs.push_back(m.mk_eq(args1[j], args2[j]));
}
conjs.push_back(m.mk_implies(m.mk_and(eqs.size(), eqs.c_ptr()), m.mk_eq(v1, v2)));
conjs.push_back(m.mk_implies(m.mk_and(eqs.size(), eqs.data()), m.mk_eq(v1, v2)));
}
}
body = m.mk_and(conjs.size(), conjs.c_ptr());
body = m.mk_and(conjs.size(), conjs.data());
m_rewriter(body);
return true;
}
@ -281,7 +281,7 @@ namespace datalog {
return false;
}
expr_ref fml1(m), fml2(m), body(m), head(m);
body = m.mk_and(new_conjs.size(), new_conjs.c_ptr());
body = m.mk_and(new_conjs.size(), new_conjs.data());
head = r.get_head();
sub(body);
m_rewriter(body);

4
src/muz/transforms/dl_mk_array_eq_rewrite.cpp
View file

@ -99,7 +99,7 @@ namespace datalog {
res_conjs.push_back(tmp);
}
proof_ref pr(m);
m_src_manager->mk_rule(m.mk_implies(m.mk_and(res_conjs.size(), res_conjs.c_ptr()), r.get_head()), pr, dest, r.name());
m_src_manager->mk_rule(m.mk_implies(m.mk_and(res_conjs.size(), res_conjs.data()), r.get_head()), pr, dest, r.name());
}
// NSB Code review: use substitution facility, such as expr_safe_replace or expr_replacer.
@ -115,7 +115,7 @@ namespace datalog {
for (expr * arg : *f) {
n_args.push_back(replace(arg, new_val, old_val));
}
return m.mk_app(f->get_decl(), n_args.size(), n_args.c_ptr());
return m.mk_app(f->get_decl(), n_args.size(), n_args.data());
}
}

12
src/muz/transforms/dl_mk_array_instantiation.cpp
View file

@ -96,7 +96,7 @@ namespace datalog {
new_tail.push_back(m.mk_eq(it->get_value(), tmp));
}
proof_ref pr(m);
src_manager->mk_rule(m.mk_implies(m.mk_and(new_tail.size(), new_tail.c_ptr()), new_head), pr, dest, r.name());
src_manager->mk_rule(m.mk_implies(m.mk_and(new_tail.size(), new_tail.data()), new_head), pr, dest, r.name());
}
expr_ref mk_array_instantiation::create_head(app* old_head) {
@ -112,7 +112,7 @@ namespace datalog {
cnt++;
}
expr_ref select(m);
select = m_a.mk_select(dummy_args.size(), dummy_args.c_ptr());
select = m_a.mk_select(dummy_args.size(), dummy_args.data());
new_args.push_back(select);
selects.insert_if_not_there(arg, ptr_vector<expr>());
selects[arg].push_back(select);
@ -183,11 +183,11 @@ namespace datalog {
new_sorts.push_back(new_args.get(i)->get_sort());
expr_ref res(m);
func_decl_ref fun_decl(m);
fun_decl = m.mk_func_decl(symbol((old_pred->get_decl()->get_name().str()+"!inst").c_str()), new_sorts.size(), new_sorts.c_ptr(), old_pred->get_decl()->get_range());
fun_decl = m.mk_func_decl(symbol((old_pred->get_decl()->get_name().str()+"!inst").c_str()), new_sorts.size(), new_sorts.data(), old_pred->get_decl()->get_range());
m_ctx.register_predicate(fun_decl, false);
if(src_set->is_output_predicate(old_pred->get_decl()))
dst->set_output_predicate(fun_decl);
res=m.mk_app(fun_decl,new_args.size(), new_args.c_ptr());
res=m.mk_app(fun_decl,new_args.size(), new_args.data());
return res;
}
@ -212,7 +212,7 @@ namespace datalog {
for(unsigned i=1; i<s->get_num_args();i++) {
args.push_back(s->get_arg(i));
}
res = m_a.mk_select(args.size(), args.c_ptr());
res = m_a.mk_select(args.size(), args.data());
return res;
}
@ -234,7 +234,7 @@ namespace datalog {
dummy_args.push_back(m.mk_var(cnt, get_array_domain(array->get_sort(), i)));
cnt++;
}
all_selects.push_back(m_a.mk_select(dummy_args.size(), dummy_args.c_ptr()));
all_selects.push_back(m_a.mk_select(dummy_args.size(), dummy_args.data()));
}
return all_selects;
}

2
src/muz/transforms/dl_mk_backwards.cpp
View file

@ -67,7 +67,7 @@ namespace datalog {
else {
head = r.get_tail(j);
}
new_rule = rm.mk(head, tail.size(), tail.c_ptr(), neg.c_ptr(), r.name(), true);
new_rule = rm.mk(head, tail.size(), tail.data(), neg.data(), r.name(), true);
result->add_rule(new_rule);
}
}

4
src/muz/transforms/dl_mk_bit_blast.cpp
View file

@ -182,7 +182,7 @@ namespace datalog {
m_args.push_back(a->get_arg(i));
m_g_vars.push_back(m.mk_var(idx++,m.mk_bool_sort()));
}
m_f_vars.push_back(m_util.mk_bv(sz, m_g_vars.c_ptr()+m_g_vars.size()-sz));
m_f_vars.push_back(m_util.mk_bv(sz, m_g_vars.data()+m_g_vars.size()-sz));
}
else {
m_args.push_back(arg);
@ -202,7 +202,7 @@ namespace datalog {
for (expr* arg : m_args) {
domain.push_back(arg->get_sort());
}
g = m_context.mk_fresh_head_predicate(f->get_name(), symbol("bv"), m_args.size(), domain.c_ptr(), f);
g = m_context.mk_fresh_head_predicate(f->get_name(), symbol("bv"), m_args.size(), domain.data(), f);
m_old_funcs.push_back(f);
m_new_funcs.push_back(g);
m_pred2blast.insert(f, g);

10
src/muz/transforms/dl_mk_coalesce.cpp
View file

@ -53,7 +53,7 @@ namespace datalog {
m_sub2.push_back(b);
args.push_back(m.mk_var(m_idx++, a->get_sort()));
}
pred = m.mk_app(p1->get_decl(), args.size(), args.c_ptr());
pred = m.mk_app(p1->get_decl(), args.size(), args.data());
}
void mk_coalesce::extract_conjs(expr_ref_vector const& sub, rule const& rl, expr_ref& result) {
@ -98,10 +98,10 @@ namespace datalog {
}
var_subst vs(m, false);
for (unsigned i = r->get_uninterpreted_tail_size(); i < r->get_tail_size(); ++i) {
result = vs(r->get_tail(i), revsub.size(), revsub.c_ptr());
result = vs(r->get_tail(i), revsub.size(), revsub.data());
conjs.push_back(result);
}
bwr.mk_and(conjs.size(), conjs.c_ptr(), result);
bwr.mk_and(conjs.size(), conjs.data(), result);
}
void mk_coalesce::merge_rules(rule_ref& tgt, rule const& src) {
@ -132,7 +132,7 @@ namespace datalog {
SASSERT(is_app(fml));
tail.push_back(to_app(fml));
is_neg.push_back(false);
res = rm.mk(head, tail.size(), tail.c_ptr(), is_neg.c_ptr(), tgt->name());
res = rm.mk(head, tail.size(), tail.data(), is_neg.data(), tgt->name());
if (m_ctx.generate_proof_trace()) {
rm.to_formula(src, fml1);
rm.to_formula(*tgt.get(),fml2);
@ -177,7 +177,7 @@ namespace datalog {
rule_set::decl2rules::iterator it = source.begin_grouped_rules(), end = source.end_grouped_rules();
for (; it != end; ++it) {
rule_ref_vector d_rules(rm);
d_rules.append(it->m_value->size(), it->m_value->c_ptr());
d_rules.append(it->m_value->size(), it->m_value->data());
for (unsigned i = 0; i < d_rules.size(); ++i) {
rule_ref r1(d_rules[i].get(), rm);
for (unsigned j = i + 1; j < d_rules.size(); ++j) {

4
src/muz/transforms/dl_mk_coi_filter.cpp
View file

@ -84,7 +84,7 @@ namespace datalog {
m_new_tail_neg.push_back(false);
}
rule* new_r = m_context.get_rule_manager().mk(r->get_head(), m_new_tail.size(),
m_new_tail.c_ptr(), m_new_tail_neg.c_ptr(), symbol::null, false);
m_new_tail.data(), m_new_tail_neg.data(), symbol::null, false);
res->add_rule(new_r);
} else {
res->add_rule(r);
@ -155,7 +155,7 @@ namespace datalog {
fmls.push_back(mk_and(conj));
}
expr_ref fml(m);
fml = m.mk_or(fmls.size(), fmls.c_ptr());
fml = m.mk_or(fmls.size(), fmls.data());
mc0->add(f, fml);
}
m_context.add_model_converter(mc0);

4
src/muz/transforms/dl_mk_elim_term_ite.cpp
View file

@ -135,7 +135,7 @@ namespace datalog {
for (expr* e : new_conjs) {
tail.push_back(rm.ensure_app(e));
}
rule_ref new_rule(rm.mk(r.get_head(), tail.size(), tail.c_ptr(), nullptr, r.name(), false), rm);
rule_ref new_rule(rm.mk(r.get_head(), tail.size(), tail.data(), nullptr, r.name(), false), rm);
rm.mk_rule_rewrite_proof(r, *new_rule.get());
new_rules.add_rule(new_rule);
TRACE("dl", tout << "No term-ite after blast_term_ite\n";);
@ -178,7 +178,7 @@ namespace datalog {
app_ref_vector consts(m);
collect_uninterp_consts(fml2, consts, m_ground);
fml2 = mk_forall(m, consts.size(), consts.c_ptr(), fml2);
fml2 = mk_forall(m, consts.size(), consts.data(), fml2);
proof_ref p(m);
rm.mk_rule(fml2, p, new_rules, r.name());

8
src/muz/transforms/dl_mk_filter_rules.cpp
View file

@ -82,11 +82,11 @@ namespace datalog {
func_decl*& filter_decl = m_tail2filter.insert_if_not_there(key, 0);
if (!filter_decl) {
filter_decl = m_context.mk_fresh_head_predicate(pred->get_decl()->get_name(), symbol("filter"),
filter_domain.size(), filter_domain.c_ptr(), pred->get_decl());
filter_domain.size(), filter_domain.data(), pred->get_decl());
m_pinned.push_back(filter_decl);
app_ref filter_head(m);
filter_head = m.mk_app(filter_decl, key->filter_args.size(), key->filter_args.c_ptr());
filter_head = m.mk_app(filter_decl, key->filter_args.size(), key->filter_args.data());
app * filter_tail = key->new_pred;
rule * filter_rule = m_context.get_rule_manager().mk(filter_head, 1, &filter_tail, (const bool *)nullptr);
filter_rule->set_accounting_parent_object(m_context, m_current);
@ -128,7 +128,7 @@ namespace datalog {
}
}
SASSERT(new_args.size() == filter_decl->get_arity());
new_tail.push_back(m.mk_app(filter_decl, new_args.size(), new_args.c_ptr()));
new_tail.push_back(m.mk_app(filter_decl, new_args.size(), new_args.data()));
rule_modified = true;
}
else {
@ -139,7 +139,7 @@ namespace datalog {
if (rule_modified) {
remove_duplicate_tails(new_tail, new_is_negated);
SASSERT(new_tail.size() == new_is_negated.size());
rule * new_rule = m_context.get_rule_manager().mk(new_head, new_tail.size(), new_tail.c_ptr(), new_is_negated.c_ptr(), r->name());
rule * new_rule = m_context.get_rule_manager().mk(new_head, new_tail.size(), new_tail.data(), new_is_negated.data(), r->name());
new_rule->set_accounting_parent_object(m_context, m_current);
m_result->add_rule(new_rule);
m_context.get_rule_manager().mk_rule_rewrite_proof(*r, *new_rule);

12
src/muz/transforms/dl_mk_interp_tail_simplifier.cpp
View file

@ -85,7 +85,7 @@ namespace datalog {
mk_rule_inliner::remove_duplicate_tails(m_tail, m_neg);
SASSERT(m_tail.size() == m_neg.size());
res = m_context.get_rule_manager().mk(m_head, m_tail.size(), m_tail.c_ptr(), m_neg.c_ptr(),m_rule->name());
res = m_context.get_rule_manager().mk(m_head, m_tail.size(), m_tail.data(), m_neg.data(),m_rule->name());
res->set_accounting_parent_object(m_context, m_rule);
res->norm_vars(res.get_manager());
}
@ -334,7 +334,7 @@ namespace datalog {
m_app_args.reset();
m_app_args.append(num, args);
std::sort(m_app_args.c_ptr(), m_app_args.c_ptr()+m_app_args.size(), m_expr_cmp);
std::sort(m_app_args.data(), m_app_args.data()+m_app_args.size(), m_expr_cmp);
remove_duplicates(m_app_args);
@ -347,11 +347,11 @@ namespace datalog {
}
else {
if (m.is_and(f)) {
result = m.mk_and(m_app_args.size(), m_app_args.c_ptr());
result = m.mk_and(m_app_args.size(), m_app_args.data());
}
else {
SASSERT(m.is_or(f));
result = m.mk_or(m_app_args.size(), m_app_args.c_ptr());
result = m.mk_or(m_app_args.size(), m_app_args.data());
}
}
@ -529,7 +529,7 @@ namespace datalog {
m_itail_members.push_back(r->get_tail(i));
SASSERT(!r->is_neg_tail(i));
}
itail = m.mk_and(m_itail_members.size(), m_itail_members.c_ptr());
itail = m.mk_and(m_itail_members.size(), m_itail_members.data());
modified = true;
}
@ -559,7 +559,7 @@ namespace datalog {
}
SASSERT(m_tail.size() == m_tail_neg.size());
res = m_context.get_rule_manager().mk(head, m_tail.size(), m_tail.c_ptr(), m_tail_neg.c_ptr(), r->name());
res = m_context.get_rule_manager().mk(head, m_tail.size(), m_tail.data(), m_tail_neg.data(), r->name());
res->set_accounting_parent_object(m_context, r);
}
else {

8
src/muz/transforms/dl_mk_karr_invariants.cpp
View file

@ -156,7 +156,7 @@ namespace datalog {
for (unsigned i = 0; i < M.size(); ++i) {
mk_body(M.A[i], M.b[i], M.eq[i], conj);
}
bool_rewriter(m).mk_and(conj.size(), conj.c_ptr(), body);
bool_rewriter(m).mk_and(conj.size(), conj.data(), body);
}
void mk_body(vector<rational> const& row, rational const& b, bool is_eq, expr_ref_vector& conj) {
@ -179,7 +179,7 @@ namespace datalog {
if (!b.is_zero()) {
sum.push_back(a.mk_numeral(b, true));
}
lhs = a.mk_add(sum.size(), sum.c_ptr());
lhs = a.mk_add(sum.size(), sum.data());
if (is_eq) {
conj.push_back(m.mk_eq(lhs, zero));
}
@ -240,7 +240,7 @@ namespace datalog {
for (; dit != dend; ++dit) {
heads.push_back(dit->m_key);
}
m_inner_ctx.rel_query(heads.size(), heads.c_ptr());
m_inner_ctx.rel_query(heads.size(), heads.data());
// retrieve invariants.
dit = src.begin_grouped_rules();
@ -306,7 +306,7 @@ namespace datalog {
}
rule* new_rule = &r;
if (tail.size() != tsz) {
new_rule = rm.mk(r.get_head(), tail.size(), tail.c_ptr(), nullptr, r.name());
new_rule = rm.mk(r.get_head(), tail.size(), tail.data(), nullptr, r.name());
}
rules.add_rule(new_rule);
rm.mk_rule_rewrite_proof(r, *new_rule); // should be weakening rule.

12
src/muz/transforms/dl_mk_loop_counter.cpp
View file

@ -42,7 +42,7 @@ namespace datalog {
ptr_vector<sort> domain;
domain.append(fn->get_num_args(), old_fn->get_domain());
domain.push_back(a.mk_int());
new_fn = m.mk_func_decl(old_fn->get_name(), domain.size(), domain.c_ptr(), old_fn->get_range());
new_fn = m.mk_func_decl(old_fn->get_name(), domain.size(), domain.data(), old_fn->get_range());
m_old2new.insert(old_fn, new_fn);
m_new2old.insert(new_fn, old_fn);
m_refs.push_back(new_fn);
@ -51,7 +51,7 @@ namespace datalog {
dst.set_output_predicate(new_fn);
}
}
return app_ref(m.mk_app(new_fn, args.size(), args.c_ptr()), m);
return app_ref(m.mk_app(new_fn, args.size(), args.data()), m);
}
app_ref mk_loop_counter::del_arg(app* fn) {
@ -60,7 +60,7 @@ namespace datalog {
SASSERT(fn->get_num_args() > 0);
args.append(fn->get_num_args()-1, fn->get_args());
VERIFY (m_new2old.find(new_fn, old_fn));
return app_ref(m.mk_app(old_fn, args.size(), args.c_ptr()), m);
return app_ref(m.mk_app(old_fn, args.size(), args.data()), m);
}
rule_set * mk_loop_counter::operator()(rule_set const & source) {
@ -108,10 +108,10 @@ namespace datalog {
expr_ref_vector args(m);
args.append(head->get_num_args(), head->get_args());
args[last] = a.mk_numeral(rational(0), true);
head = m.mk_app(head->get_decl(), args.size(), args.c_ptr());
head = m.mk_app(head->get_decl(), args.size(), args.data());
}
new_rule = rm.mk(head, tail.size(), tail.c_ptr(), neg.c_ptr(), r.name(), true);
new_rule = rm.mk(head, tail.size(), tail.data(), neg.data(), r.name(), true);
result->add_rule(new_rule);
}
@ -145,7 +145,7 @@ namespace datalog {
neg.push_back(false);
}
head = del_arg(r.get_head());
new_rule = rm.mk(head, tail.size(), tail.c_ptr(), neg.c_ptr(), r.name(), true);
new_rule = rm.mk(head, tail.size(), tail.data(), neg.data(), r.name(), true);
result->add_rule(new_rule);
}

14
src/muz/transforms/dl_mk_magic_sets.cpp
View file

@ -171,11 +171,11 @@ namespace datalog {
}
mag_pred = m_context.mk_fresh_head_predicate(l_pred->get_name(), symbol("ms"),
mag_arity, mag_domain.c_ptr(), l_pred);
mag_arity, mag_domain.data(), l_pred);
m_pinned.push_back(mag_pred);
}
app * res = m.mk_app(mag_pred, bound_args.c_ptr());
app * res = m.mk_app(mag_pred, bound_args.data());
m_pinned.push_back(res);
return res;
}
@ -194,7 +194,7 @@ namespace datalog {
continue;
}
app * mag_head = create_magic_literal(tail[i]);
rule * r = m_context.get_rule_manager().mk(mag_head, i+1, new_tail.c_ptr(), negations.c_ptr());
rule * r = m_context.get_rule_manager().mk(mag_head, i+1, new_tail.data(), negations.data());
TRACE("dl", r->display(m_context,tout); );
result.add_rule(r);
}
@ -265,7 +265,7 @@ namespace datalog {
app * new_head = m.mk_app(new_head_pred, head->get_args());
SASSERT(new_tail.size()==r->get_uninterpreted_tail_size());
create_magic_rules(new_head, new_tail.size(), new_tail.c_ptr(), negations.c_ptr(), result);
create_magic_rules(new_head, new_tail.size(), new_tail.data(), negations.data(), result);
unsigned tail_len = r->get_tail_size();
for (unsigned i=processed_tail_len; i<tail_len; i++) {
@ -276,7 +276,7 @@ namespace datalog {
new_tail.push_back(create_magic_literal(new_head));
negations.push_back(false);
rule * nr = m_context.get_rule_manager().mk(new_head, new_tail.size(), new_tail.c_ptr(), negations.c_ptr(), r->name());
rule * nr = m_context.get_rule_manager().mk(new_head, new_tail.size(), new_tail.data(), negations.data(), r->name());
result.add_rule(nr);
nr->set_accounting_parent_object(m_context, r);
}
@ -291,8 +291,8 @@ namespace datalog {
args.push_back(m.mk_var(i, adn_pred->get_domain(i)));
}
app * lit = m.mk_app(d.m_pred, args.c_ptr());
app * adn_lit = m.mk_app(adn_pred, args.c_ptr());
app * lit = m.mk_app(d.m_pred, args.data());
app * adn_lit = m.mk_app(adn_pred, args.data());
app * mag_lit = create_magic_literal(adn_lit);
app * tail[] = {lit, mag_lit};

2
src/muz/transforms/dl_mk_magic_sets.h
View file

@ -47,7 +47,7 @@ namespace datalog {
};
struct a_flag_hash {
typedef a_flag data;
typedef a_flag data_t;
unsigned operator()(a_flag x) const { return x; }
};

4
src/muz/transforms/dl_mk_magic_symbolic.cpp
View file

@ -94,7 +94,7 @@ namespace datalog {
tail.push_back(mk_ans(r.get_tail(j)));
neg.push_back(false);
}
new_rule = rm.mk(mk_ans(r.get_head()), tail.size(), tail.c_ptr(), neg.c_ptr(), r.name(), true);
new_rule = rm.mk(mk_ans(r.get_head()), tail.size(), tail.data(), neg.data(), r.name(), true);
result->add_rule(new_rule);
if (source.is_output_predicate(r.get_decl())) {
result->set_output_predicate(new_rule->get_decl());
@ -103,7 +103,7 @@ namespace datalog {
}
for (unsigned j = 0; j < utsz; ++j) {
new_rule = rm.mk(mk_query(r.get_tail(j)), tail.size()-utsz+j, tail.c_ptr(), neg.c_ptr(), r.name(), true);
new_rule = rm.mk(mk_query(r.get_tail(j)), tail.size()-utsz+j, tail.data(), neg.data(), r.name(), true);
result->add_rule(new_rule);
}

22
src/muz/transforms/dl_mk_quantifier_abstraction.cpp
View file

@ -124,7 +124,7 @@ namespace datalog {
TRACE("dl", tout << body << "\n";);
// 3. abstract and quantify those variables that should be bound.
body = expr_abstract(bound, body);
body = m.mk_forall(names.size(), bound_sorts.c_ptr(), names.c_ptr(), body);
body = m.mk_forall(names.size(), bound_sorts.data(), names.data(), body);
TRACE("dl", tout << body << "\n";);
// 4. replace remaining constants by variables.
@ -198,7 +198,7 @@ namespace datalog {
bound.push_back(true);
sorts.push_back(s1);
}
arg = mk_select(arg, args.size(), args.c_ptr());
arg = mk_select(arg, args.size(), args.data());
s = get_array_range(s);
}
domain.push_back(s);
@ -207,7 +207,7 @@ namespace datalog {
sorts.push_back(s0);
}
SASSERT(old_p->get_range() == m.mk_bool_sort());
new_p = m.mk_func_decl(old_p->get_name(), domain.size(), domain.c_ptr(), old_p->get_range());
new_p = m.mk_func_decl(old_p->get_name(), domain.size(), domain.data(), old_p->get_range());
m_refs.push_back(new_p);
m_ctx.register_predicate(new_p, false);
if (m_mc) {
@ -234,7 +234,7 @@ namespace datalog {
for (unsigned j = 0; j < arity; ++j) {
args.push_back(m.mk_var(idx++, get_array_domain(s, j)));
}
arg = mk_select(arg, arity, args.c_ptr()+args.size()-arity);
arg = mk_select(arg, arity, args.data()+args.size()-arity);
s = get_array_range(s);
}
args.push_back(arg);
@ -244,7 +244,7 @@ namespace datalog {
for (unsigned i = 0; i < args.size(); ++i) {
tout << mk_pp(args[i].get(), m) << "\n";
});
return app_ref(m.mk_app(new_p, args.size(), args.c_ptr()), m);
return app_ref(m.mk_app(new_p, args.size(), args.data()), m);
}
app_ref mk_quantifier_abstraction::mk_tail(rule_set const& rules, rule_set& dst, app* p) {
@ -278,7 +278,7 @@ namespace datalog {
names.push_back(symbol(idx));
args.push_back(m.mk_var(idx++, vars.back()));
}
arg = mk_select(arg, arity, args.c_ptr()+args.size()-arity);
arg = mk_select(arg, arity, args.data()+args.size()-arity);
s = get_array_range(s);
}
if (is_pattern) {
@ -288,12 +288,12 @@ namespace datalog {
}
expr* pat = nullptr;
expr_ref pattern(m);
pattern = m.mk_pattern(pats.size(), pats.c_ptr());
pattern = m.mk_pattern(pats.size(), pats.data());
pat = pattern.get();
app_ref result(m);
symbol qid, skid;
result = m.mk_app(new_p, args.size(), args.c_ptr());
result = m.mk_eq(m.mk_forall(vars.size(), vars.c_ptr(), names.c_ptr(), result, 1, qid, skid, 1, &pat), m.mk_true());
result = m.mk_app(new_p, args.size(), args.data());
result = m.mk_eq(m.mk_forall(vars.size(), vars.data(), names.data(), result, 1, qid, skid, 1, &pat), m.mk_true());
return result;
}
@ -301,7 +301,7 @@ namespace datalog {
ptr_vector<expr> args2;
args2.push_back(arg);
args2.append(num_args, args);
return a.mk_select(args2.size(), args2.c_ptr());
return a.mk_select(args2.size(), args2.data());
}
rule_set * mk_quantifier_abstraction::operator()(rule_set const & source) {
@ -345,7 +345,7 @@ namespace datalog {
tail.push_back(r.get_tail(j));
}
head = mk_head(source, *result, r.get_head(), cnt);
fml = m.mk_implies(m.mk_and(tail.size(), tail.c_ptr()), head);
fml = m.mk_implies(m.mk_and(tail.size(), tail.data()), head);
proof_ref pr(m);
rm.mk_rule(fml, pr, *result, r.name());
TRACE("dl", result->last()->display(m_ctx, tout););

8
src/muz/transforms/dl_mk_quantifier_instantiation.cpp
View file

@ -156,7 +156,7 @@ namespace datalog {
SASSERT(m_binding[i]);
});
m_binding.reverse();
expr_ref res = instantiate(m, q, m_binding.c_ptr());
expr_ref res = instantiate(m, q, m_binding.data());
m_binding.reverse();
m_cnst2var(res);
conjs.push_back(res);
@ -205,7 +205,7 @@ namespace datalog {
m_terms.reset();
m_var2cnst.reset();
m_cnst2var.reset();
fml = m.mk_and(conjs.size(), conjs.c_ptr());
fml = m.mk_and(conjs.size(), conjs.data());
for (unsigned i = 0; i < sorts.size(); ++i) {
var = m.mk_var(i, sorts[i]);
@ -214,7 +214,7 @@ namespace datalog {
m_cnst2var.insert(cnst, var);
}
fml = m.mk_and(conjs.size(), conjs.c_ptr());
fml = m.mk_and(conjs.size(), conjs.data());
m_var2cnst(fml);
collect_egraph(fml);
@ -224,7 +224,7 @@ namespace datalog {
for (auto & kv : m_funs) dealloc(kv.m_value);
m_funs.reset();
fml = m.mk_and(conjs.size(), conjs.c_ptr());
fml = m.mk_and(conjs.size(), conjs.data());
fml = m.mk_implies(fml, r.get_head());
TRACE("dl", r.display(m_ctx, tout); tout << mk_pp(fml, m) << "\n";);

2
src/muz/transforms/dl_mk_rule_inliner.cpp
View file

@ -117,7 +117,7 @@ namespace datalog {
std::ostringstream comb_name;
comb_name << tgt.name().str() << ";" << src.name().str();
symbol combined_rule_name(comb_name.str());
res = m_rm.mk(new_head, tail.size(), tail.c_ptr(), tail_neg.c_ptr(), combined_rule_name, m_normalize);
res = m_rm.mk(new_head, tail.size(), tail.data(), tail_neg.data(), combined_rule_name, m_normalize);
res->set_accounting_parent_object(m_context, const_cast<rule*>(&tgt));
TRACE("dl",
tgt.display(m_context, tout << "tgt (" << tail_index << "): \n");

10
src/muz/transforms/dl_mk_scale.cpp
View file

@ -60,7 +60,7 @@ namespace datalog {
subst.push_back(a.mk_numeral(rational(1), a.mk_real()));
SASSERT(!new_fi->is_partial() && new_fi->num_entries() == 0);
tmp = vs(new_fi->get_else(), subst.size(), subst.c_ptr());
tmp = vs(new_fi->get_else(), subst.size(), subst.data());
if (old_p->get_arity() == 0) {
old_model->register_decl(old_p, tmp);
}
@ -154,7 +154,7 @@ namespace datalog {
tail.append(m_eqs);
tail.push_back(a.mk_gt(m.mk_var(num_vars, a.mk_real()), a.mk_numeral(rational(0), false)));
neg.resize(tail.size(), false);
new_rule = rm.mk(new_pred, tail.size(), tail.c_ptr(), neg.c_ptr(), r.name(), true);
new_rule = rm.mk(new_pred, tail.size(), tail.data(), neg.data(), r.name(), true);
result->add_rule(new_rule);
if (source.is_output_predicate(r.get_decl())) {
result->set_output_predicate(new_rule->get_decl());
@ -174,7 +174,7 @@ namespace datalog {
ptr_vector<sort> domain(f->get_arity(), f->get_domain());
domain.push_back(a.mk_real());
func_decl_ref g(m);
g = m.mk_func_decl(f->get_name(), f->get_arity() + 1, domain.c_ptr(), f->get_range());
g = m.mk_func_decl(f->get_name(), f->get_arity() + 1, domain.data(), f->get_range());
expr_ref_vector args(m);
for (unsigned i = 0; i < q->get_num_args(); ++i) {
expr* arg = q->get_arg(i);
@ -200,7 +200,7 @@ namespace datalog {
if (m_mc) {
m_mc->add_new2old(g, f);
}
return app_ref(m.mk_app(g, q->get_num_args() + 1, args.c_ptr()), m);
return app_ref(m.mk_app(g, q->get_num_args() + 1, args.data()), m);
}
app_ref mk_scale::mk_constraint(unsigned sigma_idx, app* q) {
@ -227,7 +227,7 @@ namespace datalog {
for (unsigned i = 0; i < ap->get_num_args(); ++i) {
args.push_back(linearize(sigma_idx, ap->get_arg(i)));
}
result = m.mk_app(ap->get_decl(), args.size(), args.c_ptr());
result = m.mk_app(ap->get_decl(), args.size(), args.data());
}
else if (a.is_numeral(e)) {
result = a.mk_mul(m.mk_var(sigma_idx, a.mk_real()), e);

6
src/muz/transforms/dl_mk_separate_negated_tails.cpp
View file

@ -67,9 +67,9 @@ namespace datalog {
sorts.push_back(arg->get_sort());
}
}
fn = m.mk_fresh_func_decl(p->get_decl()->get_name(), symbol("N"), sorts.size(), sorts.c_ptr(), m.mk_bool_sort());
fn = m.mk_fresh_func_decl(p->get_decl()->get_name(), symbol("N"), sorts.size(), sorts.data(), m.mk_bool_sort());
m_ctx.register_predicate(fn, false);
q = m.mk_app(fn, args.size(), args.c_ptr());
q = m.mk_app(fn, args.size(), args.data());
bool is_neg = true;
rules.add_rule(rm.mk(q, 1, & p, &is_neg));
}
@ -101,7 +101,7 @@ namespace datalog {
tail.push_back(r.get_tail(i));
neg.push_back(false);
}
rules.add_rule(rm.mk(r.get_head(), tail.size(), tail.c_ptr(), neg.c_ptr(), r.name()));
rules.add_rule(rm.mk(r.get_head(), tail.size(), tail.data(), neg.data(), r.name()));
}
rule_set * mk_separate_negated_tails::operator()(rule_set const& src) {

16
src/muz/transforms/dl_mk_slice.cpp
View file

@ -240,7 +240,7 @@ namespace datalog {
r1 = r3;
}
rm.to_formula(*r1.get(), concl);
proof* new_p = m.mk_hyper_resolve(premises.size(), premises.c_ptr(), concl, positions, substs);
proof* new_p = m.mk_hyper_resolve(premises.size(), premises.data(), concl, positions, substs);
m_pinned_exprs.push_back(new_p);
m_pinned_rules.push_back(r1.get());
TRACE("dl",
@ -352,7 +352,7 @@ namespace datalog {
}
if (!new_fi->is_partial()) {
TRACE("dl", tout << mk_pp(new_fi->get_else(), m) << "\n";);
tmp = vs(new_fi->get_else(), subst.size(), subst.c_ptr());
tmp = vs(new_fi->get_else(), subst.size(), subst.data());
old_fi->set_else(tmp);
}
unsigned num_entries = new_fi->num_entries();
@ -362,7 +362,7 @@ namespace datalog {
func_entry const* e = new_fi->get_entry(j);
for (unsigned k = 0, l = 0; k < old_p->get_arity(); ++k) {
if (!is_sliced.get(k)) {
tmp = vs(e->get_arg(l++), subst.size(), subst.c_ptr());
tmp = vs(e->get_arg(l++), subst.size(), subst.data());
args.push_back(tmp);
}
else {
@ -370,8 +370,8 @@ namespace datalog {
}
SASSERT(l <= new_p->get_arity());
}
res = vs(e->get_result(), subst.size(), subst.c_ptr());
old_fi->insert_entry(args.c_ptr(), res.get());
res = vs(e->get_result(), subst.size(), subst.data());
old_fi->insert_entry(args.data(), res.get());
}
old_model->register_decl(old_p, old_fi);
}
@ -731,7 +731,7 @@ namespace datalog {
}
}
if (domain.size() < bv.size()) {
f = m_ctx.mk_fresh_head_predicate(p->get_name(), symbol("slice"), domain.size(), domain.c_ptr(), p);
f = m_ctx.mk_fresh_head_predicate(p->get_name(), symbol("slice"), domain.size(), domain.data(), p);
m_pinned.push_back(f);
m_predicates.insert(p, f);
dst.inherit_predicate(src, p, f);
@ -768,7 +768,7 @@ namespace datalog {
args.push_back(p->get_arg(i));
}
}
q = m.mk_app(qd, args.size(), args.c_ptr());
q = m.mk_app(qd, args.size(), args.data());
}
else {
q = p;
@ -797,7 +797,7 @@ namespace datalog {
tail.push_back(to_app(e));
}
new_rule = rm.mk(head.get(), tail.size(), tail.c_ptr(), (const bool*) nullptr, r.name());
new_rule = rm.mk(head.get(), tail.size(), tail.data(), (const bool*) nullptr, r.name());
rm.fix_unbound_vars(new_rule, false);

4
src/muz/transforms/dl_mk_subsumption_checker.cpp
View file

@ -164,7 +164,7 @@ namespace datalog {
}
SASSERT(tail.size()==tail_neg.size());
res = m_context.get_rule_manager().mk(head, tail.size(), tail.c_ptr(), tail_neg.c_ptr(), r->name());
res = m_context.get_rule_manager().mk(head, tail.size(), tail.data(), tail_neg.data(), r->name());
res->set_accounting_parent_object(m_context, r);
m_context.get_rule_manager().fix_unbound_vars(res, true);
m_context.get_rule_manager().mk_rule_rewrite_proof(*r, *res.get());
@ -189,7 +189,7 @@ namespace datalog {
//before traversing we sort rules so that the shortest are in the beginning.
//this will help make subsumption checks more efficient
std::sort(orig_rules.c_ptr(), orig_rules.c_ptr() + orig_rules.size(), rule_size_comparator);
std::sort(orig_rules.data(), orig_rules.data() + orig_rules.size(), rule_size_comparator);
for (rule * r : orig_rules) {
func_decl * head_pred = r->get_decl();

10
src/muz/transforms/dl_mk_synchronize.cpp
View file

@ -82,7 +82,7 @@ namespace datalog {
was_added = true;
func_decl* orig = decls_buf[0];
func_decl* product_pred = m_ctx.mk_fresh_head_predicate(new_name,
symbol::null, domain.size(), domain.c_ptr(), orig);
symbol::null, domain.size(), domain.data(), orig);
m_cache.insert(new_name, product_pred);
}
return;
@ -130,7 +130,7 @@ namespace datalog {
rule_ref new_rule(rm);
new_rule = rm.mk(r.get_head(), tail_idx + 1,
new_tail.c_ptr(), new_tail_neg.c_ptr(), symbol::null, false);
new_tail.data(), new_tail_neg.data(), symbol::null, false);
rules.replace_rule(&r, new_rule.get());
}
@ -150,7 +150,7 @@ namespace datalog {
rule_ref new_rule(rm);
new_rule = rm.mk(r);
rm.substitute(new_rule, revsub.size(), revsub.c_ptr());
rm.substitute(new_rule, revsub.size(), revsub.data());
return new_rule;
}
@ -246,7 +246,7 @@ namespace datalog {
args[idx] = a->get_arg(i);
}
return app_ref(m.mk_app(pred, args_num, args.c_ptr()), m);
return app_ref(m.mk_app(pred, args_num, args.data()), m);
}
rule_ref mk_synchronize::product_rule(rule_ref_vector const & rules) {
@ -302,7 +302,7 @@ namespace datalog {
rule_ref new_rule(rm);
new_rule = rm.mk(product_head, tail_idx + 1,
new_tail.c_ptr(), new_tail_neg.c_ptr(), symbol(buffer.c_str()), false);
new_tail.data(), new_tail_neg.data(), symbol(buffer.c_str()), false);
rm.fix_unbound_vars(new_rule, false);
return new_rule;
}

8
src/muz/transforms/dl_mk_unbound_compressor.cpp
View file

@ -72,7 +72,7 @@ namespace datalog {
name_suffix << "compr_arg_" << arg_index;
func_decl * cpred = m_context.mk_fresh_head_predicate(parent_name, symbol(name_suffix.str()),
arity, domain.c_ptr(), pred);
arity, domain.data(), pred);
m_pinned.push_back(cpred);
m_pinned.push_back(pred);
@ -154,7 +154,7 @@ namespace datalog {
}
}
app_ref chead(m.mk_app(cpred, head_arity-1, cargs.c_ptr()), m);
app_ref chead(m.mk_app(cpred, head_arity-1, cargs.data()), m);
m_modified = true;
if (r->get_tail_size()==0 && m_context.get_rule_manager().is_fact(chead)) {
@ -203,7 +203,7 @@ namespace datalog {
}
}
SASSERT(dtail_args.size()==dtail_pred->get_arity());
app_ref dtail(m.mk_app(dtail_pred, dtail_args.size(), dtail_args.c_ptr()), m);
app_ref dtail(m.mk_app(dtail_pred, dtail_args.size(), dtail_args.data()), m);
bool_vector tails_negated;
app_ref_vector tails(m);
@ -225,7 +225,7 @@ namespace datalog {
tails.push_back(dtail);
}
res = m_context.get_rule_manager().mk( r->get_head(), tails.size(), tails.c_ptr(), tails_negated.c_ptr());
res = m_context.get_rule_manager().mk( r->get_head(), tails.size(), tails.data(), tails_negated.data());
res->set_accounting_parent_object(m_context, r);
m_context.get_rule_manager().fix_unbound_vars(res, true);
return res;