mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-29 20: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/cmd_context/basic_cmds.cpp
View file

@ -798,15 +798,15 @@ public:
unsigned arity = m_f->get_arity();
for (unsigned i = 0; i < arity; i++) {
array_sort_args.push_back(m_f->get_domain(i));
domain.push_back(array_sort->instantiate(ctx.pm(), array_sort_args.size(), array_sort_args.c_ptr()));
domain.push_back(array_sort->instantiate(ctx.pm(), array_sort_args.size(), array_sort_args.data()));
array_sort_args.pop_back();
}
sort_ref range(ctx.m());
array_sort_args.push_back(m_f->get_range());
range = array_sort->instantiate(ctx.pm(), array_sort_args.size(), array_sort_args.c_ptr());
range = array_sort->instantiate(ctx.pm(), array_sort_args.size(), array_sort_args.data());
parameter p[1] = { parameter(m_f) };
func_decl_ref new_map(ctx.m());
new_map = ctx.m().mk_func_decl(get_array_fid(ctx), OP_ARRAY_MAP, 1, p, domain.size(), domain.c_ptr(), range.get());
new_map = ctx.m().mk_func_decl(get_array_fid(ctx), OP_ARRAY_MAP, 1, p, domain.size(), domain.data(), range.get());
if (new_map == 0)
throw cmd_exception("invalid array map operator");
ctx.insert(m_name, new_map);
@ -836,8 +836,8 @@ public:
void execute(cmd_context & ctx) override {
ast_manager& m = ctx.m();
expr_ref_vector assumptions(m), variables(m), consequences(m);
assumptions.append(m_assumptions.size(), m_assumptions.c_ptr());
variables.append(m_variables.size(), m_variables.c_ptr());
assumptions.append(m_assumptions.size(), m_assumptions.data());
variables.append(m_variables.size(), m_variables.data());
ctx.get_consequences(assumptions, variables, consequences);
ctx.regular_stream() << consequences << "\n";
}

8
src/cmd_context/cmd_context.cpp
View file

