From b3ebcfe55855589d3b2fb4dbeda1310a64a23862 Mon Sep 17 00:00:00 2001 From: Murphy Berzish Date: Wed, 29 Nov 2017 18:20:59 -0500 Subject: [PATCH 001/109] correctly check third argument of str.indexof in theory_str --- src/smt/theory_str.cpp | 47 ++++++++++++++++++++++-------------------- src/smt/theory_str.h | 2 +- 2 files changed, 26 insertions(+), 23 deletions(-) diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp index 7936b581c..a931ae458 100644 --- a/src/smt/theory_str.cpp +++ b/src/smt/theory_str.cpp @@ -641,7 +641,6 @@ namespace smt { } app * theory_str::mk_indexof(expr * haystack, expr * needle) { - // TODO check meaning of the third argument here app * indexof = u.str.mk_index(haystack, needle, mk_int(0)); m_trail.push_back(indexof); // immediately force internalization so that axiom setup does not fail @@ -844,14 +843,7 @@ namespace smt { instantiate_axiom_Contains(e); } else if (u.str.is_index(a)) { instantiate_axiom_Indexof(e); - /* TODO NEXT: Indexof2/Lastindexof rewrite? - } else if (is_Indexof2(e)) { - instantiate_axiom_Indexof2(e); - } else if (is_LastIndexof(e)) { - instantiate_axiom_LastIndexof(e); - */ } else if (u.str.is_extract(a)) { - // TODO check semantics of substr vs. extract instantiate_axiom_Substr(e); } else if (u.str.is_replace(a)) { instantiate_axiom_Replace(e); @@ -1232,27 +1224,37 @@ namespace smt { context & ctx = get_context(); ast_manager & m = get_manager(); - app * expr = e->get_owner(); - if (axiomatized_terms.contains(expr)) { - TRACE("str", tout << "already set up Indexof axiom for " << mk_pp(expr, m) << std::endl;); + app * ex = e->get_owner(); + if (axiomatized_terms.contains(ex)) { + TRACE("str", tout << "already set up str.indexof axiom for " << mk_pp(ex, m) << std::endl;); return; } - axiomatized_terms.insert(expr); + SASSERT(ex->get_num_args() == 3); + // if the third argument is exactly the integer 0, we can use this "simple" indexof; + // otherwise, we call the "extended" version + expr * startingPosition = ex->get_arg(2); + rational startingInteger; + if (!m_autil.is_numeral(startingPosition, startingInteger) || !startingInteger.is_zero()) { + // "extended" indexof term with prefix + instantiate_axiom_Indexof_extended(e); + return; + } + axiomatized_terms.insert(ex); - TRACE("str", tout << "instantiate Indexof axiom for " << mk_pp(expr, m) << std::endl;); + TRACE("str", tout << "instantiate str.indexof axiom for " << mk_pp(ex, m) << std::endl;); expr_ref x1(mk_str_var("x1"), m); expr_ref x2(mk_str_var("x2"), m); expr_ref indexAst(mk_int_var("index"), m); - expr_ref condAst(mk_contains(expr->get_arg(0), expr->get_arg(1)), m); + expr_ref condAst(mk_contains(ex->get_arg(0), ex->get_arg(1)), m); SASSERT(condAst); // ----------------------- // true branch expr_ref_vector thenItems(m); // args[0] = x1 . args[1] . x2 - thenItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(x1, mk_concat(expr->get_arg(1), x2)))); + thenItems.push_back(ctx.mk_eq_atom(ex->get_arg(0), mk_concat(x1, mk_concat(ex->get_arg(1), x2)))); // indexAst = |x1| thenItems.push_back(ctx.mk_eq_atom(indexAst, mk_strlen(x1))); // args[0] = x3 . x4 @@ -1260,11 +1262,11 @@ namespace smt { // /\ ! contains(x3, args[1]) expr_ref x3(mk_str_var("x3"), m); expr_ref x4(mk_str_var("x4"), m); - expr_ref tmpLen(m_autil.mk_add(indexAst, mk_strlen(expr->get_arg(1)), mk_int(-1)), m); + expr_ref tmpLen(m_autil.mk_add(indexAst, mk_strlen(ex->get_arg(1)), mk_int(-1)), m); SASSERT(tmpLen); - thenItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(x3, x4))); + thenItems.push_back(ctx.mk_eq_atom(ex->get_arg(0), mk_concat(x3, x4))); thenItems.push_back(ctx.mk_eq_atom(mk_strlen(x3), tmpLen)); - thenItems.push_back(mk_not(m, mk_contains(x3, expr->get_arg(1)))); + thenItems.push_back(mk_not(m, mk_contains(x3, ex->get_arg(1)))); expr_ref thenBranch(m.mk_and(thenItems.size(), thenItems.c_ptr()), m); SASSERT(thenBranch); @@ -1276,7 +1278,7 @@ namespace smt { expr_ref breakdownAssert(m.mk_ite(condAst, thenBranch, elseBranch), m); SASSERT(breakdownAssert); - expr_ref reduceToIndex(ctx.mk_eq_atom(expr, indexAst), m); + expr_ref reduceToIndex(ctx.mk_eq_atom(ex, indexAst), m); SASSERT(reduceToIndex); expr_ref finalAxiom(m.mk_and(breakdownAssert, reduceToIndex), m); @@ -1284,18 +1286,19 @@ namespace smt { assert_axiom(finalAxiom); } - void theory_str::instantiate_axiom_Indexof2(enode * e) { + void theory_str::instantiate_axiom_Indexof_extended(enode * e) { context & ctx = get_context(); ast_manager & m = get_manager(); app * expr = e->get_owner(); if (axiomatized_terms.contains(expr)) { - TRACE("str", tout << "already set up Indexof2 axiom for " << mk_pp(expr, m) << std::endl;); + TRACE("str", tout << "already set up extended str.indexof axiom for " << mk_pp(expr, m) << std::endl;); return; } + SASSERT(expr->get_num_args() == 3); axiomatized_terms.insert(expr); - TRACE("str", tout << "instantiate Indexof2 axiom for " << mk_pp(expr, m) << std::endl;); + TRACE("str", tout << "instantiate extended str.indexof axiom for " << mk_pp(expr, m) << std::endl;); // ------------------------------------------------------------------------------- // if (arg[2] >= length(arg[0])) // ite2 diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h index 03fd31162..dd2ca585b 100644 --- a/src/smt/theory_str.h +++ b/src/smt/theory_str.h @@ -447,7 +447,7 @@ protected: void instantiate_axiom_suffixof(enode * e); void instantiate_axiom_Contains(enode * e); void instantiate_axiom_Indexof(enode * e); - void instantiate_axiom_Indexof2(enode * e); + void instantiate_axiom_Indexof_extended(enode * e); void instantiate_axiom_LastIndexof(enode * e); void instantiate_axiom_Substr(enode * e); void instantiate_axiom_Replace(enode * e); From 9554723b44860733e8a633de724aa06bb9ed9a99 Mon Sep 17 00:00:00 2001 From: Murphy Berzish Date: Wed, 6 Dec 2017 20:50:03 -0500 Subject: [PATCH 002/109] use safer mk_and in extended indexof --- src/smt/theory_str.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp index a931ae458..4f84ed2f7 100644 --- a/src/smt/theory_str.cpp +++ b/src/smt/theory_str.cpp @@ -1330,7 +1330,7 @@ namespace smt { ite2ElseItems.push_back(ctx.mk_eq_atom(indexAst, mk_indexof(suffix, expr->get_arg(1)))); ite2ElseItems.push_back(ctx.mk_eq_atom(expr->get_arg(2), prefixLen)); ite2ElseItems.push_back(ite3); - expr_ref ite2Else(m.mk_and(ite2ElseItems.size(), ite2ElseItems.c_ptr()), m); + expr_ref ite2Else(mk_and(ite2ElseItems), m); SASSERT(ite2Else); expr_ref ite2(m.mk_ite( From 7b91195770479fd4d9e85ffa3d4fc702ad26e3e0 Mon Sep 17 00:00:00 2001 From: Angus Lepper Date: Tue, 20 Feb 2018 19:37:17 +0000 Subject: [PATCH 003/109] Fix Python FiniteDomainSortRef.size() --- src/api/python/z3/z3.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/api/python/z3/z3.py b/src/api/python/z3/z3.py index 641dba59c..c8ad4e0b4 100644 --- a/src/api/python/z3/z3.py +++ b/src/api/python/z3/z3.py @@ -6818,8 +6818,8 @@ class FiniteDomainSortRef(SortRef): def size(self): """Return the size of the finite domain sort""" - r = (ctype.c_ulonglong * 1)() - if Z3_get_finite_domain_sort_size(self.ctx_ref(), self.ast(), r): + r = (ctypes.c_ulonglong * 1)() + if Z3_get_finite_domain_sort_size(self.ctx_ref(), self.ast, r): return r[0] else: raise Z3Exception("Failed to retrieve finite domain sort size") From dbe5df85c303a5b04e1922890d404f79b048e7fd Mon Sep 17 00:00:00 2001 From: Lev Nachmanson Date: Thu, 22 Feb 2018 08:44:50 -0800 Subject: [PATCH 004/109] fix the override warning Signed-off-by: Lev Nachmanson --- src/util/lp/dense_matrix.h | 6 +++--- src/util/lp/eta_matrix.h | 2 +- src/util/lp/lu.h | 6 +++--- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/util/lp/dense_matrix.h b/src/util/lp/dense_matrix.h index 31b6617ac..e6663d705 100644 --- a/src/util/lp/dense_matrix.h +++ b/src/util/lp/dense_matrix.h @@ -82,10 +82,10 @@ public: void set_number_of_rows(unsigned /*m*/) override {} void set_number_of_columns(unsigned /*n*/) override {} - T get_elem(unsigned i, unsigned j) const { return m_values[i * m_n + j]; } + T get_elem(unsigned i, unsigned j) const override { return m_values[i * m_n + j]; } - unsigned row_count() const { return m_m; } - unsigned column_count() const { return m_n; } + unsigned row_count() const override { return m_m; } + unsigned column_count() const override { return m_n; } void set_elem(unsigned i, unsigned j, const T& val) { m_values[i * m_n + j] = val; } diff --git a/src/util/lp/eta_matrix.h b/src/util/lp/eta_matrix.h index eee4a2674..89d2e641d 100644 --- a/src/util/lp/eta_matrix.h +++ b/src/util/lp/eta_matrix.h @@ -83,7 +83,7 @@ public: void apply_from_right(vector & w) override; void apply_from_right(indexed_vector & w) override; - T get_elem(unsigned i, unsigned j) const; + T get_elem(unsigned i, unsigned j) const override; #ifdef Z3DEBUG unsigned row_count() const override { return m_length; } unsigned column_count() const override { return m_length; } diff --git a/src/util/lp/lu.h b/src/util/lp/lu.h index 2f9a5ec38..f2cae7961 100644 --- a/src/util/lp/lu.h +++ b/src/util/lp/lu.h @@ -78,10 +78,10 @@ public: void set_number_of_columns(unsigned n) override { m_m = n; m_n = n; } T m_one_over_val; - T get_elem (unsigned i, unsigned j) const; + T get_elem (unsigned i, unsigned j) const override; - unsigned row_count() const { return m_m; } // not defined } - unsigned column_count() const { return m_m; } // not defined } + unsigned row_count() const override { return m_m; } // not defined } + unsigned column_count() const override { return m_m; } // not defined } #endif void apply_from_left(vector & w, lp_settings &) override { w[m_i] /= m_val; From a238a0a37da800238b6ade73a2b5f5994109529a Mon Sep 17 00:00:00 2001 From: Lev Nachmanson Date: Thu, 22 Feb 2018 17:07:21 -0800 Subject: [PATCH 005/109] fix the build Signed-off-by: Lev Nachmanson --- src/util/lp/dense_matrix.h | 3 ++- src/util/lp/eta_matrix.h | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/util/lp/dense_matrix.h b/src/util/lp/dense_matrix.h index e6663d705..e2ee54058 100644 --- a/src/util/lp/dense_matrix.h +++ b/src/util/lp/dense_matrix.h @@ -81,8 +81,9 @@ public: void set_number_of_rows(unsigned /*m*/) override {} void set_number_of_columns(unsigned /*n*/) override {} - +#ifdef Z3DEBUG T get_elem(unsigned i, unsigned j) const override { return m_values[i * m_n + j]; } +#endif unsigned row_count() const override { return m_m; } unsigned column_count() const override { return m_n; } diff --git a/src/util/lp/eta_matrix.h b/src/util/lp/eta_matrix.h index 89d2e641d..abed6d06b 100644 --- a/src/util/lp/eta_matrix.h +++ b/src/util/lp/eta_matrix.h @@ -83,8 +83,8 @@ public: void apply_from_right(vector & w) override; void apply_from_right(indexed_vector & w) override; - T get_elem(unsigned i, unsigned j) const override; #ifdef Z3DEBUG + T get_elem(unsigned i, unsigned j) const override; unsigned row_count() const override { return m_length; } unsigned column_count() const override { return m_length; } void set_number_of_rows(unsigned m) override { m_length = m; } From c5336f8003dbc23e94156fe4641e1bd9da442cb2 Mon Sep 17 00:00:00 2001 From: Mikhail Ramalho Date: Fri, 23 Feb 2018 14:48:20 +0000 Subject: [PATCH 006/109] Convert BVULT(X,Y) into !BVULE(Y,X) Signed-off-by: Mikhail Ramalho --- src/ast/fpa/fpa2bv_converter.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ast/fpa/fpa2bv_converter.cpp b/src/ast/fpa/fpa2bv_converter.cpp index 033d62825..c84af84d6 100644 --- a/src/ast/fpa/fpa2bv_converter.cpp +++ b/src/ast/fpa/fpa2bv_converter.cpp @@ -25,7 +25,7 @@ Notes: #include "ast/fpa/fpa2bv_converter.h" #include "ast/rewriter/fpa_rewriter.h" -#define BVULT(X,Y,R) { expr_ref bvult_eq(m), bvult_not(m); m_simp.mk_eq(X, Y, bvult_eq); m_simp.mk_not(bvult_eq, bvult_not); expr_ref t(m); t = m_bv_util.mk_ule(X,Y); m_simp.mk_and(t, bvult_not, R); } +#define BVULT(X,Y,R) { expr_ref t(m); t = m_bv_util.mk_ule(Y,X); m_simp.mk_not(t, R); } fpa2bv_converter::fpa2bv_converter(ast_manager & m) : m(m), From 5d0e33c9ad395fa5f0c4e43ed898b6a56f684ad3 Mon Sep 17 00:00:00 2001 From: Moritz Kiefer Date: Fri, 23 Feb 2018 20:22:07 +0100 Subject: [PATCH 007/109] Fix assignment of family ids --- src/ast/ast.cpp | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/src/ast/ast.cpp b/src/ast/ast.cpp index b524cd8d4..c27651fca 100644 --- a/src/ast/ast.cpp +++ b/src/ast/ast.cpp @@ -1532,6 +1532,17 @@ void ast_manager::copy_families_plugins(ast_manager const & from) { tout << "fid: " << fid << " fidname: " << get_family_name(fid) << "\n"; }); ast_translation trans(const_cast(from), *this, false); + // Inheriting plugins can create new family ids. Since new family ids are + // assigned in the order that they are created, this can result in differing + // family ids. To avoid this, we first assign all family ids and only then inherit plugins. + for (family_id fid = 0; from.m_family_manager.has_family(fid); fid++) { + symbol fid_name = from.get_family_name(fid); + if (!m_family_manager.has_family(fid)) { + family_id new_fid = mk_family_id(fid_name); + (void)new_fid; + TRACE("copy_families_plugins", tout << "new target fid created: " << new_fid << " fid_name: " << fid_name << "\n";); + } + } for (family_id fid = 0; from.m_family_manager.has_family(fid); fid++) { SASSERT(from.is_builtin_family_id(fid) == is_builtin_family_id(fid)); SASSERT(!from.is_builtin_family_id(fid) || m_family_manager.has_family(fid)); @@ -1539,11 +1550,6 @@ void ast_manager::copy_families_plugins(ast_manager const & from) { TRACE("copy_families_plugins", tout << "copying: " << fid_name << ", src fid: " << fid << ", target has_family: " << m_family_manager.has_family(fid) << "\n"; if (m_family_manager.has_family(fid)) tout << get_family_id(fid_name) << "\n";); - if (!m_family_manager.has_family(fid)) { - family_id new_fid = mk_family_id(fid_name); - (void)new_fid; - TRACE("copy_families_plugins", tout << "new target fid created: " << new_fid << " fid_name: " << fid_name << "\n";); - } TRACE("copy_families_plugins", tout << "target fid: " << get_family_id(fid_name) << "\n";); SASSERT(fid == get_family_id(fid_name)); if (from.has_plugin(fid) && !has_plugin(fid)) { From 9279cbfbacb12332cc1cd58fd45948cccc629c23 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Sat, 24 Feb 2018 16:30:08 +0900 Subject: [PATCH 008/109] don't reinit assumptions when the solver is unsat. fixes #1502 Signed-off-by: Nikolaj Bjorner --- src/muz/transforms/dl_mk_rule_inliner.cpp | 22 ++++++++-------------- src/sat/sat_solver.cpp | 2 +- 2 files changed, 9 insertions(+), 15 deletions(-) diff --git a/src/muz/transforms/dl_mk_rule_inliner.cpp b/src/muz/transforms/dl_mk_rule_inliner.cpp index b1f222f6e..584f44303 100644 --- a/src/muz/transforms/dl_mk_rule_inliner.cpp +++ b/src/muz/transforms/dl_mk_rule_inliner.cpp @@ -209,7 +209,6 @@ namespace datalog { rel->collect_non_empty_predicates(m_preds_with_facts); } - rule_set::iterator rend = orig.end(); for (rule * r : orig) { func_decl * head_pred = r->get_decl(); m_head_pred_ctr.inc(head_pred); @@ -257,9 +256,7 @@ namespace datalog { rule_set * mk_rule_inliner::create_allowed_rule_set(rule_set const & orig) { rule_set * res = alloc(rule_set, m_context); - unsigned rcnt = orig.get_num_rules(); - for (unsigned i=0; iget_decl())) { res->add_rule(r); } @@ -283,10 +280,10 @@ namespace datalog { const rule_stratifier::comp_vector& comps = r.get_stratifier().get_strats(); for (rule_stratifier::item_set * stratum : comps) { - if (stratum->size()==1) { + if (stratum->size() == 1) { continue; } - SASSERT(stratum->size()>1); + SASSERT(stratum->size() > 1); func_decl * first_stratum_pred = *stratum->begin(); //we're trying to break cycles by removing one predicate from each of them @@ -397,12 +394,12 @@ namespace datalog { // now we start filling in the set of the inlined rules in a topological order, // so that we inline rules into other rules - SASSERT(m_inlined_rules.get_num_rules()==0); + SASSERT(m_inlined_rules.get_num_rules() == 0); const rule_stratifier::comp_vector& comps = candidate_inlined_set->get_stratifier().get_strats(); for (rule_stratifier::item_set * stratum : comps) { - SASSERT(stratum->size()==1); + SASSERT(stratum->size() == 1); func_decl * pred = *stratum->begin(); for (rule * r : candidate_inlined_set->get_predicate_rules(pred)) { transform_rule(orig, r, m_inlined_rules); @@ -411,8 +408,7 @@ namespace datalog { TRACE("dl", tout << "inlined rules after mutual inlining:\n" << m_inlined_rules; ); - for (unsigned i = 0; i < m_inlined_rules.get_num_rules(); ++i) { - rule* r = m_inlined_rules.get_rule(i); + for (rule * r : m_inlined_rules) { datalog::del_rule(m_mc, *r, false); } } @@ -426,9 +422,7 @@ namespace datalog { rule_ref r(todo.back(), m_rm); todo.pop_back(); unsigned pt_len = r->get_positive_tail_size(); - unsigned i = 0; - for (; i < pt_len && !inlining_allowed(orig, r->get_decl(i)); ++i) {}; SASSERT(!has_quantifier(*r.get())); @@ -497,9 +491,9 @@ namespace datalog { for (unsigned ti=0; ti < pt_len; ++ti) { func_decl * pred = r->get_decl(ti); unsigned pred_strat = strat.get_predicate_strat(pred); - SASSERT(pred_strat<=head_strat); + SASSERT(pred_strat <= head_strat); - if (pred_strat==head_strat) { + if (pred_strat == head_strat) { if (pred->get_arity()>head_arity || (pred->get_arity()==head_arity && pred->get_id()>=head_pred->get_id()) ) { return false; diff --git a/src/sat/sat_solver.cpp b/src/sat/sat_solver.cpp index a3d190854..135a7417d 100644 --- a/src/sat/sat_solver.cpp +++ b/src/sat/sat_solver.cpp @@ -1139,7 +1139,7 @@ namespace sat { } void solver::reinit_assumptions() { - if (tracking_assumptions() && scope_lvl() == 0) { + if (tracking_assumptions() && scope_lvl() == 0 && !inconsistent()) { TRACE("sat", tout << m_assumptions << "\n";); push(); for (unsigned i = 0; !inconsistent() && i < m_user_scope_literals.size(); ++i) { From 7b68be75c9a2050ff43eba82f07a7a99ccaf0e84 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Sun, 25 Feb 2018 13:11:20 +0900 Subject: [PATCH 009/109] fixes to #1500 and #1457 Signed-off-by: Nikolaj Bjorner --- src/smt/theory_seq.cpp | 144 ++++++++++++++++++++++------------------- src/smt/theory_seq.h | 6 +- 2 files changed, 81 insertions(+), 69 deletions(-) diff --git a/src/smt/theory_seq.cpp b/src/smt/theory_seq.cpp index e92a25159..42056ce5c 100644 --- a/src/smt/theory_seq.cpp +++ b/src/smt/theory_seq.cpp @@ -2346,28 +2346,31 @@ bool theory_seq::check_int_string() { bool change = false; for (unsigned i = 0; i < m_int_string.size(); ++i) { expr* e = m_int_string[i].get(), *n; - if (m_util.str.is_itos(e) && add_itos_axiom(e)) { + if (m_util.str.is_itos(e) && add_itos_val_axiom(e)) { change = true; } - else if (m_util.str.is_stoi(e, n) && add_stoi_axiom(e)) { + else if (m_util.str.is_stoi(e, n) && add_stoi_val_axiom(e)) { change = true; } } return change; } -bool theory_seq::add_stoi_axiom(expr* e) { +void theory_seq::add_stoi_axiom(expr* e) { + TRACE("seq", tout << mk_pp(e, m) << "\n";); + SASSERT(m_util.str.is_stoi(e)); + literal l = mk_simplified_literal(m_autil.mk_ge(e, arith_util(m).mk_int(-1))); + add_axiom(l); +} + +bool theory_seq::add_stoi_val_axiom(expr* e) { context& ctx = get_context(); expr* n = nullptr; rational val; TRACE("seq", tout << mk_pp(e, m) << "\n";); VERIFY(m_util.str.is_stoi(e, n)); if (!get_num_value(e, val)) { - literal l = mk_simplified_literal(m_autil.mk_ge(e, arith_util(m).mk_int(-1))); - add_axiom(l); - TRACE("seq", tout << l << " " << ctx.get_assignment(l) << "\n"; - ctx.display(tout);); - return true; + return false; } if (!m_stoi_axioms.contains(val)) { m_stoi_axioms.insert(val); @@ -2445,54 +2448,61 @@ expr_ref theory_seq::digit2int(expr* ch) { return expr_ref(mk_skolem(symbol("seq.digit2int"), ch, nullptr, nullptr, m_autil.mk_int()), m); } -bool theory_seq::add_itos_axiom(expr* e) { +void theory_seq::add_itos_axiom(expr* e) { context& ctx = get_context(); rational val; expr* n = nullptr; TRACE("seq", tout << mk_pp(e, m) << "\n";); VERIFY(m_util.str.is_itos(e, n)); - if (get_num_value(n, val)) { - if (!m_itos_axioms.contains(val)) { - m_itos_axioms.insert(val); - app_ref e1(m_util.str.mk_string(symbol(val.to_string().c_str())), m); - expr_ref n1(arith_util(m).mk_numeral(val, true), m); - // itos(n) = "25" <=> n = 25 - literal eq1 = mk_eq(n1, n , false); - literal eq2 = mk_eq(e, e1, false); - add_axiom(~eq1, eq2); - add_axiom(~eq2, eq1); - ctx.force_phase(eq1); - ctx.force_phase(eq2); + // itos(n) = "" <=> n < 0 + app_ref e1(m_util.str.mk_empty(m.get_sort(e)), m); + expr_ref zero(arith_util(m).mk_int(0), m); + literal eq1 = mk_eq(e1, e, false); + literal ge0 = mk_literal(m_autil.mk_ge(n, zero)); + // n >= 0 => itos(n) != "" + // itos(n) = "" or n >= 0 + add_axiom(~eq1, ~ge0); + add_axiom(eq1, ge0); + + // n >= 0 => stoi(itos(n)) = n + app_ref stoi(m_util.str.mk_stoi(e), m); + add_axiom(~ge0, mk_eq(stoi, n, false)); - m_trail_stack.push(insert_map(m_itos_axioms, val)); - m_trail_stack.push(push_replay(alloc(replay_axiom, m, e))); - return true; - } + // n >= 0 => itos(n) in (0-9)+ + expr_ref num_re(m); + num_re = m_util.re.mk_range(m_util.str.mk_string(symbol("0")), m_util.str.mk_string(symbol("9"))); + num_re = m_util.re.mk_plus(num_re); + app_ref in_re(m_util.re.mk_in_re(e, num_re), m); + add_axiom(~ge0, mk_literal(in_re)); +} + +bool theory_seq::add_itos_val_axiom(expr* e) { + context& ctx = get_context(); + rational val; + expr* n = nullptr; + TRACE("seq", tout << mk_pp(e, m) << "\n";); + VERIFY(m_util.str.is_itos(e, n)); + bool change = false; + + if (get_num_value(n, val) && !val.is_neg() && !m_itos_axioms.contains(val)) { + m_itos_axioms.insert(val); + app_ref e1(m_util.str.mk_string(symbol(val.to_string().c_str())), m); + expr_ref n1(arith_util(m).mk_numeral(val, true), m); + + // itos(n) = "25" <=> n = 25 + literal eq1 = mk_eq(n1, n , false); + literal eq2 = mk_eq(e, e1, false); + add_axiom(~eq1, eq2); + add_axiom(~eq2, eq1); + ctx.force_phase(eq1); + ctx.force_phase(eq2); + + m_trail_stack.push(insert_map(m_itos_axioms, val)); + m_trail_stack.push(push_replay(alloc(replay_axiom, m, e))); + change = true; } - else { - // stoi(itos(n)) = n - app_ref e2(m_util.str.mk_stoi(e), m); - if (ctx.e_internalized(e2) && ctx.get_enode(e2)->get_root() == ctx.get_enode(n)->get_root()) { - return false; - } - add_axiom(mk_eq(e2, n, false)); - -#if 1 - expr_ref num_re(m), opt_re(m); - num_re = m_util.re.mk_range(m_util.str.mk_string(symbol("0")), m_util.str.mk_string(symbol("9"))); - num_re = m_util.re.mk_plus(num_re); - opt_re = m_util.re.mk_opt(m_util.re.mk_to_re(m_util.str.mk_string(symbol("-")))); - num_re = m_util.re.mk_concat(opt_re, num_re); - app_ref in_re(m_util.re.mk_in_re(e, num_re), m); - internalize_term(in_re); - propagate_in_re(in_re, true); -#endif - m_trail_stack.push(push_replay(alloc(replay_axiom, m, e))); - return true; - } - - return false; + return change; } void theory_seq::apply_sort_cnstr(enode* n, sort* s) { @@ -3048,8 +3058,11 @@ expr_ref theory_seq::expand1(expr* e0, dependency*& eqs) { enode* n2 = ctx.get_enode(e1); res = m_util.str.mk_string(symbol(val.to_string().c_str())); #if 1 + if (val.is_neg()) { + result = e; + } // TBD remove this: using roots is unsound for propagation. - if (n1->get_root() == n2->get_root()) { + else if (n1->get_root() == n2->get_root()) { result = res; deps = m_dm.mk_join(deps, m_dm.mk_leaf(assumption(n1, n2))); } @@ -3147,6 +3160,9 @@ void theory_seq::deque_axiom(expr* n) { else if (m_util.str.is_itos(n)) { add_itos_axiom(n); } + else if (m_util.str.is_stoi(n)) { + add_stoi_axiom(n); + } } @@ -3366,9 +3382,9 @@ void theory_seq::add_itos_length_axiom(expr* len) { rational len1, len2; rational ten(10); if (get_num_value(n, len1)) { - bool neg = len1.is_neg(); - if (neg) len1.neg(); - num_char1 = neg?2:1; + if (len1.is_neg()) { + return; + } // 0 <= x < 10 // 10 <= x < 100 // 100 <= x < 1000 @@ -3387,13 +3403,12 @@ void theory_seq::add_itos_length_axiom(expr* len) { literal len_le(mk_literal(m_autil.mk_le(len, m_autil.mk_int(num_char)))); literal len_ge(mk_literal(m_autil.mk_ge(len, m_autil.mk_int(num_char)))); + literal n_ge_0(mk_literal(m_autil.mk_ge(n, m_autil.mk_int(0)))); + add_axiom(~n_ge_0, mk_literal(m_autil.mk_ge(len, m_autil.mk_int(1)))); if (num_char == 1) { - add_axiom(len_ge); - literal n_ge_0(mk_literal(m_autil.mk_ge(n, m_autil.mk_int(0)))); literal n_ge_10(mk_literal(m_autil.mk_ge(n, m_autil.mk_int(10)))); add_axiom(~n_ge_0, n_ge_10, len_le); - add_axiom(~len_le, n_ge_0); add_axiom(~len_le, ~n_ge_10); return; } @@ -3401,22 +3416,13 @@ void theory_seq::add_itos_length_axiom(expr* len) { for (unsigned i = 2; i < num_char; ++i) { hi *= ten; } - // n <= -hi or n >= hi*10 <=> len >= num_chars - // -10*hi < n < 100*hi <=> len <= num_chars - literal n_le_hi = mk_literal(m_autil.mk_le(n, m_autil.mk_numeral(-hi, true))); + // n >= hi*10 <=> len >= num_chars + // n < 100*hi <=> len <= num_chars literal n_ge_10hi = mk_literal(m_autil.mk_ge(n, m_autil.mk_numeral(ten*hi, true))); - literal n_le_m10hi = mk_literal(m_autil.mk_le(n, m_autil.mk_numeral(-ten*hi, true))); literal n_ge_100hi = mk_literal(m_autil.mk_ge(n, m_autil.mk_numeral(ten*ten*hi, true))); - add_axiom(~n_le_hi, len_ge); add_axiom(~n_ge_10hi, len_ge); - add_axiom(n_le_hi, n_ge_10hi, ~len_ge); - - add_axiom(n_le_m10hi, n_ge_100hi, len_le); - add_axiom(~n_le_m10hi, ~len_le); add_axiom(~n_ge_100hi, ~len_le); - - add_axiom(mk_literal(m_autil.mk_ge(len, m_autil.mk_int(1)))); } @@ -3729,6 +3735,7 @@ bool theory_seq::is_extract_suffix(expr* s, expr* i, expr* l) { /* 0 <= l <= len(s) => s = ey & l = len(e) + len(s) < l => s = e */ void theory_seq::add_extract_prefix_axiom(expr* e, expr* s, expr* l) { TRACE("seq", tout << mk_pp(e, m) << " " << mk_pp(s, m) << " " << mk_pp(l, m) << "\n";); @@ -3743,6 +3750,7 @@ void theory_seq::add_extract_prefix_axiom(expr* e, expr* s, expr* l) { add_axiom(~l_ge_0, ~l_le_s, mk_seq_eq(s, ey)); add_axiom(~l_ge_0, ~l_le_s, mk_eq(l, le, false)); add_axiom(~l_ge_0, ~l_le_s, mk_eq(ls_minus_l, m_util.str.mk_length(y), false)); + add_axiom(l_le_s, mk_eq(e, s, false)); } /* @@ -4214,7 +4222,9 @@ void theory_seq::relevant_eh(app* n) { m_util.str.is_extract(n) || m_util.str.is_at(n) || m_util.str.is_empty(n) || - m_util.str.is_string(n)) { + m_util.str.is_string(n) || + m_util.str.is_itos(n) || + m_util.str.is_stoi(n)) { enque_axiom(n); } diff --git a/src/smt/theory_seq.h b/src/smt/theory_seq.h index 203dae633..21aedd7e3 100644 --- a/src/smt/theory_seq.h +++ b/src/smt/theory_seq.h @@ -507,8 +507,10 @@ namespace smt { void add_elim_string_axiom(expr* n); void add_at_axiom(expr* n); void add_in_re_axiom(expr* n); - bool add_stoi_axiom(expr* n); - bool add_itos_axiom(expr* n); + void add_itos_axiom(expr* n); + void add_stoi_axiom(expr* n); + bool add_stoi_val_axiom(expr* n); + bool add_itos_val_axiom(expr* n); literal is_digit(expr* ch); expr_ref digit2int(expr* ch); void add_itos_length_axiom(expr* n); From ce1b135ec388228352d4f9f4159d185378a6ac16 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Mon, 26 Feb 2018 14:57:17 +0900 Subject: [PATCH 010/109] address accessor inconsistencies between - and from #1506 Signed-off-by: Nikolaj Bjorner --- src/api/api_ast.cpp | 1 + src/api/python/z3/z3printer.py | 25 ++++++++++++++++++++++--- src/api/z3_api.h | 3 +++ src/ast/datatype_decl_plugin.cpp | 9 +++++++++ src/smt/smt_context.cpp | 4 +--- src/smt/theory_seq.cpp | 16 ++++++++-------- 6 files changed, 44 insertions(+), 14 deletions(-) diff --git a/src/api/api_ast.cpp b/src/api/api_ast.cpp index f820b184b..3f5a0fcf1 100644 --- a/src/api/api_ast.cpp +++ b/src/api/api_ast.cpp @@ -1059,6 +1059,7 @@ extern "C" { switch(_d->get_decl_kind()) { case OP_DT_CONSTRUCTOR: return Z3_OP_DT_CONSTRUCTOR; case OP_DT_RECOGNISER: return Z3_OP_DT_RECOGNISER; + case OP_DT_IS: return Z3_OP_DT_IS; case OP_DT_ACCESSOR: return Z3_OP_DT_ACCESSOR; case OP_DT_UPDATE_FIELD: return Z3_OP_DT_UPDATE_FIELD; default: diff --git a/src/api/python/z3/z3printer.py b/src/api/python/z3/z3printer.py index aef71be2f..3a6b7269e 100644 --- a/src/api/python/z3/z3printer.py +++ b/src/api/python/z3/z3printer.py @@ -485,7 +485,9 @@ class PP: raise StopPPException() def pp(self, f, indent): - if f.is_string(): + if isinstance(f, str): + sef.pp_string(f, indent) + elif f.is_string(): self.pp_string(f, indent) elif f.is_indent(): self.pp(f.child, min(indent + f.indent, self.max_indent)) @@ -846,10 +848,17 @@ class Formatter: else: return seq1('MultiPattern', [ self.pp_expr(arg, d+1, xs) for arg in a.children() ]) + def pp_is(self, a, d, xs): + f = a.params()[0] + return self.pp_fdecl(f, a, d, xs) + def pp_map(self, a, d, xs): + f = z3.get_map_func(a) + return self.pp_fdecl(f, a, d, xs) + + def pp_fdecl(self, f, a, d, xs): r = [] sz = 0 - f = z3.get_map_func(a) r.append(to_format(f.name())) for child in a.children(): r.append(self.pp_expr(child, d+1, xs)) @@ -909,6 +918,8 @@ class Formatter: return self.pp_unary_param(a, d, xs) elif k == Z3_OP_EXTRACT: return self.pp_extract(a, d, xs) + elif k == Z3_OP_DT_IS: + return self.pp_is(a, d, xs) elif k == Z3_OP_ARRAY_MAP: return self.pp_map(a, d, xs) elif k == Z3_OP_CONST_ARRAY: @@ -963,6 +974,14 @@ class Formatter: else: return to_format(self.pp_unknown()) + def pp_decl(self, f): + k = f.kind() + if k == Z3_OP_DT_IS or k == Z3_OP_ARRAY_MAP: + g = f.params()[0] + r = [ to_format(g.name()) ] + return seq1(self.pp_name(f), r) + return self.pp_name(f) + def pp_seq_core(self, f, a, d, xs): self.visited = self.visited + 1 if d > self.max_depth or self.visited > self.max_visited: @@ -1054,7 +1073,7 @@ class Formatter: elif z3.is_sort(a): return self.pp_sort(a) elif z3.is_func_decl(a): - return self.pp_name(a) + return self.pp_decl(a) elif isinstance(a, z3.Goal) or isinstance(a, z3.AstVector): return self.pp_seq(a, 0, []) elif isinstance(a, z3.Solver): diff --git a/src/api/z3_api.h b/src/api/z3_api.h index ea0c1615f..500533e91 100644 --- a/src/api/z3_api.h +++ b/src/api/z3_api.h @@ -876,6 +876,8 @@ typedef enum - Z3_OP_DT_RECOGNISER: datatype recognizer. + - Z3_OP_DT_IS: datatype recognizer. + - Z3_OP_DT_ACCESSOR: datatype accessor. - Z3_OP_DT_UPDATE_FIELD: datatype field update. @@ -1220,6 +1222,7 @@ typedef enum { // Datatypes Z3_OP_DT_CONSTRUCTOR=0x800, Z3_OP_DT_RECOGNISER, + Z3_OP_DT_IS, Z3_OP_DT_ACCESSOR, Z3_OP_DT_UPDATE_FIELD, diff --git a/src/ast/datatype_decl_plugin.cpp b/src/ast/datatype_decl_plugin.cpp index 44752866c..722cb22b5 100644 --- a/src/ast/datatype_decl_plugin.cpp +++ b/src/ast/datatype_decl_plugin.cpp @@ -797,6 +797,7 @@ namespace datatype { if (m_constructor2recognizer.find(con, d)) return d; sort * datatype = con->get_range(); +#if 0 def const& dd = get_def(datatype); symbol r; for (constructor const* c : dd) { @@ -811,6 +812,14 @@ namespace datatype { m_asts.push_back(d); m_constructor2recognizer.insert(con, d); return d; +#else + parameter ps[1] = { parameter(con)}; + d = m.mk_func_decl(m_family_id, OP_DT_IS, 1, ps, 1, &datatype); + m_constructor2recognizer.insert(con, d); + m_asts.push_back(d); + m_asts.push_back(con); + return d; +#endif } func_decl * util::get_recognizer_constructor(func_decl * recognizer) const { diff --git a/src/smt/smt_context.cpp b/src/smt/smt_context.cpp index dd38776bc..cccc2e7fb 100644 --- a/src/smt/smt_context.cpp +++ b/src/smt/smt_context.cpp @@ -4313,9 +4313,7 @@ namespace smt { if (m_fparams.m_model_compact) m_proto_model->compress(); TRACE("mbqi_bug", tout << "after cleanup:\n"; model_pp(tout, *m_proto_model);); - } - else { - + IF_VERBOSE(11, model_pp(verbose_stream(), *m_proto_model);); } } diff --git a/src/smt/theory_seq.cpp b/src/smt/theory_seq.cpp index 42056ce5c..12764fd9d 100644 --- a/src/smt/theory_seq.cpp +++ b/src/smt/theory_seq.cpp @@ -2731,13 +2731,12 @@ public: bool is_string = th.m_util.is_string(m_sort); expr_ref result(th.m); if (is_string) { - svector sbuffer; + unsigned_vector sbuffer; bv_util bv(th.m); rational val; unsigned sz; - - for (unsigned i = 0; i < m_source.size(); ++i) { - switch (m_source[i]) { + for (source_t src : m_source) { + switch (src) { case unit_source: { VERIFY(bv.is_numeral(values[j++], val, sz)); sbuffer.push_back(val.get_unsigned()); @@ -2767,12 +2766,13 @@ public: break; } } + // TRACE("seq", tout << src << " " << sbuffer << "\n";); } result = th.m_util.str.mk_string(zstring(sbuffer.size(), sbuffer.c_ptr())); } else { - for (unsigned i = 0; i < m_source.size(); ++i) { - switch (m_source[i]) { + for (source_t src : m_source) { + switch (src) { case unit_source: args.push_back(th.m_util.str.mk_unit(values[j++])); break; @@ -2814,8 +2814,8 @@ model_value_proc * theory_seq::mk_value(enode * n, model_generator & mg) { seq_value_proc* sv = alloc(seq_value_proc, *this, srt); TRACE("seq", tout << mk_pp(e, m) << "\n";); - for (unsigned i = 0; i < concats.size(); ++i) { - expr* c = concats[i], *c1; + for (expr* c : concats) { + expr *c1; TRACE("seq", tout << mk_pp(c, m) << "\n";); if (m_util.str.is_unit(c, c1)) { if (ctx.e_internalized(c1)) { From 0199c7515f82025129072a485b0879a5be026580 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Mon, 26 Feb 2018 19:49:13 +0900 Subject: [PATCH 011/109] fix z3.py Signed-off-by: Nikolaj Bjorner --- src/api/python/z3/z3.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/api/python/z3/z3.py b/src/api/python/z3/z3.py index b5d35bd3f..785649e3d 100644 --- a/src/api/python/z3/z3.py +++ b/src/api/python/z3/z3.py @@ -4451,7 +4451,7 @@ class Datatype: if __debug__: _z3_assert(isinstance(name, str), "String expected") _z3_assert(name != "", "Constructor name cannot be empty") - return self.declare_core(name, "is_" + name, *args) + return self.declare_core(name, "is-" + name, *args) def __repr__(self): return "Datatype(%s, %s)" % (self.name, self.constructors) @@ -4575,7 +4575,7 @@ def CreateDatatypes(*ds): cref = cref() setattr(dref, cref_name, cref) rref = dref.recognizer(j) - setattr(dref, rref.name(), rref) + setattr(dref, "is_" + cref_name, rref) for k in range(cref_arity): aref = dref.accessor(j, k) setattr(dref, aref.name(), aref) @@ -4629,16 +4629,16 @@ class DatatypeSortRef(SortRef): >>> List.num_constructors() 2 >>> List.recognizer(0) - is_cons + is(cons) >>> List.recognizer(1) - is_nil + is(nil) >>> simplify(List.is_nil(List.cons(10, List.nil))) False >>> simplify(List.is_cons(List.cons(10, List.nil))) True >>> l = Const('l', List) >>> simplify(List.is_cons(l)) - is_cons(l) + is(cons, l) """ if __debug__: _z3_assert(idx < self.num_constructors(), "Invalid recognizer index") From 5d457c95aa312c06342d6076a36133f1da812d88 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Mon, 26 Feb 2018 21:00:41 +0900 Subject: [PATCH 012/109] update registration of built-ins Signed-off-by: Nikolaj Bjorner --- src/cmd_context/cmd_context.cpp | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/cmd_context/cmd_context.cpp b/src/cmd_context/cmd_context.cpp index 6d49d8883..3462d0cac 100644 --- a/src/cmd_context/cmd_context.cpp +++ b/src/cmd_context/cmd_context.cpp @@ -2013,9 +2013,10 @@ void cmd_context::dt_eh::operator()(sort * dt, pdecl* pd) { for (func_decl * c : *m_dt_util.get_datatype_constructors(dt)) { TRACE("new_dt_eh", tout << "new constructor: " << c->get_name() << "\n";); m_owner.insert(c); - func_decl * r = m_dt_util.get_constructor_recognizer(c); - m_owner.insert(r); - TRACE("new_dt_eh", tout << "new recognizer: " << r->get_name() << "\n";); + // Don't insert recognizer any longer. It is a built-in function. + // func_decl * r = m_dt_util.get_constructor_recognizer(c); + // m_owner.insert(r); + // TRACE("new_dt_eh", tout << "new recognizer: " << r->get_name() << "\n";); for (func_decl * a : *m_dt_util.get_constructor_accessors(c)) { TRACE("new_dt_eh", tout << "new accessor: " << a->get_name() << "\n";); m_owner.insert(a); From ac9b03528acabba60810d97887b8b20a9cfdb372 Mon Sep 17 00:00:00 2001 From: Murphy Berzish Date: Mon, 26 Feb 2018 17:19:45 -0500 Subject: [PATCH 013/109] add re.allchar support in z3str3 --- src/smt/theory_str.cpp | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp index c5058d00a..8567c6b30 100644 --- a/src/smt/theory_str.cpp +++ b/src/smt/theory_str.cpp @@ -1812,8 +1812,11 @@ namespace smt { // trivially true for any string! assert_axiom(ex); } else if (u.re.is_full_char(regex)) { - TRACE("str", tout << "ERROR: unknown regex expression " << mk_pp(regex, m) << "!" << std::endl;); - NOT_IMPLEMENTED_YET(); + // any char = any string of length 1 + expr_ref rhs(ctx.mk_eq_atom(mk_strlen(str), mk_int(1)), m); + expr_ref finalAxiom(m.mk_iff(ex, rhs), m); + SASSERT(finalAxiom); + assert_axiom(finalAxiom); } else { TRACE("str", tout << "ERROR: unknown regex expression " << mk_pp(regex, m) << "!" << std::endl;); NOT_IMPLEMENTED_YET(); @@ -6327,6 +6330,13 @@ namespace smt { make_transition(tmp, ch, tmp); } TRACE("str", tout << "re.all NFA: start = " << start << ", end = " << end << std::endl;); + } else if (u.re.is_full_char(e)) { + // effectively . (match any one character) + for (unsigned int i = 0; i < 256; ++i) { + char ch = (char)i; + make_transition(start, ch, end); + } + TRACE("str", tout << "re.allchar NFA: start = " << start << ", end = " << end << std::endl;); } else { TRACE("str", tout << "invalid regular expression" << std::endl;); m_valid = false; From b79d1a6956a6a018280993fc103aea08330cc9bc Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Wed, 28 Feb 2018 09:22:20 +0900 Subject: [PATCH 014/109] fix #1488 for smtlib basic printer Signed-off-by: Nikolaj Bjorner --- src/ast/ast_smt_pp.cpp | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/src/ast/ast_smt_pp.cpp b/src/ast/ast_smt_pp.cpp index ace0de2cc..b7404859f 100644 --- a/src/ast/ast_smt_pp.cpp +++ b/src/ast/ast_smt_pp.cpp @@ -952,6 +952,10 @@ void ast_smt_pp::display_smt2(std::ostream& strm, expr* n) { strm << "; " << m_attributes.c_str(); } +#if 0 + decls.display_decls(strm); +#else + decls.order_deps(); ast_mark sort_mark; for (unsigned i = 0; i < decls.get_num_sorts(); ++i) { sort* s = decls.get_sorts()[i]; @@ -978,18 +982,19 @@ void ast_smt_pp::display_smt2(std::ostream& strm, expr* n) { strm << "\n"; } } +#endif - for (unsigned i = 0; i < m_assumptions.size(); ++i) { + for (expr* a : m_assumptions) { smt_printer p(strm, m, ql, rn, m_logic, false, true, m_simplify_implies, 1); strm << "(assert\n "; - p(m_assumptions[i].get()); + p(a); strm << ")\n"; } - for (unsigned i = 0; i < m_assumptions_star.size(); ++i) { + for (expr* a : m_assumptions_star) { smt_printer p(strm, m, ql, rn, m_logic, false, true, m_simplify_implies, 1); strm << "(assert\n "; - p(m_assumptions_star[i].get()); + p(a); strm << ")\n"; } From 30de514a8849fccec762bd5483068fc724b7029a Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Wed, 28 Feb 2018 11:59:17 +0900 Subject: [PATCH 015/109] fix topological traversal crash Signed-off-by: Nikolaj Bjorner --- src/test/heap.cpp | 17 ++++++++++------- src/util/top_sort.h | 2 +- 2 files changed, 11 insertions(+), 8 deletions(-) diff --git a/src/test/heap.cpp b/src/test/heap.cpp index 39353af76..08891ccaa 100644 --- a/src/test/heap.cpp +++ b/src/test/heap.cpp @@ -19,20 +19,19 @@ Revision History: #include #include "util/util.h" #include "util/heap.h" -#include "util/hashtable.h" #include "util/trace.h" +#include "util/uint_set.h" struct lt_proc { bool operator()(int v1, int v2) const { return v1 < v2; } }; typedef heap int_heap; struct int_hash_proc { unsigned operator()(int v) const { return v * 17; }}; -typedef int_hashtable > int_set; #define N 10000 static random_gen heap_rand(1); static void tst1() { int_heap h(N); - int_set t; + uint_set t; for (int i = 0; i < N * 3; i++) { int val = heap_rand() % N; if (!h.contains(val)) { @@ -41,14 +40,15 @@ static void tst1() { t.insert(val); } else { + if (!t.contains(val)) { + for (int v : t) std::cout << v << "\n"; + } ENSURE(t.contains(val)); } } ENSURE(h.check_invariant()); - int_set::iterator it = t.begin(); - int_set::iterator end = t.end(); - for (; it != end; ++it) { - ENSURE(h.contains(*it)); + for (int v : t) { + ENSURE(h.contains(v)); } while (!h.empty()) { int m1 = h.min_value(); @@ -84,6 +84,8 @@ static void dump_heap(const int_heap2 & h, std::ostream & out) { static void tst2() { int_heap2 h(N); for (int i = 0; i < N * 10; i++) { + + if (i % 1 == 0) std::cout << "i: " << i << std::endl; if (i % 1000 == 0) std::cout << "i: " << i << std::endl; int cmd = heap_rand() % 10; if (cmd <= 3) { @@ -134,6 +136,7 @@ void tst_heap() { enable_trace("heap"); unsigned i = 0; while (i < 3) { + IF_VERBOSE(1, verbose_stream() << "test\n";); heap_rand.set_seed(i++); tst1(); init_values(); diff --git a/src/util/top_sort.h b/src/util/top_sort.h index d017d162b..5f7db9c3e 100644 --- a/src/util/top_sort.h +++ b/src/util/top_sort.h @@ -42,7 +42,7 @@ class top_sort { unsigned p_id = 0; if (m_dfs_num.find(f, p_id)) { if (!m_partition_id.contains(f)) { - while (!m_stack_P.empty() && m_partition_id[m_stack_P.back()] > p_id) { + while (!m_stack_P.empty() && m_partition_id.contains(m_stack_P.back()) && m_partition_id[m_stack_P.back()] > p_id) { m_stack_P.pop_back(); } } From 00c3f4fdcd6153780b66f478918008e934de8318 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Wed, 28 Feb 2018 22:35:41 +0900 Subject: [PATCH 016/109] fix bugs found while running sample from #1112 in debug mode Signed-off-by: Nikolaj Bjorner --- src/api/api_solver.cpp | 11 ++++++----- src/cmd_context/cmd_context.cpp | 4 +++- src/cmd_context/pdecl.cpp | 3 ++- src/smt/smt_context.cpp | 1 + src/solver/combined_solver.cpp | 5 +++-- 5 files changed, 15 insertions(+), 9 deletions(-) diff --git a/src/api/api_solver.cpp b/src/api/api_solver.cpp index aab783afa..1b2e9dcc3 100644 --- a/src/api/api_solver.cpp +++ b/src/api/api_solver.cpp @@ -17,6 +17,11 @@ Revision History: --*/ #include +#include "util/scoped_ctrl_c.h" +#include "util/cancel_eh.h" +#include "util/file_path.h" +#include "util/scoped_timer.h" +#include "ast/ast_pp.h" #include "api/z3.h" #include "api/api_log_macros.h" #include "api/api_context.h" @@ -26,14 +31,10 @@ Revision History: #include "api/api_stats.h" #include "api/api_ast_vector.h" #include "solver/tactic2solver.h" -#include "util/scoped_ctrl_c.h" -#include "util/cancel_eh.h" -#include "util/file_path.h" -#include "util/scoped_timer.h" +#include "solver/smt_logics.h" #include "tactic/portfolio/smt_strategic_solver.h" #include "smt/smt_solver.h" #include "smt/smt_implied_equalities.h" -#include "solver/smt_logics.h" #include "cmd_context/cmd_context.h" #include "parsers/smt2/smt2parser.h" #include "sat/dimacs.h" diff --git a/src/cmd_context/cmd_context.cpp b/src/cmd_context/cmd_context.cpp index 3462d0cac..0be458b4a 100644 --- a/src/cmd_context/cmd_context.cpp +++ b/src/cmd_context/cmd_context.cpp @@ -719,6 +719,7 @@ void cmd_context::init_manager_core(bool new_manager) { m_dt_eh = alloc(dt_eh, *this); m_pmanager->set_new_datatype_eh(m_dt_eh.get()); if (!has_logic()) { + TRACE("cmd_context", tout << "init manager\n";); // add list type only if the logic is not specified. // it prevents clashes with builtin types. insert(pm().mk_plist_decl()); @@ -1408,7 +1409,8 @@ void cmd_context::restore_assertions(unsigned old_sz) { SASSERT(m_assertions.empty()); return; } - SASSERT(old_sz <= m_assertions.size()); + if (old_sz == m_assertions.size()) return; + SASSERT(old_sz < m_assertions.size()); SASSERT(!m_interactive_mode || m_assertions.size() == m_assertion_strings.size()); restore(m(), m_assertions, old_sz); if (produce_unsat_cores()) diff --git a/src/cmd_context/pdecl.cpp b/src/cmd_context/pdecl.cpp index 3a684b867..f9ba79f6d 100644 --- a/src/cmd_context/pdecl.cpp +++ b/src/cmd_context/pdecl.cpp @@ -852,7 +852,7 @@ pdecl_manager::pdecl_manager(ast_manager & m): pdecl_manager::~pdecl_manager() { dec_ref(m_list); reset_sort_info(); - SASSERT(m_sort2psort.empty()); + SASSERT(m_sort2psort.empty()); SASSERT(m_table.empty()); } @@ -946,6 +946,7 @@ void pdecl_manager::del_decl_core(pdecl * p) { } void pdecl_manager::del_decl(pdecl * p) { + TRACE("pdecl_manager", p->display(tout); tout << "\n";); if (p->is_psort()) { psort * _p = static_cast(p); if (_p->is_sort_wrapper()) diff --git a/src/smt/smt_context.cpp b/src/smt/smt_context.cpp index cccc2e7fb..9c95ac7c3 100644 --- a/src/smt/smt_context.cpp +++ b/src/smt/smt_context.cpp @@ -3143,6 +3143,7 @@ namespace smt { push_scope(); for (unsigned i = 0; i < num_assumptions; i++) { expr * curr_assumption = assumptions[i]; + if (m_manager.is_true(curr_assumption)) continue; SASSERT(is_valid_assumption(m_manager, curr_assumption)); proof * pr = m_manager.mk_asserted(curr_assumption); internalize_assertion(curr_assumption, pr, 0); diff --git a/src/solver/combined_solver.cpp b/src/solver/combined_solver.cpp index 397f3bdb1..9d2d8aa46 100644 --- a/src/solver/combined_solver.cpp +++ b/src/solver/combined_solver.cpp @@ -18,10 +18,11 @@ Author: Notes: --*/ -#include "solver/solver.h" #include "util/scoped_timer.h" -#include "solver/combined_solver_params.hpp" #include "util/common_msgs.h" +#include "ast/ast_pp.h" +#include "solver/solver.h" +#include "solver/combined_solver_params.hpp" #define PS_VB_LVL 15 /** From a738f5af12ff14312254c7024dc253358e4b6f83 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Fri, 2 Mar 2018 20:14:59 +0900 Subject: [PATCH 017/109] fix #1512 Signed-off-by: Nikolaj Bjorner --- src/model/func_interp.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/model/func_interp.cpp b/src/model/func_interp.cpp index accb45a25..2eb687dae 100644 --- a/src/model/func_interp.cpp +++ b/src/model/func_interp.cpp @@ -112,7 +112,8 @@ bool func_interp::is_fi_entry_expr(expr * e, ptr_vector & args) { return false; } - if ((m_arity == 0) || + if (!is_ground(t) || + (m_arity == 0) || (m_arity == 1 && !m().is_eq(c, a0, a1)) || (m_arity > 1 && (!m().is_and(c) || to_app(c)->get_num_args() != m_arity))) return false; From 8e09a78c269d9c0a25f784dc0cc898ab24b1182d Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Fri, 2 Mar 2018 23:02:20 +0900 Subject: [PATCH 018/109] fix #1510 by reintroducing automatic declaration of recognizers Signed-off-by: Nikolaj Bjorner --- src/api/api_datatype.cpp | 10 +++++----- src/ast/datatype_decl_plugin.cpp | 27 +++++++++++---------------- src/ast/datatype_decl_plugin.h | 1 + src/cmd_context/cmd_context.cpp | 5 ++--- src/muz/pdr/pdr_prop_solver.cpp | 2 +- src/muz/spacer/spacer_util.cpp | 2 +- src/parsers/smt2/smt2parser.cpp | 2 +- src/qe/qe_datatype_plugin.cpp | 10 +++++----- src/qe/qe_datatypes.cpp | 4 ++-- src/qe/qe_lite.cpp | 2 +- src/smt/theory_datatype.cpp | 10 +++++----- 11 files changed, 35 insertions(+), 40 deletions(-) diff --git a/src/api/api_datatype.cpp b/src/api/api_datatype.cpp index df0b2317f..799e537ea 100644 --- a/src/api/api_datatype.cpp +++ b/src/api/api_datatype.cpp @@ -137,7 +137,7 @@ extern "C" { func_decl* decl = (decls)[i]; mk_c(c)->save_multiple_ast_trail(decl); enum_consts[i] = of_func_decl(decl); - decl = dt_util.get_constructor_recognizer(decl); + decl = dt_util.get_constructor_is(decl); mk_c(c)->save_multiple_ast_trail(decl); enum_testers[i] = of_func_decl(decl); } @@ -196,7 +196,7 @@ extern "C" { *nil_decl = of_func_decl(f); } if (is_nil_decl) { - f = data_util.get_constructor_recognizer(cnstrs[0]); + f = data_util.get_constructor_is(cnstrs[0]); mk_c(c)->save_multiple_ast_trail(f); *is_nil_decl = of_func_decl(f); } @@ -206,7 +206,7 @@ extern "C" { *cons_decl = of_func_decl(f); } if (is_cons_decl) { - f = data_util.get_constructor_recognizer(cnstrs[1]); + f = data_util.get_constructor_is(cnstrs[1]); mk_c(c)->save_multiple_ast_trail(f); *is_cons_decl = of_func_decl(f); } @@ -290,7 +290,7 @@ extern "C" { *constructor_decl = of_func_decl(f); } if (tester) { - func_decl* f2 = data_util.get_constructor_recognizer(f); + func_decl* f2 = data_util.get_constructor_is(f); mk_c(c)->save_multiple_ast_trail(f2); *tester = of_func_decl(f2); } @@ -497,7 +497,7 @@ extern "C" { RETURN_Z3(nullptr); } func_decl* decl = (decls)[idx]; - decl = dt_util.get_constructor_recognizer(decl); + decl = dt_util.get_constructor_is(decl); mk_c(c)->save_ast_trail(decl); RETURN_Z3(of_func_decl(decl)); Z3_CATCH_RETURN(nullptr); diff --git a/src/ast/datatype_decl_plugin.cpp b/src/ast/datatype_decl_plugin.cpp index 722cb22b5..44f824959 100644 --- a/src/ast/datatype_decl_plugin.cpp +++ b/src/ast/datatype_decl_plugin.cpp @@ -791,13 +791,20 @@ namespace datatype { return res; } + + func_decl * util::get_constructor_is(func_decl * con) { + SASSERT(is_constructor(con)); + sort * datatype = con->get_range(); + parameter ps[1] = { parameter(con)}; + return m.mk_func_decl(m_family_id, OP_DT_IS, 1, ps, 1, &datatype); + } + func_decl * util::get_constructor_recognizer(func_decl * con) { SASSERT(is_constructor(con)); func_decl * d = nullptr; if (m_constructor2recognizer.find(con, d)) return d; sort * datatype = con->get_range(); -#if 0 def const& dd = get_def(datatype); symbol r; for (constructor const* c : dd) { @@ -812,14 +819,6 @@ namespace datatype { m_asts.push_back(d); m_constructor2recognizer.insert(con, d); return d; -#else - parameter ps[1] = { parameter(con)}; - d = m.mk_func_decl(m_family_id, OP_DT_IS, 1, ps, 1, &datatype); - m_constructor2recognizer.insert(con, d); - m_asts.push_back(d); - m_asts.push_back(con); - return d; -#endif } func_decl * util::get_recognizer_constructor(func_decl * recognizer) const { @@ -1049,15 +1048,11 @@ namespace datatype { sort* s = todo.back(); todo.pop_back(); out << s->get_name() << " =\n"; - ptr_vector const& cnstrs = *get_datatype_constructors(s); - for (unsigned i = 0; i < cnstrs.size(); ++i) { - func_decl* cns = cnstrs[i]; - func_decl* rec = get_constructor_recognizer(cns); - out << " " << cns->get_name() << " :: " << rec->get_name() << " :: "; + for (func_decl * cns : cnstrs) { + out << " " << cns->get_name() << " :: "; ptr_vector const & accs = *get_constructor_accessors(cns); - for (unsigned j = 0; j < accs.size(); ++j) { - func_decl* acc = accs[j]; + for (func_decl* acc : accs) { sort* s1 = acc->get_range(); out << "(" << acc->get_name() << ": " << s1->get_name() << ") "; if (is_datatype(s1) && are_siblings(s1, s0) && !mark.is_marked(s1)) { diff --git a/src/ast/datatype_decl_plugin.h b/src/ast/datatype_decl_plugin.h index 81c2d09a5..e644ccbda 100644 --- a/src/ast/datatype_decl_plugin.h +++ b/src/ast/datatype_decl_plugin.h @@ -368,6 +368,7 @@ namespace datatype { sort* get_datatype_parameter_sort(sort * ty, unsigned idx); func_decl * get_non_rec_constructor(sort * ty); func_decl * get_constructor_recognizer(func_decl * constructor); + func_decl * get_constructor_is(func_decl * constructor); ptr_vector const * get_constructor_accessors(func_decl * constructor); func_decl * get_accessor_constructor(func_decl * accessor); func_decl * get_recognizer_constructor(func_decl * recognizer) const; diff --git a/src/cmd_context/cmd_context.cpp b/src/cmd_context/cmd_context.cpp index 0be458b4a..aabe43110 100644 --- a/src/cmd_context/cmd_context.cpp +++ b/src/cmd_context/cmd_context.cpp @@ -2015,9 +2015,8 @@ void cmd_context::dt_eh::operator()(sort * dt, pdecl* pd) { for (func_decl * c : *m_dt_util.get_datatype_constructors(dt)) { TRACE("new_dt_eh", tout << "new constructor: " << c->get_name() << "\n";); m_owner.insert(c); - // Don't insert recognizer any longer. It is a built-in function. - // func_decl * r = m_dt_util.get_constructor_recognizer(c); - // m_owner.insert(r); + func_decl * r = m_dt_util.get_constructor_recognizer(c); + m_owner.insert(r); // TRACE("new_dt_eh", tout << "new recognizer: " << r->get_name() << "\n";); for (func_decl * a : *m_dt_util.get_constructor_accessors(c)) { TRACE("new_dt_eh", tout << "new accessor: " << a->get_name() << "\n";); diff --git a/src/muz/pdr/pdr_prop_solver.cpp b/src/muz/pdr/pdr_prop_solver.cpp index 801d06e50..8ebc9b9cb 100644 --- a/src/muz/pdr/pdr_prop_solver.cpp +++ b/src/muz/pdr/pdr_prop_solver.cpp @@ -133,7 +133,7 @@ namespace pdr { else if ((m.is_eq(e, c, val) && is_app(val) && dt.is_constructor(to_app(val))) || (m.is_eq(e, val, c) && is_app(val) && dt.is_constructor(to_app(val)))){ func_decl* f = to_app(val)->get_decl(); - func_decl* r = dt.get_constructor_recognizer(f); + func_decl* r = dt.get_constructor_is(f); conjs[i] = m.mk_app(r, c); ptr_vector const& acc = *dt.get_constructor_accessors(f); for (unsigned j = 0; j < acc.size(); ++j) { diff --git a/src/muz/spacer/spacer_util.cpp b/src/muz/spacer/spacer_util.cpp index cdec5d7eb..625ac4b7b 100644 --- a/src/muz/spacer/spacer_util.cpp +++ b/src/muz/spacer/spacer_util.cpp @@ -694,7 +694,7 @@ void expand_literals(ast_manager &m, expr_ref_vector& conjs) } else if ((m.is_eq(e, c, val) && is_app(val) && dt.is_constructor(to_app(val))) || (m.is_eq(e, val, c) && is_app(val) && dt.is_constructor(to_app(val)))){ func_decl* f = to_app(val)->get_decl(); - func_decl* r = dt.get_constructor_recognizer(f); + func_decl* r = dt.get_constructor_is(f); conjs[i] = m.mk_app(r, c); ptr_vector const& acc = *dt.get_constructor_accessors(f); for (unsigned j = 0; j < acc.size(); ++j) { diff --git a/src/parsers/smt2/smt2parser.cpp b/src/parsers/smt2/smt2parser.cpp index 347cbbd68..9265312d4 100644 --- a/src/parsers/smt2/smt2parser.cpp +++ b/src/parsers/smt2/smt2parser.cpp @@ -1414,7 +1414,7 @@ namespace smt2 { else { SASSERT(is_app(pattern)); func_decl * f = to_app(pattern)->get_decl(); - func_decl * r = dtutil().get_constructor_recognizer(f); + func_decl * r = dtutil().get_constructor_is(f); ptr_vector const * acc = dtutil().get_constructor_accessors(f); shifter()(t, acc->size(), tsh); for (func_decl* a : *acc) { diff --git a/src/qe/qe_datatype_plugin.cpp b/src/qe/qe_datatype_plugin.cpp index 58878d067..81a402ba4 100644 --- a/src/qe/qe_datatype_plugin.cpp +++ b/src/qe/qe_datatype_plugin.cpp @@ -261,7 +261,7 @@ namespace qe { return false; } func_decl* c = a->get_decl(); - func_decl* r = m_util.get_constructor_recognizer(c); + func_decl_ref r(m_util.get_constructor_is(c), m); ptr_vector const & acc = *m_util.get_constructor_accessors(c); SASSERT(acc.size() == a->get_num_args()); // @@ -380,7 +380,7 @@ namespace qe { } func_decl* c = l->get_decl(); ptr_vector const& acc = *m_util.get_constructor_accessors(c); - func_decl* rec = m_util.get_constructor_recognizer(c); + func_decl* rec = m_util.get_constructor_is(c); expr_ref_vector conj(m); conj.push_back(m.mk_app(rec, r)); for (unsigned i = 0; i < acc.size(); ++i) { @@ -627,7 +627,7 @@ namespace qe { // if (!has_recognizer(x, fml, r, c)) { c = m_datatype_util.get_datatype_constructors(s)->get(vl.get_unsigned()); - r = m_datatype_util.get_constructor_recognizer(c); + r = m_datatype_util.get_constructor_is(c); app* is_c = m.mk_app(r, x); // assert v => r(x) m_ctx.add_constraint(true, is_c); @@ -674,7 +674,7 @@ namespace qe { // if (!has_recognizer(x, fml, r, c)) { c = m_datatype_util.get_datatype_constructors(s)->get(vl.get_unsigned()); - r = m_datatype_util.get_constructor_recognizer(c); + r = m_datatype_util.get_constructor_is(c); app* is_c = m.mk_app(r, x); fml = m.mk_and(is_c, fml); app_ref fresh_x(m.mk_fresh_const("x", s), m); @@ -775,7 +775,7 @@ namespace qe { } c = m_datatype_util.get_datatype_constructors(s)->get(vl.get_unsigned()); - r = m_datatype_util.get_constructor_recognizer(c); + r = m_datatype_util.get_constructor_is(c); app* is_c = m.mk_app(r, x); // assert v => r(x) diff --git a/src/qe/qe_datatypes.cpp b/src/qe/qe_datatypes.cpp index db1e6ec85..770beb59d 100644 --- a/src/qe/qe_datatypes.cpp +++ b/src/qe/qe_datatypes.cpp @@ -151,7 +151,7 @@ namespace qe { return false; } func_decl* c = a->get_decl(); - func_decl* rec = dt.get_constructor_recognizer(c); + func_decl_ref rec(dt.get_constructor_is(c), m); ptr_vector const & acc = *dt.get_constructor_accessors(c); SASSERT(acc.size() == a->get_num_args()); // @@ -232,7 +232,7 @@ namespace qe { func_decl* c = to_app(l)->get_decl(); ptr_vector const& acc = *dt.get_constructor_accessors(c); if (!is_app_of(r, c)) { - lits.push_back(m.mk_app(dt.get_constructor_recognizer(c), r)); + lits.push_back(m.mk_app(dt.get_constructor_is(c), r)); } for (unsigned i = 0; i < acc.size(); ++i) { lits.push_back(m.mk_eq(to_app(l)->get_arg(i), access(c, i, acc, r))); diff --git a/src/qe/qe_lite.cpp b/src/qe/qe_lite.cpp index 8cbf6c70f..e96626479 100644 --- a/src/qe/qe_lite.cpp +++ b/src/qe/qe_lite.cpp @@ -692,7 +692,7 @@ namespace eq { } } else { - func_decl* rec = dt.get_constructor_recognizer(d); + func_decl* rec = dt.get_constructor_is(d); conjs.push_back(m.mk_app(rec, r)); ptr_vector const& acc = *dt.get_constructor_accessors(d); for (unsigned i = 0; i < acc.size(); ++i) { diff --git a/src/smt/theory_datatype.cpp b/src/smt/theory_datatype.cpp index 695d479f4..3d3d56055 100644 --- a/src/smt/theory_datatype.cpp +++ b/src/smt/theory_datatype.cpp @@ -167,7 +167,7 @@ namespace smt { func_decl * upd = n->get_decl(); func_decl * acc = to_func_decl(upd->get_parameter(0).get_ast()); func_decl * con = m_util.get_accessor_constructor(acc); - func_decl * rec = m_util.get_constructor_recognizer(con); + func_decl * rec = m_util.get_constructor_is(con); ptr_vector const & accessors = *m_util.get_constructor_accessors(con); app_ref rec_app(m.mk_app(rec, arg1), m); ctx.internalize(rec_app, false); @@ -710,7 +710,7 @@ namespace smt { literal consequent; if (!r) { ptr_vector const & constructors = *m_util.get_datatype_constructors(dt); - func_decl * rec = m_util.get_constructor_recognizer(constructors[unassigned_idx]); + func_decl * rec = m_util.get_constructor_is(constructors[unassigned_idx]); app * rec_app = get_manager().mk_app(rec, n->get_owner()); ctx.internalize(rec_app, false); consequent = literal(ctx.get_bool_var(rec_app)); @@ -751,12 +751,12 @@ namespace smt { m_stats.m_splits++; if (d->m_recognizers.empty()) { - r = m_util.get_constructor_recognizer(non_rec_c); + r = m_util.get_constructor_is(non_rec_c); } else { enode * recognizer = d->m_recognizers[non_rec_idx]; if (recognizer == nullptr) { - r = m_util.get_constructor_recognizer(non_rec_c); + r = m_util.get_constructor_is(non_rec_c); } else if (!ctx.is_relevant(recognizer)) { ctx.mark_as_relevant(recognizer); @@ -776,7 +776,7 @@ namespace smt { if (curr == nullptr) { ptr_vector const & constructors = *m_util.get_datatype_constructors(s); // found empty slot... - r = m_util.get_constructor_recognizer(constructors[idx]); + r = m_util.get_constructor_is(constructors[idx]); break; } else if (!ctx.is_relevant(curr)) { From 205d77d5919d5f3d25e68631d9a3dd2a252352b4 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Sat, 3 Mar 2018 19:26:31 -0800 Subject: [PATCH 019/109] save last model to ensure it is available fixes #1514 Signed-off-by: Nikolaj Bjorner --- src/opt/opt_solver.cpp | 7 ++++++- src/opt/opt_solver.h | 1 + 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/src/opt/opt_solver.cpp b/src/opt/opt_solver.cpp index 715f45291..c5363816a 100644 --- a/src/opt/opt_solver.cpp +++ b/src/opt/opt_solver.cpp @@ -227,9 +227,13 @@ namespace opt { smt::theory_var v = m_objective_vars[i]; bool has_shared = false; inf_eps val = get_optimizer().maximize(v, blocker, has_shared); + get_model(m_model); inf_eps val2; m_valid_objectives[i] = true; TRACE("opt", tout << (has_shared?"has shared":"non-shared") << "\n";); + if (!m_models[i]) { + set_model(i); + } if (m_context.get_context().update_model(has_shared)) { if (has_shared && val != current_objective_value(i)) { decrement_value(i, val); @@ -247,7 +251,7 @@ namespace opt { tout << "objective: " << mk_pp(m_objective_terms[i].get(), m) << "\n"; tout << "maximal value: " << val << "\n"; tout << "new condition: " << blocker << "\n"; - model_smt2_pp(tout << "update model:\n", m, *m_models[i], 0); }); + if (m_models[i]) model_smt2_pp(tout << "update model:\n", m, *m_models[i], 0); }); } void opt_solver::set_model(unsigned i) { @@ -299,6 +303,7 @@ namespace opt { void opt_solver::get_model(model_ref & m) { m_context.get_model(m); + if (!m) m = m_model; else m_model = m; } proof * opt_solver::get_proof() { diff --git a/src/opt/opt_solver.h b/src/opt/opt_solver.h index 41e9dee2d..ac9884770 100644 --- a/src/opt/opt_solver.h +++ b/src/opt/opt_solver.h @@ -73,6 +73,7 @@ namespace opt { filter_model_converter& m_fm; progress_callback * m_callback; symbol m_logic; + model_ref m_model; svector m_objective_vars; vector m_objective_values; sref_vector m_models; From a64fd7145c381eed2be11d68c190b65760fb4261 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Sun, 4 Mar 2018 03:36:03 -0800 Subject: [PATCH 020/109] remove buggy legacy code, rely on pull_cheap_ite option in rewriter, #1511 Signed-off-by: Nikolaj Bjorner --- src/ast/rewriter/CMakeLists.txt | 1 - src/ast/rewriter/pull_ite_tree.cpp | 221 ------------------------- src/ast/rewriter/pull_ite_tree.h | 113 ------------- src/smt/asserted_formulas.cpp | 4 +- src/smt/asserted_formulas.h | 4 - src/smt/params/preprocessor_params.cpp | 2 +- src/smt/params/preprocessor_params.h | 4 +- src/smt/smt_setup.cpp | 2 +- 8 files changed, 5 insertions(+), 346 deletions(-) delete mode 100644 src/ast/rewriter/pull_ite_tree.cpp delete mode 100644 src/ast/rewriter/pull_ite_tree.h diff --git a/src/ast/rewriter/CMakeLists.txt b/src/ast/rewriter/CMakeLists.txt index 57924b48a..f030e2704 100644 --- a/src/ast/rewriter/CMakeLists.txt +++ b/src/ast/rewriter/CMakeLists.txt @@ -25,7 +25,6 @@ z3_add_component(rewriter pb_rewriter.cpp pb2bv_rewriter.cpp push_app_ite.cpp - pull_ite_tree.cpp quant_hoist.cpp rewriter.cpp seq_rewriter.cpp diff --git a/src/ast/rewriter/pull_ite_tree.cpp b/src/ast/rewriter/pull_ite_tree.cpp deleted file mode 100644 index 61114387c..000000000 --- a/src/ast/rewriter/pull_ite_tree.cpp +++ /dev/null @@ -1,221 +0,0 @@ -/*++ -Copyright (c) 2006 Microsoft Corporation - -Module Name: - - pull_ite_tree.cpp - -Abstract: - - - -Author: - - Leonardo de Moura (leonardo) 2008-06-22. - -Revision History: - ---*/ -#include "ast/rewriter/pull_ite_tree.h" -#include "ast/recurse_expr_def.h" -#include "ast/for_each_expr.h" -#include "ast/ast_pp.h" - -pull_ite_tree::pull_ite_tree(ast_manager & m): - m_manager(m), - m_rewriter(m), - m_cache(m) { -} - -void pull_ite_tree::cache_result(expr * n, expr * r, proof * pr) { - m_cache.insert(n, r, pr); -} - -void pull_ite_tree::visit(expr * n, bool & visited) { - if (!is_cached(n)) { - m_todo.push_back(n); - visited = false; - } -} - -bool pull_ite_tree::visit_children(expr * n) { - if (m_manager.is_ite(n)) { - bool visited = true; - visit(to_app(n)->get_arg(1), visited); - visit(to_app(n)->get_arg(2), visited); - return visited; - } - else { - return true; - } -} - -void pull_ite_tree::reduce(expr * n) { - // Remark: invoking the simplifier to build the new expression saves a lot of memory. - if (m_manager.is_ite(n)) { - expr * c = to_app(n)->get_arg(0); - expr * t_old = to_app(n)->get_arg(1); - expr * e_old = to_app(n)->get_arg(2); - expr * t = nullptr; - proof * t_pr = nullptr; - expr * e = nullptr; - proof * e_pr = nullptr; - get_cached(t_old, t, t_pr); - get_cached(e_old, e, e_pr); - expr_ref r(m_manager); - expr * args[3] = {c, t, e}; - r = m_rewriter.mk_app(to_app(n)->get_decl(), 3, args); - if (!m_manager.proofs_enabled()) { - // expr * r = m_manager.mk_ite(c, t, e); - cache_result(n, r, nullptr); - } - else { - // t_pr is a proof for (m_p ... t_old ...) == t - // e_pr is a proof for (m_p ... e_old ...) == e - expr_ref old(m_manager); - expr_ref p_t_old(m_manager); - expr_ref p_e_old(m_manager); - old = mk_p_arg(n); // (m_p ... n ...) where n is (ite c t_old e_old) - p_t_old = mk_p_arg(t_old); // (m_p ... t_old ...) - p_e_old = mk_p_arg(e_old); // (m_p ... e_old ...) - expr_ref tmp1(m_manager); - tmp1 = m_manager.mk_ite(c, p_t_old, p_e_old); // (ite c (m_p ... t_old ...) (m_p ... e_old ...)) - proof * pr1 = m_manager.mk_rewrite(old, tmp1); // proof for (m_p ... (ite c t_old e_old) ...) = (ite c (m_p ... t_old ...) (m_p ... e_old ...)) - expr_ref tmp2(m_manager); - tmp2 = m_manager.mk_ite(c, t, e); // (ite c t e) - proof * pr2 = nullptr; // it will contain a proof for (ite c (m_p ... t_old ...) (m_p ... e_old ...)) = (ite c t e) - proof * pr3 = nullptr; // it will contain a proof for (m_p ... (ite c t_old e_old) ...) = (ite c t e) - proof * proofs[2]; - unsigned num_proofs = 0; - if (t_pr != nullptr) { - proofs[num_proofs] = t_pr; - num_proofs++; - } - if (e_pr != nullptr) { - proofs[num_proofs] = e_pr; - num_proofs++; - } - if (num_proofs > 0) { - pr2 = m_manager.mk_congruence(to_app(tmp1), to_app(tmp2), num_proofs, proofs); - pr3 = m_manager.mk_transitivity(pr1, pr2); - } - else { - pr3 = pr1; - } - proof * pr4 = nullptr; // it will contain a proof for (ite c t e) = r - proof * pr5 = nullptr; // it will contain a proof for (m_p ... (ite c t_old e_old) ...) = r - if (tmp2 != r) { - pr4 = m_manager.mk_rewrite(tmp2, r); - pr5 = m_manager.mk_transitivity(pr3, pr4); - } - else { - pr5 = pr3; - } - cache_result(n, r, pr5); - } - } - else { - expr_ref r(m_manager); - m_args[m_arg_idx] = n; - r = m_rewriter.mk_app(m_p, m_args.size(), m_args.c_ptr()); - if (!m_manager.proofs_enabled()) { - // expr * r = m_manager.mk_app(m_p, m_args.size(), m_args.c_ptr()); - cache_result(n, r, nullptr); - } - else { - expr_ref old(m_manager); - proof * p; - old = mk_p_arg(n); - if (old == r) - p = nullptr; - else - p = m_manager.mk_rewrite(old, r); - cache_result(n, r, p); - } - } -} - -void pull_ite_tree::operator()(app * n, app_ref & r, proof_ref & pr) { - unsigned num_args = n->get_num_args(); - m_args.resize(num_args); - m_p = n->get_decl(); - expr * ite = nullptr; - for (unsigned i = 0; i < num_args; i++) { - expr * arg = n->get_arg(i); - if (ite) { - m_args[i] = arg; - } - else if (m_manager.is_ite(arg)) { - m_arg_idx = i; - m_args[i] = 0; - ite = arg; - } - else { - m_args[i] = arg; - } - } - if (!ite) { - r = n; - pr = nullptr; - return; - } - m_todo.push_back(ite); - while (!m_todo.empty()) { - expr * n = m_todo.back(); - if (is_cached(n)) - m_todo.pop_back(); - else if (visit_children(n)) { - m_todo.pop_back(); - reduce(n); - } - } - SASSERT(is_cached(ite)); - expr * _r = nullptr; - proof * _pr = nullptr; - get_cached(ite, _r, _pr); - r = to_app(_r); - pr = _pr; - m_cache.reset(); - m_todo.reset(); -} - - - -pull_ite_tree_cfg::pull_ite_tree_cfg(ast_manager & m): - m(m), - m_trail(m), - m_proc(m) { -} - -bool pull_ite_tree_cfg::get_subst(expr * n, expr* & r, proof* & p) { - if (is_app(n) && is_target(to_app(n))) { - app_ref tmp(m); - proof_ref pr(m); - m_proc(to_app(n), tmp, pr); - if (tmp != n) { - r = tmp; - p = pr; - m_trail.push_back(r); - m_trail.push_back(p); - return true; - } - } - return false; -} - -bool pull_cheap_ite_tree_cfg::is_target(app * n) const { - bool r = - n->get_num_args() == 2 && - n->get_family_id() != null_family_id && - m.is_bool(n) && - (m.is_value(n->get_arg(0)) || m.is_value(n->get_arg(1))) && - (m.is_term_ite(n->get_arg(0)) || m.is_term_ite(n->get_arg(1))); - TRACE("pull_ite_target", tout << mk_pp(n, m) << "\nresult: " << r << "\n";); - return r; -} - - - - - - diff --git a/src/ast/rewriter/pull_ite_tree.h b/src/ast/rewriter/pull_ite_tree.h deleted file mode 100644 index ea462315a..000000000 --- a/src/ast/rewriter/pull_ite_tree.h +++ /dev/null @@ -1,113 +0,0 @@ -/*++ -Copyright (c) 2006 Microsoft Corporation - -Module Name: - - pull_ite_tree.h - -Abstract: - - - -Author: - - Leonardo de Moura (leonardo) 2008-06-22. - -Revision History: - ---*/ -#ifndef PULL_ITE_TREE_H_ -#define PULL_ITE_TREE_H_ - -#include "ast/ast.h" -#include "ast/rewriter/rewriter.h" -#include "ast/rewriter/th_rewriter.h" -#include "ast/expr_map.h" -#include "ast/recurse_expr.h" -#include "util/obj_hashtable.h" - -/** - \brief Functor for applying the following transformation - F[(p (ite c t1 t2) args)] = F'[(ite c t1 t2), p, args] - - F'[(ite c t1 t2), p, args] = (ite c F'[t1, p, args] F'[t2, p, args]) - F'[t, p, args] = (p t args) -*/ -class pull_ite_tree { - ast_manager & m_manager; - th_rewriter m_rewriter; - func_decl * m_p; - ptr_vector m_args; - unsigned m_arg_idx; //!< position of the ite argument - expr_map m_cache; - ptr_vector m_todo; - - bool is_cached(expr * n) const { return m_cache.contains(n); } - void get_cached(expr * n, expr * & r, proof * & p) const { m_cache.get(n, r, p); } - void cache_result(expr * n, expr * r, proof * pr); - void visit(expr * n, bool & visited); - bool visit_children(expr * n); - void reduce(expr * n); - /** - \brief Creante an application (m_p ... n ...) where n is the argument m_arg_idx and the other arguments - are in m_args. - */ - expr * mk_p_arg(expr * n) { - m_args[m_arg_idx] = n; - return m_manager.mk_app(m_p, m_args.size(), m_args.c_ptr()); - } -public: - pull_ite_tree(ast_manager & m); - /** - \brief Apply the transformation above if n contains an ite-expression. - Store the result in r. If n does not contain an ite-expression, then - store n in r. - - When proof generation is enabled, pr is a proof for n = r. - */ - void operator()(app * n, app_ref & r, proof_ref & pr); -}; - -/** - \brief Functor for applying the pull_ite_tree on subexpressions n that - satisfy the is_target virtual predicate. -*/ -class pull_ite_tree_cfg : public default_rewriter_cfg { -protected: - ast_manager& m; - expr_ref_vector m_trail; - pull_ite_tree m_proc; -public: - pull_ite_tree_cfg(ast_manager & m); - virtual ~pull_ite_tree_cfg() {} - virtual bool is_target(app * n) const = 0; - bool get_subst(expr * n, expr* & r, proof* & p); -}; - -/** - \brief Apply pull_ite_tree on predicates of the form - (p ite v) and (p v ite) - - where: - - p is an interpreted predicate - - ite is an ite-term expression - - v is a value -*/ -class pull_cheap_ite_tree_cfg : public pull_ite_tree_cfg { -public: - pull_cheap_ite_tree_cfg(ast_manager & m):pull_ite_tree_cfg(m) {} - ~pull_cheap_ite_tree_cfg() override {} - bool is_target(app * n) const override; -}; - -class pull_cheap_ite_tree_rw : public rewriter_tpl { - pull_cheap_ite_tree_cfg m_cfg; -public: - pull_cheap_ite_tree_rw(ast_manager& m): - rewriter_tpl(m, m.proofs_enabled(), m_cfg), - m_cfg(m) - {} -}; - -#endif /* PULL_ITE_TREE_H_ */ - diff --git a/src/smt/asserted_formulas.cpp b/src/smt/asserted_formulas.cpp index 465371434..5903fefcb 100644 --- a/src/smt/asserted_formulas.cpp +++ b/src/smt/asserted_formulas.cpp @@ -46,7 +46,6 @@ asserted_formulas::asserted_formulas(ast_manager & m, smt_params & p): m_refine_inj_axiom(*this), m_max_bv_sharing_fn(*this), m_elim_term_ite(*this), - m_pull_cheap_ite_trees(*this), m_pull_nested_quantifiers(*this), m_elim_bvs_from_quantifiers(*this), m_cheap_quant_fourier_motzkin(*this), @@ -122,7 +121,7 @@ void asserted_formulas::set_eliminate_and(bool flag) { if (flag == m_elim_and) return; m_elim_and = flag; params_ref p; - p.set_bool("pull_cheap_ite", false); + if (m_params.m_pull_cheap_ite) p.set_bool("pull_cheap_ite", true); p.set_bool("elim_and", flag); p.set_bool("arith_ineq_lhs", true); p.set_bool("sort_sums", true); @@ -241,7 +240,6 @@ void asserted_formulas::reduce() { if (!invoke(m_nnf_cnf)) return; set_eliminate_and(true); if (!invoke(m_reduce_asserted_formulas)) return; - if (!invoke(m_pull_cheap_ite_trees)) return; if (!invoke(m_pull_nested_quantifiers)) return; if (!invoke(m_lift_ite)) return; if (!invoke(m_ng_lift_ite)) return; diff --git a/src/smt/asserted_formulas.h b/src/smt/asserted_formulas.h index a67b975eb..275687adb 100644 --- a/src/smt/asserted_formulas.h +++ b/src/smt/asserted_formulas.h @@ -26,7 +26,6 @@ Revision History: #include "ast/rewriter/bit2int.h" #include "ast/rewriter/maximize_ac_sharing.h" #include "ast/rewriter/distribute_forall.h" -#include "ast/rewriter/pull_ite_tree.h" #include "ast/rewriter/push_app_ite.h" #include "ast/rewriter/inj_axiom.h" #include "ast/rewriter/bv_elim.h" @@ -172,7 +171,6 @@ class asserted_formulas { #define MK_SIMPLIFIERF(NAME, FUNCTOR, MSG, APP, REDUCE) MK_SIMPLIFIERA(NAME, FUNCTOR, MSG, APP, (af.m), REDUCE) - MK_SIMPLIFIERF(pull_cheap_ite_trees, pull_cheap_ite_tree_rw, "pull-cheap-ite-trees", af.m_params.m_pull_cheap_ite_trees, false); MK_SIMPLIFIERF(pull_nested_quantifiers, pull_nested_quant, "pull-nested-quantifiers", af.m_params.m_pull_nested_quantifiers && af.has_quantifiers(), false); MK_SIMPLIFIERF(cheap_quant_fourier_motzkin, elim_bounds_rw, "cheap-fourier-motzkin", af.m_params.m_eliminate_bounds && af.has_quantifiers(), true); MK_SIMPLIFIERF(elim_bvs_from_quantifiers, bv_elim_rw, "eliminate-bit-vectors-from-quantifiers", af.m_params.m_bb_quantifiers, true); @@ -187,7 +185,6 @@ class asserted_formulas { refine_inj_axiom_fn m_refine_inj_axiom; max_bv_sharing_fn m_max_bv_sharing_fn; elim_term_ite_fn m_elim_term_ite; - pull_cheap_ite_trees m_pull_cheap_ite_trees; pull_nested_quantifiers m_pull_nested_quantifiers; elim_bvs_from_quantifiers m_elim_bvs_from_quantifiers; cheap_quant_fourier_motzkin m_cheap_quant_fourier_motzkin; @@ -219,7 +216,6 @@ class asserted_formulas { bool is_gt(expr* lhs, expr* rhs); void compute_depth(expr* e); unsigned depth(expr* e) { return m_expr2depth[e]; } - bool pull_cheap_ite_trees(); void init(unsigned num_formulas, expr * const * formulas, proof * const * prs); diff --git a/src/smt/params/preprocessor_params.cpp b/src/smt/params/preprocessor_params.cpp index 93ea794fa..ee4b7c2e4 100644 --- a/src/smt/params/preprocessor_params.cpp +++ b/src/smt/params/preprocessor_params.cpp @@ -41,7 +41,7 @@ void preprocessor_params::display(std::ostream & out) const { DISPLAY_PARAM(m_lift_ite); DISPLAY_PARAM(m_ng_lift_ite); - DISPLAY_PARAM(m_pull_cheap_ite_trees); + DISPLAY_PARAM(m_pull_cheap_ite); DISPLAY_PARAM(m_pull_nested_quantifiers); DISPLAY_PARAM(m_eliminate_term_ite); DISPLAY_PARAM(m_macro_finder); diff --git a/src/smt/params/preprocessor_params.h b/src/smt/params/preprocessor_params.h index dc16d6244..be7fd4c01 100644 --- a/src/smt/params/preprocessor_params.h +++ b/src/smt/params/preprocessor_params.h @@ -32,7 +32,7 @@ struct preprocessor_params : public pattern_inference_params, public bit_blaster_params { lift_ite_kind m_lift_ite; lift_ite_kind m_ng_lift_ite; // lift ite for non ground terms - bool m_pull_cheap_ite_trees; + bool m_pull_cheap_ite; bool m_pull_nested_quantifiers; bool m_eliminate_term_ite; bool m_macro_finder; @@ -54,7 +54,7 @@ public: preprocessor_params(params_ref const & p = params_ref()): m_lift_ite(LI_NONE), m_ng_lift_ite(LI_NONE), - m_pull_cheap_ite_trees(false), + m_pull_cheap_ite(false), m_pull_nested_quantifiers(false), m_eliminate_term_ite(false), m_macro_finder(false), diff --git a/src/smt/smt_setup.cpp b/src/smt/smt_setup.cpp index bbc91e4c6..383d98e67 100644 --- a/src/smt/smt_setup.cpp +++ b/src/smt/smt_setup.cpp @@ -507,7 +507,7 @@ namespace smt { m_params.m_nnf_cnf = false; if (st.m_max_ite_tree_depth > 50) { m_params.m_arith_eq2ineq = false; - m_params.m_pull_cheap_ite_trees = true; + m_params.m_pull_cheap_ite = true; m_params.m_arith_propagate_eqs = true; m_params.m_relevancy_lvl = 2; m_params.m_relevancy_lemma = false; From 534a31f74e81ab880fbb28dbf829e036d7a3957c Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Sun, 4 Mar 2018 05:06:36 -0800 Subject: [PATCH 021/109] inherit solver parameters in asserted formulas rewriter. #1511 Signed-off-by: Nikolaj Bjorner --- src/smt/asserted_formulas.cpp | 4 ++++ src/smt/asserted_formulas.h | 1 + src/smt/params/preprocessor_params.cpp | 1 + src/smt/smt_context.cpp | 4 ++++ src/smt/smt_context.h | 2 ++ src/smt/smt_kernel.cpp | 10 +++------- src/test/heap.cpp | 5 ++++- 7 files changed, 19 insertions(+), 8 deletions(-) diff --git a/src/smt/asserted_formulas.cpp b/src/smt/asserted_formulas.cpp index 5903fefcb..444069d8c 100644 --- a/src/smt/asserted_formulas.cpp +++ b/src/smt/asserted_formulas.cpp @@ -117,6 +117,10 @@ void asserted_formulas::push_assertion(expr * e, proof * pr, vector& mutexes) { return m_kernel.find_mutexes(vars, mutexes); } @@ -196,9 +195,7 @@ namespace smt { } void updt_params(params_ref const & p) { - // We don't need params2smt_params anymore. smt_params has support for reading params_ref. - // The update is performed at smt_kernel "users". - // params2smt_params(p, fparams()); + m_kernel.updt_params(p); } }; @@ -218,7 +215,6 @@ namespace smt { imp::copy(*src.m_imp, *dst.m_imp); } - bool kernel::set_logic(symbol logic) { return m_imp->set_logic(logic); } @@ -263,9 +259,9 @@ namespace smt { } void kernel::reset() { - ast_manager & _m = m(); + ast_manager & _m = m(); smt_params & fps = m_imp->fparams(); - params_ref ps = m_imp->params(); + params_ref ps = m_imp->params(); #pragma omp critical (smt_kernel) { m_imp->~imp(); diff --git a/src/test/heap.cpp b/src/test/heap.cpp index 08891ccaa..2c77b939e 100644 --- a/src/test/heap.cpp +++ b/src/test/heap.cpp @@ -21,16 +21,19 @@ Revision History: #include "util/heap.h" #include "util/trace.h" #include "util/uint_set.h" +// include "util/hashtable.h" struct lt_proc { bool operator()(int v1, int v2) const { return v1 < v2; } }; +//struct int_hash_proc { unsigned operator()(int v) const { std::cout << "hash " << v << "\n"; VERIFY(v >= 0); return v; }}; +//typedef int_hashtable > int_set; typedef heap int_heap; -struct int_hash_proc { unsigned operator()(int v) const { return v * 17; }}; #define N 10000 static random_gen heap_rand(1); static void tst1() { int_heap h(N); +// int_set t; uint_set t; for (int i = 0; i < N * 3; i++) { int val = heap_rand() % N; From eb1122c5cb434338e25b87e7d94c7c6d56be02f8 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Sun, 4 Mar 2018 21:57:08 -0800 Subject: [PATCH 022/109] delay updating parameters to ensure rewriting in asserted_formulas is applied using configuration overrides. Fixes build regression for tree_interpolation documentation test Signed-off-by: Nikolaj Bjorner --- src/api/python/z3/z3.py | 2 +- src/smt/asserted_formulas.cpp | 44 +++++++++++++------------- src/smt/asserted_formulas.h | 37 +++++++++++----------- src/smt/mam.cpp | 2 +- src/smt/params/preprocessor_params.cpp | 1 - src/smt/smt_context.cpp | 2 +- src/smt/smt_relevancy.cpp | 6 ++-- src/smt/theory_seq.cpp | 1 - 8 files changed, 47 insertions(+), 48 deletions(-) diff --git a/src/api/python/z3/z3.py b/src/api/python/z3/z3.py index 785649e3d..1cfb10179 100644 --- a/src/api/python/z3/z3.py +++ b/src/api/python/z3/z3.py @@ -8266,7 +8266,7 @@ def tree_interpolant(pat,p=None,ctx=None): solver that determines satisfiability. >>> x = Int('x') - >>> y = Int('y') + >>> y = Int('y') >>> print(tree_interpolant(And(Interpolant(x < 0), Interpolant(y > 2), x == y))) [Not(x >= 0), Not(y <= 2)] diff --git a/src/smt/asserted_formulas.cpp b/src/smt/asserted_formulas.cpp index 444069d8c..ab9bb0895 100644 --- a/src/smt/asserted_formulas.cpp +++ b/src/smt/asserted_formulas.cpp @@ -27,8 +27,9 @@ Revision History: #include "ast/macros/quasi_macros.h" #include "smt/asserted_formulas.h" -asserted_formulas::asserted_formulas(ast_manager & m, smt_params & p): +asserted_formulas::asserted_formulas(ast_manager & m, smt_params & sp, params_ref const& p): m(m), + m_smt_params(sp), m_params(p), m_rewriter(m), m_substitution(m), @@ -65,20 +66,20 @@ asserted_formulas::asserted_formulas(ast_manager & m, smt_params & p): } void asserted_formulas::setup() { - switch (m_params.m_lift_ite) { + switch (m_smt_params.m_lift_ite) { case LI_FULL: - m_params.m_ng_lift_ite = LI_NONE; + m_smt_params.m_ng_lift_ite = LI_NONE; break; case LI_CONSERVATIVE: - if (m_params.m_ng_lift_ite == LI_CONSERVATIVE) - m_params.m_ng_lift_ite = LI_NONE; + if (m_smt_params.m_ng_lift_ite == LI_CONSERVATIVE) + m_smt_params.m_ng_lift_ite = LI_NONE; break; default: break; } - if (m_params.m_relevancy_lvl == 0) - m_params.m_relevancy_lemma = false; + if (m_smt_params.m_relevancy_lvl == 0) + m_smt_params.m_relevancy_lemma = false; } @@ -118,24 +119,23 @@ void asserted_formulas::push_assertion(expr * e, proof * pr, vector l(m_check_missing_instances, true); rematch(false); diff --git a/src/smt/params/preprocessor_params.cpp b/src/smt/params/preprocessor_params.cpp index 57b11e7fd..ee4b7c2e4 100644 --- a/src/smt/params/preprocessor_params.cpp +++ b/src/smt/params/preprocessor_params.cpp @@ -25,7 +25,6 @@ void preprocessor_params::updt_local_params(params_ref const & _p) { m_quasi_macros = p.quasi_macros(); m_restricted_quasi_macros = p.restricted_quasi_macros(); m_pull_nested_quantifiers = p.pull_nested_quantifiers(); -// m_pull_cheap_ite = _p.get_bool("pull_cheap_ite", m_pull_cheap_ite); m_refine_inj_axiom = p.refine_inj_axioms(); } diff --git a/src/smt/smt_context.cpp b/src/smt/smt_context.cpp index 513bf7665..e20eae0bd 100644 --- a/src/smt/smt_context.cpp +++ b/src/smt/smt_context.cpp @@ -45,7 +45,7 @@ namespace smt { m_fparams(p), m_params(_p), m_setup(*this, p), - m_asserted_formulas(m, p), + m_asserted_formulas(m, p, _p), m_qmanager(alloc(quantifier_manager, *this, p, _p)), m_model_generator(alloc(model_generator, m)), m_relevancy_propagator(mk_relevancy_propagator(*this)), diff --git a/src/smt/smt_relevancy.cpp b/src/smt/smt_relevancy.cpp index 9eabb8319..7db5110ee 100644 --- a/src/smt/smt_relevancy.cpp +++ b/src/smt/smt_relevancy.cpp @@ -527,7 +527,7 @@ namespace smt { } #ifdef Z3DEBUG - bool check_relevancy_app(app * n) const { + bool check_relevancy_app(app * n) const { SASSERT(is_relevant(n)); unsigned num_args = n->get_num_args(); for (unsigned i = 0; i < num_args; i++) { @@ -537,7 +537,7 @@ namespace smt { return true; } - virtual bool check_relevancy_or(app * n, bool root) const { + bool check_relevancy_or(app * n, bool root) const override { lbool val = root ? l_true : m_context.find_assignment(n); if (val == l_false) return check_relevancy_app(n); @@ -600,7 +600,7 @@ namespace smt { return true; } - bool check_relevancy(expr_ref_vector const & v) const { + bool check_relevancy(expr_ref_vector const & v) const override { SASSERT(!can_propagate()); ast_manager & m = get_manager(); unsigned sz = v.size(); diff --git a/src/smt/theory_seq.cpp b/src/smt/theory_seq.cpp index 12764fd9d..b90735a07 100644 --- a/src/smt/theory_seq.cpp +++ b/src/smt/theory_seq.cpp @@ -2449,7 +2449,6 @@ expr_ref theory_seq::digit2int(expr* ch) { } void theory_seq::add_itos_axiom(expr* e) { - context& ctx = get_context(); rational val; expr* n = nullptr; TRACE("seq", tout << mk_pp(e, m) << "\n";); From 4cc936285113df07f6492cf791f7850e933cda54 Mon Sep 17 00:00:00 2001 From: Bruce Mitchener Date: Wed, 7 Mar 2018 13:18:39 +0700 Subject: [PATCH 023/109] Make proof_checker more const correct. --- src/ast/proofs/proof_checker.cpp | 52 ++++++++++++++++---------------- src/ast/proofs/proof_checker.h | 50 +++++++++++++++--------------- 2 files changed, 51 insertions(+), 51 deletions(-) diff --git a/src/ast/proofs/proof_checker.cpp b/src/ast/proofs/proof_checker.cpp index 9ba52a402..bd50e6c2a 100644 --- a/src/ast/proofs/proof_checker.cpp +++ b/src/ast/proofs/proof_checker.cpp @@ -922,7 +922,7 @@ void proof_checker::set_false(expr_ref& e, unsigned position, expr_ref& lit) { } } -bool proof_checker::match_fact(proof* p, expr_ref& fact) { +bool proof_checker::match_fact(proof const* p, expr_ref& fact) const { if (m.is_proof(p) && m.has_fact(p)) { fact = m.get_fact(p); @@ -938,13 +938,13 @@ void proof_checker::add_premise(proof* p) { } } -bool proof_checker::match_proof(proof* p) { +bool proof_checker::match_proof(proof const* p) const { return m.is_proof(p) && m.get_num_parents(p) == 0; } -bool proof_checker::match_proof(proof* p, proof_ref& p0) { +bool proof_checker::match_proof(proof const* p, proof_ref& p0) const { if (m.is_proof(p) && m.get_num_parents(p) == 1) { p0 = m.get_parent(p, 0); @@ -953,7 +953,7 @@ bool proof_checker::match_proof(proof* p, proof_ref& p0) { return false; } -bool proof_checker::match_proof(proof* p, proof_ref& p0, proof_ref& p1) { +bool proof_checker::match_proof(proof const* p, proof_ref& p0, proof_ref& p1) const { if (m.is_proof(p) && m.get_num_parents(p) == 2) { p0 = m.get_parent(p, 0); @@ -963,7 +963,7 @@ bool proof_checker::match_proof(proof* p, proof_ref& p0, proof_ref& p1) { return false; } -bool proof_checker::match_proof(proof* p, proof_ref_vector& parents) { +bool proof_checker::match_proof(proof const* p, proof_ref_vector& parents) const { if (m.is_proof(p)) { for (unsigned i = 0; i < m.get_num_parents(p); ++i) { parents.push_back(m.get_parent(p, i)); @@ -974,7 +974,7 @@ bool proof_checker::match_proof(proof* p, proof_ref_vector& parents) { } -bool proof_checker::match_binary(expr* e, func_decl_ref& d, expr_ref& t1, expr_ref& t2) { +bool proof_checker::match_binary(expr const* e, func_decl_ref& d, expr_ref& t1, expr_ref& t2) const { if (e->get_kind() == AST_APP && to_app(e)->get_num_args() == 2) { d = to_app(e)->get_decl(); @@ -986,7 +986,7 @@ bool proof_checker::match_binary(expr* e, func_decl_ref& d, expr_ref& t1, expr_r } -bool proof_checker::match_app(expr* e, func_decl_ref& d, expr_ref_vector& terms) { +bool proof_checker::match_app(expr const* e, func_decl_ref& d, expr_ref_vector& terms) const { if (e->get_kind() == AST_APP) { d = to_app(e)->get_decl(); for (unsigned i = 0; i < to_app(e)->get_num_args(); ++i) { @@ -997,9 +997,9 @@ bool proof_checker::match_app(expr* e, func_decl_ref& d, expr_ref_vector& terms) return false; } -bool proof_checker::match_quantifier(expr* e, bool& is_univ, sort_ref_vector& sorts, expr_ref& body) { +bool proof_checker::match_quantifier(expr const* e, bool& is_univ, sort_ref_vector& sorts, expr_ref& body) const { if (is_quantifier(e)) { - quantifier* q = to_quantifier(e); + quantifier const* q = to_quantifier(e); is_univ = q->is_forall(); body = q->get_expr(); for (unsigned i = 0; i < q->get_num_decls(); ++i) { @@ -1010,7 +1010,7 @@ bool proof_checker::match_quantifier(expr* e, bool& is_univ, sort_ref_vector& so return false; } -bool proof_checker::match_op(expr* e, decl_kind k, expr_ref& t1, expr_ref& t2) { +bool proof_checker::match_op(expr const* e, decl_kind k, expr_ref& t1, expr_ref& t2) const { if (e->get_kind() == AST_APP && to_app(e)->get_family_id() == m.get_basic_family_id() && to_app(e)->get_decl_kind() == k && @@ -1022,7 +1022,7 @@ bool proof_checker::match_op(expr* e, decl_kind k, expr_ref& t1, expr_ref& t2) { return false; } -bool proof_checker::match_op(expr* e, decl_kind k, expr_ref_vector& terms) { +bool proof_checker::match_op(expr const* e, decl_kind k, expr_ref_vector& terms) const { if (e->get_kind() == AST_APP && to_app(e)->get_family_id() == m.get_basic_family_id() && to_app(e)->get_decl_kind() == k) { @@ -1035,7 +1035,7 @@ bool proof_checker::match_op(expr* e, decl_kind k, expr_ref_vector& terms) { } -bool proof_checker::match_op(expr* e, decl_kind k, expr_ref& t) { +bool proof_checker::match_op(expr const* e, decl_kind k, expr_ref& t) const { if (e->get_kind() == AST_APP && to_app(e)->get_family_id() == m.get_basic_family_id() && to_app(e)->get_decl_kind() == k && @@ -1046,39 +1046,39 @@ bool proof_checker::match_op(expr* e, decl_kind k, expr_ref& t) { return false; } -bool proof_checker::match_not(expr* e, expr_ref& t) { +bool proof_checker::match_not(expr const* e, expr_ref& t) const { return match_op(e, OP_NOT, t); } -bool proof_checker::match_or(expr* e, expr_ref_vector& terms) { +bool proof_checker::match_or(expr const* e, expr_ref_vector& terms) const { return match_op(e, OP_OR, terms); } -bool proof_checker::match_and(expr* e, expr_ref_vector& terms) { +bool proof_checker::match_and(expr const* e, expr_ref_vector& terms) const { return match_op(e, OP_AND, terms); } -bool proof_checker::match_iff(expr* e, expr_ref& t1, expr_ref& t2) { +bool proof_checker::match_iff(expr const* e, expr_ref& t1, expr_ref& t2) const { return match_op(e, OP_IFF, t1, t2); } -bool proof_checker::match_equiv(expr* e, expr_ref& t1, expr_ref& t2) { +bool proof_checker::match_equiv(expr const* e, expr_ref& t1, expr_ref& t2) const { return match_oeq(e, t1, t2) || match_eq(e, t1, t2); } -bool proof_checker::match_implies(expr* e, expr_ref& t1, expr_ref& t2) { +bool proof_checker::match_implies(expr const* e, expr_ref& t1, expr_ref& t2) const { return match_op(e, OP_IMPLIES, t1, t2); } -bool proof_checker::match_eq(expr* e, expr_ref& t1, expr_ref& t2) { +bool proof_checker::match_eq(expr const* e, expr_ref& t1, expr_ref& t2) const { return match_op(e, OP_EQ, t1, t2) || match_iff(e, t1, t2); } -bool proof_checker::match_oeq(expr* e, expr_ref& t1, expr_ref& t2) { +bool proof_checker::match_oeq(expr const* e, expr_ref& t1, expr_ref& t2) const { return match_op(e, OP_OEQ, t1, t2); } -bool proof_checker::match_negated(expr* a, expr* b) { +bool proof_checker::match_negated(expr const* a, expr* b) const { expr_ref t(m); return (match_not(a, t) && t.get() == b) || @@ -1186,14 +1186,14 @@ void proof_checker::get_hypotheses(proof* p, expr_ref_vector& ante) { } -bool proof_checker::match_nil(expr* e) const { +bool proof_checker::match_nil(expr const* e) const { return is_app(e) && to_app(e)->get_family_id() == m_hyp_fid && to_app(e)->get_decl_kind() == OP_NIL; } -bool proof_checker::match_cons(expr* e, expr_ref& a, expr_ref& b) const { +bool proof_checker::match_cons(expr const* e, expr_ref& a, expr_ref& b) const { if (is_app(e) && to_app(e)->get_family_id() == m_hyp_fid && to_app(e)->get_decl_kind() == OP_CONS) { @@ -1205,7 +1205,7 @@ bool proof_checker::match_cons(expr* e, expr_ref& a, expr_ref& b) const { } -bool proof_checker::match_atom(expr* e, expr_ref& a) const { +bool proof_checker::match_atom(expr const* e, expr_ref& a) const { if (is_app(e) && to_app(e)->get_family_id() == m_hyp_fid && to_app(e)->get_decl_kind() == OP_ATOM) { @@ -1227,7 +1227,7 @@ expr* proof_checker::mk_nil() { return m_nil.get(); } -bool proof_checker::is_hypothesis(proof* p) const { +bool proof_checker::is_hypothesis(proof const* p) const { return m.is_proof(p) && p->get_decl_kind() == PR_HYPOTHESIS; @@ -1253,7 +1253,7 @@ expr* proof_checker::mk_hyp(unsigned num_hyps, expr * const * hyps) { } } -void proof_checker::dump_proof(proof * pr) { +void proof_checker::dump_proof(proof const* pr) { if (!m_dump_lemmas) return; SASSERT(m.has_fact(pr)); diff --git a/src/ast/proofs/proof_checker.h b/src/ast/proofs/proof_checker.h index ccb815c61..ac0e31dbd 100644 --- a/src/ast/proofs/proof_checker.h +++ b/src/ast/proofs/proof_checker.h @@ -77,39 +77,39 @@ private: bool check1_spc(proof* p, expr_ref_vector& side_conditions); bool check_arith_proof(proof* p); bool check_arith_literal(bool is_pos, app* lit, rational const& coeff, expr_ref& sum, bool& is_strict); - bool match_fact(proof* p, expr_ref& fact); + bool match_fact(proof const* p, expr_ref& fact) const; void add_premise(proof* p); - bool match_proof(proof* p); - bool match_proof(proof* p, proof_ref& p0); - bool match_proof(proof* p, proof_ref& p0, proof_ref& p1); - bool match_proof(proof* p, proof_ref_vector& parents); - bool match_binary(expr* e, func_decl_ref& d, expr_ref& t1, expr_ref& t2); - bool match_op(expr* e, decl_kind k, expr_ref& t1, expr_ref& t2); - bool match_op(expr* e, decl_kind k, expr_ref& t); - bool match_op(expr* e, decl_kind k, expr_ref_vector& terms); - bool match_iff(expr* e, expr_ref& t1, expr_ref& t2); - bool match_implies(expr* e, expr_ref& t1, expr_ref& t2); - bool match_eq(expr* e, expr_ref& t1, expr_ref& t2); - bool match_oeq(expr* e, expr_ref& t1, expr_ref& t2); - bool match_not(expr* e, expr_ref& t); - bool match_or(expr* e, expr_ref_vector& terms); - bool match_and(expr* e, expr_ref_vector& terms); - bool match_app(expr* e, func_decl_ref& d, expr_ref_vector& terms); - bool match_quantifier(expr*, bool& is_univ, sort_ref_vector&, expr_ref& body); - bool match_negated(expr* a, expr* b); - bool match_equiv(expr* a, expr_ref& t1, expr_ref& t2); + bool match_proof(proof const* p) const; + bool match_proof(proof const* p, proof_ref& p0) const; + bool match_proof(proof const* p, proof_ref& p0, proof_ref& p1) const; + bool match_proof(proof const* p, proof_ref_vector& parents) const; + bool match_binary(expr const* e, func_decl_ref& d, expr_ref& t1, expr_ref& t2) const; + bool match_op(expr const* e, decl_kind k, expr_ref& t1, expr_ref& t2) const; + bool match_op(expr const* e, decl_kind k, expr_ref& t) const; + bool match_op(expr const* e, decl_kind k, expr_ref_vector& terms) const; + bool match_iff(expr const* e, expr_ref& t1, expr_ref& t2) const; + bool match_implies(expr const* e, expr_ref& t1, expr_ref& t2) const; + bool match_eq(expr const* e, expr_ref& t1, expr_ref& t2) const; + bool match_oeq(expr const* e, expr_ref& t1, expr_ref& t2) const; + bool match_not(expr const* e, expr_ref& t) const; + bool match_or(expr const* e, expr_ref_vector& terms) const; + bool match_and(expr const* e, expr_ref_vector& terms) const; + bool match_app(expr const* e, func_decl_ref& d, expr_ref_vector& terms) const; + bool match_quantifier(expr const*, bool& is_univ, sort_ref_vector&, expr_ref& body) const; + bool match_negated(expr const* a, expr* b) const; + bool match_equiv(expr const* a, expr_ref& t1, expr_ref& t2) const; void get_ors(expr* e, expr_ref_vector& ors); void get_hypotheses(proof* p, expr_ref_vector& ante); - bool match_nil(expr* e) const; - bool match_cons(expr* e, expr_ref& a, expr_ref& b) const; - bool match_atom(expr* e, expr_ref& a) const; + bool match_nil(expr const* e) const; + bool match_cons(expr const* e, expr_ref& a, expr_ref& b) const; + bool match_atom(expr const* e, expr_ref& a) const; expr* mk_nil(); expr* mk_cons(expr* a, expr* b); expr* mk_atom(expr* e); - bool is_hypothesis(proof* p) const; + bool is_hypothesis(proof const* p) const; expr* mk_hyp(unsigned num_hyps, expr * const * hyps); - void dump_proof(proof * pr); + void dump_proof(proof const* pr); void dump_proof(unsigned num_antecedents, expr * const * antecedents, expr * consequent); void set_false(expr_ref& e, unsigned idx, expr_ref& lit); From 0b54a915131526df59208def2fa097fd6fd1dbb1 Mon Sep 17 00:00:00 2001 From: Bruce Mitchener Date: Wed, 7 Mar 2018 13:29:13 +0700 Subject: [PATCH 024/109] Force color output with Ninja. --- CMakeLists.txt | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index 69a0ca123..a222551ae 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -409,6 +409,20 @@ list(APPEND Z3_DEPENDENT_LIBS ${CMAKE_THREAD_LIBS_INIT}) ################################################################################ include(${CMAKE_SOURCE_DIR}/cmake/compiler_warnings.cmake) +################################################################################ +# If using Ninja, force color output for Clang and gcc. +################################################################################ +if (UNIX AND CMAKE_GENERATOR STREQUAL "Ninja") + if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fcolor-diagnostics") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fcolor-diagnostics") + endif() + if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fdiagnostics-color") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fdiagnostics-color") + endif() +endif() + ################################################################################ # Option to control what type of library we build ################################################################################ From 246941f2d30b9865229759e0d8707fc8c7de6763 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Wed, 7 Mar 2018 14:26:38 -0800 Subject: [PATCH 025/109] fix #1522 Signed-off-by: Nikolaj Bjorner --- src/ast/ast.cpp | 53 +++++++++++++++++++------------------ src/ast/ast_pp_util.cpp | 7 ++++- src/ast/ast_pp_util.h | 4 +++ src/muz/base/dl_context.cpp | 32 +++++++++++++--------- src/test/quant_elim.cpp | 2 ++ 5 files changed, 58 insertions(+), 40 deletions(-) diff --git a/src/ast/ast.cpp b/src/ast/ast.cpp index c27651fca..127967374 100644 --- a/src/ast/ast.cpp +++ b/src/ast/ast.cpp @@ -1536,34 +1536,35 @@ void ast_manager::copy_families_plugins(ast_manager const & from) { // assigned in the order that they are created, this can result in differing // family ids. To avoid this, we first assign all family ids and only then inherit plugins. for (family_id fid = 0; from.m_family_manager.has_family(fid); fid++) { - symbol fid_name = from.get_family_name(fid); - if (!m_family_manager.has_family(fid)) { - family_id new_fid = mk_family_id(fid_name); - (void)new_fid; - TRACE("copy_families_plugins", tout << "new target fid created: " << new_fid << " fid_name: " << fid_name << "\n";); - } + symbol fid_name = from.get_family_name(fid); + if (!m_family_manager.has_family(fid)) { + family_id new_fid = mk_family_id(fid_name); + (void)new_fid; + TRACE("copy_families_plugins", tout << "new target fid created: " << new_fid << " fid_name: " << fid_name << "\n";); + } } for (family_id fid = 0; from.m_family_manager.has_family(fid); fid++) { - SASSERT(from.is_builtin_family_id(fid) == is_builtin_family_id(fid)); - SASSERT(!from.is_builtin_family_id(fid) || m_family_manager.has_family(fid)); - symbol fid_name = from.get_family_name(fid); - TRACE("copy_families_plugins", tout << "copying: " << fid_name << ", src fid: " << fid - << ", target has_family: " << m_family_manager.has_family(fid) << "\n"; - if (m_family_manager.has_family(fid)) tout << get_family_id(fid_name) << "\n";); - TRACE("copy_families_plugins", tout << "target fid: " << get_family_id(fid_name) << "\n";); - SASSERT(fid == get_family_id(fid_name)); - if (from.has_plugin(fid) && !has_plugin(fid)) { - decl_plugin * new_p = from.get_plugin(fid)->mk_fresh(); - register_plugin(fid, new_p); - SASSERT(new_p->get_family_id() == fid); - SASSERT(has_plugin(fid)); - } - if (from.has_plugin(fid)) { - get_plugin(fid)->inherit(from.get_plugin(fid), trans); - } - SASSERT(from.m_family_manager.has_family(fid) == m_family_manager.has_family(fid)); - SASSERT(from.get_family_id(fid_name) == get_family_id(fid_name)); - SASSERT(!from.has_plugin(fid) || has_plugin(fid)); + SASSERT(from.is_builtin_family_id(fid) == is_builtin_family_id(fid)); + SASSERT(!from.is_builtin_family_id(fid) || m_family_manager.has_family(fid)); + symbol fid_name = from.get_family_name(fid); + (void)fid_name; + TRACE("copy_families_plugins", tout << "copying: " << fid_name << ", src fid: " << fid + << ", target has_family: " << m_family_manager.has_family(fid) << "\n"; + if (m_family_manager.has_family(fid)) tout << get_family_id(fid_name) << "\n";); + TRACE("copy_families_plugins", tout << "target fid: " << get_family_id(fid_name) << "\n";); + SASSERT(fid == get_family_id(fid_name)); + if (from.has_plugin(fid) && !has_plugin(fid)) { + decl_plugin * new_p = from.get_plugin(fid)->mk_fresh(); + register_plugin(fid, new_p); + SASSERT(new_p->get_family_id() == fid); + SASSERT(has_plugin(fid)); + } + if (from.has_plugin(fid)) { + get_plugin(fid)->inherit(from.get_plugin(fid), trans); + } + SASSERT(from.m_family_manager.has_family(fid) == m_family_manager.has_family(fid)); + SASSERT(from.get_family_id(fid_name) == get_family_id(fid_name)); + SASSERT(!from.has_plugin(fid) || has_plugin(fid)); } } diff --git a/src/ast/ast_pp_util.cpp b/src/ast/ast_pp_util.cpp index 37785e072..23c9ebe51 100644 --- a/src/ast/ast_pp_util.cpp +++ b/src/ast/ast_pp_util.cpp @@ -46,13 +46,18 @@ void ast_pp_util::display_decls(std::ostream& out) { n = coll.get_num_decls(); for (unsigned i = 0; i < n; ++i) { func_decl* f = coll.get_func_decls()[i]; - if (f->get_family_id() == null_family_id) { + if (f->get_family_id() == null_family_id && !m_removed.contains(f)) { ast_smt2_pp(out, f, env); out << "\n"; } } } +void ast_pp_util::remove_decl(func_decl* f) { + m_removed.insert(f); +} + + void ast_pp_util::display_asserts(std::ostream& out, expr_ref_vector const& fmls, bool neat) { if (neat) { smt2_pp_environment_dbg env(m); diff --git a/src/ast/ast_pp_util.h b/src/ast/ast_pp_util.h index 964a862a2..1b2686511 100644 --- a/src/ast/ast_pp_util.h +++ b/src/ast/ast_pp_util.h @@ -20,9 +20,11 @@ Revision History: #define AST_PP_UTIL_H_ #include "ast/decl_collector.h" +#include "util/obj_hashtable.h" class ast_pp_util { ast_manager& m; + obj_hashtable m_removed; public: decl_collector coll; @@ -35,6 +37,8 @@ class ast_pp_util { void collect(expr_ref_vector const& es); + void remove_decl(func_decl* f); + void display_decls(std::ostream& out); void display_asserts(std::ostream& out, expr_ref_vector const& fmls, bool neat = true); diff --git a/src/muz/base/dl_context.cpp b/src/muz/base/dl_context.cpp index 47d7cc357..521cf0dc9 100644 --- a/src/muz/base/dl_context.cpp +++ b/src/muz/base/dl_context.cpp @@ -1106,6 +1106,16 @@ namespace datalog { names.push_back(m_rule_names[i]); } } + + static std::ostream& display_symbol(std::ostream& out, symbol const& nm) { + if (is_smt2_quoted_symbol(nm)) { + out << mk_smt2_quoted_symbol(nm); + } + else { + out << nm; + } + return out; + } void context::display_smt2(unsigned num_queries, expr* const* qs, std::ostream& out) { ast_manager& m = get_manager(); @@ -1148,13 +1158,13 @@ namespace datalog { if (!use_fixedpoint_extensions) { out << "(set-logic HORN)\n"; } + for (func_decl * f : rels) + visitor.remove_decl(f); visitor.display_decls(out); - func_decl_set::iterator it = rels.begin(), end = rels.end(); - for (; it != end; ++it) { - func_decl* f = *it; + + for (func_decl * f : rels) display_rel_decl(out, f); - } if (use_fixedpoint_extensions && do_declare_vars) { declare_vars(rules, fresh_names, out); @@ -1185,13 +1195,7 @@ namespace datalog { nm = symbol(s.str().c_str()); } fresh_names.add(nm); - if (is_smt2_quoted_symbol(nm)) { - out << mk_smt2_quoted_symbol(nm); - } - else { - out << nm; - } - out << ")"; + display_symbol(out, nm) << ")"; } out << ")\n"; } @@ -1219,7 +1223,8 @@ namespace datalog { PP(qfn); out << ")\n"; } - out << "(query " << fn->get_name() << ")\n"; + out << "(query "; + display_symbol(out, fn->get_name()) << ")\n"; } } else { @@ -1238,7 +1243,8 @@ namespace datalog { void context::display_rel_decl(std::ostream& out, func_decl* f) { smt2_pp_environment_dbg env(m); - out << "(declare-rel " << f->get_name() << " ("; + out << "(declare-rel "; + display_symbol(out, f->get_name()) << " ("; for (unsigned i = 0; i < f->get_arity(); ++i) { ast_smt2_pp(out, f->get_domain(i), env); if (i + 1 < f->get_arity()) { diff --git a/src/test/quant_elim.cpp b/src/test/quant_elim.cpp index 12fca706d..f376e2c1d 100644 --- a/src/test/quant_elim.cpp +++ b/src/test/quant_elim.cpp @@ -13,6 +13,7 @@ Copyright (c) 2015 Microsoft Corporation #include "ast/reg_decl_plugins.h" +#if 0 static void test_qe(ast_manager& m, lbool expected_outcome, expr* fml, char const* option) { // enable_trace("bit2int"); @@ -48,6 +49,7 @@ static void test_qe(ast_manager& m, lbool expected_outcome, expr* fml, char cons //exit(-1); } } +#endif static void test_formula(lbool expected_outcome, char const* fml) { ast_manager m; From a7caa2fd2a5b5d888956fcc0391ff034ce91b9b7 Mon Sep 17 00:00:00 2001 From: Murphy Berzish Date: Wed, 7 Mar 2018 18:16:11 -0500 Subject: [PATCH 026/109] remove useless get_assignments in theory_str final check --- src/smt/theory_str.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp index b900f9368..e0f0909cc 100644 --- a/src/smt/theory_str.cpp +++ b/src/smt/theory_str.cpp @@ -8734,8 +8734,8 @@ namespace smt { context & ctx = get_context(); ast_manager & m = get_manager(); - expr_ref_vector assignments(m); - ctx.get_assignments(assignments); + //expr_ref_vector assignments(m); + //ctx.get_assignments(assignments); if (opt_VerifyFinalCheckProgress) { finalCheckProgressIndicator = false; From 02a969670124399e07c982b038cc861667e1b3ff Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Thu, 8 Mar 2018 11:19:00 -0500 Subject: [PATCH 027/109] fix #1521 Signed-off-by: Nikolaj Bjorner --- src/smt/theory_arith_core.h | 24 +++++++++++++++--------- 1 file changed, 15 insertions(+), 9 deletions(-) diff --git a/src/smt/theory_arith_core.h b/src/smt/theory_arith_core.h index fe62efbf4..3393634b6 100644 --- a/src/smt/theory_arith_core.h +++ b/src/smt/theory_arith_core.h @@ -469,7 +469,8 @@ namespace smt { if (negated) l_conseq.neg(); TRACE("arith_axiom", tout << mk_pp(ante, m) << "\n" << mk_pp(conseq, m) << "\n"; - tout << s_ante << "\n" << s_conseq << "\n";); + tout << s_ante << "\n" << s_conseq << "\n"; + tout << l_ante << "\n" << l_conseq << "\n";); // literal lits[2] = {l_ante, l_conseq}; mk_clause(l_ante, l_conseq, 0, nullptr); @@ -589,13 +590,14 @@ namespace smt { } // - // create the term: s := to_real(to_int(x)) - x + // create the term: s := x - to_real(to_int(x)) // add the bounds 0 <= s < 1 // template void theory_arith::mk_to_int_axiom(app * n) { SASSERT(m_util.is_to_int(n)); - ast_manager & m = get_manager(); + ast_manager & m = get_manager(); + context & ctx = get_context(); expr* x = n->get_arg(0); // to_int (to_real x) = x @@ -603,11 +605,15 @@ namespace smt { mk_axiom(m.mk_false(), m.mk_eq(to_app(x)->get_arg(0), n)); return; } - expr* to_r = m_util.mk_to_real(n); - expr_ref lo(m_util.mk_le(to_r, x), m); - expr_ref hi(m_util.mk_lt(x, m_util.mk_add(to_r, m_util.mk_numeral(rational(1), false))), m); - mk_axiom(m.mk_false(), lo); - mk_axiom(m.mk_false(), hi); + expr_ref to_r(m_util.mk_to_real(n), m); + expr_ref diff(m_util.mk_add(x, m_util.mk_mul(m_util.mk_real(-1), to_r)), m); + + expr_ref lo(m_util.mk_ge(diff, m_util.mk_real(0)), m); + expr_ref hi(m_util.mk_ge(diff, m_util.mk_real(1)), m); + hi = m.mk_not(hi); + + mk_axiom(m.mk_false(), lo, false); + mk_axiom(m.mk_false(), hi, false); } template @@ -1202,7 +1208,7 @@ namespace smt { template bool theory_arith::internalize_atom(app * n, bool gate_ctx) { - TRACE("arith_internalize", tout << "internalising atom:\n" << mk_pp(n, this->get_manager()) << "\n";); + TRACE("arith_internalize", tout << "internalizing atom:\n" << mk_pp(n, this->get_manager()) << "\n";); context & ctx = get_context(); SASSERT(m_util.is_le(n) || m_util.is_ge(n) || m_util.is_is_int(n)); SASSERT(!ctx.b_internalized(n)); From bf6975122be10ec7d4e872a274bac525d33a03a9 Mon Sep 17 00:00:00 2001 From: Murphy Berzish Date: Thu, 8 Mar 2018 12:37:44 -0500 Subject: [PATCH 028/109] integrate contains and indexof in theory_str --- src/smt/theory_str.cpp | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp index cb4a11c89..9dfd0475b 100644 --- a/src/smt/theory_str.cpp +++ b/src/smt/theory_str.cpp @@ -1284,6 +1284,21 @@ namespace smt { expr_ref finalAxiom(m.mk_and(breakdownAssert, reduceToIndex), m); SASSERT(finalAxiom); assert_axiom(finalAxiom); + + { + // heuristic: integrate with str.contains information + // (but don't introduce it if it isn't already in the instance) + expr_ref haystack(ex->get_arg(0), m), needle(ex->get_arg(1), m), startIdx(ex->get_arg(2), m); + expr_ref zeroAst(mk_int(0), m); + // (H contains N) <==> (H indexof N, i) >= 0 + expr_ref premise(u.str.mk_contains(haystack, needle), m); + ctx.internalize(premise, false); + expr_ref conclusion(m_autil.mk_ge(ex, zeroAst), m); + expr_ref containsAxiom(ctx.mk_eq_atom(premise, conclusion), m); + SASSERT(containsAxiom); + // we can't assert this during init_search as it breaks an invariant if the instance becomes inconsistent + m_delayed_axiom_setup_terms.push_back(containsAxiom); + } } void theory_str::instantiate_axiom_Indexof_extended(enode * e) { @@ -1353,6 +1368,20 @@ namespace smt { expr_ref reduceTerm(ctx.mk_eq_atom(expr, resAst), m); SASSERT(reduceTerm); assert_axiom(reduceTerm); + + { + // heuristic: integrate with str.contains information + // (but don't introduce it if it isn't already in the instance) + expr_ref haystack(expr->get_arg(0), m), needle(expr->get_arg(1), m), startIdx(expr->get_arg(2), m); + // (H contains N) <==> (H indexof N, i) >= 0 + expr_ref premise(u.str.mk_contains(haystack, needle), m); + ctx.internalize(premise, false); + expr_ref conclusion(m_autil.mk_ge(expr, zeroAst), m); + expr_ref containsAxiom(ctx.mk_eq_atom(premise, conclusion), m); + SASSERT(containsAxiom); + // we can't assert this during init_search as it breaks an invariant if the instance becomes inconsistent + m_delayed_axiom_setup_terms.push_back(containsAxiom); + } } void theory_str::instantiate_axiom_LastIndexof(enode * e) { From 878a6ca14ffd1eb9f1b26083ebb16533019cca2f Mon Sep 17 00:00:00 2001 From: Bruce Mitchener Date: Fri, 9 Mar 2018 14:29:22 +0700 Subject: [PATCH 029/109] Fix typos. --- CMakeLists.txt | 2 +- scripts/mk_consts_files.py | 2 +- src/api/c++/z3++.h | 2 +- src/api/dotnet/Context.cs | 10 +++++----- src/api/java/Context.java | 10 +++++----- src/api/python/z3/z3.py | 12 ++++++------ src/api/z3_fpa.h | 8 ++++---- src/api/z3_interp.h | 4 ++-- src/ast/rewriter/rewriter_def.h | 2 +- src/interp/iz3checker.cpp | 2 +- src/muz/base/fixedpoint_params.pyg | 8 ++++---- src/muz/transforms/dl_mk_array_instantiation.h | 2 +- src/muz/transforms/dl_mk_interp_tail_simplifier.h | 2 +- src/muz/transforms/dl_mk_rule_inliner.h | 2 +- src/muz/transforms/dl_mk_scale.h | 2 +- src/tactic/aig/aig.cpp | 2 +- src/tactic/tactic_exception.h | 2 +- src/tactic/tactical.h | 2 +- 18 files changed, 38 insertions(+), 38 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 69a0ca123..7bc60e135 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -434,7 +434,7 @@ else() endif() ################################################################################ -# Postion independent code +# Position independent code ################################################################################ # This is required because code built in the components will end up in a shared # library. If not building a shared library ``-fPIC`` isn't needed and would add diff --git a/scripts/mk_consts_files.py b/scripts/mk_consts_files.py index d0502c19d..39d4e9439 100755 --- a/scripts/mk_consts_files.py +++ b/scripts/mk_consts_files.py @@ -72,7 +72,7 @@ def main(args): if count == 0: logging.info('No files generated. You need to specific an output directory' - ' for the relevant langauge bindings') + ' for the relevant language bindings') # TODO: Add support for other bindings return 0 diff --git a/src/api/c++/z3++.h b/src/api/c++/z3++.h index 49f6cfbf3..42467cb22 100644 --- a/src/api/c++/z3++.h +++ b/src/api/c++/z3++.h @@ -989,7 +989,7 @@ namespace z3 { /** \brief sequence and regular expression operations. - + is overloaeded as sequence concatenation and regular expression union. + + is overloaded as sequence concatenation and regular expression union. concat is overloaded to handle sequences and regular expressions */ expr extract(expr const& offset, expr const& length) const { diff --git a/src/api/dotnet/Context.cs b/src/api/dotnet/Context.cs index cbd6a1bac..b3b24a6d1 100644 --- a/src/api/dotnet/Context.cs +++ b/src/api/dotnet/Context.cs @@ -2515,7 +2515,7 @@ namespace Microsoft.Z3 /// - /// Concatentate sequences. + /// Concatenate sequences. /// public SeqExpr MkConcat(params SeqExpr[] t) { @@ -3597,7 +3597,7 @@ namespace Microsoft.Z3 } /// - /// Create a tactic that fails if the goal is not triviall satisfiable (i.e., empty) + /// Create a tactic that fails if the goal is not trivially satisfiable (i.e., empty) /// or trivially unsatisfiable (i.e., contains `false'). /// public Tactic FailIfNotDecided() @@ -4656,7 +4656,7 @@ namespace Microsoft.Z3 /// Conversion of a floating-point term into a bit-vector. /// /// - /// Produces a term that represents the conversion of the floating-poiunt term t into a + /// Produces a term that represents the conversion of the floating-point term t into a /// bit-vector term of size sz in 2's complement format (signed when signed==true). If necessary, /// the result will be rounded according to rounding mode rm. /// @@ -4677,7 +4677,7 @@ namespace Microsoft.Z3 /// Conversion of a floating-point term into a real-numbered term. /// /// - /// Produces a term that represents the conversion of the floating-poiunt term t into a + /// Produces a term that represents the conversion of the floating-point term t into a /// real number. Note that this type of conversion will often result in non-linear /// constraints over real terms. /// @@ -4696,7 +4696,7 @@ namespace Microsoft.Z3 /// /// The size of the resulting bit-vector is automatically determined. Note that /// IEEE 754-2008 allows multiple different representations of NaN. This conversion - /// knows only one NaN and it will always produce the same bit-vector represenatation of + /// knows only one NaN and it will always produce the same bit-vector representation of /// that NaN. /// /// FloatingPoint term. diff --git a/src/api/java/Context.java b/src/api/java/Context.java index ba96209b3..3c5caadee 100644 --- a/src/api/java/Context.java +++ b/src/api/java/Context.java @@ -1978,7 +1978,7 @@ public class Context implements AutoCloseable { } /** - * Concatentate sequences. + * Concatenate sequences. */ public SeqExpr mkConcat(SeqExpr... t) { @@ -2781,7 +2781,7 @@ public class Context implements AutoCloseable { } /** - * Create a tactic that fails if the goal is not triviall satisfiable (i.e., + * Create a tactic that fails if the goal is not trivially satisfiable (i.e., * empty) or trivially unsatisfiable (i.e., contains `false'). **/ public Tactic failIfNotDecided() @@ -3769,7 +3769,7 @@ public class Context implements AutoCloseable { * @param sz Size of the resulting bit-vector. * @param signed Indicates whether the result is a signed or unsigned bit-vector. * Remarks: - * Produces a term that represents the conversion of the floating-poiunt term t into a + * Produces a term that represents the conversion of the floating-point term t into a * bit-vector term of size sz in 2's complement format (signed when signed==true). If necessary, * the result will be rounded according to rounding mode rm. * @throws Z3Exception @@ -3786,7 +3786,7 @@ public class Context implements AutoCloseable { * Conversion of a floating-point term into a real-numbered term. * @param t FloatingPoint term * Remarks: - * Produces a term that represents the conversion of the floating-poiunt term t into a + * Produces a term that represents the conversion of the floating-point term t into a * real number. Note that this type of conversion will often result in non-linear * constraints over real terms. * @throws Z3Exception @@ -3802,7 +3802,7 @@ public class Context implements AutoCloseable { * Remarks: * The size of the resulting bit-vector is automatically determined. Note that * IEEE 754-2008 allows multiple different representations of NaN. This conversion - * knows only one NaN and it will always produce the same bit-vector represenatation of + * knows only one NaN and it will always produce the same bit-vector representation of * that NaN. * @throws Z3Exception **/ diff --git a/src/api/python/z3/z3.py b/src/api/python/z3/z3.py index 1cfb10179..e68d7280d 100644 --- a/src/api/python/z3/z3.py +++ b/src/api/python/z3/z3.py @@ -2428,7 +2428,7 @@ def is_rational_value(a): return is_arith(a) and a.is_real() and _is_numeral(a.ctx, a.as_ast()) def is_algebraic_value(a): - """Return `True` if `a` is an algerbraic value of sort Real. + """Return `True` if `a` is an algebraic value of sort Real. >>> is_algebraic_value(RealVal("3/5")) False @@ -4437,7 +4437,7 @@ class Datatype: """Declare constructor named `name` with the given accessors `args`. Each accessor is a pair `(name, sort)`, where `name` is a string and `sort` a Z3 sort or a reference to the datatypes being declared. - In the followin example `List.declare('cons', ('car', IntSort()), ('cdr', List))` + In the following example `List.declare('cons', ('car', IntSort()), ('cdr', List))` declares the constructor named `cons` that builds a new List using an integer and a List. It also declares the accessors `car` and `cdr`. The accessor `car` extracts the integer of a `cons` cell, and `cdr` the list of a `cons` cell. After all constructors were declared, we use the method create() to create @@ -4457,7 +4457,7 @@ class Datatype: return "Datatype(%s, %s)" % (self.name, self.constructors) def create(self): - """Create a Z3 datatype based on the constructors declared using the mehtod `declare()`. + """Create a Z3 datatype based on the constructors declared using the method `declare()`. The function `CreateDatatypes()` must be used to define mutually recursive datatypes. @@ -8874,7 +8874,7 @@ class FPNumRef(FPRef): def isSubnormal(self): return Z3_fpa_is_numeral_subnormal(self.ctx.ref(), self.as_ast()) - """Indicates whether the numeral is postitive.""" + """Indicates whether the numeral is positive.""" def isPositive(self): return Z3_fpa_is_numeral_positive(self.ctx.ref(), self.as_ast()) @@ -9670,7 +9670,7 @@ def fpToIEEEBV(x, ctx=None): The size of the resulting bit-vector is automatically determined. Note that IEEE 754-2008 allows multiple different representations of NaN. This conversion - knows only one NaN and it will always produce the same bit-vector represenatation of + knows only one NaN and it will always produce the same bit-vector representation of that NaN. >>> x = FP('x', FPSort(8, 24)) @@ -9845,7 +9845,7 @@ def Empty(s): raise Z3Exception("Non-sequence, non-regular expression sort passed to Empty") def Full(s): - """Create the regular expression that accepts the universal langauge + """Create the regular expression that accepts the universal language >>> e = Full(ReSort(SeqSort(IntSort()))) >>> print(e) re.all diff --git a/src/api/z3_fpa.h b/src/api/z3_fpa.h index 358a3c619..7d237c6e7 100644 --- a/src/api/z3_fpa.h +++ b/src/api/z3_fpa.h @@ -756,7 +756,7 @@ extern "C" { /** \brief Conversion of a floating-point term into an unsigned bit-vector. - Produces a term that represents the conversion of the floating-poiunt term t into a + Produces a term that represents the conversion of the floating-point term t into a bit-vector term of size sz in unsigned 2's complement format. If necessary, the result will be rounded according to rounding mode rm. @@ -772,7 +772,7 @@ extern "C" { /** \brief Conversion of a floating-point term into a signed bit-vector. - Produces a term that represents the conversion of the floating-poiunt term t into a + Produces a term that represents the conversion of the floating-point term t into a bit-vector term of size sz in signed 2's complement format. If necessary, the result will be rounded according to rounding mode rm. @@ -788,7 +788,7 @@ extern "C" { /** \brief Conversion of a floating-point term into a real-numbered term. - Produces a term that represents the conversion of the floating-poiunt term t into a + Produces a term that represents the conversion of the floating-point term t into a real number. Note that this type of conversion will often result in non-linear constraints over real terms. @@ -1011,7 +1011,7 @@ extern "C" { determined. Note that IEEE 754-2008 allows multiple different representations of NaN. This conversion - knows only one NaN and it will always produce the same bit-vector represenatation of + knows only one NaN and it will always produce the same bit-vector representation of that NaN. def_API('Z3_mk_fpa_to_ieee_bv', AST, (_in(CONTEXT),_in(AST))) diff --git a/src/api/z3_interp.h b/src/api/z3_interp.h index bcee0e22d..2441d4339 100644 --- a/src/api/z3_interp.h +++ b/src/api/z3_interp.h @@ -98,7 +98,7 @@ extern "C" { Interpolant may not necessarily be computable from all proofs. To be sure an interpolant can be computed, the proof - must be generated by an SMT solver for which interpoaltion is + must be generated by an SMT solver for which interpolation is supported, and the premises must be expressed using only theories and operators for which interpolation is supported. @@ -199,7 +199,7 @@ extern "C" { (implies (and c1 ... cn f) v) where c1 .. cn are the children of v (which must precede v in the file) - and f is the formula assiciated to node v. The last formula in the + and f is the formula associated to node v. The last formula in the file is the root vertex, and is represented by the predicate "false". A solution to a tree interpolation problem can be thought of as a diff --git a/src/ast/rewriter/rewriter_def.h b/src/ast/rewriter/rewriter_def.h index 658fb2e05..878f4ef4c 100644 --- a/src/ast/rewriter/rewriter_def.h +++ b/src/ast/rewriter/rewriter_def.h @@ -358,7 +358,7 @@ void rewriter_tpl::process_app(app * t, frame & fr) { if (ProofGen) { NOT_IMPLEMENTED_YET(); // We do not support the use of bindings in proof generation mode. - // Thus we have to apply the subsitution here, and + // Thus we have to apply the substitution here, and // beta_reducer subst(m()); // subst.set_bindings(new_num_args, new_args); // expr_ref r2(m()); diff --git a/src/interp/iz3checker.cpp b/src/interp/iz3checker.cpp index cfea511ad..511342819 100644 --- a/src/interp/iz3checker.cpp +++ b/src/interp/iz3checker.cpp @@ -43,7 +43,7 @@ struct iz3checker : iz3base { /* HACK: for tree interpolants, we assume that uninterpreted functions are global. This is because in the current state of the tree interpolation code, symbols that appear in sibling sub-trees have to be global, and - we have no way to eliminate such function symbols. When tree interpoaltion is + we have no way to eliminate such function symbols. When tree interpolation is fixed, we can tree function symbols the same as constant symbols. */ bool is_tree; diff --git a/src/muz/base/fixedpoint_params.pyg b/src/muz/base/fixedpoint_params.pyg index 0c2f03460..753a45e06 100644 --- a/src/muz/base/fixedpoint_params.pyg +++ b/src/muz/base/fixedpoint_params.pyg @@ -33,7 +33,7 @@ def_module_params('fixedpoint', "updated relation was modified or not"), ('datalog.compile_with_widening', BOOL, False, "widening will be used to compile recursive rules"), - ('datalog.default_table_checked', BOOL, False, "if true, the detault " + + ('datalog.default_table_checked', BOOL, False, "if true, the default " + 'table will be default_table inside a wrapper that checks that its results ' + 'are the same as of default_table_checker table'), ('datalog.default_table_checker', SYMBOL, 'null', "see default_table_checked"), @@ -59,7 +59,7 @@ def_module_params('fixedpoint', ('duality.full_expand', BOOL, False, 'Fully expand derivation trees'), ('duality.no_conj', BOOL, False, 'No forced covering (conjectures)'), ('duality.feasible_edges', BOOL, True, - 'Don\'t expand definitley infeasible edges'), + 'Don\'t expand definitely infeasible edges'), ('duality.use_underapprox', BOOL, False, 'Use underapproximations'), ('duality.stratified_inlining', BOOL, False, 'Use stratified inlining'), ('duality.recursion_bound', UINT, UINT_MAX, @@ -130,7 +130,7 @@ def_module_params('fixedpoint', ('xform.magic', BOOL, False, "perform symbolic magic set transformation"), ('xform.scale', BOOL, False, - "add scaling variable to linear real arithemtic clauses"), + "add scaling variable to linear real arithmetic clauses"), ('xform.inline_linear', BOOL, True, "try linear inlining method"), ('xform.inline_eager', BOOL, True, "try eager inlining of rules"), ('xform.inline_linear_branch', BOOL, False, @@ -176,7 +176,7 @@ def_module_params('fixedpoint', ('spacer.elim_aux', BOOL, True, "Eliminate auxiliary variables in reachability facts"), ('spacer.reach_as_init', BOOL, True, "Extend initial rules with computed reachability facts"), ('spacer.blast_term_ite', BOOL, True, "Expand non-Boolean ite-terms"), - ('spacer.nondet_tie_break', BOOL, False, "Break ties in obligation queue non-deterministicly"), + ('spacer.nondet_tie_break', BOOL, False, "Break ties in obligation queue non-deterministically"), ('spacer.reach_dnf', BOOL, True, "Restrict reachability facts to DNF"), ('bmc.linear_unrolling_depth', UINT, UINT_MAX, "Maximal level to explore"), ('spacer.split_farkas_literals', BOOL, False, "Split Farkas literals"), diff --git a/src/muz/transforms/dl_mk_array_instantiation.h b/src/muz/transforms/dl_mk_array_instantiation.h index cd5715a4f..b2e80ab84 100644 --- a/src/muz/transforms/dl_mk_array_instantiation.h +++ b/src/muz/transforms/dl_mk_array_instantiation.h @@ -26,7 +26,7 @@ Implementation: 1) Dealing with multiple quantifiers -> The options fixedpoint.xform.instantiate_arrays.nb_quantifier gives the number of quantifiers per array. - 2) Inforcing the instantiation -> We suggest an option (enforce_instantiation) to enforce this abstraction. This transforms + 2) Enforcing the instantiation -> We suggest an option (enforce_instantiation) to enforce this abstraction. This transforms P(a) into P(i, a[i]). This enforces the solver to limit the space search at the cost of imprecise results. This option corresponds to fixedpoint.xform.instantiate_arrays.enforce diff --git a/src/muz/transforms/dl_mk_interp_tail_simplifier.h b/src/muz/transforms/dl_mk_interp_tail_simplifier.h index 713827588..0d4c65d11 100644 --- a/src/muz/transforms/dl_mk_interp_tail_simplifier.h +++ b/src/muz/transforms/dl_mk_interp_tail_simplifier.h @@ -53,7 +53,7 @@ namespace datalog { */ void reset(rule * r); - /** Reset subtitution and unify tail tgt_idx of the target rule and the head of the src rule */ + /** Reset substitution and unify tail tgt_idx of the target rule and the head of the src rule */ bool unify(expr * e1, expr * e2); void get_result(rule_ref & res); diff --git a/src/muz/transforms/dl_mk_rule_inliner.h b/src/muz/transforms/dl_mk_rule_inliner.h index 27b6dd418..9146343fa 100644 --- a/src/muz/transforms/dl_mk_rule_inliner.h +++ b/src/muz/transforms/dl_mk_rule_inliner.h @@ -45,7 +45,7 @@ namespace datalog { : m(ctx.get_manager()), m_rm(ctx.get_rule_manager()), m_context(ctx), m_interp_simplifier(ctx), m_subst(m), m_unif(m), m_ready(false), m_normalize(true) {} - /** Reset subtitution and unify tail tgt_idx of the target rule and the head of the src rule */ + /** Reset substitution and unify tail tgt_idx of the target rule and the head of the src rule */ bool unify_rules(rule const& tgt, unsigned tgt_idx, rule const& src); /** diff --git a/src/muz/transforms/dl_mk_scale.h b/src/muz/transforms/dl_mk_scale.h index c171a1d06..94090ec93 100644 --- a/src/muz/transforms/dl_mk_scale.h +++ b/src/muz/transforms/dl_mk_scale.h @@ -7,7 +7,7 @@ Module Name: Abstract: - Add scale factor to linear (Real) arithemetic Horn clauses. + Add scale factor to linear (Real) arithmetic Horn clauses. The transformation replaces occurrences of isolated constants by a scale multiplied to each constant. diff --git a/src/tactic/aig/aig.cpp b/src/tactic/aig/aig.cpp index 40c68f72a..6afac32b8 100644 --- a/src/tactic/aig/aig.cpp +++ b/src/tactic/aig/aig.cpp @@ -267,7 +267,7 @@ struct aig_manager::imp { } if (b == r) { if (sign1) { - // subsitution + // substitution // not (a and b) and r --> (not a) and r IF b == r l = a; l.invert(); diff --git a/src/tactic/tactic_exception.h b/src/tactic/tactic_exception.h index 177524726..bdf2636a9 100644 --- a/src/tactic/tactic_exception.h +++ b/src/tactic/tactic_exception.h @@ -7,7 +7,7 @@ Module Name: Abstract: - Tactic expection object. + Tactic exception object. Author: diff --git a/src/tactic/tactical.h b/src/tactic/tactical.h index 169566f39..9ec2f901f 100644 --- a/src/tactic/tactical.h +++ b/src/tactic/tactical.h @@ -47,7 +47,7 @@ tactic * or_else(tactic * t1, tactic * t2, tactic * t3, tactic * t4, tactic * t5 tactic * repeat(tactic * t, unsigned max = UINT_MAX); /** - \brief Fails if \c t produeces more than \c threshold subgoals. + \brief Fails if \c t produces more than \c threshold subgoals. Otherwise, it behaves like \c t. */ tactic * fail_if_branching(tactic * t, unsigned threshold = 1); From ba603307fcb39cdc12a6d0283ddc9632ca436478 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Fri, 9 Mar 2018 05:32:01 -0500 Subject: [PATCH 030/109] remove stale deprecated annotation #1525 Signed-off-by: Nikolaj Bjorner --- src/api/z3_api.h | 5 ----- 1 file changed, 5 deletions(-) diff --git a/src/api/z3_api.h b/src/api/z3_api.h index 500533e91..f7c218963 100644 --- a/src/api/z3_api.h +++ b/src/api/z3_api.h @@ -1477,7 +1477,6 @@ extern "C" { /*@{*/ /** - \deprecated \brief Create a configuration object for the Z3 context object. Configurations are created in order to assign parameters prior to creating @@ -1510,7 +1509,6 @@ extern "C" { Z3_config Z3_API Z3_mk_config(void); /** - \deprecated \brief Delete the given configuration object. \sa Z3_mk_config @@ -1520,7 +1518,6 @@ extern "C" { void Z3_API Z3_del_config(Z3_config c); /** - \deprecated \brief Set a configuration parameter. The following parameters can be set for @@ -1537,7 +1534,6 @@ extern "C" { /*@{*/ /** - \deprecated \brief Create a context using the given configuration. After a context is created, the configuration cannot be changed, @@ -1617,7 +1613,6 @@ extern "C" { void Z3_API Z3_dec_ref(Z3_context c, Z3_ast a); /** - \deprecated \brief Set a value of a context parameter. \sa Z3_global_param_set From ae165a539e476a032f83ce252582f7b94b644e20 Mon Sep 17 00:00:00 2001 From: Pierre Pronchery Date: Fri, 9 Mar 2018 14:20:31 +0100 Subject: [PATCH 031/109] Fix parameter expansion when configuring Z3 --- configure | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/configure b/configure index 29408d3e7..807fba392 100755 --- a/configure +++ b/configure @@ -14,4 +14,4 @@ if ! $PYTHON -c "print('testing')" > /dev/null ; then exit 1 fi -$PYTHON scripts/mk_make.py $* +$PYTHON scripts/mk_make.py "$@" From e5a19816943fd1fdf3c93ff0ac7dfe1871fc1807 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Fri, 9 Mar 2018 15:40:35 -0500 Subject: [PATCH 032/109] disable GCC flag change to see if this affects build Signed-off-by: Nikolaj Bjorner --- CMakeLists.txt | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index f20c4fb10..62045016a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -410,17 +410,17 @@ list(APPEND Z3_DEPENDENT_LIBS ${CMAKE_THREAD_LIBS_INIT}) include(${CMAKE_SOURCE_DIR}/cmake/compiler_warnings.cmake) ################################################################################ -# If using Ninja, force color output for Clang and gcc. +# If using Ninja, force color output for Clang (and gcc, disabled to check build). ################################################################################ if (UNIX AND CMAKE_GENERATOR STREQUAL "Ninja") if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fcolor-diagnostics") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fcolor-diagnostics") endif() - if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU") - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fdiagnostics-color") - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fdiagnostics-color") - endif() +# if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU") +# set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fdiagnostics-color") +# set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fdiagnostics-color") +# endif() endif() ################################################################################ From 6e87622c8a770c497cafbf972dbd96eaa34eb67c Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Sat, 10 Mar 2018 13:55:01 -0500 Subject: [PATCH 033/109] remove references to deprecated uses of PROOF_MODE #1531 Signed-off-by: Nikolaj Bjorner --- src/api/api_ast.cpp | 3 -- src/api/dotnet/Expr.cs | 38 +---------------- src/api/java/Expr.java | 55 ++----------------------- src/api/z3_api.h | 23 +---------- src/ast/ast.cpp | 31 -------------- src/ast/ast.h | 11 ++--- src/ast/proofs/proof_checker.cpp | 27 ------------ src/smt/theory_arith_core.h | 1 - src/smt/theory_str.cpp | 2 + src/tactic/core/ctx_simplify_tactic.cpp | 2 +- src/tactic/core/dom_simplify_tactic.cpp | 4 +- 11 files changed, 16 insertions(+), 181 deletions(-) diff --git a/src/api/api_ast.cpp b/src/api/api_ast.cpp index 3f5a0fcf1..1f4a86903 100644 --- a/src/api/api_ast.cpp +++ b/src/api/api_ast.cpp @@ -919,7 +919,6 @@ extern "C" { case PR_REWRITE: return Z3_OP_PR_REWRITE; case PR_REWRITE_STAR: return Z3_OP_PR_REWRITE_STAR; case PR_PULL_QUANT: return Z3_OP_PR_PULL_QUANT; - case PR_PULL_QUANT_STAR: return Z3_OP_PR_PULL_QUANT_STAR; case PR_PUSH_QUANT: return Z3_OP_PR_PUSH_QUANT; case PR_ELIM_UNUSED_VARS: return Z3_OP_PR_ELIM_UNUSED_VARS; case PR_DER: return Z3_OP_PR_DER; @@ -936,9 +935,7 @@ extern "C" { case PR_IFF_OEQ: return Z3_OP_PR_IFF_OEQ; case PR_NNF_POS: return Z3_OP_PR_NNF_POS; case PR_NNF_NEG: return Z3_OP_PR_NNF_NEG; - case PR_NNF_STAR: return Z3_OP_PR_NNF_STAR; case PR_SKOLEMIZE: return Z3_OP_PR_SKOLEMIZE; - case PR_CNF_STAR: return Z3_OP_PR_CNF_STAR; case PR_MODUS_PONENS_OEQ: return Z3_OP_PR_MODUS_PONENS_OEQ; case PR_TH_LEMMA: return Z3_OP_PR_TH_LEMMA; case PR_HYPER_RESOLVE: return Z3_OP_PR_HYPER_RESOLVE; diff --git a/src/api/dotnet/Expr.cs b/src/api/dotnet/Expr.cs index 0726f9d53..9310d1e7d 100644 --- a/src/api/dotnet/Expr.cs +++ b/src/api/dotnet/Expr.cs @@ -932,7 +932,7 @@ namespace Microsoft.Z3 /// Indicates whether the term is a proof by condensed transitivity of a relation /// /// - /// Condensed transitivity proof. This proof object is only used if the parameter PROOF_MODE is 1. + /// Condensed transitivity proof. /// It combines several symmetry and transitivity proofs. /// Example: /// T1: (R a b) @@ -1035,14 +1035,11 @@ namespace Microsoft.Z3 /// /// /// A proof for rewriting an expression t into an expression s. - /// This proof object is used if the parameter PROOF_MODE is 1. /// This proof object can have n antecedents. /// The antecedents are proofs for equalities used as substitution rules. - /// The object is also used in a few cases if the parameter PROOF_MODE is 2. - /// The cases are: + /// The object is used in a few cases: /// - When applying contextual simplification (CONTEXT_SIMPLIFIER=true) /// - When converting bit-vectors to Booleans (BIT2BOOL=true) - /// - When pulling ite expression up (PULL_CHEAP_ITE_TREES=true) /// public bool IsProofRewriteStar { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_REWRITE_STAR; } } @@ -1054,15 +1051,6 @@ namespace Microsoft.Z3 /// public bool IsProofPullQuant { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_PULL_QUANT; } } - /// - /// Indicates whether the term is a proof for pulling quantifiers out. - /// - /// - /// A proof for (iff P Q) where Q is in prenex normal form. - /// This proof object is only used if the parameter PROOF_MODE is 1. - /// This proof object has no antecedents - /// - public bool IsProofPullQuantStar { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_PULL_QUANT_STAR; } } /// /// Indicates whether the term is a proof for pushing quantifiers in. @@ -1304,28 +1292,6 @@ namespace Microsoft.Z3 /// public bool IsProofNNFNeg { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_NNF_NEG; } } - /// - /// Indicates whether the term is a proof for (~ P Q) here Q is in negation normal form. - /// - /// - /// A proof for (~ P Q) where Q is in negation normal form. - /// - /// This proof object is only used if the parameter PROOF_MODE is 1. - /// - /// This proof object may have n antecedents. Each antecedent is a PR_DEF_INTRO. - /// - public bool IsProofNNFStar { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_NNF_STAR; } } - - /// - /// Indicates whether the term is a proof for (~ P Q) where Q is in conjunctive normal form. - /// - /// - /// A proof for (~ P Q) where Q is in conjunctive normal form. - /// This proof object is only used if the parameter PROOF_MODE is 1. - /// This proof object may have n antecedents. Each antecedent is a PR_DEF_INTRO. - /// - public bool IsProofCNFStar { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_CNF_STAR; } } - /// /// Indicates whether the term is a proof for a Skolemization step /// diff --git a/src/api/java/Expr.java b/src/api/java/Expr.java index 7b20b7993..db5c33e79 100644 --- a/src/api/java/Expr.java +++ b/src/api/java/Expr.java @@ -1398,8 +1398,7 @@ public class Expr extends AST /** * Indicates whether the term is a proof by condensed transitivity of a * relation - * Remarks: Condensed transitivity proof. This proof object is - * only used if the parameter PROOF_MODE is 1. It combines several symmetry + * Remarks: Condensed transitivity proof. It combines several symmetry * and transitivity proofs. Example: T1: (R a b) T2: (R c b) T3: (R c d) * [trans* T1 T2 T3]: (R a d) R must be a symmetric and transitive relation. * @@ -1506,14 +1505,11 @@ public class Expr extends AST /** * Indicates whether the term is a proof by rewriting * Remarks: A proof for - * rewriting an expression t into an expression s. This proof object is used - * if the parameter PROOF_MODE is 1. This proof object can have n + * rewriting an expression t into an expression s. This proof object can have n * antecedents. The antecedents are proofs for equalities used as - * substitution rules. The object is also used in a few cases if the - * parameter PROOF_MODE is 2. The cases are: - When applying contextual + * substitution rules. The object is used in a few cases . The cases are: - When applying contextual * simplification (CONTEXT_SIMPLIFIER=true) - When converting bit-vectors to - * Booleans (BIT2BOOL=true) - When pulling ite expression up - * (PULL_CHEAP_ITE_TREES=true) + * Booleans (BIT2BOOL=true) * @throws Z3Exception on error * @return a boolean **/ @@ -1534,17 +1530,6 @@ public class Expr extends AST return isApp() && getFuncDecl().getDeclKind() == Z3_decl_kind.Z3_OP_PR_PULL_QUANT; } - /** - * Indicates whether the term is a proof for pulling quantifiers out. - * - * Remarks: A proof for (iff P Q) where Q is in prenex normal form. This * proof object is only used if the parameter PROOF_MODE is 1. This proof * object has no antecedents - * @throws Z3Exception on error - * @return a boolean - **/ - public boolean isProofPullQuantStar() - { - return isApp() && getFuncDecl().getDeclKind() == Z3_decl_kind.Z3_OP_PR_PULL_QUANT_STAR; - } /** * Indicates whether the term is a proof for pushing quantifiers in. @@ -1804,38 +1789,6 @@ public class Expr extends AST return isApp() && getFuncDecl().getDeclKind() == Z3_decl_kind.Z3_OP_PR_NNF_NEG; } - /** - * Indicates whether the term is a proof for (~ P Q) here Q is in negation - * normal form. - * Remarks: A proof for (~ P Q) where Q is in negation normal - * form. - * - * This proof object is only used if the parameter PROOF_MODE is 1. - * - * This proof object may have n antecedents. Each antecedent is a - * PR_DEF_INTRO. - * @throws Z3Exception on error - * @return a boolean - **/ - public boolean isProofNNFStar() - { - return isApp() && getFuncDecl().getDeclKind() == Z3_decl_kind.Z3_OP_PR_NNF_STAR; - } - - /** - * Indicates whether the term is a proof for (~ P Q) where Q is in - * conjunctive normal form. - * Remarks: A proof for (~ P Q) where Q is in - * conjunctive normal form. This proof object is only used if the parameter - * PROOF_MODE is 1. This proof object may have n antecedents. Each - * antecedent is a PR_DEF_INTRO. - * @throws Z3Exception on error - * @return a boolean - **/ - public boolean isProofCNFStar() - { - return isApp() && getFuncDecl().getDeclKind() == Z3_decl_kind.Z3_OP_PR_CNF_STAR; - } /** * Indicates whether the term is a proof for a Skolemization step diff --git a/src/api/z3_api.h b/src/api/z3_api.h index f7c218963..88d6aa1cf 100644 --- a/src/api/z3_api.h +++ b/src/api/z3_api.h @@ -459,7 +459,7 @@ typedef enum [trans T1 T2]: (R t u) } - - Z3_OP_PR_TRANSITIVITY_STAR: Condensed transitivity proof. This proof object is only used if the parameter PROOF_MODE is 1. + - Z3_OP_PR_TRANSITIVITY_STAR: Condensed transitivity proof. It combines several symmetry and transitivity proofs. Example: @@ -539,21 +539,14 @@ typedef enum } - Z3_OP_PR_REWRITE_STAR: A proof for rewriting an expression t into an expression s. - This proof object is used if the parameter PROOF_MODE is 1. This proof object can have n antecedents. The antecedents are proofs for equalities used as substitution rules. - The object is also used in a few cases if the parameter PROOF_MODE is 2. - The cases are: + The proof rule is used in a few cases. The cases are: - When applying contextual simplification (CONTEXT_SIMPLIFIER=true) - When converting bit-vectors to Booleans (BIT2BOOL=true) - - When pulling ite expression up (PULL_CHEAP_ITE_TREES=true) - Z3_OP_PR_PULL_QUANT: A proof for (iff (f (forall (x) q(x)) r) (forall (x) (f (q x) r))). This proof object has no antecedents. - - Z3_OP_PR_PULL_QUANT_STAR: A proof for (iff P Q) where Q is in prenex normal form. - This proof object is only used if the parameter PROOF_MODE is 1. - This proof object has no antecedents. - - Z3_OP_PR_PUSH_QUANT: A proof for: \nicebox{ @@ -726,15 +719,6 @@ typedef enum [nnf-neg T1 T2 T3 T4]: (~ (not (iff s_1 s_2)) (and (or r_1 r_2) (or r_1' r_2'))) } - - Z3_OP_PR_NNF_STAR: A proof for (~ P Q) where Q is in negation normal form. - - This proof object is only used if the parameter PROOF_MODE is 1. - - This proof object may have n antecedents. Each antecedent is a PR_DEF_INTRO. - - - Z3_OP_PR_CNF_STAR: A proof for (~ P Q) where Q is in conjunctive normal form. - This proof object is only used if the parameter PROOF_MODE is 1. - This proof object may have n antecedents. Each antecedent is a PR_DEF_INTRO. - Z3_OP_PR_SKOLEMIZE: Proof for: @@ -1142,7 +1126,6 @@ typedef enum { Z3_OP_PR_REWRITE, Z3_OP_PR_REWRITE_STAR, Z3_OP_PR_PULL_QUANT, - Z3_OP_PR_PULL_QUANT_STAR, Z3_OP_PR_PUSH_QUANT, Z3_OP_PR_ELIM_UNUSED_VARS, Z3_OP_PR_DER, @@ -1159,8 +1142,6 @@ typedef enum { Z3_OP_PR_IFF_OEQ, Z3_OP_PR_NNF_POS, Z3_OP_PR_NNF_NEG, - Z3_OP_PR_NNF_STAR, - Z3_OP_PR_CNF_STAR, Z3_OP_PR_SKOLEMIZE, Z3_OP_PR_MODUS_PONENS_OEQ, Z3_OP_PR_TH_LEMMA, diff --git a/src/ast/ast.cpp b/src/ast/ast.cpp index 127967374..7e143e1a3 100644 --- a/src/ast/ast.cpp +++ b/src/ast/ast.cpp @@ -663,7 +663,6 @@ basic_decl_plugin::basic_decl_plugin(): m_not_or_elim_decl(nullptr), m_rewrite_decl(nullptr), m_pull_quant_decl(nullptr), - m_pull_quant_star_decl(nullptr), m_push_quant_decl(nullptr), m_elim_unused_vars_decl(nullptr), m_der_decl(nullptr), @@ -827,7 +826,6 @@ func_decl * basic_decl_plugin::mk_proof_decl(basic_op_kind k, unsigned num_paren case PR_REWRITE: return mk_proof_decl("rewrite", k, 0, m_rewrite_decl); case PR_REWRITE_STAR: return mk_proof_decl("rewrite*", k, num_parents, m_rewrite_star_decls); case PR_PULL_QUANT: return mk_proof_decl("pull-quant", k, 0, m_pull_quant_decl); - case PR_PULL_QUANT_STAR: return mk_proof_decl("pull-quant*", k, 0, m_pull_quant_star_decl); case PR_PUSH_QUANT: return mk_proof_decl("push-quant", k, 0, m_push_quant_decl); case PR_ELIM_UNUSED_VARS: return mk_proof_decl("elim-unused", k, 0, m_elim_unused_vars_decl); case PR_DER: return mk_proof_decl("der", k, 0, m_der_decl); @@ -844,8 +842,6 @@ func_decl * basic_decl_plugin::mk_proof_decl(basic_op_kind k, unsigned num_paren case PR_IFF_OEQ: return mk_proof_decl("iff~", k, 1, m_iff_oeq_decl); case PR_NNF_POS: return mk_proof_decl("nnf-pos", k, num_parents, m_nnf_pos_decls); case PR_NNF_NEG: return mk_proof_decl("nnf-neg", k, num_parents, m_nnf_neg_decls); - case PR_NNF_STAR: return mk_proof_decl("nnf*", k, num_parents, m_nnf_star_decls); - case PR_CNF_STAR: return mk_proof_decl("cnf*", k, num_parents, m_cnf_star_decls); case PR_SKOLEMIZE: return mk_proof_decl("sk", k, 0, m_skolemize_decl); case PR_MODUS_PONENS_OEQ: return mk_proof_decl("mp~", k, 2, m_mp_oeq_decl); case PR_TH_LEMMA: return mk_proof_decl("th-lemma", k, num_parents, m_th_lemma_decls); @@ -949,7 +945,6 @@ void basic_decl_plugin::finalize() { DEC_REF(m_not_or_elim_decl); DEC_REF(m_rewrite_decl); DEC_REF(m_pull_quant_decl); - DEC_REF(m_pull_quant_star_decl); DEC_REF(m_push_quant_decl); DEC_REF(m_elim_unused_vars_decl); DEC_REF(m_der_decl); @@ -975,8 +970,6 @@ void basic_decl_plugin::finalize() { DEC_ARRAY_REF(m_apply_def_decls); DEC_ARRAY_REF(m_nnf_pos_decls); DEC_ARRAY_REF(m_nnf_neg_decls); - DEC_ARRAY_REF(m_nnf_star_decls); - DEC_ARRAY_REF(m_cnf_star_decls); DEC_ARRAY_REF(m_th_lemma_decls); DEC_REF(m_hyper_res_decl0); @@ -2844,12 +2837,6 @@ proof * ast_manager::mk_pull_quant(expr * e, quantifier * q) { return mk_app(m_basic_family_id, PR_PULL_QUANT, mk_iff(e, q)); } -proof * ast_manager::mk_pull_quant_star(expr * e, quantifier * q) { - if (proofs_disabled()) - return nullptr; - return mk_app(m_basic_family_id, PR_PULL_QUANT_STAR, mk_iff(e, q)); -} - proof * ast_manager::mk_push_quant(quantifier * q, expr * e) { if (proofs_disabled()) return nullptr; @@ -3094,15 +3081,6 @@ proof * ast_manager::mk_nnf_neg(expr * s, expr * t, unsigned num_proofs, proof * return mk_app(m_basic_family_id, PR_NNF_NEG, args.size(), args.c_ptr()); } -proof * ast_manager::mk_nnf_star(expr * s, expr * t, unsigned num_proofs, proof * const * proofs) { - if (proofs_disabled()) - return nullptr; - ptr_buffer args; - args.append(num_proofs, (expr**) proofs); - args.push_back(mk_oeq(s, t)); - return mk_app(m_basic_family_id, PR_NNF_STAR, args.size(), args.c_ptr()); -} - proof * ast_manager::mk_skolemization(expr * q, expr * e) { if (proofs_disabled()) return nullptr; @@ -3111,15 +3089,6 @@ proof * ast_manager::mk_skolemization(expr * q, expr * e) { return mk_app(m_basic_family_id, PR_SKOLEMIZE, mk_oeq(q, e)); } -proof * ast_manager::mk_cnf_star(expr * s, expr * t, unsigned num_proofs, proof * const * proofs) { - if (proofs_disabled()) - return nullptr; - ptr_buffer args; - args.append(num_proofs, (expr**) proofs); - args.push_back(mk_oeq(s, t)); - return mk_app(m_basic_family_id, PR_CNF_STAR, args.size(), args.c_ptr()); -} - proof * ast_manager::mk_and_elim(proof * p, unsigned i) { if (proofs_disabled()) return nullptr; diff --git a/src/ast/ast.h b/src/ast/ast.h index 55fea1b69..68e02d791 100644 --- a/src/ast/ast.h +++ b/src/ast/ast.h @@ -1042,11 +1042,11 @@ enum basic_op_kind { PR_UNDEF, PR_TRUE, PR_ASSERTED, PR_GOAL, PR_MODUS_PONENS, PR_REFLEXIVITY, PR_SYMMETRY, PR_TRANSITIVITY, PR_TRANSITIVITY_STAR, PR_MONOTONICITY, PR_QUANT_INTRO, PR_DISTRIBUTIVITY, PR_AND_ELIM, PR_NOT_OR_ELIM, PR_REWRITE, PR_REWRITE_STAR, PR_PULL_QUANT, - PR_PULL_QUANT_STAR, PR_PUSH_QUANT, PR_ELIM_UNUSED_VARS, PR_DER, PR_QUANT_INST, + PR_PUSH_QUANT, PR_ELIM_UNUSED_VARS, PR_DER, PR_QUANT_INST, PR_HYPOTHESIS, PR_LEMMA, PR_UNIT_RESOLUTION, PR_IFF_TRUE, PR_IFF_FALSE, PR_COMMUTATIVITY, PR_DEF_AXIOM, - PR_DEF_INTRO, PR_APPLY_DEF, PR_IFF_OEQ, PR_NNF_POS, PR_NNF_NEG, PR_NNF_STAR, PR_SKOLEMIZE, PR_CNF_STAR, + PR_DEF_INTRO, PR_APPLY_DEF, PR_IFF_OEQ, PR_NNF_POS, PR_NNF_NEG, PR_SKOLEMIZE, PR_MODUS_PONENS_OEQ, PR_TH_LEMMA, PR_HYPER_RESOLVE, LAST_BASIC_PR }; @@ -1080,7 +1080,6 @@ protected: func_decl * m_not_or_elim_decl; func_decl * m_rewrite_decl; func_decl * m_pull_quant_decl; - func_decl * m_pull_quant_star_decl; func_decl * m_push_quant_decl; func_decl * m_elim_unused_vars_decl; func_decl * m_der_decl; @@ -1106,8 +1105,6 @@ protected: ptr_vector m_apply_def_decls; ptr_vector m_nnf_pos_decls; ptr_vector m_nnf_neg_decls; - ptr_vector m_nnf_star_decls; - ptr_vector m_cnf_star_decls; ptr_vector m_th_lemma_decls; func_decl * m_hyper_res_decl0; @@ -2182,7 +2179,6 @@ public: proof * mk_oeq_rewrite(expr * s, expr * t); proof * mk_rewrite_star(expr * s, expr * t, unsigned num_proofs, proof * const * proofs); proof * mk_pull_quant(expr * e, quantifier * q); - proof * mk_pull_quant_star(expr * e, quantifier * q); proof * mk_push_quant(quantifier * q, expr * e); proof * mk_elim_unused_vars(quantifier * q, expr * r); proof * mk_der(quantifier * q, expr * r); @@ -2201,9 +2197,8 @@ public: proof * mk_nnf_pos(expr * s, expr * t, unsigned num_proofs, proof * const * proofs); proof * mk_nnf_neg(expr * s, expr * t, unsigned num_proofs, proof * const * proofs); - proof * mk_nnf_star(expr * s, expr * t, unsigned num_proofs, proof * const * proofs); proof * mk_skolemization(expr * q, expr * e); - proof * mk_cnf_star(expr * s, expr * t, unsigned num_proofs, proof * const * proofs); + proof * mk_and_elim(proof * p, unsigned i); proof * mk_not_or_elim(proof * p, unsigned i); diff --git a/src/ast/proofs/proof_checker.cpp b/src/ast/proofs/proof_checker.cpp index bd50e6c2a..0e16abd11 100644 --- a/src/ast/proofs/proof_checker.cpp +++ b/src/ast/proofs/proof_checker.cpp @@ -440,16 +440,6 @@ bool proof_checker::check1_basic(proof* p, expr_ref_vector& side_conditions) { IF_VERBOSE(0, verbose_stream() << "Expected proof of equivalence with a quantifier:\n" << mk_bounded_pp(p, m);); return false; } - case PR_PULL_QUANT_STAR: { - if (match_proof(p) && - match_fact(p, fact) && - match_iff(fact.get(), t1, t2)) { - // TBD: check the enchilada. - return true; - } - IF_VERBOSE(0, verbose_stream() << "Expected proof of equivalence:\n" << mk_bounded_pp(p, m);); - return false; - } case PR_PUSH_QUANT: { if (match_proof(p) && match_fact(p, fact) && @@ -730,10 +720,6 @@ bool proof_checker::check1_basic(proof* p, expr_ref_vector& side_conditions) { // TBD: return true; } - case PR_NNF_STAR: { - // TBD: - return true; - } case PR_SKOLEMIZE: { // (exists ?x (p ?x y)) -> (p (sk y) y) // (not (forall ?x (p ?x y))) -> (not (p (sk y) y)) @@ -755,19 +741,6 @@ bool proof_checker::check1_basic(proof* p, expr_ref_vector& side_conditions) { UNREACHABLE(); return false; } - case PR_CNF_STAR: { - for (unsigned i = 0; i < proofs.size(); ++i) { - if (match_op(proofs[i].get(), PR_DEF_INTRO, terms)) { - // ok - } - else { - UNREACHABLE(); - return false; - } - } - // coarse grain CNF conversion. - return true; - } case PR_MODUS_PONENS_OEQ: { if (match_fact(p, fact) && match_proof(p, p0, p1) && diff --git a/src/smt/theory_arith_core.h b/src/smt/theory_arith_core.h index 3393634b6..46388fcf4 100644 --- a/src/smt/theory_arith_core.h +++ b/src/smt/theory_arith_core.h @@ -597,7 +597,6 @@ namespace smt { void theory_arith::mk_to_int_axiom(app * n) { SASSERT(m_util.is_to_int(n)); ast_manager & m = get_manager(); - context & ctx = get_context(); expr* x = n->get_arg(0); // to_int (to_real x) = x diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp index 9dfd0475b..3335370eb 100644 --- a/src/smt/theory_str.cpp +++ b/src/smt/theory_str.cpp @@ -5595,6 +5595,8 @@ namespace smt { // merge arg0 and arg1 expr * arg0 = to_app(node)->get_arg(0); expr * arg1 = to_app(node)->get_arg(1); + SASSERT(arg0 != node); + SASSERT(arg1 != node); expr * arg0DeAlias = dealias_node(arg0, varAliasMap, concatAliasMap); expr * arg1DeAlias = dealias_node(arg1, varAliasMap, concatAliasMap); get_grounded_concats(arg0DeAlias, varAliasMap, concatAliasMap, varConstMap, concatConstMap, varEqConcatMap, groundedMap); diff --git a/src/tactic/core/ctx_simplify_tactic.cpp b/src/tactic/core/ctx_simplify_tactic.cpp index 6ad9c0812..93a0b2e88 100644 --- a/src/tactic/core/ctx_simplify_tactic.cpp +++ b/src/tactic/core/ctx_simplify_tactic.cpp @@ -582,7 +582,7 @@ struct ctx_simplify_tactic::imp { for (unsigned i = 0; !g.inconsistent() && i < sz; ++i) { expr * t = g.form(i); process(t, r); - proof* new_pr = m.mk_modus_ponens(g.pr(i), m.mk_rewrite_star(t, r, 0, nullptr)); // TODO :-) + proof* new_pr = m.mk_modus_ponens(g.pr(i), m.mk_rewrite(t, r)); g.update(i, r, new_pr, g.dep(i)); } } diff --git a/src/tactic/core/dom_simplify_tactic.cpp b/src/tactic/core/dom_simplify_tactic.cpp index e8d3150af..47f96a7d9 100644 --- a/src/tactic/core/dom_simplify_tactic.cpp +++ b/src/tactic/core/dom_simplify_tactic.cpp @@ -382,7 +382,7 @@ void dom_simplify_tactic::simplify_goal(goal& g) { change |= r != g.form(i); proof* new_pr = nullptr; if (g.proofs_enabled()) { - new_pr = m.mk_modus_ponens(g.pr(i), m.mk_rewrite_star(g.form(i), r, 0, nullptr)); + new_pr = m.mk_modus_ponens(g.pr(i), m.mk_rewrite(g.form(i), r)); } g.update(i, r, new_pr, g.dep(i)); } @@ -402,7 +402,7 @@ void dom_simplify_tactic::simplify_goal(goal& g) { CTRACE("simplify", r != g.form(i), tout << r << " " << mk_pp(g.form(i), m) << "\n";); proof* new_pr = nullptr; if (g.proofs_enabled()) { - new_pr = m.mk_modus_ponens(g.pr(i), m.mk_rewrite_star(g.form(i), r, 0, nullptr)); + new_pr = m.mk_modus_ponens(g.pr(i), m.mk_rewrite(g.form(i), r)); } g.update(i, r, new_pr, g.dep(i)); } From 0ce200144923fe5856054bcad11c9f5471f0d791 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Sat, 10 Mar 2018 11:39:22 -0800 Subject: [PATCH 034/109] fix build Signed-off-by: Nikolaj Bjorner --- examples/tptp/tptp5.cpp | 11 ----------- scripts/mk_util.py | 9 +++++++-- 2 files changed, 7 insertions(+), 13 deletions(-) diff --git a/examples/tptp/tptp5.cpp b/examples/tptp/tptp5.cpp index b2736df4c..772440b42 100644 --- a/examples/tptp/tptp5.cpp +++ b/examples/tptp/tptp5.cpp @@ -1609,7 +1609,6 @@ public: display_inference(out, "rewrite", "thm", p); break; case Z3_OP_PR_PULL_QUANT: - case Z3_OP_PR_PULL_QUANT_STAR: display_inference(out, "pull_quant", "thm", p); break; case Z3_OP_PR_PUSH_QUANT: @@ -1669,12 +1668,6 @@ public: case Z3_OP_PR_NNF_NEG: display_inference(out, "nnf_neg", "sab", p); break; - case Z3_OP_PR_NNF_STAR: - display_inference(out, "nnf", "sab", p); - break; - case Z3_OP_PR_CNF_STAR: - display_inference(out, "cnf", "sab", p); - break; case Z3_OP_PR_SKOLEMIZE: display_inference(out, "skolemize", "sab", p); break; @@ -1706,10 +1699,6 @@ public: return display_hyp_inference(out, "modus_ponens", "thm", conclusion, hyp, hyp2); } case Z3_OP_PR_NNF_POS: - case Z3_OP_PR_NNF_STAR: - return display_hyp_inference(out, "nnf", "sab", conclusion, hyp); - case Z3_OP_PR_CNF_STAR: - return display_hyp_inference(out, "cnf", "sab", conclusion, hyp); case Z3_OP_PR_SKOLEMIZE: return display_hyp_inference(out, "skolemize", "sab", conclusion, hyp); case Z3_OP_PR_TRANSITIVITY: diff --git a/scripts/mk_util.py b/scripts/mk_util.py index 03256125c..fecc207d8 100644 --- a/scripts/mk_util.py +++ b/scripts/mk_util.py @@ -889,8 +889,13 @@ def is_CXX_gpp(): return is_compiler(CXX, 'g++') def is_clang_in_gpp_form(cc): - version_string = check_output([cc, '--version']).encode('utf-8').decode('utf-8') - return version_string.find('clang') != -1 + str = check_output([cc, '--version']) + try: + version_string = str.encode('utf-8') + except: + version_string = str + clang = 'clang'.encode('utf-8') + return version_string.find(clang) != -1 def is_CXX_clangpp(): if is_compiler(CXX, 'g++'): From 58544925048b8559880edb20ccca385c895f1acb Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Sat, 10 Mar 2018 11:59:42 -0800 Subject: [PATCH 035/109] add stdbool.h to see whether build system breaks #1526 Signed-off-by: Nikolaj Bjorner --- src/api/z3.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/api/z3.h b/src/api/z3.h index 99929f33b..b29f1d6ba 100644 --- a/src/api/z3.h +++ b/src/api/z3.h @@ -21,7 +21,8 @@ Notes: #ifndef Z3_H_ #define Z3_H_ -#include +#include +#include #include "z3_macros.h" #include "z3_api.h" #include "z3_ast_containers.h" From 3d9139f6efaf9f6fb4a2f6226384a5824ae986a6 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Sat, 10 Mar 2018 12:07:55 -0800 Subject: [PATCH 036/109] bump revision Signed-off-by: Nikolaj Bjorner --- CMakeLists.txt | 2 +- scripts/mk_project.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 62045016a..4d8c15493 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -34,7 +34,7 @@ endif() ################################################################################ set(Z3_VERSION_MAJOR 4) set(Z3_VERSION_MINOR 6) -set(Z3_VERSION_PATCH 1) +set(Z3_VERSION_PATCH 2) set(Z3_VERSION_TWEAK 0) set(Z3_VERSION "${Z3_VERSION_MAJOR}.${Z3_VERSION_MINOR}.${Z3_VERSION_PATCH}.${Z3_VERSION_TWEAK}") set(Z3_FULL_VERSION_STR "${Z3_VERSION}") # Note this might be modified diff --git a/scripts/mk_project.py b/scripts/mk_project.py index 8f75e97ed..2f7402760 100644 --- a/scripts/mk_project.py +++ b/scripts/mk_project.py @@ -9,7 +9,7 @@ from mk_util import * # Z3 Project definition def init_project_def(): - set_version(4, 6, 1, 0) + set_version(4, 6, 2, 0) add_lib('util', []) add_lib('lp', ['util'], 'util/lp') add_lib('polynomial', ['util'], 'math/polynomial') From 5651d00751a1eb40b94db86f00cb7d3ec9711c4d Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Mon, 12 Mar 2018 13:21:31 -0700 Subject: [PATCH 037/109] fix #1534 Signed-off-by: Nikolaj Bjorner --- src/math/polynomial/upolynomial.cpp | 18 ++++++++---------- src/smt/theory_str.cpp | 18 ++++++++++-------- src/smt/theory_str.h | 9 +++++---- 3 files changed, 23 insertions(+), 22 deletions(-) diff --git a/src/math/polynomial/upolynomial.cpp b/src/math/polynomial/upolynomial.cpp index f7cc16de2..cc2442981 100644 --- a/src/math/polynomial/upolynomial.cpp +++ b/src/math/polynomial/upolynomial.cpp @@ -781,17 +781,15 @@ namespace upolynomial { set(q.size(), q.c_ptr(), C); m().set(bound, p); } + else if (q.size() < C.size() || m().m().is_even(p) || m().m().is_even(bound)) { + // discard accumulated image, it was affected by unlucky primes + TRACE("mgcd", tout << "discarding image\n";); + set(q.size(), q.c_ptr(), C); + m().set(bound, p); + } else { - if (q.size() < C.size()) { - // discard accumulated image, it was affected by unlucky primes - TRACE("mgcd", tout << "discarding image\n";); - set(q.size(), q.c_ptr(), C); - m().set(bound, p); - } - else { - CRA_combine_images(q, p, C, bound); - TRACE("mgcd", tout << "new combined:\n"; display_star(tout, C); tout << "\n";); - } + CRA_combine_images(q, p, C, bound); + TRACE("mgcd", tout << "new combined:\n"; display_star(tout, C); tout << "\n";); } numeral_vector & candidate = q; get_primitive(C, candidate); diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp index 3335370eb..0016b8f36 100644 --- a/src/smt/theory_str.cpp +++ b/src/smt/theory_str.cpp @@ -5553,7 +5553,8 @@ namespace smt { return node; } - void theory_str::get_grounded_concats(expr* node, std::map & varAliasMap, + void theory_str::get_grounded_concats(unsigned depth, + expr* node, std::map & varAliasMap, std::map & concatAliasMap, std::map & varConstMap, std::map & concatConstMap, std::map > & varEqConcatMap, std::map, std::set > > & groundedMap) { @@ -5568,6 +5569,9 @@ namespace smt { if (groundedMap.find(node) != groundedMap.end()) { return; } + IF_VERBOSE(100, verbose_stream() << "concats " << depth << "\n"; + if (depth > 100) verbose_stream() << mk_pp(node, get_manager()) << "\n"; + ); // haven't computed grounded concats for "node" (de-aliased) // --------------------------------------------------------- @@ -5595,12 +5599,10 @@ namespace smt { // merge arg0 and arg1 expr * arg0 = to_app(node)->get_arg(0); expr * arg1 = to_app(node)->get_arg(1); - SASSERT(arg0 != node); - SASSERT(arg1 != node); expr * arg0DeAlias = dealias_node(arg0, varAliasMap, concatAliasMap); expr * arg1DeAlias = dealias_node(arg1, varAliasMap, concatAliasMap); - get_grounded_concats(arg0DeAlias, varAliasMap, concatAliasMap, varConstMap, concatConstMap, varEqConcatMap, groundedMap); - get_grounded_concats(arg1DeAlias, varAliasMap, concatAliasMap, varConstMap, concatConstMap, varEqConcatMap, groundedMap); + get_grounded_concats(depth + 1, arg0DeAlias, varAliasMap, concatAliasMap, varConstMap, concatConstMap, varEqConcatMap, groundedMap); + get_grounded_concats(depth + 1, arg1DeAlias, varAliasMap, concatAliasMap, varConstMap, concatConstMap, varEqConcatMap, groundedMap); std::map, std::set >::iterator arg0_grdItor = groundedMap[arg0DeAlias].begin(); std::map, std::set >::iterator arg1_grdItor; @@ -5650,7 +5652,7 @@ namespace smt { else if (varEqConcatMap.find(node) != varEqConcatMap.end()) { expr * eqConcat = varEqConcatMap[node].begin()->first; expr * deAliasedEqConcat = dealias_node(eqConcat, varAliasMap, concatAliasMap); - get_grounded_concats(deAliasedEqConcat, varAliasMap, concatAliasMap, varConstMap, concatConstMap, varEqConcatMap, groundedMap); + get_grounded_concats(depth + 1, deAliasedEqConcat, varAliasMap, concatAliasMap, varConstMap, concatConstMap, varEqConcatMap, groundedMap); std::map, std::set >::iterator grdItor = groundedMap[deAliasedEqConcat].begin(); for (; grdItor != groundedMap[deAliasedEqConcat].end(); grdItor++) { @@ -5859,8 +5861,8 @@ namespace smt { expr* strDeAlias = dealias_node(str, varAliasMap, concatAliasMap); expr* subStrDeAlias = dealias_node(subStr, varAliasMap, concatAliasMap); - get_grounded_concats(strDeAlias, varAliasMap, concatAliasMap, varConstMap, concatConstMap, varEqConcatMap, groundedMap); - get_grounded_concats(subStrDeAlias, varAliasMap, concatAliasMap, varConstMap, concatConstMap, varEqConcatMap, groundedMap); + get_grounded_concats(0, strDeAlias, varAliasMap, concatAliasMap, varConstMap, concatConstMap, varEqConcatMap, groundedMap); + get_grounded_concats(0, subStrDeAlias, varAliasMap, concatAliasMap, varConstMap, concatConstMap, varEqConcatMap, groundedMap); // debugging print_grounded_concat(strDeAlias, groundedMap); diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h index 9288bac7c..64ede71b5 100644 --- a/src/smt/theory_str.h +++ b/src/smt/theory_str.h @@ -495,10 +495,11 @@ protected: std::map & concatAliasMap, std::map & varConstMap, std::map & concatConstMap, std::map > & varEqConcatMap); expr * dealias_node(expr * node, std::map & varAliasMap, std::map & concatAliasMap); - void get_grounded_concats(expr* node, std::map & varAliasMap, - std::map & concatAliasMap, std::map & varConstMap, - std::map & concatConstMap, std::map > & varEqConcatMap, - std::map, std::set > > & groundedMap); + void get_grounded_concats(unsigned depth, + expr* node, std::map & varAliasMap, + std::map & concatAliasMap, std::map & varConstMap, + std::map & concatConstMap, std::map > & varEqConcatMap, + std::map, std::set > > & groundedMap); void print_grounded_concat(expr * node, std::map, std::set > > & groundedMap); void check_subsequence(expr* str, expr* strDeAlias, expr* subStr, expr* subStrDeAlias, expr* boolVar, std::map, std::set > > & groundedMap); From 73f7e301c3f60924a8d7e1518e714711eeb5f059 Mon Sep 17 00:00:00 2001 From: Murphy Berzish Date: Mon, 12 Mar 2018 17:09:55 -0400 Subject: [PATCH 038/109] preliminary refactoring to use obj_map --- src/smt/theory_str.cpp | 19 ++++++++++--------- src/smt/theory_str.h | 21 ++++++++++----------- 2 files changed, 20 insertions(+), 20 deletions(-) diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp index 3335370eb..90eb01fa8 100644 --- a/src/smt/theory_str.cpp +++ b/src/smt/theory_str.cpp @@ -4582,8 +4582,9 @@ namespace smt { std::pair key = std::make_pair(concat, unroll); expr_ref toAssert(mgr); + expr * _toAssert; - if (concat_eq_unroll_ast_map.find(key) == concat_eq_unroll_ast_map.end()) { + if (!concat_eq_unroll_ast_map.find(concat, unroll, _toAssert)) { expr_ref arg1(to_app(concat)->get_arg(0), mgr); expr_ref arg2(to_app(concat)->get_arg(1), mgr); expr_ref r1(to_app(unroll)->get_arg(0), mgr); @@ -4634,9 +4635,9 @@ namespace smt { toAssert = mgr.mk_and(opAnd1, opAnd2); m_trail.push_back(toAssert); - concat_eq_unroll_ast_map[key] = toAssert; + concat_eq_unroll_ast_map.insert(concat, unroll, toAssert); } else { - toAssert = concat_eq_unroll_ast_map[key]; + toAssert = _toAssert; } assert_axiom(toAssert); @@ -4920,7 +4921,7 @@ namespace smt { expr_ref_vector litems(m); - if (contain_pair_idx_map.find(varNode) != contain_pair_idx_map.end()) { + if (contain_pair_idx_map.contains(varNode)) { std::set >::iterator itor1 = contain_pair_idx_map[varNode].begin(); for (; itor1 != contain_pair_idx_map[varNode].end(); ++itor1) { expr * strAst = itor1->first; @@ -5057,7 +5058,7 @@ namespace smt { ast_manager & m = get_manager(); expr_ref_vector litems(m); - if (contain_pair_idx_map.find(varNode) != contain_pair_idx_map.end()) { + if (contain_pair_idx_map.contains(varNode)) { std::set >::iterator itor1 = contain_pair_idx_map[varNode].begin(); for (; itor1 != contain_pair_idx_map[varNode].end(); ++itor1) { expr * strAst = itor1->first; @@ -5125,7 +5126,7 @@ namespace smt { } bool theory_str::in_contain_idx_map(expr * n) { - return contain_pair_idx_map.find(n) != contain_pair_idx_map.end(); + return contain_pair_idx_map.contains(n); } void theory_str::check_contain_by_eq_nodes(expr * n1, expr * n2) { @@ -6456,7 +6457,7 @@ namespace smt { } else { expr_ref_vector::iterator itor = eqNodeSet.begin(); for (; itor != eqNodeSet.end(); itor++) { - if (regex_in_var_reg_str_map.find(*itor) != regex_in_var_reg_str_map.end()) { + if (regex_in_var_reg_str_map.contains(*itor)) { std::set::iterator strItor = regex_in_var_reg_str_map[*itor].begin(); for (; strItor != regex_in_var_reg_str_map[*itor].end(); strItor++) { zstring regStr = *strItor; @@ -6469,7 +6470,7 @@ namespace smt { expr * regexTerm = a_regexIn->get_arg(1); // TODO figure out regex NFA stuff - if (regex_nfa_cache.find(regexTerm) == regex_nfa_cache.end()) { + if (!regex_nfa_cache.contains(regexTerm)) { TRACE("str", tout << "regex_nfa_cache: cache miss" << std::endl;); regex_nfa_cache[regexTerm] = nfa(u, regexTerm); } else { @@ -9596,7 +9597,7 @@ namespace smt { if (low.is_neg()) { toAssert = m_autil.mk_ge(cntInUnr, mk_int(0)); } else { - if (unroll_var_map.find(unrFunc) == unroll_var_map.end()) { + if (!unroll_var_map.contains(unrFunc)) { expr_ref newVar1(mk_regex_rep_var(), mgr); expr_ref newVar2(mk_regex_rep_var(), mgr); diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h index 9288bac7c..5a249f5dc 100644 --- a/src/smt/theory_str.h +++ b/src/smt/theory_str.h @@ -312,30 +312,29 @@ protected: obj_hashtable input_var_in_len; obj_map fvar_len_count_map; - std::map > fvar_lenTester_map; + obj_map > fvar_lenTester_map; obj_map lenTester_fvar_map; - std::map > > > fvar_valueTester_map; - std::map valueTester_fvar_map; + obj_map > > > fvar_valueTester_map; + obj_map valueTester_fvar_map; - std::map val_range_map; + obj_map val_range_map; // This can't be an expr_ref_vector because the constructor is wrong, // we would need to modify the allocator so we pass in ast_manager - std::map, ptr_vector > > unroll_tries_map; - std::map unroll_var_map; - std::map, expr*> concat_eq_unroll_ast_map; + obj_map, ptr_vector > > unroll_tries_map; + obj_map unroll_var_map; + obj_pair_map concat_eq_unroll_ast_map; expr_ref_vector contains_map; theory_str_contain_pair_bool_map_t contain_pair_bool_map; - //obj_map > contain_pair_idx_map; - std::map > > contain_pair_idx_map; + obj_map > > contain_pair_idx_map; std::map, expr*> regex_in_bool_map; - std::map > regex_in_var_reg_str_map; + obj_map > regex_in_var_reg_str_map; - std::map regex_nfa_cache; // Regex term --> NFA + obj_map regex_nfa_cache; // Regex term --> NFA svector char_set; std::map charSetLookupTable; From b5471e7fe06a2b7a14ccbcdb4273221f54fa8353 Mon Sep 17 00:00:00 2001 From: Murphy Berzish Date: Mon, 12 Mar 2018 20:04:04 -0400 Subject: [PATCH 039/109] refactor: use c++11 for (part 1) --- src/smt/theory_str.cpp | 167 ++++++++++++++++++----------------------- 1 file changed, 72 insertions(+), 95 deletions(-) diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp index 90eb01fa8..139e25740 100644 --- a/src/smt/theory_str.cpp +++ b/src/smt/theory_str.cpp @@ -289,9 +289,8 @@ namespace smt { } static void cut_vars_map_copy(std::map & dest, std::map & src) { - std::map::iterator itor = src.begin(); - for (; itor != src.end(); itor++) { - dest[itor->first] = 1; + for (auto entry : src) { + dest[entry.first] = 1; } } @@ -306,9 +305,8 @@ namespace smt { return false; } - std::map::iterator itor = cut_var_map[n1].top()->vars.begin(); - for (; itor != cut_var_map[n1].top()->vars.end(); ++itor) { - if (cut_var_map[n2].top()->vars.find(itor->first) != cut_var_map[n2].top()->vars.end()) { + for (auto entry : cut_var_map[n1].top()->vars) { + if (cut_var_map[n2].top()->vars.find(entry.first) != cut_var_map[n2].top()->vars.end()) { return true; } } @@ -781,8 +779,8 @@ namespace smt { ptr_vector childrenVector; get_nodes_in_concat(concatAst, childrenVector); expr_ref_vector items(m); - for (unsigned int i = 0; i < childrenVector.size(); i++) { - items.push_back(mk_strlen(childrenVector.get(i))); + for (auto el : childrenVector) { + items.push_back(mk_strlen(el)); } expr_ref lenAssert(ctx.mk_eq_atom(concat_length, m_autil.mk_add(items.size(), items.c_ptr())), m); assert_axiom(lenAssert); @@ -802,32 +800,30 @@ namespace smt { context & ctx = get_context(); while (can_propagate()) { TRACE("str", tout << "propagating..." << std::endl;); - for (unsigned i = 0; i < m_basicstr_axiom_todo.size(); ++i) { - instantiate_basic_string_axioms(m_basicstr_axiom_todo[i]); + for (auto el : m_basicstr_axiom_todo) { + instantiate_basic_string_axioms(el); } m_basicstr_axiom_todo.reset(); TRACE("str", tout << "reset m_basicstr_axiom_todo" << std::endl;); - for (unsigned i = 0; i < m_str_eq_todo.size(); ++i) { - std::pair pair = m_str_eq_todo[i]; + for (auto pair : m_str_eq_todo) { enode * lhs = pair.first; enode * rhs = pair.second; handle_equality(lhs->get_owner(), rhs->get_owner()); } m_str_eq_todo.reset(); - for (unsigned i = 0; i < m_concat_axiom_todo.size(); ++i) { - instantiate_concat_axiom(m_concat_axiom_todo[i]); + for (auto el : m_concat_axiom_todo) { + instantiate_concat_axiom(el); } m_concat_axiom_todo.reset(); - for (unsigned i = 0; i < m_concat_eval_todo.size(); ++i) { - try_eval_concat(m_concat_eval_todo[i]); + for (auto el : m_concat_eval_todo) { + try_eval_concat(el); } m_concat_eval_todo.reset(); - for (unsigned i = 0; i < m_library_aware_axiom_todo.size(); ++i) { - enode * e = m_library_aware_axiom_todo[i]; + for (enode * e : m_library_aware_axiom_todo) { app * a = e->get_owner(); if (u.str.is_stoi(a)) { instantiate_axiom_str_to_int(e); @@ -856,10 +852,10 @@ namespace smt { } m_library_aware_axiom_todo.reset(); - for (unsigned i = 0; i < m_delayed_axiom_setup_terms.size(); ++i) { + for (auto el : m_delayed_axiom_setup_terms) { // I think this is okay - ctx.internalize(m_delayed_axiom_setup_terms[i].get(), false); - set_up_axioms(m_delayed_axiom_setup_terms[i].get()); + ctx.internalize(el, false); + set_up_axioms(el); } m_delayed_axiom_setup_terms.reset(); } @@ -2380,9 +2376,8 @@ namespace smt { } else { expr_ref_vector items(m); int pos = 0; - std::map::iterator itor = resolvedMap.begin(); - for (; itor != resolvedMap.end(); ++itor) { - items.push_back(ctx.mk_eq_atom(itor->first, itor->second)); + for (auto itor : resolvedMap) { + items.push_back(ctx.mk_eq_atom(itor.first, itor.second)); pos += 1; } expr_ref premise(mk_and(items), m); @@ -2558,8 +2553,7 @@ namespace smt { context & ctx = get_context(); // pull each literal out of the arrangement disjunction literal_vector ls; - for (unsigned i = 0; i < terms.size(); ++i) { - expr * e = terms.get(i); + for (expr * e : terms) { literal l = ctx.get_literal(e); ls.push_back(l); } @@ -2572,9 +2566,8 @@ namespace smt { if (cut_var_map.contains(node)) { if (!cut_var_map[node].empty()) { xout << "[" << cut_var_map[node].top()->level << "] "; - std::map::iterator itor = cut_var_map[node].top()->vars.begin(); - for (; itor != cut_var_map[node].top()->vars.end(); ++itor) { - xout << mk_pp(itor->first, m) << ", "; + for (auto entry : cut_var_map[node].top()->vars) { + xout << mk_pp(entry.first, m) << ", "; } xout << std::endl; } @@ -4498,8 +4491,7 @@ namespace smt { } } - for (std::list::iterator itor = overlapLen.begin(); itor != overlapLen.end(); itor++) { - unsigned int overLen = *itor; + for (unsigned int overLen : overlapLen) { zstring prefix = str1Value.extract(0, str1Len - overLen); zstring suffix = str2Value.extract(overLen, str2Len - overLen); @@ -4580,7 +4572,6 @@ namespace smt { TRACE("str", tout << "concat = " << mk_pp(concat, mgr) << ", unroll = " << mk_pp(unroll, mgr) << std::endl;); - std::pair key = std::make_pair(concat, unroll); expr_ref toAssert(mgr); expr * _toAssert; @@ -4922,10 +4913,9 @@ namespace smt { expr_ref_vector litems(m); if (contain_pair_idx_map.contains(varNode)) { - std::set >::iterator itor1 = contain_pair_idx_map[varNode].begin(); - for (; itor1 != contain_pair_idx_map[varNode].end(); ++itor1) { - expr * strAst = itor1->first; - expr * substrAst = itor1->second; + for (auto entry : contain_pair_idx_map[varNode]) { + expr * strAst = entry.first; + expr * substrAst = entry.second; expr * boolVar = nullptr; if (!contain_pair_bool_map.find(strAst, substrAst, boolVar)) { @@ -4983,23 +4973,19 @@ namespace smt { // collect eqc concat std::set eqcConcats; get_concats_in_eqc(substrAst, eqcConcats); - for (std::set::iterator concatItor = eqcConcats.begin(); - concatItor != eqcConcats.end(); concatItor++) { + for (expr * aConcat : eqcConcats) { expr_ref_vector constList(m); bool counterEgFound = false; - // get constant strings in concat - expr * aConcat = *concatItor; get_const_str_asts_in_node(aConcat, constList); - for (expr_ref_vector::iterator cstItor = constList.begin(); - cstItor != constList.end(); cstItor++) { + //for (expr_ref_vector::iterator cstItor = constList.begin(); cstItor != constList.end(); cstItor++) { + for (auto cst : constList) { zstring pieceStr; - u.str.is_string(*cstItor, pieceStr); + u.str.is_string(cst, pieceStr); if (!strConst.contains(pieceStr)) { counterEgFound = true; if (aConcat != substrAst) { litems.push_back(ctx.mk_eq_atom(substrAst, aConcat)); } - //implyR = Z3_mk_eq(ctx, boolVar, Z3_mk_false(ctx)); implyR = mk_not(m, boolVar); break; } @@ -5059,10 +5045,9 @@ namespace smt { expr_ref_vector litems(m); if (contain_pair_idx_map.contains(varNode)) { - std::set >::iterator itor1 = contain_pair_idx_map[varNode].begin(); - for (; itor1 != contain_pair_idx_map[varNode].end(); ++itor1) { - expr * strAst = itor1->first; - expr * substrAst = itor1->second; + for (auto entry : contain_pair_idx_map[varNode]) { + expr * strAst = entry.first; + expr * substrAst = entry.second; expr * boolVar = nullptr; if (!contain_pair_bool_map.find(strAst, substrAst, boolVar)) { @@ -5091,17 +5076,16 @@ namespace smt { zstring strConst; u.str.is_string(strValue, strConst); // iterate eqc (also eqc-to-be) of substr - for (expr_ref_vector::iterator itAst = willEqClass.begin(); itAst != willEqClass.end(); itAst++) { + for (auto itAst : willEqClass) { bool counterEgFound = false; - if (u.str.is_concat(to_app(*itAst))) { + if (u.str.is_concat(to_app(itAst))) { expr_ref_vector constList(m); // get constant strings in concat - app * aConcat = to_app(*itAst); + app * aConcat = to_app(itAst); get_const_str_asts_in_node(aConcat, constList); - for (expr_ref_vector::iterator cstItor = constList.begin(); - cstItor != constList.end(); cstItor++) { + for (auto cst : constList) { zstring pieceStr; - u.str.is_string(*cstItor, pieceStr); + u.str.is_string(cst, pieceStr); if (!strConst.contains(pieceStr)) { TRACE("str", tout << "Inconsistency found!" << std::endl;); counterEgFound = true; @@ -5134,12 +5118,13 @@ namespace smt { ast_manager & m = get_manager(); if (in_contain_idx_map(n1) && in_contain_idx_map(n2)) { - std::set >::iterator keysItor1 = contain_pair_idx_map[n1].begin(); - std::set >::iterator keysItor2; + //std::set >::iterator keysItor1 = contain_pair_idx_map[n1].begin(); + //std::set >::iterator keysItor2; - for (; keysItor1 != contain_pair_idx_map[n1].end(); keysItor1++) { + //for (; keysItor1 != contain_pair_idx_map[n1].end(); keysItor1++) { + for (auto key1 : contain_pair_idx_map[n1]) { // keysItor1 is on set {<.., n1>, ..., , ...} - std::pair key1 = *keysItor1; + //std::pair key1 = *keysItor1; if (key1.first == n1 && key1.second == n2) { expr_ref implyL(m); expr_ref implyR(contain_pair_bool_map[key1], m); @@ -5151,10 +5136,10 @@ namespace smt { } } - for (keysItor2 = contain_pair_idx_map[n2].begin(); - keysItor2 != contain_pair_idx_map[n2].end(); keysItor2++) { + //for (keysItor2 = contain_pair_idx_map[n2].begin(); keysItor2 != contain_pair_idx_map[n2].end(); keysItor2++) { + for (auto key2 : contain_pair_idx_map[n2]) { // keysItor2 is on set {<.., n2>, ..., , ...} - std::pair key2 = *keysItor2; + //std::pair key2 = *keysItor2; // skip if the pair is eq if (key1 == key2) { continue; @@ -5248,10 +5233,12 @@ namespace smt { // * key1.first = key2.first // check eqc(key1.second) and eqc(key2.second) // ----------------------------------------------------------- - expr_ref_vector::iterator eqItorSub1 = subAst1Eqc.begin(); - for (; eqItorSub1 != subAst1Eqc.end(); eqItorSub1++) { - expr_ref_vector::iterator eqItorSub2 = subAst2Eqc.begin(); - for (; eqItorSub2 != subAst2Eqc.end(); eqItorSub2++) { + //expr_ref_vector::iterator eqItorSub1 = subAst1Eqc.begin(); + //for (; eqItorSub1 != subAst1Eqc.end(); eqItorSub1++) { + for (auto eqSubVar1 : subAst1Eqc) { + //expr_ref_vector::iterator eqItorSub2 = subAst2Eqc.begin(); + //for (; eqItorSub2 != subAst2Eqc.end(); eqItorSub2++) { + for (auto eqSubVar2 : subAst2Eqc) { // ------------ // key1.first = key2.first /\ containPairBoolMap[] // ==> (containPairBoolMap[key1] --> containPairBoolMap[key2]) @@ -5261,11 +5248,11 @@ namespace smt { if (n1 != n2) { litems3.push_back(ctx.mk_eq_atom(n1, n2)); } - expr * eqSubVar1 = *eqItorSub1; + if (eqSubVar1 != subAst1) { litems3.push_back(ctx.mk_eq_atom(subAst1, eqSubVar1)); } - expr * eqSubVar2 = *eqItorSub2; + if (eqSubVar2 != subAst2) { litems3.push_back(ctx.mk_eq_atom(subAst2, eqSubVar2)); } @@ -5286,11 +5273,11 @@ namespace smt { if (n1 != n2) { litems4.push_back(ctx.mk_eq_atom(n1, n2)); } - expr * eqSubVar1 = *eqItorSub1; + if (eqSubVar1 != subAst1) { litems4.push_back(ctx.mk_eq_atom(subAst1, eqSubVar1)); } - expr * eqSubVar2 = *eqItorSub2; + if (eqSubVar2 != subAst2) { litems4.push_back(ctx.mk_eq_atom(subAst2, eqSubVar2)); } @@ -5398,20 +5385,18 @@ namespace smt { // * key1.second = key2.second // check eqc(key1.first) and eqc(key2.first) // ----------------------------------------------------------- - expr_ref_vector::iterator eqItorStr1 = str1Eqc.begin(); - for (; eqItorStr1 != str1Eqc.end(); eqItorStr1++) { - expr_ref_vector::iterator eqItorStr2 = str2Eqc.begin(); - for (; eqItorStr2 != str2Eqc.end(); eqItorStr2++) { + for (auto eqStrVar1 : str1Eqc) { + for (auto eqStrVar2 : str2Eqc) { { expr_ref_vector litems3(m); if (n1 != n2) { litems3.push_back(ctx.mk_eq_atom(n1, n2)); } - expr * eqStrVar1 = *eqItorStr1; + if (eqStrVar1 != str1) { litems3.push_back(ctx.mk_eq_atom(str1, eqStrVar1)); } - expr * eqStrVar2 = *eqItorStr2; + if (eqStrVar2 != str2) { litems3.push_back(ctx.mk_eq_atom(str2, eqStrVar2)); } @@ -5434,11 +5419,9 @@ namespace smt { if (n1 != n2) { litems4.push_back(ctx.mk_eq_atom(n1, n2)); } - expr * eqStrVar1 = *eqItorStr1; if (eqStrVar1 != str1) { litems4.push_back(ctx.mk_eq_atom(str1, eqStrVar1)); } - expr *eqStrVar2 = *eqItorStr2; if (eqStrVar2 != str2) { litems4.push_back(ctx.mk_eq_atom(str2, eqStrVar2)); } @@ -5484,8 +5467,7 @@ namespace smt { expr * constStrAst = (constStrAst_1 != nullptr) ? constStrAst_1 : constStrAst_2; TRACE("str", tout << "eqc of n1 is {"; - for (expr_ref_vector::iterator it = willEqClass.begin(); it != willEqClass.end(); ++it) { - expr * el = *it; + for (expr * el : willEqClass) { tout << " " << mk_pp(el, m); } tout << std::endl; @@ -5498,12 +5480,11 @@ namespace smt { // step 1: we may have constant values for Contains checks now if (constStrAst != nullptr) { - expr_ref_vector::iterator itAst = willEqClass.begin(); - for (; itAst != willEqClass.end(); itAst++) { - if (*itAst == constStrAst) { + for (auto a : willEqClass) { + if (a == constStrAst) { continue; } - check_contain_by_eqc_val(*itAst, constStrAst); + check_contain_by_eqc_val(a, constStrAst); } } else { // no concrete value to be put in eqc, solely based on context @@ -5515,9 +5496,8 @@ namespace smt { // * "EQC(M) U EQC(concat(..., "jio", ...))" as substr and // * If strAst registered has an eqc constant in the context // ------------------------------------------------------------- - expr_ref_vector::iterator itAst = willEqClass.begin(); - for (; itAst != willEqClass.end(); ++itAst) { - check_contain_by_substr(*itAst, willEqClass); + for (auto a : willEqClass) { + check_contain_by_substr(a, willEqClass); } } @@ -5534,12 +5514,8 @@ namespace smt { // (9) containPairBoolMap[] /\ m = n ==> (b1 -> b2) // ------------------------------------------ - expr_ref_vector::iterator varItor1 = willEqClass.begin(); - for (; varItor1 != willEqClass.end(); ++varItor1) { - expr * varAst1 = *varItor1; - expr_ref_vector::iterator varItor2 = varItor1; - for (; varItor2 != willEqClass.end(); ++varItor2) { - expr * varAst2 = *varItor2; + for (auto varAst1 : willEqClass) { + for (auto varAst2 : willEqClass) { check_contain_by_eq_nodes(varAst1, varAst2); } } @@ -7947,11 +7923,12 @@ namespace smt { // Step 1: get variables / concat AST appearing in the context // the thing we iterate over should just be variable_set - internal_variable_set // so we avoid computing the set difference (but this might be slower) - for(obj_hashtable::iterator it = variable_set.begin(); it != variable_set.end(); ++it) { - expr* var = *it; + for (expr* var : variable_set) { + //for(obj_hashtable::iterator it = variable_set.begin(); it != variable_set.end(); ++it) { + //expr* var = *it; if (internal_variable_set.find(var) == internal_variable_set.end()) { TRACE("str", tout << "new variable: " << mk_pp(var, m) << std::endl;); - strVarMap[*it] = 1; + strVarMap[var] = 1; } } classify_ast_by_type_in_positive_context(strVarMap, concatMap, unrollMap); From 5f7bd993de4b83d95e22921d424a7902d0480f83 Mon Sep 17 00:00:00 2001 From: Pierre Pronchery Date: Tue, 13 Mar 2018 21:37:22 +0100 Subject: [PATCH 040/109] Add support for NetBSD Originally from David Holland . --- CMakeLists.txt | 3 +++ scripts/mk_util.py | 17 ++++++++++++++++- src/util/scoped_timer.cpp | 18 +++++++++--------- src/util/stopwatch.h | 5 +++++ 4 files changed, 33 insertions(+), 10 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 4d8c15493..c11c272be 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -240,6 +240,9 @@ elseif ("${CMAKE_SYSTEM_NAME}" STREQUAL "Darwin") elseif ("${CMAKE_SYSTEM_NAME}" MATCHES "FreeBSD") message(STATUS "Platform: FreeBSD") list(APPEND Z3_COMPONENT_CXX_DEFINES "-D_FREEBSD_") +elseif ("${CMAKE_SYSTEM_NAME}" MATCHES "NetBSD") + message(STATUS "Platform: NetBSD") + list(APPEND Z3_COMPONENT_CXX_DEFINES "-D_NetBSD_") elseif ("${CMAKE_SYSTEM_NAME}" MATCHES "OpenBSD") message(STATUS "Platform: OpenBSD") list(APPEND Z3_COMPONENT_CXX_DEFINES "-D_OPENBSD_") diff --git a/scripts/mk_util.py b/scripts/mk_util.py index fecc207d8..99de61703 100644 --- a/scripts/mk_util.py +++ b/scripts/mk_util.py @@ -69,6 +69,7 @@ IS_WINDOWS=False IS_LINUX=False IS_OSX=False IS_FREEBSD=False +IS_NETBSD=False IS_OPENBSD=False IS_CYGWIN=False IS_CYGWIN_MINGW=False @@ -141,6 +142,9 @@ def is_linux(): def is_freebsd(): return IS_FREEBSD +def is_netbsd(): + return IS_NETBSD + def is_openbsd(): return IS_OPENBSD @@ -604,6 +608,8 @@ elif os.name == 'posix': IS_LINUX=True elif os.uname()[0] == 'FreeBSD': IS_FREEBSD=True + elif os.uname()[0] == 'NetBSD': + IS_NETBSD=True elif os.uname()[0] == 'OpenBSD': IS_OPENBSD=True elif os.uname()[0][:6] == 'CYGWIN': @@ -1245,7 +1251,7 @@ def get_so_ext(): sysname = os.uname()[0] if sysname == 'Darwin': return 'dylib' - elif sysname == 'Linux' or sysname == 'FreeBSD' or sysname == 'OpenBSD': + elif sysname == 'Linux' or sysname == 'FreeBSD' or sysname == 'NetBSD' or sysname == 'OpenBSD': return 'so' elif sysname == 'CYGWIN' or sysname.startswith('MSYS_NT') or sysname.startswith('MINGW'): return 'dll' @@ -1795,6 +1801,8 @@ class JavaDLLComponent(Component): t = t.replace('PLATFORM', 'linux') elif IS_FREEBSD: t = t.replace('PLATFORM', 'freebsd') + elif IS_NETBSD: + t = t.replace('PLATFORM', 'netbsd') elif IS_OPENBSD: t = t.replace('PLATFORM', 'openbsd') elif IS_CYGWIN: @@ -2504,6 +2512,13 @@ def mk_config(): LDFLAGS = '%s -lrt' % LDFLAGS SLIBFLAGS = '-shared' SLIBEXTRAFLAGS = '%s -lrt' % SLIBEXTRAFLAGS + elif sysname == 'NetBSD': + CXXFLAGS = '%s -D_NETBSD_' % CXXFLAGS + OS_DEFINES = '-D_NETBSD_' + SO_EXT = '.so' + LDFLAGS = '%s -lrt' % LDFLAGS + SLIBFLAGS = '-shared' + SLIBEXTRAFLAGS = '%s -lrt' % SLIBEXTRAFLAGS elif sysname == 'OpenBSD': CXXFLAGS = '%s -D_OPENBSD_' % CXXFLAGS OS_DEFINES = '-D_OPENBSD_' diff --git a/src/util/scoped_timer.cpp b/src/util/scoped_timer.cpp index 1ecca8ffe..a2a0cc269 100644 --- a/src/util/scoped_timer.cpp +++ b/src/util/scoped_timer.cpp @@ -33,8 +33,8 @@ Revision History: #include #include #include -#elif defined(_LINUX_) || defined(_FREEBSD_) -// Linux +#elif defined(_LINUX_) || defined(_FREEBSD_) || defined(_NetBSD_) +// Linux & FreeBSD & NetBSD #include #include #include @@ -66,8 +66,8 @@ struct scoped_timer::imp { pthread_mutex_t m_mutex; pthread_cond_t m_condition_var; struct timespec m_end_time; -#elif defined(_LINUX_) || defined(_FREEBSD_) - // Linux & FreeBSD +#elif defined(_LINUX_) || defined(_FREEBSD_) || defined(_NETBSD_) + // Linux & FreeBSD & NetBSD pthread_t m_thread_id; pthread_mutex_t m_mutex; pthread_cond_t m_cond; @@ -104,7 +104,7 @@ struct scoped_timer::imp { return st; } -#elif defined(_LINUX_) || defined(_FREEBSD_) +#elif defined(_LINUX_) || defined(_FREEBSD_) || defined(_NETBSD_) static void* thread_func(void *arg) { scoped_timer::imp *st = static_cast(arg); @@ -175,8 +175,8 @@ struct scoped_timer::imp { if (pthread_create(&m_thread_id, &m_attributes, &thread_func, this) != 0) throw default_exception("failed to start timer thread"); -#elif defined(_LINUX_) || defined(_FREEBSD_) - // Linux & FreeBSD +#elif defined(_LINUX_) || defined(_FREEBSD_) || defined(_NETBSD_) + // Linux & FreeBSD & NetBSD m_ms = ms; m_initialized = false; m_signal_sent = false; @@ -216,8 +216,8 @@ struct scoped_timer::imp { throw default_exception("failed to destroy pthread condition variable"); if (pthread_attr_destroy(&m_attributes) != 0) throw default_exception("failed to destroy pthread attributes object"); -#elif defined(_LINUX_) || defined(_FREEBSD_) - // Linux & FreeBSD +#elif defined(_LINUX_) || defined(_FREEBSD_) || defined(_NETBSD_) + // Linux & FreeBSD & NetBSD bool init = false; // spin until timer thread has been created diff --git a/src/util/stopwatch.h b/src/util/stopwatch.h index 9ba707af0..83e03a2f7 100644 --- a/src/util/stopwatch.h +++ b/src/util/stopwatch.h @@ -134,6 +134,11 @@ public: #include +#ifndef CLOCK_PROCESS_CPUTIME_ID +/* BSD */ +# define CLOCK_PROCESS_CPUTIME_ID CLOCK_MONOTONIC +#endif + class stopwatch { unsigned long long m_time; // elapsed time in ns bool m_running; From 2b2aee3c18bee27bee94908d650596e7e5424b64 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Wed, 14 Mar 2018 07:29:26 -0700 Subject: [PATCH 041/109] remove unused operators #1530 Signed-off-by: Nikolaj Bjorner --- src/api/ml/z3.ml | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/api/ml/z3.ml b/src/api/ml/z3.ml index 120b0ddfd..5766c79f9 100644 --- a/src/api/ml/z3.ml +++ b/src/api/ml/z3.ml @@ -1402,7 +1402,6 @@ struct let is_rewrite (x:expr) = (AST.is_app x) && (FuncDecl.get_decl_kind (Expr.get_func_decl x) = OP_PR_REWRITE) let is_rewrite_star (x:expr) = (AST.is_app x) && (FuncDecl.get_decl_kind (Expr.get_func_decl x) = OP_PR_REWRITE_STAR) let is_pull_quant (x:expr) = (AST.is_app x) && (FuncDecl.get_decl_kind (Expr.get_func_decl x) = OP_PR_PULL_QUANT) - let is_pull_quant_star (x:expr) = (AST.is_app x) && (FuncDecl.get_decl_kind (Expr.get_func_decl x) = OP_PR_PULL_QUANT_STAR) let is_push_quant (x:expr) = (AST.is_app x) && (FuncDecl.get_decl_kind (Expr.get_func_decl x) = OP_PR_PUSH_QUANT) let is_elim_unused_vars (x:expr) = (AST.is_app x) && (FuncDecl.get_decl_kind (Expr.get_func_decl x) = OP_PR_ELIM_UNUSED_VARS) let is_der (x:expr) = (AST.is_app x) && (FuncDecl.get_decl_kind (Expr.get_func_decl x) = OP_PR_DER) @@ -1419,8 +1418,6 @@ struct let is_iff_oeq (x:expr) = (AST.is_app x) && (FuncDecl.get_decl_kind (Expr.get_func_decl x) = OP_PR_IFF_OEQ) let is_nnf_pos (x:expr) = (AST.is_app x) && (FuncDecl.get_decl_kind (Expr.get_func_decl x) = OP_PR_NNF_POS) let is_nnf_neg (x:expr) = (AST.is_app x) && (FuncDecl.get_decl_kind (Expr.get_func_decl x) = OP_PR_NNF_NEG) - let is_nnf_star (x:expr) = (AST.is_app x) && (FuncDecl.get_decl_kind (Expr.get_func_decl x) = OP_PR_NNF_STAR) - let is_cnf_star (x:expr) = (AST.is_app x) && (FuncDecl.get_decl_kind (Expr.get_func_decl x) = OP_PR_CNF_STAR) let is_skolemize (x:expr) = (AST.is_app x) && (FuncDecl.get_decl_kind (Expr.get_func_decl x) = OP_PR_SKOLEMIZE) let is_modus_ponens_oeq (x:expr) = (AST.is_app x) && (FuncDecl.get_decl_kind (Expr.get_func_decl x) = OP_PR_MODUS_PONENS_OEQ) let is_theory_lemma (x:expr) = (AST.is_app x) && (FuncDecl.get_decl_kind (Expr.get_func_decl x) = OP_PR_TH_LEMMA) From 5e2723a16ebf1603dc5a048ef98528e40d75d682 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Wed, 14 Mar 2018 09:04:08 -0700 Subject: [PATCH 042/109] java Signed-off-by: Nikolaj Bjorner --- src/api/java/Context.java | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/src/api/java/Context.java b/src/api/java/Context.java index ba96209b3..8720fd975 100644 --- a/src/api/java/Context.java +++ b/src/api/java/Context.java @@ -2543,14 +2543,15 @@ public class Context implements AutoCloseable { /** * Parse the given string using the SMT-LIB2 parser. * - * @return A conjunction of assertions in the scope (up to push/pop) at the - * end of the string. + * @return A conjunction of assertions. + * + * If the string contains push/pop commands, the + * set of assertions returned are the ones in the + * last scope level. **/ public BoolExpr parseSMTLIB2String(String str, Symbol[] sortNames, - Sort[] sorts, Symbol[] declNames, FuncDecl[] decls) - + Sort[] sorts, Symbol[] declNames, FuncDecl[] decls) { - int csn = Symbol.arrayLength(sortNames); int cs = Sort.arrayLength(sorts); int cdn = Symbol.arrayLength(declNames); From 46048d51502c749e8a230e9a43e1afdeb439d2dd Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Wed, 14 Mar 2018 12:15:13 -0700 Subject: [PATCH 043/109] change lemma display utility to use updated pretty printer Signed-off-by: Nikolaj Bjorner --- src/smt/smt_context_pp.cpp | 52 ++++++++++++++++++++++---------------- 1 file changed, 30 insertions(+), 22 deletions(-) diff --git a/src/smt/smt_context_pp.cpp b/src/smt/smt_context_pp.cpp index f5ba52128..e883e0a09 100644 --- a/src/smt/smt_context_pp.cpp +++ b/src/smt/smt_context_pp.cpp @@ -19,7 +19,7 @@ Revision History: #include "smt/smt_context.h" #include "ast/ast_ll_pp.h" #include "ast/ast_pp.h" -#include "ast/ast_smt_pp.h" +#include "ast/ast_pp_util.h" #include "util/stats.h" namespace smt { @@ -413,19 +413,23 @@ namespace smt { } void context::display_lemma_as_smt_problem(std::ostream & out, unsigned num_antecedents, literal const * antecedents, literal consequent, symbol const& logic) const { - ast_smt_pp pp(m_manager); - pp.set_benchmark_name("lemma"); - pp.set_status("unsat"); - pp.set_logic(logic); + ast_pp_util visitor(m_manager); + expr_ref_vector fmls(m_manager); + visitor.collect(fmls); + expr_ref n(m_manager); for (unsigned i = 0; i < num_antecedents; i++) { literal l = antecedents[i]; - expr_ref n(m_manager); literal2expr(l, n); - pp.add_assumption(n); + fmls.push_back(n); } - expr_ref n(m_manager); - literal2expr(~consequent, n); - pp.display_smt2(out, n); + if (consequent != false_literal) { + literal2expr(~consequent, n); + fmls.push_back(n); + } + if (logic != symbol::null) out << "(set-logic " << logic << ")\n"; + visitor.collect(fmls); + visitor.display_decls(out); + visitor.display_asserts(out, fmls, true); } static unsigned g_lemma_id = 0; @@ -448,25 +452,29 @@ namespace smt { void context::display_lemma_as_smt_problem(std::ostream & out, unsigned num_antecedents, literal const * antecedents, unsigned num_eq_antecedents, enode_pair const * eq_antecedents, literal consequent, symbol const& logic) const { - ast_smt_pp pp(m_manager); - pp.set_benchmark_name("lemma"); - pp.set_status("unsat"); - pp.set_logic(logic); + ast_pp_util visitor(m_manager); + expr_ref_vector fmls(m_manager); + visitor.collect(fmls); + expr_ref n(m_manager); for (unsigned i = 0; i < num_antecedents; i++) { literal l = antecedents[i]; - expr_ref n(m_manager); literal2expr(l, n); - pp.add_assumption(n); + fmls.push_back(n); } for (unsigned i = 0; i < num_eq_antecedents; i++) { enode_pair const & p = eq_antecedents[i]; - expr_ref eq(m_manager); - eq = m_manager.mk_eq(p.first->get_owner(), p.second->get_owner()); - pp.add_assumption(eq); + n = m_manager.mk_eq(p.first->get_owner(), p.second->get_owner()); + fmls.push_back(n); } - expr_ref n(m_manager); - literal2expr(~consequent, n); - pp.display_smt2(out, n); + if (consequent != false_literal) { + literal2expr(~consequent, n); + fmls.push_back(n); + } + + if (logic != symbol::null) out << "(set-logic " << logic << ")\n"; + visitor.collect(fmls); + visitor.display_decls(out); + visitor.display_asserts(out, fmls, true); } void context::display_lemma_as_smt_problem(unsigned num_antecedents, literal const * antecedents, From b1f05d8271e1773bb560c58daa2bf3180dacb419 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Wed, 14 Mar 2018 18:14:29 -0700 Subject: [PATCH 044/109] fix #1539 Signed-off-by: Nikolaj Bjorner --- src/api/ml/z3.mli | 23 ----------------------- 1 file changed, 23 deletions(-) diff --git a/src/api/ml/z3.mli b/src/api/ml/z3.mli index 20a1e9c10..14d2ceac4 100644 --- a/src/api/ml/z3.mli +++ b/src/api/ml/z3.mli @@ -2458,13 +2458,6 @@ sig A proof for (iff (f (forall (x) q(x)) r) (forall (x) (f (q x) r))). This proof object has no antecedents. *) val is_pull_quant : Expr.expr -> bool - (** Indicates whether the term is a proof for pulling quantifiers out. - - A proof for (iff P Q) where Q is in prenex normal form. - This proof object is only used if the parameter PROOF_MODE is 1. - This proof object has no antecedents *) - val is_pull_quant_star : Expr.expr -> bool - (** Indicates whether the term is a proof for pushing quantifiers in. A proof for: @@ -2658,22 +2651,6 @@ sig (and (or r_1 r_2) (or r_1' r_2'))) *) val is_nnf_neg : Expr.expr -> bool - (** Indicates whether the term is a proof for (~ P Q) here Q is in negation normal form. - - A proof for (~ P Q) where Q is in negation normal form. - - This proof object is only used if the parameter PROOF_MODE is 1. - - This proof object may have n antecedents. Each antecedent is a PR_DEF_INTRO. *) - val is_nnf_star : Expr.expr -> bool - - (** Indicates whether the term is a proof for (~ P Q) where Q is in conjunctive normal form. - - A proof for (~ P Q) where Q is in conjunctive normal form. - This proof object is only used if the parameter PROOF_MODE is 1. - This proof object may have n antecedents. Each antecedent is a PR_DEF_INTRO. *) - val is_cnf_star : Expr.expr -> bool - (** Indicates whether the term is a proof for a Skolemization step Proof for: From e4cab7bc834b81c8f4d0dcf3fd62668f61e916a0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Filipe=20Gon=C3=A7alves?= Date: Fri, 16 Mar 2018 22:04:39 +1000 Subject: [PATCH 045/109] Fix #1540 Remove extraneous function Remove extra __deepcopy__ function definition that shadows working implementation. --- src/api/python/z3/z3.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/api/python/z3/z3.py b/src/api/python/z3/z3.py index e68d7280d..d4ff556fe 100644 --- a/src/api/python/z3/z3.py +++ b/src/api/python/z3/z3.py @@ -368,9 +368,6 @@ class AstRef(Z3PPObject): def __copy__(self): return self.translate(self.ctx) - def __deepcopy__(self): - return self.translate(self.ctx) - def hash(self): """Return a hashcode for the `self`. From 0a0b7a9635d416d117b488639666d25d6b5491be Mon Sep 17 00:00:00 2001 From: Bruce Mitchener Date: Fri, 16 Mar 2018 20:56:06 +0700 Subject: [PATCH 046/109] Fix minor issues in docs. --- src/api/z3_algebraic.h | 2 +- src/api/z3_api.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/api/z3_algebraic.h b/src/api/z3_algebraic.h index faa41bfea..49c61afef 100644 --- a/src/api/z3_algebraic.h +++ b/src/api/z3_algebraic.h @@ -31,7 +31,7 @@ extern "C" { /** @name Algebraic Numbers */ /*@{*/ /** - \brief Return Z3_TRUE if \c can be used as value in the Z3 real algebraic + \brief Return Z3_TRUE if \c a can be used as value in the Z3 real algebraic number package. def_API('Z3_algebraic_is_value', BOOL, (_in(CONTEXT), _in(AST))) diff --git a/src/api/z3_api.h b/src/api/z3_api.h index 88d6aa1cf..87bb4d818 100644 --- a/src/api/z3_api.h +++ b/src/api/z3_api.h @@ -4350,7 +4350,7 @@ extern "C" { Z3_bool Z3_API Z3_is_numeral_ast(Z3_context c, Z3_ast a); /** - \brief Return true if the give AST is a real algebraic number. + \brief Return true if the given AST is a real algebraic number. def_API('Z3_is_algebraic_number', BOOL, (_in(CONTEXT), _in(AST))) */ From 86d3bbe6cb8815a20bee5ee29caff12dac9f5202 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Fri, 16 Mar 2018 07:46:27 -0700 Subject: [PATCH 047/109] added TODO markers in theory_str.h for moving to obj_map, remove include of stdbool for now Signed-off-by: Nikolaj Bjorner --- src/api/z3.h | 1 - src/smt/smt_context_pp.cpp | 50 ++++++++++++----------------------- src/smt/theory_str.cpp | 17 +++++------- src/smt/theory_str.h | 34 ++++++++---------------- src/util/obj_pair_hashtable.h | 13 +++++++++ 5 files changed, 48 insertions(+), 67 deletions(-) diff --git a/src/api/z3.h b/src/api/z3.h index b29f1d6ba..e08b0c073 100644 --- a/src/api/z3.h +++ b/src/api/z3.h @@ -22,7 +22,6 @@ Notes: #define Z3_H_ #include -#include #include "z3_macros.h" #include "z3_api.h" #include "z3_ast_containers.h" diff --git a/src/smt/smt_context_pp.cpp b/src/smt/smt_context_pp.cpp index e883e0a09..f072a1d13 100644 --- a/src/smt/smt_context_pp.cpp +++ b/src/smt/smt_context_pp.cpp @@ -43,11 +43,10 @@ namespace smt { return out << "RESOURCE_LIMIT"; case THEORY: if (!m_incomplete_theories.empty()) { - ptr_vector::const_iterator it = m_incomplete_theories.begin(); - ptr_vector::const_iterator end = m_incomplete_theories.end(); - for (bool first = true; it != end; ++it) { + bool first = true; + for (theory* th : m_incomplete_theories) { if (first) first = false; else out << " "; - out << (*it)->get_name(); + out << th->get_name(); } } else { @@ -173,12 +172,10 @@ namespace smt { void context::display_binary_clauses(std::ostream & out) const { bool first = true; - vector::const_iterator it = m_watches.begin(); - vector::const_iterator end = m_watches.end(); - for (unsigned l_idx = 0; it != end; ++it, ++l_idx) { - literal l1 = to_literal(l_idx); + unsigned l_idx = 0; + for (watch_list const& wl : m_watches) { + literal l1 = to_literal(l_idx++); literal neg_l1 = ~l1; - watch_list const & wl = *it; literal const * it2 = wl.begin_literals(); literal const * end2 = wl.end_literals(); for (; it2 != end2; ++it2) { @@ -291,10 +288,7 @@ namespace smt { } void context::display_theories(std::ostream & out) const { - ptr_vector::const_iterator it = m_theory_set.begin(); - ptr_vector::const_iterator end = m_theory_set.end(); - for (; it != end; ++it) { - theory * th = *it; + for (theory* th : m_theory_set) { th->display(out); } } @@ -393,10 +387,8 @@ namespace smt { #endif m_qmanager->collect_statistics(st); m_asserted_formulas.collect_statistics(st); - ptr_vector::const_iterator it = m_theory_set.begin(); - ptr_vector::const_iterator end = m_theory_set.end(); - for (; it != end; ++it) { - (*it)->collect_statistics(st); + for (theory* th : m_theory_set) { + th->collect_statistics(st); } } @@ -498,10 +490,7 @@ namespace smt { */ void context::display_normalized_enodes(std::ostream & out) const { out << "normalized enodes:\n"; - ptr_vector::const_iterator it = m_enodes.begin(); - ptr_vector::const_iterator end = m_enodes.end(); - for (; it != end; ++it) { - enode * n = *it; + for (enode * n : m_enodes) { out << "#"; out.width(5); out << std::left << n->get_owner_id() << " #"; @@ -532,28 +521,23 @@ namespace smt { } void context::display_enodes_lbls(std::ostream & out) const { - ptr_vector::const_iterator it = m_enodes.begin(); - ptr_vector::const_iterator end = m_enodes.end(); - for (; it != end; ++it) { - enode * n = *it; + for (enode* n : m_enodes) { n->display_lbls(out); } } void context::display_decl2enodes(std::ostream & out) const { out << "decl2enodes:\n"; - vector::const_iterator it1 = m_decl2enodes.begin(); - vector::const_iterator end1 = m_decl2enodes.end(); - for (unsigned id = 0; it1 != end1; ++it1, ++id) { - enode_vector const & v = *it1; + unsigned id = 0; + for (enode_vector const& v : m_decl2enodes) { if (!v.empty()) { out << "id " << id << " ->"; - enode_vector::const_iterator it2 = v.begin(); - enode_vector::const_iterator end2 = v.end(); - for (; it2 != end2; ++it2) - out << " #" << (*it2)->get_owner_id(); + for (enode* n : v) { + out << " #" << n->get_owner_id(); + } out << "\n"; } + ++id; } } diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp index 0016b8f36..30092097a 100644 --- a/src/smt/theory_str.cpp +++ b/src/smt/theory_str.cpp @@ -288,10 +288,9 @@ namespace smt { } } - static void cut_vars_map_copy(std::map & dest, std::map & src) { - std::map::iterator itor = src.begin(); - for (; itor != src.end(); itor++) { - dest[itor->first] = 1; + static void cut_vars_map_copy(obj_map & dest, obj_map & src) { + for (auto const& kv : src) { + dest.insert(kv.m_key, 1); } } @@ -306,9 +305,8 @@ namespace smt { return false; } - std::map::iterator itor = cut_var_map[n1].top()->vars.begin(); - for (; itor != cut_var_map[n1].top()->vars.end(); ++itor) { - if (cut_var_map[n2].top()->vars.find(itor->first) != cut_var_map[n2].top()->vars.end()) { + for (auto const& kv : cut_var_map[n1].top()->vars) { + if (cut_var_map[n2].top()->vars.contains(kv.m_key)) { return true; } } @@ -2572,9 +2570,8 @@ namespace smt { if (cut_var_map.contains(node)) { if (!cut_var_map[node].empty()) { xout << "[" << cut_var_map[node].top()->level << "] "; - std::map::iterator itor = cut_var_map[node].top()->vars.begin(); - for (; itor != cut_var_map[node].top()->vars.end(); ++itor) { - xout << mk_pp(itor->first, m) << ", "; + for (auto const& kv : cut_var_map[node].top()->vars) { + xout << mk_pp(kv.m_key, m) << ", "; } xout << std::endl; } diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h index 64ede71b5..09d6498a4 100644 --- a/src/smt/theory_str.h +++ b/src/smt/theory_str.h @@ -77,25 +77,8 @@ public: void register_value(expr * n) override { /* Ignore */ } }; -// rather than modify obj_pair_map I inherit from it and add my own helper methods -class theory_str_contain_pair_bool_map_t : public obj_pair_map { -public: - expr * operator[](std::pair key) const { - expr * value; - bool found = this->find(key.first, key.second, value); - if (found) { - return value; - } else { - TRACE("t_str", tout << "WARNING: lookup miss in contain_pair_bool_map!" << std::endl;); - return nullptr; - } - } - - bool contains(std::pair key) const { - expr * unused; - return this->find(key.first, key.second, unused); - } -}; +// NSB: added operator[] and contains to obj_pair_hashtable +class theory_str_contain_pair_bool_map_t : public obj_pair_map {}; template class binary_search_trail : public trail { @@ -169,7 +152,7 @@ class theory_str : public theory { struct T_cut { int level; - std::map vars; + obj_map vars; T_cut() { level = -100; @@ -292,8 +275,8 @@ protected: int tmpXorVarCount; int tmpLenTestVarCount; int tmpValTestVarCount; - std::map, std::map > varForBreakConcat; - + // obj_pair_map > varForBreakConcat; + std::map, std::map > varForBreakConcat; bool avoidLoopCut; bool loopDetected; obj_map > cut_var_map; @@ -312,9 +295,11 @@ protected: obj_hashtable input_var_in_len; obj_map fvar_len_count_map; + // TBD: need to replace by obj_map for determinism std::map > fvar_lenTester_map; obj_map lenTester_fvar_map; + // TBD: need to replace by obj_map for determinism std::map > > > fvar_valueTester_map; std::map valueTester_fvar_map; @@ -322,8 +307,10 @@ protected: // This can't be an expr_ref_vector because the constructor is wrong, // we would need to modify the allocator so we pass in ast_manager + // TBD: need to replace by obj_map for determinism std::map, ptr_vector > > unroll_tries_map; std::map unroll_var_map; + // TBD: need to replace by obj_pair_map for determinism std::map, expr*> concat_eq_unroll_ast_map; expr_ref_vector contains_map; @@ -332,9 +319,10 @@ protected: //obj_map > contain_pair_idx_map; std::map > > contain_pair_idx_map; + // TBD: do a curried map for determinism. std::map, expr*> regex_in_bool_map; + // TBD: need to replace by obj_map for determinism std::map > regex_in_var_reg_str_map; - std::map regex_nfa_cache; // Regex term --> NFA svector char_set; diff --git a/src/util/obj_pair_hashtable.h b/src/util/obj_pair_hashtable.h index f002a7807..2b8924e9f 100644 --- a/src/util/obj_pair_hashtable.h +++ b/src/util/obj_pair_hashtable.h @@ -160,10 +160,23 @@ public: } return (nullptr != e); } + + Value const & find(Key1 * k1, Key2 * k2) const { + entry * e = find_core(k1, k2); + return e->get_data().get_value(); + } + + Value const& operator[](std::pair const& key) const { + return find(key.first, key.second); + } bool contains(Key1 * k1, Key2 * k2) const { return find_core(k1, k2) != nullptr; } + + bool contains(std::pair const& key) const { + return contains(key.first, key.second); + } void erase(Key1 * k1, Key2 * k2) { m_table.remove(key_data(k1, k2)); From b12a1caa0759052380d60fbd1f71a5d8436ac047 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Fri, 16 Mar 2018 09:05:44 -0700 Subject: [PATCH 048/109] fix build Signed-off-by: Nikolaj Bjorner --- src/smt/theory_str.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp index 30092097a..e1340c301 100644 --- a/src/smt/theory_str.cpp +++ b/src/smt/theory_str.cpp @@ -321,7 +321,7 @@ namespace smt { T_cut * varInfo = alloc(T_cut); m_cut_allocs.push_back(varInfo); varInfo->level = slevel; - varInfo->vars[node] = 1; + varInfo->vars.insert(node, 1); cut_var_map.insert(baseNode, std::stack()); cut_var_map[baseNode].push(varInfo); TRACE("str", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << " [" << slevel << "]" << std::endl;); @@ -330,7 +330,7 @@ namespace smt { T_cut * varInfo = alloc(T_cut); m_cut_allocs.push_back(varInfo); varInfo->level = slevel; - varInfo->vars[node] = 1; + varInfo->vars.insert(node, 1); cut_var_map[baseNode].push(varInfo); TRACE("str", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << " [" << slevel << "]" << std::endl;); } else { @@ -339,11 +339,11 @@ namespace smt { m_cut_allocs.push_back(varInfo); varInfo->level = slevel; cut_vars_map_copy(varInfo->vars, cut_var_map[baseNode].top()->vars); - varInfo->vars[node] = 1; + varInfo->vars.insert(node, 1); cut_var_map[baseNode].push(varInfo); TRACE("str", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << " [" << slevel << "]" << std::endl;); } else if (cut_var_map[baseNode].top()->level == slevel) { - cut_var_map[baseNode].top()->vars[node] = 1; + cut_var_map[baseNode].top()->vars.insert(node, 1); TRACE("str", tout << "add var info for baseNode=" << mk_pp(baseNode, get_manager()) << ", node=" << mk_pp(node, get_manager()) << " [" << slevel << "]" << std::endl;); } else { get_manager().raise_exception("entered illegal state during add_cut_info_one_node()"); From 5dd7e2c520b37c75bfe3c22f1e81911373e1dfed Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Fri, 16 Mar 2018 19:30:13 -0700 Subject: [PATCH 049/109] fix #1544 Signed-off-by: Nikolaj Bjorner --- src/api/z3.h | 1 - src/ast/rewriter/rewriter_def.h | 2 ++ src/model/model_evaluator.cpp | 11 +++++------ 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/api/z3.h b/src/api/z3.h index b29f1d6ba..e08b0c073 100644 --- a/src/api/z3.h +++ b/src/api/z3.h @@ -22,7 +22,6 @@ Notes: #define Z3_H_ #include -#include #include "z3_macros.h" #include "z3_api.h" #include "z3_ast_containers.h" diff --git a/src/ast/rewriter/rewriter_def.h b/src/ast/rewriter/rewriter_def.h index 878f4ef4c..dfb6542d6 100644 --- a/src/ast/rewriter/rewriter_def.h +++ b/src/ast/rewriter/rewriter_def.h @@ -194,12 +194,14 @@ bool rewriter_tpl::constant_fold(app * t, frame & fr) { result_stack().shrink(fr.m_spos); result_stack().push_back(arg); fr.m_state = REWRITE_BUILTIN; + TRACE("rewriter_step", tout << "step\n" << mk_ismt2_pp(t, m()) << "\n";); if (visit(arg, fr.m_max_depth)) { m_r = result_stack().back(); result_stack().pop_back(); result_stack().pop_back(); result_stack().push_back(m_r); cache_result(t, m_r, m_pr, fr.m_cache_result); + TRACE("rewriter_step", tout << "step 1\n" << mk_ismt2_pp(m_r, m()) << "\n";); frame_stack().pop_back(); set_new_child_flag(t); } diff --git a/src/model/model_evaluator.cpp b/src/model/model_evaluator.cpp index fd2dc7656..227e14ca6 100644 --- a/src/model/model_evaluator.cpp +++ b/src/model/model_evaluator.cpp @@ -187,14 +187,14 @@ struct evaluator_cfg : public default_rewriter_cfg { TRACE("model_evaluator", tout << "reduce_app " << f->get_name() << "\n"; for (unsigned i = 0; i < num; i++) tout << mk_ismt2_pp(args[i], m) << "\n"; tout << "---->\n" << mk_ismt2_pp(result, m) << "\n";); - return BR_DONE; + return BR_REWRITE1; } if (st == BR_FAILED && !m.is_builtin_family_id(fid)) st = evaluate_partial_theory_func(f, num, args, result, result_pr); if (st == BR_DONE && is_app(result)) { app* a = to_app(result); if (evaluate(a->get_decl(), a->get_num_args(), a->get_args(), result)) { - return BR_DONE; + return BR_REWRITE1; } } CTRACE("model_evaluator", st != BR_FAILED, tout << result << "\n";); @@ -399,12 +399,11 @@ struct evaluator_cfg : public default_rewriter_cfg { } } } - args_table::iterator it = table1.begin(), end = table1.end(); - for (; it != end; ++it) { - switch (compare((*it)[arity], else2)) { + for (auto const& t : table1) { + switch (compare((t)[arity], else2)) { case l_true: break; case l_false: result = m.mk_false(); return BR_DONE; - default: conj.push_back(m.mk_eq((*it)[arity], else2)); break; + default: conj.push_back(m.mk_eq((t)[arity], else2)); break; } } result = mk_and(conj); From aa913c564c7b41fc1a2bb3a198b91f18ff717892 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Sat, 17 Mar 2018 04:21:28 -0700 Subject: [PATCH 050/109] moving more std::map std::set to obj_*, #1529 Signed-off-by: Nikolaj Bjorner --- src/smt/theory_str.cpp | 19 ++++++++++--------- src/smt/theory_str.h | 11 +++++------ 2 files changed, 15 insertions(+), 15 deletions(-) diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp index e1340c301..69cf80de6 100644 --- a/src/smt/theory_str.cpp +++ b/src/smt/theory_str.cpp @@ -441,7 +441,7 @@ namespace smt { void theory_str::track_variable_scope(expr * var) { if (internal_variable_scope_levels.find(sLevel) == internal_variable_scope_levels.end()) { - internal_variable_scope_levels[sLevel] = std::set(); + internal_variable_scope_levels[sLevel] = obj_hashtable(); } internal_variable_scope_levels[sLevel].insert(var); } @@ -6468,9 +6468,9 @@ namespace smt { expr * regexTerm = a_regexIn->get_arg(1); // TODO figure out regex NFA stuff - if (regex_nfa_cache.find(regexTerm) == regex_nfa_cache.end()) { + if (!regex_nfa_cache.contains(regexTerm)) { TRACE("str", tout << "regex_nfa_cache: cache miss" << std::endl;); - regex_nfa_cache[regexTerm] = nfa(u, regexTerm); + regex_nfa_cache.insert(regexTerm, nfa(u, regexTerm)); } else { TRACE("str", tout << "regex_nfa_cache: cache hit" << std::endl;); } @@ -9286,7 +9286,7 @@ namespace smt { h++; coverAll = get_next_val_encode(options[options.size() - 1], base); } - val_range_map[val_indicator] = options[options.size() - 1]; + val_range_map.insert(val_indicator, options[options.size() - 1]); TRACE("str", tout << "value tester encoding " << "{" << std::endl; @@ -9380,7 +9380,7 @@ namespace smt { TRACE("str", tout << "no previous value testers, or none of them were in scope" << std::endl;); int tries = 0; expr * val_indicator = mk_internal_valTest_var(freeVar, len, tries); - valueTester_fvar_map[val_indicator] = freeVar; + valueTester_fvar_map.insert(val_indicator, freeVar); fvar_valueTester_map[freeVar][len].push_back(std::make_pair(sLevel, val_indicator)); print_value_tester_list(fvar_valueTester_map[freeVar][len]); return gen_val_options(freeVar, len_indicator, val_indicator, len_valueStr, tries); @@ -9430,7 +9430,7 @@ namespace smt { refresh_theory_var(valTester); } else { valTester = mk_internal_valTest_var(freeVar, len, i + 1); - valueTester_fvar_map[valTester] = freeVar; + valueTester_fvar_map.insert(valTester, freeVar); fvar_valueTester_map[freeVar][len].push_back(std::make_pair(sLevel, valTester)); print_value_tester_list(fvar_valueTester_map[freeVar][len]); } @@ -9595,7 +9595,7 @@ namespace smt { if (low.is_neg()) { toAssert = m_autil.mk_ge(cntInUnr, mk_int(0)); } else { - if (unroll_var_map.find(unrFunc) == unroll_var_map.end()) { + if (!unroll_var_map.contains(unrFunc)) { expr_ref newVar1(mk_regex_rep_var(), mgr); expr_ref newVar2(mk_regex_rep_var(), mgr); @@ -9627,8 +9627,9 @@ namespace smt { // put together toAssert = mgr.mk_and(ctx.mk_eq_atom(op0, and1), toAssert); - unroll_var_map[unrFunc] = toAssert; - } else { + unroll_var_map.insert(unrFunc, toAssert); + } + else { toAssert = unroll_var_map[unrFunc]; } } diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h index 09d6498a4..508a1c905 100644 --- a/src/smt/theory_str.h +++ b/src/smt/theory_str.h @@ -286,7 +286,7 @@ protected: obj_hashtable variable_set; obj_hashtable internal_variable_set; obj_hashtable regex_variable_set; - std::map > internal_variable_scope_levels; + std::map > internal_variable_scope_levels; obj_hashtable internal_lenTest_vars; obj_hashtable internal_valTest_vars; @@ -295,21 +295,20 @@ protected: obj_hashtable input_var_in_len; obj_map fvar_len_count_map; - // TBD: need to replace by obj_map for determinism std::map > fvar_lenTester_map; obj_map lenTester_fvar_map; // TBD: need to replace by obj_map for determinism std::map > > > fvar_valueTester_map; - std::map valueTester_fvar_map; + obj_map valueTester_fvar_map; - std::map val_range_map; + obj_map val_range_map; // This can't be an expr_ref_vector because the constructor is wrong, // we would need to modify the allocator so we pass in ast_manager // TBD: need to replace by obj_map for determinism std::map, ptr_vector > > unroll_tries_map; - std::map unroll_var_map; + obj_map unroll_var_map; // TBD: need to replace by obj_pair_map for determinism std::map, expr*> concat_eq_unroll_ast_map; @@ -323,7 +322,7 @@ protected: std::map, expr*> regex_in_bool_map; // TBD: need to replace by obj_map for determinism std::map > regex_in_var_reg_str_map; - std::map regex_nfa_cache; // Regex term --> NFA + obj_map regex_nfa_cache; // Regex term --> NFA svector char_set; std::map charSetLookupTable; From 72f8e408fc39afca1f5c690b20fd86e3518ac687 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Sat, 17 Mar 2018 11:25:07 -0700 Subject: [PATCH 051/109] fix #1538 Signed-off-by: Nikolaj Bjorner --- src/smt/smt_context_pp.cpp | 6 +++--- src/smt/theory_seq.cpp | 8 ++++---- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/smt/smt_context_pp.cpp b/src/smt/smt_context_pp.cpp index f072a1d13..f4f56df5d 100644 --- a/src/smt/smt_context_pp.cpp +++ b/src/smt/smt_context_pp.cpp @@ -580,20 +580,20 @@ namespace smt { case b_justification::BIN_CLAUSE: { literal l2 = j.get_literal(); out << "bin-clause "; - display_literal(out, l2); + display_literal_verbose(out, l2); break; } case b_justification::CLAUSE: { clause * cls = j.get_clause(); out << "clause "; - if (cls) display_literals(out, cls->get_num_literals(), cls->begin_literals()); + if (cls) display_literals_verbose(out, cls->get_num_literals(), cls->begin_literals()); break; } case b_justification::JUSTIFICATION: { out << "justification " << j.get_justification()->get_from_theory() << ": "; literal_vector lits; const_cast(*m_conflict_resolution).justification2literals(j.get_justification(), lits); - display_literals(out, lits); + display_literals_verbose(out, lits); break; } default: diff --git a/src/smt/theory_seq.cpp b/src/smt/theory_seq.cpp index b90735a07..94841603d 100644 --- a/src/smt/theory_seq.cpp +++ b/src/smt/theory_seq.cpp @@ -2404,8 +2404,7 @@ bool theory_seq::add_stoi_val_axiom(expr* e) { lits.push_back(~is_digit(ith_char)); nums.push_back(digit2int(ith_char)); } - for (unsigned i = sz-1, c = 1; i > 0; c *= 10) { - --i; + for (unsigned i = sz, c = 1; i-- > 0; c *= 10) { coeff = m_autil.mk_int(c); nums[i] = m_autil.mk_mul(coeff, nums[i].get()); } @@ -2414,9 +2413,10 @@ bool theory_seq::add_stoi_val_axiom(expr* e) { lits.push_back(mk_eq(e, num, false)); ++m_stats.m_add_axiom; m_new_propagation = true; - for (unsigned i = 0; i < lits.size(); ++i) { - ctx.mark_as_relevant(lits[i]); + for (literal lit : lits) { + ctx.mark_as_relevant(lit); } + TRACE("seq", ctx.display_literals_verbose(tout, lits); tout << "\n";); ctx.mk_th_axiom(get_id(), lits.size(), lits.c_ptr()); m_stoi_axioms.insert(val); m_trail_stack.push(insert_map(m_stoi_axioms, val)); From b572639fcdfc622a7615cea821a945f5499a4f08 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Sat, 17 Mar 2018 17:49:33 -0700 Subject: [PATCH 052/109] fix #1545 Signed-off-by: Nikolaj Bjorner --- src/api/python/z3/z3.py | 27 ++++++++++++++++++++------- src/api/python/z3/z3printer.py | 4 +++- src/smt/smt_quantifier.cpp | 2 +- 3 files changed, 24 insertions(+), 9 deletions(-) diff --git a/src/api/python/z3/z3.py b/src/api/python/z3/z3.py index d4ff556fe..36283356d 100644 --- a/src/api/python/z3/z3.py +++ b/src/api/python/z3/z3.py @@ -114,15 +114,26 @@ def _symbol2py(ctx, s): # Hack for having nary functions that can receive one argument that is the # list of arguments. +# Use this when function takes a single list of arguments def _get_args(args): - try: - if len(args) == 1 and (isinstance(args[0], tuple) or isinstance(args[0], list)): + try: + if len(args) == 1 and (isinstance(args[0], tuple) or isinstance(args[0], list)): return args[0] - elif len(args) == 1 and (isinstance(args[0], set) or isinstance(args[0], AstVector)): + elif len(args) == 1 and (isinstance(args[0], set) or isinstance(args[0], AstVector)): return [arg for arg in args[0]] + else: + return args + except: # len is not necessarily defined when args is not a sequence (use reflection?) + return args + +# Use this when function takes multiple arguments +def _get_args_ast_list(args): + try: + if isinstance(args, set) or isinstance(args, AstVector) or isinstance(args, tuple): + return [arg for arg in args] else: return args - except: # len is not necessarily defined when args is not a sequence (use reflection?) + except: return args def _to_param_value(val): @@ -7943,8 +7954,10 @@ def AtLeast(*args): return BoolRef(Z3_mk_atleast(ctx.ref(), sz, _args, k), ctx) -def _pb_args_coeffs(args): - args = _get_args(args) +def _pb_args_coeffs(args, default_ctx = None): + args = _get_args_ast_list(args) + if len(args) == 0: + return _get_ctx(default_ctx), 0, (Ast * 0)(), (ctypes.c_int * 0)() args, coeffs = zip(*args) if __debug__: _z3_assert(len(args) > 0, "Non empty list of arguments expected") @@ -7976,7 +7989,7 @@ def PbGe(args, k): ctx, sz, _args, _coeffs = _pb_args_coeffs(args) return BoolRef(Z3_mk_pbge(ctx.ref(), sz, _args, _coeffs, k), ctx) -def PbEq(args, k): +def PbEq(args, k, ctx = None): """Create a Pseudo-Boolean inequality k constraint. >>> a, b, c = Bools('a b c') diff --git a/src/api/python/z3/z3printer.py b/src/api/python/z3/z3printer.py index 3a6b7269e..8fd0c182e 100644 --- a/src/api/python/z3/z3printer.py +++ b/src/api/python/z3/z3printer.py @@ -36,7 +36,7 @@ _z3_op_to_str = { Z3_OP_CONCAT : 'Concat', Z3_OP_EXTRACT : 'Extract', Z3_OP_BV2INT : 'BV2Int', Z3_OP_ARRAY_MAP : 'Map', Z3_OP_SELECT : 'Select', Z3_OP_STORE : 'Store', Z3_OP_CONST_ARRAY : 'K', Z3_OP_ARRAY_EXT : 'Ext', - Z3_OP_PB_AT_MOST : 'AtMost', Z3_OP_PB_LE : 'PbLe', Z3_OP_PB_GE : 'PbGe' + Z3_OP_PB_AT_MOST : 'AtMost', Z3_OP_PB_LE : 'PbLe', Z3_OP_PB_GE : 'PbGe', Z3_OP_PB_EQ : 'PbEq' } # List of infix operators @@ -930,6 +930,8 @@ class Formatter: return self.pp_pbcmp(a, d, f, xs) elif k == Z3_OP_PB_GE: return self.pp_pbcmp(a, d, f, xs) + elif k == Z3_OP_PB_EQ: + return self.pp_pbcmp(a, d, f, xs) elif z3.is_pattern(a): return self.pp_pattern(a, d, xs) elif self.is_infix(k): diff --git a/src/smt/smt_quantifier.cpp b/src/smt/smt_quantifier.cpp index 0ca244185..1f6811a0f 100644 --- a/src/smt/smt_quantifier.cpp +++ b/src/smt/smt_quantifier.cpp @@ -222,7 +222,7 @@ namespace smt { final_check_status final_check_eh(bool full) { if (full) { - IF_VERBOSE(100, verbose_stream() << "(smt.final-check \"quantifiers\")\n";); + IF_VERBOSE(100, if (!m_quantifiers.empty()) verbose_stream() << "(smt.final-check \"quantifiers\")\n";); final_check_status result = m_qi_queue.final_check_eh() ? FC_DONE : FC_CONTINUE; final_check_status presult = m_plugin->final_check_eh(full); if (presult != FC_DONE) From a988d015374869c91302b45f43ff01877817d016 Mon Sep 17 00:00:00 2001 From: Murphy Berzish Date: Mon, 19 Mar 2018 12:25:44 -0400 Subject: [PATCH 053/109] add const to iterator loops where it can be used --- src/smt/theory_str.cpp | 25 ++++++++++--------------- 1 file changed, 10 insertions(+), 15 deletions(-) diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp index 144ddb9c9..a985ca678 100644 --- a/src/smt/theory_str.cpp +++ b/src/smt/theory_str.cpp @@ -800,25 +800,25 @@ namespace smt { context & ctx = get_context(); while (can_propagate()) { TRACE("str", tout << "propagating..." << std::endl;); - for (auto el : m_basicstr_axiom_todo) { + for (auto const& el : m_basicstr_axiom_todo) { instantiate_basic_string_axioms(el); } m_basicstr_axiom_todo.reset(); TRACE("str", tout << "reset m_basicstr_axiom_todo" << std::endl;); - for (auto pair : m_str_eq_todo) { + for (auto const& pair : m_str_eq_todo) { enode * lhs = pair.first; enode * rhs = pair.second; handle_equality(lhs->get_owner(), rhs->get_owner()); } m_str_eq_todo.reset(); - for (auto el : m_concat_axiom_todo) { + for (auto const& el : m_concat_axiom_todo) { instantiate_concat_axiom(el); } m_concat_axiom_todo.reset(); - for (auto el : m_concat_eval_todo) { + for (auto const& el : m_concat_eval_todo) { try_eval_concat(el); } m_concat_eval_todo.reset(); @@ -4977,8 +4977,7 @@ namespace smt { expr_ref_vector constList(m); bool counterEgFound = false; get_const_str_asts_in_node(aConcat, constList); - //for (expr_ref_vector::iterator cstItor = constList.begin(); cstItor != constList.end(); cstItor++) { - for (auto cst : constList) { + for (auto const& cst : constList) { zstring pieceStr; u.str.is_string(cst, pieceStr); if (!strConst.contains(pieceStr)) { @@ -5118,11 +5117,7 @@ namespace smt { ast_manager & m = get_manager(); if (in_contain_idx_map(n1) && in_contain_idx_map(n2)) { - //std::set >::iterator keysItor1 = contain_pair_idx_map[n1].begin(); - //std::set >::iterator keysItor2; - - //for (; keysItor1 != contain_pair_idx_map[n1].end(); keysItor1++) { - for (auto key1 : contain_pair_idx_map[n1]) { + for (auto const& key1 : contain_pair_idx_map[n1]) { // keysItor1 is on set {<.., n1>, ..., , ...} //std::pair key1 = *keysItor1; if (key1.first == n1 && key1.second == n2) { @@ -5137,7 +5132,7 @@ namespace smt { } //for (keysItor2 = contain_pair_idx_map[n2].begin(); keysItor2 != contain_pair_idx_map[n2].end(); keysItor2++) { - for (auto key2 : contain_pair_idx_map[n2]) { + for (auto const& key2 : contain_pair_idx_map[n2]) { // keysItor2 is on set {<.., n2>, ..., , ...} //std::pair key2 = *keysItor2; // skip if the pair is eq @@ -5385,8 +5380,8 @@ namespace smt { // * key1.second = key2.second // check eqc(key1.first) and eqc(key2.first) // ----------------------------------------------------------- - for (auto eqStrVar1 : str1Eqc) { - for (auto eqStrVar2 : str2Eqc) { + for (auto const& eqStrVar1 : str1Eqc) { + for (auto const& eqStrVar2 : str2Eqc) { { expr_ref_vector litems3(m); if (n1 != n2) { @@ -6944,7 +6939,7 @@ namespace smt { } // now create a fake length tester over this finite disjunction of lengths - fvar_len_count_map[v] = 1; + fvar_len_count_map.insert(v, 1); unsigned int testNum = fvar_len_count_map[v]; expr_ref indicator(mk_internal_lenTest_var(v, testNum), m); From ebc6ec2eb5348b438b154f531791e8cab5deeb07 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Mon, 19 Mar 2018 13:33:58 -0700 Subject: [PATCH 054/109] fix #1547 by rewriting legacy recognizers to SMT-LIB2.6 style recognizers which are assumed by theory_datatype Signed-off-by: Nikolaj Bjorner --- src/ast/datatype_decl_plugin.cpp | 4 ++++ src/ast/datatype_decl_plugin.h | 1 + src/ast/rewriter/datatype_rewriter.cpp | 3 +++ src/interp/iz3interp.cpp | 12 ++++++------ src/interp/iz3translate.cpp | 4 ++-- 5 files changed, 16 insertions(+), 8 deletions(-) diff --git a/src/ast/datatype_decl_plugin.cpp b/src/ast/datatype_decl_plugin.cpp index 44f824959..f685c70d5 100644 --- a/src/ast/datatype_decl_plugin.cpp +++ b/src/ast/datatype_decl_plugin.cpp @@ -821,6 +821,10 @@ namespace datatype { return d; } + app* util::mk_is(func_decl * c, expr *f) { + return m.mk_app(get_constructor_is(c), 1, &f); + } + func_decl * util::get_recognizer_constructor(func_decl * recognizer) const { SASSERT(is_recognizer(recognizer)); return to_func_decl(recognizer->get_parameter(0).get_ast()); diff --git a/src/ast/datatype_decl_plugin.h b/src/ast/datatype_decl_plugin.h index e644ccbda..f32e9990d 100644 --- a/src/ast/datatype_decl_plugin.h +++ b/src/ast/datatype_decl_plugin.h @@ -362,6 +362,7 @@ namespace datatype { bool is_recognizer(app * f) const { return is_recognizer0(f) || is_is(f); } bool is_accessor(app * f) const { return is_app_of(f, m_family_id, OP_DT_ACCESSOR); } bool is_update_field(app * f) const { return is_app_of(f, m_family_id, OP_DT_UPDATE_FIELD); } + app* mk_is(func_decl * c, expr *f); ptr_vector const * get_datatype_constructors(sort * ty); unsigned get_datatype_num_constructors(sort * ty); unsigned get_datatype_num_parameter_sorts(sort * ty); diff --git a/src/ast/rewriter/datatype_rewriter.cpp b/src/ast/rewriter/datatype_rewriter.cpp index f0a95929b..194668b9c 100644 --- a/src/ast/rewriter/datatype_rewriter.cpp +++ b/src/ast/rewriter/datatype_rewriter.cpp @@ -23,6 +23,9 @@ br_status datatype_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr switch(f->get_decl_kind()) { case OP_DT_CONSTRUCTOR: return BR_FAILED; case OP_DT_RECOGNISER: + SASSERT(num_args == 1); + result = m_util.mk_is(m_util.get_recognizer_constructor(f), args[0]); + return BR_REWRITE1; case OP_DT_IS: // // simplify is_cons(cons(x,y)) -> true diff --git a/src/interp/iz3interp.cpp b/src/interp/iz3interp.cpp index 3d1d84f3c..41c968bd8 100644 --- a/src/interp/iz3interp.cpp +++ b/src/interp/iz3interp.cpp @@ -255,12 +255,12 @@ public: catch (const char *msg) { throw interpolation_failure(msg); } - catch (const iz3translation::unsupported &) { - TRACE("iz3", tout << "unsupported\n";); + catch (const iz3translation::unsupported & ex) { + TRACE("iz3", tout << "unsupported " << "\n";); throw interpolation_error(); } - catch (const iz3proof::proof_error &) { - TRACE("iz3", tout << "proof error\n";); + catch (const iz3proof::proof_error & ex) { + TRACE("iz3", tout << "proof error " << "\n";); throw interpolation_error(); } profiling::timer_stop("Proof translation"); @@ -306,8 +306,8 @@ public: catch (const char *msg) { throw interpolation_failure(msg); } - catch (const iz3translation::unsupported &) { - TRACE("iz3", tout << "unsupported\n";); + catch (const iz3translation::unsupported & ex) { + TRACE("iz3", tout << "unsupported " << "\n";); throw interpolation_error(); } catch (const iz3proof::proof_error &) { diff --git a/src/interp/iz3translate.cpp b/src/interp/iz3translate.cpp index 9680ec95e..44bac0643 100644 --- a/src/interp/iz3translate.cpp +++ b/src/interp/iz3translate.cpp @@ -2029,8 +2029,8 @@ public: case PR_IFF_FALSE: { // turns ~p into p <-> false, noop for us if(is_local(con)) res = args[0]; - else - throw_unsupported(con); + else + throw_unsupported(proof); break; } case PR_COMMUTATIVITY: { From 84c30e0b60e795c212bdafa41c18d1609112fb32 Mon Sep 17 00:00:00 2001 From: Murphy Berzish Date: Mon, 19 Mar 2018 17:03:01 -0400 Subject: [PATCH 055/109] theory_str fixups for new collections --- src/smt/theory_str.cpp | 85 ++++++++++++++++++++++++++++++------------ 1 file changed, 62 insertions(+), 23 deletions(-) diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp index a985ca678..ec7406d8a 100644 --- a/src/smt/theory_str.cpp +++ b/src/smt/theory_str.cpp @@ -967,6 +967,15 @@ namespace smt { TRACE("str", tout << "set up basic string axioms on " << mk_pp(str->get_owner(), m) << std::endl;); + { + sort * a_sort = m.get_sort(str->get_owner()); + sort * str_sort = u.str.mk_string_sort(); + if (a_sort != str_sort) { + TRACE("str", tout << "WARNING: not setting up string axioms on non-string term " << mk_pp(str->get_owner(), m) << std::endl;); + return; + } + } + // TESTING: attempt to avoid a crash here when a variable goes out of scope if (str->get_iscope_lvl() > ctx.get_scope_level()) { TRACE("str", tout << "WARNING: skipping axiom setup on out-of-scope string term" << std::endl;); @@ -975,6 +984,7 @@ namespace smt { // generate a stronger axiom for constant strings app * a_str = str->get_owner(); + if (u.str.is_string(a_str)) { expr_ref len_str(m); len_str = mk_strlen(a_str); @@ -1202,6 +1212,12 @@ namespace smt { contains_map.push_back(ex); std::pair key = std::pair(str, substr); contain_pair_bool_map.insert(str, substr, ex); + if (!contain_pair_idx_map.contains(str)) { + contain_pair_idx_map.insert(str, std::set>()); + } + if (!contain_pair_idx_map.contains(substr)) { + contain_pair_idx_map.insert(substr, std::set>()); + } contain_pair_idx_map[str].insert(key); contain_pair_idx_map[substr].insert(key); } @@ -5824,11 +5840,10 @@ namespace smt { std::map & concatAliasMap, std::map & varConstMap, std::map & concatConstMap, std::map > & varEqConcatMap) { std::map, std::set > > groundedMap; - theory_str_contain_pair_bool_map_t::iterator containItor = contain_pair_bool_map.begin(); - for (; containItor != contain_pair_bool_map.end(); containItor++) { - expr* containBoolVar = containItor->get_value(); - expr* str = containItor->get_key1(); - expr* subStr = containItor->get_key2(); + for (auto const& kv : contain_pair_bool_map) { + expr* containBoolVar = kv.get_value(); + expr* str = kv.get_key1(); + expr* subStr = kv.get_key2(); expr* strDeAlias = dealias_node(str, varAliasMap, concatAliasMap); expr* subStrDeAlias = dealias_node(subStr, varAliasMap, concatAliasMap); @@ -6889,12 +6904,14 @@ namespace smt { if (!map_effectively_empty) { map_effectively_empty = true; - ptr_vector indicator_set = fvar_lenTester_map[v]; - for (ptr_vector::iterator it = indicator_set.begin(); it != indicator_set.end(); ++it) { - expr * indicator = *it; - if (internal_variable_set.find(indicator) != internal_variable_set.end()) { - map_effectively_empty = false; - break; + if (fvar_lenTester_map.contains(v)) { + ptr_vector indicator_set = fvar_lenTester_map[v]; + for (ptr_vector::iterator it = indicator_set.begin(); it != indicator_set.end(); ++it) { + expr * indicator = *it; + if (internal_variable_set.find(indicator) != internal_variable_set.end()) { + map_effectively_empty = false; + break; + } } } } @@ -6946,9 +6963,12 @@ namespace smt { SASSERT(indicator); m_trail.push_back(indicator); + if (!fvar_lenTester_map.contains(v)) { + fvar_lenTester_map.insert(v, ptr_vector()); + } fvar_lenTester_map[v].shrink(0); fvar_lenTester_map[v].push_back(indicator); - lenTester_fvar_map[indicator] = v; + lenTester_fvar_map.insert(indicator, v); expr_ref_vector orList(m); expr_ref_vector andList(m); @@ -7015,7 +7035,12 @@ namespace smt { } } } else { - int lenTesterCount = fvar_lenTester_map[fVar].size(); + int lenTesterCount; + if (fvar_lenTester_map.contains(fVar)) { + lenTesterCount = fvar_lenTester_map[fVar].size(); + } else { + lenTesterCount = 0; + } expr * effectiveLenInd = nullptr; zstring effectiveLenIndiStr = ""; @@ -9336,7 +9361,8 @@ namespace smt { // check whether any value tester is actually in scope TRACE("str", tout << "checking scope of previous value testers" << std::endl;); bool map_effectively_empty = true; - if (fvar_valueTester_map[freeVar].find(len) != fvar_valueTester_map[freeVar].end()) { + if (fvar_valueTester_map.contains(freeVar) && + fvar_valueTester_map[freeVar].find(len) != fvar_valueTester_map[freeVar].end()) { // there's *something* in the map, but check its scope svector > entries = fvar_valueTester_map[freeVar][len]; for (svector >::iterator it = entries.begin(); it != entries.end(); ++it) { @@ -9357,6 +9383,9 @@ namespace smt { int tries = 0; expr * val_indicator = mk_internal_valTest_var(freeVar, len, tries); valueTester_fvar_map.insert(val_indicator, freeVar); + if (!fvar_valueTester_map.contains(freeVar)) { + fvar_valueTester_map.insert(freeVar, std::map > >()); + } fvar_valueTester_map[freeVar][len].push_back(std::make_pair(sLevel, val_indicator)); print_value_tester_list(fvar_valueTester_map[freeVar][len]); return gen_val_options(freeVar, len_indicator, val_indicator, len_valueStr, tries); @@ -10240,14 +10269,16 @@ namespace smt { // assume empty and find a counterexample map_effectively_empty = true; - ptr_vector indicator_set = fvar_lenTester_map[freeVar]; - for (ptr_vector::iterator it = indicator_set.begin(); it != indicator_set.end(); ++it) { - expr * indicator = *it; - if (internal_variable_set.find(indicator) != internal_variable_set.end()) { - TRACE("str", tout <<"found active internal variable " << mk_ismt2_pp(indicator, m) - << " in fvar_lenTester_map[freeVar]" << std::endl;); - map_effectively_empty = false; - break; + if (fvar_lenTester_map.contains(freeVar)) { + ptr_vector indicator_set = fvar_lenTester_map[freeVar]; + for (ptr_vector::iterator it = indicator_set.begin(); it != indicator_set.end(); ++it) { + expr * indicator = *it; + if (internal_variable_set.find(indicator) != internal_variable_set.end()) { + TRACE("str", tout <<"found active internal variable " << mk_ismt2_pp(indicator, m) + << " in fvar_lenTester_map[freeVar]" << std::endl;); + map_effectively_empty = false; + break; + } } } CTRACE("str", map_effectively_empty, tout << "all variables in fvar_lenTester_map[freeVar] out of scope" << std::endl;); @@ -10264,6 +10295,9 @@ namespace smt { SASSERT(indicator); // since the map is "effectively empty", we can remove those variables that have left scope... + if (!fvar_lenTester_map.contains(freeVar)) { + fvar_lenTester_map.insert(freeVar, ptr_vector()); + } fvar_lenTester_map[freeVar].shrink(0); fvar_lenTester_map[freeVar].push_back(indicator); lenTester_fvar_map.insert(indicator, freeVar); @@ -10276,7 +10310,12 @@ namespace smt { expr * effectiveLenInd = nullptr; zstring effectiveLenIndiStr(""); - int lenTesterCount = (int) fvar_lenTester_map[freeVar].size(); + int lenTesterCount; + if (fvar_lenTester_map.contains(freeVar)) { + lenTesterCount = fvar_lenTester_map[freeVar].size(); + } else { + lenTesterCount = 0; + } TRACE("str", tout << lenTesterCount << " length testers in fvar_lenTester_map[" << mk_pp(freeVar, m) << "]:" << std::endl; From 5c692dc79dccb1866e5c2a402128ffe33ec14c7e Mon Sep 17 00:00:00 2001 From: Murphy Berzish Date: Mon, 19 Mar 2018 18:06:42 -0400 Subject: [PATCH 056/109] fixups to theory_str indexof and axiom handling loop --- src/smt/theory_str.cpp | 190 ++++++++++++++++++++++++----------------- 1 file changed, 110 insertions(+), 80 deletions(-) diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp index ec7406d8a..534acf785 100644 --- a/src/smt/theory_str.cpp +++ b/src/smt/theory_str.cpp @@ -638,6 +638,7 @@ namespace smt { return contains; } + // note, this invokes "special-case" handling for the start index being 0 app * theory_str::mk_indexof(expr * haystack, expr * needle) { app * indexof = u.str.mk_index(haystack, needle, mk_int(0)); m_trail.push_back(indexof); @@ -823,31 +824,49 @@ namespace smt { } m_concat_eval_todo.reset(); - for (enode * e : m_library_aware_axiom_todo) { - app * a = e->get_owner(); - if (u.str.is_stoi(a)) { - instantiate_axiom_str_to_int(e); - } else if (u.str.is_itos(a)) { - instantiate_axiom_int_to_str(e); - } else if (u.str.is_at(a)) { - instantiate_axiom_CharAt(e); - } else if (u.str.is_prefix(a)) { - instantiate_axiom_prefixof(e); - } else if (u.str.is_suffix(a)) { - instantiate_axiom_suffixof(e); - } else if (u.str.is_contains(a)) { - instantiate_axiom_Contains(e); - } else if (u.str.is_index(a)) { - instantiate_axiom_Indexof(e); - } else if (u.str.is_extract(a)) { - instantiate_axiom_Substr(e); - } else if (u.str.is_replace(a)) { - instantiate_axiom_Replace(e); - } else if (u.str.is_in_re(a)) { - instantiate_axiom_RegexIn(e); + while(true) { + // Special handling: terms can recursively set up other terms + // (e.g. indexof can instantiate other indexof terms). + // - Copy the list so it can potentially be modified during setup. + // - Don't clear this list if new ones are added in the process; + // instead, set up all the new terms before proceeding. + // TODO see if any other propagate() worklists need this kind of handling + // TODO we really only need to check the new ones on each pass + unsigned start_count = m_library_aware_axiom_todo.size(); + ptr_vector axioms_tmp(m_library_aware_axiom_todo); + for (auto const& e : axioms_tmp) { + app * a = e->get_owner(); + if (u.str.is_stoi(a)) { + instantiate_axiom_str_to_int(e); + } else if (u.str.is_itos(a)) { + instantiate_axiom_int_to_str(e); + } else if (u.str.is_at(a)) { + instantiate_axiom_CharAt(e); + } else if (u.str.is_prefix(a)) { + instantiate_axiom_prefixof(e); + } else if (u.str.is_suffix(a)) { + instantiate_axiom_suffixof(e); + } else if (u.str.is_contains(a)) { + instantiate_axiom_Contains(e); + } else if (u.str.is_index(a)) { + instantiate_axiom_Indexof(e); + } else if (u.str.is_extract(a)) { + instantiate_axiom_Substr(e); + } else if (u.str.is_replace(a)) { + instantiate_axiom_Replace(e); + } else if (u.str.is_in_re(a)) { + instantiate_axiom_RegexIn(e); + } else { + TRACE("str", tout << "BUG: unhandled library-aware term " << mk_pp(e->get_owner(), get_manager()) << std::endl;); + NOT_IMPLEMENTED_YET(); + } + } + unsigned end_count = m_library_aware_axiom_todo.size(); + if (end_count > start_count) { + TRACE("str", tout << "new library-aware terms added during axiom setup -- checking again" << std::endl;); + continue; } else { - TRACE("str", tout << "BUG: unhandled library-aware term " << mk_pp(e->get_owner(), get_manager()) << std::endl;); - NOT_IMPLEMENTED_YET(); + break; } } m_library_aware_axiom_todo.reset(); @@ -1313,74 +1332,85 @@ namespace smt { } } - void theory_str::instantiate_axiom_Indexof_extended(enode * e) { + void theory_str::instantiate_axiom_Indexof_extended(enode * _e) { context & ctx = get_context(); ast_manager & m = get_manager(); - app * expr = e->get_owner(); - if (axiomatized_terms.contains(expr)) { - TRACE("str", tout << "already set up extended str.indexof axiom for " << mk_pp(expr, m) << std::endl;); + app * e = _e->get_owner(); + if (axiomatized_terms.contains(e)) { + TRACE("str", tout << "already set up extended str.indexof axiom for " << mk_pp(e, m) << std::endl;); return; } - SASSERT(expr->get_num_args() == 3); - axiomatized_terms.insert(expr); + SASSERT(e->get_num_args() == 3); + axiomatized_terms.insert(e); - TRACE("str", tout << "instantiate extended str.indexof axiom for " << mk_pp(expr, m) << std::endl;); + TRACE("str", tout << "instantiate extended str.indexof axiom for " << mk_pp(e, m) << std::endl;); - // ------------------------------------------------------------------------------- - // if (arg[2] >= length(arg[0])) // ite2 - // resAst = -1 - // else - // args[0] = prefix . suffix - // /\ indexAst = indexof(suffix, arg[1]) - // /\ args[2] = len(prefix) - // /\ if (indexAst == -1) resAst = indexAst // ite3 - // else resAst = args[2] + indexAst - // ------------------------------------------------------------------------------- + // str.indexof(H, N, i): + // i < 0 --> -1 + // i == 0 --> str.indexof(H, N, 0) + // i >= len(H) --> -1 + // 0 < i < len(H) --> + // H = hd ++ tl + // len(hd) = i + // str.indexof(tl, N, 0) - expr_ref resAst(mk_int_var("res"), m); - expr_ref indexAst(mk_int_var("index"), m); - expr_ref prefix(mk_str_var("prefix"), m); - expr_ref suffix(mk_str_var("suffix"), m); - expr_ref prefixLen(mk_strlen(prefix), m); - expr_ref zeroAst(mk_int(0), m); - expr_ref negOneAst(mk_int(-1), m); + expr * H; // "haystack" + expr * N; // "needle" + expr * i; // start index + u.str.is_index(e, H, N, i); - expr_ref ite3(m.mk_ite( - ctx.mk_eq_atom(indexAst, negOneAst), - ctx.mk_eq_atom(resAst, negOneAst), - ctx.mk_eq_atom(resAst, m_autil.mk_add(expr->get_arg(2), indexAst)) - ),m); + expr_ref minus_one(m_autil.mk_numeral(rational::minus_one(), true), m); + expr_ref zero(m_autil.mk_numeral(rational::zero(), true), m); - expr_ref_vector ite2ElseItems(m); - ite2ElseItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(prefix, suffix))); - ite2ElseItems.push_back(ctx.mk_eq_atom(indexAst, mk_indexof(suffix, expr->get_arg(1)))); - ite2ElseItems.push_back(ctx.mk_eq_atom(expr->get_arg(2), prefixLen)); - ite2ElseItems.push_back(ite3); - expr_ref ite2Else(mk_and(ite2ElseItems), m); - SASSERT(ite2Else); + // case split - expr_ref ite2(m.mk_ite( - //m_autil.mk_ge(expr->get_arg(2), mk_strlen(expr->get_arg(0))), - m_autil.mk_ge(m_autil.mk_add(expr->get_arg(2), m_autil.mk_mul(mk_int(-1), mk_strlen(expr->get_arg(0)))), zeroAst), - ctx.mk_eq_atom(resAst, negOneAst), - ite2Else - ), m); - SASSERT(ite2); + // case 1: i < 0 + { + expr_ref premise(m_autil.mk_le(i, minus_one), m); + expr_ref conclusion(ctx.mk_eq_atom(e, minus_one), m); + assert_implication(premise, conclusion); + } - expr_ref ite1(m.mk_ite( - //m_autil.mk_lt(expr->get_arg(2), zeroAst), - mk_not(m, m_autil.mk_ge(expr->get_arg(2), zeroAst)), - ctx.mk_eq_atom(resAst, mk_indexof(expr->get_arg(0), expr->get_arg(1))), - ite2 - ), m); - SASSERT(ite1); - assert_axiom(ite1); + // case 2: i = 0 + { + expr_ref premise(ctx.mk_eq_atom(i, zero), m); + // reduction to simpler case + expr_ref conclusion(ctx.mk_eq_atom(e, mk_indexof(H, N)), m); + assert_implication(premise, conclusion); + } + // case 3: i >= len(H) + { + //expr_ref _premise(m_autil.mk_ge(i, mk_strlen(H)), m); + //expr_ref premise(_premise); + //th_rewriter rw(m); + //rw(premise); + expr_ref premise(m_autil.mk_ge(m_autil.mk_add(i, m_autil.mk_mul(minus_one, mk_strlen(H))), zero), m); + expr_ref conclusion(ctx.mk_eq_atom(e, minus_one), m); + assert_implication(premise, conclusion); + } + // case 4: 0 < i < len(H) + { + expr_ref premise1(m_autil.mk_gt(i, zero), m); + expr_ref premise2(m_autil.mk_lt(i, mk_strlen(H)), m); + expr_ref _premise(m.mk_and(premise1, premise2), m); + expr_ref premise(_premise); + th_rewriter rw(m); + rw(premise); - expr_ref reduceTerm(ctx.mk_eq_atom(expr, resAst), m); - SASSERT(reduceTerm); - assert_axiom(reduceTerm); + expr_ref hd(mk_str_var("hd"), m); + expr_ref tl(mk_str_var("tl"), m); + expr_ref_vector conclusion_terms(m); + conclusion_terms.push_back(ctx.mk_eq_atom(H, mk_concat(hd, tl))); + conclusion_terms.push_back(ctx.mk_eq_atom(mk_strlen(hd), i)); + conclusion_terms.push_back(ctx.mk_eq_atom(e, mk_indexof(tl, N))); + + expr_ref conclusion(mk_and(conclusion_terms), m); + assert_implication(premise, conclusion); + } + + /* { // heuristic: integrate with str.contains information // (but don't introduce it if it isn't already in the instance) @@ -1394,6 +1424,7 @@ namespace smt { // we can't assert this during init_search as it breaks an invariant if the instance becomes inconsistent m_delayed_axiom_setup_terms.push_back(containsAxiom); } + */ } void theory_str::instantiate_axiom_LastIndexof(enode * e) { @@ -7411,8 +7442,7 @@ namespace smt { if (is_app(ex)) { app * ap = to_app(ex); - // TODO indexof2/lastindexof - if (u.str.is_index(ap) /* || is_Indexof2(ap) || is_LastIndexof(ap) */) { + if (u.str.is_index(ap)) { m_library_aware_axiom_todo.push_back(n); } else if (u.str.is_stoi(ap)) { TRACE("str", tout << "found string-integer conversion term: " << mk_pp(ex, get_manager()) << std::endl;); From 1f4bfcb4e5a6dee0e4e5df70f288c6b9a44fd3a1 Mon Sep 17 00:00:00 2001 From: Murphy Berzish Date: Mon, 19 Mar 2018 18:10:06 -0400 Subject: [PATCH 057/109] fix indexof subterm --- src/smt/theory_str.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp index 534acf785..16fd28d79 100644 --- a/src/smt/theory_str.cpp +++ b/src/smt/theory_str.cpp @@ -1392,7 +1392,8 @@ namespace smt { // case 4: 0 < i < len(H) { expr_ref premise1(m_autil.mk_gt(i, zero), m); - expr_ref premise2(m_autil.mk_lt(i, mk_strlen(H)), m); + //expr_ref premise2(m_autil.mk_lt(i, mk_strlen(H)), m); + expr_ref premise2(m.mk_not(m_autil.mk_ge(m_autil.mk_add(i, m_autil.mk_mul(minus_one, mk_strlen(H))), zero)), m); expr_ref _premise(m.mk_and(premise1, premise2), m); expr_ref premise(_premise); th_rewriter rw(m); From d26eddf77671dfefb4832c7455077a191751736d Mon Sep 17 00:00:00 2001 From: Murphy Berzish Date: Mon, 19 Mar 2018 18:31:26 -0400 Subject: [PATCH 058/109] re-add indexof-contains heuristic --- src/smt/theory_str.cpp | 23 +++++++++++++++-------- src/smt/theory_str.h | 1 + 2 files changed, 16 insertions(+), 8 deletions(-) diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp index 16fd28d79..ec554df7b 100644 --- a/src/smt/theory_str.cpp +++ b/src/smt/theory_str.cpp @@ -50,6 +50,7 @@ namespace smt { m_factory(nullptr), m_unused_id(0), m_delayed_axiom_setup_terms(m), + m_delayed_assertions_todo(m), tmpStringVarCount(0), tmpXorVarCount(0), tmpLenTestVarCount(0), @@ -793,7 +794,8 @@ namespace smt { return !m_basicstr_axiom_todo.empty() || !m_str_eq_todo.empty() || !m_concat_axiom_todo.empty() || !m_concat_eval_todo.empty() || !m_library_aware_axiom_todo.empty() - || !m_delayed_axiom_setup_terms.empty(); + || !m_delayed_axiom_setup_terms.empty() + || (search_started && !m_delayed_assertions_todo.empty()) ; } @@ -877,6 +879,13 @@ namespace smt { set_up_axioms(el); } m_delayed_axiom_setup_terms.reset(); + + if (search_started) { + for (auto const& el : m_delayed_assertions_todo) { + assert_axiom(el); + } + m_delayed_assertions_todo.reset(); + } } } @@ -1327,8 +1336,9 @@ namespace smt { expr_ref conclusion(m_autil.mk_ge(ex, zeroAst), m); expr_ref containsAxiom(ctx.mk_eq_atom(premise, conclusion), m); SASSERT(containsAxiom); + // we can't assert this during init_search as it breaks an invariant if the instance becomes inconsistent - m_delayed_axiom_setup_terms.push_back(containsAxiom); + //m_delayed_axiom_setup_terms.push_back(containsAxiom); } } @@ -1411,21 +1421,18 @@ namespace smt { assert_implication(premise, conclusion); } - /* { // heuristic: integrate with str.contains information // (but don't introduce it if it isn't already in the instance) - expr_ref haystack(expr->get_arg(0), m), needle(expr->get_arg(1), m), startIdx(expr->get_arg(2), m); // (H contains N) <==> (H indexof N, i) >= 0 - expr_ref premise(u.str.mk_contains(haystack, needle), m); + expr_ref premise(u.str.mk_contains(H, N), m); ctx.internalize(premise, false); - expr_ref conclusion(m_autil.mk_ge(expr, zeroAst), m); + expr_ref conclusion(m_autil.mk_ge(e, zero), m); expr_ref containsAxiom(ctx.mk_eq_atom(premise, conclusion), m); SASSERT(containsAxiom); // we can't assert this during init_search as it breaks an invariant if the instance becomes inconsistent - m_delayed_axiom_setup_terms.push_back(containsAxiom); + m_delayed_assertions_todo.push_back(containsAxiom); } - */ } void theory_str::instantiate_axiom_LastIndexof(enode * e) { diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h index cd491ac55..5378b05f3 100644 --- a/src/smt/theory_str.h +++ b/src/smt/theory_str.h @@ -262,6 +262,7 @@ protected: ptr_vector m_concat_axiom_todo; ptr_vector m_string_constant_length_todo; ptr_vector m_concat_eval_todo; + expr_ref_vector m_delayed_assertions_todo; // enode lists for library-aware/high-level string terms (e.g. substr, contains) ptr_vector m_library_aware_axiom_todo; From 7759d05efee280bd2360584cab43ec33a1d328ba Mon Sep 17 00:00:00 2001 From: Murphy Berzish Date: Mon, 19 Mar 2018 23:09:07 -0400 Subject: [PATCH 059/109] fix use-after-free --- src/smt/theory_str.cpp | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp index ec554df7b..5a39659e8 100644 --- a/src/smt/theory_str.cpp +++ b/src/smt/theory_str.cpp @@ -803,8 +803,20 @@ namespace smt { context & ctx = get_context(); while (can_propagate()) { TRACE("str", tout << "propagating..." << std::endl;); - for (auto const& el : m_basicstr_axiom_todo) { - instantiate_basic_string_axioms(el); + while(true) { + // this can potentially recursively activate itself + unsigned start_count = m_basicstr_axiom_todo.size(); + ptr_vector axioms_tmp(m_basicstr_axiom_todo); + for (auto const& el : axioms_tmp) { + instantiate_basic_string_axioms(el); + } + unsigned end_count = m_basicstr_axiom_todo.size(); + if (end_count > start_count) { + TRACE("str", tout << "new basic string axiom terms added -- checking again" << std::endl;); + continue; + } else { + break; + } } m_basicstr_axiom_todo.reset(); TRACE("str", tout << "reset m_basicstr_axiom_todo" << std::endl;); From eb6bbd390a93b125a70e4b554b83357dca31e05d Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Tue, 20 Mar 2018 08:33:09 -0700 Subject: [PATCH 060/109] vsts script Signed-off-by: Nikolaj Bjorner --- scripts/vsts-vs2017.cmd | 40 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 scripts/vsts-vs2017.cmd diff --git a/scripts/vsts-vs2017.cmd b/scripts/vsts-vs2017.cmd new file mode 100644 index 000000000..3b3a60231 --- /dev/null +++ b/scripts/vsts-vs2017.cmd @@ -0,0 +1,40 @@ +echo "Build" +md build +cd build +call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\VC\Auxiliary\Build\vcvars64.bat" +cmake -DBUILD_DOTNET_BINDINGS=True -DBUILD_JAVA_BINDINGS=True -DBUILD_PYTHON_BINDINGS=True -G "NMake Makefiles" ../ +nmake +rem TBD: test error level + +echo "Test python bindings" +pushd python +python z3test.py z3 +python z3test.py z3num +popd + +echo "Build and run examples" +nmake cpp_example +examples\cpp_example_build_dir\cpp_example.exe + +nmake c_example +examples\c_example_build_dir\c_example.exe + +rem nmake java_example +rem java_example.exe + +rem nmake dotnet_example +rem dotnet_example.exe + +echo "Build and run unit tests" +nmake test-z3 +rem TBD: test error level +rem test-z3.exe -a + + +cd .. +echo "Run regression tests" +git clone https://github.com/z3prover/z3test z3test +echo "test-benchmarks" +python z3test\scripts\test_benchmarks.py build\z3.exe z3test\regressions\smt2 +echo "benchmarks tested" + From 0d13a2812ee06d2cf3c489e3b40434f5f3e0ec55 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Tue, 20 Mar 2018 09:26:39 -0700 Subject: [PATCH 061/109] add error checking and command argument Signed-off-by: Nikolaj Bjorner --- scripts/vsts-vs2017.cmd | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/scripts/vsts-vs2017.cmd b/scripts/vsts-vs2017.cmd index 3b3a60231..d4c1e34b4 100644 --- a/scripts/vsts-vs2017.cmd +++ b/scripts/vsts-vs2017.cmd @@ -1,29 +1,37 @@ +rem Supply argument x64 or x86 + echo "Build" md build cd build -call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\VC\Auxiliary\Build\vcvars64.bat" +call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\VC\Auxiliary\Build\vcvars.bat" %1 cmake -DBUILD_DOTNET_BINDINGS=True -DBUILD_JAVA_BINDINGS=True -DBUILD_PYTHON_BINDINGS=True -G "NMake Makefiles" ../ nmake -rem TBD: test error level +if ERRORLEVEL 1 exit 1 echo "Test python bindings" pushd python python z3test.py z3 +if ERRORLEVEL 1 exit 1 python z3test.py z3num +if ERRORLEVEL 1 exit 1 popd echo "Build and run examples" nmake cpp_example examples\cpp_example_build_dir\cpp_example.exe +if ERRORLEVEL 1 exit 1 nmake c_example examples\c_example_build_dir\c_example.exe +if ERRORLEVEL 1 exit 1 rem nmake java_example rem java_example.exe +if ERRORLEVEL 1 exit 1 rem nmake dotnet_example rem dotnet_example.exe +if ERRORLEVEL 1 exit 1 echo "Build and run unit tests" nmake test-z3 @@ -36,5 +44,6 @@ echo "Run regression tests" git clone https://github.com/z3prover/z3test z3test echo "test-benchmarks" python z3test\scripts\test_benchmarks.py build\z3.exe z3test\regressions\smt2 +if ERRORLEVEL 1 exit 1 echo "benchmarks tested" From db7844bef733d3f225d90988034f974945983c91 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Tue, 20 Mar 2018 09:33:23 -0700 Subject: [PATCH 062/109] adding build definition Signed-off-by: Nikolaj Bjorner --- README.md | 6 +++--- scripts/vsts-vs2017.cmd | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 70956d439..899d23385 100644 --- a/README.md +++ b/README.md @@ -12,9 +12,9 @@ See the [release notes](RELEASE_NOTES) for notes on various stable releases of Z ## Build status -| Windows x86 | Windows x64 | Ubuntu x64 | Debian x64 | OSX | TravisCI | -| ----------- | ----------- | ---------- | ---------- | --- | -------- | -[![win32-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/4/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=4) | [![win64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/7/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=7) | [![ubuntu-x64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/3/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=3) | [![debian-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/5/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=5) | [![osx-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/2/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=2) | [![Build Status](https://travis-ci.org/Z3Prover/z3.svg?branch=master)](https://travis-ci.org/Z3Prover/z3) +| Windows x64 | Windows x86 | Windows x64 | Ubuntu x64 | Debian x64 | OSX | TravisCI | +| ----------- | ----------- | ----------- | ---------- | ---------- | --- | -------- | +[![win64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/4/badge)](https://z3build.visualstudio.com/Z3Build/_build/index?definitionId=2) [![win32-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/4/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=4) | [![win64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/7/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=7) | [![ubuntu-x64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/3/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=3) | [![debian-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/5/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=5) | [![osx-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/2/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=2) | [![Build Status](https://travis-ci.org/Z3Prover/z3.svg?branch=master)](https://travis-ci.org/Z3Prover/z3) [1]: #building-z3-on-windows-using-visual-studio-command-prompt [2]: #building-z3-using-make-and-gccclang diff --git a/scripts/vsts-vs2017.cmd b/scripts/vsts-vs2017.cmd index d4c1e34b4..fe2f55bca 100644 --- a/scripts/vsts-vs2017.cmd +++ b/scripts/vsts-vs2017.cmd @@ -3,7 +3,7 @@ rem Supply argument x64 or x86 echo "Build" md build cd build -call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\VC\Auxiliary\Build\vcvars.bat" %1 +call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" %1 cmake -DBUILD_DOTNET_BINDINGS=True -DBUILD_JAVA_BINDINGS=True -DBUILD_PYTHON_BINDINGS=True -G "NMake Makefiles" ../ nmake if ERRORLEVEL 1 exit 1 From d8462807c3bae35368f07f954189e279ca7a3f2a Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Tue, 20 Mar 2018 09:35:51 -0700 Subject: [PATCH 063/109] add missin bar Signed-off-by: Nikolaj Bjorner --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 899d23385..d501c5d5c 100644 --- a/README.md +++ b/README.md @@ -14,7 +14,7 @@ See the [release notes](RELEASE_NOTES) for notes on various stable releases of Z | Windows x64 | Windows x86 | Windows x64 | Ubuntu x64 | Debian x64 | OSX | TravisCI | | ----------- | ----------- | ----------- | ---------- | ---------- | --- | -------- | -[![win64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/4/badge)](https://z3build.visualstudio.com/Z3Build/_build/index?definitionId=2) [![win32-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/4/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=4) | [![win64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/7/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=7) | [![ubuntu-x64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/3/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=3) | [![debian-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/5/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=5) | [![osx-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/2/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=2) | [![Build Status](https://travis-ci.org/Z3Prover/z3.svg?branch=master)](https://travis-ci.org/Z3Prover/z3) +[![win64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/4/badge)](https://z3build.visualstudio.com/Z3Build/_build/index?definitionId=2) | [![win32-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/4/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=4) | [![win64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/7/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=7) | [![ubuntu-x64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/3/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=3) | [![debian-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/5/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=5) | [![osx-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/2/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=2) | [![Build Status](https://travis-ci.org/Z3Prover/z3.svg?branch=master)](https://travis-ci.org/Z3Prover/z3) [1]: #building-z3-on-windows-using-visual-studio-command-prompt [2]: #building-z3-using-make-and-gccclang From f7dfc39984f2f86ea31e719d2de5a371a08c8777 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Tue, 20 Mar 2018 12:20:40 -0700 Subject: [PATCH 064/109] add vstsvs2013 outline Signed-off-by: Nikolaj Bjorner --- scripts/vsts-vs2013.cmd | 49 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 49 insertions(+) create mode 100644 scripts/vsts-vs2013.cmd diff --git a/scripts/vsts-vs2013.cmd b/scripts/vsts-vs2013.cmd new file mode 100644 index 000000000..baf9f4bb4 --- /dev/null +++ b/scripts/vsts-vs2013.cmd @@ -0,0 +1,49 @@ + +set +echo "Build" +md build +cd build +call "C:\Program Files (x86)\Microsoft Visual Studio\2013\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" x64 +cmake -DBUILD_DOTNET_BINDINGS=True -DBUILD_JAVA_BINDINGS=True -DBUILD_PYTHON_BINDINGS=True -G "NMake Makefiles" ../ +nmake +if ERRORLEVEL 1 exit 1 + +echo "Test python bindings" +pushd python +python z3test.py z3 +if ERRORLEVEL 1 exit 1 +python z3test.py z3num +if ERRORLEVEL 1 exit 1 +popd + +echo "Build and run examples" +nmake cpp_example +examples\cpp_example_build_dir\cpp_example.exe +if ERRORLEVEL 1 exit 1 + +nmake c_example +examples\c_example_build_dir\c_example.exe +if ERRORLEVEL 1 exit 1 + +rem nmake java_example +rem java_example.exe +if ERRORLEVEL 1 exit 1 + +rem nmake dotnet_example +rem dotnet_example.exe +if ERRORLEVEL 1 exit 1 + +echo "Build and run unit tests" +nmake test-z3 +rem TBD: test error level +rem test-z3.exe -a + + +cd .. +echo "Run regression tests" +git clone https://github.com/z3prover/z3test z3test +echo "test-benchmarks" +python z3test\scripts\test_benchmarks.py build\z3.exe z3test\regressions\smt2 +if ERRORLEVEL 1 exit 1 +echo "benchmarks tested" + From 6ee4efe93a027abc705c9cd756f2c3e4ea308602 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Tue, 20 Mar 2018 12:48:21 -0700 Subject: [PATCH 065/109] remove python tests from x86 build Signed-off-by: Nikolaj Bjorner --- scripts/vsts-vs2017.cmd | 2 ++ 1 file changed, 2 insertions(+) diff --git a/scripts/vsts-vs2017.cmd b/scripts/vsts-vs2017.cmd index fe2f55bca..4ec4deca9 100644 --- a/scripts/vsts-vs2017.cmd +++ b/scripts/vsts-vs2017.cmd @@ -8,6 +8,7 @@ cmake -DBUILD_DOTNET_BINDINGS=True -DBUILD_JAVA_BINDINGS=True -DBUILD_PYTHON_BIN nmake if ERRORLEVEL 1 exit 1 +if %1 == "x86" goto :BUILD_EXAMPLES echo "Test python bindings" pushd python python z3test.py z3 @@ -16,6 +17,7 @@ python z3test.py z3num if ERRORLEVEL 1 exit 1 popd +:BUILD_EXAMPLES echo "Build and run examples" nmake cpp_example examples\cpp_example_build_dir\cpp_example.exe From 8c4ea7983f5acc24204daab2658f6fc9d45a6015 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Tue, 20 Mar 2018 12:59:42 -0700 Subject: [PATCH 066/109] use vc path in 2013 Signed-off-by: Nikolaj Bjorner --- scripts/vsts-vs2013.cmd | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/vsts-vs2013.cmd b/scripts/vsts-vs2013.cmd index baf9f4bb4..203c2668e 100644 --- a/scripts/vsts-vs2013.cmd +++ b/scripts/vsts-vs2013.cmd @@ -3,7 +3,7 @@ set echo "Build" md build cd build -call "C:\Program Files (x86)\Microsoft Visual Studio\2013\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" x64 +call "C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\vcvarsall.bat" amd64 cmake -DBUILD_DOTNET_BINDINGS=True -DBUILD_JAVA_BINDINGS=True -DBUILD_PYTHON_BINDINGS=True -G "NMake Makefiles" ../ nmake if ERRORLEVEL 1 exit 1 From 931dbd5933d77ba4a63b63259a339fa03410f661 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Tue, 20 Mar 2018 13:37:04 -0700 Subject: [PATCH 067/109] remove python doc test Signed-off-by: Nikolaj Bjorner --- scripts/vsts-vs2013.cmd | 14 +++---- src/smt/theory_str.cpp | 87 +++++++++++++++++----------------------- src/smt/theory_str.h | 3 +- src/util/hashtable.h | 17 ++++---- src/util/obj_hashtable.h | 3 ++ 5 files changed, 55 insertions(+), 69 deletions(-) diff --git a/scripts/vsts-vs2013.cmd b/scripts/vsts-vs2013.cmd index 203c2668e..1676f3e2d 100644 --- a/scripts/vsts-vs2013.cmd +++ b/scripts/vsts-vs2013.cmd @@ -8,13 +8,13 @@ cmake -DBUILD_DOTNET_BINDINGS=True -DBUILD_JAVA_BINDINGS=True -DBUILD_PYTHON_BIN nmake if ERRORLEVEL 1 exit 1 -echo "Test python bindings" -pushd python -python z3test.py z3 -if ERRORLEVEL 1 exit 1 -python z3test.py z3num -if ERRORLEVEL 1 exit 1 -popd +rem echo "Test python bindings" +rem pushd python +rem python z3test.py z3 +rem if ERRORLEVEL 1 exit 1 +rem python z3test.py z3num +rem if ERRORLEVEL 1 exit 1 +rem popd echo "Build and run examples" nmake cpp_example diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp index 69cf80de6..f61293a5f 100644 --- a/src/smt/theory_str.cpp +++ b/src/smt/theory_str.cpp @@ -169,6 +169,8 @@ namespace smt { } void theory_str::assert_axiom(expr * _e) { + if (_e == nullptr) + return; if (opt_VerifyFinalCheckProgress) { finalCheckProgressIndicator = true; } @@ -6914,10 +6916,8 @@ namespace smt { if (!map_effectively_empty) { map_effectively_empty = true; - ptr_vector indicator_set = fvar_lenTester_map[v]; - for (ptr_vector::iterator it = indicator_set.begin(); it != indicator_set.end(); ++it) { - expr * indicator = *it; - if (internal_variable_set.find(indicator) != internal_variable_set.end()) { + for (expr * indicator : fvar_lenTester_map[v]) { + if (internal_variable_set.contains(indicator)) { map_effectively_empty = false; break; } @@ -8977,12 +8977,12 @@ namespace smt { CTRACE("str", needToAssignFreeVars, tout << "Need to assign values to the following free variables:" << std::endl; - for (std::set::iterator itx = free_variables.begin(); itx != free_variables.end(); ++itx) { - tout << mk_ismt2_pp(*itx, m) << std::endl; + for (expr* v : free_variables) { + tout << mk_ismt2_pp(v, m) << std::endl; } tout << "freeVar_map has the following entries:" << std::endl; - for (std::map::iterator fvIt = freeVar_map.begin(); fvIt != freeVar_map.end(); fvIt++) { - expr * var = fvIt->first; + for (auto const& kv : freeVar_map) { + expr * var = kv.first; tout << mk_ismt2_pp(var, m) << std::endl; } ); @@ -9360,7 +9360,7 @@ namespace smt { // check whether any value tester is actually in scope TRACE("str", tout << "checking scope of previous value testers" << std::endl;); bool map_effectively_empty = true; - if (fvar_valueTester_map[freeVar].find(len) != fvar_valueTester_map[freeVar].end()) { + if (fvar_valueTester_map[freeVar].find(len) != fvar_valueTester_map[freeVar].end()) { // there's *something* in the map, but check its scope svector > entries = fvar_valueTester_map[freeVar][len]; for (svector >::iterator it = entries.begin(); it != entries.end(); ++it) { @@ -9721,8 +9721,8 @@ namespace smt { int dist = opt_LCMUnrollStep; expr_ref_vector litems(mgr); expr_ref moreAst(mk_string("more"), mgr); - for (std::set::iterator itor = unrolls.begin(); itor != unrolls.end(); itor++) { - expr_ref item(ctx.mk_eq_atom(var, *itor), mgr); + for (expr * e : unrolls) { + expr_ref item(ctx.mk_eq_atom(var, e), mgr); TRACE("str", tout << "considering unroll " << mk_pp(item, mgr) << std::endl;); litems.push_back(item); } @@ -9731,10 +9731,8 @@ namespace smt { ptr_vector outOfScopeTesters; - for (ptr_vector::iterator it = unroll_tries_map[var][unrolls].begin(); - it != unroll_tries_map[var][unrolls].end(); ++it) { - expr * tester = *it; - bool inScope = (internal_unrollTest_vars.find(tester) != internal_unrollTest_vars.end()); + for (expr * tester : unroll_tries_map[var][unrolls]) { + bool inScope = internal_unrollTest_vars.contains(tester); TRACE("str", tout << "unroll test var " << mk_pp(tester, mgr) << (inScope ? " in scope" : " out of scope") << std::endl;); @@ -9743,12 +9741,10 @@ namespace smt { } } - for (ptr_vector::iterator it = outOfScopeTesters.begin(); - it != outOfScopeTesters.end(); ++it) { - unroll_tries_map[var][unrolls].erase(*it); + for (expr* e : outOfScopeTesters) { + unroll_tries_map[var][unrolls].erase(e); } - if (unroll_tries_map[var][unrolls].size() == 0) { unroll_tries_map[var][unrolls].push_back(mk_unroll_test_var()); } @@ -10265,9 +10261,8 @@ namespace smt { // assume empty and find a counterexample map_effectively_empty = true; ptr_vector indicator_set = fvar_lenTester_map[freeVar]; - for (ptr_vector::iterator it = indicator_set.begin(); it != indicator_set.end(); ++it) { - expr * indicator = *it; - if (internal_variable_set.find(indicator) != internal_variable_set.end()) { + for (expr * indicator : indicator_set) { + if (internal_variable_set.contains(indicator)) { TRACE("str", tout <<"found active internal variable " << mk_ismt2_pp(indicator, m) << " in fvar_lenTester_map[freeVar]" << std::endl;); map_effectively_empty = false; @@ -10437,14 +10432,14 @@ namespace smt { void theory_str::process_free_var(std::map & freeVar_map) { context & ctx = get_context(); - std::set eqcRepSet; - std::set leafVarSet; - std::map > aloneVars; + obj_hashtable eqcRepSet; + obj_hashtable leafVarSet; + std::map > aloneVars; - for (std::map::iterator fvIt = freeVar_map.begin(); fvIt != freeVar_map.end(); fvIt++) { - expr * freeVar = fvIt->first; + for (auto const& kv : freeVar_map) { + expr * freeVar = kv.first; // skip all regular expression vars - if (regex_variable_set.find(freeVar) != regex_variable_set.end()) { + if (regex_variable_set.contains(freeVar)) { continue; } @@ -10454,10 +10449,10 @@ namespace smt { get_var_in_eqc(freeVar, eqVarSet); bool duplicated = false; expr * dupVar = nullptr; - for (std::set::iterator itorEqv = eqVarSet.begin(); itorEqv != eqVarSet.end(); itorEqv++) { - if (eqcRepSet.find(*itorEqv) != eqcRepSet.end()) { + for (expr* eq : eqVarSet) { + if (eqcRepSet.contains(eq)) { duplicated = true; - dupVar = *itorEqv; + dupVar = eq; break; } } @@ -10470,13 +10465,9 @@ namespace smt { } } - for (std::set::iterator fvIt = eqcRepSet.begin(); fvIt != eqcRepSet.end(); fvIt++) { - bool standAlone = true; - expr * freeVar = *fvIt; + for (expr * freeVar : eqcRepSet) { // has length constraint initially - if (input_var_in_len.find(freeVar) != input_var_in_len.end()) { - standAlone = false; - } + bool standAlone = !input_var_in_len.contains(freeVar); // iterate parents if (standAlone) { // I hope this works! @@ -10507,25 +10498,19 @@ namespace smt { } } - for(std::set::iterator itor1 = leafVarSet.begin(); - itor1 != leafVarSet.end(); ++itor1) { - expr * toAssert = gen_len_val_options_for_free_var(*itor1, nullptr, ""); + for (expr* lv : leafVarSet) { + expr * toAssert = gen_len_val_options_for_free_var(lv, nullptr, ""); // gen_len_val_options_for_free_var() can legally return NULL, // as methods that it calls may assert their own axioms instead. - if (toAssert != nullptr) { - assert_axiom(toAssert); - } + if (toAssert) assert_axiom(toAssert); + } - for (std::map >::iterator mItor = aloneVars.begin(); - mItor != aloneVars.end(); ++mItor) { - std::set::iterator itor2 = mItor->second.begin(); - for(; itor2 != mItor->second.end(); ++itor2) { - expr * toAssert = gen_len_val_options_for_free_var(*itor2, nullptr, ""); + for (auto const& kv : aloneVars) { + for (expr* av : kv.second) { + expr * toAssert = gen_len_val_options_for_free_var(av, nullptr, ""); // same deal with returning a NULL axiom here - if(toAssert != nullptr) { - assert_axiom(toAssert); - } + if (toAssert) assert_axiom(toAssert); } } } diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h index 508a1c905..0a8495b14 100644 --- a/src/smt/theory_str.h +++ b/src/smt/theory_str.h @@ -295,7 +295,8 @@ protected: obj_hashtable input_var_in_len; obj_map fvar_len_count_map; - std::map > fvar_lenTester_map; + // std::map > fvar_lenTester_map; + obj_map > fvar_lenTester_map; obj_map lenTester_fvar_map; // TBD: need to replace by obj_map for determinism diff --git a/src/util/hashtable.h b/src/util/hashtable.h index 742438814..4dc05fe4d 100644 --- a/src/util/hashtable.h +++ b/src/util/hashtable.h @@ -600,9 +600,8 @@ public: core_hashtable& operator|=(core_hashtable const& other) { if (this == &other) return *this; - iterator i = other.begin(), e = other.end(); - for (; i != e; ++i) { - insert(*i); + for (const data& d : other) { + insert(d); } return *this; } @@ -610,10 +609,9 @@ public: core_hashtable& operator&=(core_hashtable const& other) { if (this == &other) return *this; core_hashtable copy(*this); - iterator i = copy.begin(), e = copy.end(); - for (; i != e; ++i) { - if (!other.contains(*i)) { - remove(*i); + for (const data& d : copy) { + if (!other.contains(d)) { + remove(d); } } return *this; @@ -622,9 +620,8 @@ public: core_hashtable& operator=(core_hashtable const& other) { if (this == &other) return *this; reset(); - iterator i = other.begin(), e = other.end(); - for (; i != e; ++i) { - insert(*i); + for (const data& d : e) { + insert(d); } return *this; } diff --git a/src/util/obj_hashtable.h b/src/util/obj_hashtable.h index 8826e8b76..d042779a8 100644 --- a/src/util/obj_hashtable.h +++ b/src/util/obj_hashtable.h @@ -174,6 +174,9 @@ public: value & find(key * k) { obj_map_entry * e = find_core(k); + if (!e) { + e = insert_if_not_there2(k, value()); + } SASSERT(e); return e->get_data().m_value; } From 4529ad933ac92737e51fb90fbd3b9bdb9e100840 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Tue, 20 Mar 2018 15:19:05 -0700 Subject: [PATCH 068/109] add vstsmac Signed-off-by: Nikolaj Bjorner --- scripts/vsts-mac.sh | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 scripts/vsts-mac.sh diff --git a/scripts/vsts-mac.sh b/scripts/vsts-mac.sh new file mode 100644 index 000000000..807631bba --- /dev/null +++ b/scripts/vsts-mac.sh @@ -0,0 +1,9 @@ +#!/bin/sh + +mkdir build +CSC=/usr/bin/csc GACUTIL=/usr/bin/gacutil CXX=clang++ CC=clang python scripts/mk_make.py -x --dotnet --java --python +cd build +make + + + From 3765bde5e993d78cfbcf43a2999b45b18ed7866d Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Thu, 22 Mar 2018 20:19:08 -0700 Subject: [PATCH 069/109] updated OSX build Signed-off-by: Nikolaj Bjorner --- scripts/vsts-mac.sh | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/scripts/vsts-mac.sh b/scripts/vsts-mac.sh index 807631bba..9be53967f 100644 --- a/scripts/vsts-mac.sh +++ b/scripts/vsts-mac.sh @@ -1,9 +1,19 @@ #!/bin/sh +cd .. mkdir build -CSC=/usr/bin/csc GACUTIL=/usr/bin/gacutil CXX=clang++ CC=clang python scripts/mk_make.py -x --dotnet --java --python +CSC=/usr/bin/csc GACUTIL=/usr/bin/gacutil CXX=clang++ CC=clang python scripts/mk_make.py --java --python cd build make +make test-z3 +make cpp_example +make c_example +# make java_example +# make python_example +./cpp_example +./test_capi - +git clone https://github.com/z3prover/z3test.git z3test +ls +python z3test/scripts/test_benchmarks.py ./z3 ./z3test/regressions/smt2 From 705439cb85d00453a2f3ed446d965de34393688e Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Thu, 22 Mar 2018 20:22:42 -0700 Subject: [PATCH 070/109] update build definition to 4 Signed-off-by: Nikolaj Bjorner --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index d501c5d5c..e3ef58b70 100644 --- a/README.md +++ b/README.md @@ -14,7 +14,7 @@ See the [release notes](RELEASE_NOTES) for notes on various stable releases of Z | Windows x64 | Windows x86 | Windows x64 | Ubuntu x64 | Debian x64 | OSX | TravisCI | | ----------- | ----------- | ----------- | ---------- | ---------- | --- | -------- | -[![win64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/4/badge)](https://z3build.visualstudio.com/Z3Build/_build/index?definitionId=2) | [![win32-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/4/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=4) | [![win64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/7/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=7) | [![ubuntu-x64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/3/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=3) | [![debian-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/5/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=5) | [![osx-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/2/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=2) | [![Build Status](https://travis-ci.org/Z3Prover/z3.svg?branch=master)](https://travis-ci.org/Z3Prover/z3) +[![win64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/4/badge)](https://z3build.visualstudio.com/Z3Build/_build/index?definitionId=4) | [![win32-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/4/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=4) | [![win64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/7/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=7) | [![ubuntu-x64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/3/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=3) | [![debian-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/5/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=5) | [![osx-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/2/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=2) | [![Build Status](https://travis-ci.org/Z3Prover/z3.svg?branch=master)](https://travis-ci.org/Z3Prover/z3) [1]: #building-z3-on-windows-using-visual-studio-command-prompt [2]: #building-z3-using-make-and-gccclang From 966a8f73d33d9ed011286c6fb62fbf6f5449112f Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Fri, 23 Mar 2018 16:26:20 -0700 Subject: [PATCH 071/109] add eval feature #1553 Signed-off-by: Nikolaj Bjorner --- src/api/api_context.h | 3 +++ src/api/api_parsers.cpp | 27 +++++++++++++++++++++++++++ src/api/z3_api.h | 11 +++++++++++ 3 files changed, 41 insertions(+) diff --git a/src/api/api_context.h b/src/api/api_context.h index 7009250cc..185eb9e0f 100644 --- a/src/api/api_context.h +++ b/src/api/api_context.h @@ -34,6 +34,7 @@ Revision History: #include "util/event_handler.h" #include "cmd_context/tactic_manager.h" #include "cmd_context/context_params.h" +#include "cmd_context/cmd_context.h" #include "api/api_polynomial.h" #include "util/hashtable.h" @@ -53,6 +54,7 @@ namespace api { context_params m_params; bool m_user_ref_count; //!< if true, the user is responsible for managing reference counters. scoped_ptr m_manager; + scoped_ptr m_cmd; add_plugins m_plugins; arith_util m_arith_util; @@ -114,6 +116,7 @@ namespace api { ast_manager & m() const { return *(m_manager.get()); } context_params & params() { return m_params; } + scoped_ptr& cmd() { return m_cmd; } bool produce_proofs() const { return m().proofs_enabled(); } bool produce_models() const { return m_params.m_model; } bool produce_unsat_cores() const { return m_params.m_unsat_core; } diff --git a/src/api/api_parsers.cpp b/src/api/api_parsers.cpp index 2e33c1a13..830bef7a8 100644 --- a/src/api/api_parsers.cpp +++ b/src/api/api_parsers.cpp @@ -117,4 +117,31 @@ extern "C" { RETURN_Z3(r); Z3_CATCH_RETURN(nullptr); } + + Z3_string Z3_API Z3_eval_smtlib2_string(Z3_context c, Z3_string str) { + Z3_TRY; + LOG_Z3_eval_smtlib2_string(c, str); + if (!mk_c(c)->cmd()) { + mk_c(c)->cmd() = alloc(cmd_context, false, &(mk_c(c)->m())); + } + scoped_ptr& ctx = mk_c(c)->cmd(); + std::string s(str); + std::istringstream is(s); + std::stringstream ous; + ctx->set_regular_stream(ous); + try { + if (!parse_smt2_commands(*ctx.get(), is)) { + mk_c(c)->m_parser_error_buffer = ous.str(); + SET_ERROR_CODE(Z3_PARSER_ERROR); + RETURN_Z3(nullptr); + } + } + catch (z3_exception& e) { + mk_c(c)->m_parser_error_buffer = e.msg(); + SET_ERROR_CODE(Z3_PARSER_ERROR); + RETURN_Z3(nullptr); + } + RETURN_Z3(mk_c(c)->mk_external_string(ous.str())); + Z3_CATCH_RETURN(nullptr); + } }; diff --git a/src/api/z3_api.h b/src/api/z3_api.h index 87bb4d818..50ed85c70 100644 --- a/src/api/z3_api.h +++ b/src/api/z3_api.h @@ -5209,6 +5209,17 @@ extern "C" { Z3_func_decl const decls[]); + /** + \brief Parse and evaluate and SMT-LIB2 command sequence. The state from a previous call is saved so the next + evaluation builds on top of the previous call. + + \returns output generated from processing commands. + + def_API('Z3_eval_smtlib2_string', STRING, (_in(CONTEXT), _in(STRING),)) + */ + + Z3_string Z3_API Z3_eval_smtlib2_string(Z3_context, Z3_string str); + /** \brief Retrieve that last error message information generated from parsing. From 753f2c89ef70890253b930ec74220aafc209dcbd Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Fri, 23 Mar 2018 18:54:06 -0700 Subject: [PATCH 072/109] initialize solvers to ensure that eval mode has a solver Signed-off-by: Nikolaj Bjorner --- src/api/api_parsers.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/api/api_parsers.cpp b/src/api/api_parsers.cpp index 830bef7a8..3af2e567c 100644 --- a/src/api/api_parsers.cpp +++ b/src/api/api_parsers.cpp @@ -21,8 +21,11 @@ Revision History: #include "api/api_context.h" #include "api/api_util.h" #include "cmd_context/cmd_context.h" +#include "smt/smt_solver.h" #include "parsers/smt2/smt2parser.h" #include "solver/solver_na2as.h" +#include "tactic/portfolio/smt_strategic_solver.h" + extern "C" { @@ -123,6 +126,7 @@ extern "C" { LOG_Z3_eval_smtlib2_string(c, str); if (!mk_c(c)->cmd()) { mk_c(c)->cmd() = alloc(cmd_context, false, &(mk_c(c)->m())); + mk_c(c)->cmd()->set_solver_factory(mk_smt_strategic_solver_factory()); } scoped_ptr& ctx = mk_c(c)->cmd(); std::string s(str); From fc719a5ee82361ffedb9ef46793e3401fdc32cc5 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Sat, 24 Mar 2018 10:37:05 -0700 Subject: [PATCH 073/109] fix diagnostic output #1553 Signed-off-by: Nikolaj Bjorner --- src/api/api_parsers.cpp | 12 +++++++----- src/cmd_context/cmd_context.h | 1 + 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/src/api/api_parsers.cpp b/src/api/api_parsers.cpp index 3af2e567c..28db62cc3 100644 --- a/src/api/api_parsers.cpp +++ b/src/api/api_parsers.cpp @@ -122,6 +122,7 @@ extern "C" { } Z3_string Z3_API Z3_eval_smtlib2_string(Z3_context c, Z3_string str) { + std::stringstream ous; Z3_TRY; LOG_Z3_eval_smtlib2_string(c, str); if (!mk_c(c)->cmd()) { @@ -131,21 +132,22 @@ extern "C" { scoped_ptr& ctx = mk_c(c)->cmd(); std::string s(str); std::istringstream is(s); - std::stringstream ous; ctx->set_regular_stream(ous); + ctx->set_diagnostic_stream(ous); try { if (!parse_smt2_commands(*ctx.get(), is)) { mk_c(c)->m_parser_error_buffer = ous.str(); SET_ERROR_CODE(Z3_PARSER_ERROR); - RETURN_Z3(nullptr); + RETURN_Z3(mk_c(c)->mk_external_string(ous.str())); } } catch (z3_exception& e) { - mk_c(c)->m_parser_error_buffer = e.msg(); + if (ous.str().empty()) ous << e.msg(); + mk_c(c)->m_parser_error_buffer = ous.str(); SET_ERROR_CODE(Z3_PARSER_ERROR); - RETURN_Z3(nullptr); + RETURN_Z3(mk_c(c)->mk_external_string(ous.str())); } RETURN_Z3(mk_c(c)->mk_external_string(ous.str())); - Z3_CATCH_RETURN(nullptr); + Z3_CATCH_RETURN(mk_c(c)->mk_external_string(ous.str())); } }; diff --git a/src/cmd_context/cmd_context.h b/src/cmd_context/cmd_context.h index d1e470c3b..90b3f6c56 100644 --- a/src/cmd_context/cmd_context.h +++ b/src/cmd_context/cmd_context.h @@ -406,6 +406,7 @@ public: void reset_user_tactics(); void set_regular_stream(char const * name) { m_regular.set(name); } void set_regular_stream(std::ostream& out) { m_regular.set(out); } + void set_diagnostic_stream(std::ostream& out) { m_diagnostic.set(out); } void set_diagnostic_stream(char const * name); std::ostream & regular_stream() override { return *m_regular; } std::ostream & diagnostic_stream() override { return *m_diagnostic; } From bd2ed196e3afde3d575affd127c42503dfde04c2 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Sun, 25 Mar 2018 19:36:21 -0700 Subject: [PATCH 074/109] add correct badge Signed-off-by: Nikolaj Bjorner --- README.md | 2 +- src/opt/opt_solver.cpp | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index e3ef58b70..8ebf6a078 100644 --- a/README.md +++ b/README.md @@ -14,7 +14,7 @@ See the [release notes](RELEASE_NOTES) for notes on various stable releases of Z | Windows x64 | Windows x86 | Windows x64 | Ubuntu x64 | Debian x64 | OSX | TravisCI | | ----------- | ----------- | ----------- | ---------- | ---------- | --- | -------- | -[![win64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/4/badge)](https://z3build.visualstudio.com/Z3Build/_build/index?definitionId=4) | [![win32-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/4/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=4) | [![win64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/7/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=7) | [![ubuntu-x64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/3/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=3) | [![debian-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/5/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=5) | [![osx-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/2/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=2) | [![Build Status](https://travis-ci.org/Z3Prover/z3.svg?branch=master)](https://travis-ci.org/Z3Prover/z3) +[![win64-badge](https://z3build.visualstudio.com/_apis/public/build/definitions/2e0aa542-a22c-4b1a-8dcd-3ebae8e12db4/4/badge)](https://z3build.visualstudio.com/Z3Build/_build/index?definitionId=4) | [![win32-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/4/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=4) | [![win64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/7/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=7) | [![ubuntu-x64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/3/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=3) | [![debian-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/5/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=5) | [![osx-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/2/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=2) | [![Build Status](https://travis-ci.org/Z3Prover/z3.svg?branch=master)](https://travis-ci.org/Z3Prover/z3) [1]: #building-z3-on-windows-using-visual-studio-command-prompt [2]: #building-z3-using-make-and-gccclang diff --git a/src/opt/opt_solver.cpp b/src/opt/opt_solver.cpp index c5363816a..785836f56 100644 --- a/src/opt/opt_solver.cpp +++ b/src/opt/opt_solver.cpp @@ -229,6 +229,7 @@ namespace opt { inf_eps val = get_optimizer().maximize(v, blocker, has_shared); get_model(m_model); inf_eps val2; + std::cout << m_valid_objectives.size() << " " << i << "\n"; m_valid_objectives[i] = true; TRACE("opt", tout << (has_shared?"has shared":"non-shared") << "\n";); if (!m_models[i]) { @@ -341,6 +342,7 @@ namespace opt { smt::theory_var opt_solver::add_objective(app* term) { smt::theory_var v = get_optimizer().add_objective(term); + std::cout << "add objective " << v << "\n"; m_objective_vars.push_back(v); m_objective_values.push_back(inf_eps(rational(-1), inf_rational())); m_objective_terms.push_back(term); @@ -436,6 +438,7 @@ namespace opt { } void opt_solver::reset_objectives() { + std::cout << "reset-objectives\n"; m_objective_vars.reset(); m_objective_values.reset(); m_objective_terms.reset(); From 88e777748ad94c097ff8d2e00359107a9f4aba76 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Sun, 25 Mar 2018 19:37:19 -0700 Subject: [PATCH 075/109] remove stdout Signed-off-by: Nikolaj Bjorner --- src/opt/opt_solver.cpp | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/opt/opt_solver.cpp b/src/opt/opt_solver.cpp index 785836f56..c5363816a 100644 --- a/src/opt/opt_solver.cpp +++ b/src/opt/opt_solver.cpp @@ -229,7 +229,6 @@ namespace opt { inf_eps val = get_optimizer().maximize(v, blocker, has_shared); get_model(m_model); inf_eps val2; - std::cout << m_valid_objectives.size() << " " << i << "\n"; m_valid_objectives[i] = true; TRACE("opt", tout << (has_shared?"has shared":"non-shared") << "\n";); if (!m_models[i]) { @@ -342,7 +341,6 @@ namespace opt { smt::theory_var opt_solver::add_objective(app* term) { smt::theory_var v = get_optimizer().add_objective(term); - std::cout << "add objective " << v << "\n"; m_objective_vars.push_back(v); m_objective_values.push_back(inf_eps(rational(-1), inf_rational())); m_objective_terms.push_back(term); @@ -438,7 +436,6 @@ namespace opt { } void opt_solver::reset_objectives() { - std::cout << "reset-objectives\n"; m_objective_vars.reset(); m_objective_values.reset(); m_objective_terms.reset(); From 78744e589c5a3213929b09174fb19bfb0abf6ee0 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Tue, 27 Mar 2018 12:19:24 -0700 Subject: [PATCH 076/109] add stdbool.h Signed-off-by: Nikolaj Bjorner --- src/api/z3.h | 1 + 1 file changed, 1 insertion(+) diff --git a/src/api/z3.h b/src/api/z3.h index e08b0c073..b29f1d6ba 100644 --- a/src/api/z3.h +++ b/src/api/z3.h @@ -22,6 +22,7 @@ Notes: #define Z3_H_ #include +#include #include "z3_macros.h" #include "z3_api.h" #include "z3_ast_containers.h" From 76dec85c93233922d4c79eb98c2b6c237e8c3b15 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Tue, 27 Mar 2018 15:41:53 -0700 Subject: [PATCH 077/109] use stdbool #1526 instead of int Signed-off-by: Nikolaj Bjorner --- scripts/update_api.py | 7 ++++++- src/api/z3_api.h | 2 +- src/api/z3_replayer.cpp | 10 ++++++++++ src/api/z3_replayer.h | 1 + 4 files changed, 18 insertions(+), 2 deletions(-) diff --git a/scripts/update_api.py b/scripts/update_api.py index 18878d6ea..0a86db18d 100755 --- a/scripts/update_api.py +++ b/scripts/update_api.py @@ -957,11 +957,16 @@ def def_API(name, result, params): log_c.write(" }\n") log_c.write(" Au(a%s);\n" % sz) exe_c.write("in.get_uint_array(%s)" % i) - elif ty == INT or ty == BOOL: + elif ty == INT: log_c.write("U(a%s[i]);" % i) log_c.write(" }\n") log_c.write(" Au(a%s);\n" % sz) exe_c.write("in.get_int_array(%s)" % i) + elif ty == BOOL: + log_c.write("U(a%s[i]);" % i) + log_c.write(" }\n") + log_c.write(" Au(a%s);\n" % sz) + exe_c.write("in.get_bool_array(%s)" % i) else: error ("unsupported parameter for %s, %s, %s" % (ty, name, p)) elif kind == OUT_ARRAY: diff --git a/src/api/z3_api.h b/src/api/z3_api.h index 50ed85c70..ab570581b 100644 --- a/src/api/z3_api.h +++ b/src/api/z3_api.h @@ -82,7 +82,7 @@ DEFINE_TYPE(Z3_rcf_num); /** \brief Z3 Boolean type. It is just an alias for \c int. */ -typedef int Z3_bool; +typedef bool Z3_bool; /** \brief Z3 string type. It is just an alias for \ccode{const char *}. diff --git a/src/api/z3_replayer.cpp b/src/api/z3_replayer.cpp index 1515e6df7..fde9b1f48 100644 --- a/src/api/z3_replayer.cpp +++ b/src/api/z3_replayer.cpp @@ -630,6 +630,12 @@ struct z3_replayer::imp { return m_int_arrays[idx].c_ptr(); } + bool * get_bool_array(unsigned pos) const { + check_arg(pos, UINT_ARRAY); + unsigned idx = static_cast(m_args[pos].m_uint); + return reinterpret_cast(m_unsigned_arrays[idx].c_ptr()); + } + Z3_symbol * get_symbol_array(unsigned pos) const { check_arg(pos, SYMBOL_ARRAY); unsigned idx = static_cast(m_args[pos].m_uint); @@ -761,6 +767,10 @@ int * z3_replayer::get_int_array(unsigned pos) const { return m_imp->get_int_array(pos); } +bool * z3_replayer::get_bool_array(unsigned pos) const { + return m_imp->get_bool_array(pos); +} + Z3_symbol * z3_replayer::get_symbol_array(unsigned pos) const { return m_imp->get_symbol_array(pos); } diff --git a/src/api/z3_replayer.h b/src/api/z3_replayer.h index e1b32af75..b81659945 100644 --- a/src/api/z3_replayer.h +++ b/src/api/z3_replayer.h @@ -51,6 +51,7 @@ public: unsigned * get_uint_array(unsigned pos) const; int * get_int_array(unsigned pos) const; + bool * get_bool_array(unsigned pos) const; Z3_symbol * get_symbol_array(unsigned pos) const; void ** get_obj_array(unsigned pos) const; From 32c9af5e5a4b119dc09eaae2bd05acf5ec7859db Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Tue, 27 Mar 2018 16:16:25 -0700 Subject: [PATCH 078/109] fix use of Z3_bool -> Z3_lbool Signed-off-by: Nikolaj Bjorner --- examples/c/test_capi.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/examples/c/test_capi.c b/examples/c/test_capi.c index b947928a7..c2b1f0af9 100644 --- a/examples/c/test_capi.c +++ b/examples/c/test_capi.c @@ -2452,7 +2452,6 @@ Z3_lbool ext_check(Z3_ext_context ctx) { } printf("\n"); } - return result; } @@ -2464,7 +2463,7 @@ void incremental_example1() { Z3_context ctx = ext_ctx->m_context; Z3_ast x, y, z, two, one; unsigned c1, c2, c3, c4; - Z3_bool result; + Z3_lbool result; printf("\nincremental_example1\n"); LOG_MSG("incremental_example1"); @@ -2485,7 +2484,7 @@ void incremental_example1() { c4 = assert_retractable_cnstr(ext_ctx, Z3_mk_lt(ctx, y, one)); result = ext_check(ext_ctx); - if (result != Z3_L_FALSE) + if (result != Z3_L_FALSE) exitf("bug in Z3"); printf("unsat\n"); From b9f2188fc02c0e171103b383a8684a5199a3c232 Mon Sep 17 00:00:00 2001 From: Bruce Mitchener Date: Fri, 30 Mar 2018 22:34:07 +0700 Subject: [PATCH 079/109] Update Z3_bool doc. --- src/api/z3_api.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/api/z3_api.h b/src/api/z3_api.h index ab570581b..2b46127fa 100644 --- a/src/api/z3_api.h +++ b/src/api/z3_api.h @@ -80,7 +80,7 @@ DEFINE_TYPE(Z3_rcf_num); */ /** - \brief Z3 Boolean type. It is just an alias for \c int. + \brief Z3 Boolean type. It is just an alias for \c bool. */ typedef bool Z3_bool; From 16a2ad9afd8bed86fc7d5d2f40ca3d48b7fedd07 Mon Sep 17 00:00:00 2001 From: Bruce Mitchener Date: Fri, 30 Mar 2018 23:06:24 +0700 Subject: [PATCH 080/109] Use stdint.h for int64_t / uint64_t in API. Now that we can use stdint.h, we can use it to portably define 64 bit integer types for use in the API. --- scripts/update_api.py | 5 +---- src/api/api_datalog.cpp | 4 ++-- src/api/api_fpa.cpp | 6 +++--- src/api/api_numeral.cpp | 16 +++++++------- src/api/api_stats.cpp | 2 +- src/api/c++/z3++.h | 48 ++++++++++++++++++++--------------------- src/api/z3.h | 1 + src/api/z3_api.h | 36 ++++++++++++------------------- src/api/z3_fpa.h | 6 +++--- src/api/z3_logger.h | 4 ++-- src/api/z3_replayer.cpp | 32 +++++++++++++-------------- src/api/z3_replayer.h | 8 +++---- 12 files changed, 79 insertions(+), 89 deletions(-) diff --git a/scripts/update_api.py b/scripts/update_api.py index 0a86db18d..8a7b33efd 100755 --- a/scripts/update_api.py +++ b/scripts/update_api.py @@ -60,7 +60,7 @@ FIRST_OBJ_ID = 100 def is_obj(ty): return ty >= FIRST_OBJ_ID -Type2Str = { VOID : 'void', VOID_PTR : 'void*', INT : 'int', UINT : 'unsigned', INT64 : '__int64', UINT64 : '__uint64', DOUBLE : 'double', +Type2Str = { VOID : 'void', VOID_PTR : 'void*', INT : 'int', UINT : 'unsigned', INT64 : 'int64_t', UINT64 : 'uint64_t', DOUBLE : 'double', FLOAT : 'float', STRING : 'Z3_string', STRING_PTR : 'Z3_string_ptr', BOOL : 'Z3_bool', SYMBOL : 'Z3_symbol', PRINT_MODE : 'Z3_ast_print_mode', ERROR_CODE : 'Z3_error_code' } @@ -577,9 +577,6 @@ def mk_java(java_dir, package_name): java_wrapper = open(java_wrapperf, 'w') pkg_str = package_name.replace('.', '_') java_wrapper.write('// Automatically generated file\n') - java_wrapper.write('#ifdef _CYGWIN\n') - java_wrapper.write('typedef long long __int64;\n') - java_wrapper.write('#endif\n') java_wrapper.write('#include\n') java_wrapper.write('#include\n') java_wrapper.write('#include"z3.h"\n') diff --git a/src/api/api_datalog.cpp b/src/api/api_datalog.cpp index 5e0082f09..ce2373498 100644 --- a/src/api/api_datalog.cpp +++ b/src/api/api_datalog.cpp @@ -189,7 +189,7 @@ extern "C" { Z3_CATCH_RETURN(nullptr); } - Z3_sort Z3_API Z3_mk_finite_domain_sort(Z3_context c, Z3_symbol name, __uint64 size) { + Z3_sort Z3_API Z3_mk_finite_domain_sort(Z3_context c, Z3_symbol name, uint64_t size) { Z3_TRY; LOG_Z3_mk_finite_domain_sort(c, name, size); RESET_ERROR_CODE(); @@ -199,7 +199,7 @@ extern "C" { Z3_CATCH_RETURN(nullptr); } - Z3_bool Z3_API Z3_get_finite_domain_sort_size(Z3_context c, Z3_sort s, __uint64 * out) { + Z3_bool Z3_API Z3_get_finite_domain_sort_size(Z3_context c, Z3_sort s, uint64_t * out) { Z3_TRY; if (out) { *out = 0; diff --git a/src/api/api_fpa.cpp b/src/api/api_fpa.cpp index 972505ca2..261198354 100644 --- a/src/api/api_fpa.cpp +++ b/src/api/api_fpa.cpp @@ -358,7 +358,7 @@ extern "C" { Z3_CATCH_RETURN(nullptr); } - Z3_ast Z3_API Z3_mk_fpa_numeral_int64_uint64(Z3_context c, Z3_bool sgn, __int64 exp, __uint64 sig, Z3_sort ty) { + Z3_ast Z3_API Z3_mk_fpa_numeral_int64_uint64(Z3_context c, Z3_bool sgn, int64_t exp, uint64_t sig, Z3_sort ty) { Z3_TRY; LOG_Z3_mk_fpa_numeral_int64_uint64(c, sgn, exp, sig, ty); RESET_ERROR_CODE(); @@ -1035,7 +1035,7 @@ extern "C" { Z3_CATCH_RETURN(""); } - Z3_bool Z3_API Z3_fpa_get_numeral_significand_uint64(Z3_context c, Z3_ast t, __uint64 * n) { + Z3_bool Z3_API Z3_fpa_get_numeral_significand_uint64(Z3_context c, Z3_ast t, uint64_t * n) { Z3_TRY; LOG_Z3_fpa_get_numeral_significand_uint64(c, t, n); RESET_ERROR_CODE(); @@ -1113,7 +1113,7 @@ extern "C" { Z3_CATCH_RETURN(""); } - Z3_bool Z3_API Z3_fpa_get_numeral_exponent_int64(Z3_context c, Z3_ast t, __int64 * n, Z3_bool biased) { + Z3_bool Z3_API Z3_fpa_get_numeral_exponent_int64(Z3_context c, Z3_ast t, int64_t * n, Z3_bool biased) { Z3_TRY; LOG_Z3_fpa_get_numeral_exponent_int64(c, t, n, biased); RESET_ERROR_CODE(); diff --git a/src/api/api_numeral.cpp b/src/api/api_numeral.cpp index 5aa762a96..ab379c3de 100644 --- a/src/api/api_numeral.cpp +++ b/src/api/api_numeral.cpp @@ -116,7 +116,7 @@ extern "C" { Z3_CATCH_RETURN(nullptr); } - Z3_ast Z3_API Z3_mk_int64(Z3_context c, long long value, Z3_sort ty) { + Z3_ast Z3_API Z3_mk_int64(Z3_context c, int64_t value, Z3_sort ty) { Z3_TRY; LOG_Z3_mk_int64(c, value, ty); RESET_ERROR_CODE(); @@ -129,7 +129,7 @@ extern "C" { Z3_CATCH_RETURN(nullptr); } - Z3_ast Z3_API Z3_mk_unsigned_int64(Z3_context c, unsigned long long value, Z3_sort ty) { + Z3_ast Z3_API Z3_mk_unsigned_int64(Z3_context c, uint64_t value, Z3_sort ty) { Z3_TRY; LOG_Z3_mk_unsigned_int64(c, value, ty); RESET_ERROR_CODE(); @@ -262,7 +262,7 @@ extern "C" { Z3_CATCH_RETURN(""); } - Z3_bool Z3_API Z3_get_numeral_small(Z3_context c, Z3_ast a, long long* num, long long* den) { + Z3_bool Z3_API Z3_get_numeral_small(Z3_context c, Z3_ast a, int64_t* num, int64_t* den) { Z3_TRY; // This function invokes Z3_get_numeral_rational, but it is still ok to add LOG command here because it does not return a Z3 object. LOG_Z3_get_numeral_small(c, a, num, den); @@ -296,7 +296,7 @@ extern "C" { SET_ERROR_CODE(Z3_INVALID_ARG); return Z3_FALSE; } - long long l; + int64_t l; if (Z3_get_numeral_int64(c, v, &l) && l >= INT_MIN && l <= INT_MAX) { *i = static_cast(l); return Z3_TRUE; @@ -314,7 +314,7 @@ extern "C" { SET_ERROR_CODE(Z3_INVALID_ARG); return Z3_FALSE; } - unsigned long long l; + uint64_t l; if (Z3_get_numeral_uint64(c, v, &l) && (l <= 0xFFFFFFFF)) { *u = static_cast(l); return Z3_TRUE; @@ -323,7 +323,7 @@ extern "C" { Z3_CATCH_RETURN(Z3_FALSE); } - Z3_bool Z3_API Z3_get_numeral_uint64(Z3_context c, Z3_ast v, unsigned long long* u) { + Z3_bool Z3_API Z3_get_numeral_uint64(Z3_context c, Z3_ast v, uint64_t* u) { Z3_TRY; // This function invokes Z3_get_numeral_rational, but it is still ok to add LOG command here because it does not return a Z3 object. LOG_Z3_get_numeral_uint64(c, v, u); @@ -343,7 +343,7 @@ extern "C" { Z3_CATCH_RETURN(Z3_FALSE); } - Z3_bool Z3_API Z3_get_numeral_int64(Z3_context c, Z3_ast v, long long* i) { + Z3_bool Z3_API Z3_get_numeral_int64(Z3_context c, Z3_ast v, int64_t* i) { Z3_TRY; // This function invokes Z3_get_numeral_rational, but it is still ok to add LOG command here because it does not return a Z3 object. LOG_Z3_get_numeral_int64(c, v, i); @@ -362,7 +362,7 @@ extern "C" { Z3_CATCH_RETURN(Z3_FALSE); } - Z3_bool Z3_API Z3_get_numeral_rational_int64(Z3_context c, Z3_ast v, long long* num, long long* den) { + Z3_bool Z3_API Z3_get_numeral_rational_int64(Z3_context c, Z3_ast v, int64_t* num, int64_t* den) { Z3_TRY; // This function invokes Z3_get_numeral_rational, but it is still ok to add LOG command here because it does not return a Z3 object. LOG_Z3_get_numeral_rational_int64(c, v, num, den); diff --git a/src/api/api_stats.cpp b/src/api/api_stats.cpp index a92b908dc..2e1dac4de 100644 --- a/src/api/api_stats.cpp +++ b/src/api/api_stats.cpp @@ -130,7 +130,7 @@ extern "C" { Z3_CATCH_RETURN(0.0); } - __uint64 Z3_API Z3_get_estimated_alloc_size(void) { + uint64_t Z3_API Z3_get_estimated_alloc_size(void) { return memory::get_allocation_size(); } diff --git a/src/api/c++/z3++.h b/src/api/c++/z3++.h index 42467cb22..b3df2d53a 100644 --- a/src/api/c++/z3++.h +++ b/src/api/c++/z3++.h @@ -294,21 +294,21 @@ namespace z3 { expr int_val(int n); expr int_val(unsigned n); - expr int_val(__int64 n); - expr int_val(__uint64 n); + expr int_val(int64_t n); + expr int_val(uint64_t n); expr int_val(char const * n); expr real_val(int n, int d); expr real_val(int n); expr real_val(unsigned n); - expr real_val(__int64 n); - expr real_val(__uint64 n); + expr real_val(int64_t n); + expr real_val(uint64_t n); expr real_val(char const * n); expr bv_val(int n, unsigned sz); expr bv_val(unsigned n, unsigned sz); - expr bv_val(__int64 n, unsigned sz); - expr bv_val(__uint64 n, unsigned sz); + expr bv_val(int64_t n, unsigned sz); + expr bv_val(uint64_t n, unsigned sz); expr bv_val(char const * n, unsigned sz); expr bv_val(unsigned n, bool const* bits); @@ -660,8 +660,8 @@ namespace z3 { small integers, 64 bit integers or rational or decimal strings. */ bool is_numeral() const { return kind() == Z3_NUMERAL_AST; } - bool is_numeral_i64(__int64& i) const { bool r = 0 != Z3_get_numeral_int64(ctx(), m_ast, &i); check_error(); return r;} - bool is_numeral_u64(__uint64& i) const { bool r = 0 != Z3_get_numeral_uint64(ctx(), m_ast, &i); check_error(); return r;} + bool is_numeral_i64(int64_t& i) const { bool r = 0 != Z3_get_numeral_int64(ctx(), m_ast, &i); check_error(); return r;} + bool is_numeral_u64(uint64_t& i) const { bool r = 0 != Z3_get_numeral_uint64(ctx(), m_ast, &i); check_error(); return r;} bool is_numeral_i(int& i) const { bool r = 0 != Z3_get_numeral_int(ctx(), m_ast, &i); check_error(); return r;} bool is_numeral_u(unsigned& i) const { bool r = 0 != Z3_get_numeral_uint(ctx(), m_ast, &i); check_error(); return r;} bool is_numeral(std::string& s) const { if (!is_numeral()) return false; s = Z3_get_numeral_string(ctx(), m_ast); check_error(); return true; } @@ -744,35 +744,35 @@ namespace z3 { } /** - \brief Return __int64 value of numeral, throw if result cannot fit in - __int64 + \brief Return \c int64_t value of numeral, throw if result cannot fit in + \c int64_t. \pre is_numeral() */ - __int64 get_numeral_int64() const { + int64_t get_numeral_int64() const { assert(is_numeral()); - __int64 result = 0; + int64_t result = 0; if (!is_numeral_i64(result)) { assert(ctx().enable_exceptions()); if (!ctx().enable_exceptions()) return 0; - Z3_THROW(exception("numeral does not fit in machine __int64")); + Z3_THROW(exception("numeral does not fit in machine int64_t")); } return result; } /** - \brief Return __uint64 value of numeral, throw if result cannot fit in - __uint64 + \brief Return \c uint64_t value of numeral, throw if result cannot fit in + \c uint64_t. \pre is_numeral() */ - __uint64 get_numeral_uint64() const { + uint64_t get_numeral_uint64() const { assert(is_numeral()); - __uint64 result = 0; + uint64_t result = 0; if (!is_numeral_u64(result)) { assert(ctx().enable_exceptions()); if (!ctx().enable_exceptions()) return 0; - Z3_THROW(exception("numeral does not fit in machine __uint64")); + Z3_THROW(exception("numeral does not fit in machine uint64_t")); } return result; } @@ -2526,21 +2526,21 @@ namespace z3 { inline expr context::int_val(int n) { Z3_ast r = Z3_mk_int(m_ctx, n, int_sort()); check_error(); return expr(*this, r); } inline expr context::int_val(unsigned n) { Z3_ast r = Z3_mk_unsigned_int(m_ctx, n, int_sort()); check_error(); return expr(*this, r); } - inline expr context::int_val(__int64 n) { Z3_ast r = Z3_mk_int64(m_ctx, n, int_sort()); check_error(); return expr(*this, r); } - inline expr context::int_val(__uint64 n) { Z3_ast r = Z3_mk_unsigned_int64(m_ctx, n, int_sort()); check_error(); return expr(*this, r); } + inline expr context::int_val(int64_t n) { Z3_ast r = Z3_mk_int64(m_ctx, n, int_sort()); check_error(); return expr(*this, r); } + inline expr context::int_val(uint64_t n) { Z3_ast r = Z3_mk_unsigned_int64(m_ctx, n, int_sort()); check_error(); return expr(*this, r); } inline expr context::int_val(char const * n) { Z3_ast r = Z3_mk_numeral(m_ctx, n, int_sort()); check_error(); return expr(*this, r); } inline expr context::real_val(int n, int d) { Z3_ast r = Z3_mk_real(m_ctx, n, d); check_error(); return expr(*this, r); } inline expr context::real_val(int n) { Z3_ast r = Z3_mk_int(m_ctx, n, real_sort()); check_error(); return expr(*this, r); } inline expr context::real_val(unsigned n) { Z3_ast r = Z3_mk_unsigned_int(m_ctx, n, real_sort()); check_error(); return expr(*this, r); } - inline expr context::real_val(__int64 n) { Z3_ast r = Z3_mk_int64(m_ctx, n, real_sort()); check_error(); return expr(*this, r); } - inline expr context::real_val(__uint64 n) { Z3_ast r = Z3_mk_unsigned_int64(m_ctx, n, real_sort()); check_error(); return expr(*this, r); } + inline expr context::real_val(int64_t n) { Z3_ast r = Z3_mk_int64(m_ctx, n, real_sort()); check_error(); return expr(*this, r); } + inline expr context::real_val(uint64_t n) { Z3_ast r = Z3_mk_unsigned_int64(m_ctx, n, real_sort()); check_error(); return expr(*this, r); } inline expr context::real_val(char const * n) { Z3_ast r = Z3_mk_numeral(m_ctx, n, real_sort()); check_error(); return expr(*this, r); } inline expr context::bv_val(int n, unsigned sz) { sort s = bv_sort(sz); Z3_ast r = Z3_mk_int(m_ctx, n, s); check_error(); return expr(*this, r); } inline expr context::bv_val(unsigned n, unsigned sz) { sort s = bv_sort(sz); Z3_ast r = Z3_mk_unsigned_int(m_ctx, n, s); check_error(); return expr(*this, r); } - inline expr context::bv_val(__int64 n, unsigned sz) { sort s = bv_sort(sz); Z3_ast r = Z3_mk_int64(m_ctx, n, s); check_error(); return expr(*this, r); } - inline expr context::bv_val(__uint64 n, unsigned sz) { sort s = bv_sort(sz); Z3_ast r = Z3_mk_unsigned_int64(m_ctx, n, s); check_error(); return expr(*this, r); } + inline expr context::bv_val(int64_t n, unsigned sz) { sort s = bv_sort(sz); Z3_ast r = Z3_mk_int64(m_ctx, n, s); check_error(); return expr(*this, r); } + inline expr context::bv_val(uint64_t n, unsigned sz) { sort s = bv_sort(sz); Z3_ast r = Z3_mk_unsigned_int64(m_ctx, n, s); check_error(); return expr(*this, r); } inline expr context::bv_val(char const * n, unsigned sz) { sort s = bv_sort(sz); Z3_ast r = Z3_mk_numeral(m_ctx, n, s); check_error(); return expr(*this, r); } inline expr context::bv_val(unsigned n, bool const* bits) { array _bits(n); diff --git a/src/api/z3.h b/src/api/z3.h index b29f1d6ba..37ea68f84 100644 --- a/src/api/z3.h +++ b/src/api/z3.h @@ -23,6 +23,7 @@ Notes: #include #include +#include #include "z3_macros.h" #include "z3_api.h" #include "z3_ast_containers.h" diff --git a/src/api/z3_api.h b/src/api/z3_api.h index 2b46127fa..ac6c39137 100644 --- a/src/api/z3_api.h +++ b/src/api/z3_api.h @@ -36,14 +36,6 @@ DEFINE_TYPE(Z3_fixedpoint); DEFINE_TYPE(Z3_optimize); DEFINE_TYPE(Z3_rcf_num); -#ifndef __int64 -#define __int64 long long -#endif - -#ifndef __uint64 -#define __uint64 unsigned long long -#endif - /** \defgroup capi C API */ /*@{*/ @@ -1843,7 +1835,7 @@ extern "C" { def_API('Z3_mk_finite_domain_sort', SORT, (_in(CONTEXT), _in(SYMBOL), _in(UINT64))) */ - Z3_sort Z3_API Z3_mk_finite_domain_sort(Z3_context c, Z3_symbol name, __uint64 size); + Z3_sort Z3_API Z3_mk_finite_domain_sort(Z3_context c, Z3_symbol name, uint64_t size); /** \brief Create an array type. @@ -3200,26 +3192,26 @@ extern "C" { /** \brief Create a numeral of a int, bit-vector, or finite-domain sort. - This function can be used to create numerals that fit in a machine __int64 integer. + This function can be used to create numerals that fit in a machine \c int64_t integer. It is slightly faster than #Z3_mk_numeral since it is not necessary to parse a string. \sa Z3_mk_numeral def_API('Z3_mk_int64', AST, (_in(CONTEXT), _in(INT64), _in(SORT))) */ - Z3_ast Z3_API Z3_mk_int64(Z3_context c, __int64 v, Z3_sort ty); + Z3_ast Z3_API Z3_mk_int64(Z3_context c, int64_t v, Z3_sort ty); /** \brief Create a numeral of a int, bit-vector, or finite-domain sort. - This function can be used to create numerals that fit in a machine __uint64 integer. + This function can be used to create numerals that fit in a machine \c uint64_t integer. It is slightly faster than #Z3_mk_numeral since it is not necessary to parse a string. \sa Z3_mk_numeral def_API('Z3_mk_unsigned_int64', AST, (_in(CONTEXT), _in(UINT64), _in(SORT))) */ - Z3_ast Z3_API Z3_mk_unsigned_int64(Z3_context c, __uint64 v, Z3_sort ty); + Z3_ast Z3_API Z3_mk_unsigned_int64(Z3_context c, uint64_t v, Z3_sort ty); /** \brief create a bit-vector numeral from a vector of Booleans. @@ -3868,7 +3860,7 @@ extern "C" { def_API('Z3_get_finite_domain_sort_size', BOOL, (_in(CONTEXT), _in(SORT), _out(UINT64))) */ - Z3_bool_opt Z3_API Z3_get_finite_domain_sort_size(Z3_context c, Z3_sort s, __uint64* r); + Z3_bool_opt Z3_API Z3_get_finite_domain_sort_size(Z3_context c, Z3_sort s, uint64_t* r); /** \brief Return the domain of the given array sort. @@ -4425,7 +4417,7 @@ extern "C" { def_API('Z3_get_numeral_small', BOOL, (_in(CONTEXT), _in(AST), _out(INT64), _out(INT64))) */ - Z3_bool Z3_API Z3_get_numeral_small(Z3_context c, Z3_ast a, __int64* num, __int64* den); + Z3_bool Z3_API Z3_get_numeral_small(Z3_context c, Z3_ast a, int64_t* num, int64_t* den); /** \brief Similar to #Z3_get_numeral_string, but only succeeds if @@ -4453,7 +4445,7 @@ extern "C" { /** \brief Similar to #Z3_get_numeral_string, but only succeeds if - the value can fit in a machine __uint64 int. Return Z3_TRUE if the call succeeded. + the value can fit in a machine \c uint64_t int. Return Z3_TRUE if the call succeeded. \pre Z3_get_ast_kind(c, v) == Z3_NUMERAL_AST @@ -4461,11 +4453,11 @@ extern "C" { def_API('Z3_get_numeral_uint64', BOOL, (_in(CONTEXT), _in(AST), _out(UINT64))) */ - Z3_bool Z3_API Z3_get_numeral_uint64(Z3_context c, Z3_ast v, __uint64* u); + Z3_bool Z3_API Z3_get_numeral_uint64(Z3_context c, Z3_ast v, uint64_t* u); /** \brief Similar to #Z3_get_numeral_string, but only succeeds if - the value can fit in a machine __int64 int. Return Z3_TRUE if the call succeeded. + the value can fit in a machine \c int64_t int. Return Z3_TRUE if the call succeeded. \pre Z3_get_ast_kind(c, v) == Z3_NUMERAL_AST @@ -4473,11 +4465,11 @@ extern "C" { def_API('Z3_get_numeral_int64', BOOL, (_in(CONTEXT), _in(AST), _out(INT64))) */ - Z3_bool Z3_API Z3_get_numeral_int64(Z3_context c, Z3_ast v, __int64* i); + Z3_bool Z3_API Z3_get_numeral_int64(Z3_context c, Z3_ast v, int64_t* i); /** \brief Similar to #Z3_get_numeral_string, but only succeeds if - the value can fit as a rational number as machine __int64 int. Return Z3_TRUE if the call succeeded. + the value can fit as a rational number as machine \c int64_t int. Return Z3_TRUE if the call succeeded. \pre Z3_get_ast_kind(c, v) == Z3_NUMERAL_AST @@ -4485,7 +4477,7 @@ extern "C" { def_API('Z3_get_numeral_rational_int64', BOOL, (_in(CONTEXT), _in(AST), _out(INT64), _out(INT64))) */ - Z3_bool Z3_API Z3_get_numeral_rational_int64(Z3_context c, Z3_ast v, __int64* num, __int64* den); + Z3_bool Z3_API Z3_get_numeral_rational_int64(Z3_context c, Z3_ast v, int64_t* num, int64_t* den); /** \brief Return a lower bound for the given real algebraic number. @@ -6248,7 +6240,7 @@ extern "C" { def_API('Z3_get_estimated_alloc_size', UINT64, ()) */ - __uint64 Z3_API Z3_get_estimated_alloc_size(void); + uint64_t Z3_API Z3_get_estimated_alloc_size(void); /*@}*/ diff --git a/src/api/z3_fpa.h b/src/api/z3_fpa.h index 7d237c6e7..f6001e87d 100644 --- a/src/api/z3_fpa.h +++ b/src/api/z3_fpa.h @@ -349,7 +349,7 @@ extern "C" { def_API('Z3_mk_fpa_numeral_int64_uint64', AST, (_in(CONTEXT), _in(BOOL), _in(INT64), _in(UINT64), _in(SORT))) */ - Z3_ast Z3_API Z3_mk_fpa_numeral_int64_uint64(Z3_context c, Z3_bool sgn, __int64 exp, __uint64 sig, Z3_sort ty); + Z3_ast Z3_API Z3_mk_fpa_numeral_int64_uint64(Z3_context c, Z3_bool sgn, int64_t exp, uint64_t sig, Z3_sort ty); /** \brief Floating-point absolute value @@ -956,7 +956,7 @@ extern "C" { def_API('Z3_fpa_get_numeral_significand_uint64', BOOL, (_in(CONTEXT), _in(AST), _out(UINT64))) */ - Z3_bool Z3_API Z3_fpa_get_numeral_significand_uint64(Z3_context c, Z3_ast t, __uint64 * n); + Z3_bool Z3_API Z3_fpa_get_numeral_significand_uint64(Z3_context c, Z3_ast t, uint64_t * n); /** \brief Return the exponent value of a floating-point numeral as a string. @@ -985,7 +985,7 @@ extern "C" { def_API('Z3_fpa_get_numeral_exponent_int64', BOOL, (_in(CONTEXT), _in(AST), _out(INT64), _in(BOOL))) */ - Z3_bool Z3_API Z3_fpa_get_numeral_exponent_int64(Z3_context c, Z3_ast t, __int64 * n, Z3_bool biased); + Z3_bool Z3_API Z3_fpa_get_numeral_exponent_int64(Z3_context c, Z3_ast t, int64_t * n, Z3_bool biased); /** \brief Retrieves the exponent of a floating-point literal as a bit-vector expression. diff --git a/src/api/z3_logger.h b/src/api/z3_logger.h index dd2816bff..357d79bcb 100644 --- a/src/api/z3_logger.h +++ b/src/api/z3_logger.h @@ -23,8 +23,8 @@ static std::ostream & operator<<(std::ostream & out, ll_escaped const & d); static void __declspec(noinline) R() { *g_z3_log << "R\n"; g_z3_log->flush(); } static void __declspec(noinline) P(void * obj) { *g_z3_log << "P " << obj << "\n"; g_z3_log->flush(); } -static void __declspec(noinline) I(__int64 i) { *g_z3_log << "I " << i << "\n"; g_z3_log->flush(); } -static void __declspec(noinline) U(__uint64 u) { *g_z3_log << "U " << u << "\n"; g_z3_log->flush(); } +static void __declspec(noinline) I(int64_t i) { *g_z3_log << "I " << i << "\n"; g_z3_log->flush(); } +static void __declspec(noinline) U(uint64_t u) { *g_z3_log << "U " << u << "\n"; g_z3_log->flush(); } static void __declspec(noinline) D(double d) { *g_z3_log << "D " << d << "\n"; g_z3_log->flush(); } static void __declspec(noinline) S(Z3_string str) { *g_z3_log << "S \"" << ll_escaped(str) << "\"\n"; g_z3_log->flush(); } static void __declspec(noinline) Sy(Z3_symbol sym) { diff --git a/src/api/z3_replayer.cpp b/src/api/z3_replayer.cpp index fde9b1f48..0e8297879 100644 --- a/src/api/z3_replayer.cpp +++ b/src/api/z3_replayer.cpp @@ -40,8 +40,8 @@ struct z3_replayer::imp { int m_line; // line svector m_string; symbol m_id; - __int64 m_int64; - __uint64 m_uint64; + int64_t m_int64; + uint64_t m_uint64; double m_double; float m_float; size_t m_ptr; @@ -85,8 +85,8 @@ struct z3_replayer::imp { struct value { value_kind m_kind; union { - __int64 m_int; - __uint64 m_uint; + int64_t m_int; + uint64_t m_uint; double m_double; char const * m_str; void * m_obj; @@ -95,8 +95,8 @@ struct z3_replayer::imp { value():m_kind(OBJECT), m_int(0) {} value(void * obj):m_kind(OBJECT), m_obj(obj) {} value(value_kind k, char const * str):m_kind(k), m_str(str) {} - value(value_kind k, __uint64 u):m_kind(k), m_uint(u) {} - value(value_kind k, __int64 i):m_kind(k), m_int(i) {} + value(value_kind k, uint64_t u):m_kind(k), m_uint(u) {} + value(value_kind k, int64_t i):m_kind(k), m_int(i) {} value(value_kind k, double d):m_kind(k), m_double(d) {} value(value_kind k, float f):m_kind(k), m_float(f) {} }; @@ -342,7 +342,7 @@ struct z3_replayer::imp { unsigned asz = m_args.size(); if (sz > asz) throw z3_replayer_exception("invalid array size"); - __uint64 aidx; + uint64_t aidx; value_kind nk; for (unsigned i = asz - sz; i < asz; i++) { if (m_args[i].m_kind != k) @@ -400,7 +400,7 @@ struct z3_replayer::imp { #define TICK_FREQUENCY 100000 void parse() { - unsigned long long counter = 0; + uint64_t counter = 0; unsigned tick = 0; while (true) { IF_VERBOSE(1, { @@ -577,7 +577,7 @@ struct z3_replayer::imp { return static_cast(m_args[pos].m_int); } - __int64 get_int64(unsigned pos) const { + int64_t get_int64(unsigned pos) const { check_arg(pos, INT64); return m_args[pos].m_int; } @@ -587,7 +587,7 @@ struct z3_replayer::imp { return static_cast(m_args[pos].m_uint); } - __uint64 get_uint64(unsigned pos) const { + uint64_t get_uint64(unsigned pos) const { check_arg(pos, UINT64); return m_args[pos].m_uint; } @@ -656,7 +656,7 @@ struct z3_replayer::imp { return reinterpret_cast(&(m_args[pos].m_int)); } - __int64 * get_int64_addr(unsigned pos) { + int64_t * get_int64_addr(unsigned pos) { check_arg(pos, INT64); return &(m_args[pos].m_int); } @@ -666,7 +666,7 @@ struct z3_replayer::imp { return reinterpret_cast(&(m_args[pos].m_uint)); } - __uint64 * get_uint64_addr(unsigned pos) { + uint64_t * get_uint64_addr(unsigned pos) { check_arg(pos, UINT64); return &(m_args[pos].m_uint); } @@ -731,11 +731,11 @@ unsigned z3_replayer::get_uint(unsigned pos) const { return m_imp->get_uint(pos); } -__int64 z3_replayer::get_int64(unsigned pos) const { +int64_t z3_replayer::get_int64(unsigned pos) const { return m_imp->get_int64(pos); } -__uint64 z3_replayer::get_uint64(unsigned pos) const { +uint64_t z3_replayer::get_uint64(unsigned pos) const { return m_imp->get_uint64(pos); } @@ -783,7 +783,7 @@ int * z3_replayer::get_int_addr(unsigned pos) { return m_imp->get_int_addr(pos); } -__int64 * z3_replayer::get_int64_addr(unsigned pos) { +int64_t * z3_replayer::get_int64_addr(unsigned pos) { return m_imp->get_int64_addr(pos); } @@ -791,7 +791,7 @@ unsigned * z3_replayer::get_uint_addr(unsigned pos) { return m_imp->get_uint_addr(pos); } -__uint64 * z3_replayer::get_uint64_addr(unsigned pos) { +uint64_t * z3_replayer::get_uint64_addr(unsigned pos) { return m_imp->get_uint64_addr(pos); } diff --git a/src/api/z3_replayer.h b/src/api/z3_replayer.h index b81659945..8e423cc09 100644 --- a/src/api/z3_replayer.h +++ b/src/api/z3_replayer.h @@ -40,8 +40,8 @@ public: int get_int(unsigned pos) const; unsigned get_uint(unsigned pos) const; - __int64 get_int64(unsigned pos) const; - __uint64 get_uint64(unsigned pos) const; + int64_t get_int64(unsigned pos) const; + uint64_t get_uint64(unsigned pos) const; float get_float(unsigned pos) const; double get_double(unsigned pos) const; bool get_bool(unsigned pos) const; @@ -56,9 +56,9 @@ public: void ** get_obj_array(unsigned pos) const; int * get_int_addr(unsigned pos); - __int64 * get_int64_addr(unsigned pos); + int64_t * get_int64_addr(unsigned pos); unsigned * get_uint_addr(unsigned pos); - __uint64 * get_uint64_addr(unsigned pos); + uint64_t * get_uint64_addr(unsigned pos); Z3_string * get_str_addr(unsigned pos); void ** get_obj_addr(unsigned pos); From 2fa304d8dea48687cdc6dec79b81323a7ea85825 Mon Sep 17 00:00:00 2001 From: Bruce Mitchener Date: Sat, 31 Mar 2018 14:45:04 +0700 Subject: [PATCH 081/109] Remove int64, uint64 typedefs in favor of int64_t / uint64_t. --- src/api/api_context.cpp | 2 +- src/api/api_numeral.cpp | 2 +- src/ast/ast.h | 12 +-- src/ast/ast_smt2_pp.cpp | 2 +- src/ast/bv_decl_plugin.h | 2 +- src/ast/dl_decl_plugin.cpp | 12 +-- src/ast/dl_decl_plugin.h | 12 +-- src/ast/fpa/fpa2bv_converter.cpp | 2 +- src/ast/rewriter/bv_rewriter.cpp | 26 +++--- src/ast/rewriter/dl_rewriter.cpp | 2 +- src/math/hilbert/hilbert_basis.h | 2 +- src/math/polynomial/polynomial.cpp | 4 +- src/math/polynomial/polynomial.h | 4 +- src/math/polynomial/upolynomial.h | 4 +- .../polynomial/upolynomial_factorization.cpp | 6 +- src/math/subpaving/subpaving.cpp | 4 +- src/math/subpaving/subpaving_t.h | 16 ++-- src/muz/base/dl_context.cpp | 20 ++--- src/muz/base/dl_context.h | 10 +-- src/muz/base/dl_costs.cpp | 2 +- src/muz/base/dl_costs.h | 2 +- src/muz/base/dl_util.cpp | 12 +-- src/muz/base/dl_util.h | 6 +- src/muz/ddnf/ddnf.cpp | 4 +- src/muz/fp/datalog_parser.cpp | 32 +++---- src/muz/rel/dl_base.cpp | 2 +- src/muz/rel/dl_base.h | 2 +- src/muz/rel/dl_relation_manager.cpp | 10 +-- src/muz/rel/dl_sparse_table.cpp | 4 +- src/muz/rel/dl_sparse_table.h | 18 ++-- src/muz/rel/doc.cpp | 4 +- src/muz/rel/doc.h | 4 +- src/muz/rel/rel_context.cpp | 2 +- src/muz/rel/tbv.cpp | 6 +- src/muz/rel/tbv.h | 6 +- src/muz/rel/udoc_relation.cpp | 4 +- src/qe/qe_dl_plugin.cpp | 8 +- src/shell/datalog_frontend.cpp | 2 +- src/smt/smt_context.cpp | 2 +- src/smt/theory_dl.cpp | 6 +- src/tactic/bv/bv_bounds_tactic.cpp | 14 +-- src/test/algebraic.cpp | 2 +- src/test/dl_query.cpp | 6 +- src/test/mpff.cpp | 30 +++---- src/test/mpfx.cpp | 2 +- src/test/mpq.cpp | 2 +- src/test/mpz.cpp | 6 +- src/test/prime_generator.cpp | 6 +- src/test/rational.cpp | 4 +- src/util/checked_int64.h | 22 ++--- src/util/double_manager.h | 8 +- src/util/hash.h | 4 +- src/util/hwf.cpp | 36 ++++---- src/util/hwf.h | 8 +- src/util/inf_eps_rational.h | 4 +- src/util/inf_int_rational.h | 4 +- src/util/inf_rational.h | 4 +- src/util/inf_s_integer.h | 4 +- src/util/mpbq.cpp | 2 +- src/util/mpbq.h | 2 +- src/util/mpf.cpp | 16 ++-- src/util/mpf.h | 4 +- src/util/mpff.cpp | 76 ++++++++-------- src/util/mpff.h | 22 ++--- src/util/mpfx.cpp | 32 +++---- src/util/mpfx.h | 14 +-- src/util/mpn.cpp | 2 +- src/util/mpq.h | 18 ++-- src/util/mpz.cpp | 90 +++++++++---------- src/util/mpz.h | 32 +++---- src/util/mpzzp.h | 16 ++-- src/util/prime_generator.cpp | 20 ++--- src/util/prime_generator.h | 8 +- src/util/rational.h | 10 +-- src/util/rlimit.cpp | 4 +- src/util/rlimit.h | 8 +- src/util/s_integer.h | 8 +- src/util/total_order.h | 30 +++---- src/util/util.cpp | 2 +- src/util/util.h | 22 ++--- 80 files changed, 437 insertions(+), 449 deletions(-) diff --git a/src/api/api_context.cpp b/src/api/api_context.cpp index 12a4642c1..c8b365f22 100644 --- a/src/api/api_context.cpp +++ b/src/api/api_context.cpp @@ -184,7 +184,7 @@ namespace api { e = m_bv_util.mk_numeral(n, s); } else if (fid == get_datalog_fid() && n.is_uint64()) { - uint64 sz; + uint64_t sz; if (m_datalog_util.try_get_size(s, sz) && sz <= n.get_uint64()) { invoke_error_handler(Z3_INVALID_ARG); diff --git a/src/api/api_numeral.cpp b/src/api/api_numeral.cpp index ab379c3de..de9886571 100644 --- a/src/api/api_numeral.cpp +++ b/src/api/api_numeral.cpp @@ -172,7 +172,7 @@ extern "C" { if (mk_c(c)->bvutil().is_numeral(e, r, bv_size)) { return Z3_TRUE; } - uint64 v; + uint64_t v; if (mk_c(c)->datalog_util().is_numeral(e, v)) { r = rational(v, rational::ui64()); return Z3_TRUE; diff --git a/src/ast/ast.h b/src/ast/ast.h index 68e02d791..35e9a1cbb 100644 --- a/src/ast/ast.h +++ b/src/ast/ast.h @@ -298,11 +298,11 @@ class sort_size { SS_FINITE_VERY_BIG, SS_INFINITE } m_kind; - uint64 m_size; // It is only meaningful if m_kind == SS_FINITE - sort_size(kind_t k, uint64 r):m_kind(k), m_size(r) {} + uint64_t m_size; // It is only meaningful if m_kind == SS_FINITE + sort_size(kind_t k, uint64_t r):m_kind(k), m_size(r) {} public: sort_size():m_kind(SS_INFINITE) {} - sort_size(uint64 const & sz):m_kind(SS_FINITE), m_size(sz) {} + sort_size(uint64_t const & sz):m_kind(SS_FINITE), m_size(sz) {} sort_size(sort_size const& other): m_kind(other.m_kind), m_size(other.m_size) {} explicit sort_size(rational const& r) { if (r.is_uint64()) { @@ -316,7 +316,7 @@ public: } static sort_size mk_infinite() { return sort_size(SS_INFINITE, 0); } static sort_size mk_very_big() { return sort_size(SS_FINITE_VERY_BIG, 0); } - static sort_size mk_finite(uint64 r) { return sort_size(SS_FINITE, r); } + static sort_size mk_finite(uint64_t r) { return sort_size(SS_FINITE, r); } bool is_infinite() const { return m_kind == SS_INFINITE; } bool is_very_big() const { return m_kind == SS_FINITE_VERY_BIG; } @@ -324,7 +324,7 @@ public: static bool is_very_big_base2(unsigned power) { return power >= 64; } - uint64 size() const { SASSERT(is_finite()); return m_size; } + uint64_t size() const { SASSERT(is_finite()); return m_size; } }; std::ostream& operator<<(std::ostream& out, sort_size const & ss); @@ -346,7 +346,7 @@ public: decl_info(family_id, k, num_parameters, parameters, private_parameters) { } - sort_info(family_id family_id, decl_kind k, uint64 num_elements, + sort_info(family_id family_id, decl_kind k, uint64_t num_elements, unsigned num_parameters = 0, parameter const * parameters = nullptr, bool private_parameters = false): decl_info(family_id, k, num_parameters, parameters, private_parameters), m_num_elements(num_elements) { } diff --git a/src/ast/ast_smt2_pp.cpp b/src/ast/ast_smt2_pp.cpp index 8ad7c27f1..aeaebc6bf 100644 --- a/src/ast/ast_smt2_pp.cpp +++ b/src/ast/ast_smt2_pp.cpp @@ -387,7 +387,7 @@ format * smt2_pp_environment::pp_string_literal(app * t) { } format * smt2_pp_environment::pp_datalog_literal(app * t) { - uint64 v; + uint64_t v; VERIFY (get_dlutil().is_numeral(t, v)); std::ostringstream buffer; buffer << v; diff --git a/src/ast/bv_decl_plugin.h b/src/ast/bv_decl_plugin.h index 4aff8cd06..e128f2c03 100644 --- a/src/ast/bv_decl_plugin.h +++ b/src/ast/bv_decl_plugin.h @@ -384,7 +384,7 @@ public: app * mk_numeral(rational const & val, sort* s) const; app * mk_numeral(rational const & val, unsigned bv_size) const; - app * mk_numeral(uint64 u, unsigned bv_size) const { return mk_numeral(rational(u, rational::ui64()), bv_size); } + app * mk_numeral(uint64_t u, unsigned bv_size) const { return mk_numeral(rational(u, rational::ui64()), bv_size); } sort * mk_sort(unsigned bv_size); unsigned get_bv_size(sort const * s) const { diff --git a/src/ast/dl_decl_plugin.cpp b/src/ast/dl_decl_plugin.cpp index e5b9ed930..f4a538abd 100644 --- a/src/ast/dl_decl_plugin.cpp +++ b/src/ast/dl_decl_plugin.cpp @@ -652,9 +652,9 @@ namespace datalog { // create a constant belonging to a given finite domain. - app* dl_decl_util::mk_numeral(uint64 value, sort* s) { + app* dl_decl_util::mk_numeral(uint64_t value, sort* s) { if (is_finite_sort(s)) { - uint64 sz = 0; + uint64_t sz = 0; if (try_get_size(s, sz) && sz <= value) { m.raise_exception("value is out of bounds"); } @@ -680,7 +680,7 @@ namespace datalog { return nullptr; } - bool dl_decl_util::is_numeral(const expr* e, uint64& v) const { + bool dl_decl_util::is_numeral(const expr* e, uint64_t& v) const { if (is_numeral(e)) { const app* c = to_app(e); SASSERT(c->get_decl()->get_num_parameters() == 2); @@ -693,7 +693,7 @@ namespace datalog { return false; } - bool dl_decl_util::is_numeral_ext(expr* e, uint64& v) const { + bool dl_decl_util::is_numeral_ext(expr* e, uint64_t& v) const { if (is_numeral(e, v)) { return true; } @@ -724,7 +724,7 @@ namespace datalog { return m.is_true(c) || m.is_false(c); } - sort* dl_decl_util::mk_sort(const symbol& name, uint64 domain_size) { + sort* dl_decl_util::mk_sort(const symbol& name, uint64_t domain_size) { if (domain_size == 0) { std::stringstream sstm; sstm << "Domain size of sort '" << name << "' may not be 0"; @@ -734,7 +734,7 @@ namespace datalog { return m.mk_sort(m_fid, DL_FINITE_SORT, 2, params); } - bool dl_decl_util::try_get_size(const sort * s, uint64& size) const { + bool dl_decl_util::try_get_size(const sort * s, uint64_t& size) const { sort_size sz = s->get_info()->get_num_elements(); if (sz.is_finite()) { size = sz.size(); diff --git a/src/ast/dl_decl_plugin.h b/src/ast/dl_decl_plugin.h index 03b9d1fd8..257404f70 100644 --- a/src/ast/dl_decl_plugin.h +++ b/src/ast/dl_decl_plugin.h @@ -122,7 +122,7 @@ namespace datalog { // Contract for func_decl: // parameters[0] - array sort // Contract for OP_DL_CONSTANT: - // parameters[0] - rational containing uint64 with constant value + // parameters[0] - rational containing uint64_t with constant value // parameters[1] - a DL_FINITE_SORT sort of the constant // Contract for others: // no parameters @@ -166,7 +166,7 @@ namespace datalog { dl_decl_util(ast_manager& m); // create a constant belonging to a given finite domain. // the options include the DL_FINITE_SORT, BV_SORT, and BOOL_SORT - app* mk_numeral(uint64 value, sort* s); + app* mk_numeral(uint64_t value, sort* s); app* mk_lt(expr* a, expr* b); @@ -176,19 +176,19 @@ namespace datalog { bool is_numeral(const expr* c) const { return is_app_of(c, m_fid, OP_DL_CONSTANT); } - bool is_numeral(const expr* e, uint64& v) const; + bool is_numeral(const expr* e, uint64_t& v) const; // // Utilities for extracting constants // from bit-vectors and finite domains. // - bool is_numeral_ext(expr* c, uint64& v) const; + bool is_numeral_ext(expr* c, uint64_t& v) const; bool is_numeral_ext(expr* c) const; - sort* mk_sort(const symbol& name, uint64 domain_size); + sort* mk_sort(const symbol& name, uint64_t domain_size); - bool try_get_size(const sort *, uint64& size) const; + bool try_get_size(const sort *, uint64_t& size) const; bool is_finite_sort(sort* s) const { return is_sort_of(s, m_fid, DL_FINITE_SORT); diff --git a/src/ast/fpa/fpa2bv_converter.cpp b/src/ast/fpa/fpa2bv_converter.cpp index c84af84d6..b7b0b6f08 100644 --- a/src/ast/fpa/fpa2bv_converter.cpp +++ b/src/ast/fpa/fpa2bv_converter.cpp @@ -1071,7 +1071,7 @@ void fpa2bv_converter::mk_rem(sort * s, expr_ref & x, expr_ref & y, expr_ref & r SASSERT(m_mpz_manager.is_int64(max_exp_diff)); SASSERT(m_mpz_manager.get_uint64(max_exp_diff) <= UINT_MAX); - uint64 max_exp_diff_ui64 = m_mpz_manager.get_uint64(max_exp_diff); + uint64_t max_exp_diff_ui64 = m_mpz_manager.get_uint64(max_exp_diff); SASSERT(max_exp_diff_ui64 <= UINT_MAX); unsigned max_exp_diff_ui = (unsigned)max_exp_diff_ui64; m_mpz_manager.del(max_exp_diff); diff --git a/src/ast/rewriter/bv_rewriter.cpp b/src/ast/rewriter/bv_rewriter.cpp index e327df452..a0adb6398 100644 --- a/src/ast/rewriter/bv_rewriter.cpp +++ b/src/ast/rewriter/bv_rewriter.cpp @@ -680,8 +680,8 @@ br_status bv_rewriter::mk_extract(unsigned high, unsigned low, expr * arg, expr_ if (v.is_neg()) mod(v, rational::power_of_two(sz), v); if (v.is_uint64()) { - uint64 u = v.get_uint64(); - uint64 e = shift_right(u, low) & (shift_left(1ull, sz) - 1ull); + uint64_t u = v.get_uint64(); + uint64_t e = shift_right(u, low) & (shift_left(1ull, sz) - 1ull); result = mk_numeral(numeral(e, numeral::ui64()), sz); return BR_DONE; } @@ -811,7 +811,7 @@ br_status bv_rewriter::mk_bv_shl(expr * arg1, expr * arg2, expr_ref & result) { SASSERT(r1.is_uint64() && r2.is_uint64()); SASSERT(r2.get_uint64() < bv_size); - uint64 r = shift_left(r1.get_uint64(), r2.get_uint64()); + uint64_t r = shift_left(r1.get_uint64(), r2.get_uint64()); numeral rn(r, numeral::ui64()); rn = m_util.norm(rn, bv_size); result = mk_numeral(rn, bv_size); @@ -860,7 +860,7 @@ br_status bv_rewriter::mk_bv_lshr(expr * arg1, expr * arg2, expr_ref & result) { if (bv_size <= 64) { SASSERT(r1.is_uint64()); SASSERT(r2.is_uint64()); - uint64 r = shift_right(r1.get_uint64(), r2.get_uint64()); + uint64_t r = shift_right(r1.get_uint64(), r2.get_uint64()); numeral rn(r, numeral::ui64()); rn = m_util.norm(rn, bv_size); result = mk_numeral(rn, bv_size); @@ -902,11 +902,11 @@ br_status bv_rewriter::mk_bv_ashr(expr * arg1, expr * arg2, expr_ref & result) { bool is_num1 = is_numeral(arg1, r1, bv_size); if (bv_size <= 64 && is_num1 && is_num2) { - uint64 n1 = r1.get_uint64(); - uint64 n2_orig = r2.get_uint64(); - uint64 n2 = n2_orig % bv_size; + uint64_t n1 = r1.get_uint64(); + uint64_t n2_orig = r2.get_uint64(); + uint64_t n2 = n2_orig % bv_size; SASSERT(n2 < bv_size); - uint64 r = shift_right(n1, n2); + uint64_t r = shift_right(n1, n2); bool sign = (n1 & shift_left(1ull, bv_size - 1ull)) != 0; if (n2_orig > n2) { if (sign) { @@ -917,9 +917,9 @@ br_status bv_rewriter::mk_bv_ashr(expr * arg1, expr * arg2, expr_ref & result) { } } else if (sign) { - uint64 allone = shift_left(1ull, bv_size) - 1ull; - uint64 mask = ~(shift_left(1ull, bv_size - n2) - 1ull); - mask &= allone; + uint64_t allone = shift_left(1ull, bv_size) - 1ull; + uint64_t mask = ~(shift_left(1ull, bv_size - n2) - 1ull); + mask &= allone; r |= mask; } result = mk_numeral(numeral(r, numeral::ui64()), bv_size); @@ -2021,7 +2021,7 @@ br_status bv_rewriter::mk_bv_ext_rotate_left(expr * arg1, expr * arg2, expr_ref numeral r2; unsigned bv_size; if (is_numeral(arg2, r2, bv_size)) { - unsigned shift = static_cast((r2 % numeral(bv_size)).get_uint64() % static_cast(bv_size)); + unsigned shift = static_cast((r2 % numeral(bv_size)).get_uint64() % static_cast(bv_size)); return mk_bv_rotate_left(shift, arg1, result); } return BR_FAILED; @@ -2031,7 +2031,7 @@ br_status bv_rewriter::mk_bv_ext_rotate_right(expr * arg1, expr * arg2, expr_ref numeral r2; unsigned bv_size; if (is_numeral(arg2, r2, bv_size)) { - unsigned shift = static_cast((r2 % numeral(bv_size)).get_uint64() % static_cast(bv_size)); + unsigned shift = static_cast((r2 % numeral(bv_size)).get_uint64() % static_cast(bv_size)); return mk_bv_rotate_right(shift, arg1, result); } return BR_FAILED; diff --git a/src/ast/rewriter/dl_rewriter.cpp b/src/ast/rewriter/dl_rewriter.cpp index 74ea7814e..73944085b 100644 --- a/src/ast/rewriter/dl_rewriter.cpp +++ b/src/ast/rewriter/dl_rewriter.cpp @@ -22,7 +22,7 @@ Revision History: br_status dl_rewriter::mk_app_core( func_decl * f, unsigned num_args, expr* const* args, expr_ref& result) { ast_manager& m = result.get_manager(); - uint64 v1, v2; + uint64_t v1, v2; switch(f->get_decl_kind()) { case datalog::OP_DL_LT: if (m_util.is_numeral_ext(args[0], v1) && diff --git a/src/math/hilbert/hilbert_basis.h b/src/math/hilbert/hilbert_basis.h index a0350492a..54208d268 100644 --- a/src/math/hilbert/hilbert_basis.h +++ b/src/math/hilbert/hilbert_basis.h @@ -20,7 +20,7 @@ Revision History: Hilbert basis can be templatized based on traits that define numeral: - as rational, mpz, checked_int64 + as rational, mpz, checked_int64 (checked or unchecked). --*/ diff --git a/src/math/polynomial/polynomial.cpp b/src/math/polynomial/polynomial.cpp index a58f26597..35a95ce82 100644 --- a/src/math/polynomial/polynomial.cpp +++ b/src/math/polynomial/polynomial.cpp @@ -5479,7 +5479,7 @@ namespace polynomial { } p_prime = derivative(p, x); resultant(p, p_prime, x, r); - bool sign = (static_cast(m) * static_cast(m-1))%4 != 0; + bool sign = (static_cast(m) * static_cast(m-1))%4 != 0; TRACE("resultant", tout << "discriminant sign: " << sign << "\n";); scoped_numeral lc(m_manager); if (const_coeff(p, x, m, lc)) { @@ -6963,7 +6963,7 @@ namespace polynomial { return m_imp->m().set_zp(p); } - void manager::set_zp(uint64 p) { + void manager::set_zp(uint64_t p) { return m_imp->m().set_zp(p); } diff --git a/src/math/polynomial/polynomial.h b/src/math/polynomial/polynomial.h index 43774f0ac..374a51084 100644 --- a/src/math/polynomial/polynomial.h +++ b/src/math/polynomial/polynomial.h @@ -218,7 +218,7 @@ namespace polynomial { \brief Set manager as Z_p[X1, ..., Xn] */ void set_zp(numeral const & p); - void set_zp(uint64 p); + void set_zp(uint64_t p); /** \brief Abstract event handler. @@ -1043,7 +1043,7 @@ namespace polynomial { scoped_numeral m_p; public: scoped_set_zp(manager & _m, numeral const & p):m(_m), m_modular(m.modular()), m_p(m.m()) { m_p = m.p(); m.set_zp(p); } - scoped_set_zp(manager & _m, uint64 p):m(_m), m_modular(m.modular()), m_p(m.m()) { m_p = m.p(); m.set_zp(p); } + scoped_set_zp(manager & _m, uint64_t p):m(_m), m_modular(m.modular()), m_p(m.m()) { m_p = m.p(); m.set_zp(p); } ~scoped_set_zp() { if (m_modular) m.set_zp(m_p); else m.set_z(); } }; }; diff --git a/src/math/polynomial/upolynomial.h b/src/math/polynomial/upolynomial.h index 6bd3e4a27..439b4be9f 100644 --- a/src/math/polynomial/upolynomial.h +++ b/src/math/polynomial/upolynomial.h @@ -153,7 +153,7 @@ namespace upolynomial { \brief Set manager as Z_p[X] */ void set_zp(numeral const & p) { m().set_zp(p); } - void set_zp(uint64 p) { m().set_zp(p); } + void set_zp(uint64_t p) { m().set_zp(p); } void checkpoint(); @@ -486,7 +486,7 @@ namespace upolynomial { core_manager::scoped_numeral m_p; public: scoped_set_zp(core_manager & _m, numeral const & p):m(_m), m_modular(m.modular()), m_p(m.m()) { m_p = m.p(); m.set_zp(p); } - scoped_set_zp(core_manager & _m, uint64 p):m(_m), m_modular(m.modular()), m_p(m.m()) { m_p = m.p(); m.set_zp(p); } + scoped_set_zp(core_manager & _m, uint64_t p):m(_m), m_modular(m.modular()), m_p(m.m()) { m_p = m.p(); m.set_zp(p); } ~scoped_set_zp() { if (m_modular) m.set_zp(m_p); else m.set_z(); } }; diff --git a/src/math/polynomial/upolynomial_factorization.cpp b/src/math/polynomial/upolynomial_factorization.cpp index a1f6e6ec1..5d9d3f1f1 100644 --- a/src/math/polynomial/upolynomial_factorization.cpp +++ b/src/math/polynomial/upolynomial_factorization.cpp @@ -38,9 +38,9 @@ unsigned get_p_from_manager(zp_numeral_manager const & zp_nm) { if (!nm.is_uint64(p)) { throw upolynomial_exception("The prime number attempted in factorization is too big!"); } - uint64 p_uint64 = nm.get_uint64(p); + uint64_t p_uint64 = nm.get_uint64(p); unsigned p_uint = static_cast(p_uint64); - if (((uint64)p_uint) != p_uint64) { + if (((uint64_t)p_uint) != p_uint64) { throw upolynomial_exception("The prime number attempted in factorization is too big!"); } return p_uint; @@ -1075,7 +1075,7 @@ bool factor_square_free(z_manager & upm, numeral_vector const & f, factors & fs, while (trials < params.m_p_trials) { upm.checkpoint(); // construct prime to check - uint64 next_prime = prime_it.next(); + uint64_t next_prime = prime_it.next(); if (next_prime > params.m_max_p) { fs.push_back(f_pp, k); return false; diff --git a/src/math/subpaving/subpaving.cpp b/src/math/subpaving/subpaving.cpp index 1f32a6189..16a9a9a9e 100644 --- a/src/math/subpaving/subpaving.cpp +++ b/src/math/subpaving/subpaving.cpp @@ -150,12 +150,12 @@ namespace subpaving { void int2hwf(mpz const & a, hwf & o) { if (!m_qm.is_int64(a)) throw subpaving::exception(); - int64 val = m_qm.get_int64(a); + int64_t val = m_qm.get_int64(a); double dval = static_cast(val); m_ctx.nm().set(o, dval); double _dval = m_ctx.nm().m().to_double(o); // TODO check the following test - if (static_cast(_dval) != val) + if (static_cast(_dval) != val) throw subpaving::exception(); } diff --git a/src/math/subpaving/subpaving_t.h b/src/math/subpaving/subpaving_t.h index 360b2a32f..02c538828 100644 --- a/src/math/subpaving/subpaving_t.h +++ b/src/math/subpaving/subpaving_t.h @@ -73,17 +73,17 @@ public: // TODO: add SIN, COS, TAN, ... }; protected: - kind m_kind; - uint64 m_timestamp; + kind m_kind; + uint64_t m_timestamp; public: constraint(kind k):m_kind(k), m_timestamp(0) {} kind get_kind() const { return m_kind; } // Return the timestamp of the last propagation visit - uint64 timestamp() const { return m_timestamp; } + uint64_t timestamp() const { return m_timestamp; } // Reset propagation visit time - void set_visited(uint64 ts) { m_timestamp = ts; } + void set_visited(uint64_t ts) { m_timestamp = ts; } }; /** @@ -149,17 +149,17 @@ public: unsigned m_lower:1; unsigned m_open:1; unsigned m_mark:1; - uint64 m_timestamp; + uint64_t m_timestamp; bound * m_prev; justification m_jst; - void set_timestamp(uint64 ts) { m_timestamp = ts; } + void set_timestamp(uint64_t ts) { m_timestamp = ts; } public: var x() const { return static_cast(m_x); } numeral const & value() const { return m_val; } numeral & value() { return m_val; } bool is_lower() const { return m_lower; } bool is_open() const { return m_open; } - uint64 timestamp() const { return m_timestamp; } + uint64_t timestamp() const { return m_timestamp; } bound * prev() const { return m_prev; } justification jst() const { return m_jst; } void display(std::ostream & out, numeral_manager & nm, display_var_proc const & proc = display_var_proc()); @@ -486,7 +486,7 @@ private: id_gen m_node_id_gen; - uint64 m_timestamp; + uint64_t m_timestamp; node * m_root; // m_leaf_head is the head of a doubly linked list of leaf nodes to be processed. node * m_leaf_head; diff --git a/src/muz/base/dl_context.cpp b/src/muz/base/dl_context.cpp index 521cf0dc9..54c07da28 100644 --- a/src/muz/base/dl_context.cpp +++ b/src/muz/base/dl_context.cpp @@ -45,7 +45,7 @@ namespace datalog { protected: sort_ref m_sort; bool m_limited_size; - uint64 m_size; + uint64_t m_size; sort_domain(sort_kind k, context & ctx, sort * s) : m_kind(k), m_sort(s, ctx.get_manager()) { @@ -103,15 +103,15 @@ namespace datalog { }; class context::uint64_sort_domain : public sort_domain { - typedef map > el2num; - typedef svector num2el; + typedef map > el2num; + typedef svector num2el; el2num m_el_numbers; num2el m_el_names; public: uint64_sort_domain(context & ctx, sort * s) : sort_domain(SK_UINT64, ctx, s) {} - finite_element get_number(uint64 el) { + finite_element get_number(uint64_t el) { //we number symbols starting from zero, so table->size() is equal to the //index of the symbol to be added next @@ -368,14 +368,14 @@ namespace datalog { return dom.get_number(sym); } - context::finite_element context::get_constant_number(relation_sort srt, uint64 el) { + context::finite_element context::get_constant_number(relation_sort srt, uint64_t el) { sort_domain & dom0 = get_sort_domain(srt); SASSERT(dom0.get_kind()==SK_UINT64); uint64_sort_domain & dom = static_cast(dom0); return dom.get_number(el); } - void context::print_constant_name(relation_sort srt, uint64 num, std::ostream & out) + void context::print_constant_name(relation_sort srt, uint64_t num, std::ostream & out) { if (has_sort_domain(srt)) { SASSERT(num<=UINT_MAX); @@ -386,7 +386,7 @@ namespace datalog { } } - bool context::try_get_sort_constant_count(relation_sort srt, uint64 & constant_count) { + bool context::try_get_sort_constant_count(relation_sort srt, uint64_t & constant_count) { if (!has_sort_domain(srt)) { return false; } @@ -394,18 +394,18 @@ namespace datalog { return true; } - uint64 context::get_sort_size_estimate(relation_sort srt) { + uint64_t context::get_sort_size_estimate(relation_sort srt) { if (get_decl_util().is_rule_sort(srt)) { return 1; } - uint64 res; + uint64_t res; if (!try_get_sort_constant_count(srt, res)) { const sort_size & sz = srt->get_num_elements(); if (sz.is_finite()) { res = sz.size(); } else { - res = std::numeric_limits::max(); + res = std::numeric_limits::max(); } } return res; diff --git a/src/muz/base/dl_context.h b/src/muz/base/dl_context.h index f37826feb..865c746db 100644 --- a/src/muz/base/dl_context.h +++ b/src/muz/base/dl_context.h @@ -61,7 +61,7 @@ namespace datalog { class relation_manager; typedef sort * relation_sort; - typedef uint64 table_element; + typedef uint64_t table_element; typedef svector table_fact; typedef app * relation_element; @@ -351,16 +351,16 @@ namespace datalog { /** \brief Return number of a symbol in a DK_UINT64 kind sort (\see register_sort() ) */ - finite_element get_constant_number(relation_sort srt, uint64 el); + finite_element get_constant_number(relation_sort srt, uint64_t el); /** \brief Output name of constant with number \c num in sort \c sort. */ - void print_constant_name(relation_sort sort, uint64 num, std::ostream & out); + void print_constant_name(relation_sort sort, uint64_t num, std::ostream & out); - bool try_get_sort_constant_count(relation_sort srt, uint64 & constant_count); + bool try_get_sort_constant_count(relation_sort srt, uint64_t & constant_count); - uint64 get_sort_size_estimate(relation_sort srt); + uint64_t get_sort_size_estimate(relation_sort srt); /** \brief Assign names of variables used in the declaration of a predicate. diff --git a/src/muz/base/dl_costs.cpp b/src/muz/base/dl_costs.cpp index d429af803..70688cd59 100644 --- a/src/muz/base/dl_costs.cpp +++ b/src/muz/base/dl_costs.cpp @@ -141,7 +141,7 @@ namespace datalog { } void cost_recorder::start(accounted_object * obj) { - uint64 curr_time = static_cast(m_stopwatch->get_current_seconds()*1000); + uint64_t curr_time = static_cast(m_stopwatch->get_current_seconds()*1000); if(m_obj) { costs::time_type time_delta = static_cast(curr_time-m_last_time); costs & c = m_obj->get_current_costs(); diff --git a/src/muz/base/dl_costs.h b/src/muz/base/dl_costs.h index 59d4fd8c1..6a5b5e5d6 100644 --- a/src/muz/base/dl_costs.h +++ b/src/muz/base/dl_costs.h @@ -95,7 +95,7 @@ namespace datalog { stopwatch * m_stopwatch; bool m_running; - uint64 m_last_time; + uint64_t m_last_time; public: cost_recorder(); ~cost_recorder(); diff --git a/src/muz/base/dl_util.cpp b/src/muz/base/dl_util.cpp index c2622cec4..7cc9d4b03 100644 --- a/src/muz/base/dl_util.cpp +++ b/src/muz/base/dl_util.cpp @@ -165,7 +165,7 @@ namespace datalog { } expr * arg = f->get_arg(i); - uint64 sym_num; + uint64_t sym_num; SASSERT(is_app(arg)); VERIFY( ctx.get_decl_util().is_numeral_ext(to_app(arg), sym_num) ); relation_sort sort = pred_decl->get_domain(i); @@ -621,7 +621,7 @@ namespace datalog { return name.substr(ofs, count); } - bool string_to_uint64(const char * s, uint64 & res) { + bool string_to_uint64(const char * s, uint64_t & res) { #if _WINDOWS int converted = sscanf_s(s, "%I64u", &res); #else @@ -634,9 +634,9 @@ namespace datalog { return true; } - bool read_uint64(const char * & s, uint64 & res) { - static const uint64 max_but_one_digit = ULLONG_MAX/10; - static const uint64 max_but_one_digit_safe = (ULLONG_MAX-9)/10; + bool read_uint64(const char * & s, uint64_t & res) { + static const uint64_t max_but_one_digit = ULLONG_MAX/10; + static const uint64_t max_but_one_digit_safe = (ULLONG_MAX-9)/10; if(*s<'0' || *s>'9') { return false; @@ -664,7 +664,7 @@ namespace datalog { return true; } - std::string to_string(uint64 num) { + std::string to_string(uint64_t num) { std::stringstream stm; stm< uint64_vector; - typedef hashtable > uint64_set; - typedef map > num2sym; + typedef svector uint64_vector; + typedef hashtable > uint64_set; + typedef map > num2sym; typedef map sym2nums; num2sym m_number_names; @@ -1261,7 +1261,7 @@ private: return true; } - bool inp_num_to_element(sort * s, uint64 num, table_element & res) { + bool inp_num_to_element(sort * s, uint64_t num, table_element & res) { if(s==m_bool_sort.get() || s==m_short_sort.get()) { res = mk_table_const(num, s); return true; @@ -1332,7 +1332,7 @@ private: if(*ptr==0) { break; } - uint64 num; + uint64_t num; if(!read_uint64(ptr, num)) { throw default_exception(default_exception::fmt(), "number expected on line %d in file %s", m_current_line, m_current_file.c_str()); @@ -1389,7 +1389,7 @@ private: bool fact_fail = false; fact.reset(); for(unsigned i=0;im_key; uint64_set & sort_content = *sit->m_value; //the +1 is for a zero element which happens to appear in the problem files - uint64 domain_size = sort_content.size()+1; + uint64_t domain_size = sort_content.size()+1; // sort * s; if(!m_use_map_names) { /* s = */ register_finite_sort(sort_name, domain_size, context::SK_UINT64); @@ -1428,7 +1428,7 @@ private: uint64_set::iterator cit = sort_content.begin(); uint64_set::iterator cend = sort_content.end(); for(; cit!=cend; ++cit) { - uint64 const_num = *cit; + uint64_t const_num = *cit; inp_num_to_element(s, const_num); } */ @@ -1443,7 +1443,7 @@ private: *ptr=0; } - bool parse_map_line(char * full_line, uint64 & num, symbol & name) { + bool parse_map_line(char * full_line, uint64_t & num, symbol & name) { cut_off_comment(full_line); if(full_line[0]==0) { return false; @@ -1515,7 +1515,7 @@ private: m_current_line++; char * full_line = rdr.get_line(); - uint64 num; + uint64_t num; symbol el_name; if(!parse_map_line(full_line, num, el_name)) { diff --git a/src/muz/rel/dl_base.cpp b/src/muz/rel/dl_base.cpp index 20418e3bb..5dd21a9f0 100644 --- a/src/muz/rel/dl_base.cpp +++ b/src/muz/rel/dl_base.cpp @@ -384,7 +384,7 @@ namespace datalog { VERIFY(sig.first_functional() == 1); - uint64 upper_bound = get_signature()[0]; + uint64_t upper_bound = get_signature()[0]; bool empty_table = empty(); if (upper_bound > (1 << 18)) { diff --git a/src/muz/rel/dl_base.h b/src/muz/rel/dl_base.h index dfdcb304d..4d202f2a2 100644 --- a/src/muz/rel/dl_base.h +++ b/src/muz/rel/dl_base.h @@ -832,7 +832,7 @@ namespace datalog { class table_plugin; class table_base; - typedef uint64 table_sort; + typedef uint64_t table_sort; typedef svector table_signature_base0; typedef uint64_hash table_sort_hash; diff --git a/src/muz/rel/dl_relation_manager.cpp b/src/muz/rel/dl_relation_manager.cpp index deb289277..c9fc4f173 100644 --- a/src/muz/rel/dl_relation_manager.cpp +++ b/src/muz/rel/dl_relation_manager.cpp @@ -448,7 +448,7 @@ namespace datalog { } std::string relation_manager::to_nice_string(const relation_element & el) const { - uint64 val; + uint64_t val; std::stringstream stm; if(get_context().get_decl_util().is_numeral_ext(el, val)) { stm << val; @@ -461,7 +461,7 @@ namespace datalog { std::string relation_manager::to_nice_string(const relation_sort & s, const relation_element & el) const { std::stringstream stm; - uint64 val; + uint64_t val; if(get_context().get_decl_util().is_numeral_ext(el, val)) { get_context().print_constant_name(s, val, stm); } @@ -1339,9 +1339,9 @@ namespace datalog { class relation_manager::default_table_filter_not_equal_fn : public table_mutator_fn, auxiliary_table_filter_fn { unsigned m_column; - uint64 m_value; + uint64_t m_value; public: - default_table_filter_not_equal_fn(context & ctx, unsigned column, uint64 value) + default_table_filter_not_equal_fn(context & ctx, unsigned column, uint64_t value) : m_column(column), m_value(value) { } @@ -1372,7 +1372,7 @@ namespace datalog { return nullptr; } dl_decl_util decl_util(m); - uint64 value = 0; + uint64_t value = 0; if (!decl_util.is_numeral_ext(y, value)) { return nullptr; } diff --git a/src/muz/rel/dl_sparse_table.cpp b/src/muz/rel/dl_sparse_table.cpp index 779172b0d..bb48211c7 100644 --- a/src/muz/rel/dl_sparse_table.cpp +++ b/src/muz/rel/dl_sparse_table.cpp @@ -93,7 +93,7 @@ namespace datalog { // // ----------------------------------- - unsigned get_domain_length(uint64 dom_size) { + unsigned get_domain_length(uint64_t dom_size) { SASSERT(dom_size>0); unsigned length = 0; @@ -128,7 +128,7 @@ namespace datalog { unsigned sig_sz = sig.size(); unsigned first_functional = sig_sz-m_functional_col_cnt; for (unsigned i=0; i0); SASSERT(length<=64); diff --git a/src/muz/rel/dl_sparse_table.h b/src/muz/rel/dl_sparse_table.h index a9f3b31a4..fbbbd12f8 100644 --- a/src/muz/rel/dl_sparse_table.h +++ b/src/muz/rel/dl_sparse_table.h @@ -153,7 +153,7 @@ namespace datalog { variable. Otherwise \c m_reserve==NO_RESERVE. The size of m_data is actually 8 bytes larger than stated in m_data_size, so that we may - deref an uint64 pointer at the end of the array. + deref an uint64_t pointer at the end of the array. */ storage m_data; storage_indexer m_data_indexer; @@ -290,10 +290,10 @@ namespace datalog { //the following two operations allow breaking of the object invariant! void resize_data(size_t sz) { m_data_size = sz; - if (sz + sizeof(uint64) < sz) { + if (sz + sizeof(uint64_t) < sz) { throw default_exception("overflow resizing data section for sparse table"); } - m_data.resize(sz + sizeof(uint64)); + m_data.resize(sz + sizeof(uint64_t)); } bool insert_offset(store_offset ofs) { @@ -321,8 +321,8 @@ namespace datalog { class column_info { unsigned m_big_offset; unsigned m_small_offset; - uint64 m_mask; - uint64 m_write_mask; + uint64_t m_mask; + uint64_t m_write_mask; public: unsigned m_offset; //!< in bits unsigned m_length; //!< in bits @@ -330,7 +330,7 @@ namespace datalog { column_info(unsigned offset, unsigned length) \ : m_big_offset(offset/8), m_small_offset(offset%8), - m_mask( length==64 ? ULLONG_MAX : (static_cast(1)<(1)<(rec+m_big_offset); - uint64 res = *ptr; + const uint64_t * ptr = reinterpret_cast(rec+m_big_offset); + uint64_t res = *ptr; res>>=m_small_offset; res&=m_mask; return res; } void set(char * rec, table_element val) const { SASSERT( (val&~m_mask)==0 ); //the value fits into the column - uint64 * ptr = reinterpret_cast(rec+m_big_offset); + uint64_t * ptr = reinterpret_cast(rec+m_big_offset); *ptr&=m_write_mask; *ptr|=val<restart_time); remaining_time_limit -= restart_time; } - uint64 new_restart_time = static_cast(restart_time)*m_context.initial_restart_timeout(); + uint64_t new_restart_time = static_cast(restart_time)*m_context.initial_restart_timeout(); if (new_restart_time > UINT_MAX) { restart_time = UINT_MAX; } diff --git a/src/muz/rel/tbv.cpp b/src/muz/rel/tbv.cpp index 69cc4819a..b96f32114 100644 --- a/src/muz/rel/tbv.cpp +++ b/src/muz/rel/tbv.cpp @@ -72,7 +72,7 @@ tbv* tbv_manager::allocate(tbv const& bv) { copy(*r, bv); return r; } -tbv* tbv_manager::allocate(uint64 val) { +tbv* tbv_manager::allocate(uint64_t val) { tbv* v = allocate0(); for (unsigned bit = std::min(64u, num_tbits()); bit-- > 0;) { if (val & (1ULL << bit)) { @@ -84,7 +84,7 @@ tbv* tbv_manager::allocate(uint64 val) { return v; } -tbv* tbv_manager::allocate(uint64 val, unsigned hi, unsigned lo) { +tbv* tbv_manager::allocate(uint64_t val, unsigned hi, unsigned lo) { tbv* v = allocateX(); SASSERT(64 >= num_tbits() && num_tbits() > hi && hi >= lo); set(*v, val, hi, lo); @@ -134,7 +134,7 @@ void tbv_manager::set(tbv& dst, unsigned index, tbit value) { } -void tbv_manager::set(tbv& dst, uint64 val, unsigned hi, unsigned lo) { +void tbv_manager::set(tbv& dst, uint64_t val, unsigned hi, unsigned lo) { SASSERT(lo <= hi && hi < num_tbits()); for (unsigned i = 0; i < hi - lo + 1; ++i) { set(dst, lo + i, (val & (1ULL << i))?BIT_1:BIT_0); diff --git a/src/muz/rel/tbv.h b/src/muz/rel/tbv.h index 22c25a5e9..346208a3f 100644 --- a/src/muz/rel/tbv.h +++ b/src/muz/rel/tbv.h @@ -51,9 +51,9 @@ public: tbv* allocate0(); tbv* allocateX(); tbv* allocate(tbv const& bv); - tbv* allocate(uint64 n); + tbv* allocate(uint64_t n); tbv* allocate(rational const& r); - tbv* allocate(uint64 n, unsigned hi, unsigned lo); + tbv* allocate(uint64_t n, unsigned hi, unsigned lo); tbv* allocate(tbv const& bv, unsigned const* permutation); tbv* allocate(char const* bv); @@ -80,7 +80,7 @@ public: std::ostream& display(std::ostream& out, tbv const& b, unsigned hi, unsigned lo) const; tbv* project(bit_vector const& to_delete, tbv const& src); bool is_well_formed(tbv const& b) const; // - does not contain BIT_z; - void set(tbv& dst, uint64 n, unsigned hi, unsigned lo); + void set(tbv& dst, uint64_t n, unsigned hi, unsigned lo); void set(tbv& dst, rational const& r, unsigned hi, unsigned lo); void set(tbv& dst, tbv const& other, unsigned hi, unsigned lo); void set(tbv& dst, unsigned index, tbit value); diff --git a/src/muz/rel/udoc_relation.cpp b/src/muz/rel/udoc_relation.cpp index ff23a5e53..2e9ab693c 100644 --- a/src/muz/rel/udoc_relation.cpp +++ b/src/muz/rel/udoc_relation.cpp @@ -261,7 +261,7 @@ namespace datalog { num_bits = 1; return true; } - uint64 n, sz; + uint64_t n, sz; ast_manager& m = get_ast_manager(); if (dl.is_numeral(e, n) && dl.try_get_size(m.get_sort(e), sz)) { num_bits = 0; @@ -277,7 +277,7 @@ namespace datalog { return bv.get_bv_size(s); if (m.is_bool(s)) return 1; - uint64 sz; + uint64_t sz; if (dl.try_get_size(s, sz)) { while (sz > 0) ++num_bits, sz /= 2; return num_bits; diff --git a/src/qe/qe_dl_plugin.cpp b/src/qe/qe_dl_plugin.cpp index 8d688d80c..6e411511d 100644 --- a/src/qe/qe_dl_plugin.cpp +++ b/src/qe/qe_dl_plugin.cpp @@ -70,7 +70,7 @@ namespace qe { return false; } eq_atoms& eqs = get_eqs(x.x(), fml); - uint64 domain_size; + uint64_t domain_size; if (is_small_domain(x, eqs, domain_size)) { num_branches = rational(domain_size, rational::ui64()); } @@ -84,7 +84,7 @@ namespace qe { SASSERT(v.is_unsigned()); eq_atoms& eqs = get_eqs(x.x(), fml); unsigned uv = v.get_unsigned(); - uint64 domain_size; + uint64_t domain_size; if (is_small_domain(x, eqs, domain_size)) { SASSERT(v < rational(domain_size, rational::ui64())); assign_small_domain(x, eqs, uv); @@ -98,7 +98,7 @@ namespace qe { SASSERT(v.is_unsigned()); eq_atoms& eqs = get_eqs(x.x(), fml); unsigned uv = v.get_unsigned(); - uint64 domain_size; + uint64_t domain_size; if (is_small_domain(x, eqs, domain_size)) { SASSERT(uv < domain_size); subst_small_domain(x, eqs, uv, fml); @@ -115,7 +115,7 @@ namespace qe { private: - bool is_small_domain(contains_app& x, eq_atoms& eqs, uint64& domain_size) { + bool is_small_domain(contains_app& x, eq_atoms& eqs, uint64_t& domain_size) { VERIFY(m_util.try_get_size(m.get_sort(x.x()), domain_size)); return domain_size < eqs.num_eqs() + eqs.num_neqs(); } diff --git a/src/shell/datalog_frontend.cpp b/src/shell/datalog_frontend.cpp index 427c1015f..9cc13b897 100644 --- a/src/shell/datalog_frontend.cpp +++ b/src/shell/datalog_frontend.cpp @@ -212,7 +212,7 @@ unsigned read_datalog(char const * file) { if (early_termination) { IF_VERBOSE(1, verbose_stream() << "restarting saturation\n";); - uint64 new_timeout = static_cast(timeout)*ctx.initial_restart_timeout(); + uint64_t new_timeout = static_cast(timeout)*ctx.initial_restart_timeout(); if(new_timeout>UINT_MAX) { timeout=UINT_MAX; } diff --git a/src/smt/smt_context.cpp b/src/smt/smt_context.cpp index e20eae0bd..608b7c63e 100644 --- a/src/smt/smt_context.cpp +++ b/src/smt/smt_context.cpp @@ -3951,7 +3951,7 @@ namespace smt { #if 0 { static unsigned counter = 0; - static uint64 total = 0; + static uint64_t total = 0; static unsigned max = 0; counter++; total += num_lits; diff --git a/src/smt/theory_dl.cpp b/src/smt/theory_dl.cpp index 285c03946..824bd1d9e 100644 --- a/src/smt/theory_dl.cpp +++ b/src/smt/theory_dl.cpp @@ -182,7 +182,7 @@ namespace smt { if (n->get_decl() != v) { expr* rep = m().mk_app(r, n); - uint64 vl; + uint64_t vl; if (u().is_numeral_ext(n, vl)) { assert_cnstr(m().mk_eq(rep, mk_bv_constant(vl, s))); } @@ -237,12 +237,12 @@ namespace smt { return true; } - app* mk_bv_constant(uint64 val, sort* s) { + app* mk_bv_constant(uint64_t val, sort* s) { return b().mk_numeral(rational(val, rational::ui64()), 64); } app* max_value(sort* s) { - uint64 sz; + uint64_t sz; VERIFY(u().try_get_size(s, sz)); SASSERT(sz > 0); return mk_bv_constant(sz-1, s); diff --git a/src/tactic/bv/bv_bounds_tactic.cpp b/src/tactic/bv/bv_bounds_tactic.cpp index 2cd6a5a1b..2704d92ff 100644 --- a/src/tactic/bv/bv_bounds_tactic.cpp +++ b/src/tactic/bv/bv_bounds_tactic.cpp @@ -25,7 +25,7 @@ Author: #include "ast/ast_pp.h" #include -static uint64 uMaxInt(unsigned sz) { +static uint64_t uMaxInt(unsigned sz) { SASSERT(sz <= 64); return ULLONG_MAX >> (64u - sz); } @@ -35,12 +35,12 @@ namespace { struct interval { // l < h: [l, h] // l > h: [0, h] U [l, UMAX_INT] - uint64 l, h; + uint64_t l, h; unsigned sz; bool tight; interval() {} - interval(uint64 l, uint64 h, unsigned sz, bool tight = false) : l(l), h(h), sz(sz), tight(tight) { + interval(uint64_t l, uint64_t h, unsigned sz, bool tight = false) : l(l), h(h), sz(sz), tight(tight) { // canonicalize full set if (is_wrapped() && l == h + 1) { this->l = 0; @@ -183,7 +183,7 @@ namespace { svector m_expr_vars; svector m_bound_exprs; - bool is_number(expr *e, uint64& n, unsigned& sz) const { + bool is_number(expr *e, uint64_t& n, unsigned& sz) const { rational r; if (m_bv.is_numeral(e, r, sz) && sz <= 64) { n = r.get_uint64(); @@ -193,7 +193,7 @@ namespace { } bool is_bound(expr *e, expr*& v, interval& b) const { - uint64 n; + uint64_t n; expr *lhs = nullptr, *rhs = nullptr; unsigned sz; @@ -550,7 +550,7 @@ namespace { svector m_expr_vars; svector m_bound_exprs; - bool is_number(expr *e, uint64& n, unsigned& sz) const { + bool is_number(expr *e, uint64_t& n, unsigned& sz) const { rational r; if (m_bv.is_numeral(e, r, sz) && sz <= 64) { n = r.get_uint64(); @@ -560,7 +560,7 @@ namespace { } bool is_bound(expr *e, expr*& v, interval& b) const { - uint64 n; + uint64_t n; expr *lhs = nullptr, *rhs = nullptr; unsigned sz = 0; diff --git a/src/test/algebraic.cpp b/src/test/algebraic.cpp index b893b5ee2..38948c0d7 100644 --- a/src/test/algebraic.cpp +++ b/src/test/algebraic.cpp @@ -278,7 +278,7 @@ static void tst_select_small(mpbq_manager & m, scoped_mpbq const & l, scoped_mpb std::cout << "choice: " << r << " as decimal: "; m.display_decimal(std::cout, r); std::cout << std::endl; } -static void tst_select_small(mpbq_manager & m, int64 n1, unsigned k1, int64 n2, unsigned k2, bool expected) { +static void tst_select_small(mpbq_manager & m, int64_t n1, unsigned k1, int64_t n2, unsigned k2, bool expected) { scoped_mpbq l(m); scoped_mpbq u(m); m.set(l, n1, k1); diff --git a/src/test/dl_query.cpp b/src/test/dl_query.cpp index c5765bd6b..3dc99e33c 100644 --- a/src/test/dl_query.cpp +++ b/src/test/dl_query.cpp @@ -95,12 +95,12 @@ void dl_query_test(ast_manager & m, smt_params & fparams, params_ref& params, f_b.reset(); f_q.reset(); for(unsigned col=0; colget_domain(0); - uint64 var_sz; + uint64_t var_sz; TRUSTME( ctx.try_get_sort_constant_count(var_sort, var_sz) ); for(unsigned attempt=0; attempt(100)); - m.set(b, static_cast(-100)); + m.set(a, static_cast(100)); + m.set(b, static_cast(-100)); std::cout << "[test2], a: " << a << ", b: " << b << "\n"; } @@ -75,7 +75,7 @@ static void tst4() { static void tst5() { mpff_manager m; scoped_mpff a(m), b(m); - m.set(a, static_cast(1) << 63); + m.set(a, static_cast(1) << 63); m.display_raw(std::cout, a); std::cout << "\n"; ENSURE(m.is_zero(b)); ENSURE(m.lt(b, a)); @@ -117,7 +117,7 @@ static void tst7() { #define MK_BIN_OP(OP) \ -static void tst_ ## OP ## _core(int64 n1, uint64 d1, int64 n2, uint64 d2, unsigned precision = 2, unsigned exp = 0) { \ +static void tst_ ## OP ## _core(int64_t n1, uint64_t d1, int64_t n2, uint64_t d2, unsigned precision = 2, unsigned exp = 0) { \ TRACE("mpff_bug", tout << n1 << "/" << d1 << ", " << n2 << "/" << d2 << "\n";); \ unsynch_mpq_manager qm; \ scoped_mpq qa(qm), qb(qm), qc(qm), qt(qm); \ @@ -207,7 +207,7 @@ static void tst_set64(unsigned N, unsigned prec) { mpff_manager fm(prec); scoped_mpff a(fm); - fm.set(a, static_cast(INT64_MAX)); + fm.set(a, static_cast(INT64_MAX)); ENSURE(fm.is_int64(a)); ENSURE(fm.is_uint64(a)); fm.inc(a); @@ -221,7 +221,7 @@ static void tst_set64(unsigned N, unsigned prec) { ENSURE(fm.is_int64(a)); ENSURE(fm.is_uint64(a)); - fm.set(a, static_cast(INT64_MIN)); + fm.set(a, static_cast(INT64_MIN)); ENSURE(fm.is_int64(a)); ENSURE(!fm.is_uint64(a)); fm.dec(a); @@ -235,7 +235,7 @@ static void tst_set64(unsigned N, unsigned prec) { ENSURE(fm.is_int64(a)); ENSURE(!fm.is_uint64(a)); - fm.set(a, static_cast(UINT64_MAX)); + fm.set(a, static_cast(UINT64_MAX)); ENSURE(fm.is_uint64(a)); ENSURE(!fm.is_int64(a)); fm.inc(a); @@ -250,23 +250,23 @@ static void tst_set64(unsigned N, unsigned prec) { for (unsigned i = 0; i < N; i++) { { - uint64 v = (static_cast(rand()) << 32) + static_cast(rand()); + uint64_t v = (static_cast(rand()) << 32) + static_cast(rand()); fm.set(a, v); ENSURE(fm.is_uint64(a)); - v = (static_cast(rand() % 3) << 32) + static_cast(rand()); + v = (static_cast(rand() % 3) << 32) + static_cast(rand()); fm.set(a, v); ENSURE(fm.is_uint64(a)); } { - int64 v = (static_cast(rand() % INT_MAX) << 32) + static_cast(rand()); + int64_t v = (static_cast(rand() % INT_MAX) << 32) + static_cast(rand()); if (rand()%2 == 0) v = -v; fm.set(a, v); ENSURE(fm.is_int64(a)); - v = (static_cast(rand() % 3) << 32) + static_cast(rand()); + v = (static_cast(rand() % 3) << 32) + static_cast(rand()); if (rand()%2 == 0) v = -v; fm.set(a, v); @@ -336,7 +336,7 @@ static void tst_power(unsigned prec = 2) { m.set(a, UINT_MAX); m.inc(a); ENSURE(m.is_power_of_two(a, k) && k == 32); - ENSURE(m.get_uint64(a) == static_cast(UINT_MAX) + 1); + ENSURE(m.get_uint64(a) == static_cast(UINT_MAX) + 1); m.power(a, 2, a); ENSURE(m.is_power_of_two(a, k) && k == 64); m.power(a, 4, a); @@ -538,7 +538,7 @@ static void tst_add_corner(unsigned prec) { } #endif -static void tst_decimal(int64 n, uint64 d, bool to_plus_inf, unsigned prec, char const * expected, unsigned decimal_places = UINT_MAX) { +static void tst_decimal(int64_t n, uint64_t d, bool to_plus_inf, unsigned prec, char const * expected, unsigned decimal_places = UINT_MAX) { mpff_manager m(prec); scoped_mpff a(m); m.set_rounding(to_plus_inf); @@ -567,7 +567,7 @@ static void tst_decimal() { tst_decimal(-32, 5, true, 2, "-6.39999999999999999965305530480463858111761510372161865234375"); } -static void tst_prev_power_2(int64 n, uint64 d, unsigned expected) { +static void tst_prev_power_2(int64_t n, uint64_t d, unsigned expected) { mpff_manager m; scoped_mpff a(m); m.set(a, n, d); @@ -598,7 +598,7 @@ static void tst_div(unsigned prec) { scoped_mpff a(m), b(m), c(m); m.round_to_plus_inf(); m.set(a, 1); - m.set(b, static_cast(UINT64_MAX)); + m.set(b, static_cast(UINT64_MAX)); m.div(a, b, c); m.display_raw(std::cout, a); std::cout << "\n"; m.display_raw(std::cout, b); std::cout << "\n"; diff --git a/src/test/mpfx.cpp b/src/test/mpfx.cpp index f9dc123f5..f5cf7e2fb 100644 --- a/src/test/mpfx.cpp +++ b/src/test/mpfx.cpp @@ -35,7 +35,7 @@ static void tst1() { m.display_decimal(std::cout, a); std::cout << "\n"; } -static void tst_prev_power_2(int64 n, uint64 d, unsigned expected) { +static void tst_prev_power_2(int64_t n, uint64_t d, unsigned expected) { mpfx_manager m; scoped_mpfx a(m); m.set(a, n, d); diff --git a/src/test/mpq.cpp b/src/test/mpq.cpp index 7b60d9dcb..6294a97f7 100644 --- a/src/test/mpq.cpp +++ b/src/test/mpq.cpp @@ -133,7 +133,7 @@ static void set_str_bug() { ENSURE(a == b); } -static void tst_prev_power_2(int64 n, uint64 d, unsigned expected) { +static void tst_prev_power_2(int64_t n, uint64_t d, unsigned expected) { unsynch_mpq_manager m; scoped_mpq a(m); m.set(a, n, d); diff --git a/src/test/mpz.cpp b/src/test/mpz.cpp index 7926388df..cf7f3d8e6 100644 --- a/src/test/mpz.cpp +++ b/src/test/mpz.cpp @@ -50,7 +50,7 @@ static void tst1() { static void tst2() { synch_mpz_manager m; mpz v1, v2, v3; - m.set(v1, static_cast(UINT_MAX)); + m.set(v1, static_cast(UINT_MAX)); m.add(v1, m.mk_z(1), v2); m.mul(v2, v2, v3); std::cout << "v2:\n" << m.to_string(v2) << "\n"; @@ -63,7 +63,7 @@ static void tst2() { static void tst2b() { synch_mpz_manager m; mpz v1, v2, v3; - m.set(v1, static_cast(UINT_MAX)); + m.set(v1, static_cast(UINT_MAX)); m.add(v1, m.mk_z(1), v2); m.mul(v2, v2, v3); std::cout << "v2:\n" << m.to_string(v2) << "\n"; @@ -282,7 +282,7 @@ void tst_int_min_bug() { mpz big; mpz expected; mpz r; - m.set(big, static_cast(UINT64_MAX)); + m.set(big, static_cast(UINT64_MAX)); m.set(expected, "18446744075857035263"); m.sub(big, intmin, r); std::cout << "r: " << m.to_string(r) << "\nexpected: " << m.to_string(expected) << "\n"; diff --git a/src/test/prime_generator.cpp b/src/test/prime_generator.cpp index 12c38ef78..3820959d9 100644 --- a/src/test/prime_generator.cpp +++ b/src/test/prime_generator.cpp @@ -25,7 +25,7 @@ void tst_prime_generator() { prime_generator gen; for (unsigned i = 0; i < 10000; i++) { - uint64 p = gen(i); + uint64_t p = gen(i); std::cout << p << ", "; if (i % 11 == 0) std::cout << "\n"; std::cout.flush(); @@ -33,8 +33,8 @@ void tst_prime_generator() { continue; m.set(sqrt_p, p); m.root(sqrt_p, 2); - uint64 k = m.get_uint64(sqrt_p); - for (uint64 i = 2; i <= k; i++) { + uint64_t k = m.get_uint64(sqrt_p); + for (uint64_t i = 2; i <= k; i++) { ENSURE(p % i != 0); } } diff --git a/src/test/rational.cpp b/src/test/rational.cpp index 0618a01fb..ac477a02f 100644 --- a/src/test/rational.cpp +++ b/src/test/rational.cpp @@ -194,8 +194,8 @@ static void tst2() { ENSURE(uint64_max.is_uint64()); // get_int64, get_uint64 - uint64 u1 = uint64_max.get_uint64(); - uint64 u2 = UINT64_MAX; + uint64_t u1 = uint64_max.get_uint64(); + uint64_t u2 = UINT64_MAX; VERIFY(u1 == u2); std::cout << "int64_max: " << int64_max << ", INT64_MAX: " << INT64_MAX << ", int64_max.get_int64(): " << int64_max.get_int64() << ", int64_max.get_uint64(): " << int64_max.get_uint64() << "\n"; ENSURE(int64_max.get_int64() == INT64_MAX); diff --git a/src/util/checked_int64.h b/src/util/checked_int64.h index e5a88fb31..507564a2e 100644 --- a/src/util/checked_int64.h +++ b/src/util/checked_int64.h @@ -7,7 +7,7 @@ Module Name: Abstract: - A class for wrapping checked (and unchecked) int64 operations. + A class for wrapping checked (and unchecked) int64_t operations. Note: the mpfx class defines a more general class of fixed-point operations. A tradeoff is that it relies on a manager. This class several of the most common operations from rational, so @@ -29,15 +29,15 @@ Revision History: template class checked_int64 { - int64 m_value; + int64_t m_value; typedef checked_int64 ci; - rational r64(int64 i) { return rational(i, rational::i64()); } + rational r64(int64_t i) { return rational(i, rational::i64()); } public: checked_int64(): m_value(0) {} - checked_int64(int64 v): m_value(v) {} + checked_int64(int64_t v): m_value(v) {} checked_int64(checked_int64 const& other) { m_value = other.m_value; } class overflow_exception : public z3_exception { @@ -57,7 +57,7 @@ public: static checked_int64 one() { return ci(1); } static checked_int64 minus_one() { return ci(-1);} - int64 get_int64() const { return m_value; } + int64_t get_int64() const { return m_value; } checked_int64 abs() const { if (m_value >= 0) { @@ -117,9 +117,9 @@ public: checked_int64& operator+=(checked_int64 const& other) { if (CHECK) { - uint64 x = static_cast(m_value); - uint64 y = static_cast(other.m_value); - int64 r = static_cast(x + y); + uint64_t x = static_cast(m_value); + uint64_t y = static_cast(other.m_value); + int64_t r = static_cast(x + y); if (m_value > 0 && other.m_value > 0 && r <= 0) throw overflow_exception(); if (m_value < 0 && other.m_value < 0 && r >= 0) throw overflow_exception(); m_value = r; @@ -132,9 +132,9 @@ public: checked_int64& operator-=(checked_int64 const& other) { if (CHECK) { - uint64 x = static_cast(m_value); - uint64 y = static_cast(other.m_value); - int64 r = static_cast(x - y); + uint64_t x = static_cast(m_value); + uint64_t y = static_cast(other.m_value); + int64_t r = static_cast(x - y); if (m_value > 0 && other.m_value < 0 && r <= 0) throw overflow_exception(); if (m_value < 0 && other.m_value > 0 && r >= 0) throw overflow_exception(); m_value = r; diff --git a/src/util/double_manager.h b/src/util/double_manager.h index 7532a3b8b..481701f42 100644 --- a/src/util/double_manager.h +++ b/src/util/double_manager.h @@ -75,8 +75,8 @@ public: static void set(double & a, char const * val) { a = atof(val); } static void set(double & a, int val) { a = static_cast(val); } static void set(double & a, unsigned val) { a = static_cast(val); } - static void set(double & a, int64 val) { a = static_cast(val); } - static void set(double & a, uint64 val) { a = static_cast(val); } + static void set(double & a, int64_t val) { a = static_cast(val); } + static void set(double & a, uint64_t val) { a = static_cast(val); } static void swap(double & a, double & b) { std::swap(a, b); } bool is_pos(double a) const { return a > m_zero_tolerance; } bool is_neg(double a) const { return a < m_zero_tolerance; } @@ -93,11 +93,11 @@ public: } static unsigned hash(double a) { - return hash_ull(static_cast(a)); + return hash_ull(static_cast(a)); } }; -static_assert(sizeof(uint64) == sizeof(double), ""); +static_assert(sizeof(uint64_t) == sizeof(double), ""); #endif /* DOUBLE_MANAGER_H_ */ diff --git a/src/util/hash.h b/src/util/hash.h index bc6117cac..a2af8253f 100644 --- a/src/util/hash.h +++ b/src/util/hash.h @@ -140,8 +140,8 @@ struct size_t_hash { }; struct uint64_hash { - typedef uint64 data; - unsigned operator()(uint64 x) const { return static_cast(x); } + typedef uint64_t data; + unsigned operator()(uint64_t x) const { return static_cast(x); } }; struct bool_hash { diff --git a/src/util/hwf.cpp b/src/util/hwf.cpp index 014e62625..c59621b6b 100644 --- a/src/util/hwf.cpp +++ b/src/util/hwf.cpp @@ -91,8 +91,8 @@ hwf_manager::~hwf_manager() { } -uint64 RAW(double X) { uint64 tmp; memcpy(&tmp, &(X), sizeof(uint64)); return tmp; } -double DBL(uint64 X) { double tmp; memcpy(&tmp, &(X), sizeof(double)); return tmp; } +uint64_t RAW(double X) { uint64_t tmp; memcpy(&tmp, &(X), sizeof(uint64_t)); return tmp; } +double DBL(uint64_t X) { double tmp; memcpy(&tmp, &(X), sizeof(double)); return tmp; } void hwf_manager::set(hwf & o, int value) { o.value = (double) value; @@ -147,7 +147,7 @@ void hwf_manager::set(hwf & o, mpf_rounding_mode rm, mpq const & significand, mp mpq sig; m_mpq_manager.set(sig, significand); - int64 exp = m_mpz_manager.get_int64(exponent); + int64_t exp = m_mpz_manager.get_int64(exponent); if (m_mpq_manager.is_zero(significand)) o.value = 0.0; @@ -160,17 +160,17 @@ void hwf_manager::set(hwf & o, mpf_rounding_mode rm, mpq const & significand, mp } hwf s; s.value = m_mpq_manager.get_double(sig); - uint64 r = (RAW(s.value) & 0x800FFFFFFFFFFFFFull) | ((exp + 1023) << 52); + uint64_t r = (RAW(s.value) & 0x800FFFFFFFFFFFFFull) | ((exp + 1023) << 52); o.value = DBL(r); } } -void hwf_manager::set(hwf & o, bool sign, uint64 significand, int exponent) { +void hwf_manager::set(hwf & o, bool sign, uint64_t significand, int exponent) { // Assumption: this represents (sign * -1) * (significand/2^sbits) * 2^exponent. SASSERT(significand <= 0x000FFFFFFFFFFFFFull); SASSERT(-1022 <= exponent && exponent <= 1023); - uint64 raw = (sign?0x8000000000000000ull:0); - raw |= (((uint64)exponent) + 1023) << 52; + uint64_t raw = (sign?0x8000000000000000ull:0); + raw |= (((uint64_t)exponent) + 1023) << 52; raw |= significand; memcpy(&o.value, &raw, sizeof(double)); } @@ -428,7 +428,7 @@ void hwf_manager::to_rational(hwf const & x, unsynch_mpq_manager & qm, mpq & o) } bool hwf_manager::is_zero(hwf const & x) { - uint64 t = RAW(x.value) & 0x7FFFFFFFFFFFFFFFull; + uint64_t t = RAW(x.value) & 0x7FFFFFFFFFFFFFFFull; return (t == 0x0ull); // CMW: I tried, and these are slower: // return (t != 0x0ull) ? false : true; @@ -483,12 +483,12 @@ bool hwf_manager::is_ninf(hwf const & x) { } bool hwf_manager::is_normal(hwf const & x) { - uint64 t = RAW(x.value) & 0x7FF0000000000000ull; + uint64_t t = RAW(x.value) & 0x7FF0000000000000ull; return (t != 0x0ull && t != 0x7FF0000000000000ull); } bool hwf_manager::is_denormal(hwf const & x) { - uint64 t = RAW(x.value); + uint64_t t = RAW(x.value); return ((t & 0x7FF0000000000000ull) == 0x0 && (t & 0x000FFFFFFFFFFFFFull) != 0x0); } @@ -498,7 +498,7 @@ bool hwf_manager::is_regular(hwf const & x) { // Note that +-0.0 and denormal numbers have exponent==0; these are regular. // All normal numbers are also regular. What remains is +-Inf and NaN, they are // not regular and they are the only numbers that have exponent 7FF. - uint64 e = RAW(x.value) & 0x7FF0000000000000ull; // the exponent + uint64_t e = RAW(x.value) & 0x7FF0000000000000ull; // the exponent return (e != 0x7FF0000000000000ull); } @@ -513,15 +513,15 @@ bool hwf_manager::is_int(hwf const & x) { return false; else { - uint64 t = sig(x); + uint64_t t = sig(x); unsigned shift = 52 - ((unsigned)e); - uint64 mask = (0x1ull << shift) - 1; + uint64_t mask = (0x1ull << shift) - 1; return (t & mask) == 0; } } void hwf_manager::mk_nzero(hwf & o) { - uint64 raw = 0x8000000000000000ull; + uint64_t raw = 0x8000000000000000ull; o.value = DBL(raw); } @@ -537,22 +537,22 @@ void hwf_manager::mk_zero(bool sign, hwf & o) { } void hwf_manager::mk_nan(hwf & o) { - uint64 raw = 0x7FF0000000000001ull; + uint64_t raw = 0x7FF0000000000001ull; o.value = DBL(raw); } void hwf_manager::mk_inf(bool sign, hwf & o) { - uint64 raw = (sign) ? 0xFFF0000000000000ull : 0x7FF0000000000000ull; + uint64_t raw = (sign) ? 0xFFF0000000000000ull : 0x7FF0000000000000ull; o.value = DBL(raw); } void hwf_manager::mk_pinf(hwf & o) { - uint64 raw = 0x7FF0000000000000ull; + uint64_t raw = 0x7FF0000000000000ull; o.value = DBL(raw); } void hwf_manager::mk_ninf(hwf & o) { - uint64 raw = 0xFFF0000000000000ull; + uint64_t raw = 0xFFF0000000000000ull; o.value = DBL(raw); } diff --git a/src/util/hwf.h b/src/util/hwf.h index 5f7692204..21e7655ea 100644 --- a/src/util/hwf.h +++ b/src/util/hwf.h @@ -28,8 +28,8 @@ class hwf { friend class hwf_manager; double value; hwf & operator=(hwf const & other) { UNREACHABLE(); return *this; } - uint64 get_raw() const { - uint64 n; + uint64_t get_raw() const { + uint64_t n; SASSERT(sizeof(n) == sizeof(value)); memcpy(&n, &value, sizeof(value)); return n; @@ -60,7 +60,7 @@ public: void set(hwf & o, mpf_rounding_mode rm, mpq const & value); void set(hwf & o, mpf_rounding_mode rm, char const * value); void set(hwf & o, mpf_rounding_mode rm, mpq const & significand, mpz const & exponent); - void set(hwf & o, bool sign, uint64 significand, int exponent); + void set(hwf & o, bool sign, uint64_t significand, int exponent); void set(hwf & o, hwf const & x); // auxiliary methods to make the interface compatible with mpf @@ -128,7 +128,7 @@ public: return (x.get_raw() & 0x8000000000000000ull) != 0; } - uint64 sig(hwf const & x) const { + uint64_t sig(hwf const & x) const { return x.get_raw() & 0x000FFFFFFFFFFFFFull; } diff --git a/src/util/inf_eps_rational.h b/src/util/inf_eps_rational.h index c184623ca..d0b6f2d99 100644 --- a/src/util/inf_eps_rational.h +++ b/src/util/inf_eps_rational.h @@ -118,12 +118,12 @@ class inf_eps_rational { bool is_rational() const { return m_infty.is_zero() && m_r.is_rational(); } - int64 get_int64() const { + int64_t get_int64() const { SASSERT(is_int64()); return m_r.get_int64(); } - uint64 get_uint64() const { + uint64_t get_uint64() const { SASSERT(is_uint64()); return m_r.get_uint64(); } diff --git a/src/util/inf_int_rational.h b/src/util/inf_int_rational.h index c9c82052e..44ed76ebd 100644 --- a/src/util/inf_int_rational.h +++ b/src/util/inf_int_rational.h @@ -109,12 +109,12 @@ class inf_int_rational { bool is_rational() const { return m_second == 0; } - int64 get_int64() const { + int64_t get_int64() const { SASSERT(is_int64()); return m_first.get_int64(); } - uint64 get_uint64() const { + uint64_t get_uint64() const { SASSERT(is_uint64()); return m_first.get_uint64(); } diff --git a/src/util/inf_rational.h b/src/util/inf_rational.h index d49e45f50..c3f4160ba 100644 --- a/src/util/inf_rational.h +++ b/src/util/inf_rational.h @@ -122,12 +122,12 @@ class inf_rational { bool is_rational() const { return m_second.is_zero(); } - int64 get_int64() const { + int64_t get_int64() const { SASSERT(is_int64()); return m_first.get_int64(); } - uint64 get_uint64() const { + uint64_t get_uint64() const { SASSERT(is_uint64()); return m_first.get_uint64(); } diff --git a/src/util/inf_s_integer.h b/src/util/inf_s_integer.h index 067000202..dd136d1b9 100644 --- a/src/util/inf_s_integer.h +++ b/src/util/inf_s_integer.h @@ -60,8 +60,8 @@ class inf_s_integer { bool is_int64() const { return m_second == 0; } bool is_uint64() const { return m_second == 0; } bool is_rational() const { return m_second == 0; } - int64 get_int64() const { return m_first; } - uint64 get_uint64() const { return m_first; } + int64_t get_int64() const { return m_first; } + uint64_t get_uint64() const { return m_first; } s_integer get_rational() const { return s_integer(m_first); } s_integer get_infinitesimal() const { return s_integer(m_second); } inf_s_integer & operator=(const inf_s_integer & r) { diff --git a/src/util/mpbq.cpp b/src/util/mpbq.cpp index 9fcd1b58f..3edbdab67 100644 --- a/src/util/mpbq.cpp +++ b/src/util/mpbq.cpp @@ -250,7 +250,7 @@ void mpbq_manager::mul(mpbq const & a, mpz const & b, mpbq & r) { } void mpbq_manager::power(mpbq & a, unsigned k) { - SASSERT(static_cast(k) * static_cast(a.k()) <= static_cast(UINT_MAX)); + SASSERT(static_cast(k) * static_cast(a.k()) <= static_cast(UINT_MAX)); // We don't need to normalize because: // If a.m_k == 0, then a is an integer, and the result be an integer // If a.m_k > 0, then a.m_num must be odd, and the (a.m_num)^k will also be odd diff --git a/src/util/mpbq.h b/src/util/mpbq.h index 61ef2b0e2..ed8a8c523 100644 --- a/src/util/mpbq.h +++ b/src/util/mpbq.h @@ -84,7 +84,7 @@ public: void set(mpbq & a, mpz const & n, unsigned k) { m_manager.set(a.m_num, n); a.m_k = k; normalize(a); } void set(mpbq & a, mpz const & n) { m_manager.set(a.m_num, n); a.m_k = 0; } void set(mpbq & a, mpbq const & b) { m_manager.set(a.m_num, b.m_num); a.m_k = b.m_k; } - void set(mpbq & a, int64 n, unsigned k) { m_manager.set(a.m_num, n); a.m_k = k; normalize(a); } + void set(mpbq & a, int64_t n, unsigned k) { m_manager.set(a.m_num, n); a.m_k = k; normalize(a); } bool is_int(mpbq const & a) const { return a.m_k == 0; } void get_numerator(mpbq const & a, mpz & n) { m_manager.set(n, a.m_num); } diff --git a/src/util/mpf.cpp b/src/util/mpf.cpp index b9829f02d..17705cc34 100644 --- a/src/util/mpf.cpp +++ b/src/util/mpf.cpp @@ -115,11 +115,11 @@ void mpf_manager::set(mpf & o, unsigned ebits, unsigned sbits, double value) { // double === mpf(11, 53) static_assert(sizeof(double) == 8, "doubles are 8 bytes"); - uint64 raw; + uint64_t raw; memcpy(&raw, &value, sizeof(double)); bool sign = (raw >> 63) != 0; - int64 e = ((raw & 0x7FF0000000000000ull) >> 52) - 1023; - uint64 s = raw & 0x000FFFFFFFFFFFFFull; + int64_t e = ((raw & 0x7FF0000000000000ull) >> 52) - 1023; + uint64_t s = raw & 0x000FFFFFFFFFFFFFull; TRACE("mpf_dbg", tout << "set: " << value << " is: raw=" << raw << " (double)" << " sign=" << sign << " s=" << s << " e=" << e << std::endl;); @@ -300,7 +300,7 @@ void mpf_manager::set(mpf & o, unsigned ebits, unsigned sbits, mpf_rounding_mode TRACE("mpf_dbg", tout << "set: res = " << to_string(o) << std::endl;); } -void mpf_manager::set(mpf & o, unsigned ebits, unsigned sbits, bool sign, mpf_exp_t exponent, uint64 significand) { +void mpf_manager::set(mpf & o, unsigned ebits, unsigned sbits, bool sign, mpf_exp_t exponent, uint64_t significand) { // Assumption: this represents (sign * -1) * (significand/2^sbits) * 2^exponent. o.ebits = ebits; o.sbits = sbits; @@ -1711,8 +1711,8 @@ void mpf_manager::to_rational(mpf const & x, unsynch_mpq_manager & qm, mpq & o) double mpf_manager::to_double(mpf const & x) { SASSERT(x.ebits <= 11 && x.sbits <= 53); - uint64 raw = 0; - int64 sig = 0, exp = 0; + uint64_t raw = 0; + int64_t sig = 0, exp = 0; sig = m_mpz_manager.get_uint64(x.significand); sig <<= 53 - x.sbits; @@ -1741,7 +1741,7 @@ float mpf_manager::to_float(mpf const & x) { unsigned int raw = 0; unsigned int sig = 0, exp = 0; - uint64 q = m_mpz_manager.get_uint64(x.significand); + uint64_t q = m_mpz_manager.get_uint64(x.significand); SASSERT(q < 4294967296ull); sig = q & 0x00000000FFFFFFFF; sig <<= 24 - x.sbits; @@ -1751,7 +1751,7 @@ float mpf_manager::to_float(mpf const & x) { else if (has_bot_exp(x)) exp = -127; else { - int64 q = x.exponent; + int64_t q = x.exponent; SASSERT(q < 4294967296ll); exp = q & 0x00000000FFFFFFFF; } diff --git a/src/util/mpf.h b/src/util/mpf.h index 27116e2de..107ada0bd 100644 --- a/src/util/mpf.h +++ b/src/util/mpf.h @@ -35,7 +35,7 @@ typedef enum { MPF_ROUND_TOWARD_ZERO } mpf_rounding_mode; -typedef int64 mpf_exp_t; +typedef int64_t mpf_exp_t; class mpf { friend class mpf_manager; @@ -80,7 +80,7 @@ public: void set(mpf & o, unsigned ebits, unsigned sbits, mpf_rounding_mode rm, mpq const & value); void set(mpf & o, unsigned ebits, unsigned sbits, mpf_rounding_mode rm, char const * value); void set(mpf & o, unsigned ebits, unsigned sbits, mpf_rounding_mode rm, mpz const & exponent, mpq const & significand); - void set(mpf & o, unsigned ebits, unsigned sbits, bool sign, mpf_exp_t exponent, uint64 significand); + void set(mpf & o, unsigned ebits, unsigned sbits, bool sign, mpf_exp_t exponent, uint64_t significand); void set(mpf & o, unsigned ebits, unsigned sbits, bool sign, mpf_exp_t exponent, mpz const & significand); void set(mpf & o, mpf const & x); void set(mpf & o, unsigned ebits, unsigned sbits, mpf_rounding_mode rm, mpf const & x); diff --git a/src/util/mpff.cpp b/src/util/mpff.cpp index eac9cc80c..64e07f9f0 100644 --- a/src/util/mpff.cpp +++ b/src/util/mpff.cpp @@ -155,27 +155,27 @@ bool mpff_manager::is_uint64(mpff const & n) const { !has_one_at_first_k_bits(m_precision, sig(n), -n.m_exponent); } -uint64 mpff_manager::get_uint64(mpff const & a) const { +uint64_t mpff_manager::get_uint64(mpff const & a) const { SASSERT(is_uint64(a)); if (is_zero(a)) return 0; int exp = -a.m_exponent - sizeof(unsigned) * 8 * (m_precision - 2); SASSERT(exp >= 0); - uint64 * s = reinterpret_cast(sig(a) + (m_precision - 2)); + uint64_t * s = reinterpret_cast(sig(a) + (m_precision - 2)); return *s >> exp; } -int64 mpff_manager::get_int64(mpff const & a) const { +int64_t mpff_manager::get_int64(mpff const & a) const { SASSERT(is_int64(a)); if (is_zero(a)) return 0; int exp = -a.m_exponent - sizeof(unsigned) * 8 * (m_precision - 2); SASSERT(exp >= 0); - uint64 * s = reinterpret_cast(sig(a) + (m_precision - 2)); + uint64_t * s = reinterpret_cast(sig(a) + (m_precision - 2)); // INT64_MIN case if (exp == 0 && *s == 0x8000000000000000ull && is_neg(a)) { return INT64_MIN; } else { - int64 r = *s >> exp; + int64_t r = *s >> exp; if (is_neg(a)) r = -r; return r; @@ -249,26 +249,26 @@ void mpff_manager::set(mpff & n, unsigned v) { SASSERT(check(n)); } -void mpff_manager::set(mpff & n, int64 v) { +void mpff_manager::set(mpff & n, int64_t v) { if (v == 0) { reset(n); } else { if (v < 0) { - set(n, 1 + static_cast(-(1+v))); + set(n, 1 + static_cast(-(1+v))); n.m_sign = 1; } else { - set(n, static_cast(v)); + set(n, static_cast(v)); } } SASSERT(check(n)); SASSERT(get_int64(n) == v); } -void mpff_manager::set(mpff & n, uint64 v) { +void mpff_manager::set(mpff & n, uint64_t v) { #ifdef Z3DEBUG - uint64 old_v = v; + uint64_t old_v = v; #endif if (v == 0) { reset(n); @@ -278,7 +278,7 @@ void mpff_manager::set(mpff & n, uint64 v) { n.m_sign = 0; unsigned * _v = reinterpret_cast(&v); int num_leading_zeros = nlz(2, _v); - n.m_exponent = static_cast(8 * sizeof(uint64)) - num_leading_zeros - static_cast(m_precision_bits); + n.m_exponent = static_cast(8 * sizeof(uint64_t)) - num_leading_zeros - static_cast(m_precision_bits); v <<= num_leading_zeros; SASSERT(m_precision >= 2); unsigned * s = sig(n); @@ -299,7 +299,7 @@ void mpff_manager::set(mpff & n, int num, unsigned den) { SASSERT(check(n)); } -void mpff_manager::set(mpff & n, int64 num, uint64 den) { +void mpff_manager::set(mpff & n, int64_t num, uint64_t den) { scoped_mpff a(*this), b(*this); set(a, num); set(b, den); @@ -470,7 +470,7 @@ bool mpff_manager::lt(mpff const & a, mpff const & b) const { } } -void mpff_manager::inc_significand(unsigned * s, int64 & exp) { +void mpff_manager::inc_significand(unsigned * s, int64_t & exp) { if (!::inc(m_precision, s)) { SASSERT(::is_zero(m_precision, s)); s[m_precision - 1] = MIN_MSW; @@ -597,7 +597,7 @@ void mpff_manager::prev(mpff & a) { SASSERT(check(a)); } -void mpff_manager::set_big_exponent(mpff & a, int64 e) { +void mpff_manager::set_big_exponent(mpff & a, int64_t e) { SASSERT(e > INT_MAX || e < INT_MIN); if (e > INT_MAX) { if (a.m_sign == 1) { @@ -715,7 +715,7 @@ void mpff_manager::add_sub(bool is_sub, mpff const & a, mpff const & b, mpff & c else if (num_leading_zeros == sizeof(unsigned) * 8 - 1) { // shift 1 right bool _inc_significand = ((c.m_sign == 1) != m_to_plus_inf) && has_one_at_first_k_bits(m_precision*2, sig_r, 1); - int64 exp_c = exp_a; + int64_t exp_c = exp_a; exp_c++; shr(m_precision + 1, sig_r, 1, m_precision, sig_c); if (_inc_significand) @@ -728,7 +728,7 @@ void mpff_manager::add_sub(bool is_sub, mpff const & a, mpff const & b, mpff & c // Now, we can assume sig_r has size m_precision SASSERT(num_leading_zeros > 0); // shift left num_leading_zeros - int64 exp_c = exp_a; + int64_t exp_c = exp_a; exp_c -= num_leading_zeros; shl(m_precision, sig_r, num_leading_zeros, m_precision, sig_c); set_exponent(c, exp_c); @@ -752,7 +752,7 @@ void mpff_manager::add_sub(bool is_sub, mpff const & a, mpff const & b, mpff & c reset(c); } else if (num_leading_zeros > 0) { - int64 exp_c = exp_a; + int64_t exp_c = exp_a; exp_c -= num_leading_zeros; shl(m_precision, sig_c, num_leading_zeros, m_precision, sig_c); set_exponent(c, exp_c); @@ -787,10 +787,10 @@ void mpff_manager::mul(mpff const & a, mpff const & b, mpff & c) { allocate_if_needed(c); TRACE("mpff", tout << "mul("; display(tout, a); tout << ", "; display(tout, b); tout << ")\n";); c.m_sign = a.m_sign ^ b.m_sign; - // use int64 to make sure we do not have overflows - int64 exp_a = a.m_exponent; - int64 exp_b = b.m_exponent; - int64 exp_c = exp_a + exp_b; + // use int64_t to make sure we do not have overflows + int64_t exp_a = a.m_exponent; + int64_t exp_b = b.m_exponent; + int64_t exp_c = exp_a + exp_b; // store result in m_buffers[0] unsigned * r = m_buffers[0].c_ptr(); m_mpn_manager.mul(sig(a), m_precision, sig(b), m_precision, r); @@ -834,7 +834,7 @@ void mpff_manager::div(mpff const & a, mpff const & b, mpff & c) { #if 1 else if (is_two(b)) { set(c, a); - int64 exp_c = a.m_exponent; + int64_t exp_c = a.m_exponent; exp_c--; set_exponent(c, exp_c); } @@ -842,10 +842,10 @@ void mpff_manager::div(mpff const & a, mpff const & b, mpff & c) { else { allocate_if_needed(c); c.m_sign = a.m_sign ^ b.m_sign; - // use int64 to make sure we do not have overflows - int64 exp_a = a.m_exponent; - int64 exp_b = b.m_exponent; - int64 exp_c = exp_a - exp_b; + // use int64_t to make sure we do not have overflows + int64_t exp_a = a.m_exponent; + int64_t exp_b = b.m_exponent; + int64_t exp_c = exp_a - exp_b; exp_c -= m_precision_bits; // we will multiplying (shifting) a by 2^m_precision_bits. // copy a to buffer 0, and shift by m_precision_bits @@ -1023,7 +1023,7 @@ void mpff_manager::power(mpff const & a, unsigned p, mpff & b) { b.m_sign = 0; else b.m_sign = a.m_sign; - int64 exp = a.m_exponent; + int64_t exp = a.m_exponent; exp *= p; if (exp > INT_MAX || exp < INT_MIN) throw overflow_exception(); @@ -1057,7 +1057,7 @@ void mpff_manager::power(mpff const & a, unsigned p, mpff & b) { bool mpff_manager::is_power_of_two(mpff const & a, unsigned & k) const { if (!is_power_of_two(a)) return false; - int64 exp = a.m_exponent + m_precision_bits - 1; + int64_t exp = a.m_exponent + m_precision_bits - 1; SASSERT(exp >= 0); k = static_cast(exp); return true; @@ -1132,7 +1132,7 @@ void mpff_manager::to_mpq_core(mpff const & n, mpq_manager & m, mpq & t) if (exp < 0) { // Avoid -INT_MIN == INT_MIN issue. It is not really useful, since we will run out of memory anyway. if (exp == INT_MIN) - abs_exp = static_cast(-static_cast(INT_MIN)); + abs_exp = static_cast(-static_cast(INT_MIN)); else abs_exp = -exp; } @@ -1177,7 +1177,7 @@ void mpff_manager::display(std::ostream & out, mpff const & n) const { svector & u_buffer = const_cast(this)->m_buffers[0]; int num_trailing_zeros = ntz(m_precision, u_buffer.c_ptr()); int shift = 0; - int64 exp = n.m_exponent; // use int64 to avoid -INT_MIN == INT_MIN issue + int64_t exp = n.m_exponent; // use int64_t to avoid -INT_MIN == INT_MIN issue if (exp < 0) { if (num_trailing_zeros >= -exp) { shift = static_cast(-exp); @@ -1194,7 +1194,7 @@ void mpff_manager::display(std::ostream & out, mpff const & n) const { out << m_mpn_manager.to_string(u_buffer.c_ptr(), m_precision, str_buffer.begin(), str_buffer.size()); if (exp > 0) { if (exp <= 63) { - uint64 _exp = 1; + uint64_t _exp = 1; _exp <<= exp; out << "*" << _exp; } @@ -1209,7 +1209,7 @@ void mpff_manager::display(std::ostream & out, mpff const & n) const { else if (exp < 0) { exp = -exp; if (exp <= 63) { - uint64 _exp = 1; + uint64_t _exp = 1; _exp <<= exp; out << "/" << _exp; } @@ -1225,8 +1225,8 @@ void mpff_manager::display(std::ostream & out, mpff const & n) const { void mpff_manager::display_decimal(std::ostream & out, mpff const & n, unsigned prec, unsigned min_exponent) { // The result in scientific notation when n.m_exponent >= min_exponent or n.m_exponent <= - min_exponent - m_precision_bits - int64 exp = n.m_exponent; - if (exp >= min_exponent || exp <= -static_cast(min_exponent) - m_precision_bits || is_int(n)) { + int64_t exp = n.m_exponent; + if (exp >= min_exponent || exp <= -static_cast(min_exponent) - m_precision_bits || is_int(n)) { display(out, n); return; } @@ -1327,7 +1327,7 @@ void mpff_manager::display_smt2(std::ostream & out, mpff const & n, bool decimal svector & u_buffer = const_cast(this)->m_buffers[0]; int num_trailing_zeros = ntz(m_precision, u_buffer.c_ptr()); int shift = 0; - int64 exp = n.m_exponent; + int64_t exp = n.m_exponent; if (exp < 0) { if (num_trailing_zeros >= -exp) { shift = static_cast(-exp); @@ -1353,7 +1353,7 @@ void mpff_manager::display_smt2(std::ostream & out, mpff const & n, bool decimal if (exp != 0) { if (exp < 0) exp = -exp; if (exp <= 63) { - uint64 _exp = 1; + uint64_t _exp = 1; _exp <<= exp; out << _exp; if (decimal) out << ".0"; @@ -1387,8 +1387,8 @@ unsigned mpff_manager::prev_power_of_two(mpff const & a) { return 0; if (a.m_exponent <= -static_cast(m_precision_bits)) return 0; // Number is smaller than 1 - SASSERT(static_cast(a.m_exponent) + static_cast(m_precision_bits) - 1 >= 0); - SASSERT(static_cast(a.m_exponent) + static_cast(m_precision_bits) - 1 <= static_cast(static_cast(UINT_MAX))); + SASSERT(static_cast(a.m_exponent) + static_cast(m_precision_bits) - 1 >= 0); + SASSERT(static_cast(a.m_exponent) + static_cast(m_precision_bits) - 1 <= static_cast(static_cast(UINT_MAX))); return m_precision_bits + a.m_exponent - 1; } diff --git a/src/util/mpff.h b/src/util/mpff.h index e34f2cb41..8023053d2 100644 --- a/src/util/mpff.h +++ b/src/util/mpff.h @@ -92,7 +92,7 @@ class mpff_manager { // // Remarks: // - // - All values of type int, unsigned, int64 and uint64 can be precisely represented as mpff numerals. + // - All values of type int, unsigned, int64_t and uint64_t can be precisely represented as mpff numerals. // // - Hardware float and double values (corresponding to rationals) can also be precisely represented as mpff numerals. // That is, NaN, +oo and -oo are not supported by this module. @@ -141,14 +141,14 @@ class mpff_manager { // copy (and shift by m_precision_bits) n to buffer idx void to_buffer_shifting(unsigned idx, mpff const & n) const; - void inc_significand(unsigned * s, int64 & exp); + void inc_significand(unsigned * s, int64_t & exp); void inc_significand(mpff & a); void dec_significand(mpff & a); bool min_significand(mpff const & a) const; void set_min_significand(mpff & a); void set_max_significand(mpff & a); - void set_big_exponent(mpff & a, int64 e); - void set_exponent(mpff & a, int64 e) { + void set_big_exponent(mpff & a, int64_t e); + void set_exponent(mpff & a, int64_t e) { if (e > INT_MAX || e < INT_MIN) set_big_exponent(a, e); else @@ -286,12 +286,12 @@ public: bool is_plus_epsilon(mpff const & a) const; /** - \brief Return true if \c a is an integer and fits in an int64 machine integer. + \brief Return true if \c a is an integer and fits in an int64_t machine integer. */ bool is_int64(mpff const & a) const; /** - \brief Return true if \c a is a non-negative integer and fits in an int64 machine integer. + \brief Return true if \c a is a non-negative integer and fits in an int64_t machine integer. */ bool is_uint64(mpff const & a) const; @@ -372,10 +372,10 @@ public: void set(mpff & n, int v); void set(mpff & n, unsigned v); - void set(mpff & n, int64 v); - void set(mpff & n, uint64 v); + void set(mpff & n, int64_t v); + void set(mpff & n, uint64_t v); void set(mpff & n, int num, unsigned den); - void set(mpff & n, int64 num, uint64 den); + void set(mpff & n, int64_t num, uint64_t den); void set(mpff & n, mpff const & v); void set(mpff & n, unsynch_mpz_manager & m, mpz const & v); void set(mpff & n, synch_mpz_manager & m, mpz const & v); @@ -448,14 +448,14 @@ public: \pre is_int64(n) */ - int64 get_int64(mpff const & n) const; + int64_t get_int64(mpff const & n) const; /** \brief Return n as an uint64. \pre is_uint64(n) */ - uint64 get_uint64(mpff const & n) const; + uint64_t get_uint64(mpff const & n) const; /** \brief Return the biggest k s.t. 2^k <= a. diff --git a/src/util/mpfx.cpp b/src/util/mpfx.cpp index e46708341..e17a5e766 100644 --- a/src/util/mpfx.cpp +++ b/src/util/mpfx.cpp @@ -164,10 +164,10 @@ void mpfx_manager::set(mpfx & n, unsigned v) { SASSERT(check(n)); } -void mpfx_manager::set(mpfx & n, int64 v) { +void mpfx_manager::set(mpfx & n, int64_t v) { if (m_int_part_sz == 1) { - if (v < -static_cast(static_cast(UINT_MAX)) || - v > static_cast(static_cast(UINT_MAX))) + if (v < -static_cast(static_cast(UINT_MAX)) || + v > static_cast(static_cast(UINT_MAX))) throw overflow_exception(); } if (v == 0) { @@ -175,11 +175,11 @@ void mpfx_manager::set(mpfx & n, int64 v) { } else { if (v < 0) { - set(n, static_cast(-v)); + set(n, static_cast(-v)); n.m_sign = 1; } else { - set(n, static_cast(v)); + set(n, static_cast(v)); } } SASSERT(is_int(n)); @@ -187,9 +187,9 @@ void mpfx_manager::set(mpfx & n, int64 v) { SASSERT(check(n)); } -void mpfx_manager::set(mpfx & n, uint64 v) { +void mpfx_manager::set(mpfx & n, uint64_t v) { if (m_int_part_sz == 1) { - if (v > static_cast(UINT_MAX)) + if (v > static_cast(UINT_MAX)) throw overflow_exception(); } @@ -200,7 +200,7 @@ void mpfx_manager::set(mpfx & n, uint64 v) { allocate_if_needed(n); n.m_sign = 0; unsigned * w = words(n); - uint64 * _vp = &v; + uint64_t * _vp = &v; unsigned * _v = nullptr; memcpy(&_v, &_vp, sizeof(unsigned*)); for (unsigned i = 0; i < m_total_sz; i++) @@ -226,7 +226,7 @@ void mpfx_manager::set(mpfx & n, int num, unsigned den) { SASSERT(check(n)); } -void mpfx_manager::set(mpfx & n, int64 num, uint64 den) { +void mpfx_manager::set(mpfx & n, int64_t num, uint64_t den) { scoped_mpfx a(*this), b(*this); set(a, num); set(b, den); @@ -677,27 +677,27 @@ bool mpfx_manager::is_power_of_two(mpfx const & a) const { return is_power_of_two(a, k); } -int64 mpfx_manager::get_int64(mpfx const & n) const { +int64_t mpfx_manager::get_int64(mpfx const & n) const { SASSERT(is_int64(n)); unsigned * w = words(n); w += m_frac_part_sz; - uint64 r = 0; - memcpy(&r, w, sizeof(uint64)); + uint64_t r = 0; + memcpy(&r, w, sizeof(uint64_t)); if (r == 0x8000000000000000ull) { SASSERT(is_neg(n)); return INT64_MIN; } else { - return is_neg(n) ? -static_cast(r) : r; + return is_neg(n) ? -static_cast(r) : r; } } -uint64 mpfx_manager::get_uint64(mpfx const & n) const { +uint64_t mpfx_manager::get_uint64(mpfx const & n) const { SASSERT(is_uint64(n)); unsigned * w = words(n); w += m_frac_part_sz; - uint64 r = 0; - memcpy(&r, w, sizeof(uint64)); + uint64_t r = 0; + memcpy(&r, w, sizeof(uint64_t)); return r; } diff --git a/src/util/mpfx.h b/src/util/mpfx.h index 03a805f69..a8e93f0b0 100644 --- a/src/util/mpfx.h +++ b/src/util/mpfx.h @@ -200,12 +200,12 @@ public: bool is_minus_one(mpfx const & n) const { return is_neg(n) && is_abs_one(n); } /** - \brief Return true if \c a is an integer and fits in an int64 machine integer. + \brief Return true if \c a is an integer and fits in an \c int64_t machine integer. */ bool is_int64(mpfx const & a) const; /** - \brief Return true if \c a is a non-negative integer and fits in an int64 machine integer. + \brief Return true if \c a is a non-negative integer and fits in an \c int64_t machine integer. */ bool is_uint64(mpfx const & a) const; @@ -306,10 +306,10 @@ public: void set(mpfx & n, int v); void set(mpfx & n, unsigned v); - void set(mpfx & n, int64 v); - void set(mpfx & n, uint64 v); + void set(mpfx & n, int64_t v); + void set(mpfx & n, uint64_t v); void set(mpfx & n, int num, unsigned den); - void set(mpfx & n, int64 num, uint64 den); + void set(mpfx & n, int64_t num, uint64_t den); void set(mpfx & n, mpfx const & v); void set(mpfx & n, unsynch_mpz_manager & m, mpz const & v); void set(mpfx & n, synch_mpz_manager & m, mpz const & v); @@ -343,14 +343,14 @@ public: \pre is_int64(n) */ - int64 get_int64(mpfx const & n) const; + int64_t get_int64(mpfx const & n) const; /** \brief Return n as an uint64. \pre is_uint64(n) */ - uint64 get_uint64(mpfx const & n) const; + uint64_t get_uint64(mpfx const & n) const; /** \brief Convert n into a mpz numeral. diff --git a/src/util/mpn.cpp b/src/util/mpn.cpp index 2059ea6fd..b8cab4a9f 100644 --- a/src/util/mpn.cpp +++ b/src/util/mpn.cpp @@ -23,7 +23,7 @@ Revision History: #define max(a,b) (((a) > (b)) ? (a) : (b)) -typedef uint64 mpn_double_digit; +typedef uint64_t mpn_double_digit; static_assert(sizeof(mpn_double_digit) == 2 * sizeof(mpn_digit), "size alignment"); const mpn_digit mpn_manager::zero = 0; diff --git a/src/util/mpq.h b/src/util/mpq.h index fd0ae13d4..f1b261278 100644 --- a/src/util/mpq.h +++ b/src/util/mpq.h @@ -686,7 +686,7 @@ public: normalize(a); } - void set(mpq & a, int64 n, uint64 d) { + void set(mpq & a, int64_t n, uint64_t d) { SASSERT(d != 0); set(a.m_num, n); set(a.m_den, d); @@ -718,16 +718,16 @@ public: void set(mpq & a, char const * val); - void set(mpz & a, int64 val) { mpz_manager::set(a, val); } + void set(mpz & a, int64_t val) { mpz_manager::set(a, val); } - void set(mpq & a, int64 val) { + void set(mpq & a, int64_t val) { set(a.m_num, val); reset_denominator(a); } - void set(mpz & a, uint64 val) { mpz_manager::set(a, val); } + void set(mpz & a, uint64_t val) { mpz_manager::set(a, val); } - void set(mpq & a, uint64 val) { + void set(mpq & a, uint64_t val) { set(a.m_num, val); reset_denominator(a); } @@ -765,17 +765,17 @@ public: bool is_int64(mpz const & a) const { return mpz_manager::is_int64(a); } - uint64 get_uint64(mpz const & a) const { return mpz_manager::get_uint64(a); } + uint64_t get_uint64(mpz const & a) const { return mpz_manager::get_uint64(a); } - int64 get_int64(mpz const & a) const { return mpz_manager::get_int64(a); } + int64_t get_int64(mpz const & a) const { return mpz_manager::get_int64(a); } bool is_uint64(mpq const & a) const { return is_int(a) && is_uint64(a.m_num); } bool is_int64(mpq const & a) const { return is_int(a) && is_int64(a.m_num); } - uint64 get_uint64(mpq const & a) const { SASSERT(is_uint64(a)); return get_uint64(a.m_num); } + uint64_t get_uint64(mpq const & a) const { SASSERT(is_uint64(a)); return get_uint64(a.m_num); } - int64 get_int64(mpq const & a) const { SASSERT(is_int64(a)); return get_int64(a.m_num); } + int64_t get_int64(mpq const & a) const { SASSERT(is_int64(a)); return get_int64(a.m_num); } double get_double(mpz const & a) const { return mpz_manager::get_double(a); } diff --git a/src/util/mpz.cpp b/src/util/mpz.cpp index 7ad472ef1..39ea428a7 100644 --- a/src/util/mpz.cpp +++ b/src/util/mpz.cpp @@ -81,7 +81,7 @@ static T gcd_core(T u, T v) { } unsigned u_gcd(unsigned u, unsigned v) { return gcd_core(u, v); } -uint64 u64_gcd(uint64 u, uint64 v) { return gcd_core(u, v); } +uint64_t u64_gcd(uint64_t u, uint64_t v) { return gcd_core(u, v); } template mpz_manager::mpz_manager(): @@ -89,7 +89,7 @@ mpz_manager::mpz_manager(): if (SYNCH) omp_init_nest_lock(&m_lock); #ifndef _MP_GMP - if (sizeof(digit_t) == sizeof(uint64)) { + if (sizeof(digit_t) == sizeof(uint64_t)) { // 64-bit machine m_init_cell_capacity = 4; } @@ -101,7 +101,7 @@ mpz_manager::mpz_manager(): m_arg[i] = allocate(m_init_cell_capacity); m_arg[i]->m_size = 1; } - set(m_int_min, -static_cast(INT_MIN)); + set(m_int_min, -static_cast(INT_MIN)); #else // GMP mpz_init(m_tmp); @@ -122,8 +122,8 @@ mpz_manager::mpz_manager(): mpz_init(m_int64_max); mpz_init(m_int64_min); - max_l = static_cast(INT64_MAX % static_cast(UINT_MAX)); - max_h = static_cast(INT64_MAX / static_cast(UINT_MAX)); + max_l = static_cast(INT64_MAX % static_cast(UINT_MAX)); + max_h = static_cast(INT64_MAX / static_cast(UINT_MAX)); mpz_set_ui(m_int64_max, max_h); mpz_set_ui(m_tmp, UINT_MAX); mpz_mul(m_int64_max, m_tmp, m_int64_max); @@ -134,7 +134,7 @@ mpz_manager::mpz_manager(): #endif mpz one(1); - set(m_two64, (uint64)UINT64_MAX); + set(m_two64, (uint64_t)UINT64_MAX); add(m_two64, one, m_two64); } @@ -162,13 +162,13 @@ mpz_manager::~mpz_manager() { } template -void mpz_manager::set_big_i64(mpz & c, int64 v) { +void mpz_manager::set_big_i64(mpz & c, int64_t v) { #ifndef _MP_GMP if (is_small(c)) { c.m_ptr = allocate(m_init_cell_capacity); } SASSERT(capacity(c) >= m_init_cell_capacity); - uint64 _v; + uint64_t _v; if (v < 0) { _v = -v; c.m_val = -1; @@ -177,7 +177,7 @@ void mpz_manager::set_big_i64(mpz & c, int64 v) { _v = v; c.m_val = 1; } - if (sizeof(digit_t) == sizeof(uint64)) { + if (sizeof(digit_t) == sizeof(uint64_t)) { // 64-bit machine digits(c)[0] = static_cast(_v); c.m_ptr->m_size = 1; @@ -192,7 +192,7 @@ void mpz_manager::set_big_i64(mpz & c, int64 v) { if (is_small(c)) { c.m_ptr = allocate(); } - uint64 _v; + uint64_t _v; bool sign; if (v < 0) { _v = -v; @@ -212,14 +212,14 @@ void mpz_manager::set_big_i64(mpz & c, int64 v) { } template -void mpz_manager::set_big_ui64(mpz & c, uint64 v) { +void mpz_manager::set_big_ui64(mpz & c, uint64_t v) { #ifndef _MP_GMP if (is_small(c)) { c.m_ptr = allocate(m_init_cell_capacity); } SASSERT(capacity(c) >= m_init_cell_capacity); c.m_val = 1; - if (sizeof(digit_t) == sizeof(uint64)) { + if (sizeof(digit_t) == sizeof(uint64_t)) { // 64-bit machine digits(c)[0] = static_cast(v); c.m_ptr->m_size = 1; @@ -726,7 +726,7 @@ void mpz_manager::gcd(mpz const & a, mpz const & b, mpz & c) { // For now, it only works if sizeof(digit_t) == sizeof(unsigned) static_assert(sizeof(digit_t) == sizeof(unsigned), ""); - int64 a_hat, b_hat, A, B, C, D, T, q, a_sz, b_sz; + int64_t a_hat, b_hat, A, B, C, D, T, q, a_sz, b_sz; mpz a1, b1, t, r, tmp; set(a1, a); set(b1, b); @@ -766,10 +766,10 @@ void mpz_manager::gcd(mpz const & a, mpz const & b, mpz & c) { D = 1; while (true) { // Loop invariants - SASSERT(a_hat + A <= static_cast(UINT_MAX) + 1); - SASSERT(a_hat + B < static_cast(UINT_MAX) + 1); - SASSERT(b_hat + C < static_cast(UINT_MAX) + 1); - SASSERT(b_hat + D <= static_cast(UINT_MAX) + 1); + SASSERT(a_hat + A <= static_cast(UINT_MAX) + 1); + SASSERT(a_hat + B < static_cast(UINT_MAX) + 1); + SASSERT(b_hat + C < static_cast(UINT_MAX) + 1); + SASSERT(b_hat + D <= static_cast(UINT_MAX) + 1); // overflows can't happen since I'm using int64 if (b_hat + C == 0 || b_hat + D == 0) break; @@ -1035,7 +1035,7 @@ void mpz_manager::bitwise_or(mpz const & a, mpz const & b, mpz & c) { mod(a1, m_two64, a2); mod(b1, m_two64, b2); TRACE("mpz", tout << "a2: " << to_string(a2) << ", b2: " << to_string(b2) << "\n";); - uint64 v = get_uint64(a2) | get_uint64(b2); + uint64_t v = get_uint64(a2) | get_uint64(b2); TRACE("mpz", tout << "uint(a2): " << get_uint64(a2) << ", uint(b2): " << get_uint64(b2) << "\n";); set(tmp, v); mul(tmp, m, tmp); @@ -1082,7 +1082,7 @@ void mpz_manager::bitwise_and(mpz const & a, mpz const & b, mpz & c) { while (!is_zero(a1) && !is_zero(b1)) { mod(a1, m_two64, a2); mod(b1, m_two64, b2); - uint64 v = get_uint64(a2) & get_uint64(b2); + uint64_t v = get_uint64(a2) & get_uint64(b2); set(tmp, v); mul(tmp, m, tmp); add(c, tmp, c); // c += m * v @@ -1119,7 +1119,7 @@ void mpz_manager::bitwise_xor(mpz const & a, mpz const & b, mpz & c) { while (!is_zero(a1) && !is_zero(b1)) { mod(a1, m_two64, a2); mod(b1, m_two64, b2); - uint64 v = get_uint64(a2) ^ get_uint64(b2); + uint64_t v = get_uint64(a2) ^ get_uint64(b2); set(tmp, v); mul(tmp, m, tmp); add(c, tmp, c); // c += m * v @@ -1151,7 +1151,7 @@ template void mpz_manager::bitwise_not(unsigned sz, mpz const & a, mpz & c) { SASSERT(is_nonneg(a)); if (is_small(a) && sz <= 63) { - int64 mask = (static_cast(1) << sz) - static_cast(1); + int64_t mask = (static_cast(1) << sz) - static_cast(1); set_i64(c, (~ i64(a)) & mask); } else { @@ -1161,11 +1161,11 @@ void mpz_manager::bitwise_not(unsigned sz, mpz const & a, mpz & c) { set(c, 0); while (sz > 0) { mod(a1, m_two64, a2); - uint64 n = get_uint64(a2); - uint64 v = ~n; + uint64_t n = get_uint64(a2); + uint64_t v = ~n; SASSERT(~v == n); if (sz < 64) { - uint64 mask = (1ull << static_cast(sz)) - 1ull; + uint64_t mask = (1ull << static_cast(sz)) - 1ull; v = mask & v; } TRACE("bitwise_not", tout << "sz: " << sz << ", v: " << v << ", n: " << n << "\n";); @@ -1265,7 +1265,7 @@ bool mpz_manager::is_uint64(mpz const & a) const { return false; if (is_small(a)) return true; - if (sizeof(digit_t) == sizeof(uint64)) { + if (sizeof(digit_t) == sizeof(uint64_t)) { return size(a) <= 1; } else { @@ -1286,9 +1286,9 @@ bool mpz_manager::is_int64(mpz const & a) const { #ifndef _MP_GMP if (!is_abs_uint64(a)) return false; - uint64 num = big_abs_to_uint64(a); - uint64 msb = static_cast(1) << 63; - uint64 msb_val = msb & num; + uint64_t num = big_abs_to_uint64(a); + uint64_t msb = static_cast(1) << 63; + uint64_t msb_val = msb & num; if (a.m_val >= 0) { // non-negative number. return (0 == msb_val); @@ -1307,54 +1307,54 @@ bool mpz_manager::is_int64(mpz const & a) const { } template -uint64 mpz_manager::get_uint64(mpz const & a) const { +uint64_t mpz_manager::get_uint64(mpz const & a) const { if (is_small(a)) - return static_cast(a.m_val); + return static_cast(a.m_val); #ifndef _MP_GMP SASSERT(a.m_ptr->m_size > 0); return big_abs_to_uint64(a); #else // GMP version - if (sizeof(uint64) == sizeof(unsigned long)) { + if (sizeof(uint64_t) == sizeof(unsigned long)) { return mpz_get_ui(*a.m_ptr); } else { mpz_manager * _this = const_cast(this); mpz_set(_this->m_tmp, *a.m_ptr); mpz_mod(_this->m_tmp, m_tmp, m_two32); - uint64 r = static_cast(mpz_get_ui(m_tmp)); + uint64_t r = static_cast(mpz_get_ui(m_tmp)); mpz_set(_this->m_tmp, *a.m_ptr); mpz_div(_this->m_tmp, m_tmp, m_two32); - r += static_cast(mpz_get_ui(m_tmp)) << static_cast(32); + r += static_cast(mpz_get_ui(m_tmp)) << static_cast(32); return r; } #endif } template -int64 mpz_manager::get_int64(mpz const & a) const { +int64_t mpz_manager::get_int64(mpz const & a) const { if (is_small(a)) - return static_cast(a.m_val); + return static_cast(a.m_val); #ifndef _MP_GMP SASSERT(is_int64(a)); - uint64 num = big_abs_to_uint64(a); + uint64_t num = big_abs_to_uint64(a); if (a.m_val < 0) { if (num != 0 && (num << 1) == 0) return INT64_MIN; - return -static_cast(num); + return -static_cast(num); } - return static_cast(num); + return static_cast(num); #else // GMP - if (sizeof(int64) == sizeof(long) || mpz_fits_slong_p(*a.m_ptr)) { + if (sizeof(int64_t) == sizeof(long) || mpz_fits_slong_p(*a.m_ptr)) { return mpz_get_si(*a.m_ptr); } else { mpz_manager * _this = const_cast(this); mpz_mod(_this->m_tmp, *a.m_ptr, m_two32); - int64 r = static_cast(mpz_get_ui(m_tmp)); + int64_t r = static_cast(mpz_get_ui(m_tmp)); mpz_div(_this->m_tmp, *a.m_ptr, m_two32); - r += static_cast(mpz_get_si(m_tmp)) << static_cast(32); + r += static_cast(mpz_get_si(m_tmp)) << static_cast(32); return r; } #endif @@ -1370,7 +1370,7 @@ double mpz_manager::get_double(mpz const & a) const { unsigned sz = size(a); for (unsigned i = 0; i < sz; i++) { r += d * static_cast(digits(a)[i]); - if (sizeof(digit_t) == sizeof(uint64)) + if (sizeof(digit_t) == sizeof(uint64_t)) d *= static_cast(UINT64_MAX); // 64-bit version else d *= static_cast(UINT_MAX); // 32-bit version @@ -1696,7 +1696,7 @@ void mpz_manager::mul2k(mpz & a, unsigned k) { if (k == 0 || is_zero(a)) return; if (is_small(a) && k < 32) { - set_i64(a, i64(a) * (static_cast(1) << k)); + set_i64(a, i64(a) * (static_cast(1) << k)); return; } #ifndef _MP_GMP @@ -1798,9 +1798,9 @@ unsigned mpz_manager::power_of_two_multiple(mpz const & a) { if (sizeof(digit_t) == 8) { // TODO: we can remove this if after we move to MPN // In MPN the digit_t is always an unsigned integer - if (static_cast(v) % (static_cast(1) << 32) == 0) { + if (static_cast(v) % (static_cast(1) << 32) == 0) { r += 32; - v = static_cast(static_cast(v) / (static_cast(1) << 32)); + v = static_cast(static_cast(v) / (static_cast(1) << 32)); } } COUNT_DIGIT_RIGHT_ZEROS(); diff --git a/src/util/mpz.h b/src/util/mpz.h index f4c3f6f0d..92c6d0d10 100644 --- a/src/util/mpz.h +++ b/src/util/mpz.h @@ -30,7 +30,7 @@ Revision History: #include "util/mpn.h" unsigned u_gcd(unsigned u, unsigned v); -uint64 u64_gcd(uint64 u, uint64 v); +uint64_t u64_gcd(uint64_t u, uint64_t v); #ifdef _MP_GMP typedef unsigned digit_t; @@ -192,11 +192,11 @@ class mpz_manager { template void set(mpz & a, int sign, unsigned sz); - static int64 i64(mpz const & a) { return static_cast(a.m_val); } + static int64_t i64(mpz const & a) { return static_cast(a.m_val); } - void set_big_i64(mpz & c, int64 v); + void set_big_i64(mpz & c, int64_t v); - void set_i64(mpz & c, int64 v) { + void set_i64(mpz & c, int64_t v) { if (v >= INT_MIN && v <= INT_MAX) { del(c); c.m_val = static_cast(v); @@ -208,7 +208,7 @@ class mpz_manager { } } - void set_big_ui64(mpz & c, uint64 v); + void set_big_ui64(mpz & c, uint64_t v); #ifndef _MP_GMP static unsigned capacity(mpz const & c) { return c.m_ptr->m_capacity; } @@ -221,24 +221,24 @@ class mpz_manager { static bool is_abs_uint64(mpz const & a) { if (is_small(a)) return true; - if (sizeof(digit_t) == sizeof(uint64)) + if (sizeof(digit_t) == sizeof(uint64_t)) return size(a) <= 1; else return size(a) <= 2; } // CAST the absolute value into a UINT64 - static uint64 big_abs_to_uint64(mpz const & a) { + static uint64_t big_abs_to_uint64(mpz const & a) { SASSERT(is_abs_uint64(a)); SASSERT(!is_small(a)); if (a.m_ptr->m_size == 1) return digits(a)[0]; - if (sizeof(digit_t) == sizeof(uint64)) + if (sizeof(digit_t) == sizeof(uint64_t)) // 64-bit machine return digits(a)[0]; else // 32-bit machine - return ((static_cast(digits(a)[1]) << 32) | (static_cast(digits(a)[0]))); + return ((static_cast(digits(a)[1]) << 32) | (static_cast(digits(a)[0]))); } template @@ -426,8 +426,8 @@ public: void machine_div_rem(mpz const & a, mpz const & b, mpz & q, mpz & r) { STRACE("mpz", tout << "[mpz-ext] divrem(" << to_string(a) << ", " << to_string(b) << ") == ";); if (is_small(a) && is_small(b)) { - int64 _a = i64(a); - int64 _b = i64(b); + int64_t _a = i64(a); + int64_t _b = i64(b); set_i64(q, _a / _b); set_i64(r, _a % _b); } @@ -686,16 +686,16 @@ public: if (val <= INT_MAX) set(a, static_cast(val)); else - set(a, static_cast(static_cast(val))); + set(a, static_cast(static_cast(val))); } void set(mpz & a, char const * val); - void set(mpz & a, int64 val) { + void set(mpz & a, int64_t val) { set_i64(a, val); } - void set(mpz & a, uint64 val) { + void set(mpz & a, uint64_t val) { if (val < INT_MAX) { del(a); a.m_val = static_cast(val); @@ -729,9 +729,9 @@ public: bool is_int64(mpz const & a) const; - uint64 get_uint64(mpz const & a) const; + uint64_t get_uint64(mpz const & a) const; - int64 get_int64(mpz const & a) const; + int64_t get_int64(mpz const & a) const; bool is_uint(mpz const & a) const { return is_uint64(a) && get_uint64(a) < UINT_MAX; } diff --git a/src/util/mpzzp.h b/src/util/mpzzp.h index a30eff7b6..82ed55bbc 100644 --- a/src/util/mpzzp.h +++ b/src/util/mpzzp.h @@ -87,7 +87,7 @@ public: setup_p(); } - mpzzp_manager(numeral_manager & _m, uint64 p, bool prime = true): + mpzzp_manager(numeral_manager & _m, uint64_t p, bool prime = true): m_manager(_m), m_z(false) { m().set(m_p, p); @@ -120,7 +120,7 @@ public: void set_z() { m_z = true; } void set_zp(mpz const & new_p) { m_z = false; m_p_prime = true; m().set(m_p, new_p); setup_p(); } - void set_zp(uint64 new_p) { m_z = false; m_p_prime = true; m().set(m_p, new_p); setup_p(); } + void set_zp(uint64_t new_p) { m_z = false; m_p_prime = true; m().set(m_p, new_p); setup_p(); } // p = p^2 void set_p_sq() { SASSERT(!m_z); m_p_prime = false; m().mul(m_p, m_p, m_p); setup_p(); } void set_zp_swap(mpz & new_p) { SASSERT(!m_z); m().swap(m_p, new_p); setup_p(); } @@ -230,14 +230,14 @@ public: void set(mpz & a, int val) { m().set(a, val); p_normalize(a); } void set(mpz & a, unsigned val) { m().set(a, val); p_normalize(a); } void set(mpz & a, char const * val) { m().set(a, val); p_normalize(a); } - void set(mpz & a, int64 val) { m().set(a, val); p_normalize(a); } - void set(mpz & a, uint64 val) { m().set(a, val); p_normalize(a); } + void set(mpz & a, int64_t val) { m().set(a, val); p_normalize(a); } + void set(mpz & a, uint64_t val) { m().set(a, val); p_normalize(a); } void set(mpz & a, mpz const & val) { m().set(a, val); p_normalize(a); } bool is_uint64(mpz & a) const { const_cast(this)->p_normalize(a); return m().is_uint64(a); } bool is_int64(mpz & a) const { const_cast(this)->p_normalize(a); return m().is_int64(a); } - uint64 get_uint64(mpz & a) const { const_cast(this)->p_normalize(a); return m().get_uint64(a); } - int64 get_int64(mpz & a) const { const_cast(this)->p_normalize(a); return m().get_int64(a); } + uint64_t get_uint64(mpz & a) const { const_cast(this)->p_normalize(a); return m().get_uint64(a); } + int64_t get_int64(mpz & a) const { const_cast(this)->p_normalize(a); return m().get_int64(a); } double get_double(mpz & a) const { const_cast(this)->p_normalize(a); return m().get_double(a); } void power(mpz const & a, unsigned k, mpz & b) { SASSERT(is_p_normalized(a)); @@ -265,8 +265,8 @@ public: bool is_uint64(mpz const & a) const { return m().is_uint64(a); } bool is_int64(mpz const & a) const { return m().is_int64(a); } - uint64 get_uint64(mpz const & a) const { return m().get_uint64(a); } - int64 get_int64(mpz const & a) const { return m().get_int64(a); } + uint64_t get_uint64(mpz const & a) const { return m().get_uint64(a); } + int64_t get_int64(mpz const & a) const { return m().get_int64(a); } void mul2k(mpz & a, unsigned k) { m().mul2k(a, k); p_normalize(a); } void mul2k(mpz const & a, unsigned k, mpz & r) { m().mul2k(a, k, r); p_normalize(r); } diff --git a/src/util/prime_generator.cpp b/src/util/prime_generator.cpp index dbcccaaf7..6c0376e52 100644 --- a/src/util/prime_generator.cpp +++ b/src/util/prime_generator.cpp @@ -26,11 +26,11 @@ prime_generator::prime_generator() { process_next_k_numbers(128); } -void prime_generator::process_next_k_numbers(uint64 k) { - svector todo; - uint64 begin = m_primes.back() + 2; - uint64 end = begin + k; - for (uint64 i = begin; i < end; i+=2) { +void prime_generator::process_next_k_numbers(uint64_t k) { + svector todo; + uint64_t begin = m_primes.back() + 2; + uint64_t end = begin + k; + for (uint64_t i = begin; i < end; i+=2) { todo.push_back(i); } unsigned j = 1; @@ -38,7 +38,7 @@ void prime_generator::process_next_k_numbers(uint64 k) { while (!todo.empty()) { unsigned sz = m_primes.size(); for (; j < sz; j++) { - uint64 p = m_primes[j]; + uint64_t p = m_primes[j]; unsigned todo_sz = todo.size(); unsigned k1 = 0; unsigned k2 = 0; @@ -59,7 +59,7 @@ void prime_generator::process_next_k_numbers(uint64 k) { return; } } - uint64 p = m_primes.back(); + uint64_t p = m_primes.back(); p = p*p; unsigned todo_sz = todo.size(); unsigned k1 = 0; @@ -83,7 +83,7 @@ void prime_generator::finalize() { m_primes.finalize(); } -uint64 prime_generator::operator()(unsigned idx) { +uint64_t prime_generator::operator()(unsigned idx) { if (idx < m_primes.size()) return m_primes[idx]; if (idx > PRIME_LIST_MAX_SIZE) @@ -109,14 +109,14 @@ prime_iterator::prime_iterator(prime_generator * g):m_idx(0) { } } -uint64 prime_iterator::next() { +uint64_t prime_iterator::next() { unsigned idx = m_idx; m_idx++; if (!m_global) { return (*m_generator)(idx); } else { - uint64 r; + uint64_t r; #pragma omp critical (prime_iterator) { r = (*m_generator)(idx); diff --git a/src/util/prime_generator.h b/src/util/prime_generator.h index 2e16ebfbe..bd388954c 100644 --- a/src/util/prime_generator.h +++ b/src/util/prime_generator.h @@ -32,11 +32,11 @@ public: \brief Prime generator */ class prime_generator { - svector m_primes; - void process_next_k_numbers(uint64 k); + svector m_primes; + void process_next_k_numbers(uint64_t k); public: prime_generator(); - uint64 operator()(unsigned idx); + uint64_t operator()(unsigned idx); void finalize(); }; @@ -46,7 +46,7 @@ class prime_iterator { bool m_global; public: prime_iterator(prime_generator * g = nullptr); - uint64 next(); + uint64_t next(); static void finalize(); /* ADD_FINALIZER('prime_iterator::finalize();') diff --git a/src/util/rational.h b/src/util/rational.h index 392a1982b..dc7b79419 100644 --- a/src/util/rational.h +++ b/src/util/rational.h @@ -59,10 +59,10 @@ public: explicit rational(char const * v) { m().set(m_val, v); } struct i64 {}; - rational(int64 i, i64) { m().set(m_val, i); } + rational(int64_t i, i64) { m().set(m_val, i); } struct ui64 {}; - rational(uint64 i, ui64) { m().set(m_val, i); } + rational(uint64_t i, ui64) { m().set(m_val, i); } ~rational() { m().del(m_val); } @@ -98,9 +98,9 @@ public: bool is_int64() const { return m().is_int64(m_val); } - uint64 get_uint64() const { return m().get_uint64(m_val); } + uint64_t get_uint64() const { return m().get_uint64(m_val); } - int64 get_int64() const { return m().get_int64(m_val); } + int64_t get_int64() const { return m().get_int64(m_val); } bool is_unsigned() const { return is_uint64() && (get_uint64() < (1ull << 32)); } @@ -113,7 +113,7 @@ public: if (is_small() && is_int()) return true; // we don't assume that if it is small, then it is int32. if (!is_int64()) return false; - int64 v = get_int64(); + int64_t v = get_int64(); return INT_MIN <= v && v <= INT_MAX; } diff --git a/src/util/rlimit.cpp b/src/util/rlimit.cpp index e625cab95..e3afd0d92 100644 --- a/src/util/rlimit.cpp +++ b/src/util/rlimit.cpp @@ -26,7 +26,7 @@ reslimit::reslimit(): m_limit(0) { } -uint64 reslimit::count() const { +uint64_t reslimit::count() const { return m_count; } @@ -41,7 +41,7 @@ bool reslimit::inc(unsigned offset) { } void reslimit::push(unsigned delta_limit) { - uint64 new_limit = delta_limit + m_count; + uint64_t new_limit = delta_limit + m_count; if (new_limit <= m_count) { new_limit = 0; } diff --git a/src/util/rlimit.h b/src/util/rlimit.h index 0c81f9449..60d26be7f 100644 --- a/src/util/rlimit.h +++ b/src/util/rlimit.h @@ -24,9 +24,9 @@ Revision History: class reslimit { volatile unsigned m_cancel; bool m_suspend; - uint64 m_count; - uint64 m_limit; - svector m_limits; + uint64_t m_count; + uint64_t m_limit; + svector m_limits; ptr_vector m_children; void set_cancel(unsigned f); @@ -41,7 +41,7 @@ public: bool inc(); bool inc(unsigned offset); - uint64 count() const; + uint64_t count() const; bool get_cancel_flag() const { return m_cancel > 0 && !m_suspend; } diff --git a/src/util/s_integer.h b/src/util/s_integer.h index 658ae8eea..80310368d 100644 --- a/src/util/s_integer.h +++ b/src/util/s_integer.h @@ -46,9 +46,9 @@ public: s_integer(const s_integer & r):m_val(r.m_val) {} explicit s_integer(int n):m_val(n) {} struct i64 {}; - explicit s_integer(int64 i, i64):m_val(static_cast(i)) {} + explicit s_integer(int64_t i, i64):m_val(static_cast(i)) {} struct ui64 {}; - explicit s_integer(uint64 i, ui64):m_val(static_cast(i)) {} + explicit s_integer(uint64_t i, ui64):m_val(static_cast(i)) {} explicit s_integer(const char * str); explicit s_integer(const rational & r):m_val(static_cast(r.get_int64())) {} @@ -60,8 +60,8 @@ public: static bool is_int64() { return true; } static bool is_uint64() { return true; } int get_int() const { return m_val; } - int64 get_int64() const { return m_val; } - uint64 get_uint64() const { return m_val; } + int64_t get_int64() const { return m_val; } + uint64_t get_uint64() const { return m_val; } static bool is_unsigned() { return true; } unsigned get_unsigned() const { return static_cast(m_val); } s_integer const& get_s_integer() const { return *this; } diff --git a/src/util/total_order.h b/src/util/total_order.h index a309b63a1..44ab6f749 100644 --- a/src/util/total_order.h +++ b/src/util/total_order.h @@ -35,7 +35,7 @@ class total_order { struct cell { cell * m_next; cell * m_prev; - uint64 m_val; + uint64_t m_val; T m_data; }; @@ -53,11 +53,11 @@ class total_order { m_base.m_val = 0; } - uint64 v(cell * a) const { return a->m_val; } + uint64_t v(cell * a) const { return a->m_val; } - uint64 vb(cell * a) const { return v(a) - v(base()); } + uint64_t vb(cell * a) const { return v(a) - v(base()); } - uint64 vbn(cell * a) const { return a->m_next == base() ? UINT64_MAX : vb(a->m_next); } + uint64_t vbn(cell * a) const { return a->m_next == base() ? UINT64_MAX : vb(a->m_next); } cell * mk_cell(T const & a) { SASSERT(!m_map.contains(a)); @@ -84,18 +84,18 @@ class total_order { } void _insert_after(cell * a, cell * b) { - uint64 vb_a = vb(a); - uint64 vbn_a = vbn(a); + uint64_t vb_a = vb(a); + uint64_t vbn_a = vbn(a); SASSERT(vb_a < vbn_a); if (vbn_a < 2 || (vb_a > vbn_a - 2)) { TRACE("total_order", tout << "relabeling...\n"; tout << "\n";); - uint64 v0 = v(a); - unsigned sz = size(); - uint64 ideal_gap = UINT64_MAX / sz; - uint64 goal_gap = ideal_gap / 32; - cell * c = a->m_next->m_next; - unsigned j = 2; - uint64 curr_gap = (v(c) - v0) / j; + uint64_t v0 = v(a); + unsigned sz = size(); + uint64_t ideal_gap = UINT64_MAX / sz; + uint64_t goal_gap = ideal_gap / 32; + cell * c = a->m_next->m_next; + unsigned j = 2; + uint64_t curr_gap = (v(c) - v0) / j; while (j < sz && curr_gap < goal_gap) { j++; c = c->m_next; @@ -105,7 +105,7 @@ class total_order { if (j == sz) curr_gap = ideal_gap; c = a->m_next; - uint64 inc = curr_gap; + uint64_t inc = curr_gap; for (unsigned i = 0; i < j; i++) { c->m_val = v0 + inc; c = c->m_next; @@ -116,7 +116,7 @@ class total_order { vbn_a = vbn(a); } SASSERT(vb_a <= vbn_a - 2); - uint64 vb_b = vb_a + ((vbn_a - vb_a)/2); + uint64_t vb_b = vb_a + ((vbn_a - vb_a)/2); SASSERT(vb_b > vb_a); SASSERT(vb_b < vbn_a); b->m_val = vb_b + v(base()); diff --git a/src/util/util.cpp b/src/util/util.cpp index 0b58419f8..8ffa89877 100644 --- a/src/util/util.cpp +++ b/src/util/util.cpp @@ -80,7 +80,7 @@ unsigned log2(unsigned v) { return r; } -unsigned uint64_log2(uint64 v) { +unsigned uint64_log2(uint64_t v) { unsigned r = 0; if (v & 0xFFFFFFFF00000000ull) { v >>= 32; diff --git a/src/util/util.h b/src/util/util.h index ad427dfaf..3fc6f6510 100644 --- a/src/util/util.h +++ b/src/util/util.h @@ -29,23 +29,11 @@ Revision History: #define SIZE_MAX std::numeric_limits::max() #endif -#ifndef uint64 -typedef unsigned long long uint64; -#endif - -static_assert(sizeof(uint64) == 8, "64 bits please"); - -#ifndef int64 -typedef long long int64; -#endif - -static_assert(sizeof(int64) == 8, "64 bits"); - #ifndef INT64_MIN -#define INT64_MIN static_cast(0x8000000000000000ull) +#define INT64_MIN static_cast(0x8000000000000000ull) #endif #ifndef INT64_MAX -#define INT64_MAX static_cast(0x7fffffffffffffffull) +#define INT64_MAX static_cast(0x7fffffffffffffffull) #endif #ifndef UINT64_MAX #define UINT64_MAX 0xffffffffffffffffull @@ -110,7 +98,7 @@ inline unsigned next_power_of_two(unsigned v) { \brief Return the position of the most significant bit. */ unsigned log2(unsigned v); -unsigned uint64_log2(uint64 v); +unsigned uint64_log2(uint64_t v); static_assert(sizeof(unsigned) == 4, "unsigned are 32 bits"); @@ -136,11 +124,11 @@ static inline unsigned get_num_1bits(unsigned v) { // Remark: on gcc, the operators << and >> do not produce zero when the second argument >= 64. // So, I'm using the following two definitions to fix the problem -static inline uint64 shift_right(uint64 x, uint64 y) { +static inline uint64_t shift_right(uint64_t x, uint64_t y) { return y < 64ull ? (x >> y) : 0ull; } -static inline uint64 shift_left(uint64 x, uint64 y) { +static inline uint64_t shift_left(uint64_t x, uint64_t y) { return y < 64ull ? (x << y) : 0ull; } From 21a3b9c8e2d61af7b0b71260430402c68bbf2585 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Sat, 31 Mar 2018 05:20:47 -0700 Subject: [PATCH 082/109] increment version number due to ABI/API breaking change #1556 Signed-off-by: Nikolaj Bjorner --- CMakeLists.txt | 2 +- scripts/mk_project.py | 2 +- src/api/dotnet/AlgebraicNum.cs | 4 ++-- src/api/dotnet/BitVecNum.cs | 4 ++-- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index c11c272be..bd3774ac7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -34,7 +34,7 @@ endif() ################################################################################ set(Z3_VERSION_MAJOR 4) set(Z3_VERSION_MINOR 6) -set(Z3_VERSION_PATCH 2) +set(Z3_VERSION_PATCH 3) set(Z3_VERSION_TWEAK 0) set(Z3_VERSION "${Z3_VERSION_MAJOR}.${Z3_VERSION_MINOR}.${Z3_VERSION_PATCH}.${Z3_VERSION_TWEAK}") set(Z3_FULL_VERSION_STR "${Z3_VERSION}") # Note this might be modified diff --git a/scripts/mk_project.py b/scripts/mk_project.py index 2f7402760..b77975dfa 100644 --- a/scripts/mk_project.py +++ b/scripts/mk_project.py @@ -9,7 +9,7 @@ from mk_util import * # Z3 Project definition def init_project_def(): - set_version(4, 6, 2, 0) + set_version(4, 6, 3, 0) add_lib('util', []) add_lib('lp', ['util'], 'util/lp') add_lib('polynomial', ['util'], 'math/polynomial') diff --git a/src/api/dotnet/AlgebraicNum.cs b/src/api/dotnet/AlgebraicNum.cs index 66552f1a0..3687e1f83 100644 --- a/src/api/dotnet/AlgebraicNum.cs +++ b/src/api/dotnet/AlgebraicNum.cs @@ -3,11 +3,11 @@ Copyright (c) 2012 Microsoft Corporation Module Name: - IntNum.cs + AlgebraicNum.cs Abstract: - Z3 Managed API: Int Numerals + Z3 Managed API: Algebraic Numerals Author: diff --git a/src/api/dotnet/BitVecNum.cs b/src/api/dotnet/BitVecNum.cs index c6ac471f6..66054761a 100644 --- a/src/api/dotnet/BitVecNum.cs +++ b/src/api/dotnet/BitVecNum.cs @@ -3,11 +3,11 @@ Copyright (c) 2012 Microsoft Corporation Module Name: - IntNum.cs + BitVecNum.cs Abstract: - Z3 Managed API: Int Numerals + Z3 Managed API: BitVec Numerals Author: From 6b38edf102a84e9b6da62f8700107276a9791502 Mon Sep 17 00:00:00 2001 From: Moritz Kiefer Date: Tue, 3 Apr 2018 11:57:31 +0200 Subject: [PATCH 083/109] Fix buffering issue in print_success for declare-datatype --- src/parsers/smt2/smt2parser.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/parsers/smt2/smt2parser.cpp b/src/parsers/smt2/smt2parser.cpp index 9265312d4..e72b9ad79 100644 --- a/src/parsers/smt2/smt2parser.cpp +++ b/src/parsers/smt2/smt2parser.cpp @@ -949,8 +949,9 @@ namespace smt2 { check_duplicate(d, line, pos); d->commit(pm()); - check_rparen_next("invalid end of datatype declaration, ')' expected"); + check_rparen("invalid end of datatype declaration, ')' expected"); m_ctx.print_success(); + next(); } From 5ba939ad5eabac44317ecd24867b00d0a632be9a Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Tue, 3 Apr 2018 12:40:18 -0700 Subject: [PATCH 084/109] add tuple shortcut and example to C++ API Signed-off-by: Nikolaj Bjorner --- examples/c++/example.cpp | 11 +++++++++++ src/api/c++/z3++.h | 22 ++++++++++++++++++++++ 2 files changed, 33 insertions(+) diff --git a/examples/c++/example.cpp b/examples/c++/example.cpp index df977268a..ed5bf7086 100644 --- a/examples/c++/example.cpp +++ b/examples/c++/example.cpp @@ -920,6 +920,16 @@ void enum_sort_example() { std::cout << "2: " << result_goal.as_expr() << std::endl; } +void tuple_example() { + std::cout << "tuple example\n"; + context ctx; + const char * names[] = { "first", "second" }; + sort sorts[2] = { ctx.int_sort(), ctx.bool_sort() }; + func_decl_vector projs(ctx); + func_decl pair = ctx.tuple_sort("pair", 2, names, sorts, projs); + std::cout << pair << "\n"; +} + void expr_vector_example() { std::cout << "expr_vector example\n"; context c; @@ -1179,6 +1189,7 @@ int main() { incremental_example2(); std::cout << "\n"; incremental_example3(); std::cout << "\n"; enum_sort_example(); std::cout << "\n"; + tuple_example(); std::cout << "\n"; expr_vector_example(); std::cout << "\n"; exists_expr_vector_example(); std::cout << "\n"; substitute_example(); std::cout << "\n"; diff --git a/src/api/c++/z3++.h b/src/api/c++/z3++.h index 42467cb22..6f46f9440 100644 --- a/src/api/c++/z3++.h +++ b/src/api/c++/z3++.h @@ -267,6 +267,15 @@ namespace z3 { and in \c ts the predicates for testing if terms of the enumeration sort correspond to an enumeration. */ sort enumeration_sort(char const * name, unsigned n, char const * const * enum_names, func_decl_vector & cs, func_decl_vector & ts); + + /** + \brief Return a tuple constructor. + \c name is the name of the returned constructor, + \c n are the number of arguments, \c names and \c sorts are their projected sorts. + \c projs is an output paramter. It contains the set of projection functions. + */ + func_decl tuple_sort(char const * name, unsigned n, char const * const * names, sort const* sorts, func_decl_vector & projs); + /** \brief create an uninterpreted sort with the name given by the string or symbol. */ @@ -2432,6 +2441,19 @@ namespace z3 { for (unsigned i = 0; i < n; i++) { cs.push_back(func_decl(*this, _cs[i])); ts.push_back(func_decl(*this, _ts[i])); } return s; } + inline func_decl context::tuple_sort(char const * name, unsigned n, char const * const * names, sort const* sorts, func_decl_vector & projs) { + array _names(n); + array _sorts(n); + for (unsigned i = 0; i < n; i++) { _names[i] = Z3_mk_string_symbol(*this, names[i]); _sorts[i] = sorts[i]; } + array _projs(n); + Z3_symbol _name = Z3_mk_string_symbol(*this, name); + Z3_func_decl tuple; + sort _ignore_s = to_sort(*this, Z3_mk_tuple_sort(*this, _name, n, _names.ptr(), _sorts.ptr(), &tuple, _projs.ptr())); + check_error(); + for (unsigned i = 0; i < n; i++) { projs.push_back(func_decl(*this, _projs[i])); } + return func_decl(*this, tuple); + } + inline sort context::uninterpreted_sort(char const* name) { Z3_symbol _name = Z3_mk_string_symbol(*this, name); return to_sort(*this, Z3_mk_uninterpreted_sort(*this, _name)); From 793642f48dd602f6532a6f94d63d1c9b08528f7b Mon Sep 17 00:00:00 2001 From: "Christoph M. Wintersteiger" Date: Thu, 5 Apr 2018 15:23:16 +0100 Subject: [PATCH 085/109] Fixed MPF to_sbv. Thanks to Florian Schanda for reporting this bug. --- src/util/mpf.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/util/mpf.cpp b/src/util/mpf.cpp index b9829f02d..bfa6f4726 100644 --- a/src/util/mpf.cpp +++ b/src/util/mpf.cpp @@ -1194,7 +1194,7 @@ void mpf_manager::to_sbv_mpq(mpf_rounding_mode rm, const mpf & x, scoped_mpq & o m_mpz_manager.set(z, t.significand()); mpf_exp_t e = (mpf_exp_t)t.exponent() - t.sbits() + 1; if (e < 0) { - bool last = false, round = false, sticky = m_mpz_manager.is_odd(z); + bool last = m_mpz_manager.is_odd(z), round = false, sticky = false; for (; e != 0; e++) { m_mpz_manager.machine_div2k(z, 1); sticky |= round; @@ -1204,7 +1204,7 @@ void mpf_manager::to_sbv_mpq(mpf_rounding_mode rm, const mpf & x, scoped_mpq & o bool inc = false; switch (rm) { case MPF_ROUND_NEAREST_TEVEN: inc = round && (last || sticky); break; - case MPF_ROUND_NEAREST_TAWAY: inc = round && (!last || sticky); break; // CMW: Check! + case MPF_ROUND_NEAREST_TAWAY: inc = round; break; case MPF_ROUND_TOWARD_POSITIVE: inc = (!x.sign && (round || sticky)); break; case MPF_ROUND_TOWARD_NEGATIVE: inc = (x.sign && (round || sticky)); break; case MPF_ROUND_TOWARD_ZERO: inc = false; break; From 328ad248b67f3cce4ad4fbc619d0e22624c06c0b Mon Sep 17 00:00:00 2001 From: "Christoph M. Wintersteiger" Date: Thu, 5 Apr 2018 15:26:25 +0100 Subject: [PATCH 086/109] Fixed overflow problem in fp.to_?bv. Thanks to Florian Schanda for reporting this bug. --- src/ast/fpa/fpa2bv_converter.cpp | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/src/ast/fpa/fpa2bv_converter.cpp b/src/ast/fpa/fpa2bv_converter.cpp index df5d56505..7344f6f2f 100644 --- a/src/ast/fpa/fpa2bv_converter.cpp +++ b/src/ast/fpa/fpa2bv_converter.cpp @@ -3241,18 +3241,20 @@ void fpa2bv_converter::mk_to_bv(func_decl * f, unsigned num, expr * const * args dbg_decouple("fpa2bv_to_bv_inc", inc); dbg_decouple("fpa2bv_to_bv_pre_rounded", pre_rounded); - pre_rounded = m.mk_ite(x_is_neg, m_bv_util.mk_bv_neg(pre_rounded), pre_rounded); - - expr_ref ll(m), ul(m), in_range(m); + expr_ref ul(m), ovfl(m), in_range(m); if (!is_signed) { - ll = m_bv_util.mk_numeral(0, bv_sz+3); ul = m_bv_util.mk_zero_extend(3, m_bv_util.mk_numeral(-1, bv_sz)); + in_range = m.mk_and(m.mk_not(x_is_neg), m_bv_util.mk_ule(pre_rounded, ul)); } else { + expr_ref ll(m); ll = m_bv_util.mk_sign_extend(3, m_bv_util.mk_concat(bv1, m_bv_util.mk_numeral(0, bv_sz-1))); ul = m_bv_util.mk_zero_extend(4, m_bv_util.mk_numeral(-1, bv_sz-1)); + pre_rounded = m.mk_ite(x_is_neg, m_bv_util.mk_bv_neg(pre_rounded), pre_rounded); + in_range = m.mk_and(m.mk_not(ovfl), m_bv_util.mk_sle(ll, pre_rounded), m_bv_util.mk_sle(pre_rounded, ul)); + dbg_decouple("fpa2bv_to_bv_in_range_ll", ll); } - in_range = m.mk_and(m_bv_util.mk_sle(ll, pre_rounded), m_bv_util.mk_sle(pre_rounded, ul)); + dbg_decouple("fpa2bv_to_bv_in_range_ul", ul); dbg_decouple("fpa2bv_to_bv_in_range", in_range); expr_ref rounded(m); From 3de41e5179a33753d4ce6d3831cdb95e8e96fea2 Mon Sep 17 00:00:00 2001 From: "Christoph M. Wintersteiger" Date: Thu, 5 Apr 2018 15:27:02 +0100 Subject: [PATCH 087/109] Fixed model completion for unspecified cases of floating-point functions. Thanks to Florian Schanda for reporting this bug. --- src/ast/fpa/bv2fpa_converter.cpp | 28 ++++++++++++---------------- 1 file changed, 12 insertions(+), 16 deletions(-) diff --git a/src/ast/fpa/bv2fpa_converter.cpp b/src/ast/fpa/bv2fpa_converter.cpp index d87929864..86a5b80c9 100644 --- a/src/ast/fpa/bv2fpa_converter.cpp +++ b/src/ast/fpa/bv2fpa_converter.cpp @@ -262,11 +262,11 @@ func_interp * bv2fpa_converter::convert_func_interp(model_core * mc, func_decl * unsigned arity = bv_f->get_arity(); func_interp * bv_fi = mc->get_func_interp(bv_f); + result = alloc(func_interp, m, arity); if (bv_fi) { fpa_rewriter rw(m); expr_ref ai(m); - result = alloc(func_interp, m, arity); for (unsigned i = 0; i < bv_fi->num_entries(); i++) { func_entry const * bv_fe = bv_fi->get_entry(i); @@ -311,6 +311,8 @@ func_interp * bv2fpa_converter::convert_func_interp(model_core * mc, func_decl * result->set_else(ft_els); } } + else + result->set_else(m.get_some_value(f->get_range())); return result; } @@ -467,24 +469,18 @@ void bv2fpa_converter::convert_uf2bvuf(model_core * mc, model_core * target_mode // it->m_value contains the model for the unspecified cases of it->m_key. func_interp * fmv = convert_func_interp(mc, f, it->m_value); - if (fmv) { + SASSERT(fmv); #if 0 - // Upon request, add this 'recursive' definition? - unsigned n = fmv->get_arity(); - expr_ref_vector args(m); - for (unsigned i = 0; i < n; i++) - args.push_back(m.mk_var(i, f->get_domain()[i])); - fmv->set_else(m.mk_app(it->m_key, n, args.c_ptr())); + // Upon request, add this 'recursive' definition? + unsigned n = fmv->get_arity(); + expr_ref_vector args(m); + for (unsigned i = 0; i < n; i++) + args.push_back(m.mk_var(i, f->get_domain()[i])); + fmv->set_else(m.mk_app(it->m_key, n, args.c_ptr())); #else - - fmv->set_else(0); + fmv->set_else(0); // Make sure it's not left open. #endif - target_model->register_decl(f, fmv); - } - } - else { - func_interp * fmv = convert_func_interp(mc, f, it->m_value); - if (fmv) target_model->register_decl(f, fmv); + target_model->register_decl(f, fmv); } } } From bd00d98398b8dbeb45a78fb128e7e5dddb324fc3 Mon Sep 17 00:00:00 2001 From: "Christoph M. Wintersteiger" Date: Thu, 5 Apr 2018 17:21:17 +0100 Subject: [PATCH 088/109] Fixed overflow bug in fp.to_ubv. Thanks to Florian Schanda for reporting this bug. --- src/ast/fpa/fpa2bv_converter.cpp | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/ast/fpa/fpa2bv_converter.cpp b/src/ast/fpa/fpa2bv_converter.cpp index 7344f6f2f..2b09dfe8c 100644 --- a/src/ast/fpa/fpa2bv_converter.cpp +++ b/src/ast/fpa/fpa2bv_converter.cpp @@ -3243,8 +3243,13 @@ void fpa2bv_converter::mk_to_bv(func_decl * f, unsigned num, expr * const * args expr_ref ul(m), ovfl(m), in_range(m); if (!is_signed) { + expr_ref incd(m), pr_is_zero(m); + incd = m.mk_eq(rounding_decision, bv1); + pr_is_zero = m.mk_eq(pre_rounded, m_bv_util.mk_numeral(0, bv_sz + 3)); ul = m_bv_util.mk_zero_extend(3, m_bv_util.mk_numeral(-1, bv_sz)); - in_range = m.mk_and(m.mk_not(x_is_neg), m_bv_util.mk_ule(pre_rounded, ul)); + in_range = m.mk_and(m.mk_not(x_is_neg), + m.mk_not(m.mk_and(incd, pr_is_zero)), + m_bv_util.mk_ule(pre_rounded, ul)); } else { expr_ref ll(m); From 724f86d43e23a7230277dcb53a4d27d9db66c473 Mon Sep 17 00:00:00 2001 From: "Christoph M. Wintersteiger" Date: Thu, 5 Apr 2018 19:55:04 +0100 Subject: [PATCH 089/109] Bugfix for unspecified semantics of some fp.* operators. --- src/ast/fpa/bv2fpa_converter.cpp | 17 +---------------- 1 file changed, 1 insertion(+), 16 deletions(-) diff --git a/src/ast/fpa/bv2fpa_converter.cpp b/src/ast/fpa/bv2fpa_converter.cpp index 86a5b80c9..2bacae12a 100644 --- a/src/ast/fpa/bv2fpa_converter.cpp +++ b/src/ast/fpa/bv2fpa_converter.cpp @@ -311,8 +311,6 @@ func_interp * bv2fpa_converter::convert_func_interp(model_core * mc, func_decl * result->set_else(ft_els); } } - else - result->set_else(m.get_some_value(f->get_range())); return result; } @@ -467,20 +465,7 @@ void bv2fpa_converter::convert_uf2bvuf(model_core * mc, model_core * target_mode else { if (it->get_key().get_family_id() == m_fpa_util.get_fid()) { // it->m_value contains the model for the unspecified cases of it->m_key. - - func_interp * fmv = convert_func_interp(mc, f, it->m_value); - SASSERT(fmv); -#if 0 - // Upon request, add this 'recursive' definition? - unsigned n = fmv->get_arity(); - expr_ref_vector args(m); - for (unsigned i = 0; i < n; i++) - args.push_back(m.mk_var(i, f->get_domain()[i])); - fmv->set_else(m.mk_app(it->m_key, n, args.c_ptr())); -#else - fmv->set_else(0); // Make sure it's not left open. -#endif - target_model->register_decl(f, fmv); + target_model->register_decl(f, convert_func_interp(mc, f, it->m_value)); } } } From 02bf2530b5eff6eec23bc0a2b5499998e65771f7 Mon Sep 17 00:00:00 2001 From: "Christoph M. Wintersteiger" Date: Thu, 5 Apr 2018 19:55:41 +0100 Subject: [PATCH 090/109] Bugfix for fp.to_sbv. Thanks to Florian Schanda for reporting this bug. --- src/ast/fpa/fpa2bv_converter.cpp | 21 +++++++++++++-------- 1 file changed, 13 insertions(+), 8 deletions(-) diff --git a/src/ast/fpa/fpa2bv_converter.cpp b/src/ast/fpa/fpa2bv_converter.cpp index 2b09dfe8c..9d8576203 100644 --- a/src/ast/fpa/fpa2bv_converter.cpp +++ b/src/ast/fpa/fpa2bv_converter.cpp @@ -3241,24 +3241,29 @@ void fpa2bv_converter::mk_to_bv(func_decl * f, unsigned num, expr * const * args dbg_decouple("fpa2bv_to_bv_inc", inc); dbg_decouple("fpa2bv_to_bv_pre_rounded", pre_rounded); - expr_ref ul(m), ovfl(m), in_range(m); + expr_ref incd(m), pr_is_zero(m), ovfl(m); + incd = m.mk_eq(rounding_decision, bv1); + pr_is_zero = m.mk_eq(pre_rounded, m_bv_util.mk_numeral(0, bv_sz + 3)); + ovfl = m.mk_and(incd, pr_is_zero); + + expr_ref ul(m), in_range(m); if (!is_signed) { - expr_ref incd(m), pr_is_zero(m); - incd = m.mk_eq(rounding_decision, bv1); - pr_is_zero = m.mk_eq(pre_rounded, m_bv_util.mk_numeral(0, bv_sz + 3)); ul = m_bv_util.mk_zero_extend(3, m_bv_util.mk_numeral(-1, bv_sz)); - in_range = m.mk_and(m.mk_not(x_is_neg), - m.mk_not(m.mk_and(incd, pr_is_zero)), + in_range = m.mk_and(m.mk_not(x_is_neg), m.mk_not(ovfl), m_bv_util.mk_ule(pre_rounded, ul)); } else { expr_ref ll(m); ll = m_bv_util.mk_sign_extend(3, m_bv_util.mk_concat(bv1, m_bv_util.mk_numeral(0, bv_sz-1))); ul = m_bv_util.mk_zero_extend(4, m_bv_util.mk_numeral(-1, bv_sz-1)); - pre_rounded = m.mk_ite(x_is_neg, m_bv_util.mk_bv_neg(pre_rounded), pre_rounded); - in_range = m.mk_and(m.mk_not(ovfl), m_bv_util.mk_sle(ll, pre_rounded), m_bv_util.mk_sle(pre_rounded, ul)); + ovfl = m.mk_or(ovfl, m_bv_util.mk_sle(pre_rounded, m_bv_util.mk_numeral(-1, bv_sz + 3))); + in_range = m.mk_and(m.mk_not(ovfl), + m_bv_util.mk_sle(ll, pre_rounded), + m_bv_util.mk_sle(pre_rounded, ul)); dbg_decouple("fpa2bv_to_bv_in_range_ll", ll); + pre_rounded = m.mk_ite(x_is_neg, m_bv_util.mk_bv_neg(pre_rounded), pre_rounded); } + dbg_decouple("fpa2bv_to_bv_in_range_ovfl", ovfl); dbg_decouple("fpa2bv_to_bv_in_range_ul", ul); dbg_decouple("fpa2bv_to_bv_in_range", in_range); From 287c6f08e1250a610ad8d3a4e4821218a8652800 Mon Sep 17 00:00:00 2001 From: "Christoph M. Wintersteiger" Date: Thu, 5 Apr 2018 20:31:45 +0100 Subject: [PATCH 091/109] Resolved merge conflict --- src/tactic/sine_filter.cpp | 149 ++++++++++++++++++++----------------- 1 file changed, 79 insertions(+), 70 deletions(-) diff --git a/src/tactic/sine_filter.cpp b/src/tactic/sine_filter.cpp index 88792e955..e67169a8e 100644 --- a/src/tactic/sine_filter.cpp +++ b/src/tactic/sine_filter.cpp @@ -35,25 +35,25 @@ class sine_tactic : public tactic { public: - sine_tactic(ast_manager& m, params_ref const& p): + sine_tactic(ast_manager& m, params_ref const& p): m(m), m_params(p) {} - - tactic * translate(ast_manager & m) override { + + virtual tactic * translate(ast_manager & m) { return alloc(sine_tactic, m, m_params); } - void updt_params(params_ref const & p) override { + virtual void updt_params(params_ref const & p) { } - void collect_param_descrs(param_descrs & r) override { + virtual void collect_param_descrs(param_descrs & r) { } - void operator()(goal_ref const & g, - goal_ref_buffer & result, - model_converter_ref & mc, - proof_converter_ref & pc, - expr_dependency_ref & core) override { - mc = nullptr; pc = nullptr; core = nullptr; + virtual void operator()(goal_ref const & g, + goal_ref_buffer & result, + model_converter_ref & mc, + proof_converter_ref & pc, + expr_dependency_ref & core) { + mc = 0; pc = 0; core = 0; TRACE("sine", g->display(tout);); TRACE("sine", tout << g->size();); @@ -62,7 +62,7 @@ public: TRACE("sine", tout << new_forms.size();); g->reset(); for (unsigned i = 0; i < new_forms.size(); i++) { - g->assert_expr(new_forms.get(i), nullptr, nullptr); + g->assert_expr(new_forms.get(i), 0, 0); } g->inc_depth(); g->updt_prec(goal::OVER); @@ -72,115 +72,120 @@ public: filter_model_converter * fmc = alloc(filter_model_converter, m); mc = fmc; } - - void cleanup() override { + + virtual void cleanup() { } private: typedef std::pair t_work_item; - t_work_item work_item(expr *e, expr *root) { + t_work_item work_item(expr * e, expr * root) { return std::pair(e, root); } - void find_constants(expr *e, obj_hashtable &consts) { + void find_constants(expr * e, obj_hashtable &consts) { ptr_vector stack; stack.push_back(e); - expr *curr; + expr * curr; while (!stack.empty()) { curr = stack.back(); stack.pop_back(); - if (is_app(curr)) { + if (is_app(curr) && is_uninterp(curr)) { app *a = to_app(curr); - if (is_uninterp(a)) { - func_decl *f = a->get_decl(); - consts.insert_if_not_there(f); - } + func_decl *f = a->get_decl(); + consts.insert_if_not_there(f); } } } - bool quantifier_matches(quantifier *q, + bool quantifier_matches(quantifier * q, obj_hashtable const & consts, ptr_vector & next_consts) { - TRACE("sine", tout << "size of consts is "; tout << consts.size(); tout << "\n";); - for (obj_hashtable::iterator constit = consts.begin(), constend = consts.end(); constit != constend; constit++) { - TRACE("sine", tout << *constit; tout << "\n";); - } + TRACE("sine", + tout << "size of consts is "; tout << consts.size(); tout << "\n"; + obj_hashtable::iterator it = consts.begin(); + obj_hashtable::iterator end = consts.end(); + for (; it != end; it++) + tout << *it << "\n"; ); + bool matched = false; for (unsigned i = 0; i < q->get_num_patterns(); i++) { bool p_matched = true; ptr_vector stack; - expr *curr; + expr * curr; + // patterns are wrapped with "pattern" - if (!m.is_pattern(q->get_pattern(i), stack)) { + if (!m.is_pattern(q->get_pattern(i), stack)) continue; - } + while (!stack.empty()) { curr = stack.back(); stack.pop_back(); + if (is_app(curr)) { - app *a = to_app(curr); - func_decl *f = a->get_decl(); + app * a = to_app(curr); + func_decl * f = a->get_decl(); if (!consts.contains(f)) { TRACE("sine", tout << mk_pp(f, m) << "\n";); p_matched = false; next_consts.push_back(f); break; } - for (unsigned j = 0; j < a->get_num_args(); j++) { + for (unsigned j = 0; j < a->get_num_args(); j++) stack.push_back(a->get_arg(j)); - } } } + if (p_matched) { matched = true; break; } } + return matched; } - + void filter_expressions(goal_ref const & g, ptr_vector & new_exprs) { obj_map > const2exp; obj_map > exp2const; obj_map > const2quantifier; obj_hashtable consts; vector stack; - for (unsigned i = 0; i < g->size(); i++) { - stack.push_back(work_item(g->form(i), g->form(i))); - } t_work_item curr; + + for (unsigned i = 0; i < g->size(); i++) + stack.push_back(work_item(g->form(i), g->form(i))); + while (!stack.empty()) { curr = stack.back(); stack.pop_back(); - if (is_app(curr.first)) { - app *a = to_app(curr.first); - if (is_uninterp(a)) { - func_decl *f = a->get_decl(); - if (!consts.contains(f)) { - consts.insert(f); - if (const2quantifier.contains(f)) { - for (obj_pair_hashtable::iterator it = const2quantifier[f].begin(), end = const2quantifier[f].end(); it != end; it++) { - stack.push_back(*it); - } - const2quantifier.remove(f); - } - } - if (!const2exp.contains(f)) { - const2exp.insert(f, obj_hashtable()); - } - if (!const2exp[f].contains(curr.second)) { - const2exp[f].insert(curr.second); - } - if (!exp2const.contains(curr.second)) { - exp2const.insert(curr.second, obj_hashtable()); - } - if (!exp2const[curr.second].contains(f)) { - exp2const[curr.second].insert(f); + if (is_app(curr.first) && is_uninterp(curr.first)) { + app * a = to_app(curr.first); + func_decl * f = a->get_decl(); + if (!consts.contains(f)) { + consts.insert(f); + if (const2quantifier.contains(f)) { + obj_pair_hashtable::iterator it = const2quantifier[f].begin(); + obj_pair_hashtable::iterator end = const2quantifier[f].end(); + for (; it != end; it++) + stack.push_back(*it); + const2quantifier.remove(f); } } + if (!const2exp.contains(f)) { + const2exp.insert(f, obj_hashtable()); + } + if (!const2exp[f].contains(curr.second)) { + const2exp[f].insert(curr.second); + } + if (!exp2const.contains(curr.second)) { + exp2const.insert(curr.second, obj_hashtable()); + } + if (!exp2const[curr.second].contains(f)) { + exp2const[curr.second].insert(f); + } + for (unsigned i = 0; i < a->get_num_args(); i++) { stack.push_back(work_item(a->get_arg(i), curr.second)); } @@ -214,28 +219,32 @@ private: } } } + // ok, now we just need to find the connected component of the last term - obj_hashtable visited; ptr_vector to_visit; to_visit.push_back(g->form(g->size() - 1)); - expr *visiting; + expr * visiting; + while (!to_visit.empty()) { visiting = to_visit.back(); to_visit.pop_back(); visited.insert(visiting); - for (obj_hashtable::iterator constit = exp2const[visiting].begin(), constend = exp2const[visiting].end(); constit != constend; constit++) { - for (obj_hashtable::iterator exprit = const2exp[*constit].begin(), exprend = const2exp[*constit].end(); exprit != exprend; exprit++) { - if (!visited.contains(*exprit)) { + obj_hashtable::iterator it = exp2const[visiting].begin(); + obj_hashtable::iterator end = exp2const[visiting].end(); + for (; it != end; it++) { + obj_hashtable::iterator exprit = const2exp[*it].begin(); + obj_hashtable::iterator exprend = const2exp[*it].end(); + for (; exprit != exprend; exprit++) { + if (!visited.contains(*exprit)) to_visit.push_back(*exprit); - } } } } + for (unsigned i = 0; i < g->size(); i++) { - if (visited.contains(g->form(i))) { + if (visited.contains(g->form(i))) new_exprs.push_back(g->form(i)); - } } } }; From be4edddd2b0e81693ef5fefd53aa597428443e8f Mon Sep 17 00:00:00 2001 From: "Christoph M. Wintersteiger" Date: Fri, 6 Apr 2018 17:08:29 +0100 Subject: [PATCH 092/109] Fixed bug in to_fp/to_fp_unsigned. Thanks to Florian Schanda for reporting this bug. --- src/ast/fpa/fpa2bv_converter.cpp | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/src/ast/fpa/fpa2bv_converter.cpp b/src/ast/fpa/fpa2bv_converter.cpp index 9b9f0b427..66b912eb8 100644 --- a/src/ast/fpa/fpa2bv_converter.cpp +++ b/src/ast/fpa/fpa2bv_converter.cpp @@ -2845,7 +2845,7 @@ void fpa2bv_converter::mk_to_fp_signed(func_decl * f, unsigned num, expr * const expr_ref is_neg(m), x_abs(m), neg_x(m); is_neg_bit = m_bv_util.mk_extract(bv_sz - 1, bv_sz - 1, x); is_neg = m.mk_eq(is_neg_bit, bv1_1); - neg_x = m_bv_util.mk_bv_neg(x); + neg_x = m_bv_util.mk_bv_neg(x); // overflow problem? x_abs = m.mk_ite(is_neg, neg_x, x); dbg_decouple("fpa2bv_to_fp_signed_is_neg", is_neg); // x_abs has an extra bit in the front. @@ -2882,11 +2882,13 @@ void fpa2bv_converter::mk_to_fp_signed(func_decl * f, unsigned num, expr * const SASSERT(is_well_sorted(m, lz)); } SASSERT(m_bv_util.get_bv_size(sig_4) == sig_sz); + dbg_decouple("fpa2bv_to_fp_signed_sig_4", sig_4); expr_ref s_exp(m), exp_rest(m); s_exp = m_bv_util.mk_bv_sub(m_bv_util.mk_numeral(bv_sz - 2, bv_sz), lz); // s_exp = (bv_sz-2) + (-lz) signed SASSERT(m_bv_util.get_bv_size(s_exp) == bv_sz); + dbg_decouple("fpa2bv_to_fp_signed_s_exp", s_exp); unsigned exp_sz = ebits + 2; // (+2 for rounder) exp_2 = m_bv_util.mk_extract(exp_sz - 1, 0, s_exp); @@ -2907,10 +2909,9 @@ void fpa2bv_converter::mk_to_fp_signed(func_decl * f, unsigned num, expr * const mk_max_exp(exp_sz, max_exp); max_exp_bvsz = m_bv_util.mk_zero_extend(bv_sz - exp_sz, max_exp); - exp_too_large = m_bv_util.mk_ule(m_bv_util.mk_bv_add( - max_exp_bvsz, - m_bv_util.mk_numeral(1, bv_sz)), - s_exp); + exp_too_large = m_bv_util.mk_sle( + m_bv_util.mk_bv_add(max_exp_bvsz, m_bv_util.mk_numeral(1, bv_sz)), + s_exp); zero_sig_sz = m_bv_util.mk_numeral(0, sig_sz); sig_4 = m.mk_ite(exp_too_large, zero_sig_sz, sig_4); exp_2 = m.mk_ite(exp_too_large, max_exp, exp_2); @@ -3040,7 +3041,7 @@ void fpa2bv_converter::mk_to_fp_unsigned(func_decl * f, unsigned num, expr * con mk_max_exp(exp_sz, max_exp); max_exp_bvsz = m_bv_util.mk_zero_extend(bv_sz - exp_sz, max_exp); - exp_too_large = m_bv_util.mk_ule(m_bv_util.mk_bv_add( + exp_too_large = m_bv_util.mk_sle(m_bv_util.mk_bv_add( max_exp_bvsz, m_bv_util.mk_numeral(1, bv_sz)), s_exp); From 3b78bdc8e5250617fe9c527c589845453852c43f Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Fri, 6 Apr 2018 14:01:09 -0700 Subject: [PATCH 093/109] shorthands in enode to access args and partents Signed-off-by: Nikolaj Bjorner --- examples/c++/example.cpp | 5 ++++- src/smt/smt_enode.h | 19 +++++++++++++++++++ 2 files changed, 23 insertions(+), 1 deletion(-) diff --git a/examples/c++/example.cpp b/examples/c++/example.cpp index ed5bf7086..b25507885 100644 --- a/examples/c++/example.cpp +++ b/examples/c++/example.cpp @@ -927,7 +927,10 @@ void tuple_example() { sort sorts[2] = { ctx.int_sort(), ctx.bool_sort() }; func_decl_vector projs(ctx); func_decl pair = ctx.tuple_sort("pair", 2, names, sorts, projs); - std::cout << pair << "\n"; + sorts[1] = pair.range(); + func_decl pair2 = ctx.tuple_sort("pair2", 2, names, sorts, projs); + + std::cout << pair2 << "\n"; } void expr_vector_example() { diff --git a/src/smt/smt_enode.h b/src/smt/smt_enode.h index b216665e5..df6309424 100644 --- a/src/smt/smt_enode.h +++ b/src/smt/smt_enode.h @@ -216,6 +216,15 @@ namespace smt { return m_args; } + class args { + enode const& n; + public: + args(enode const& n):n(n) {} + args(enode const* n):n(*n) {} + enode_vector::const_iterator begin() const { return n.get_args(); } + enode_vector::const_iterator end() const { return n.get_args() + n.get_num_args(); } + }; + // unsigned get_id() const { // return m_id; // } @@ -285,6 +294,16 @@ namespace smt { return m_commutative; } + class parents { + enode const& n; + public: + parents(enode const& _n):n(_n) {} + parents(enode const* _n):n(*_n) {} + enode_vector::const_iterator begin() const { return n.begin_parents(); } + enode_vector::const_iterator end() const { return n.end_parents(); } + }; + + unsigned get_num_parents() const { return m_parents.size(); } From b5d531f079d6b678dc8accf6fd165185361c18d6 Mon Sep 17 00:00:00 2001 From: Simon Cruanes Date: Mon, 2 Apr 2018 13:37:12 -0500 Subject: [PATCH 094/109] perf(datatype): improve caching in occurs_check --- src/smt/theory_datatype.cpp | 10 +++++++--- src/smt/theory_datatype.h | 16 ++++++++++++++++ 2 files changed, 23 insertions(+), 3 deletions(-) diff --git a/src/smt/theory_datatype.cpp b/src/smt/theory_datatype.cpp index 3d3d56055..a3c0ecc96 100644 --- a/src/smt/theory_datatype.cpp +++ b/src/smt/theory_datatype.cpp @@ -389,12 +389,14 @@ namespace smt { final_check_status theory_datatype::final_check_eh() { int num_vars = get_num_vars(); final_check_status r = FC_DONE; + init_final_check(); for (int v = 0; v < num_vars; v++) { if (v == static_cast(m_find.find(v))) { enode * node = get_enode(v); if (occurs_check(node)) { // conflict was detected... // return... + cleanup_final_check(); return FC_CONTINUE; } if (m_params.m_dt_lazy_splits > 0) { @@ -407,6 +409,7 @@ namespace smt { } } } + cleanup_final_check(); return r; } @@ -434,6 +437,8 @@ namespace smt { tout << "eq: #" << p.first->get_owner_id() << " #" << p.second->get_owner_id() << "\n"; tout << mk_bounded_pp(p.first->get_owner(), get_manager()) << " " << mk_bounded_pp(p.second->get_owner(), get_manager()) << "\n"; }); + } else { + oc_mark_cycle_free(n); } return res; } @@ -443,12 +448,11 @@ namespace smt { TODO: improve performance. */ bool theory_datatype::occurs_check_core(enode * app) { - if (app->is_marked()) + if (oc_cycle_free(app) || oc_explored(app)) return false; m_stats.m_occurs_check++; - app->set_mark(); - m_to_unmark.push_back(app); + oc_mark_explore(app); TRACE("datatype", tout << "occurs check_core: #" << app->get_owner_id() << " #" << m_main->get_owner_id() << "\n";); diff --git a/src/smt/theory_datatype.h b/src/smt/theory_datatype.h index 2337fd0ea..1ccc15314 100644 --- a/src/smt/theory_datatype.h +++ b/src/smt/theory_datatype.h @@ -74,8 +74,24 @@ namespace smt { void sign_recognizer_conflict(enode * c, enode * r); ptr_vector m_to_unmark; + ptr_vector m_to_unmark2; enode_pair_vector m_used_eqs; enode * m_main; + + void oc_mark_explore(enode * n) { n->set_mark(); m_to_unmark.push_back(n); } + bool oc_explored(enode * n) const { n->is_marked(); } + + void oc_mark_cycle_free(enode * n) { n->set_mark2(); m_to_unmark2.push_back(n); } + bool oc_cycle_free(enode * n) const { n->is_marked2(); } + + void init_final_check() { + m_to_unmark2.reset(); + } + void cleanup_final_check() { + unmark_enodes2(m_to_unmark2.size(), m_to_unmark2.c_ptr()); + m_to_unmark2.reset(); + } + bool occurs_check(enode * n); bool occurs_check_core(enode * n); From 2ee1e358b6cb3aa03c63580d656499106ae4c4a2 Mon Sep 17 00:00:00 2001 From: Simon Cruanes Date: Mon, 2 Apr 2018 15:10:08 -0500 Subject: [PATCH 095/109] chore: add definition for `enode_tbl` --- src/smt/smt_types.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/smt/smt_types.h b/src/smt/smt_types.h index 6300bd43c..17b99c8b2 100644 --- a/src/smt/smt_types.h +++ b/src/smt/smt_types.h @@ -21,6 +21,7 @@ Revision History: #include "util/list.h" #include "util/vector.h" +#include "util/hashtable.h" #include "util/lbool.h" class model; @@ -46,6 +47,7 @@ namespace smt { typedef ptr_vector enode_vector; typedef std::pair enode_pair; typedef svector enode_pair_vector; + typedef ptr_hashtable, deref_eq > enode_tbl; class context; From 9df140343a9565cbdae2fdf39b876882add46933 Mon Sep 17 00:00:00 2001 From: Simon Cruanes Date: Mon, 2 Apr 2018 17:17:21 -0500 Subject: [PATCH 096/109] perf(datatype): whole-graph implementation of occurs_check --- src/smt/smt_enode.h | 7 ++ src/smt/smt_types.h | 1 - src/smt/theory_datatype.cpp | 136 ++++++++++++++++++++++-------------- src/smt/theory_datatype.h | 61 +++++++++++----- 4 files changed, 135 insertions(+), 70 deletions(-) diff --git a/src/smt/smt_enode.h b/src/smt/smt_enode.h index df6309424..ba13a31bb 100644 --- a/src/smt/smt_enode.h +++ b/src/smt/smt_enode.h @@ -171,6 +171,9 @@ namespace smt { m_interpreted = true; } + inline bool equal(const enode & other) const { + return m_owner == other.m_owner; + } void del_eh(ast_manager & m, bool update_children_parent = true); @@ -423,5 +426,9 @@ namespace smt { }; +inline bool operator==(const smt::enode & e1, const smt::enode & e2) { + return e1.equal(e2); +} + #endif /* SMT_ENODE_H_ */ diff --git a/src/smt/smt_types.h b/src/smt/smt_types.h index 17b99c8b2..e062a4ad6 100644 --- a/src/smt/smt_types.h +++ b/src/smt/smt_types.h @@ -47,7 +47,6 @@ namespace smt { typedef ptr_vector enode_vector; typedef std::pair enode_pair; typedef svector enode_pair_vector; - typedef ptr_hashtable, deref_eq > enode_tbl; class context; diff --git a/src/smt/theory_datatype.cpp b/src/smt/theory_datatype.cpp index a3c0ecc96..b3c6ffadf 100644 --- a/src/smt/theory_datatype.cpp +++ b/src/smt/theory_datatype.cpp @@ -389,14 +389,13 @@ namespace smt { final_check_status theory_datatype::final_check_eh() { int num_vars = get_num_vars(); final_check_status r = FC_DONE; - init_final_check(); + final_check_st _guard(this); // RAII for managing state for (int v = 0; v < num_vars; v++) { if (v == static_cast(m_find.find(v))) { enode * node = get_enode(v); if (occurs_check(node)) { // conflict was detected... // return... - cleanup_final_check(); return FC_CONTINUE; } if (m_params.m_dt_lazy_splits > 0) { @@ -409,10 +408,62 @@ namespace smt { } } } - cleanup_final_check(); return r; } + // explain the cycle root -> … -> app -> root + void theory_datatype::occurs_check_explain(enode * app, enode * const root) { + TRACE("datatype", tout << "occurs_check_explain " << mk_bounded_pp(app->get_owner(), get_manager()) << " <-> " << mk_bounded_pp(root->get_owner(), get_manager()) << "\n";); + enode* app_parent = nullptr; + + while (app->get_root() != root->get_root()) { + theory_var v = app->get_root()->get_th_var(get_id()); + SASSERT(v != null_theory_var); + v = m_find.find(v); + var_data * d = m_var_data[v]; + SASSERT(d->m_constructor); + if (app != d->m_constructor) + m_used_eqs.push_back(enode_pair(app, d->m_constructor)); + bool found = m_parent.find(app, app_parent); + SASSERT(found); + app = app_parent; + } + + SASSERT(app->get_root() == root->get_root()); + if (app != root) + m_used_eqs.push_back(enode_pair(app, root)); + } + + // start exploring subgraph below `app` + bool theory_datatype::occurs_check_enter(enode * app) { + oc_mark_on_stack(app); + theory_var v = app->get_root()->get_th_var(get_id()); + if (v != null_theory_var) { + v = m_find.find(v); + var_data * d = m_var_data[v]; + if (d->m_constructor) { + unsigned num_args = d->m_constructor->get_num_args(); + for (unsigned i = 0; i < num_args; i++) { + enode * arg = d->m_constructor->get_arg(i); + if (oc_cycle_free(arg)) { + return false; + } + if (oc_on_stack(arg)) { + // arg was explored before app, and is still on the stack: cycle + occurs_check_explain(app, arg); + return true; + } + // explore `arg` (with parent `app`) + if (m_util.is_datatype(get_manager().get_sort(arg->get_owner()))) { + m_parent.insert(arg, app); + oc_push_stack(arg); + } + } + } + } + return false; + } + /** \brief Check if n can be reached starting from n and following equalities and constructors. For example, occur_check(a1) returns true in the following set of equalities: @@ -421,68 +472,47 @@ namespace smt { a3 = cons(v3, a1) */ bool theory_datatype::occurs_check(enode * n) { - TRACE("datatype", tout << "occurs check: #" << n->get_owner_id() << "\n";); - m_to_unmark.reset(); - m_used_eqs.reset(); - m_main = n; - bool res = occurs_check_core(m_main); - unmark_enodes(m_to_unmark.size(), m_to_unmark.c_ptr()); + TRACE("datatype", tout << "occurs check: #" << n->get_owner_id() << " " << mk_bounded_pp(n->get_owner(), get_manager()) << "\n";); + m_stats.m_occurs_check++; + + bool res = false; + oc_push_stack(n); + + // DFS traversal from `n`. Look at top element and explore it. + while (!res && !m_stack.empty()) { + stack_op op = m_stack.back().first; + enode * app = m_stack.back().second; + m_stack.pop_back(); + + if (oc_cycle_free(app)) continue; + + TRACE("datatype", tout << "occurs check loop: #" << app->get_owner_id() << " " << mk_bounded_pp(app->get_owner(), get_manager()) << (op==ENTER?" enter":" exit")<< "\n";); + + switch (op) { + case ENTER: + res = occurs_check_enter(app) || res; + break; + + case EXIT: + oc_mark_cycle_free(app); + break; + } + } + if (res) { + // m_used_eqs should contain conflict context & ctx = get_context(); region & r = ctx.get_region(); ctx.set_conflict(ctx.mk_justification(ext_theory_conflict_justification(get_id(), r, 0, nullptr, m_used_eqs.size(), m_used_eqs.c_ptr()))); - TRACE("occurs_check", + TRACE("datatype", tout << "occurs_check: true\n"; for (enode_pair const& p : m_used_eqs) { tout << "eq: #" << p.first->get_owner_id() << " #" << p.second->get_owner_id() << "\n"; tout << mk_bounded_pp(p.first->get_owner(), get_manager()) << " " << mk_bounded_pp(p.second->get_owner(), get_manager()) << "\n"; }); - } else { - oc_mark_cycle_free(n); } return res; } - - /** - \brief Auxiliary method for occurs_check. - TODO: improve performance. - */ - bool theory_datatype::occurs_check_core(enode * app) { - if (oc_cycle_free(app) || oc_explored(app)) - return false; - - m_stats.m_occurs_check++; - oc_mark_explore(app); - - TRACE("datatype", tout << "occurs check_core: #" << app->get_owner_id() << " #" << m_main->get_owner_id() << "\n";); - - theory_var v = app->get_root()->get_th_var(get_id()); - if (v != null_theory_var) { - v = m_find.find(v); - var_data * d = m_var_data[v]; - if (d->m_constructor) { - if (app != d->m_constructor) - m_used_eqs.push_back(enode_pair(app, d->m_constructor)); - unsigned num_args = d->m_constructor->get_num_args(); - for (unsigned i = 0; i < num_args; i++) { - enode * arg = d->m_constructor->get_arg(i); - if (arg->get_root() == m_main->get_root()) { - if (arg != m_main) - m_used_eqs.push_back(enode_pair(arg, m_main)); - return true; - } - if (m_util.is_datatype(get_manager().get_sort(arg->get_owner())) && occurs_check_core(arg)) - return true; - } - if (app != d->m_constructor) { - SASSERT(m_used_eqs.back().first == app); - SASSERT(m_used_eqs.back().second == d->m_constructor); - m_used_eqs.pop_back(); - } - } - } - return false; - } void theory_datatype::reset_eh() { m_trail_stack.reset(); diff --git a/src/smt/theory_datatype.h b/src/smt/theory_datatype.h index 1ccc15314..fe8396fc5 100644 --- a/src/smt/theory_datatype.h +++ b/src/smt/theory_datatype.h @@ -26,7 +26,6 @@ Revision History: #include "smt/proto_model/datatype_factory.h" namespace smt { - class theory_datatype : public theory { typedef trail_stack th_trail_stack; typedef union_find th_union_find; @@ -73,27 +72,57 @@ namespace smt { void propagate_recognizer(theory_var v, enode * r); void sign_recognizer_conflict(enode * c, enode * r); - ptr_vector m_to_unmark; - ptr_vector m_to_unmark2; - enode_pair_vector m_used_eqs; - enode * m_main; + typedef enum { ENTER, EXIT } stack_op; + typedef map, deref_eq > parent_tbl; + typedef std::pair stack_entry; - void oc_mark_explore(enode * n) { n->set_mark(); m_to_unmark.push_back(n); } - bool oc_explored(enode * n) const { n->is_marked(); } + ptr_vector m_to_unmark; + ptr_vector m_to_unmark2; + enode_pair_vector m_used_eqs; // conflict, if any + parent_tbl m_parent; // parent explanation for occurs_check + svector m_stack; // stack for DFS for occurs_check - void oc_mark_cycle_free(enode * n) { n->set_mark2(); m_to_unmark2.push_back(n); } - bool oc_cycle_free(enode * n) const { n->is_marked2(); } + void oc_mark_on_stack(enode * n) { + n = n->get_root(); + n->set_mark(); + m_to_unmark.push_back(n); } + bool oc_on_stack(enode * n) const { return n->get_root()->is_marked(); } - void init_final_check() { - m_to_unmark2.reset(); - } - void cleanup_final_check() { - unmark_enodes2(m_to_unmark2.size(), m_to_unmark2.c_ptr()); - m_to_unmark2.reset(); + void oc_mark_cycle_free(enode * n) { + n = n->get_root(); + n->set_mark2(); + m_to_unmark2.push_back(n); } + bool oc_cycle_free(enode * n) const { return n->get_root()->is_marked2(); } + + void oc_push_stack(enode * n) { + m_stack.push_back(std::make_pair(EXIT, n)); + m_stack.push_back(std::make_pair(ENTER, n)); } + // class for managing state of final_check + class final_check_st { + theory_datatype * th; + public: + final_check_st(theory_datatype * th) : th(th) { + th->m_to_unmark2.reset(); + th->m_to_unmark.reset(); + th->m_used_eqs.reset(); + th->m_stack.reset(); + th->m_parent.reset(); + } + ~final_check_st() { + unmark_enodes(th->m_to_unmark.size(), th->m_to_unmark.c_ptr()); + unmark_enodes2(th->m_to_unmark2.size(), th->m_to_unmark2.c_ptr()); + th->m_to_unmark.reset(); + th->m_to_unmark2.reset(); + th->m_stack.reset(); + th->m_parent.reset(); + } + }; + bool occurs_check(enode * n); - bool occurs_check_core(enode * n); + bool occurs_check_enter(enode * n); + void occurs_check_explain(enode * top, enode * root); void mk_split(theory_var v); From fa10e510bba1647a00807a04cb7bdff73acf0dea Mon Sep 17 00:00:00 2001 From: Simon Cruanes Date: Tue, 3 Apr 2018 11:53:29 -0500 Subject: [PATCH 097/109] fix(datatype): only use pointer equality for enode_tbl --- src/smt/smt_enode.h | 7 ------- src/smt/theory_datatype.h | 2 +- 2 files changed, 1 insertion(+), 8 deletions(-) diff --git a/src/smt/smt_enode.h b/src/smt/smt_enode.h index ba13a31bb..df6309424 100644 --- a/src/smt/smt_enode.h +++ b/src/smt/smt_enode.h @@ -171,9 +171,6 @@ namespace smt { m_interpreted = true; } - inline bool equal(const enode & other) const { - return m_owner == other.m_owner; - } void del_eh(ast_manager & m, bool update_children_parent = true); @@ -426,9 +423,5 @@ namespace smt { }; -inline bool operator==(const smt::enode & e1, const smt::enode & e2) { - return e1.equal(e2); -} - #endif /* SMT_ENODE_H_ */ diff --git a/src/smt/theory_datatype.h b/src/smt/theory_datatype.h index fe8396fc5..4dc99f774 100644 --- a/src/smt/theory_datatype.h +++ b/src/smt/theory_datatype.h @@ -73,7 +73,7 @@ namespace smt { void sign_recognizer_conflict(enode * c, enode * r); typedef enum { ENTER, EXIT } stack_op; - typedef map, deref_eq > parent_tbl; + typedef map, ptr_eq > parent_tbl; typedef std::pair stack_entry; ptr_vector m_to_unmark; From e535cad48004e027f97f1d37bf341c61ec4eab4b Mon Sep 17 00:00:00 2001 From: Simon Cruanes Date: Tue, 3 Apr 2018 12:12:09 -0500 Subject: [PATCH 098/109] chore(datatype): small improvements --- src/smt/theory_datatype.cpp | 2 +- src/smt/theory_datatype.h | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/smt/theory_datatype.cpp b/src/smt/theory_datatype.cpp index b3c6ffadf..fb817502b 100644 --- a/src/smt/theory_datatype.cpp +++ b/src/smt/theory_datatype.cpp @@ -393,7 +393,7 @@ namespace smt { for (int v = 0; v < num_vars; v++) { if (v == static_cast(m_find.find(v))) { enode * node = get_enode(v); - if (occurs_check(node)) { + if (!oc_cycle_free(node) && occurs_check(node)) { // conflict was detected... // return... return FC_CONTINUE; diff --git a/src/smt/theory_datatype.h b/src/smt/theory_datatype.h index 4dc99f774..29799910b 100644 --- a/src/smt/theory_datatype.h +++ b/src/smt/theory_datatype.h @@ -104,8 +104,8 @@ namespace smt { theory_datatype * th; public: final_check_st(theory_datatype * th) : th(th) { - th->m_to_unmark2.reset(); th->m_to_unmark.reset(); + th->m_to_unmark2.reset(); th->m_used_eqs.reset(); th->m_stack.reset(); th->m_parent.reset(); @@ -115,6 +115,7 @@ namespace smt { unmark_enodes2(th->m_to_unmark2.size(), th->m_to_unmark2.c_ptr()); th->m_to_unmark.reset(); th->m_to_unmark2.reset(); + th->m_used_eqs.reset(); th->m_stack.reset(); th->m_parent.reset(); } From 433f487ff2d2dcb8d4c4427169b46e8db3b34c82 Mon Sep 17 00:00:00 2001 From: Simon Cruanes Date: Tue, 3 Apr 2018 18:30:09 -0500 Subject: [PATCH 099/109] fix(datatype): always use root nodes for the `parent` table --- src/smt/theory_datatype.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/smt/theory_datatype.cpp b/src/smt/theory_datatype.cpp index fb817502b..68ebb60e6 100644 --- a/src/smt/theory_datatype.cpp +++ b/src/smt/theory_datatype.cpp @@ -424,7 +424,7 @@ namespace smt { SASSERT(d->m_constructor); if (app != d->m_constructor) m_used_eqs.push_back(enode_pair(app, d->m_constructor)); - bool found = m_parent.find(app, app_parent); + bool found = m_parent.find(app->get_root(), app_parent); SASSERT(found); app = app_parent; } @@ -455,7 +455,7 @@ namespace smt { } // explore `arg` (with parent `app`) if (m_util.is_datatype(get_manager().get_sort(arg->get_owner()))) { - m_parent.insert(arg, app); + m_parent.insert(arg->get_root(), app); oc_push_stack(arg); } } From d973b0824745ba97ebeb0259d250cc1ad78a4899 Mon Sep 17 00:00:00 2001 From: Simon Cruanes Date: Wed, 4 Apr 2018 10:41:40 -0500 Subject: [PATCH 100/109] fix(datatypes): update following @nikolajbjorner 's review --- src/smt/theory_datatype.cpp | 5 ++--- src/smt/theory_datatype.h | 4 ++-- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/src/smt/theory_datatype.cpp b/src/smt/theory_datatype.cpp index 68ebb60e6..e21067a56 100644 --- a/src/smt/theory_datatype.cpp +++ b/src/smt/theory_datatype.cpp @@ -412,7 +412,7 @@ namespace smt { } // explain the cycle root -> … -> app -> root - void theory_datatype::occurs_check_explain(enode * app, enode * const root) { + void theory_datatype::occurs_check_explain(enode * app, enode * root) { TRACE("datatype", tout << "occurs_check_explain " << mk_bounded_pp(app->get_owner(), get_manager()) << " <-> " << mk_bounded_pp(root->get_owner(), get_manager()) << "\n";); enode* app_parent = nullptr; @@ -424,8 +424,7 @@ namespace smt { SASSERT(d->m_constructor); if (app != d->m_constructor) m_used_eqs.push_back(enode_pair(app, d->m_constructor)); - bool found = m_parent.find(app->get_root(), app_parent); - SASSERT(found); + app_parent = m_parent[app->get_root()]; app = app_parent; } diff --git a/src/smt/theory_datatype.h b/src/smt/theory_datatype.h index 29799910b..77da52360 100644 --- a/src/smt/theory_datatype.h +++ b/src/smt/theory_datatype.h @@ -104,8 +104,8 @@ namespace smt { theory_datatype * th; public: final_check_st(theory_datatype * th) : th(th) { - th->m_to_unmark.reset(); - th->m_to_unmark2.reset(); + SASSERT(th->m_to_unmark.empty()); + SASSERT(th->m_to_unmark2.empty()); th->m_used_eqs.reset(); th->m_stack.reset(); th->m_parent.reset(); From bf6928fec0bfa273201ecc6d3c0f07706e82a9b5 Mon Sep 17 00:00:00 2001 From: Simon Cruanes Date: Fri, 6 Apr 2018 11:13:53 -0500 Subject: [PATCH 101/109] fix(datatypes): additional explanation in occurs_check --- src/smt/theory_datatype.cpp | 36 +++++++++++++++++++++++++++++------- src/smt/theory_datatype.h | 1 + 2 files changed, 30 insertions(+), 7 deletions(-) diff --git a/src/smt/theory_datatype.cpp b/src/smt/theory_datatype.cpp index e21067a56..f17bdc3d6 100644 --- a/src/smt/theory_datatype.cpp +++ b/src/smt/theory_datatype.cpp @@ -411,19 +411,41 @@ namespace smt { return r; } + // Assuming `app` is equal to a constructor term, return the constructor enode + inline enode * theory_datatype::oc_get_cstor(enode * app) { + theory_var v = app->get_root()->get_th_var(get_id()); + SASSERT(v != null_theory_var); + v = m_find.find(v); + var_data * d = m_var_data[v]; + SASSERT(d->m_constructor); + return d->m_constructor; + } + // explain the cycle root -> … -> app -> root void theory_datatype::occurs_check_explain(enode * app, enode * root) { TRACE("datatype", tout << "occurs_check_explain " << mk_bounded_pp(app->get_owner(), get_manager()) << " <-> " << mk_bounded_pp(root->get_owner(), get_manager()) << "\n";); enode* app_parent = nullptr; + // first: explain that root=v, given that app=cstor(…,v,…) + { + enode * app_cstor = oc_get_cstor(app); + unsigned n_args_app = app_cstor->get_num_args(); + for (unsigned i=0; i < n_args_app; ++i) { + enode * arg = app_cstor->get_arg(i); + // found an argument which is equal to root + if (arg->get_root() == root->get_root()) { + if (arg != root) + m_used_eqs.push_back(enode_pair(arg, root)); + break; + } + } + } + + // now explain app=cstor(…,v,…) where v=root, and recurse with parent of app while (app->get_root() != root->get_root()) { - theory_var v = app->get_root()->get_th_var(get_id()); - SASSERT(v != null_theory_var); - v = m_find.find(v); - var_data * d = m_var_data[v]; - SASSERT(d->m_constructor); - if (app != d->m_constructor) - m_used_eqs.push_back(enode_pair(app, d->m_constructor)); + enode * app_cstor = oc_get_cstor(app); + if (app != app_cstor) + m_used_eqs.push_back(enode_pair(app, app_cstor)); app_parent = m_parent[app->get_root()]; app = app_parent; } diff --git a/src/smt/theory_datatype.h b/src/smt/theory_datatype.h index 77da52360..020949296 100644 --- a/src/smt/theory_datatype.h +++ b/src/smt/theory_datatype.h @@ -121,6 +121,7 @@ namespace smt { } }; + enode * oc_get_cstor(enode * n); bool occurs_check(enode * n); bool occurs_check_enter(enode * n); void occurs_check_explain(enode * top, enode * root); From 8fd2d8a636b65ca9e5d13bcc7f327e34ec40a09f Mon Sep 17 00:00:00 2001 From: Simon Cruanes Date: Fri, 6 Apr 2018 15:56:05 -0500 Subject: [PATCH 102/109] chore(datatype): small fixes --- src/smt/theory_datatype.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/smt/theory_datatype.cpp b/src/smt/theory_datatype.cpp index f17bdc3d6..825856e37 100644 --- a/src/smt/theory_datatype.cpp +++ b/src/smt/theory_datatype.cpp @@ -452,7 +452,7 @@ namespace smt { SASSERT(app->get_root() == root->get_root()); if (app != root) - m_used_eqs.push_back(enode_pair(app, root)); + m_used_eqs.push_back(enode_pair(app, root)); } // start exploring subgraph below `app` @@ -511,7 +511,7 @@ namespace smt { switch (op) { case ENTER: - res = occurs_check_enter(app) || res; + res = occurs_check_enter(app); break; case EXIT: From ac881d949d69db7bf83df9dd861526f64c5a3deb Mon Sep 17 00:00:00 2001 From: Simon Cruanes Date: Fri, 6 Apr 2018 17:19:06 -0500 Subject: [PATCH 103/109] style(datatype): use modern iteration --- src/smt/theory_datatype.cpp | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/src/smt/theory_datatype.cpp b/src/smt/theory_datatype.cpp index 825856e37..147067d61 100644 --- a/src/smt/theory_datatype.cpp +++ b/src/smt/theory_datatype.cpp @@ -429,9 +429,7 @@ namespace smt { // first: explain that root=v, given that app=cstor(…,v,…) { enode * app_cstor = oc_get_cstor(app); - unsigned n_args_app = app_cstor->get_num_args(); - for (unsigned i=0; i < n_args_app; ++i) { - enode * arg = app_cstor->get_arg(i); + for (enode * arg : enode::args(app_cstor)) { // found an argument which is equal to root if (arg->get_root() == root->get_root()) { if (arg != root) @@ -463,9 +461,7 @@ namespace smt { v = m_find.find(v); var_data * d = m_var_data[v]; if (d->m_constructor) { - unsigned num_args = d->m_constructor->get_num_args(); - for (unsigned i = 0; i < num_args; i++) { - enode * arg = d->m_constructor->get_arg(i); + for (enode * arg : enode::args(d->m_constructor)) { if (oc_cycle_free(arg)) { return false; } From cfd9785025e7995cc7622abe258c1271dd85bf89 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Fri, 6 Apr 2018 19:32:01 -0700 Subject: [PATCH 104/109] replace by int64_t and uint64_t Signed-off-by: Nikolaj Bjorner --- src/util/util.h | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/util/util.h b/src/util/util.h index ad427dfaf..067c2b2f4 100644 --- a/src/util/util.h +++ b/src/util/util.h @@ -24,19 +24,22 @@ Revision History: #include #include #include +#include #ifndef SIZE_MAX #define SIZE_MAX std::numeric_limits::max() #endif +#undef uint64 #ifndef uint64 -typedef unsigned long long uint64; +typedef uint64_t uint64; #endif static_assert(sizeof(uint64) == 8, "64 bits please"); +#undef int64 #ifndef int64 -typedef long long int64; +typedef int64_t int64; #endif static_assert(sizeof(int64) == 8, "64 bits"); From 66b85e000b419ba414939eeb9fa4e146bbebdfd0 Mon Sep 17 00:00:00 2001 From: Simon Cruanes Date: Sat, 7 Apr 2018 01:25:19 -0500 Subject: [PATCH 105/109] fix in occurs_check (early exit) --- src/smt/theory_datatype.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/smt/theory_datatype.cpp b/src/smt/theory_datatype.cpp index 147067d61..da18460f4 100644 --- a/src/smt/theory_datatype.cpp +++ b/src/smt/theory_datatype.cpp @@ -463,7 +463,7 @@ namespace smt { if (d->m_constructor) { for (enode * arg : enode::args(d->m_constructor)) { if (oc_cycle_free(arg)) { - return false; + continue; } if (oc_on_stack(arg)) { // arg was explored before app, and is still on the stack: cycle From 4f5133cf72e98453a8faab089fba720438cbc0c1 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Sat, 7 Apr 2018 10:16:46 -0700 Subject: [PATCH 106/109] disambiguate calls to set Signed-off-by: Nikolaj Bjorner --- src/util/hwf.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/util/hwf.cpp b/src/util/hwf.cpp index 014e62625..0768eac41 100644 --- a/src/util/hwf.cpp +++ b/src/util/hwf.cpp @@ -413,12 +413,12 @@ void hwf_manager::to_rational(hwf const & x, unsynch_mpq_manager & qm, mpq & o) scoped_mpz n(qm), d(qm); if (is_normal(x)) - qm.set(n, sig(x) | 0x0010000000000000ull); + qm.set(n, (uint64)(sig(x) | 0x0010000000000000ull)); else qm.set(n, sig(x)); if (sgn(x)) qm.neg(n); - qm.set(d, 0x0010000000000000ull); + qm.set(d, (uint64)0x0010000000000000ull); int e = exp(x); if (e >= 0) qm.mul2k(n, (unsigned)e); From 65834661a8369bcb0fda19dd129a194e751a7f0c Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Sat, 7 Apr 2018 10:53:52 -0700 Subject: [PATCH 107/109] disambiguate calls to set Signed-off-by: Nikolaj Bjorner --- src/api/api_datalog.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/api/api_datalog.cpp b/src/api/api_datalog.cpp index 5e0082f09..0e3ae4a74 100644 --- a/src/api/api_datalog.cpp +++ b/src/api/api_datalog.cpp @@ -213,7 +213,9 @@ extern "C" { // must start loggging here, since function uses Z3_get_sort_kind above LOG_Z3_get_finite_domain_sort_size(c, s, out); RESET_ERROR_CODE(); - VERIFY(mk_c(c)->datalog_util().try_get_size(to_sort(s), *out)); + uint64 _out = 0; + VERIFY(mk_c(c)->datalog_util().try_get_size(to_sort(s), _out)); + *out = static_cast<__uint64>(_out); return Z3_TRUE; Z3_CATCH_RETURN(Z3_FALSE); From 187ba6a5617a346ca7ce981955578d6e41beac28 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Sat, 7 Apr 2018 13:31:23 -0700 Subject: [PATCH 108/109] fix cast in tests Signed-off-by: Nikolaj Bjorner --- src/test/mpz.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/test/mpz.cpp b/src/test/mpz.cpp index 7926388df..3fd8cf51b 100644 --- a/src/test/mpz.cpp +++ b/src/test/mpz.cpp @@ -127,8 +127,8 @@ static void bug3() { static void bug4() { synch_mpz_manager m; mpz x, y; - m.set(y, 4294967295ull); - m.set(x, 4026531839ull); + m.set(y, static_cast(4294967295ull)); + m.set(x, static_cast(4026531839ull)); mpz result1; m.bitwise_or(x, y, result1); From bab87bfb9b0b2fd2a1b15c5ab9e61c829d021412 Mon Sep 17 00:00:00 2001 From: Nikolaj Bjorner Date: Sat, 7 Apr 2018 17:34:46 -0700 Subject: [PATCH 109/109] move some methods from header to cpp, format fixing, remove special characters Signed-off-by: Nikolaj Bjorner --- src/smt/theory_datatype.cpp | 56 +++++++++++++++++++++++++++++-------- src/smt/theory_datatype.h | 35 ++++------------------- 2 files changed, 50 insertions(+), 41 deletions(-) diff --git a/src/smt/theory_datatype.cpp b/src/smt/theory_datatype.cpp index da18460f4..9ff81fa08 100644 --- a/src/smt/theory_datatype.cpp +++ b/src/smt/theory_datatype.cpp @@ -36,6 +36,41 @@ namespace smt { theory_id get_from_theory() const override { return null_theory_id; } }; + theory_datatype::final_check_st::final_check_st(theory_datatype * th) : th(th) { + SASSERT(th->m_to_unmark.empty()); + SASSERT(th->m_to_unmark2.empty()); + th->m_used_eqs.reset(); + th->m_stack.reset(); + th->m_parent.reset(); + } + + theory_datatype::final_check_st::~final_check_st() { + unmark_enodes(th->m_to_unmark.size(), th->m_to_unmark.c_ptr()); + unmark_enodes2(th->m_to_unmark2.size(), th->m_to_unmark2.c_ptr()); + th->m_to_unmark.reset(); + th->m_to_unmark2.reset(); + th->m_used_eqs.reset(); + th->m_stack.reset(); + th->m_parent.reset(); + } + + void theory_datatype::oc_mark_on_stack(enode * n) { + n = n->get_root(); + n->set_mark(); + m_to_unmark.push_back(n); + } + + void theory_datatype::oc_mark_cycle_free(enode * n) { + n = n->get_root(); + n->set_mark2(); + m_to_unmark2.push_back(n); + } + + void theory_datatype::oc_push_stack(enode * n) { + m_stack.push_back(std::make_pair(EXIT, n)); + m_stack.push_back(std::make_pair(ENTER, n)); + } + theory* theory_datatype::mk_fresh(context* new_ctx) { return alloc(theory_datatype, new_ctx->get_manager(), m_params); @@ -421,25 +456,22 @@ namespace smt { return d->m_constructor; } - // explain the cycle root -> … -> app -> root + // explain the cycle root -> ... -> app -> root void theory_datatype::occurs_check_explain(enode * app, enode * root) { TRACE("datatype", tout << "occurs_check_explain " << mk_bounded_pp(app->get_owner(), get_manager()) << " <-> " << mk_bounded_pp(root->get_owner(), get_manager()) << "\n";); enode* app_parent = nullptr; // first: explain that root=v, given that app=cstor(…,v,…) - { - enode * app_cstor = oc_get_cstor(app); - for (enode * arg : enode::args(app_cstor)) { - // found an argument which is equal to root - if (arg->get_root() == root->get_root()) { - if (arg != root) - m_used_eqs.push_back(enode_pair(arg, root)); - break; - } + for (enode * arg : enode::args(oc_get_cstor(app))) { + // found an argument which is equal to root + if (arg->get_root() == root->get_root()) { + if (arg != root) + m_used_eqs.push_back(enode_pair(arg, root)); + break; } } - // now explain app=cstor(…,v,…) where v=root, and recurse with parent of app + // now explain app=cstor(..,v,..) where v=root, and recurse with parent of app while (app->get_root() != root->get_root()) { enode * app_cstor = oc_get_cstor(app); if (app != app_cstor) @@ -447,7 +479,7 @@ namespace smt { app_parent = m_parent[app->get_root()]; app = app_parent; } - + SASSERT(app->get_root() == root->get_root()); if (app != root) m_used_eqs.push_back(enode_pair(app, root)); diff --git a/src/smt/theory_datatype.h b/src/smt/theory_datatype.h index 020949296..010e78cb3 100644 --- a/src/smt/theory_datatype.h +++ b/src/smt/theory_datatype.h @@ -82,43 +82,20 @@ namespace smt { parent_tbl m_parent; // parent explanation for occurs_check svector m_stack; // stack for DFS for occurs_check - void oc_mark_on_stack(enode * n) { - n = n->get_root(); - n->set_mark(); - m_to_unmark.push_back(n); } + void oc_mark_on_stack(enode * n); bool oc_on_stack(enode * n) const { return n->get_root()->is_marked(); } - void oc_mark_cycle_free(enode * n) { - n = n->get_root(); - n->set_mark2(); - m_to_unmark2.push_back(n); } + void oc_mark_cycle_free(enode * n); bool oc_cycle_free(enode * n) const { return n->get_root()->is_marked2(); } - void oc_push_stack(enode * n) { - m_stack.push_back(std::make_pair(EXIT, n)); - m_stack.push_back(std::make_pair(ENTER, n)); - } + void oc_push_stack(enode * n); // class for managing state of final_check class final_check_st { theory_datatype * th; - public: - final_check_st(theory_datatype * th) : th(th) { - SASSERT(th->m_to_unmark.empty()); - SASSERT(th->m_to_unmark2.empty()); - th->m_used_eqs.reset(); - th->m_stack.reset(); - th->m_parent.reset(); - } - ~final_check_st() { - unmark_enodes(th->m_to_unmark.size(), th->m_to_unmark.c_ptr()); - unmark_enodes2(th->m_to_unmark2.size(), th->m_to_unmark2.c_ptr()); - th->m_to_unmark.reset(); - th->m_to_unmark2.reset(); - th->m_used_eqs.reset(); - th->m_stack.reset(); - th->m_parent.reset(); - } + public: + final_check_st(theory_datatype * th); + ~final_check_st(); }; enode * oc_get_cstor(enode * n);