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

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);