@ -252,7 +252,7 @@ func_decl * func_decls::find(ast_manager & m, unsigned num_args, expr * const *
return nullptr;
sorts.push_back(args[i]->get_sort());
}
return find(m, num_args, sorts.c_ptr(), range);
return find(m, num_args, sorts.data(), range);
}
unsigned func_decls::get_num_entries() const {
@ -982,7 +982,7 @@ void cmd_context::insert_rec_fun(func_decl* f, expr_ref_vector const& binding, s
recfun::promise_def d = p.get_promise_def(f);
recfun_replace replace(m());
p.set_definition(replace, d, vars.size(), vars.c_ptr(), rhs);
p.set_definition(replace, d, vars.size(), vars.data(), rhs);
}
func_decl * cmd_context::find_func_decl(symbol const & s) const {
@ -1060,7 +1060,7 @@ func_decl * cmd_context::find_func_decl(symbol const & s, unsigned num_indices,
buffer<parameter> ps;
for (unsigned i = 0; i < num_indices; i++)
ps.push_back(parameter(indices[i]));
f = m().mk_func_decl(fid, k, num_indices, ps.c_ptr(), arity, domain, range);
f = m().mk_func_decl(fid, k, num_indices, ps.data(), arity, domain, range);
}
if (f == nullptr)
throw cmd_exception("invalid function declaration reference, invalid builtin reference ", s);
@ -1873,7 +1873,7 @@ void cmd_context::complete_model(model_ref& md) const {
SASSERT(!v->has_var_params());
IF_VERBOSE(12, verbose_stream() << "(model.completion " << k << ")\n"; );
ptr_vector<sort> param_sorts(v->get_num_params(), m().mk_bool_sort());
sort * srt = v->instantiate(*m_pmanager, param_sorts.size(), param_sorts.c_ptr());
sort * srt = v->instantiate(*m_pmanager, param_sorts.size(), param_sorts.data());
if (!md->has_uninterpreted_sort(srt)) {
expr * singleton = m().get_some_value(srt);
md->register_usort(srt, 1, &singleton);

4
src/cmd_context/extra_cmds/dbg_cmds.cpp
View file

@ -123,7 +123,7 @@ public:
}
void execute(cmd_context & ctx) override {
beta_reducer p(ctx.m());
expr_ref r = p(m_source, m_subst.size(), m_subst.c_ptr());
expr_ref r = p(m_source, m_subst.size(), m_subst.data());
store_expr_ref(ctx, m_target, r.get());
}
};
@ -304,7 +304,7 @@ public:
}
void execute(cmd_context & ctx) override {
expr_ref r = instantiate(ctx.m(), m_q, m_args.c_ptr());
expr_ref r = instantiate(ctx.m(), m_q, m_args.data());
ctx.display(ctx.regular_stream(), r);
ctx.regular_stream() << std::endl;
}

36
src/cmd_context/pdecl.cpp
View file

@ -203,7 +203,7 @@ class psort_app : public psort {
void finalize(pdecl_manager & m) override {
m.lazy_dec_ref(m_decl);
m.lazy_dec_ref(m_args.size(), m_args.c_ptr());
m.lazy_dec_ref(m_args.size(), m_args.data());
psort::finalize(m);
}
@ -227,7 +227,7 @@ class psort_app : public psort {
sort * a = m_args[i]->instantiate(m, n, s);
args_i.push_back(a);
}
r = m_decl->instantiate(m, args_i.size(), args_i.c_ptr());
r = m_decl->instantiate(m, args_i.size(), args_i.data());
cache(m, s, r);
return r;
}
@ -321,7 +321,7 @@ sort * psort_user_decl::instantiate(pdecl_manager & m, unsigned n, sort * const
buffer<parameter> ps;
for (unsigned i = 0; i < n; i++)
ps.push_back(parameter(s[i]));
r = m.m().mk_uninterpreted_sort(m_name, ps.size(), ps.c_ptr());
r = m.m().mk_uninterpreted_sort(m_name, ps.size(), ps.data());
}
else {
r = m_def->instantiate(m, n, s);
@ -388,7 +388,7 @@ sort * psort_builtin_decl::instantiate(pdecl_manager & m, unsigned n, sort * con
buffer<parameter> params;
for (unsigned i = 0; i < n; i++)
params.push_back(parameter(s[i]));
sort * r = m.m().mk_sort(m_fid, m_kind, n, params.c_ptr());
sort * r = m.m().mk_sort(m_fid, m_kind, n, params.data());
m.save_info(r, this, n, s);
return r;
}
@ -404,7 +404,7 @@ sort * psort_builtin_decl::instantiate(pdecl_manager & m, unsigned n, unsigned c
buffer<parameter> params;
for (unsigned i = 0; i < n; i++)
params.push_back(parameter(s[i]));
sort * r = m.m().mk_sort(m_fid, m_kind, n, params.c_ptr());
sort * r = m.m().mk_sort(m_fid, m_kind, n, params.data());
m.save_info(r, this, n, s);
return r;
}
@ -488,7 +488,7 @@ pconstructor_decl::pconstructor_decl(unsigned id, unsigned num_params, pdecl_man
}
void pconstructor_decl::finalize(pdecl_manager & m) {
m.lazy_dec_ref(m_accessors.size(), m_accessors.c_ptr());
m.lazy_dec_ref(m_accessors.size(), m_accessors.data());
}
bool pconstructor_decl::has_missing_refs(symbol & missing) const {
@ -511,7 +511,7 @@ constructor_decl * pconstructor_decl::instantiate_decl(pdecl_manager & m, unsign
ptr_buffer<accessor_decl> as;
for (paccessor_decl* a : m_accessors)
as.push_back(a->instantiate_decl(m, n, s));
return mk_constructor_decl(m_name, m_recogniser_name, as.size(), as.c_ptr());
return mk_constructor_decl(m_name, m_recogniser_name, as.size(), as.data());
}
void pconstructor_decl::display(std::ostream & out, pdatatype_decl const * const * dts) const {
@ -532,7 +532,7 @@ pdatatype_decl::pdatatype_decl(unsigned id, unsigned num_params, pdecl_manager &
}
void pdatatype_decl::finalize(pdecl_manager & m) {
m.lazy_dec_ref(m_constructors.size(), m_constructors.c_ptr());
m.lazy_dec_ref(m_constructors.size(), m_constructors.data());
psort_decl::finalize(m);
}
@ -573,12 +573,12 @@ datatype_decl * pdatatype_decl::instantiate_decl(pdecl_manager & m, unsigned n,
cs.push_back(c->instantiate_decl(m, n, s));
}
datatype_util util(m.m());
return mk_datatype_decl(util, m_name, m_num_params, s, cs.size(), cs.c_ptr());
return mk_datatype_decl(util, m_name, m_num_params, s, cs.size(), cs.data());
}
struct datatype_decl_buffer {
ptr_buffer<datatype_decl> m_buffer;
~datatype_decl_buffer() { del_datatype_decls(m_buffer.size(), m_buffer.c_ptr()); }
~datatype_decl_buffer() { del_datatype_decls(m_buffer.size(), m_buffer.data()); }
};
@ -603,7 +603,7 @@ sort * pdatatype_decl::instantiate(pdecl_manager & m, unsigned n, sort * const *
for (unsigned j = 0; j < util.get_datatype_num_parameter_sorts(rng); ++j) {
ps.push_back(util.get_datatype_parameter_sort(acc->get_range(), j));
}
m.instantiate_datatype(p, p->get_name(), ps.size(), ps.c_ptr());
m.instantiate_datatype(p, p->get_name(), ps.size(), ps.data());
break;
}
}
@ -641,10 +641,10 @@ bool pdatatype_decl::commit(pdecl_manager& m) {
ps.push_back(m.m().mk_uninterpreted_sort(symbol(i), 0, nullptr));
}
datatype_decl_buffer dts;
dts.m_buffer.push_back(instantiate_decl(m, ps.size(), ps.c_ptr()));
dts.m_buffer.push_back(instantiate_decl(m, ps.size(), ps.data()));
datatype_decl * d_ptr = dts.m_buffer[0];
sort_ref_vector sorts(m.m());
bool is_ok = m.get_dt_plugin()->mk_datatypes(1, &d_ptr, m_num_params, ps.c_ptr(), sorts);
bool is_ok = m.get_dt_plugin()->mk_datatypes(1, &d_ptr, m_num_params, ps.data(), sorts);
if (is_ok && m_num_params == 0) {
m.notify_new_dt(sorts.get(0), this);
}
@ -665,7 +665,7 @@ pdatatypes_decl::pdatatypes_decl(unsigned id, unsigned num_params, pdecl_manager
}
void pdatatypes_decl::finalize(pdecl_manager & m) {
m.lazy_dec_ref(m_datatypes.size(), m_datatypes.c_ptr());
m.lazy_dec_ref(m_datatypes.size(), m_datatypes.data());
}
bool pdatatypes_decl::fix_missing_refs(symbol & missing) {
@ -694,7 +694,7 @@ sort* pdecl_manager::instantiate_datatype(psort_decl* p, symbol const& name, uns
for (unsigned i = 0; i < n; i++)
ps.push_back(parameter(s[i]));
datatype_util util(m.m());
r = m.m().mk_sort(util.get_family_id(), DATATYPE_SORT, ps.size(), ps.c_ptr());
r = m.m().mk_sort(util.get_family_id(), DATATYPE_SORT, ps.size(), ps.data());
p->cache(m, s, r);
m.save_info(r, p, n, s);
notify_datatype(r, p, n, s);
@ -746,10 +746,10 @@ bool pdatatypes_decl::commit(pdecl_manager& m) {
for (unsigned i = 0; i < d->get_num_params(); ++i) {
ps.push_back(m.m().mk_uninterpreted_sort(symbol(i), 0, nullptr));
}
dts.m_buffer.push_back(d->instantiate_decl(m, ps.size(), ps.c_ptr()));
dts.m_buffer.push_back(d->instantiate_decl(m, ps.size(), ps.data()));
}
sort_ref_vector sorts(m.m());
bool is_ok = m.get_dt_plugin()->mk_datatypes(m_datatypes.size(), dts.m_buffer.c_ptr(), 0, nullptr, sorts);
bool is_ok = m.get_dt_plugin()->mk_datatypes(m_datatypes.size(), dts.m_buffer.data(), 0, nullptr, sorts);
if (is_ok) {
for (unsigned i = 0; i < m_datatypes.size(); ++i) {
pdatatype_decl* d = m_datatypes[i];
@ -790,7 +790,7 @@ struct pdecl_manager::app_sort_info : public pdecl_manager::sort_info {
void finalize(pdecl_manager & m) override {
sort_info::finalize(m);
m.m().dec_array_ref(m_args.size(), m_args.c_ptr());
m.m().dec_array_ref(m_args.size(), m_args.data());
}
void display(std::ostream & out, pdecl_manager const & m) const override {

2
src/cmd_context/pdecl.h
View file

@ -257,7 +257,7 @@ class pdatatypes_decl : public pdecl {
bool instantiate(pdecl_manager & m, sort * const * s);
~pdatatypes_decl() override {}
public:
pdatatype_decl const * const * children() const { return m_datatypes.c_ptr(); }
pdatatype_decl const * const * children() const { return m_datatypes.data(); }
pdatatype_decl * const * begin() const { return m_datatypes.begin(); }
pdatatype_decl * const * end() const { return m_datatypes.end(); }
// commit declaration

16
src/cmd_context/tactic_cmds.cpp
View file

@ -242,7 +242,7 @@ public:
if (ctx.produce_unsat_cores()) {
ptr_vector<expr> core_elems;
m.linearize(core, core_elems);
result->m_core.append(core_elems.size(), core_elems.c_ptr());
result->m_core.append(core_elems.size(), core_elems.data());
if (p.get_bool("print_unsat_core", false)) {
ctx.regular_stream() << "(unsat-core";
for (expr * e : core_elems) {
@ -359,7 +359,7 @@ public:
for (unsigned i = 0; i < sz; i++) {
assertions.push_back(fg->form(i));
}
ctx.display_smt2_benchmark(ctx.regular_stream(), assertions.size(), assertions.c_ptr());
ctx.display_smt2_benchmark(ctx.regular_stream(), assertions.size(), assertions.data());
}
else {
// create a big OR
@ -371,10 +371,10 @@ public:
if (formulas.size() == 1)
or_args.push_back(formulas[0]);
else
or_args.push_back(m.mk_and(formulas.size(), formulas.c_ptr()));
or_args.push_back(m.mk_and(formulas.size(), formulas.data()));
}
expr_ref assertion_ref(m);
assertion_ref = m.mk_or(or_args.size(), or_args.c_ptr());
assertion_ref = m.mk_or(or_args.size(), or_args.data());
expr * assertions[1] = { assertion_ref.get() };
ctx.display_smt2_benchmark(ctx.regular_stream(), 1, assertions);
}
@ -412,7 +412,7 @@ static tactic * mk_and_then(cmd_context & ctx, sexpr * n) {
tactic_ref_buffer args;
for (unsigned i = 1; i < num_children; i++)
args.push_back(sexpr2tactic(ctx, n->get_child(i)));
return and_then(args.size(), args.c_ptr());
return and_then(args.size(), args.data());
}
static tactic * mk_or_else(cmd_context & ctx, sexpr * n) {
@ -425,7 +425,7 @@ static tactic * mk_or_else(cmd_context & ctx, sexpr * n) {
tactic_ref_buffer args;
for (unsigned i = 1; i < num_children; i++)
args.push_back(sexpr2tactic(ctx, n->get_child(i)));
return or_else(args.size(), args.c_ptr());
return or_else(args.size(), args.data());
}
static tactic * mk_par(cmd_context & ctx, sexpr * n) {
@ -438,7 +438,7 @@ static tactic * mk_par(cmd_context & ctx, sexpr * n) {
tactic_ref_buffer args;
for (unsigned i = 1; i < num_children; i++)
args.push_back(sexpr2tactic(ctx, n->get_child(i)));
return par(args.size(), args.c_ptr());
return par(args.size(), args.data());
}
static tactic * mk_par_then(cmd_context & ctx, sexpr * n) {
@ -451,7 +451,7 @@ static tactic * mk_par_then(cmd_context & ctx, sexpr * n) {
tactic_ref_buffer args;
for (unsigned i = 1; i < num_children; i++)
args.push_back(sexpr2tactic(ctx, n->get_child(i)));
return par_and_then(args.size(), args.c_ptr());
return par_and_then(args.size(), args.data());
}
static tactic * mk_try_for(cmd_context & ctx, sexpr * n) {