mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-23 09:05:31 +00:00
Code Activity

remove using insert_if_not_there2

Browse source 
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner 2020-04-25 15:08:51 -07:00
parent 9ea1cf3c5c
commit a884201d62
47 changed files with 172 additions and 208 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -74,8 +74,7 @@ namespace datalog {
unsigned newIdx = m_el_numbers.size();
sym2num::entry* sym_e = m_el_numbers.insert_if_not_there2(sym, newIdx);
unsigned idx=sym_e->get_data().m_value;
unsigned idx = m_el_numbers.insert_if_not_there(sym, newIdx);
if (idx==newIdx) {
m_el_names.push_back(sym);
@ -117,10 +116,9 @@ namespace datalog {
unsigned newIdx = m_el_numbers.size();
el2num::entry* sym_e = m_el_numbers.insert_if_not_there2(el, newIdx);
unsigned idx=sym_e->get_data().m_value;
unsigned idx = m_el_numbers.insert_if_not_there(el, newIdx);
if (idx==newIdx) {
if (idx == newIdx) {
m_el_names.push_back(el);
SASSERT(m_el_names.size()==m_el_numbers.size());
}
@ -1315,8 +1313,7 @@ namespace datalog {
// index into fresh variable array.
// unsigned fresh_var_idx = 0;
obj_map<sort, unsigned_vector>::obj_map_entry* e = var_idxs.insert_if_not_there2(s, unsigned_vector());
unsigned_vector& vars = e->get_data().m_value;
unsigned_vector& vars = var_idxs.insert_if_not_there(s, unsigned_vector());
if (max_var >= vars.size()) {
SASSERT(vars.size() == max_var);
vars.push_back(fresh_vars.size());

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

@ -64,11 +64,11 @@ namespace datalog {
}
rule_dependencies::item_set & rule_dependencies::ensure_key(func_decl * pred) {
deps_type::obj_map_entry * e = m_data.insert_if_not_there2(pred, 0);
if (!e->get_data().m_value) {
e->get_data().m_value = alloc(item_set);
auto& value = m_data.insert_if_not_there(pred, 0);
if (!value) {
value = alloc(item_set);
}
return *e->get_data().m_value;
return *value;
}
void rule_dependencies::insert(func_decl * depending, func_decl * master) {
@ -324,9 +324,9 @@ namespace datalog {
app * head = r->get_head();
SASSERT(head != 0);
func_decl * d = head->get_decl();
decl2rules::obj_map_entry* e = m_head2rules.insert_if_not_there2(d, 0);
if (!e->get_data().m_value) e->get_data().m_value = alloc(ptr_vector<rule>);
e->get_data().m_value->push_back(r);
auto& value = m_head2rules.insert_if_not_there(d, 0);
if (!value) value = alloc(ptr_vector<rule>);
value->push_back(r);
}
void rule_set::del_rule(rule * r) {

16
src/muz/dataflow/dataflow.h
View file

@ -65,15 +65,15 @@ namespace datalog {
for (rule* cur : m_rules) {
for (unsigned i = 0; i < cur->get_uninterpreted_tail_size(); ++i) {
func_decl *d = cur->get_decl(i);
rule_set::decl2rules::obj_map_entry *e = m_body2rules.insert_if_not_there2(d, 0);
if (!e->get_data().m_value) {
e->get_data().m_value = alloc(ptr_vector<rule>);
auto& value = m_body2rules.insert_if_not_there(d, nullptr);
if (!value) {
value = alloc(ptr_vector<rule>);
}
e->get_data().m_value->push_back(cur);
value->push_back(cur);
}
if (cur->get_positive_tail_size() == 0) {
func_decl *sym = cur->get_head()->get_decl();
bool new_info = m_facts.insert_if_not_there2(sym, Fact())->get_data().m_value.init_up(m_context, cur);
bool new_info = m_facts.insert_if_not_there(sym, Fact()).init_up(m_context, cur);
if (new_info) {
m_todo[m_todo_idx].insert(sym);
}
@ -86,7 +86,7 @@ namespace datalog {
TRACE("dl", tout << sym->get_name() << "\n";);
const rule_vector& output_rules = m_rules.get_predicate_rules(sym);
for (rule* r : output_rules) {
m_facts.insert_if_not_there2(sym, Fact())->get_data().m_value.init_down(m_context, r);
m_facts.insert_if_not_there(sym, Fact()).init_down(m_context, r);
m_todo[m_todo_idx].insert(sym);
}
}
@ -100,7 +100,7 @@ namespace datalog {
for (rule* r : *rules) {
func_decl* head_sym = r->get_head()->get_decl();
fact_reader<Fact> tail_facts(m_facts, r);
bool new_info = m_facts.insert_if_not_there2(head_sym, Fact())->get_data().m_value.propagate_up(m_context, r, tail_facts);
bool new_info = m_facts.insert_if_not_there(head_sym, Fact()).propagate_up(m_context, r, tail_facts);
if (new_info) {
m_todo[!m_todo_idx].insert(head_sym);
}
@ -238,7 +238,7 @@ namespace datalog {
Fact& get(unsigned idx) {
func_decl *sym = m_rule->get_decl(idx);
return m_facts.insert_if_not_there2(sym, Fact())->get_data().m_value;
return m_facts.insert_if_not_there(sym, Fact());
}
void set_changed(unsigned idx) {

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

@ -1188,11 +1188,11 @@ class wpa_parser_impl : public wpa_parser, dparser {
bool m_use_map_names;
uint64_set& ensure_sort_content(symbol sort_name) {
sym2nums::entry * e = m_sort_contents.insert_if_not_there2(sort_name, nullptr);
if(!e->get_data().m_value) {
e->get_data().m_value = alloc(uint64_set);
auto& value = m_sort_contents.insert_if_not_there(sort_name, nullptr);
if (!value) {
value = alloc(uint64_set);
}
return *e->get_data().m_value;
return *value;
}
public:
@ -1527,10 +1527,10 @@ private:
sort_elements.insert(num);
if(m_use_map_names) {
num2sym::entry * e = m_number_names.insert_if_not_there2(num, el_name);
if(e->get_data().m_value!=el_name) {
auto const & value = m_number_names.insert_if_not_there(num, el_name);
if (value!=el_name) {
warning_msg("mismatch of number names on line %d in file %s. old: \"%s\" new: \"%s\"",
m_current_line, fname.c_str(), e->get_data().m_value.bare_str(), el_name.bare_str());
m_current_line, fname.c_str(), value.bare_str(), el_name.bare_str());
}
}
}

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

@ -37,15 +37,15 @@ namespace datalog {
}
void compiler::ensure_predicate_loaded(func_decl * pred, instruction_block & acc) {
pred2idx::obj_map_entry * e = m_pred_regs.insert_if_not_there2(pred, UINT_MAX);
if(e->get_data().m_value!=UINT_MAX) {
auto& value = m_pred_regs.insert_if_not_there(pred, UINT_MAX);
if (value != UINT_MAX) {
//predicate is already loaded
return;
}
relation_signature sig;
m_context.get_rel_context()->get_rmanager().from_predicate(pred, sig);
reg_idx reg = get_fresh_register(sig);
e->get_data().m_value=reg;
value = reg;
acc.push_back(instruction::mk_load(m_context.get_manager(), pred, reg));
}
@ -570,8 +570,8 @@ namespace datalog {
else {
SASSERT(is_var(exp));
unsigned var_num=to_var(exp)->get_idx();
int2ints::entry * e = var_indexes.insert_if_not_there2(var_num, unsigned_vector());
e->get_data().m_value.push_back(i);
auto& value = var_indexes.insert_if_not_there(var_num, unsigned_vector());
value.push_back(i);
}
}
}
@ -631,8 +631,8 @@ namespace datalog {
src_col = single_res_expr.size();
single_res_expr.push_back(m.mk_var(v, unbound_sort));
entry = var_indexes.insert_if_not_there2(v, unsigned_vector());
entry->get_data().m_value.push_back(src_col);
var_indexes.insert_if_not_there(v, unsigned_vector()).push_back(src_col);
}
relation_sort var_sort = m_reg_signatures[filtered_res][src_col];
binding[m_free_vars.size()-v] = m.mk_var(src_col, var_sort);
@ -790,7 +790,7 @@ namespace datalog {
unsigned unbound_column_index = single_res_expr.size();
single_res_expr.push_back(m.mk_var(v, unbound_sort));
e = var_indexes.insert_if_not_there2(v, unsigned_vector());
e = var_indexes.insert_if_not_there3(v, unsigned_vector());
e->get_data().m_value.push_back(unbound_column_index);
}
unsigned src_col=e->get_data().m_value.back();

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

@ -676,21 +676,21 @@ namespace datalog {
}
func_decl * mk_explanations::get_e_decl(func_decl * orig_decl) {
decl_map::obj_map_entry * e = m_e_decl_map.insert_if_not_there2(orig_decl, 0);
if (e->get_data().m_value == nullptr) {
auto& value = m_e_decl_map.insert_if_not_there(orig_decl, 0);
if (value == nullptr) {
relation_signature e_domain;
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);
m_pinned.push_back(new_decl);
e->get_data().m_value = new_decl;
value = new_decl;
if (m_relation_level) {
assign_rel_level_kind(new_decl, orig_decl);
}
}
return e->get_data().m_value;
return value;
}
app * mk_explanations::get_e_lit(app * lit, unsigned e_var_idx) {

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

@ -259,8 +259,7 @@ namespace datalog {
*/
void register_pair(app * t1, app * t2, rule * r, const var_idx_set & non_local_vars) {
SASSERT (t1 != t2);
cost_map::entry * e = m_costs.insert_if_not_there2(get_key(t1, t2), nullptr);
pair_info * & ptr_inf = e->get_data().m_value;
pair_info * & ptr_inf = m_costs.insert_if_not_there(get_key(t1, t2), nullptr);
if (ptr_inf == nullptr) {
ptr_inf = alloc(pair_info);
}
@ -296,8 +295,7 @@ namespace datalog {
counter.count_rule_vars(r, 1);
TRACE("dl", tout << "counter: "; for (auto const& kv: counter) tout << kv.m_key << ": " << kv.m_value << " "; tout << "\n";);
ptr_vector<app> & rule_content =
m_rules_content.insert_if_not_there2(r, ptr_vector<app>())->get_data().m_value;
ptr_vector<app> & rule_content = m_rules_content.insert_if_not_there(r, ptr_vector<app>());
SASSERT(rule_content.empty());
TRACE("dl", r->display(m_context, tout << "register "););

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

@ -105,14 +105,14 @@ namespace datalog {
void relation_manager::store_relation(func_decl * pred, relation_base * rel) {
SASSERT(rel);
relation_map::obj_map_entry * e = m_relations.insert_if_not_there2(pred, 0);
if (e->get_data().m_value) {
e->get_data().m_value->deallocate();
auto& value = m_relations.insert_if_not_there(pred, 0);
if (value) {
value->deallocate();
}
else {
get_context().get_manager().inc_ref(pred); //dec_ref in reset
}
e->get_data().m_value = rel;
value = rel;
}
decl_set relation_manager::collect_predicates() const {

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

@ -673,7 +673,7 @@ namespace datalog {
family_id get_relation_kind(const relation_signature & sig, const Spec & spec) {
typename sig2store::entry * e = m_kind_assignment.find_core(sig);
if(!e) {
e = m_kind_assignment.insert_if_not_there2(sig, alloc(family_id_idx_store));
e = m_kind_assignment.insert_if_not_there3(sig, alloc(family_id_idx_store));
m_kind_specs.insert(sig, alloc(family_id2spec));
}
family_id_idx_store & ids = *e->get_data().m_value;

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

@ -302,7 +302,7 @@ namespace datalog {
index_map::entry * e = m_map.find_core(ofs);
if (!e) {
TRACE("dl_table_relation", tout << "inserting\n";);
e = m_map.insert_if_not_there2(ofs, offset_vector());
e = m_map.insert_if_not_there3(ofs, offset_vector());
}
return e->get_data().m_value;
}
@ -473,7 +473,7 @@ namespace datalog {
#endif
key_spec kspec;
kspec.append(key_len, key_cols);
key_index_map::entry * key_map_entry = m_key_indexes.insert_if_not_there2(kspec, nullptr);
key_index_map::entry * key_map_entry = m_key_indexes.insert_if_not_there3(kspec, nullptr);
if (!key_map_entry->get_data().m_value) {
if (full_signature_key_indexer::can_handle(key_len, key_cols, *this)) {
key_map_entry->get_data().m_value = alloc(full_signature_key_indexer, key_len, key_cols, *this);
@ -777,8 +777,7 @@ namespace datalog {
const table_signature & sig = t->get_signature();
t->reset();
table_pool::entry * e = m_pool.insert_if_not_there2(sig, nullptr);
sp_table_vector * & vect = e->get_data().m_value;
sp_table_vector * & vect = m_pool.insert_if_not_there(sig, nullptr);
if (vect == nullptr) {
vect = alloc(sp_table_vector);
}

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

@ -2357,10 +2357,10 @@ void context::init_rules(datalog::rule_set& rules, decl2rel& rels)
func_decl* pred = dit->m_key;
TRACE("spacer", tout << mk_pp(pred, m) << "\n";);
SASSERT(!rels.contains(pred));
auto *e = rels.insert_if_not_there2(pred, alloc(pred_transformer, *this,
auto* pt = rels.insert_if_not_there(pred, alloc(pred_transformer, *this,
get_manager(), pred));
datalog::rule_vector const& pred_rules = *dit->m_value;
for (auto rule : pred_rules) {e->get_data().m_value->add_rule(rule);}
for (auto rule : pred_rules) {pt->add_rule(rule);}
}
// Allocate predicate transformers for predicates that are used

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

@ -128,7 +128,7 @@ void model_search::add_leaf(model_node* _n) {
model_node& n = *_n;
SASSERT(n.children().empty());
model_nodes ns;
model_nodes& nodes = cache(n).insert_if_not_there2(n.post(), ns)->get_data().m_value;
model_nodes& nodes = cache(n).insert_if_not_there(n.post(), ns);
if (nodes.contains(&n)) return;
nodes.push_back(_n);

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

@ -454,9 +454,7 @@ namespace tb {
unsigned idx = m_rules.size();
m_rules.push_back(g);
func_decl* f = g->get_decl();
map::obj_map_entry* e = m_index.insert_if_not_there2(f, unsigned_vector());
SASSERT(e);
e->get_data().m_value.push_back(idx);
m_index.insert_if_not_there(f, unsigned_vector()).push_back(idx);
}
unsigned get_num_rules(func_decl* p) const {

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

@ -79,8 +79,7 @@ namespace datalog {
filter_key * key = alloc(filter_key, m);
mk_new_rule_tail(m, pred, non_local_vars, filter_domain, key->filter_args, key->new_pred);
filter_cache::obj_map_entry *entry = m_tail2filter.insert_if_not_there2(key, 0);
func_decl*& filter_decl = entry->get_data().m_value;
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());

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

@ -129,15 +129,13 @@ namespace datalog {
SASSERT(m.is_bool(old_pred->get_range()));
adornment_desc adn(old_pred);
adn.m_adornment.populate(lit, bound_vars);
adornment_map::entry * e = m_adorned_preds.insert_if_not_there2(adn, nullptr);
func_decl * new_pred = e->get_data().m_value;
func_decl *& new_pred = m_adorned_preds.insert_if_not_there(adn, nullptr);
if (new_pred==nullptr) {
std::string suffix = "ad_"+adn.m_adornment.to_string();
new_pred = m_context.mk_fresh_head_predicate(
old_pred->get_name(), symbol(suffix.c_str()),
old_pred->get_arity(), old_pred->get_domain(), old_pred);
m_pinned.push_back(new_pred);
e->get_data().m_value = new_pred;
m_todo.push_back(adn);
m_adornments.insert(new_pred, adn.m_adornment);
}
@ -161,8 +159,7 @@ namespace datalog {
}
}
pred2pred::obj_map_entry * e = m_magic_preds.insert_if_not_there2(l_pred, 0);
func_decl * mag_pred = e->get_data().m_value;
func_decl *& mag_pred = m_magic_preds.insert_if_not_there(l_pred, 0);
if (mag_pred==nullptr) {
unsigned mag_arity = bound_args.size();
@ -176,7 +173,6 @@ namespace datalog {
mag_pred = m_context.mk_fresh_head_predicate(l_pred->get_name(), symbol("ms"),
mag_arity, mag_domain.c_ptr(), l_pred);
m_pinned.push_back(mag_pred);
e->get_data().m_value = mag_pred;
}
app * res = m.mk_app(mag_pred, bound_args.c_ptr());

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

@ -639,9 +639,9 @@ namespace datalog {
}
unsigned_vector const& mk_rule_inliner::visitor::add_position(expr* e, unsigned j) {
obj_map<expr, unsigned_vector>::obj_map_entry * et = m_positions.insert_if_not_there2(e, unsigned_vector());
et->get_data().m_value.push_back(j);
return et->get_data().m_value;
auto& value = m_positions.insert_if_not_there(e, unsigned_vector());
value.push_back(j);
return value;
}
unsigned_vector const& mk_rule_inliner::visitor::del_position(expr* e, unsigned j) {