Merge branch 'master' into fix-static-linking

Author: NikolajBjorner

README.md

@@ -97,8 +97,9 @@ To clean Z3 you can delete the build directory and run the ``mk_make.py`` script
 
 ## Building Z3 using CMake
 
-Z3 has an unofficial build system using CMake. Read the [README-CMake.md](README-CMake.md)
-file for details.
+Z3 has a build system using CMake. Read the [README-CMake.md](README-CMake.md)
+file for details. It is recommended for most build tasks, 
+except for building OCaml bindings.
 
 ## Z3 bindings
 

src/smt/asserted_formulas.cpp

@@ -25,6 +25,7 @@ Revision History:
 #include "ast/normal_forms/nnf.h"
 #include "ast/pattern/pattern_inference.h"
 #include "ast/macros/quasi_macros.h"
+#include "ast/occurs.h"
 #include "smt/asserted_formulas.h"
 
 asserted_formulas::asserted_formulas(ast_manager & m, smt_params & sp, params_ref const& p):
@@ -133,7 +134,7 @@ void asserted_formulas::set_eliminate_and(bool flag) {
     m_params.set_bool("eq2ineq", m_smt_params.m_arith_eq2ineq);
     m_params.set_bool("gcd_rounding", true);
     m_params.set_bool("expand_select_store", true);
-    m_params.set_bool("expand_nested_stores", true);
+    //m_params.set_bool("expand_nested_stores", true);
     m_params.set_bool("bv_sort_ac", true);
     m_params.set_bool("som", true);
     m_rewriter.updt_params(m_params);

src/smt/dyn_ack.cpp

@@ -105,7 +105,7 @@ namespace smt {
 
     dyn_ack_manager::dyn_ack_manager(context & ctx, dyn_ack_params & p):
         m_context(ctx),
-        m_manager(ctx.get_manager()),
+        m(ctx.get_manager()),
         m_params(p) {
     }
 
@@ -115,12 +115,9 @@ namespace smt {
     }
 
     void dyn_ack_manager::reset_app_pairs() {
-        svector<app_pair>::iterator it  = m_app_pairs.begin();
-        svector<app_pair>::iterator end = m_app_pairs.end();
-        for (; it != end; ++it) {
-            app_pair & p = *it;
-            m_manager.dec_ref(p.first);
-            m_manager.dec_ref(p.second);
+        for (app_pair& p : m_app_pairs) {
+            m.dec_ref(p.first);
+            m.dec_ref(p.second);
         }
         m_app_pairs.reset();
     }
@@ -144,22 +141,24 @@ namespace smt {
         SASSERT(n1->get_decl() == n2->get_decl());
         SASSERT(n1->get_num_args() == n2->get_num_args());
         SASSERT(n1 != n2);
-        if (m_manager.is_eq(n1))
+        if (m.is_eq(n1)) {
             return;
+        }
         if (n1->get_id() > n2->get_id())
             std::swap(n1,n2);
         app_pair p(n1, n2);
-        if (m_instantiated.contains(p))
+        if (m_instantiated.contains(p)) {
             return;
+        }
         unsigned num_occs = 0;
         if (m_app_pair2num_occs.find(n1, n2, num_occs)) {
-            TRACE("dyn_ack", tout << "used_cg_eh:\n" << mk_pp(n1, m_manager) << "\n" << mk_pp(n2, m_manager) << "\nnum_occs: " << num_occs << "\n";);
+            TRACE("dyn_ack", tout << "used_cg_eh:\n" << mk_pp(n1, m) << "\n" << mk_pp(n2, m) << "\nnum_occs: " << num_occs << "\n";);
             num_occs++;
         }
         else {
             num_occs = 1;
-            m_manager.inc_ref(n1);
-            m_manager.inc_ref(n2);
+            m.inc_ref(n1);
+            m.inc_ref(n2);
             m_app_pairs.push_back(p);
         }
         SASSERT(num_occs > 0);
@@ -169,34 +168,35 @@ namespace smt {
         SASSERT(m_app_pair2num_occs.find(n1, n2, num_occs2) && num_occs == num_occs2);
 #endif
         if (num_occs == m_params.m_dack_threshold) {
-            TRACE("dyn_ack", tout << "found candidate:\n" << mk_pp(n1, m_manager) << "\n" << mk_pp(n2, m_manager) << "\nnum_occs: " << num_occs << "\n";);
+            TRACE("dyn_ack", tout << "found candidate:\n" << mk_pp(n1, m) << "\n" << mk_pp(n2, m) << "\nnum_occs: " << num_occs << "\n";);
             m_to_instantiate.push_back(p);
         }
     }
 
     void dyn_ack_manager::eq_eh(app * n1, app * n2, app* r) {
-        if (n1 == n2 || r == n1 || r == n2 || m_manager.is_bool(n1)) {
+        if (n1 == n2 || r == n1 || r == n2 || m.is_bool(n1)) {
             return;
         }
         if (n1->get_id() > n2->get_id())
             std::swap(n1,n2);
         TRACE("dyn_ack", 
-              tout << mk_pp(n1, m_manager) << " = " << mk_pp(n2, m_manager) 
-              << " = " << mk_pp(r, m_manager) << "\n";);
+              tout << mk_pp(n1, m) << " = " << mk_pp(n2, m) 
+              << " = " << mk_pp(r, m) << "\n";);
         app_triple tr(n1, n2, r);
-        if (m_triple.m_instantiated.contains(tr))
+        if (m_triple.m_instantiated.contains(tr)) {
             return;
+        }
         unsigned num_occs = 0;
         if (m_triple.m_app2num_occs.find(n1, n2, r, num_occs)) {
-            TRACE("dyn_ack", tout << mk_pp(n1, m_manager) << "\n" << mk_pp(n2, m_manager) 
-                  << mk_pp(r, m_manager) << "\n" << "\nnum_occs: " << num_occs << "\n";);
+            TRACE("dyn_ack", tout << mk_pp(n1, m) << "\n" << mk_pp(n2, m) 
+                  << mk_pp(r, m) << "\n" << "\nnum_occs: " << num_occs << "\n";);
             num_occs++;
         }
         else {
             num_occs = 1;
-            m_manager.inc_ref(n1);
-            m_manager.inc_ref(n2);
-            m_manager.inc_ref(r);
+            m.inc_ref(n1);
+            m.inc_ref(n2);
+            m.inc_ref(r);
             m_triple.m_apps.push_back(tr);
         }
         SASSERT(num_occs > 0);
@@ -206,8 +206,8 @@ namespace smt {
         SASSERT(m_triple.m_app2num_occs.find(n1, n2, r, num_occs2) && num_occs == num_occs2);
 #endif
         if (num_occs == m_params.m_dack_threshold) {
-            TRACE("dyn_ack", tout << "found candidate:\n" << mk_pp(n1, m_manager) << "\n" << mk_pp(n2, m_manager) 
-                  << "\n" << mk_pp(r, m_manager) 
+            TRACE("dyn_ack", tout << "found candidate:\n" << mk_pp(n1, m) << "\n" << mk_pp(n2, m) 
+                  << "\n" << mk_pp(r, m) 
                   << "\nnum_occs: " << num_occs << "\n";);
             m_triple.m_to_instantiate.push_back(tr);
         }
@@ -245,9 +245,9 @@ namespace smt {
         for (; it != end; ++it) {
             app_pair & p = *it;
             if (m_instantiated.contains(p)) {
-                TRACE("dyn_ack", tout << "1) erasing:\n" << mk_pp(p.first, m_manager) << "\n" << mk_pp(p.second, m_manager) << "\n";);
-                m_manager.dec_ref(p.first);
-                m_manager.dec_ref(p.second);
+                TRACE("dyn_ack", tout << "1) erasing:\n" << mk_pp(p.first, m) << "\n" << mk_pp(p.second, m) << "\n";);
+                m.dec_ref(p.first);
+                m.dec_ref(p.second);
                 SASSERT(!m_app_pair2num_occs.contains(p.first, p.second));
                 continue;
             }
@@ -261,10 +261,10 @@ namespace smt {
             num_occs = static_cast<unsigned>(num_occs * m_params.m_dack_gc_inv_decay);
             if (num_occs <= 1) {
                 num_deleted++;
-                TRACE("dyn_ack", tout << "2) erasing:\n" << mk_pp(p.first, m_manager) << "\n" << mk_pp(p.second, m_manager) << "\n";);
+                TRACE("dyn_ack", tout << "2) erasing:\n" << mk_pp(p.first, m) << "\n" << mk_pp(p.second, m) << "\n";);
                 m_app_pair2num_occs.erase(p.first, p.second);
-                m_manager.dec_ref(p.first);
-                m_manager.dec_ref(p.second);
+                m.dec_ref(p.first);
+                m.dec_ref(p.second);
                 continue;
             }
             *it2 = p;
@@ -283,20 +283,19 @@ namespace smt {
     }
 
     class dyn_ack_clause_del_eh : public clause_del_eh {
-        dyn_ack_manager & m_manager;
+        dyn_ack_manager & m;
     public:
         dyn_ack_clause_del_eh(dyn_ack_manager & m):
-            m_manager(m) {
+            m(m) {
         }
         ~dyn_ack_clause_del_eh() override {}
-        void operator()(ast_manager & m, clause * cls) override {
-            m_manager.del_clause_eh(cls);
+        void operator()(ast_manager & _m, clause * cls) override {
+            m.del_clause_eh(cls);
             dealloc(this);
         }
     };
 
     void dyn_ack_manager::del_clause_eh(clause * cls) {
-        TRACE("dyn_ack", tout << "del_clause_eh: "; m_context.display_clause(tout, cls); tout << "\n";);
         m_context.m_stats.m_num_del_dyn_ack++;
 
         app_pair p((app*)nullptr,(app*)nullptr);
@@ -342,7 +341,7 @@ namespace smt {
         app * eq  = m_context.mk_eq_atom(n1, n2);
         m_context.internalize(eq, true);
         literal l = m_context.get_literal(eq);
-        TRACE("dyn_ack", tout << "eq:\n" << mk_pp(eq, m_manager) << "\nliteral: "; 
+        TRACE("dyn_ack", tout << "eq:\n" << mk_pp(eq, m) << "\nliteral: "; 
               m_context.display_literal(tout, l); tout << "\n";);
         return l;
     }
@@ -354,7 +353,7 @@ namespace smt {
         SASSERT(n1 != n2);
         m_context.m_stats.m_num_dyn_ack++;
         TRACE("dyn_ack_inst", tout << "dyn_ack: " << n1->get_id() << " " << n2->get_id() << "\n";);
-        TRACE("dyn_ack", tout << "expanding Ackermann's rule for:\n" << mk_pp(n1, m_manager) << "\n" << mk_pp(n2, m_manager) << "\n";);
+        TRACE("dyn_ack", tout << "expanding Ackermann's rule for:\n" << mk_pp(n1, m) << "\n" << mk_pp(n2, m) << "\n";);
         unsigned num_args = n1->get_num_args();
         literal_buffer lits;
         for (unsigned i = 0; i < num_args; i++) {
@@ -372,7 +371,7 @@ namespace smt {
         clause_del_eh * del_eh = alloc(dyn_ack_clause_del_eh, *this);
 
         justification * js = nullptr;
-        if (m_manager.proofs_enabled())
+        if (m.proofs_enabled())
             js = alloc(dyn_ack_justification, n1, n2);
         clause * cls = m_context.mk_clause(lits.size(), lits.c_ptr(), js, CLS_TH_LEMMA, del_eh);
         if (!cls) {
@@ -392,13 +391,10 @@ namespace smt {
     }
 
     void dyn_ack_manager::reset_app_triples() {
-        svector<app_triple>::iterator it  = m_triple.m_apps.begin();
-        svector<app_triple>::iterator end = m_triple.m_apps.end();
-        for (; it != end; ++it) {
-            app_triple & p = *it;
-            m_manager.dec_ref(p.first);
-            m_manager.dec_ref(p.second);
-            m_manager.dec_ref(p.third);
+        for (app_triple& p : m_triple.m_apps) {
+            m.dec_ref(p.first);
+            m.dec_ref(p.second);
+            m.dec_ref(p.third);
         }
         m_triple.m_apps.reset();
     }
@@ -408,9 +404,9 @@ namespace smt {
         SASSERT(n1 != n2 && n1 != r && n2 != r);
         m_context.m_stats.m_num_dyn_ack++;
         TRACE("dyn_ack_inst", tout << "dyn_ack: " << n1->get_id() << " " << n2->get_id() << " " << r->get_id() << "\n";);
-        TRACE("dyn_ack", tout << "expanding Ackermann's rule for:\n" << mk_pp(n1, m_manager) << "\n" 
-              << mk_pp(n2, m_manager) << "\n"
-              << mk_pp(r,  m_manager) << "\n";
+        TRACE("dyn_ack", tout << "expanding Ackermann's rule for:\n" << mk_pp(n1, m) << "\n" 
+              << mk_pp(n2, m) << "\n"
+              << mk_pp(r,  m) << "\n";
               );
         app_triple tr(n1, n2, r);
         SASSERT(m_triple.m_app2num_occs.contains(n1, n2, r));
@@ -424,7 +420,7 @@ namespace smt {
         clause_del_eh * del_eh = alloc(dyn_ack_clause_del_eh, *this);
 
         justification * js = nullptr;
-        if (m_manager.proofs_enabled())
+        if (m.proofs_enabled())
             js = alloc(dyn_ack_justification, n1, n2);
         clause * cls = m_context.mk_clause(lits.size(), lits.c_ptr(), js, CLS_TH_LEMMA, del_eh);
         if (!cls) {
@@ -467,10 +463,10 @@ namespace smt {
         for (; it != end; ++it) {
             app_triple & p = *it;
             if (m_triple.m_instantiated.contains(p)) {
-                TRACE("dyn_ack", tout << "1) erasing:\n" << mk_pp(p.first, m_manager) << "\n" << mk_pp(p.second, m_manager) << "\n";);
-                m_manager.dec_ref(p.first);
-                m_manager.dec_ref(p.second);
-                m_manager.dec_ref(p.third);
+                TRACE("dyn_ack", tout << "1) erasing:\n" << mk_pp(p.first, m) << "\n" << mk_pp(p.second, m) << "\n";);
+                m.dec_ref(p.first);
+                m.dec_ref(p.second);
+                m.dec_ref(p.third);
                 SASSERT(!m_triple.m_app2num_occs.contains(p.first, p.second, p.third));
                 continue;
             }
@@ -484,11 +480,11 @@ namespace smt {
             num_occs = static_cast<unsigned>(num_occs * m_params.m_dack_gc_inv_decay);
             if (num_occs <= 1) {
                 num_deleted++;
-                TRACE("dyn_ack", tout << "2) erasing:\n" << mk_pp(p.first, m_manager) << "\n" << mk_pp(p.second, m_manager) << "\n";);
+                TRACE("dyn_ack", tout << "2) erasing:\n" << mk_pp(p.first, m) << "\n" << mk_pp(p.second, m) << "\n";);
                 m_triple.m_app2num_occs.erase(p.first, p.second, p.third);
-                m_manager.dec_ref(p.first);
-                m_manager.dec_ref(p.second);
-                m_manager.dec_ref(p.third);
+                m.dec_ref(p.first);
+                m.dec_ref(p.second);
+                m.dec_ref(p.third);
                 continue;
             }
             *it2 = p;
@@ -509,10 +505,8 @@ namespace smt {
 
 #ifdef Z3DEBUG
     bool dyn_ack_manager::check_invariant() const {
-        clause2app_pair::iterator it  = m_clause2app_pair.begin();
-        clause2app_pair::iterator end = m_clause2app_pair.end();
-        for (; it != end; ++it) {
-            app_pair const & p = it->get_value();
+        for (auto const& kv : m_clause2app_pair) {
+            app_pair const & p = kv.get_value();
             SASSERT(m_instantiated.contains(p));
             SASSERT(!m_app_pair2num_occs.contains(p.first, p.second));
         }

src/smt/dyn_ack.h

@@ -44,7 +44,7 @@ namespace smt {
         typedef obj_map<clause, app_triple>         clause2app_triple;
 
         context &                                  m_context;
-        ast_manager &                              m_manager;
+        ast_manager &                              m;
         dyn_ack_params &                           m_params;
         app_pair2num_occs                          m_app_pair2num_occs;
         app_pair_vector                            m_app_pairs;

src/smt/smt_clause.cpp

@@ -123,7 +123,7 @@ namespace smt {
             if (lit.sign()) args[args.size()-1] = m.mk_not(args.back());
         }
         expr_ref disj(m.mk_or(args.size(), args.c_ptr()), m);
-        return out << disj;
+        return out << mk_bounded_pp(disj, m, 3);
     }
 
 };

src/smt/smt_conflict_resolution.cpp

@@ -16,10 +16,11 @@ Module Name:
 Revision History:
 
 --*/
-#include "smt/smt_context.h"
-#include "smt/smt_conflict_resolution.h"
+
 #include "ast/ast_pp.h"
 #include "ast/ast_ll_pp.h"
+#include "smt/smt_context.h"
+#include "smt/smt_conflict_resolution.h"
 
 namespace smt {