Merge branch 'master' of https://github.com/Z3Prover/z3

contrib/cmake/src/smt/CMakeLists.txt

@@ -43,6 +43,7 @@ z3_add_component(smt
     smt_statistics.cpp
     smt_theory.cpp
     smt_value_sort.cpp
+    smt2_extra_cmds.cpp
     theory_arith.cpp
     theory_array_base.cpp
     theory_array.cpp

scripts/mk_win_dist.py

@@ -315,8 +315,8 @@ def main():
         init_project_def()
         mk_dist_dirs()
         cp_licenses()
-        cp_vs_runtime()
+        cp_vs_runtimes()
-        mk_zip()
+        mk_zips()
 
 main()
 

src/ast/macros/macro_manager.cpp

@@ -189,7 +189,7 @@ func_decl * macro_manager::get_macro_interpretation(unsigned i, expr_ref & inter
     get_head_def(q, f, head, def);
     TRACE("macro_bug",
           tout << f->get_name() << "\n" << mk_pp(head, m_manager) << "\n" << mk_pp(q, m_manager) << "\n";);
-    m_util.mk_macro_interpretation(head, def, interp);
+    m_util.mk_macro_interpretation(head, q->get_num_decls(), def, interp);
     return f;
 }
 

src/ast/macros/macro_util.cpp

@@ -405,7 +405,7 @@ bool macro_util::is_quasi_macro_head(expr * n, unsigned num_decls) const {
    \brief Convert a quasi-macro head into a macro head, and store the conditions under
    which it is valid in cond.
 */
-void macro_util::quasi_macro_head_to_macro_head(app * qhead, unsigned num_decls, app_ref & head, expr_ref & cond) const {
+void macro_util::quasi_macro_head_to_macro_head(app * qhead, unsigned & num_decls, app_ref & head, expr_ref & cond) const {
     unsigned num_args = qhead->get_num_args();
     sbuffer<bool> found_vars;
     found_vars.resize(num_decls, false);
@@ -431,6 +431,7 @@ void macro_util::quasi_macro_head_to_macro_head(app * qhead, unsigned num_decls,
     }
     get_basic_simp()->mk_and(new_conds.size(), new_conds.c_ptr(), cond);
     head = m_manager.mk_app(qhead->get_decl(), new_args.size(), new_args.c_ptr());
+    num_decls = next_var_idx;
 }
 
 /**
@@ -440,10 +441,10 @@ void macro_util::quasi_macro_head_to_macro_head(app * qhead, unsigned num_decls,
 
    See normalize_expr
 */
-void macro_util::mk_macro_interpretation(app * head, expr * def, expr_ref & interp) const {
+void macro_util::mk_macro_interpretation(app * head, unsigned num_decls, expr * def, expr_ref & interp) const {
     SASSERT(is_macro_head(head, head->get_num_args()));
     SASSERT(!occurs(head->get_decl(), def));
-    normalize_expr(head, def, interp);
+    normalize_expr(head, num_decls, def, interp);
 }
 
 /**
@@ -456,36 +457,27 @@ void macro_util::mk_macro_interpretation(app * head, expr * def, expr_ref & inte
    f(x_1, x_2) --> f(x_0, x_1)
    f(x_3, x_2) --> f(x_0, x_1)
 */
-void macro_util::normalize_expr(app * head, expr * t, expr_ref & norm_t) const {
+void macro_util::normalize_expr(app * head, unsigned num_decls, expr * t, expr_ref & norm_t) const {
     expr_ref_buffer var_mapping(m_manager);
+    var_mapping.resize(num_decls);
     bool changed = false;
     unsigned num_args = head->get_num_args();
-    unsigned max_var_idx = 0;
-    for (unsigned i = 0; i < num_args; i++) {
-        var const * v = to_var(head->get_arg(i));
-        if (v->get_idx() > max_var_idx)
-            max_var_idx = v->get_idx();
-    }
     TRACE("macro_util",
           tout << "head: " << mk_pp(head, m_manager) << "\n";
           tout << "applying substitution to:\n" << mk_bounded_pp(t, m_manager) << "\n";);
     for (unsigned i = 0; i < num_args; i++) {
         var * v = to_var(head->get_arg(i));
-        if (v->get_idx() != i) {
+        unsigned vi = v->get_idx();
+        SASSERT(vi < num_decls);
+        if (vi != i) {
             changed = true;
             var_ref new_var(m_manager.mk_var(i, v->get_sort()), m_manager);
-            var_mapping.setx(max_var_idx - v->get_idx(), new_var);
+            var_mapping.setx(num_decls - vi - 1, new_var);
         }
         else
-            var_mapping.setx(max_var_idx - i, v);
+            var_mapping.setx(num_decls - i - 1, v);
     }
 
-    for (unsigned i = num_args; i <= max_var_idx; i++)
-        // CMW: Won't be used, but dictates a larger binding size,
-        // so that the indexes between here and in the rewriter match.
-        // It's possible that we don't see the true max idx of all vars here.
-        var_mapping.setx(max_var_idx - i, 0);
-
     if (changed) {
         // REMARK: t may have nested quantifiers... So, I must use the std order for variable substitution.
         var_subst subst(m_manager, true);
@@ -573,7 +565,7 @@ bool is_hint_atom(expr * lhs, expr * rhs) {
     return !occurs(to_app(lhs)->get_decl(), rhs) && vars_of_is_subset(rhs, vars);
 }
 
-void hint_to_macro_head(ast_manager & m, app * head, unsigned num_decls, app_ref & new_head) {
+void hint_to_macro_head(ast_manager & m, app * head, unsigned & num_decls, app_ref & new_head) {
     unsigned num_args = head->get_num_args();
     ptr_buffer<expr> new_args;
     sbuffer<bool> found_vars;
@@ -595,6 +587,7 @@ void hint_to_macro_head(ast_manager & m, app * head, unsigned num_decls, app_ref
         new_args.push_back(new_var);
     }
     new_head = m.mk_app(head->get_decl(), new_args.size(), new_args.c_ptr());
+    num_decls = next_var_idx;
 }
 
 /**
@@ -671,12 +664,12 @@ void macro_util::macro_candidates::insert(func_decl * f, expr * def, expr * cond
 //
 // -----------------------------
 
-void macro_util::insert_macro(app * head, expr * def, expr * cond, bool ineq, bool satisfy_atom, bool hint, macro_candidates & r) {
+void macro_util::insert_macro(app * head, unsigned num_decls, expr * def, expr * cond, bool ineq, bool satisfy_atom, bool hint, macro_candidates & r) {
     expr_ref norm_def(m_manager);
     expr_ref norm_cond(m_manager);
-    normalize_expr(head, def, norm_def);
+    normalize_expr(head, num_decls, def, norm_def);
     if (cond != 0)
-        normalize_expr(head, cond, norm_cond);
+        normalize_expr(head, num_decls, cond, norm_cond);
     else if (!hint)
         norm_cond = m_manager.mk_true();
     SASSERT(!hint || norm_cond.get() == 0);
@@ -698,11 +691,14 @@ void macro_util::insert_quasi_macro(app * head, unsigned num_decls, expr * def,
         }
         else {
             hint_to_macro_head(m_manager, head, num_decls, new_head);
+            TRACE("macro_util",
+                tout << "hint macro head: " << mk_ismt2_pp(new_head, m_manager) << std::endl;
+                tout << "hint macro def: " << mk_ismt2_pp(def, m_manager) << std::endl; );
         }
-        insert_macro(new_head, def, new_cond, ineq, satisfy_atom, hint, r);
+        insert_macro(new_head, num_decls, def, new_cond, ineq, satisfy_atom, hint, r);
     }
     else {
-        insert_macro(head, def, cond, ineq, satisfy_atom, hint, r);
+        insert_macro(head, num_decls, def, cond, ineq, satisfy_atom, hint, r);
     }
 }
 
@@ -879,6 +875,9 @@ void macro_util::collect_arith_macro_candidates(expr * atom, unsigned num_decls,
 */
 void macro_util::collect_macro_candidates_core(expr * atom, unsigned num_decls, macro_candidates & r) {
     expr* lhs, *rhs;
+
+    TRACE("macro_util", tout << "Candidate check for: " << mk_ismt2_pp(atom, m_manager) << std::endl;);
+
     if (m_manager.is_eq(atom, lhs, rhs) || m_manager.is_iff(atom, lhs, rhs)) {
         if (is_quasi_macro_head(lhs, num_decls) &&
             !is_forbidden(to_app(lhs)->get_decl()) &&

src/ast/macros/macro_util.h

@@ -74,8 +74,8 @@ private:
     void collect_arith_macros(expr * n, unsigned num_decls, unsigned max_macros, bool allow_cond_macros,
                               macro_candidates & r);
 
-    void normalize_expr(app * head, expr * t, expr_ref & norm_t) const;
+    void normalize_expr(app * head, unsigned num_decls, expr * t, expr_ref & norm_t) const;
-    void insert_macro(app * head, expr * def, expr * cond, bool ineq, bool satisfy_atom, bool hint, macro_candidates & r);
+    void insert_macro(app * head, unsigned num_decls, expr * def, expr * cond, bool ineq, bool satisfy_atom, bool hint, macro_candidates & r);
     void insert_quasi_macro(app * head, unsigned num_decls, expr * def, expr * cond, bool ineq, bool satisfy_atom, bool hint,
                             macro_candidates & r);
 
@@ -118,9 +118,9 @@ public:
     bool is_pseudo_predicate_macro(expr * n, app_ref & head, app_ref & t, expr_ref & def);
 
     bool is_quasi_macro_head(expr * n, unsigned num_decls) const;
-    void quasi_macro_head_to_macro_head(app * qhead, unsigned num_decls, app_ref & head, expr_ref & cond) const;
+    void quasi_macro_head_to_macro_head(app * qhead, unsigned & num_decls, app_ref & head, expr_ref & cond) const;
 
-    void mk_macro_interpretation(app * head, expr * def, expr_ref & interp) const;
+    void mk_macro_interpretation(app * head, unsigned num_decls, expr * def, expr_ref & interp) const;
 
     void collect_macro_candidates(expr * atom, unsigned num_decls, macro_candidates & r);
     void collect_macro_candidates(quantifier * q, macro_candidates & r);

src/parsers/smt2/smt2parser.cpp

@@ -109,7 +109,6 @@ namespace smt2 {
         typedef std::pair<symbol, expr*> named_expr;
         named_expr           m_last_named_expr;
 
-
         ast_manager & m() const { return m_ctx.m(); }
         pdecl_manager & pm() const { return m_ctx.pm(); }
         sexpr_manager & sm() const { return m_ctx.sm(); }
@@ -402,6 +401,9 @@ namespace smt2 {
         void check_int_or_float(char const * msg) { if (!curr_is_int() && !curr_is_float()) throw parser_exception(msg); }
         void check_float(char const * msg) { if (!curr_is_float()) throw parser_exception(msg); }
 
+        char const * m_current_file;
+        void set_current_file(char const * s) { m_current_file = s; }
+
         void error(unsigned line, unsigned pos, char const * msg) {
             m_ctx.set_cancel(false);
             if (use_vs_format()) {
@@ -410,7 +412,9 @@ namespace smt2 {
                     m_ctx.diagnostic_stream() << std::endl;
             }
             else {
-                m_ctx.regular_stream() << "(error \"line " << line << " column " << pos << ": " << escaped(msg, true) << "\")" << std::endl;
+                m_ctx.regular_stream() << "(error \"";
+                if (m_current_file) m_ctx.regular_stream() << m_current_file << ": ";
+                m_ctx.regular_stream()<< "line " << line << " column " << pos << ": " << escaped(msg, true) << "\")" << std::endl;
             }
             if (m_ctx.exit_on_error()) {
                 exit(1);
@@ -2558,7 +2562,7 @@ namespace smt2 {
         }
 
     public:
-        parser(cmd_context & ctx, std::istream & is, bool interactive, params_ref const & p):
+        parser(cmd_context & ctx, std::istream & is, bool interactive, params_ref const & p, char const * filename=0):
             m_ctx(ctx),
             m_params(p),
             m_scanner(ctx, is, interactive),
@@ -2598,7 +2602,8 @@ namespace smt2 {
             m_define_fun_rec("define-fun-rec"),
             m_define_funs_rec("define-funs-rec"),
             m_underscore("_"),
-            m_num_open_paren(0) {
+            m_num_open_paren(0),
+            m_current_file(filename) {
             // the following assertion does not hold if ctx was already attached to an AST manager before the parser object is created.
             // SASSERT(!m_ctx.has_manager());
 
@@ -2705,8 +2710,8 @@ namespace smt2 {
     };
 };
 
-bool parse_smt2_commands(cmd_context & ctx, std::istream & is, bool interactive, params_ref const & ps) {
+bool parse_smt2_commands(cmd_context & ctx, std::istream & is, bool interactive, params_ref const & ps, char const * filename) {
-    smt2::parser p(ctx, is, interactive, ps);
+    smt2::parser p(ctx, is, interactive, ps, filename);
     return p();
 }
 

src/parsers/smt2/smt2parser.h

@@ -21,6 +21,6 @@ Revision History:
 
 #include"cmd_context.h"
 
-bool parse_smt2_commands(cmd_context & ctx, std::istream & is, bool interactive = false, params_ref const & p = params_ref());
+bool parse_smt2_commands(cmd_context & ctx, std::istream & is, bool interactive = false, params_ref const & p = params_ref(), char const * filename = 0);
 
 #endif

src/shell/smtlib_frontend.cpp

@@ -29,6 +29,7 @@ Revision History:
 #include"opt_cmds.h"
 #include"polynomial_cmds.h"
 #include"subpaving_cmds.h"
+#include"smt2_extra_cmds.h"
 #include"smt_strategic_solver.h"
 #include"smt_solver.h"
 
@@ -113,6 +114,7 @@ unsigned read_smtlib2_commands(char const * file_name) {
     install_polynomial_cmds(ctx);
     install_subpaving_cmds(ctx);
     install_opt_cmds(ctx);
+    install_smt2_extra_cmds(ctx);
 
     g_cmd_context = &ctx;
     signal(SIGINT, on_ctrl_c);

src/smt/smt2_extra_cmds.cpp

@@ -0,0 +1,47 @@
+/*++
+Copyright (c) 2011 Microsoft Corporation
+
+Module Name:
+
+    smt2_extra_cmds.cpp
+
+Abstract:
+
+    Additional SMT-specific commands.
+
+Author:
+
+    Christoph (cwinter) 2017-01-16
+
+Notes:
+
+--*/
+#include"cmd_context.h"
+#include"smt2parser.h"
+#include"smt2_extra_cmds.h"
+
+class include_cmd : public cmd {
+    char const * m_filename;
+public:
+    include_cmd() : cmd("include"), m_filename(0) {}
+    virtual char const * get_usage() const { return "<string>"; }
+    virtual char const * get_descr(cmd_context & ctx) const { return "include a file"; }
+    virtual unsigned get_arity() const { return 1; }
+    virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const { return CPK_STRING; }
+    virtual void set_next_arg(cmd_context & ctx, char const * val) { m_filename = val; }
+    virtual void failure_cleanup(cmd_context & ctx) {}
+    virtual void execute(cmd_context & ctx) {
+        std::ifstream is(m_filename);
+        if (is.bad() || is.fail())
+            throw cmd_exception(std::string("failed to open file '") + m_filename + "'");
+        parse_smt2_commands(ctx, is, false, params_ref(), m_filename);
+        is.close();
+    }
+    virtual void prepare(cmd_context & ctx) { reset(ctx); }
+    virtual void reset(cmd_context & ctx) { m_filename = 0; }
+    virtual void finalize(cmd_context & ctx) { reset(ctx); }
+};
+
+void install_smt2_extra_cmds(cmd_context & ctx) {
+    ctx.insert(alloc(include_cmd));
+}

src/smt/smt2_extra_cmds.h

@@ -0,0 +1,26 @@
+/*++
+Copyright (c) 2011 Microsoft Corporation
+
+Module Name:
+
+    smt2_extra_cmds.h
+
+Abstract:
+
+    Additional SMT-specific commands.
+
+Author:
+
+    Christoph (cwinter) 2017-01-16
+
+Notes:
+
+--*/
+#ifndef SMT2_EXTRA_CMDS_H_
+#define SMT2_EXTRA_CMDS_H_
+
+class cmd_context;
+
+void install_smt2_extra_cmds(cmd_context & ctx);
+
+#endif /* SMT2_EXTRA_CMDS_H_ */