Merge branch 'develop' into regex-develop

src/ast/arith_decl_plugin.h

@@ -370,7 +370,7 @@ public:
     app * mk_lt(expr * arg1, expr * arg2) const { return m_manager.mk_app(m_afid, OP_LT, arg1, arg2); }
     app * mk_gt(expr * arg1, expr * arg2) const { return m_manager.mk_app(m_afid, OP_GT, arg1, arg2); }
 
-    app * mk_add(unsigned num_args, expr * const * args) const { return m_manager.mk_app(m_afid, OP_ADD, num_args, args); }
+    app * mk_add(unsigned num_args, expr * const * args) const { return num_args == 1 && is_app(args[0]) ? to_app(args[0]) : m_manager.mk_app(m_afid, OP_ADD, num_args, args); }
     app * mk_add(expr * arg1, expr * arg2) const { return m_manager.mk_app(m_afid, OP_ADD, arg1, arg2); }
     app * mk_add(expr * arg1, expr * arg2, expr* arg3) const { return m_manager.mk_app(m_afid, OP_ADD, arg1, arg2, arg3); }
 
@@ -378,7 +378,7 @@ public:
     app * mk_sub(unsigned num_args, expr * const * args) const { return m_manager.mk_app(m_afid, OP_SUB, num_args, args); }
     app * mk_mul(expr * arg1, expr * arg2) const { return m_manager.mk_app(m_afid, OP_MUL, arg1, arg2); }
     app * mk_mul(expr * arg1, expr * arg2, expr* arg3) const { return m_manager.mk_app(m_afid, OP_MUL, arg1, arg2, arg3); }
-    app * mk_mul(unsigned num_args, expr * const * args) const { return m_manager.mk_app(m_afid, OP_MUL, num_args, args); }
+    app * mk_mul(unsigned num_args, expr * const * args) const { return num_args == 1 && is_app(args[0]) ? to_app(args[0]) : m_manager.mk_app(m_afid, OP_MUL, num_args, args); }
     app * mk_uminus(expr * arg) const { return m_manager.mk_app(m_afid, OP_UMINUS, arg); }
     app * mk_div(expr * arg1, expr * arg2) { return m_manager.mk_app(m_afid, OP_DIV, arg1, arg2); }
     app * mk_idiv(expr * arg1, expr * arg2) { return m_manager.mk_app(m_afid, OP_IDIV, arg1, arg2); }

src/ast/ast.cpp

@@ -1289,7 +1289,7 @@ decl_kind user_sort_plugin::register_name(symbol s) {
 
 decl_plugin * user_sort_plugin::mk_fresh() {
     user_sort_plugin * p = alloc(user_sort_plugin);
-    for (symbol const& s : m_sort_names) 
+    for (symbol const& s : m_sort_names)
         p->register_name(s);
     return p;
 }
@@ -1415,7 +1415,7 @@ ast_manager::~ast_manager() {
             p->finalize();
     }
     for (decl_plugin* p : m_plugins) {
-        if (p) 
+        if (p)
             dealloc(p);
     }
     m_plugins.reset();
@@ -1454,13 +1454,13 @@ ast_manager::~ast_manager() {
                 mark_array_ref(mark, to_quantifier(n)->get_num_patterns(), to_quantifier(n)->get_patterns());
                 mark_array_ref(mark, to_quantifier(n)->get_num_no_patterns(), to_quantifier(n)->get_no_patterns());
                 break;
-            }           
-        }        
+            }
+        }
         for (ast * n : m_ast_table) {
             if (!mark.is_marked(n)) {
                 roots.push_back(n);
             }
-        }        
+        }
         SASSERT(!roots.empty());
         for (unsigned i = 0; i < roots.size(); ++i) {
             ast* a = roots[i];
@@ -1492,11 +1492,8 @@ void ast_manager::compact_memory() {
     unsigned capacity = m_ast_table.capacity();
     if (capacity > 4*m_ast_table.size()) {
         ast_table new_ast_table;
-        ast_table::iterator it  = m_ast_table.begin();
-        ast_table::iterator end = m_ast_table.end();
-        for (; it != end; ++it) {
-            new_ast_table.insert(*it);
-        }
+        for (ast* curr : m_ast_table)
+            new_ast_table.insert(curr);
         m_ast_table.swap(new_ast_table);
         IF_VERBOSE(10, verbose_stream() << "(ast-table :prev-capacity " << capacity
                    << " :capacity " << m_ast_table.capacity() << " :size " << m_ast_table.size() << ")\n";);
@@ -1510,10 +1507,7 @@ void ast_manager::compress_ids() {
     ptr_vector<ast> asts;
     m_expr_id_gen.cleanup();
     m_decl_id_gen.cleanup(c_first_decl_id);
-    ast_table::iterator it  = m_ast_table.begin();
-    ast_table::iterator end = m_ast_table.end();
-    for (; it != end; ++it) {
-        ast * n = *it;
+    for (ast * n : m_ast_table) {
         if (is_decl(n))
             n->m_id = m_decl_id_gen.mk();
         else
@@ -1521,10 +1515,8 @@ void ast_manager::compress_ids() {
         asts.push_back(n);
     }
     m_ast_table.finalize();
-    ptr_vector<ast>::iterator it2  = asts.begin();
-    ptr_vector<ast>::iterator end2 = asts.end();
-    for (; it2 != end2; ++it2)
-        m_ast_table.insert(*it2);
+    for (ast* a : asts) 
+        m_ast_table.insert(a);
 }
 
 void ast_manager::raise_exception(char const * msg) {
@@ -1570,20 +1562,15 @@ void ast_manager::copy_families_plugins(ast_manager const & from) {
 }
 
 void ast_manager::set_next_expr_id(unsigned id) {
-    while (true) {
-        id = m_expr_id_gen.set_next_id(id);
-        ast_table::iterator it  = m_ast_table.begin();
-        ast_table::iterator end = m_ast_table.end();
-        for (; it != end; ++it) {
-            ast * curr = *it;
-            if (curr->get_id() == id)
-                break;
+ try_again:
+    id = m_expr_id_gen.set_next_id(id);
+    for (ast * curr : m_ast_table) {
+        if (curr->get_id() == id) {
+            // id is in use, move to the next one.
+            ++id;
+            goto try_again;
         }
-        if (it == end)
-            return;
-        // id is in use, move to the next one.
-        id++;
-    }
+    }    
 }
 
 unsigned ast_manager::get_node_size(ast const * n) { return ::get_node_size(n); }
@@ -1683,7 +1670,7 @@ ast * ast_manager::register_node_core(ast * n) {
     bool contains = m_ast_table.contains(n);
     CASSERT("nondet_bug", contains || slow_not_contains(n));
 #endif
-    
+
     ast * r = m_ast_table.insert_if_not_there(n);
     SASSERT(r->m_hash == h);
     if (r != n) {
@@ -2358,8 +2345,9 @@ quantifier * ast_manager::mk_quantifier(bool forall, unsigned num_decls, sort *
                                         unsigned num_patterns, expr * const * patterns,
                                         unsigned num_no_patterns, expr * const * no_patterns) {
     SASSERT(body);
-    SASSERT(num_patterns == 0 || num_no_patterns == 0);
     SASSERT(num_decls > 0);
+    if (num_patterns != 0 && num_no_patterns != 0)
+        throw ast_exception("simultaneous patterns and no-patterns not supported");
     DEBUG_CODE({
             for (unsigned i = 0; i < num_patterns; ++i) {
                 TRACE("ast", tout << i << " " << mk_pp(patterns[i], *this) << "\n";);
@@ -2763,7 +2751,7 @@ proof * ast_manager::mk_transitivity(unsigned num_proofs, proof * const * proofs
 }
 
 proof * ast_manager::mk_transitivity(unsigned num_proofs, proof * const * proofs, expr * n1, expr * n2) {
-    if (num_proofs == 0) 
+    if (num_proofs == 0)
         return nullptr;
     if (num_proofs == 1)
         return proofs[0];

src/ast/ast.h

@@ -53,6 +53,12 @@ Revision History:
 #pragma warning(disable : 4355)
 #endif
 
+#ifdef _MSC_VER
+#  define Z3_NORETURN __declspec(noreturn)
+#else
+#  define Z3_NORETURN [[noreturn]]
+#endif
+
 class ast;
 class ast_manager;
 
@@ -330,7 +336,7 @@ std::ostream& operator<<(std::ostream& out, sort_size const & ss);
 // -----------------------------------
 
 /**
-   \brief Extra information that may be attached to intepreted sorts.
+   \brief Extra information that may be attached to interpreted sorts.
 */
 class sort_info : public decl_info {
     sort_size m_num_elements;
@@ -932,7 +938,7 @@ struct builtin_name {
 };
 
 /**
-   \brief Each family of intepreted function declarations and sorts must provide a plugin
+   \brief Each family of interpreted function declarations and sorts must provide a plugin
    to build sorts and decls of the family.
 */
 class decl_plugin {
@@ -1059,7 +1065,7 @@ protected:
     ptr_vector<func_decl> m_eq_decls;  // cached eqs
     ptr_vector<func_decl> m_ite_decls; // cached ites
 
-    ptr_vector<func_decl> m_oeq_decls;  // cached obsevational eqs
+    ptr_vector<func_decl> m_oeq_decls;  // cached observational eqs
     sort *      m_proof_sort;
     func_decl * m_undef_decl;
     func_decl * m_true_pr_decl;
@@ -1161,7 +1167,7 @@ public:
     virtual expr * get_some_value(sort * s);
 };
 
-typedef app proof; /* a proof is just an applicaton */
+typedef app proof; /* a proof is just an application */
 
 // -----------------------------------
 //
@@ -1220,7 +1226,7 @@ enum pattern_op_kind {
 
 /**
    \brief Patterns are used to group expressions. These expressions are using during E-matching for
-   heurisitic quantifier instantiation.
+   heuristic quantifier instantiation.
 */
 class pattern_decl_plugin : public decl_plugin {
 public:
@@ -1245,13 +1251,13 @@ enum model_value_op_kind {
 /**
    \brief Values are used during model construction. All values are
    assumed to be different.  Users should not use them, since they may
-   introduce unsoundess if the sort of a value is finite.
+   introduce unsoundness if the sort of a value is finite.
 
    Moreover, values should never be internalized in a logical context.
 
    However, values can be used during evaluation (i.e., simplification).
 
-   \remark Model values can be viewed as the partion ids in Z3 1.x.
+   \remark Model values can be viewed as the partition ids in Z3 1.x.
 */
 class model_value_decl_plugin : public decl_plugin {
 public:
@@ -1515,7 +1521,7 @@ public:
     void compress_ids();
 
     // Equivalent to throw ast_exception(msg)
-    void raise_exception(char const * msg);
+    Z3_NORETURN void raise_exception(char const * msg);
 
     bool is_format_manager() const { return m_format_manager == 0; }
 

src/ast/ast_smt_pp.cpp

@@ -340,8 +340,7 @@ class smt_printer {
     }
 
 
-    void pp_arg(expr *arg, app *parent)
-    {
+    void pp_arg(expr *arg, app *parent) {
         pp_marked_expr(arg);
     }
 
@@ -417,7 +416,7 @@ class smt_printer {
         else if (m_simplify_implies && m_manager.is_implies(decl) && m_manager.is_implies(n->get_arg(1))) {
             expr *curr = n;
             expr *arg;
-            m_out << "(implies (and";
+            m_out << "(=> (and";
             while (m_manager.is_implies(curr)) {
                 arg = to_app(curr)->get_arg(0);
 
@@ -476,9 +475,8 @@ class smt_printer {
         }
     }
 
-    void print_no_lets(expr *e)
-    {
-        smt_printer p(m_out, m_manager, m_qlists, m_renaming, m_logic, true, m_simplify_implies, true, m_indent, m_num_var_names, m_var_names);
+    void print_no_lets(expr *e) {
+        smt_printer p(m_out, m_manager, m_qlists, m_renaming, m_logic, true, m_simplify_implies, m_indent, m_num_var_names, m_var_names);
         p(e);
     }
 
@@ -511,7 +509,7 @@ class smt_printer {
             m_out << "(! ";
         }
         {
-            smt_printer p(m_out, m_manager, m_qlists, m_renaming, m_logic, false, true, m_simplify_implies, m_indent, m_num_var_names, m_var_names);
+            smt_printer p(m_out, m_manager, m_qlists, m_renaming, m_logic, false, m_simplify_implies, m_indent, m_num_var_names, m_var_names);
             p(q->get_expr());
         }
 
@@ -704,7 +702,7 @@ class smt_printer {
 
 public:
     smt_printer(std::ostream& out, ast_manager& m, ptr_vector<quantifier>& ql, smt_renaming& rn,
-                symbol logic, bool no_lets, bool is_smt2, bool simplify_implies, unsigned indent, unsigned num_var_names = 0, char const* const* var_names = 0) :
+                symbol logic, bool no_lets, bool simplify_implies, unsigned indent, unsigned num_var_names = 0, char const* const* var_names = 0) :
         m_out(out),
         m_manager(m),
         m_qlists(ql),
@@ -894,25 +892,17 @@ ast_smt_pp::ast_smt_pp(ast_manager& m):
     m_simplify_implies(true)
 {}
 
-
-void ast_smt_pp::display_expr(std::ostream& strm, expr* n) {
-    ptr_vector<quantifier> ql;
-    smt_renaming rn;
-    smt_printer p(strm, m_manager, ql, rn, m_logic, false, false, m_simplify_implies, 0);
-    p(n);
-}
-
 void ast_smt_pp::display_expr_smt2(std::ostream& strm, expr* n, unsigned indent, unsigned num_var_names, char const* const* var_names) {
     ptr_vector<quantifier> ql;
     smt_renaming rn;
-    smt_printer p(strm, m_manager, ql, rn, m_logic, false, true, m_simplify_implies, indent, num_var_names, var_names);
+    smt_printer p(strm, m_manager, ql, rn, m_logic, false, m_simplify_implies, indent, num_var_names, var_names);
     p(n);
 }
 
 void ast_smt_pp::display_ast_smt2(std::ostream& strm, ast* a, unsigned indent, unsigned num_var_names, char const* const* var_names) {
     ptr_vector<quantifier> ql;
     smt_renaming rn;
-    smt_printer p(strm, m_manager, ql, rn, m_logic, false, true, m_simplify_implies, indent, num_var_names, var_names);
+    smt_printer p(strm, m_manager, ql, rn, m_logic, false, m_simplify_implies, indent, num_var_names, var_names);
     if (is_expr(a)) {
         p(to_expr(a));
     }
@@ -1021,92 +1011,3 @@ void ast_smt_pp::display_smt2(std::ostream& strm, expr* n) {
         p(n);
     }
 }
-
-void ast_smt_pp::display(std::ostream& strm, expr* n) {
-    ptr_vector<quantifier> ql;
-    decl_collector decls(m_manager);
-    smt_renaming rn;
-
-    for (unsigned i = 0; i < m_assumptions.size(); ++i) {
-        decls.visit(m_assumptions[i].get());
-    }
-    for (unsigned i = 0; i < m_assumptions_star.size(); ++i) {
-        decls.visit(m_assumptions_star[i].get());
-    }
-    decls.visit(n);
-
-    strm << "(benchmark ";
-
-    if (m_benchmark_name != symbol::null) {
-        strm << m_benchmark_name << "\n";
-    }
-    else {
-        strm << "unnamed\n";
-    }
-    if (m_source_info != symbol::null && m_source_info != symbol("")) {
-        strm << ":source { " << m_source_info << " }\n";
-    }
-    strm << ":status " << m_status << "\n";
-    if (m_category != symbol::null && m_category != symbol("")) {
-        strm << ":category { " << m_category << " }\n";
-    }
-    if (m_logic != symbol::null && m_logic != symbol("")) {
-        strm << ":logic " << m_logic << "\n";
-    }
-
-    if (m_attributes.size() > 0) {
-        strm << m_attributes.c_str();
-    }
-
-    ast_mark sort_mark;
-    for (unsigned i = 0; i < decls.get_num_sorts(); ++i) {
-        sort* s = decls.get_sorts()[i];
-        if (!(*m_is_declared)(s)) {
-            smt_printer p(strm, m_manager, ql, rn, m_logic, true, false, m_simplify_implies, 0);
-            p.pp_sort_decl(sort_mark, s);
-        }
-    }
-
-    for (unsigned i = 0; i < decls.get_num_decls(); ++i) {
-        func_decl* d = decls.get_func_decls()[i];
-        if (!(*m_is_declared)(d)) {
-            strm << ":extrafuns (";
-            smt_printer p(strm, m_manager, ql, rn, m_logic, true, false, m_simplify_implies, 0);
-            p(d);
-            strm << ")\n";
-        }
-    }
-
-    for (unsigned i = 0; i < decls.get_num_preds(); ++i) {
-        func_decl* d = decls.get_pred_decls()[i];
-        if (!(*m_is_declared)(d)) {
-            strm << ":extrapreds (";
-            smt_printer p(strm, m_manager, ql, rn, m_logic, true, false, m_simplify_implies, 0);
-            p.visit_pred(d);
-            strm << ")\n";
-        }
-    }
-
-    for (unsigned i = 0; i < m_assumptions.size(); ++i) {
-        expr *    e = m_assumptions[i].get();
-        strm << ":assumption\n";
-        smt_printer p(strm, m_manager, ql, rn, m_logic, false, false, m_simplify_implies, 0);
-        p(e);
-        strm << "\n";
-    }
-
-    for (unsigned i = 0; i < m_assumptions_star.size(); ++i) {
-        strm << ":assumption-core\n";
-        smt_printer p(strm, m_manager, ql, rn, m_logic, false, false, m_simplify_implies, 0);
-        p(m_assumptions_star[i].get());
-        strm << "\n";
-    }
-
-    {
-        strm << ":formula\n";
-        smt_printer p(strm, m_manager, ql, rn, m_logic, false, false, m_simplify_implies, 0);
-        p(n);
-        strm << "\n";
-    }
-    strm << ")\n";
-}

src/ast/ast_smt_pp.h

@@ -75,9 +75,7 @@ public:
 
     void set_is_declared(is_declared* id) { m_is_declared = id; }
 
-    void display(std::ostream& strm, expr* n);
     void display_smt2(std::ostream& strm, expr* n);
-    void display_expr(std::ostream& strm, expr* n);
     void display_expr_smt2(std::ostream& strm, expr* n, unsigned indent = 0, unsigned num_var_names = 0, char const* const* var_names = 0);
     void display_ast_smt2(std::ostream& strm, ast* n, unsigned indent = 0, unsigned num_var_names = 0, char const* const* var_names = 0);
 

src/ast/proofs/proof_checker.cpp

@@ -502,7 +502,7 @@ bool proof_checker::check1_basic(proof* p, expr_ref_vector& side_conditions) {
         return false;
     }
     case PR_HYPOTHESIS: {
-        // TBD all branches with hyptheses must be closed by a later lemma.
+        // TBD all branches with hypotheses must be closed by a later lemma.
         if (match_proof(p) &&
             match_fact(p, fml)) {
             return true;
@@ -1284,7 +1284,7 @@ void proof_checker::dump_proof(unsigned num_antecedents, expr * const * antecede
         pp.add_assumption(antecedents[i]);
     expr_ref n(m);
     n = m.mk_not(consequent);
-    pp.display(out, n);
+    pp.display_smt2(out, n);
     out.close();
     m_proof_lemma_id++;
 }

src/ast/rewriter/bit_blaster/bit_blaster_tpl_def.h

@@ -1193,7 +1193,6 @@ bool bit_blaster_tpl<Cfg>::mk_const_case_multiplier(unsigned sz, expr * const *
         return false;
     }
     SASSERT(out_bits.empty());
-    
     ptr_buffer<expr, 128> na_bits;
     na_bits.append(sz, a_bits);
     ptr_buffer<expr, 128> nb_bits;

src/ast/static_features.cpp

@@ -111,16 +111,6 @@ void static_features::flush_cache() {
     m_expr2formula_depth.reset();
 }
 
-#if 0
-bool static_features::is_non_linear(expr * e) const {
-    if (!is_arith_expr(e))
-        return false;
-    if (is_numeral(e))
-        return true;
-    if (m_autil.is_add(e))
-        return true; // the non
-} 
-#endif
 
 bool static_features::is_diff_term(expr const * e, rational & r) const {
     // lhs can be 'x' or '(+ k x)'
@@ -301,10 +291,12 @@ void static_features::update_core(expr * e) {
                 m_num_interpreted_constants++;
         }
         if (fid == m_afid) {
+            // std::cout << mk_pp(e, m_manager) << "\n";
             switch (to_app(e)->get_decl_kind()) {
             case OP_MUL:
-                if (!is_numeral(to_app(e)->get_arg(0)))
+                if (!is_numeral(to_app(e)->get_arg(0)) || to_app(e)->get_num_args() > 2) {
                     m_num_non_linear++;
+                }
                 break;
             case OP_DIV:
             case OP_IDIV: