diff --git a/CMakeLists.txt b/CMakeLists.txt index c11c272be..e4732ef67 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -33,8 +33,8 @@ endif() # Project version ################################################################################ set(Z3_VERSION_MAJOR 4) -set(Z3_VERSION_MINOR 6) -set(Z3_VERSION_PATCH 2) +set(Z3_VERSION_MINOR 7) +set(Z3_VERSION_PATCH 0) 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/README.md b/README.md index e3ef58b70..447034a84 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 @@ -189,3 +189,6 @@ python -c 'import z3; print(z3.get_version_string())' See [``examples/python``](examples/python) for examples. +### ``Web Assembly`` + +[WebAssembly](https://github.com/cpitclaudel/z3.wasm) bindings are provided by Clément Pit-Claudel. diff --git a/examples/c++/example.cpp b/examples/c++/example.cpp index 0c002300d..640e3a10b 100644 --- a/examples/c++/example.cpp +++ b/examples/c++/example.cpp @@ -920,6 +920,19 @@ 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); + sorts[1] = pair.range(); + func_decl pair2 = ctx.tuple_sort("pair2", 2, names, sorts, projs); + + std::cout << pair2 << "\n"; +} + void expr_vector_example() { std::cout << "expr_vector example\n"; context c; @@ -1179,6 +1192,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/examples/c/test_capi.c b/examples/c/test_capi.c index b9f5d4e1d..e49b2991f 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"); diff --git a/scripts/mk_project.py b/scripts/mk_project.py index 4a508c471..3a2f30938 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, 7, 0, 0) add_lib('util', []) add_lib('polynomial', ['util'], 'math/polynomial') add_lib('sat', ['util']) diff --git a/scripts/update_api.py b/scripts/update_api.py index 18878d6ea..78fad45be 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') @@ -957,11 +954,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: @@ -1655,7 +1657,7 @@ else: if hasattr(builtins, "Z3_LIB_DIRS"): _all_dirs = builtins.Z3_LIB_DIRS -for v in ('Z3_LIBRARY_PATH', 'PATH'): +for v in ('Z3_LIBRARY_PATH', 'PATH', 'PYTHONPATH'): if v in os.environ: lp = os.environ[v]; lds = lp.split(';') if sys.platform in ('win32') else lp.split(':') diff --git a/src/api/api_context.cpp b/src/api/api_context.cpp index 12a4642c1..5993e9fdd 100644 --- a/src/api/api_context.cpp +++ b/src/api/api_context.cpp @@ -78,7 +78,6 @@ namespace api { m_bv_util(m()), m_datalog_util(m()), m_fpa_util(m()), - m_dtutil(m()), m_sutil(m()), m_last_result(m()), m_ast_trail(m()), @@ -184,7 +183,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_context.h b/src/api/api_context.h index 70ccf0e4d..50e89113d 100644 --- a/src/api/api_context.h +++ b/src/api/api_context.h @@ -61,7 +61,6 @@ namespace api { bv_util m_bv_util; datalog::dl_decl_util m_datalog_util; fpa_util m_fpa_util; - datatype_util m_dtutil; seq_util m_sutil; // Support for old solver API @@ -121,13 +120,13 @@ namespace api { bool produce_models() const { return m_params.m_model; } bool produce_unsat_cores() const { return m_params.m_unsat_core; } bool use_auto_config() const { return m_params.m_auto_config; } - unsigned get_timeout() { return params().m_timeout; } - unsigned get_rlimit() { return params().m_rlimit; } + unsigned get_timeout() const { return m_params.m_timeout; } + unsigned get_rlimit() const { return m_params.rlimit(); } arith_util & autil() { return m_arith_util; } bv_util & bvutil() { return m_bv_util; } datalog::dl_decl_util & datalog_util() { return m_datalog_util; } fpa_util & fpautil() { return m_fpa_util; } - datatype_util& dtutil() { return m_dtutil; } + datatype_util& dtutil() { return m_dt_plugin->u(); } seq_util& sutil() { return m_sutil; } family_id get_basic_fid() const { return m_basic_fid; } family_id get_array_fid() const { return m_array_fid; } diff --git a/src/api/api_datalog.cpp b/src/api/api_datalog.cpp index 5e0082f09..2bc3d01e1 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; @@ -215,7 +215,6 @@ extern "C" { RESET_ERROR_CODE(); VERIFY(mk_c(c)->datalog_util().try_get_size(to_sort(s), *out)); return Z3_TRUE; - Z3_CATCH_RETURN(Z3_FALSE); } 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..de9886571 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(); @@ -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; @@ -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 eac44ef1e..c17d71518 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. */ @@ -294,21 +303,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); @@ -661,8 +670,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; } @@ -745,35 +754,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; } @@ -2563,6 +2572,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)); @@ -2657,21 +2679,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); @@ -2789,6 +2811,12 @@ namespace z3 { inline func_decl function(char const * name, sort const & d1, sort const & d2, sort const & d3, sort const & d4, sort const & d5, sort const & range) { return range.ctx().function(name, d1, d2, d3, d4, d5, range); } + inline func_decl function(char const* name, sort_vector const& domain, sort const& range) { + return range.ctx().function(name, domain, range); + } + inline func_decl function(std::string const& name, sort_vector const& domain, sort const& range) { + return range.ctx().function(name.c_str(), domain, range); + } inline expr select(expr const & a, expr const & i) { check_context(a, i); 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: diff --git a/src/api/z3.h b/src/api/z3.h index e08b0c073..37ea68f84 100644 --- a/src/api/z3.h +++ b/src/api/z3.h @@ -22,6 +22,8 @@ Notes: #define Z3_H_ #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 9a38873cb..0825f27a0 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 */ /*@{*/ @@ -80,9 +72,9 @@ 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 int Z3_bool; +typedef bool Z3_bool; /** \brief Z3 string type. It is just an alias for \ccode{const char *}. @@ -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. @@ -6292,7 +6284,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 1515e6df7..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; } @@ -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); @@ -650,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); } @@ -660,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); } @@ -725,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); } @@ -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); } @@ -773,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); } @@ -781,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 e1b32af75..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; @@ -51,13 +51,14 @@ 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; 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); diff --git a/src/ast/ast.cpp b/src/ast/ast.cpp index c320bbdaa..a07be0b22 100644 --- a/src/ast/ast.cpp +++ b/src/ast/ast.cpp @@ -2259,7 +2259,12 @@ var * ast_manager::mk_var(unsigned idx, sort * s) { unsigned sz = var::get_obj_size(); void * mem = allocate_node(sz); var * new_node = new (mem) var(idx, s); - return register_node(new_node); + var * r = register_node(new_node); + + if (m_trace_stream && r == new_node) { + *m_trace_stream << "[mk-var] #" << r->get_id() << "\n"; + } + return r; } app * ast_manager::mk_label(bool pos, unsigned num_names, symbol const * names, expr * n) { diff --git a/src/ast/ast.h b/src/ast/ast.h index ed803fb4a..2db0fde04 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 fb270edf1..5906281df 100644 --- a/src/ast/ast_smt2_pp.cpp +++ b/src/ast/ast_smt2_pp.cpp @@ -395,7 +395,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/datatype_decl_plugin.cpp b/src/ast/datatype_decl_plugin.cpp index f685c70d5..d3704a84a 100644 --- a/src/ast/datatype_decl_plugin.cpp +++ b/src/ast/datatype_decl_plugin.cpp @@ -390,6 +390,7 @@ namespace datatype { TRACE("datatype", tout << "declaring " << datatypes[i]->name() << "\n";); if (m_defs.find(datatypes[i]->name(), d)) { TRACE("datatype", tout << "delete previous version for " << datatypes[i]->name() << "\n";); + u().reset(); dealloc(d); } m_defs.insert(datatypes[i]->name(), datatypes[i]); diff --git a/src/ast/datatype_decl_plugin.h b/src/ast/datatype_decl_plugin.h index f32e9990d..88b50af82 100644 --- a/src/ast/datatype_decl_plugin.h +++ b/src/ast/datatype_decl_plugin.h @@ -239,7 +239,6 @@ namespace datatype { map m_defs; svector m_def_block; unsigned m_class_id; - util & u() const; void inherit(decl_plugin* other_p, ast_translation& tr) override; @@ -279,6 +278,8 @@ namespace datatype { def const& get_def(sort* s) const { return *(m_defs[datatype_name(s)]); } def& get_def(symbol const& s) { return *(m_defs[s]); } bool is_declared(sort* s) const { return m_defs.contains(datatype_name(s)); } + util & u() const; + private: bool is_value_visit(expr * arg, ptr_buffer & todo) 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/bv2fpa_converter.cpp b/src/ast/fpa/bv2fpa_converter.cpp index ede6e43f3..f1c2b1a14 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); @@ -465,26 +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); - if (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(nullptr); -#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, convert_func_interp(mc, f, it->m_value)); } } } diff --git a/src/ast/fpa/fpa2bv_converter.cpp b/src/ast/fpa/fpa2bv_converter.cpp index c84af84d6..b079fc2ca 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); @@ -1919,7 +1919,7 @@ void fpa2bv_converter::mk_round_to_integral(sort * s, expr_ref & rm, expr_ref & expr_ref pow_2_sbitsm1(m), m1(m); pow_2_sbitsm1 = m_bv_util.mk_numeral(fu().fm().m_powers2(sbits - 1), sbits); - m1 = m_bv_util.mk_numeral(-1, ebits); + m1 = m_bv_util.mk_bv_neg(m_bv_util.mk_numeral(1, ebits)); m_simp.mk_eq(a_sig, pow_2_sbitsm1, t1); m_simp.mk_eq(a_exp, m1, t2); m_simp.mk_and(t1, t2, tie); @@ -1927,7 +1927,7 @@ void fpa2bv_converter::mk_round_to_integral(sort * s, expr_ref & rm, expr_ref & m_simp.mk_and(tie, rm_is_rte, c421); m_simp.mk_and(tie, rm_is_rta, c422); - c423 = m_bv_util.mk_sle(a_exp, m_bv_util.mk_numeral(-2, ebits)); + c423 = m_bv_util.mk_sle(a_exp, m_bv_util.mk_bv_neg(m_bv_util.mk_numeral(2, ebits))); dbg_decouple("fpa2bv_r2i_c421", c421); dbg_decouple("fpa2bv_r2i_c422", c422); @@ -2452,7 +2452,7 @@ void fpa2bv_converter::mk_to_fp_float(sort * to_srt, expr * rm, expr * x, expr_r const mpz & ovft = m_mpf_manager.m_powers2.m1(to_ebits+1, false); first_ovf_exp = m_bv_util.mk_numeral(ovft, from_ebits+2); first_udf_exp = m_bv_util.mk_concat( - m_bv_util.mk_numeral(-1, ebits_diff + 3), + m_bv_util.mk_bv_neg(m_bv_util.mk_numeral(1, ebits_diff + 3)), m_bv_util.mk_numeral(1, to_ebits + 1)); dbg_decouple("fpa2bv_to_float_first_ovf_exp", first_ovf_exp); dbg_decouple("fpa2bv_to_float_first_udf_exp", first_udf_exp); @@ -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); @@ -3106,7 +3107,7 @@ void fpa2bv_converter::mk_to_ieee_bv_unspecified(func_decl * f, unsigned num, ex expr_ref exp_bv(m), exp_all_ones(m); exp_bv = m_bv_util.mk_extract(ebits+sbits-2, sbits-1, result); - exp_all_ones = m.mk_eq(exp_bv, m_bv_util.mk_numeral(-1, ebits)); + exp_all_ones = m.mk_eq(exp_bv, m_bv_util.mk_bv_neg(m_bv_util.mk_numeral(1, ebits))); m_extra_assertions.push_back(exp_all_ones); expr_ref sig_bv(m), sig_is_non_zero(m); @@ -3241,18 +3242,34 @@ 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 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); + dbg_decouple("fpa2bv_to_bv_incd", incd); + dbg_decouple("fpa2bv_to_bv_ovfl", ovfl); - expr_ref ll(m), ul(m), in_range(m); + expr_ref ul(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)); + ul = m_bv_util.mk_zero_extend(3, m_bv_util.mk_bv_neg(m_bv_util.mk_numeral(1, bv_sz))); + in_range = m.mk_and(m.mk_or(m.mk_not(x_is_neg), + m.mk_eq(pre_rounded, m_bv_util.mk_numeral(0, bv_sz+3))), + 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)); + ul = m_bv_util.mk_zero_extend(4, m_bv_util.mk_bv_neg(m_bv_util.mk_numeral(1, bv_sz-1))); + ovfl = m.mk_or(ovfl, m_bv_util.mk_sle(pre_rounded, m_bv_util.mk_bv_neg(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); } - 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_ovfl", ovfl); + dbg_decouple("fpa2bv_to_bv_in_range_ul", ul); dbg_decouple("fpa2bv_to_bv_in_range", in_range); expr_ref rounded(m); diff --git a/src/ast/pattern/expr_pattern_match.cpp b/src/ast/pattern/expr_pattern_match.cpp index d688c840c..c441fb4ce 100644 --- a/src/ast/pattern/expr_pattern_match.cpp +++ b/src/ast/pattern/expr_pattern_match.cpp @@ -387,7 +387,7 @@ expr_pattern_match::initialize(char const * spec_string) { m_instrs.push_back(instr(BACKTRACK)); std::istringstream is(spec_string); - cmd_context ctx(true, &m_manager); + cmd_context ctx(true, &m_manager); bool ps = ctx.print_success_enabled(); ctx.set_print_success(false); VERIFY(parse_smt2_commands(ctx, is)); 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/ast/rewriter/fpa_rewriter.cpp b/src/ast/rewriter/fpa_rewriter.cpp index 162f9d5c7..d978779aa 100644 --- a/src/ast/rewriter/fpa_rewriter.cpp +++ b/src/ast/rewriter/fpa_rewriter.cpp @@ -773,7 +773,7 @@ br_status fpa_rewriter::mk_to_ieee_bv(func_decl * f, expr * arg, expr_ref & resu if (m_fm.is_nan(v)) { if (m_hi_fp_unspecified) { expr * args[4] = { bu.mk_numeral(0, 1), - bu.mk_numeral(-1, x.get_ebits()), + bu.mk_bv_neg(bu.mk_numeral(1, x.get_ebits())), bu.mk_numeral(0, x.get_sbits() - 2), bu.mk_numeral(1, 1) }; result = bu.mk_concat(4, args); diff --git a/src/ast/rewriter/seq_rewriter.cpp b/src/ast/rewriter/seq_rewriter.cpp index 89840ea43..3ead59833 100644 --- a/src/ast/rewriter/seq_rewriter.cpp +++ b/src/ast/rewriter/seq_rewriter.cpp @@ -200,6 +200,9 @@ void re2automaton::set_solver(expr_solver* solver) { m_sa = alloc(symbolic_automata_t, sm, *m_ba.get()); } +eautomaton* re2automaton::mk_product(eautomaton* a1, eautomaton* a2) { + return m_sa->mk_product(*a1, *a2); +} eautomaton* re2automaton::operator()(expr* e) { eautomaton* r = re2aut(e); @@ -364,6 +367,9 @@ br_status seq_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con SASSERT(num_args == 2); return mk_re_concat(args[0], args[1], result); case OP_RE_UNION: + if (num_args == 1) { + result = args[0]; return BR_DONE; + } SASSERT(num_args == 2); return mk_re_union(args[0], args[1], result); case OP_RE_RANGE: @@ -850,7 +856,7 @@ br_status seq_rewriter::mk_seq_replace(expr* a, expr* b, expr* c, expr_ref& resu return BR_DONE; } if (m_util.str.is_string(b, s2) && s2.length() == 0) { - result = m_util.str.mk_concat(a, c); + result = m_util.str.mk_concat(c, a); return BR_REWRITE1; } if (m_util.str.is_string(a, s1) && s1.length() == 0) { diff --git a/src/ast/rewriter/seq_rewriter.h b/src/ast/rewriter/seq_rewriter.h index 69f319168..95b043bd7 100644 --- a/src/ast/rewriter/seq_rewriter.h +++ b/src/ast/rewriter/seq_rewriter.h @@ -53,7 +53,9 @@ public: bool is_range() const { return m_ty == t_range; } sort* get_sort() const { return m_sort; } expr* get_char() const { SASSERT(is_char()); return m_t; } - + expr* get_pred() const { SASSERT(is_pred()); return m_t; } + expr* get_lo() const { SASSERT(is_range()); return m_t; } + expr* get_hi() const { SASSERT(is_range()); return m_s; } }; class sym_expr_manager { @@ -87,6 +89,7 @@ public: ~re2automaton(); eautomaton* operator()(expr* e); void set_solver(expr_solver* solver); + eautomaton* mk_product(eautomaton *a1, eautomaton *a2); }; /** diff --git a/src/ast/seq_decl_plugin.cpp b/src/ast/seq_decl_plugin.cpp index a390bee3c..cd8571a95 100644 --- a/src/ast/seq_decl_plugin.cpp +++ b/src/ast/seq_decl_plugin.cpp @@ -177,7 +177,7 @@ zstring zstring::replace(zstring const& src, zstring const& dst) const { return zstring(*this); } if (src.length() == 0) { - return zstring(*this); + return dst + zstring(*this); } bool found = false; for (unsigned i = 0; i < length(); ++i) { @@ -213,6 +213,9 @@ std::string zstring::encode() const { else if (ch == '\\') { strm << "\\\\"; } + else if (ch >= 128) { + strm << "\\x" << std::hex << (unsigned)ch << std::dec; + } else { strm << (char)(ch); } diff --git a/src/cmd_context/basic_cmds.cpp b/src/cmd_context/basic_cmds.cpp index 2fe58bb7c..c2c257f43 100644 --- a/src/cmd_context/basic_cmds.cpp +++ b/src/cmd_context/basic_cmds.cpp @@ -502,7 +502,7 @@ public: ctx.set_random_seed(to_unsigned(val)); } else if (m_option == m_reproducible_resource_limit) { - ctx.params().m_rlimit = to_unsigned(val); + ctx.params().set_rlimit(to_unsigned(val)); } else if (m_option == m_verbosity) { set_verbosity_level(to_unsigned(val)); diff --git a/src/cmd_context/cmd_context.cpp b/src/cmd_context/cmd_context.cpp index f2669feb1..20b28ecc1 100644 --- a/src/cmd_context/cmd_context.cpp +++ b/src/cmd_context/cmd_context.cpp @@ -720,8 +720,8 @@ 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";); + if (!has_logic() && new_manager) { + TRACE("cmd_context", tout << "init manager " << m_logic << "\n";); // add list type only if the logic is not specified. // it prevents clashes with builtin types. insert(pm().mk_plist_decl()); @@ -759,6 +759,7 @@ void cmd_context::init_external_manager() { } bool cmd_context::set_logic(symbol const & s) { + TRACE("cmd_context", tout << s << "\n";); if (has_logic()) throw cmd_exception("the logic has already been set"); if (has_manager() && m_main_ctx) @@ -1259,7 +1260,7 @@ void cmd_context::insert_aux_pdecl(pdecl * p) { m_aux_pdecls.push_back(p); } -void cmd_context::reset(bool finalize) { +void cmd_context::reset(bool finalize) { m_processing_pareto = false; m_logic = symbol::null; m_check_sat_result = nullptr; @@ -1346,7 +1347,8 @@ void cmd_context::push() { s.m_macros_stack_lim = m_macros_stack.size(); s.m_aux_pdecls_lim = m_aux_pdecls.size(); s.m_assertions_lim = m_assertions.size(); - if (m_solver) + m().limit().push(m_params.rlimit()); + if (m_solver) m_solver->push(); if (m_opt) m_opt->push(); @@ -1369,9 +1371,10 @@ void cmd_context::restore_func_decls(unsigned old_sz) { } void cmd_context::restore_psort_inst(unsigned old_sz) { - for (unsigned i = old_sz; i < m_psort_inst_stack.size(); ++i) { + for (unsigned i = m_psort_inst_stack.size(); i-- > old_sz; ) { pdecl * s = m_psort_inst_stack[i]; - s->reset_cache(*m_pmanager); + s->reset_cache(pm()); + pm().dec_ref(s); } m_psort_inst_stack.resize(old_sz); } @@ -1461,6 +1464,9 @@ void cmd_context::pop(unsigned n) { restore_assertions(s.m_assertions_lim); restore_psort_inst(s.m_psort_inst_stack_lim); m_scopes.shrink(new_lvl); + while (n--) { + m().limit().pop(); + } } @@ -1471,7 +1477,7 @@ void cmd_context::check_sat(unsigned num_assumptions, expr * const * assumptions TRACE("before_check_sat", dump_assertions(tout);); init_manager(); unsigned timeout = m_params.m_timeout; - unsigned rlimit = m_params.m_rlimit; + unsigned rlimit = m_params.rlimit(); scoped_watch sw(*this); lbool r; bool was_opt = false; @@ -1546,7 +1552,7 @@ void cmd_context::check_sat(unsigned num_assumptions, expr * const * assumptions void cmd_context::get_consequences(expr_ref_vector const& assumptions, expr_ref_vector const& vars, expr_ref_vector & conseq) { unsigned timeout = m_params.m_timeout; - unsigned rlimit = m_params.m_rlimit; + unsigned rlimit = m_params.rlimit(); lbool r; m_check_sat_result = m_solver.get(); // solver itself stores the result. m_solver->set_progress_callback(this); @@ -2039,8 +2045,8 @@ void cmd_context::dt_eh::operator()(sort * dt, pdecl* pd) { } } if (m_owner.m_scopes.size() > 0) { + m_owner.pm().inc_ref(pd); m_owner.m_psort_inst_stack.push_back(pd); - } } diff --git a/src/cmd_context/context_params.cpp b/src/cmd_context/context_params.cpp index 85ac2274b..ff39907da 100644 --- a/src/cmd_context/context_params.cpp +++ b/src/cmd_context/context_params.cpp @@ -135,7 +135,7 @@ void context_params::set(char const * param, char const * value) { } void context_params::updt_params() { - updt_params(gparams::get()); + updt_params(gparams::get_ref()); } void context_params::updt_params(params_ref const & p) { diff --git a/src/cmd_context/context_params.h b/src/cmd_context/context_params.h index df62057fe..3d2947b7a 100644 --- a/src/cmd_context/context_params.h +++ b/src/cmd_context/context_params.h @@ -27,6 +27,8 @@ class context_params { void set_bool(bool & opt, char const * param, char const * value); void set_uint(unsigned & opt, char const * param, char const * value); + unsigned m_rlimit; + public: bool m_auto_config; bool m_proof; @@ -42,10 +44,11 @@ public: bool m_unsat_core; bool m_smtlib2_compliant; // it must be here because it enable/disable the use of coercions in the ast_manager. unsigned m_timeout; - unsigned m_rlimit; + unsigned rlimit() const { return m_rlimit; } context_params(); void set(char const * param, char const * value); + void set_rlimit(unsigned lim) { m_rlimit = lim; } void updt_params(); void updt_params(params_ref const & p); static void collect_param_descrs(param_descrs & d); diff --git a/src/cmd_context/extra_cmds/dbg_cmds.cpp b/src/cmd_context/extra_cmds/dbg_cmds.cpp index 465bcb956..fa1d56fe2 100644 --- a/src/cmd_context/extra_cmds/dbg_cmds.cpp +++ b/src/cmd_context/extra_cmds/dbg_cmds.cpp @@ -271,7 +271,7 @@ UNARY_CMD(elim_unused_vars_cmd, "dbg-elim-unused-vars", "", "eliminate unu return; } expr_ref r(ctx.m()); - elim_unused_vars(ctx.m(), to_quantifier(arg), gparams::get(), r); + elim_unused_vars(ctx.m(), to_quantifier(arg), gparams::get_ref(), r); SASSERT(!is_quantifier(r) || !to_quantifier(r)->may_have_unused_vars()); ctx.display(ctx.regular_stream(), r); ctx.regular_stream() << std::endl; diff --git a/src/cmd_context/tactic_cmds.cpp b/src/cmd_context/tactic_cmds.cpp index 831056faf..cbe44da2d 100644 --- a/src/cmd_context/tactic_cmds.cpp +++ b/src/cmd_context/tactic_cmds.cpp @@ -207,7 +207,7 @@ public: tref->set_logic(ctx.get_logic()); ast_manager & m = ctx.m(); unsigned timeout = p.get_uint("timeout", ctx.params().m_timeout); - unsigned rlimit = p.get_uint("rlimit", ctx.params().m_rlimit); + unsigned rlimit = p.get_uint("rlimit", ctx.params().rlimit()); labels_vec labels; goal_ref g = alloc(goal, m, ctx.produce_proofs(), ctx.produce_models(), ctx.produce_unsat_cores()); assert_exprs_from(ctx, *g); @@ -323,7 +323,7 @@ public: assert_exprs_from(ctx, *g); unsigned timeout = p.get_uint("timeout", ctx.params().m_timeout); - unsigned rlimit = p.get_uint("rlimit", ctx.params().m_rlimit); + unsigned rlimit = p.get_uint("rlimit", ctx.params().rlimit()); goal_ref_buffer result_goals; 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/model/model_evaluator.cpp b/src/model/model_evaluator.cpp index 227e14ca6..0b25a250b 100644 --- a/src/model/model_evaluator.cpp +++ b/src/model/model_evaluator.cpp @@ -454,6 +454,7 @@ struct evaluator_cfg : public default_rewriter_cfg { func_decl* f = m_ar.get_as_array_func_decl(to_app(a)); func_interp* g = m_model.get_func_interp(f); + if (!g) return false; unsigned sz = g->num_entries(); unsigned arity = f->get_arity(); unsigned base_sz = stores.size(); 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 28165c6d5..6c52d0537 100644 --- a/src/muz/base/dl_util.cpp +++ b/src/muz/base/dl_util.cpp @@ -31,6 +31,10 @@ Revision History: #include "muz/base/dl_rule.h" #include "muz/base/dl_util.h" #include "util/stopwatch.h" +#ifndef __STDC_FORMAT_MACROS +#define __STDC_FORMAT_MACROS +#endif +#include namespace datalog { @@ -165,7 +169,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); @@ -626,11 +630,11 @@ 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); + int converted = sscanf_s(s, "%" SCNu64, &res); #else - int converted = sscanf(s, "%llu", &res); + int converted = sscanf(s, "%" SCNu64, &res); #endif if(converted==0) { return false; @@ -639,9 +643,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; @@ -669,7 +673,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/opt/opt_context.cpp b/src/opt/opt_context.cpp index b93149216..237cd132f 100644 --- a/src/opt/opt_context.cpp +++ b/src/opt/opt_context.cpp @@ -265,6 +265,9 @@ namespace opt { normalize(); internalize(); update_solver(); + if (contains_quantifiers()) { + warning_msg("optimization with quantified constraints is not supported"); + } #if 0 if (is_qsat_opt()) { return run_qsat_opt(); @@ -372,7 +375,6 @@ namespace opt { if (result == l_true && committed) m_optsmt.commit_assignment(index); if (result == l_true && m_optsmt.is_unbounded(index, is_max) && contains_quantifiers()) { throw default_exception("unbounded objectives on quantified constraints is not supported"); - result = l_undef; } return result; } @@ -1525,7 +1527,7 @@ namespace opt { } void context::validate_model() { - if (!gparams::get().get_bool("model_validate", false)) return; + if (!gparams::get_ref().get_bool("model_validate", false)) return; expr_ref_vector fmls(m); get_hard_constraints(fmls); expr_ref tmp(m); diff --git a/src/opt/opt_context.h b/src/opt/opt_context.h index 20b0d1c71..0f02dfb1c 100644 --- a/src/opt/opt_context.h +++ b/src/opt/opt_context.h @@ -316,13 +316,13 @@ namespace opt { struct is_propositional_fn; bool is_propositional(expr* e); - void init_solver(); - void update_solver(); - void setup_arith_solver(); - void add_maxsmt(symbol const& id, unsigned index); - void set_simplify(tactic *simplify); - void set_pareto(pareto_base* p); - void clear_state(); + void init_solver(); + void update_solver(); + void setup_arith_solver(); + void add_maxsmt(symbol const& id, unsigned index); + void set_simplify(tactic *simplify); + void set_pareto(pareto_base* p); + void clear_state(); bool is_numeral(expr* e, rational& n) const; diff --git a/src/opt/wmax.cpp b/src/opt/wmax.cpp index 52b87e536..513c68d6e 100644 --- a/src/opt/wmax.cpp +++ b/src/opt/wmax.cpp @@ -84,6 +84,9 @@ namespace opt { if (m.canceled()) { is_sat = l_undef; } + if (is_sat == l_undef) { + break; + } if (is_sat == l_false) { TRACE("opt", tout << "Unsat\n";); break; @@ -97,9 +100,6 @@ namespace opt { //DEBUG_CODE(verify_cores(cores);); s().assert_expr(fml); } - else { - //DEBUG_CODE(verify_cores(cores);); - } update_cores(wth(), cores); wth().init_min_cost(m_upper - m_lower); trace_bounds("wmax"); diff --git a/src/parsers/smt2/smt2parser.cpp b/src/parsers/smt2/smt2parser.cpp index e88a293bd..9276b60cd 100644 --- a/src/parsers/smt2/smt2parser.cpp +++ b/src/parsers/smt2/smt2parser.cpp @@ -951,8 +951,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(); } diff --git a/src/parsers/util/pattern_validation.cpp b/src/parsers/util/pattern_validation.cpp index 0d076aadd..df1f6cd00 100644 --- a/src/parsers/util/pattern_validation.cpp +++ b/src/parsers/util/pattern_validation.cpp @@ -48,7 +48,7 @@ struct pattern_validation_functor { bool is_forbidden(func_decl const * decl) { family_id fid = decl->get_family_id(); - if (fid == m_bfid && decl->get_decl_kind() != OP_TRUE && decl->get_decl_kind() != OP_FALSE) + if (fid == m_bfid && decl->get_decl_kind() != OP_EQ && decl->get_decl_kind() != OP_TRUE && decl->get_decl_kind() != OP_FALSE) return true; if (fid == m_lfid) return true; 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/sat/ba_solver.cpp b/src/sat/ba_solver.cpp index 9340ac635..90f737109 100644 --- a/src/sat/ba_solver.cpp +++ b/src/sat/ba_solver.cpp @@ -1020,14 +1020,14 @@ namespace sat { SASSERT(v != null_bool_var); m_coeffs.reserve(v + 1, 0); - int64 coeff0 = m_coeffs[v]; + int64_t coeff0 = m_coeffs[v]; if (coeff0 == 0) { m_active_vars.push_back(v); } - int64 loffset = static_cast(offset); - int64 inc = l.sign() ? -loffset : loffset; - int64 coeff1 = inc + coeff0; + int64_t loffset = static_cast(offset); + int64_t inc = l.sign() ? -loffset : loffset; + int64_t coeff1 = inc + coeff0; m_coeffs[v] = coeff1; if (coeff1 > INT_MAX || coeff1 < INT_MIN) { m_overflow = true; @@ -1040,7 +1040,7 @@ namespace sat { else if (coeff0 < 0 && inc > 0) { inc_bound(coeff0 - std::min(0LL, coeff1)); } - int64 lbound = static_cast(m_bound); + int64_t lbound = static_cast(m_bound); // reduce coefficient to be no larger than bound. if (coeff1 > lbound) { @@ -1051,12 +1051,12 @@ namespace sat { } } - int64 ba_solver::get_coeff(bool_var v) const { + int64_t ba_solver::get_coeff(bool_var v) const { return m_coeffs.get(v, 0); } unsigned ba_solver::get_abs_coeff(bool_var v) const { - int64 c = get_coeff(v); + int64_t c = get_coeff(v); if (c < INT_MIN+1 || c > UINT_MAX) { m_overflow = true; return UINT_MAX; @@ -1065,7 +1065,7 @@ namespace sat { } int ba_solver::get_int_coeff(bool_var v) const { - int64 c = m_coeffs.get(v, 0); + int64_t c = m_coeffs.get(v, 0); if (c < INT_MIN || c > INT_MAX) { m_overflow = true; return 0; @@ -1073,12 +1073,12 @@ namespace sat { return static_cast(c); } - void ba_solver::inc_bound(int64 i) { + void ba_solver::inc_bound(int64_t i) { if (i < INT_MIN || i > INT_MAX) { m_overflow = true; return; } - int64 new_bound = m_bound; + int64_t new_bound = m_bound; new_bound += i; if (new_bound < 0) { m_overflow = true; @@ -1196,7 +1196,7 @@ namespace sat { switch (cnstr.tag()) { case card_t: { card& c = cnstr.to_card(); - inc_bound(static_cast(offset) * c.k()); + inc_bound(static_cast(offset) * c.k()); process_card(c, offset); break; } @@ -1269,7 +1269,7 @@ namespace sat { js = s().m_justification[v]; offset = get_abs_coeff(v); if (offset > m_bound) { - int64 bound64 = static_cast(m_bound); + int64_t bound64 = static_cast(m_bound); m_coeffs[v] = (get_coeff(v) < 0) ? -bound64 : bound64; offset = m_bound; DEBUG_CODE(active2pb(m_A);); @@ -1323,8 +1323,8 @@ namespace sat { } IF_VERBOSE(0, active2pb(m_A); - uint64 c = 0; - for (uint64 c1 : m_A.m_coeffs) c += c1; + uint64_t c = 0; + for (uint64_t c1 : m_A.m_coeffs) c += c1; verbose_stream() << "sum of coefficients: " << c << "\n"; display(verbose_stream(), m_A, true); verbose_stream() << "conflicting literal: " << s().m_not_l << "\n";); @@ -1347,18 +1347,18 @@ namespace sat { bool adjusted = false; adjust_conflict_level: - int64 bound64 = m_bound; - int64 slack = -bound64; + int64_t bound64 = m_bound; + int64_t slack = -bound64; for (bool_var v : m_active_vars) { slack += get_abs_coeff(v); } m_lemma.reset(); m_lemma.push_back(null_literal); unsigned num_skipped = 0; - int64 asserting_coeff = 0; + int64_t asserting_coeff = 0; for (unsigned i = 0; 0 <= slack && i < m_active_vars.size(); ++i) { bool_var v = m_active_vars[i]; - int64 coeff = get_coeff(v); + int64_t coeff = get_coeff(v); lbool val = value(v); bool is_true = val == l_true; bool append = coeff != 0 && val != l_undef && (coeff < 0 == is_true); @@ -1434,7 +1434,7 @@ namespace sat { continue; } if (m_bound < coeff) { - int64 bound64 = m_bound; + int64_t bound64 = m_bound; if (get_coeff(v) > 0) { m_coeffs[v] = bound64; } @@ -1474,7 +1474,7 @@ namespace sat { inc_coeff(c[i], offset); } if (lit != null_literal) { - uint64 offset1 = static_cast(offset) * c.k(); + uint64_t offset1 = static_cast(offset) * c.k(); if (offset1 > UINT_MAX) { m_overflow = true; } @@ -3753,12 +3753,12 @@ namespace sat { } bool ba_solver::validate_lemma() { - int64 bound64 = m_bound; - int64 val = -bound64; + int64_t bound64 = m_bound; + int64_t val = -bound64; reset_active_var_set(); for (bool_var v : m_active_vars) { if (m_active_var_set.contains(v)) continue; - int64 coeff = get_coeff(v); + int64_t coeff = get_coeff(v); if (coeff == 0) continue; m_active_var_set.insert(v); literal lit(v, false); @@ -3782,7 +3782,7 @@ namespace sat { p.reset(m_bound); for (bool_var v : m_active_vars) { if (m_active_var_set.contains(v)) continue; - int64 coeff = get_coeff(v); + int64_t coeff = get_coeff(v); if (coeff == 0) continue; m_active_var_set.insert(v); literal lit(v, coeff < 0); @@ -3794,7 +3794,7 @@ namespace sat { ba_solver::constraint* ba_solver::active2constraint() { reset_active_var_set(); m_wlits.reset(); - uint64 sum = 0; + uint64_t sum = 0; if (m_bound == 1) return 0; if (m_overflow) return 0; @@ -3855,7 +3855,7 @@ namespace sat { } std::sort(m_wlits.begin(), m_wlits.end(), compare_wlit()); unsigned k = 0; - uint64 sum = 0, sum0 = 0; + uint64_t sum = 0, sum0 = 0; for (wliteral wl : m_wlits) { if (sum >= m_bound) break; sum0 = sum; @@ -3986,15 +3986,15 @@ namespace sat { bool ba_solver::validate_resolvent() { return true; - u_map coeffs; - uint64 k = m_A.m_k + m_B.m_k; + u_map coeffs; + uint64_t k = m_A.m_k + m_B.m_k; for (unsigned i = 0; i < m_A.m_lits.size(); ++i) { - uint64 coeff = m_A.m_coeffs[i]; + uint64_t coeff = m_A.m_coeffs[i]; SASSERT(!coeffs.contains(m_A.m_lits[i].index())); coeffs.insert(m_A.m_lits[i].index(), coeff); } for (unsigned i = 0; i < m_B.m_lits.size(); ++i) { - uint64 coeff1 = m_B.m_coeffs[i], coeff2; + uint64_t coeff1 = m_B.m_coeffs[i], coeff2; literal lit = m_B.m_lits[i]; if (coeffs.find((~lit).index(), coeff2)) { if (coeff1 == coeff2) { @@ -4022,7 +4022,7 @@ namespace sat { // C is above the sum of A and B for (unsigned i = 0; i < m_C.m_lits.size(); ++i) { literal lit = m_C.m_lits[i]; - uint64 coeff; + uint64_t coeff; if (coeffs.find(lit.index(), coeff)) { if (coeff > m_C.m_coeffs[i] && m_C.m_coeffs[i] < m_C.m_k) { goto violated; @@ -4103,7 +4103,7 @@ namespace sat { \brief encode the case where Sum(a) >= k-1 & Sum(b) >= 1 \/ ... \/ Sum(a) >= 1 & Sum(b) >= k-1 */ literal ba_solver::translate_to_sat(solver& s, u_map& translation, ineq& a, ineq& b) { - uint64 k0 = a.m_k; + uint64_t k0 = a.m_k; literal_vector lits; for (unsigned k = 1; k < a.m_k - 1; ++k) { a.m_k = k; b.m_k = k0 - k; @@ -4143,7 +4143,7 @@ namespace sat { ba_solver::ineq ba_solver::negate(ineq const& a) const { ineq result; - uint64 sum = 0; + uint64_t sum = 0; for (unsigned i = 0; i < a.m_lits.size(); ++i) { result.push(~a.m_lits[i], a.m_coeffs[i]); sum += a.m_coeffs[i]; @@ -4170,9 +4170,9 @@ namespace sat { return false; } } - uint64 value = 0; + uint64_t value = 0; for (unsigned i = 0; i < p.m_lits.size(); ++i) { - uint64 coeff = p.m_coeffs[i]; + uint64_t coeff = p.m_coeffs[i]; if (!lits.contains(p.m_lits[i])) { value += coeff; } diff --git a/src/sat/ba_solver.h b/src/sat/ba_solver.h index 9b5a31774..c565c362e 100644 --- a/src/sat/ba_solver.h +++ b/src/sat/ba_solver.h @@ -204,12 +204,12 @@ namespace sat { protected: struct ineq { - literal_vector m_lits; - svector m_coeffs; - uint64 m_k; + literal_vector m_lits; + svector m_coeffs; + uint64_t m_k; ineq(): m_k(0) {} - void reset(uint64 k) { m_lits.reset(); m_coeffs.reset(); m_k = k; } - void push(literal l, uint64 c) { m_lits.push_back(l); m_coeffs.push_back(c); } + void reset(uint64_t k) { m_lits.reset(); m_coeffs.reset(); m_k = k; } + void push(literal l, uint64_t c) { m_lits.push_back(l); m_coeffs.push_back(c); } }; solver* m_solver; @@ -229,7 +229,7 @@ namespace sat { // conflict resolution unsigned m_num_marks; unsigned m_conflict_lvl; - svector m_coeffs; + svector m_coeffs; svector m_active_vars; unsigned m_bound; tracked_uint_set m_active_var_set; @@ -426,11 +426,11 @@ namespace sat { void reset_active_var_set(); void normalize_active_coeffs(); void inc_coeff(literal l, unsigned offset); - int64 get_coeff(bool_var v) const; + int64_t get_coeff(bool_var v) const; unsigned get_abs_coeff(bool_var v) const; int get_int_coeff(bool_var v) const; unsigned get_bound() const; - void inc_bound(int64 i); + void inc_bound(int64_t i); literal get_asserting_literal(literal conseq); void process_antecedent(literal l, unsigned offset); diff --git a/src/sat/sat_asymm_branch.cpp b/src/sat/sat_asymm_branch.cpp index b2053c68f..941426321 100644 --- a/src/sat/sat_asymm_branch.cpp +++ b/src/sat/sat_asymm_branch.cpp @@ -105,7 +105,7 @@ namespace sat { void asymm_branch::process(big* big, clause_vector& clauses) { - int64 limit = -m_asymm_branch_limit; + int64_t limit = -m_asymm_branch_limit; std::stable_sort(clauses.begin(), clauses.end(), clause_size_lt()); m_counter -= clauses.size(); clause_vector::iterator it = clauses.begin(); diff --git a/src/sat/sat_asymm_branch.h b/src/sat/sat_asymm_branch.h index 6034ce5f3..4d032022c 100644 --- a/src/sat/sat_asymm_branch.h +++ b/src/sat/sat_asymm_branch.h @@ -33,7 +33,7 @@ namespace sat { solver & s; params_ref m_params; - int64 m_counter; + int64_t m_counter; random_gen m_rand; unsigned m_calls; @@ -43,7 +43,7 @@ namespace sat { unsigned m_asymm_branch_delay; bool m_asymm_branch_sampled; bool m_asymm_branch_all; - int64 m_asymm_branch_limit; + int64_t m_asymm_branch_limit; // stats unsigned m_elim_literals; diff --git a/src/sat/sat_lookahead.cpp b/src/sat/sat_lookahead.cpp index 57ef90af9..122c628a0 100644 --- a/src/sat/sat_lookahead.cpp +++ b/src/sat/sat_lookahead.cpp @@ -47,7 +47,7 @@ namespace sat { void lookahead::flip_prefix() { if (m_trail_lim.size() < 64) { - uint64 mask = (1ull << m_trail_lim.size()); + uint64_t mask = (1ull << m_trail_lim.size()); m_prefix = mask | (m_prefix & (mask - 1)); } } @@ -909,7 +909,7 @@ namespace sat { void lookahead::display_search_string() { printf("\r"); - uint64 q = m_prefix; + uint64_t q = m_prefix; unsigned depth = m_trail_lim.size(); unsigned d = std::min(63u, depth); unsigned new_prefix_length = d; diff --git a/src/sat/sat_lookahead.h b/src/sat/sat_lookahead.h index 3213c5a80..d03ceb64a 100644 --- a/src/sat/sat_lookahead.h +++ b/src/sat/sat_lookahead.h @@ -27,13 +27,13 @@ Notes: namespace sat { struct pp_prefix { - uint64 m_prefix; + uint64_t m_prefix; unsigned m_depth; - pp_prefix(uint64 p, unsigned d) : m_prefix(p), m_depth(d) {} + pp_prefix(uint64_t p, unsigned d) : m_prefix(p), m_depth(d) {} }; inline std::ostream& operator<<(std::ostream& out, pp_prefix const& p) { - uint64 q = p.m_prefix; + uint64_t q = p.m_prefix; unsigned d = std::min(63u, p.m_depth); for (unsigned i = 0; i <= d; ++i) { if (0 != (p.m_prefix & (1ull << i))) out << "1"; else out << "0"; @@ -238,7 +238,7 @@ namespace sat { double m_lookahead_reward; // metric associated with current lookahead1 literal. literal_vector m_wstack; // windofall stack that is populated in lookahead1 mode unsigned m_last_prefix_length; - uint64 m_prefix; // where we are in search tree + uint64_t m_prefix; // where we are in search tree svector m_vprefix; // var: prefix where variable participates in propagation unsigned m_rating_throttle; // throttle to recompute rating indexed_uint_set m_freevars; @@ -523,7 +523,7 @@ namespace sat { void update_lookahead_reward(literal l, unsigned level); bool dl_enabled(literal l) const { return m_lits[l.index()].m_double_lookahead != m_istamp_id; } void dl_disable(literal l) { m_lits[l.index()].m_double_lookahead = m_istamp_id; } - bool dl_no_overflow(unsigned base) const { return base + 2 * m_lookahead.size() * static_cast(m_config.m_dl_max_iterations + 1) < c_fixed_truth; } + bool dl_no_overflow(unsigned base) const { return base + 2 * m_lookahead.size() * static_cast(m_config.m_dl_max_iterations + 1) < c_fixed_truth; } unsigned do_double(literal l, unsigned& base); unsigned double_look(literal l, unsigned& base); diff --git a/src/sat/sat_solver.cpp b/src/sat/sat_solver.cpp index ecef12553..1f3995d49 100644 --- a/src/sat/sat_solver.cpp +++ b/src/sat/sat_solver.cpp @@ -782,7 +782,7 @@ namespace sat { } if (m_config.m_anti_exploration) { - uint64 age = m_stats.m_conflict - m_canceled[v]; + uint64_t age = m_stats.m_conflict - m_canceled[v]; if (age > 0) { double decay = pow(0.95, age); m_activity[v] = static_cast(m_activity[v] * decay); @@ -1032,7 +1032,7 @@ namespace sat { return check_par(num_lits, lits); } flet _searching(m_searching, true); - if (m_mc.empty() && gparams::get().get_bool("model_validate", false)) { + if (m_mc.empty() && gparams::get_ref().get_bool("model_validate", false)) { m_clone = alloc(solver, m_params, m_rlimit); m_clone->copy(*this); } @@ -3101,7 +3101,7 @@ namespace sat { SASSERT(value(v) == l_undef); m_case_split_queue.unassign_var_eh(v); if (m_config.m_branching_heuristic == BH_LRB) { - uint64 interval = m_stats.m_conflict - m_last_propagation[v]; + uint64_t interval = m_stats.m_conflict - m_last_propagation[v]; if (interval > 0) { auto activity = m_activity[v]; auto reward = (m_config.m_reward_offset * (m_participated[v] + m_reasoned[v])) / interval; diff --git a/src/sat/sat_solver.h b/src/sat/sat_solver.h index 5e5af6d9f..a3d6ea527 100644 --- a/src/sat/sat_solver.h +++ b/src/sat/sat_solver.h @@ -120,11 +120,11 @@ namespace sat { // branch variable selection: svector m_activity; unsigned m_activity_inc; - svector m_last_conflict; - svector m_last_propagation; - svector m_participated; - svector m_canceled; - svector m_reasoned; + svector m_last_conflict; + svector m_last_propagation; + svector m_participated; + svector m_canceled; + svector m_reasoned; int m_action; double m_step_size; // phase diff --git a/src/sat/sat_solver/inc_sat_solver.cpp b/src/sat/sat_solver/inc_sat_solver.cpp index 41c5ebbbf..6107e5252 100644 --- a/src/sat/sat_solver/inc_sat_solver.cpp +++ b/src/sat/sat_solver/inc_sat_solver.cpp @@ -816,7 +816,7 @@ private: TRACE("sat", model_smt2_pp(tout, m, *mdl, 0);); - if (!gparams::get().get_bool("model_validate", false)) return; + if (!gparams::get_ref().get_bool("model_validate", false)) return; IF_VERBOSE(0, verbose_stream() << "Verifying solution\n";); model_evaluator eval(*mdl); eval.set_model_completion(false); 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/shell/lp_frontend.cpp b/src/shell/lp_frontend.cpp index c79396cd1..ad9bcbd54 100644 --- a/src/shell/lp_frontend.cpp +++ b/src/shell/lp_frontend.cpp @@ -55,8 +55,8 @@ struct front_end_resource_limit : public lp::lp_resource_limit { void run_solver(lp_params & params, char const * mps_file_name) { reslimit rlim; - unsigned timeout = gparams::get().get_uint("timeout", 0); - unsigned rlimit = gparams::get().get_uint("rlimit", 0); + unsigned timeout = gparams::get_ref().get_uint("timeout", 0); + unsigned rlimit = gparams::get_ref().get_uint("rlimit", 0); front_end_resource_limit lp_limit(rlim); scoped_rlimit _rlimit(rlim, rlimit); diff --git a/src/shell/opt_frontend.cpp b/src/shell/opt_frontend.cpp index a0cef1557..5af5bfdd7 100644 --- a/src/shell/opt_frontend.cpp +++ b/src/shell/opt_frontend.cpp @@ -115,7 +115,7 @@ static unsigned parse_opt(std::istream& in, opt_format f) { case l_undef: std::cout << "unknown\n"; break; } - if (r != l_false && gparams::get().get_bool("model_validate", false)) { + if (r != l_false && gparams::get_ref().get_bool("model_validate", false)) { model_ref mdl; opt.get_model(mdl); expr_ref_vector hard(m); diff --git a/src/smt/params/smt_params_helper.pyg b/src/smt/params/smt_params_helper.pyg index d9603ebdb..a85365de0 100644 --- a/src/smt/params/smt_params_helper.pyg +++ b/src/smt/params/smt_params_helper.pyg @@ -80,6 +80,12 @@ def_module_params(module_name='smt', ('theory_aware_branching', BOOL, False, 'Allow the context to use extra information from theory solvers regarding literal branching prioritization.'), ('str.finite_overlap_models', BOOL, False, 'attempt a finite model search for overlapping variables instead of completely giving up on the arrangement'), ('str.overlap_priority', DOUBLE, -0.1, 'theory-aware priority for overlapping variable cases; use smt.theory_aware_branching=true'), + ('str.regex_automata', BOOL, True, 'use automata-based reasoning for regular expressions (Z3str3 only)'), + ('str.regex_automata_difficulty_threshold', UINT, 1000, 'difficulty threshold for regex automata heuristics'), + ('str.regex_automata_intersection_difficulty_threshold', UINT, 1000, 'difficulty threshold for regex intersection heuristics'), + ('str.regex_automata_failed_automaton_threshold', UINT, 10, 'number of failed automaton construction attempts after which a full automaton is automatically built'), + ('str.regex_automata_failed_intersection_threshold', UINT, 10, 'number of failed automaton intersection attempts after which intersection is always computed'), + ('str.regex_automata_length_attempt_threshold', UINT, 10, 'number of length/path constraint attempts before checking unsatisfiability of regex terms'), ('core.minimize', BOOL, False, 'minimize unsat core produced by SMT context'), ('core.extend_patterns', BOOL, False, 'extend unsat core with literals that trigger (potential) quantifier instances'), ('core.extend_patterns.max_distance', UINT, UINT_MAX, 'limits the distance of a pattern-extended unsat core'), diff --git a/src/smt/params/theory_str_params.cpp b/src/smt/params/theory_str_params.cpp index afbfc33fc..92478bcd9 100644 --- a/src/smt/params/theory_str_params.cpp +++ b/src/smt/params/theory_str_params.cpp @@ -31,4 +31,10 @@ void theory_str_params::updt_params(params_ref const & _p) { m_UseBinarySearch = p.str_use_binary_search(); m_BinarySearchInitialUpperBound = p.str_binary_search_start(); m_OverlapTheoryAwarePriority = p.str_overlap_priority(); + m_RegexAutomata = p.str_regex_automata(); + m_RegexAutomata_DifficultyThreshold = p.str_regex_automata_difficulty_threshold(); + m_RegexAutomata_IntersectionDifficultyThreshold = p.str_regex_automata_intersection_difficulty_threshold(); + m_RegexAutomata_FailedAutomatonThreshold = p.str_regex_automata_failed_automaton_threshold(); + m_RegexAutomata_FailedIntersectionThreshold = p.str_regex_automata_failed_intersection_threshold(); + m_RegexAutomata_LengthAttemptThreshold = p.str_regex_automata_length_attempt_threshold(); } diff --git a/src/smt/params/theory_str_params.h b/src/smt/params/theory_str_params.h index c841609db..8c7816839 100644 --- a/src/smt/params/theory_str_params.h +++ b/src/smt/params/theory_str_params.h @@ -80,6 +80,43 @@ struct theory_str_params { double m_OverlapTheoryAwarePriority; + /* + * If RegexAutomata is set to true, + * Z3str3 will use automata-based methods to reason about + * regular expression constraints. + */ + bool m_RegexAutomata; + + /* + * RegexAutomata_DifficultyThreshold is the lowest difficulty above which Z3str3 + * will not eagerly construct an automaton for a regular expression term. + */ + unsigned m_RegexAutomata_DifficultyThreshold; + + /* + * RegexAutomata_IntersectionDifficultyThreshold is the lowest difficulty above which Z3str3 + * will not eagerly intersect automata to check unsatisfiability. + */ + unsigned m_RegexAutomata_IntersectionDifficultyThreshold; + + /* + * RegexAutomata_FailedAutomatonThreshold is the number of failed attempts to build an automaton + * after which a full automaton (i.e. with no length information) will be built regardless of difficulty. + */ + unsigned m_RegexAutomata_FailedAutomatonThreshold; + + /* + * RegexAutomaton_FailedIntersectionThreshold is the number of failed attempts to perform automaton + * intersection after which intersection will always be performed regardless of difficulty. + */ + unsigned m_RegexAutomata_FailedIntersectionThreshold; + + /* + * RegexAutomaton_LengthAttemptThreshold is the number of attempts to satisfy length/path constraints + * before which we begin checking unsatisfiability of a regex term. + */ + unsigned m_RegexAutomata_LengthAttemptThreshold; + theory_str_params(params_ref const & p = params_ref()): m_StrongArrangements(true), m_AggressiveLengthTesting(false), @@ -91,7 +128,13 @@ struct theory_str_params { m_FiniteOverlapModels(false), m_UseBinarySearch(false), m_BinarySearchInitialUpperBound(64), - m_OverlapTheoryAwarePriority(-0.1) + m_OverlapTheoryAwarePriority(-0.1), + m_RegexAutomata(true), + m_RegexAutomata_DifficultyThreshold(1000), + m_RegexAutomata_IntersectionDifficultyThreshold(1000), + m_RegexAutomata_FailedAutomatonThreshold(10), + m_RegexAutomata_FailedIntersectionThreshold(10), + m_RegexAutomata_LengthAttemptThreshold(10) { updt_params(p); } diff --git a/src/smt/smt_context.cpp b/src/smt/smt_context.cpp index 14df1615f..12c64c404 100644 --- a/src/smt/smt_context.cpp +++ b/src/smt/smt_context.cpp @@ -3980,7 +3980,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/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(); } diff --git a/src/smt/smt_types.h b/src/smt/smt_types.h index 6300bd43c..e062a4ad6 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; diff --git a/src/smt/theory_datatype.cpp b/src/smt/theory_datatype.cpp index 3d3d56055..049555297 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); @@ -389,10 +424,11 @@ namespace smt { final_check_status theory_datatype::final_check_eh() { int num_vars = get_num_vars(); final_check_status r = FC_DONE; + 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)) { + if (!oc_cycle_free(node) && occurs_check(node)) { // conflict was detected... // return... return FC_CONTINUE; @@ -410,6 +446,73 @@ 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,...) + 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 + while (app->get_root() != root->get_root()) { + 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; + } + + 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) { + for (enode * arg : enode::args(d->m_constructor)) { + if (oc_cycle_free(arg)) { + continue; + } + 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->get_root(), 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: @@ -418,17 +521,39 @@ 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); + 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"; @@ -437,48 +562,6 @@ namespace smt { } return res; } - - /** - \brief Auxiliary method for occurs_check. - TODO: improve performance. - */ - bool theory_datatype::occurs_check_core(enode * app) { - if (app->is_marked()) - return false; - - m_stats.m_occurs_check++; - app->set_mark(); - m_to_unmark.push_back(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 2337fd0ea..010e78cb3 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,11 +72,36 @@ namespace smt { void propagate_recognizer(theory_var v, enode * r); void sign_recognizer_conflict(enode * c, enode * r); - ptr_vector m_to_unmark; - enode_pair_vector m_used_eqs; - enode * m_main; + typedef enum { ENTER, EXIT } stack_op; + typedef map, ptr_eq > parent_tbl; + typedef std::pair stack_entry; + + 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_on_stack(enode * n); + bool oc_on_stack(enode * n) const { return n->get_root()->is_marked(); } + + 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); + + // class for managing state of final_check + class final_check_st { + theory_datatype * th; + public: + final_check_st(theory_datatype * th); + ~final_check_st(); + }; + + enode * oc_get_cstor(enode * n); 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); 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/smt/theory_pb.cpp b/src/smt/theory_pb.cpp index 6ef15f2ac..40965ee82 100644 --- a/src/smt/theory_pb.cpp +++ b/src/smt/theory_pb.cpp @@ -500,7 +500,16 @@ namespace smt { expr* arg = atom->get_arg(i); literal l = compile_arg(arg); numeral c = pb.get_coeff(atom, i); - args.push_back(std::make_pair(l, c)); + switch (ctx.get_assignment(l)) { + case l_true: + k -= c; + break; + case l_false: + break; + default: + args.push_back(std::make_pair(l, c)); + break; + } } if (pb.is_at_most_k(atom) || pb.is_le(atom)) { // turn W <= k into -W >= -k @@ -512,7 +521,7 @@ namespace smt { else { SASSERT(pb.is_at_least_k(atom) || pb.is_ge(atom) || pb.is_eq(atom)); } - TRACE("pb", display(tout, *c);); + TRACE("pb", display(tout, *c, true);); //app_ref fml1(m), fml2(m); //fml1 = c->to_expr(ctx, m); c->unique(); diff --git a/src/smt/theory_seq.cpp b/src/smt/theory_seq.cpp index 94841603d..95f804863 100644 --- a/src/smt/theory_seq.cpp +++ b/src/smt/theory_seq.cpp @@ -134,8 +134,7 @@ void theory_seq::solution_map::pop_scope(unsigned num_scopes) { if (num_scopes == 0) return; m_cache.reset(); unsigned start = m_limit[m_limit.size() - num_scopes]; - for (unsigned i = m_updates.size(); i > start; ) { - --i; + for (unsigned i = m_updates.size(); i-- > start; ) { if (m_updates[i] == INS) { m_map.remove(m_lhs[i].get()); } @@ -436,8 +435,8 @@ bool theory_seq::is_unit_eq(expr_ref_vector const& ls, expr_ref_vector const& rs if (ls.empty() || !is_var(ls[0])) { return false; } - for (unsigned i = 0; i < rs.size(); ++i) { - if (!m_util.str.is_unit(rs[i])) { + for (expr* r : rs) { + if (!m_util.str.is_unit(r)) { return false; } } @@ -482,8 +481,7 @@ void theory_seq::branch_unit_variable(dependency* dep, expr* X, expr_ref_vector bool theory_seq::branch_variable_mb() { bool change = false; - for (unsigned i = 0; i < m_eqs.size(); ++i) { - eq const& e = m_eqs[i]; + for (eq const& e : m_eqs) { vector len1, len2; if (!is_complex(e)) { continue; @@ -1473,7 +1471,7 @@ bool theory_seq::add_solution(expr* l, expr* r, dependency* deps) { if (l == r) { return false; } - TRACE("seq", tout << mk_pp(l, m) << " ==> " << mk_pp(r, m) << "\n";); + TRACE("seq", tout << mk_pp(l, m) << " ==> " << mk_pp(r, m) << "\n"; display_deps(tout, deps);); m_new_solution = true; m_rep.update(l, r, deps); enode* n1 = ensure_enode(l); @@ -1513,7 +1511,9 @@ bool theory_seq::solve_eq(expr_ref_vector const& l, expr_ref_vector const& r, de change = canonize(r, rs, dep2) || change; deps = m_dm.mk_join(dep2, deps); TRACE("seq", tout << l << " = " << r << " ==> "; - tout << ls << " = " << rs << "\n";); + tout << ls << " = " << rs << "\n"; + display_deps(tout, deps); + ); if (!ctx.inconsistent() && simplify_eq(ls, rs, deps)) { return true; } @@ -2224,63 +2224,7 @@ void theory_seq::internalize_eq_eh(app * atom, bool_var v) { } bool theory_seq::internalize_atom(app* a, bool) { -#if 1 return internalize_term(a); -#else - if (is_skolem(m_eq, a)) { - return internalize_term(a); - } - context & ctx = get_context(); - bool_var bv = ctx.mk_bool_var(a); - ctx.set_var_theory(bv, get_id()); - ctx.mark_as_relevant(bv); - - expr* e1, *e2; - if (m_util.str.is_in_re(a, e1, e2)) { - return internalize_term(to_app(e1)) && internalize_re(e2); - } - if (m_util.str.is_contains(a, e1, e2) || - m_util.str.is_prefix(a, e1, e2) || - m_util.str.is_suffix(a, e1, e2)) { - return internalize_term(to_app(e1)) && internalize_term(to_app(e2)); - } - if (is_accept(a) || is_reject(a) || is_step(a) || is_skolem(symbol("seq.is_digit"), a)) { - return true; - } - UNREACHABLE(); - return internalize_term(a); -#endif -} - -bool theory_seq::internalize_re(expr* e) { - expr* e1, *e2; - unsigned lc, uc; - if (m_util.re.is_to_re(e, e1)) { - return internalize_term(to_app(e1)); - } - if (m_util.re.is_star(e, e1) || - m_util.re.is_plus(e, e1) || - m_util.re.is_opt(e, e1) || - m_util.re.is_loop(e, e1, lc) || - m_util.re.is_loop(e, e1, lc, uc) || - m_util.re.is_complement(e, e1)) { - return internalize_re(e1); - } - if (m_util.re.is_union(e, e1, e2) || - m_util.re.is_intersection(e, e1, e2) || - m_util.re.is_concat(e, e1, e2)) { - return internalize_re(e1) && internalize_re(e2); - } - if (m_util.re.is_full_seq(e) || - m_util.re.is_full_char(e) || - m_util.re.is_empty(e)) { - return true; - } - if (m_util.re.is_range(e, e1, e2)) { - return internalize_term(to_app(e1)) && internalize_term(to_app(e2)); - } - UNREACHABLE(); - return internalize_term(to_app(e)); } bool theory_seq::internalize_term(app* term) { @@ -2344,8 +2288,8 @@ void theory_seq::add_int_string(expr* e) { 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; + for (expr * e : m_int_string) { + expr* n = nullptr; if (m_util.str.is_itos(e) && add_itos_val_axiom(e)) { change = true; } @@ -2358,9 +2302,21 @@ bool theory_seq::check_int_string() { 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))); + expr* s = nullptr; + VERIFY (m_util.str.is_stoi(e, s)); + + // stoi(s) >= -1 + literal l = mk_simplified_literal(m_autil.mk_ge(e, m_autil.mk_int(-1))); add_axiom(l); + + // stoi(s) >= 0 <=> s 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(s, num_re), m); + literal ge0 = mk_simplified_literal(m_autil.mk_ge(e, m_autil.mk_int(0))); + add_axiom(~ge0, mk_literal(in_re)); + add_axiom(ge0, ~mk_literal(in_re)); } bool theory_seq::add_stoi_val_axiom(expr* e) { @@ -2404,8 +2360,9 @@ 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, c = 1; i-- > 0; c *= 10) { - coeff = m_autil.mk_int(c); + rational c(1); + for (unsigned i = sz; i-- > 0; c *= rational(10)) { + coeff = m_autil.mk_numeral(c, true); nums[i] = m_autil.mk_mul(coeff, nums[i].get()); } num = m_autil.mk_add(nums.size(), nums.c_ptr()); @@ -2674,7 +2631,12 @@ void theory_seq::init_model(expr_ref_vector const& es) { } } +void theory_seq::finalize_model(model_generator& mg) { + m_rep.pop_scope(1); +} + void theory_seq::init_model(model_generator & mg) { + m_rep.push_scope(); m_factory = alloc(seq_factory, get_manager(), get_family_id(), mg.get_model()); mg.register_factory(m_factory); for (ne const& n : m_nqs) { @@ -3428,8 +3390,8 @@ void theory_seq::add_itos_length_axiom(expr* len) { void theory_seq::propagate_in_re(expr* n, bool is_true) { TRACE("seq", tout << mk_pp(n, m) << " <- " << (is_true?"true":"false") << "\n";); - expr* e1 = nullptr, *e2 = nullptr; - VERIFY(m_util.str.is_in_re(n, e1, e2)); + expr* s = nullptr, *re = nullptr; + VERIFY(m_util.str.is_in_re(n, s, re)); expr_ref tmp(n, m); m_rewrite(tmp); @@ -3450,21 +3412,21 @@ void theory_seq::propagate_in_re(expr* n, bool is_true) { return; } - expr_ref e3(e2, m); + expr_ref e3(re, m); context& ctx = get_context(); literal lit = ctx.get_literal(n); if (!is_true) { - e3 = m_util.re.mk_complement(e2); + e3 = m_util.re.mk_complement(re); lit.neg(); } eautomaton* a = get_automaton(e3); if (!a) return; - expr_ref len(m_util.str.mk_length(e1), m); + expr_ref len(m_util.str.mk_length(s), m); for (unsigned i = 0; i < a->num_states(); ++i) { - literal acc = mk_accept(e1, len, e3, i); - literal rej = mk_reject(e1, len, e3, i); + literal acc = mk_accept(s, len, e3, i); + literal rej = mk_reject(s, len, e3, i); add_axiom(a->is_final_state(i)?acc:~acc); add_axiom(a->is_final_state(i)?~rej:rej); } @@ -3475,8 +3437,8 @@ void theory_seq::propagate_in_re(expr* n, bool is_true) { literal_vector lits; lits.push_back(~lit); - for (unsigned i = 0; i < states.size(); ++i) { - lits.push_back(mk_accept(e1, zero, e3, states[i])); + for (unsigned st : states) { + lits.push_back(mk_accept(s, zero, e3, st)); } if (lits.size() == 2) { propagate_lit(nullptr, 1, &lit, lits[1]); @@ -3527,8 +3489,8 @@ static bool get_arith_value(context& ctx, theory_id afid, expr* e, expr_ref& v) bool theory_seq::get_num_value(expr* e, rational& val) const { context& ctx = get_context(); expr_ref _val(m); - if (!ctx.e_internalized(e)) - return false; + if (!ctx.e_internalized(e)) + return false; enode* next = ctx.get_enode(e), *n = next; do { if (get_arith_value(ctx, m_autil.get_family_id(), next->get_owner(), _val) && m_autil.is_numeral(_val, val) && val.is_int()) { @@ -3925,8 +3887,8 @@ theory_seq::dependency* theory_seq::mk_join(dependency* deps, literal lit) { } theory_seq::dependency* theory_seq::mk_join(dependency* deps, literal_vector const& lits) { - for (unsigned i = 0; i < lits.size(); ++i) { - deps = mk_join(deps, lits[i]); + for (literal l : lits) { + deps = mk_join(deps, l); } return deps; } @@ -4131,53 +4093,15 @@ void theory_seq::new_diseq_eh(theory_var v1, theory_var v2) { TRACE("seq", tout << "new disequality " << get_context().get_scope_level() << ": " << eq << "\n";); m_rewrite(eq); if (!m.is_false(eq)) { - literal lit = mk_eq(e1, e2, false); - if (m_util.str.is_empty(e2)) { std::swap(e1, e2); } - if (false && m_util.str.is_empty(e1)) { - expr_ref head(m), tail(m), conc(m); - mk_decompose(e2, head, tail); - conc = mk_concat(head, tail); - propagate_eq(~lit, e2, conc, true); - } -#if 0 - - // (e1 = "" & e2 = xdz) or (e2 = "" & e1 = xcy) or (e1 = xcy & e2 = xdz & c != d) or (e1 = x & e2 = xdz) or (e2 = x & e1 = xcy) - // e1 = "" or e1 = xcy or e1 = x - // e2 = "" or e2 = xdz or e2 = x - // e1 = xcy or e2 = xdz - // c != d - - sort* char_sort = 0; - expr_ref emp(m); - VERIFY(m_util.is_seq(m.get_sort(e1), char_sort)); - emp = m_util.str.mk_empty(m.get_sort(e1)); - - expr_ref x = mk_skolem(symbol("seq.ne.x"), e1, e2); - expr_ref y = mk_skolem(symbol("seq.ne.y"), e1, e2); - expr_ref z = mk_skolem(symbol("seq.ne.z"), e1, e2); - expr_ref c = mk_skolem(symbol("seq.ne.c"), e1, e2, 0, char_sort); - expr_ref d = mk_skolem(symbol("seq.ne.d"), e1, e2, 0, char_sort); - literal e1_is_emp = mk_seq_eq(e1, emp); - literal e2_is_emp = mk_seq_eq(e2, emp); - literal e1_is_xcy = mk_seq_eq(e1, mk_concat(x, m_util.str.mk_unit(c), y)); - literal e2_is_xdz = mk_seq_eq(e2, mk_concat(x, m_util.str.mk_unit(d), z)); - add_axiom(lit, e1_is_emp, e1_is_xcy, mk_seq_eq(e1, x)); - add_axiom(lit, e2_is_emp, e2_is_xdz, mk_seq_eq(e2, x)); - add_axiom(lit, e1_is_xcy, e2_is_xdz); - add_axiom(lit, ~mk_eq(c, d, false)); -#else - else { - dependency* dep = m_dm.mk_leaf(assumption(~lit)); - m_nqs.push_back(ne(e1, e2, dep)); - solve_nqs(m_nqs.size() - 1); - } -#endif + dependency* dep = m_dm.mk_leaf(assumption(~lit)); + m_nqs.push_back(ne(e1, e2, dep)); + solve_nqs(m_nqs.size() - 1); } } @@ -4508,8 +4432,7 @@ bool theory_seq::add_reject2reject(expr* rej, bool& change) { ensure_nth(~len_le_idx, s, idx); literal_vector eqs; bool has_undef = false; - for (unsigned i = 0; i < mvs.size(); ++i) { - eautomaton::move const& mv = mvs[i]; + for (eautomaton::move const& mv : mvs) { literal eq = mk_literal(mv.t()->accept(nth)); switch (ctx.get_assignment(eq)) { case l_false: diff --git a/src/smt/theory_seq.h b/src/smt/theory_seq.h index 21aedd7e3..b6b553dec 100644 --- a/src/smt/theory_seq.h +++ b/src/smt/theory_seq.h @@ -64,14 +64,14 @@ namespace smt { // + a cache for normalization. class solution_map { enum map_update { INS, DEL }; - ast_manager& m; + ast_manager& m; dependency_manager& m_dm; - eqdep_map_t m_map; - eval_cache m_cache; - expr_ref_vector m_lhs, m_rhs; + eqdep_map_t m_map; + eval_cache m_cache; + expr_ref_vector m_lhs, m_rhs; ptr_vector m_deps; - svector m_updates; - unsigned_vector m_limit; + svector m_updates; + unsigned_vector m_limit; void add_trail(map_update op, expr* l, expr* r, dependency* d); public: @@ -362,6 +362,7 @@ namespace smt { void collect_statistics(::statistics & st) const override; model_value_proc * mk_value(enode * n, model_generator & mg) override; void init_model(model_generator & mg) override; + void finalize_model(model_generator & mg) override; void init_search_eh() override; void init_model(expr_ref_vector const& es); @@ -389,7 +390,6 @@ namespace smt { vector const& ll, vector const& rl); bool set_empty(expr* x); bool is_complex(eq const& e); - bool internalize_re(expr* e); bool check_extensionality(); bool check_contains(); diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp index 7d2364f4b..126594b06 100644 --- a/src/smt/theory_str.cpp +++ b/src/smt/theory_str.cpp @@ -25,6 +25,8 @@ #include "smt/theory_seq_empty.h" #include "smt/theory_arith.h" #include "ast/ast_util.h" +#include "ast/rewriter/seq_rewriter.h" +#include "smt_kernel.h" namespace smt { @@ -33,7 +35,7 @@ namespace smt { m_params(params), /* Options */ opt_EagerStringConstantLengthAssertions(true), - opt_VerifyFinalCheckProgress(true), + opt_VerifyFinalCheckProgress(false), opt_LCMUnrollStep(2), opt_NoQuickReturn_IntegerTheory(false), opt_DisableIntegerTheoryIntegration(false), @@ -48,9 +50,12 @@ namespace smt { finalCheckProgressIndicator(false), m_trail(m), m_factory(nullptr), + m_mk_aut(m), m_unused_id(0), m_delayed_axiom_setup_terms(m), m_delayed_assertions_todo(m), + m_persisted_axioms(m), + m_persisted_axiom_todo(m), tmpStringVarCount(0), tmpXorVarCount(0), tmpLenTestVarCount(0), @@ -72,6 +77,10 @@ namespace smt { theory_str::~theory_str() { m_trail_stack.reset(); + for (eautomaton * aut : regex_automata) { + dealloc(aut); + } + regex_automata.clear(); } expr * theory_str::mk_string(zstring const& str) { @@ -96,6 +105,26 @@ namespace smt { return u.str.mk_string(sym); } + class seq_expr_solver : public expr_solver { + kernel m_kernel; + public: + seq_expr_solver(ast_manager& m, smt_params& fp): + m_kernel(m, fp) {} + virtual lbool check_sat(expr* e) { + m_kernel.push(); + m_kernel.assert_expr(e); + lbool r = m_kernel.check(); + m_kernel.pop(1); + return r; + } + }; + + void theory_str::init(context * ctx) { + theory::init(ctx); + m_mk_aut.set_solver(alloc(seq_expr_solver, get_manager(), + get_context().get_fparams())); + } + void theory_str::initialize_charset() { bool defaultCharset = true; if (defaultCharset) { @@ -266,10 +295,13 @@ namespace smt { } void theory_str::refresh_theory_var(expr * e) { + ast_manager & m = get_manager(); enode * en = ensure_enode(e); theory_var v = mk_var(en); (void)v; TRACE("str", tout << "refresh " << mk_pp(e, get_manager()) << ": v#" << v << std::endl;); - m_basicstr_axiom_todo.push_back(en); + if (m.get_sort(e) == u.str.mk_string_sort()) { + m_basicstr_axiom_todo.push_back(en); + } } theory_var theory_str::mk_var(enode* n) { @@ -686,6 +718,12 @@ namespace smt { bool n2HasEqcValue = false; expr * v1 = get_eqc_value(n1, n1HasEqcValue); expr * v2 = get_eqc_value(n2, n2HasEqcValue); + if (u.str.is_string(v1)) { + n1HasEqcValue = true; + } + if (u.str.is_string(v2)) { + n2HasEqcValue = true; + } if (n1HasEqcValue && n2HasEqcValue) { zstring n1_str; u.str.is_string(v1, n1_str); @@ -797,6 +835,7 @@ namespace smt { || !m_concat_axiom_todo.empty() || !m_concat_eval_todo.empty() || !m_library_aware_axiom_todo.empty() || !m_delayed_axiom_setup_terms.empty() + || !m_persisted_axiom_todo.empty() || (search_started && !m_delayed_assertions_todo.empty()) ; } @@ -894,6 +933,11 @@ namespace smt { } m_delayed_axiom_setup_terms.reset(); + for (expr * a : m_persisted_axiom_todo) { + assert_axiom(a); + } + m_persisted_axiom_todo.reset(); + if (search_started) { for (auto const& el : m_delayed_assertions_todo) { assert_axiom(el); @@ -1695,12 +1739,11 @@ namespace smt { { expr_ref premise(m_autil.mk_ge(ex, m_autil.mk_numeral(rational::one(), true)), m); - expr_ref hd(mk_str_var("hd"), m); - expr_ref tl(mk_str_var("tl"), m); - expr_ref conclusion1(ctx.mk_eq_atom(S, mk_concat(hd, tl)), m); - expr_ref conclusion2(ctx.mk_eq_atom(mk_strlen(hd), m_autil.mk_numeral(rational::one(), true)), m); - expr_ref conclusion3(mk_not(m, ctx.mk_eq_atom(hd, mk_string("0"))), m); - expr_ref conclusion(m.mk_and(conclusion1, conclusion2, conclusion3), m); + // S >= 1 --> S in [1-9][0-9]* + expr_ref re_positiveInteger(u.re.mk_concat( + u.re.mk_range(mk_string("1"), mk_string("9")), + u.re.mk_star(u.re.mk_range(mk_string("0"), mk_string("9")))), m); + expr_ref conclusion(mk_RegexIn(S, re_positiveInteger), m); SASSERT(premise); SASSERT(conclusion); assert_implication(premise, conclusion); @@ -1814,12 +1857,25 @@ namespace smt { std::pair key1(ex->get_arg(0), regexStr); // skip Z3str's map check, because we already check if we set up axioms on this term regex_in_bool_map[key1] = ex; + if (!regex_in_var_reg_str_map.contains(ex->get_arg(0))) { + regex_in_var_reg_str_map.insert(ex->get_arg(0), std::set()); + } regex_in_var_reg_str_map[ex->get_arg(0)].insert(regexStr); } expr_ref str(ex->get_arg(0), m); app * regex = to_app(ex->get_arg(1)); + if (m_params.m_RegexAutomata) { + regex_terms.insert(ex); + if (!regex_terms_by_string.contains(str)) { + regex_terms_by_string.insert(str, ptr_vector()); + } + regex_terms_by_string[str].push_back(ex); + // stop setting up axioms here, we do this differently + return; + } + // quick reference for the following code: // - ex: top-level regex membership term // - str: string term appearing in ex @@ -1992,7 +2048,7 @@ namespace smt { check_contain_in_new_eq(lhs, rhs); } - if (!regex_in_bool_map.empty()) { + if (!regex_in_bool_map.empty() && !m_params.m_RegexAutomata) { TRACE("str", tout << "checking regex consistency" << std::endl;); check_regex_in(lhs, rhs); } @@ -6537,6 +6593,839 @@ namespace smt { } } + void theory_str::regex_inc_counter(obj_map & counter_map, expr * key) { + unsigned old_v; + if (counter_map.find(key, old_v)) { + unsigned new_v = old_v += 1; + counter_map.insert(key, new_v); + } else { + counter_map.insert(key, 1); + } + } + + unsigned theory_str::regex_get_counter(obj_map & counter_map, expr * key) { + unsigned v; + if (counter_map.find(key, v)) { + return v; + } else { + counter_map.insert(key, 0); + return 0; + } + } + + // saturating unsigned addition + unsigned inline _qadd(unsigned a, unsigned b) { + if (a == UINT_MAX || b == UINT_MAX) { + return UINT_MAX; + } + unsigned result = a + b; + if (result < a || result < b) { + return UINT_MAX; + } + return result; + } + + // saturating unsigned multiply + unsigned inline _qmul(unsigned a, unsigned b) { + if (a == UINT_MAX || b == UINT_MAX) { + return UINT_MAX; + } + if (a == 0 || b == 0) { + return 0; + } + unsigned result = a * b; + if (result < a || result < b) { + return UINT_MAX; + } + return result; + } + + unsigned theory_str::estimate_regex_complexity(expr * re) { + ENSURE(u.is_re(re)); + expr * sub1; + expr * sub2; + if (u.re.is_to_re(re, sub1)) { + SASSERT(u.str.is_string(sub1)); + zstring str; + u.str.is_string(sub1, str); + return str.length(); + } else if (u.re.is_complement(re, sub1)) { + return estimate_regex_complexity_under_complement(sub1); + } else if (u.re.is_concat(re, sub1, sub2)) { + unsigned cx1 = estimate_regex_complexity(sub1); + unsigned cx2 = estimate_regex_complexity(sub2); + return _qadd(cx1, cx2); + } else if (u.re.is_union(re, sub1, sub2)) { + unsigned cx1 = estimate_regex_complexity(sub1); + unsigned cx2 = estimate_regex_complexity(sub2); + return _qadd(cx1, cx2); + } else if (u.re.is_star(re, sub1) || u.re.is_plus(re, sub1)) { + unsigned cx = estimate_regex_complexity(sub1); + return _qmul(2, cx); + } else if (u.re.is_range(re, sub1, sub2)) { + SASSERT(u.str.is_string(sub1)); + SASSERT(u.str.is_string(sub2)); + zstring str1, str2; + u.str.is_string(sub1, str1); + u.str.is_string(sub2, str2); + SASSERT(str1.length() == 1); + SASSERT(str2.length() == 1); + return 1 + str2[0] - str1[0]; + } else if (u.re.is_full_char(re) || u.re.is_full_seq(re)) { + return 1; + } else { + TRACE("str", tout << "WARNING: unknown regex term " << mk_pp(re, get_manager()) << std::endl;); + return 1; + } + } + + unsigned theory_str::estimate_regex_complexity_under_complement(expr * re) { + ENSURE(u.is_re(re)); + expr * sub1; + expr * sub2; + if (u.re.is_to_re(re, sub1)) { + SASSERT(u.str.is_string(sub1)); + zstring str; + u.str.is_string(sub1, str); + return str.length(); + } else if (u.re.is_complement(re, sub1)) { + // Why don't we return the regular complexity here? + // We could, but this might be called from under another complemented subexpression. + // It's better to give a worst-case complexity. + return estimate_regex_complexity_under_complement(sub1); + } else if (u.re.is_concat(re, sub1, sub2)) { + unsigned cx1 = estimate_regex_complexity_under_complement(sub1); + unsigned cx2 = estimate_regex_complexity_under_complement(sub2); + return _qadd(_qmul(2, cx1), cx2); + } else if (u.re.is_union(re, sub1, sub2)) { + unsigned cx1 = estimate_regex_complexity_under_complement(sub1); + unsigned cx2 = estimate_regex_complexity_under_complement(sub2); + return _qmul(cx1, cx2); + } else if (u.re.is_star(re, sub1) || u.re.is_plus(re, sub1)) { + unsigned cx = estimate_regex_complexity_under_complement(sub1); + return _qmul(2, cx); + } else if (u.re.is_range(re, sub1, sub2)) { + SASSERT(u.str.is_string(sub1)); + SASSERT(u.str.is_string(sub2)); + zstring str1, str2; + u.str.is_string(sub1, str1); + u.str.is_string(sub2, str2); + SASSERT(str1.length() == 1); + SASSERT(str2.length() == 1); + return 1 + str2[0] - str1[0]; + } else if (u.re.is_full_char(re) || u.re.is_full_seq(re)) { + return 1; + } else { + TRACE("str", tout << "WARNING: unknown regex term " << mk_pp(re, get_manager()) << std::endl;); + return 1; + } + } + + unsigned theory_str::estimate_automata_intersection_difficulty(eautomaton * aut1, eautomaton * aut2) { + ENSURE(aut1 != NULL); + ENSURE(aut2 != NULL); + return _qmul(aut1->num_states(), aut2->num_states()); + } + + // Check whether a regex translates well to a linear set of length constraints. + bool theory_str::check_regex_length_linearity(expr * re) { + return check_regex_length_linearity_helper(re, false); + } + + bool theory_str::check_regex_length_linearity_helper(expr * re, bool already_star) { + expr * sub1; + expr * sub2; + if (u.re.is_to_re(re)) { + return true; + } else if (u.re.is_concat(re, sub1, sub2)) { + return check_regex_length_linearity_helper(sub1, already_star) && check_regex_length_linearity_helper(sub2, already_star); + } else if (u.re.is_union(re, sub1, sub2)) { + return check_regex_length_linearity_helper(sub1, already_star) && check_regex_length_linearity_helper(sub2, already_star); + } else if (u.re.is_star(re, sub1) || u.re.is_plus(re, sub1)) { + if (already_star) { + return false; + } else { + return check_regex_length_linearity_helper(sub1, true); + } + } else if (u.re.is_range(re)) { + return true; + } else if (u.re.is_full_char(re)) { + return true; + } else if (u.re.is_full_seq(re)) { + return true; + } else if (u.re.is_complement(re)) { + // TODO can we do better? + return false; + } else { + TRACE("str", tout << "WARNING: unknown regex term " << mk_pp(re, get_manager()) << std::endl;); + UNREACHABLE(); return false; + } + } + + // note: returns an empty set `lens` if something went wrong + void theory_str::check_subterm_lengths(expr * re, integer_set & lens) { + expr * sub1; + expr * sub2; + if (u.re.is_to_re(re, sub1)) { + SASSERT(u.str.is_string(sub1)); + zstring(str); + u.str.is_string(sub1, str); + lens.insert(str.length()); + } else if (u.re.is_concat(re, sub1, sub2)) { + integer_set lens_1, lens_2; + check_subterm_lengths(sub1, lens_1); + check_subterm_lengths(sub2, lens_2); + if (lens_1.empty() || lens_2.empty()) { + lens.reset(); + } else { + // take all pairwise lengths + for (integer_set::iterator it1 = lens_1.begin(); it1 != lens_1.end(); ++it1) { + for(integer_set::iterator it2 = lens_2.begin(); it2 != lens_2.end(); ++it2) { + int l1 = *it1; + int l2 = *it2; + lens.insert(l1 + l2); + } + } + } + } else if (u.re.is_union(re, sub1, sub2)) { + integer_set lens_1, lens_2; + check_subterm_lengths(sub1, lens_1); + check_subterm_lengths(sub2, lens_2); + if (lens_1.empty() || lens_2.empty()) { + lens.reset(); + } else { + // take all possibilities from either side + for (integer_set::iterator it1 = lens_1.begin(); it1 != lens_1.end(); ++it1) { + lens.insert(*it1); + } + for (integer_set::iterator it2 = lens_2.begin(); it2 != lens_2.end(); ++it2) { + lens.insert(*it2); + } + } + } else if (u.re.is_star(re, sub1) || u.re.is_plus(re, sub1)) { + // this is bad -- term generation requires this not to appear + lens.reset(); + } else if (u.re.is_range(re, sub1, sub2)) { + SASSERT(u.str.is_string(sub1)); + SASSERT(u.str.is_string(sub2)); + zstring str1, str2; + u.str.is_string(sub1, str1); + u.str.is_string(sub2, str2); + SASSERT(str1.length() == 1); + SASSERT(str2.length() == 1); + lens.insert(1); + } else if (u.re.is_full_char(re)) { + lens.insert(1); + } else if (u.re.is_full_seq(re)) { + lens.reset(); + } else if (u.re.is_complement(re)) { + lens.reset(); + } else { + TRACE("str", tout << "WARNING: unknown regex term " << mk_pp(re, get_manager()) << std::endl;); + lens.reset(); + } + } + + /* + * Infer all length constraints implied by the given regular expression `re` + * in order to constrain `lenVar` (which must be of sort Int). + * This assumes that `re` appears in a positive context. + * Returns a Boolean formula expressing the appropriate constraints over `lenVar`. + * In some cases, the returned formula requires one or more free integer variables to be created. + * These variables are returned in the reference parameter `freeVariables`. + * Extra assertions should be made for these free variables constraining them to be non-negative. + */ + expr_ref theory_str::infer_all_regex_lengths(expr * lenVar, expr * re, expr_ref_vector & freeVariables) { + ENSURE(u.is_re(re)); + context & ctx = get_context(); + ast_manager & m = get_manager(); + expr * sub1; + expr * sub2; + if (u.re.is_to_re(re, sub1)) { + SASSERT(u.str.is_string(sub1)); + zstring str; + u.str.is_string(sub1, str); + rational strlen(str.length()); + expr_ref retval(ctx.mk_eq_atom(lenVar, m_autil.mk_numeral(strlen, true)), m); + return retval; + } else if (u.re.is_union(re, sub1, sub2)) { + expr_ref r1 = infer_all_regex_lengths(lenVar, sub1, freeVariables); + expr_ref r2 = infer_all_regex_lengths(lenVar, sub2, freeVariables); + expr_ref retval(m.mk_or(r1, r2), m); + return retval; + } else if (u.re.is_concat(re, sub1, sub2)) { + expr * v1 = mk_int_var("rlen1"); + expr * v2 = mk_int_var("rlen2"); + freeVariables.push_back(v1); + freeVariables.push_back(v2); + expr_ref r1 = infer_all_regex_lengths(v1, sub1, freeVariables); + expr_ref r2 = infer_all_regex_lengths(v2, sub2, freeVariables); + expr_ref_vector finalResult(m); + finalResult.push_back(ctx.mk_eq_atom(lenVar, m_autil.mk_add(v1, v2))); + finalResult.push_back(r1); + finalResult.push_back(r2); + expr_ref retval(mk_and(finalResult), m); + return retval; + } else if (u.re.is_star(re, sub1) || u.re.is_plus(re, sub1)) { + // stars are generated as a linear combination of all possible subterm lengths; + // this requires that there are no stars under this one + /* + expr * v = mk_int_var("rlen"); + expr * n = mk_int_var("rstar"); + freeVariables.push_back(v); + freeVariables.push_back(n); + expr_ref rsub = infer_all_regex_lengths(v, sub1, freeVariables); + expr_ref_vector finalResult(m); + finalResult.push_back(rsub); + finalResult.push_back(ctx.mk_eq_atom(lenVar, m_autil.mk_mul(v, n))); + expr_ref retval(mk_and(finalResult), m); + return retval; + */ + integer_set subterm_lens; + check_subterm_lengths(sub1, subterm_lens); + if (subterm_lens.empty()) { + // somehow generation was impossible + expr_ref retval(m_autil.mk_ge(lenVar, m_autil.mk_numeral(rational::zero(), true)), m); + return retval; + } else { + TRACE("str", tout << "subterm lengths:"; + for(integer_set::iterator it = subterm_lens.begin(); it != subterm_lens.end(); ++it) { + tout << " " << *it; + } + tout << std::endl;); + expr_ref_vector sum_terms(m); + for (integer_set::iterator it = subterm_lens.begin(); it != subterm_lens.end(); ++it) { + rational lenOption(*it); + expr * n = mk_int_var("rstar"); + freeVariables.push_back(n); + expr_ref term(m_autil.mk_mul(m_autil.mk_numeral(lenOption, true), n), m); + expr_ref term2(term, m); + if (u.re.is_plus(re)) { + // n effectively starts at 1 + term2 = m_autil.mk_add(m_autil.mk_numeral(lenOption, true), term); + } + sum_terms.push_back(term2); + } + expr_ref retval(ctx.mk_eq_atom(lenVar, m_autil.mk_add_simplify(sum_terms)), m); + return retval; + } + } else if (u.re.is_range(re, sub1, sub2)) { + SASSERT(u.str.is_string(sub1)); + SASSERT(u.str.is_string(sub2)); + zstring str1, str2; + u.str.is_string(sub1, str1); + u.str.is_string(sub2, str2); + SASSERT(str1.length() == 1); + SASSERT(str2.length() == 1); + expr_ref retval(ctx.mk_eq_atom(lenVar, m_autil.mk_numeral(rational::one(), true)), m); + return retval; + } else if (u.re.is_full_char(re)) { + expr_ref retval(ctx.mk_eq_atom(lenVar, m_autil.mk_numeral(rational::one(), true)), m); + return retval; + } else if (u.re.is_full_seq(re)) { + // match any unbounded string + expr_ref retval(m_autil.mk_ge(lenVar, m_autil.mk_numeral(rational::zero(), true)), m); + return retval; + } else if (u.re.is_complement(re)) { + // skip complement for now, in general this is difficult to predict + expr_ref retval(m_autil.mk_ge(lenVar, m_autil.mk_numeral(rational::zero(), true)), m); + return retval; + } else { + TRACE("str", tout << "WARNING: unknown regex term " << mk_pp(re, m) << std::endl;); + expr_ref retval(m_autil.mk_ge(lenVar, m_autil.mk_numeral(rational::zero(), true)), m); + return retval; + } + } + + /* + * Assert initial lower and upper bounds for the positive constraint (str in re) corresponding + * to the automaton `aut`. + * This asserts a constraint of the form: + * str_in_re --> (len(str) ?= 0 OR len(str) >= lb) AND len(str) <= ub + * where the upper bound clause is omitted if the upper bound doesn't exist + * and the equality with 0 is based on whether solutions of length 0 are allowed. + */ + void theory_str::find_automaton_initial_bounds(expr * str_in_re, eautomaton * aut) { + ENSURE(aut != NULL); + context & ctx = get_context(); + ast_manager & m = get_manager(); + + expr_ref_vector rhs(m); + expr * str; + expr * re; + u.str.is_in_re(str_in_re, str, re); + expr_ref strlen(mk_strlen(str), m); + + // lower bound first + rational nonzero_lower_bound; + bool zero_sol_exists = refine_automaton_lower_bound(aut, rational::zero(), nonzero_lower_bound); + if (zero_sol_exists) { + regex_last_lower_bound.insert(str, rational::zero()); + // solution at 0 + if (!nonzero_lower_bound.is_minus_one()) { + expr_ref rhs1(ctx.mk_eq_atom(strlen, m_autil.mk_numeral(rational::zero(), true)), m); + expr_ref rhs2(m_autil.mk_ge(strlen, m_autil.mk_numeral(nonzero_lower_bound, true)), m); + rhs.push_back(m.mk_or(rhs1, rhs2)); + } else { + // shouldn't happen + UNREACHABLE(); + } + } else { + // no solution at 0 + if (!nonzero_lower_bound.is_minus_one()) { + regex_last_lower_bound.insert(str, nonzero_lower_bound); + expr_ref rhs2(m_autil.mk_ge(strlen, m_autil.mk_numeral(nonzero_lower_bound, true)), m); + rhs.push_back(rhs2); + } else { + // shouldn't happen + UNREACHABLE(); + } + } + // TODO upper bound check + + if (!rhs.empty()) { + expr_ref lhs(str_in_re, m); + expr_ref _rhs(mk_and(rhs), m); + assert_implication(lhs, _rhs); + } + } + + /* + * Refine the lower bound on the length of a solution to a given automaton. + * The method returns TRUE if a solution of length `current_lower_bound` exists, + * and FALSE otherwise. In addition, the reference parameter `refined_lower_bound` + * is assigned the length of the shortest solution longer than `current_lower_bound` + * if it exists, or -1 otherwise. + */ + bool theory_str::refine_automaton_lower_bound(eautomaton * aut, rational current_lower_bound, rational & refined_lower_bound) { + ENSURE(aut != NULL); + + if (aut->final_states().size() < 1) { + // no solutions at all + refined_lower_bound = rational::minus_one(); + return false; + } + + // from here we assume that there is a final state reachable from the initial state + + unsigned_vector search_queue; + // populate search_queue with all states reachable from the epsilon-closure of start state + aut->get_epsilon_closure(aut->init(), search_queue); + + unsigned search_depth = 0; + hashtable> next_states; + unsigned_vector next_search_queue; + + bool found_solution_at_lower_bound = false; + + while (!search_queue.empty()) { + // if we are at the lower bound, check for final states + if (search_depth == current_lower_bound.get_unsigned()) { + for (unsigned_vector::iterator it = search_queue.begin(); it != search_queue.end(); ++it) { + unsigned state = *it; + if (aut->is_final_state(state)) { + found_solution_at_lower_bound = true; + break; + } + } + // end phase 1 + break; + } + next_states.reset(); + next_search_queue.clear(); + // move one step along all states + for (unsigned_vector::iterator it = search_queue.begin(); it != search_queue.end(); ++it) { + unsigned src = *it; + eautomaton::moves next_moves; + aut->get_moves_from(src, next_moves, true); + for (eautomaton::moves::iterator move_it = next_moves.begin(); + move_it != next_moves.end(); ++move_it) { + unsigned dst = move_it->dst(); + if (!next_states.contains(dst)) { + next_states.insert(dst); + next_search_queue.push_back(dst); + } + } + } + search_queue.clear(); + search_queue.append(next_search_queue); + search_depth += 1; + } // !search_queue.empty() + + // if we got here before reaching the lower bound, + // there aren't any solutions at or above it, so stop + if (search_depth < current_lower_bound.get_unsigned()) { + refined_lower_bound = rational::minus_one(); + return false; + } + + // phase 2: continue exploring the automaton above the lower bound + SASSERT(search_depth == current_lower_bound.get_unsigned()); + + while (!search_queue.empty()) { + if (search_depth > current_lower_bound.get_unsigned()) { + // check if we have found a solution above the lower bound + for (unsigned_vector::iterator it = search_queue.begin(); it != search_queue.end(); ++it) { + unsigned state = *it; + if (aut->is_final_state(state)) { + // this is a solution at a depth higher than the lower bound + refined_lower_bound = rational(search_depth); + return found_solution_at_lower_bound; + } + } + } + next_states.reset(); + next_search_queue.clear(); + // move one step along all states + for (unsigned_vector::iterator it = search_queue.begin(); it != search_queue.end(); ++it) { + unsigned src = *it; + eautomaton::moves next_moves; + aut->get_moves_from(src, next_moves, true); + for (eautomaton::moves::iterator move_it = next_moves.begin(); + move_it != next_moves.end(); ++move_it) { + unsigned dst = move_it->dst(); + if (!next_states.contains(dst)) { + next_states.insert(dst); + next_search_queue.push_back(dst); + } + } + } + search_queue.clear(); + search_queue.append(next_search_queue); + search_depth += 1; + } + // if we reached this point, we explored the whole automaton and didn't find any + // solutions above the lower bound + refined_lower_bound = rational::minus_one(); + return found_solution_at_lower_bound; + } + + /* + * Refine the upper bound on the length of a solution to a given automaton. + * The method returns TRUE if a solution of length `current_upper_bound` exists, + * and FALSE otherwise. In addition, the reference parameter `refined_upper_bound` + * is assigned the length of the longest solution shorter than `current_upper_bound`, + * if a shorter solution exists, or -1 otherwise. + */ + bool theory_str::refine_automaton_upper_bound(eautomaton * aut, rational current_upper_bound, rational & refined_upper_bound) { + ENSURE(aut != NULL); + + if (aut->final_states().empty()) { + // no solutions at all! + refined_upper_bound = rational::minus_one(); + return false; + } + + // from here we assume there is a final state reachable from the initial state + unsigned_vector search_queue; + // populate search queue with all states reachable from the epsilon-closure of the start state + aut->get_epsilon_closure(aut->init(), search_queue); + + rational last_solution_depth = rational::minus_one(); + bool found_solution_at_upper_bound = false; + + unsigned search_depth = 0; + hashtable > next_states; + unsigned_vector next_search_queue; + + while(!search_queue.empty()) { + // see if any of the current states are final + for (unsigned_vector::iterator it = search_queue.begin(); it != search_queue.end(); ++it) { + unsigned src = *it; + if (aut->is_final_state(src)) { + if (search_depth == current_upper_bound.get_unsigned()) { + found_solution_at_upper_bound = true; + } else { + last_solution_depth = rational(search_depth); + } + break; + } + } + + if (search_depth == current_upper_bound.get_unsigned()) { + break; + } + + next_states.reset(); + next_search_queue.clear(); + // move one step along all states + for (unsigned_vector::iterator it = search_queue.begin(); it != search_queue.end(); ++it) { + unsigned src = *it; + eautomaton::moves next_moves; + aut->get_moves_from(src, next_moves, true); + for (eautomaton::moves::iterator moves_it = next_moves.begin(); + moves_it != next_moves.end(); ++moves_it) { + unsigned dst = moves_it->dst(); + if (!next_states.contains(dst)) { + next_states.insert(dst); + next_search_queue.push_back(dst); + } + } + } + search_queue.clear(); + search_queue.append(next_search_queue); + search_depth += 1; + } //!search_queue.empty() + + refined_upper_bound = last_solution_depth; + return found_solution_at_upper_bound; + } + + void theory_str::aut_path_add_next(u_map& next, expr_ref_vector& trail, unsigned idx, expr* cond) { + expr* acc; + if (!get_manager().is_true(cond) && next.find(idx, acc)) { + expr* args[2] = { cond, acc }; + cond = mk_or(get_manager(), 2, args); + } + trail.push_back(cond); + next.insert(idx, cond); + } + + expr_ref theory_str::aut_path_rewrite_constraint(expr * cond, expr * ch_var) { + context & ctx = get_context(); + ast_manager & m = get_manager(); + bv_util bvu(m); + + expr_ref retval(m); + + rational char_val; + unsigned int bv_width; + + expr * lhs; + expr * rhs; + + if (bvu.is_numeral(cond, char_val, bv_width)) { + SASSERT(char_val.is_nonneg() && char_val.get_unsigned() < 256); + TRACE("str", tout << "rewrite character constant " << char_val << std::endl;); + zstring str_const(char_val.get_unsigned()); + retval = u.str.mk_string(str_const); + return retval; + } else if (is_var(cond)) { + TRACE("str", tout << "substitute var" << std::endl;); + retval = ch_var; + return retval; + } else if (m.is_eq(cond, lhs, rhs)) { + // handle this specially because the sort of the equality will change + expr_ref new_lhs(aut_path_rewrite_constraint(lhs, ch_var), m); + SASSERT(new_lhs); + expr_ref new_rhs(aut_path_rewrite_constraint(rhs, ch_var), m); + SASSERT(new_rhs); + retval = ctx.mk_eq_atom(new_lhs, new_rhs); + return retval; + } else if (m.is_bool(cond)) { + TRACE("str", tout << "rewrite boolean term " << mk_pp(cond, m) << std::endl;); + app * a_cond = to_app(cond); + expr_ref_vector rewritten_args(m); + for (unsigned i = 0; i < a_cond->get_num_args(); ++i) { + expr * argI = a_cond->get_arg(i); + expr_ref new_arg(aut_path_rewrite_constraint(argI, ch_var), m); + SASSERT(new_arg); + rewritten_args.push_back(new_arg); + } + retval = m.mk_app(a_cond->get_decl(), rewritten_args.c_ptr()); + TRACE("str", tout << "final rewritten term is " << mk_pp(retval, m) << std::endl;); + return retval; + } else { + TRACE("str", tout << "ERROR: unrecognized automaton path constraint " << mk_pp(cond, m) << ", cannot translate" << std::endl;); + retval = NULL; + return retval; + } + } + + /* + * Create finite path constraints for the string variable `str` with respect to the automaton `aut`. + * The returned expression is the right-hand side of a constraint of the form + * (str in re) AND (|str| = len) AND (any applicable length assumptions on aut) -> (rhs AND character constraints). + * The character constraints, which are (str = c0 . c1 . (...) . cn) and (|c0| = 1, ...), + * are returned in `characterConstraints`. + */ + expr_ref theory_str::generate_regex_path_constraints(expr * stringTerm, eautomaton * aut, rational lenVal, expr_ref & characterConstraints) { + ENSURE(aut != NULL); + context & ctx = get_context(); + ast_manager & m = get_manager(); + + if (lenVal.is_zero()) { + // if any state in the epsilon-closure of the start state is accepting, + // then the empty string is in this language + unsigned_vector states; + bool has_final = false; + aut->get_epsilon_closure(aut->init(), states); + for (unsigned i = 0; i < states.size() && !has_final; ++i) { + has_final = aut->is_final_state(states[i]); + } + if (has_final) { + // empty string is OK, assert axiom + expr_ref rhs(ctx.mk_eq_atom(stringTerm, mk_string("")), m); + SASSERT(rhs); + //regex_automata_assertions.insert(stringTerm, final_axiom); + //m_trail_stack.push(insert_obj_map(regex_automata_assertions, stringTerm) ); + return rhs; + } else { + // negate -- the empty string isn't in the language + //expr_ref conflict(m.mk_not(mk_and(toplevel_lhs)), m); + //assert_axiom(conflict); + expr_ref conflict(m.mk_false(), m); + return conflict; + } + } // lenVal.is_zero() + + expr_ref_vector pathChars(m); + expr_ref_vector pathChars_len_constraints(m); + + // reuse character terms over the same string + if (string_chars.contains(stringTerm)) { + // find out whether we have enough characters already + ptr_vector old_chars; + string_chars.find(stringTerm, old_chars); + if (old_chars.size() < lenVal.get_unsigned()) { + for (unsigned i = old_chars.size(); i < lenVal.get_unsigned(); ++i) { + std::stringstream ss; + ss << "ch" << i; + expr_ref ch(mk_str_var(ss.str()), m); + m_trail.push_back(ch); + old_chars.push_back(ch); + } + } + string_chars.insert(stringTerm, old_chars); + // now we're guaranteed to have at least the right number of characters in old_chars + for (unsigned i = 0; i < lenVal.get_unsigned(); ++i) { + expr_ref ch(old_chars.get(i), m); + refresh_theory_var(ch); + pathChars.push_back(ch); + pathChars_len_constraints.push_back(ctx.mk_eq_atom(mk_strlen(ch), m_autil.mk_numeral(rational::one(), true))); + } + } else { + ptr_vector new_chars; + for (unsigned i = 0; i < lenVal.get_unsigned(); ++i) { + std::stringstream ss; + ss << "ch" << i; + expr_ref ch(mk_str_var(ss.str()), m); + pathChars.push_back(ch); + pathChars_len_constraints.push_back(ctx.mk_eq_atom(mk_strlen(ch), m_autil.mk_numeral(rational::one(), true))); + new_chars.push_back(ch); + } + string_chars.insert(stringTerm, new_chars); + } + + // modification of code in seq_rewriter::mk_str_in_regexp() + expr_ref_vector trail(m); + u_map maps[2]; + bool select_map = false; + expr_ref ch(m), cond(m); + eautomaton::moves mvs; + maps[0].insert(aut->init(), m.mk_true()); + // is_accepted(a, aut) & some state in frontier is final. + for (unsigned i = 0; i < lenVal.get_unsigned(); ++i) { + u_map& frontier = maps[select_map]; + u_map& next = maps[!select_map]; + select_map = !select_map; + ch = pathChars.get(i); + next.reset(); + u_map::iterator it = frontier.begin(), end = frontier.end(); + for (; it != end; ++it) { + mvs.reset(); + unsigned state = it->m_key; + expr* acc = it->m_value; + aut->get_moves_from(state, mvs, false); + for (unsigned j = 0; j < mvs.size(); ++j) { + eautomaton::move const& mv = mvs[j]; + SASSERT(mv.t()); + if (mv.t()->is_char() && m.is_value(mv.t()->get_char())) { + // change this to a string constraint + expr_ref cond_rhs = aut_path_rewrite_constraint(mv.t()->get_char(), ch); + SASSERT(cond_rhs); + cond = ctx.mk_eq_atom(ch, cond_rhs); + SASSERT(cond); + expr * args[2] = {cond, acc}; + cond = mk_and(m, 2, args); + aut_path_add_next(next, trail, mv.dst(), cond); + } else if (mv.t()->is_range()) { + expr_ref range_lo(mv.t()->get_lo(), m); + expr_ref range_hi(mv.t()->get_hi(), m); + bv_util bvu(m); + + rational lo_val, hi_val; + unsigned int bv_width; + + if (bvu.is_numeral(range_lo, lo_val, bv_width) && bvu.is_numeral(range_hi, hi_val, bv_width)) { + TRACE("str", tout << "make range predicate from " << lo_val << " to " << hi_val << std::endl;); + expr_ref cond_rhs(m); + + if (hi_val < lo_val) { + rational tmp = lo_val; + lo_val = hi_val; + hi_val = tmp; + } + + expr_ref_vector cond_rhs_terms(m); + for (unsigned i = lo_val.get_unsigned(); i <= hi_val.get_unsigned(); ++i) { + zstring str_const(i); + expr_ref str_expr(u.str.mk_string(str_const), m); + cond_rhs_terms.push_back(ctx.mk_eq_atom(ch, str_expr)); + } + cond_rhs = mk_or(cond_rhs_terms); + SASSERT(cond_rhs); + expr * args[2] = {cond_rhs, acc}; + cond = mk_and(m, 2, args); + aut_path_add_next(next, trail, mv.dst(), cond); + } else { + TRACE("str", tout << "warning: non-bitvectors in automaton range predicate" << std::endl;); + UNREACHABLE(); + } + } else if (mv.t()->is_pred()) { + // rewrite this constraint over string terms + expr_ref cond_rhs = aut_path_rewrite_constraint(mv.t()->get_pred(), ch); + SASSERT(cond_rhs); + + if (m.is_false(cond_rhs)) { + continue; + } else if (m.is_true(cond_rhs)) { + aut_path_add_next(next, trail, mv.dst(), acc); + continue; + } + expr * args[2] = {cond_rhs, acc}; + cond = mk_and(m, 2, args); + aut_path_add_next(next, trail, mv.dst(), cond); + } + } + } + } + u_map const& frontier = maps[select_map]; + u_map::iterator it = frontier.begin(), end = frontier.end(); + expr_ref_vector ors(m); + for (; it != end; ++it) { + unsigned_vector states; + bool has_final = false; + aut->get_epsilon_closure(it->m_key, states); + for (unsigned i = 0; i < states.size() && !has_final; ++i) { + has_final = aut->is_final_state(states[i]); + } + if (has_final) { + ors.push_back(it->m_value); + } + } + expr_ref result(mk_or(ors)); + TRACE("str", tout << "regex path constraint: " << mk_pp(result, m) << "\n";); + + expr_ref concat_rhs(m); + if (pathChars.size() == 1) { + concat_rhs = ctx.mk_eq_atom(stringTerm, pathChars.get(0)); + } else { + expr_ref acc(pathChars.get(0), m); + for (unsigned i = 1; i < pathChars.size(); ++i) { + acc = mk_concat(acc, pathChars.get(i)); + } + concat_rhs = ctx.mk_eq_atom(stringTerm, acc); + } + + //expr_ref toplevel_rhs(m.mk_and(result, mk_and(pathChars_len_constraints), concat_rhs), m); + characterConstraints = m.mk_and(mk_and(pathChars_len_constraints), concat_rhs); + //expr_ref final_axiom(rewrite_implication(mk_and(toplevel_lhs), toplevel_rhs), m); + //regex_automata_assertions.insert(stringTerm, final_axiom); + //m_trail_stack.push(insert_obj_map(regex_automata_assertions, stringTerm) ); + return result; + } + /* * strArgmt::solve_concat_eq_str() * Solve concatenations of the form: @@ -7207,7 +8096,7 @@ namespace smt { rational nn1Len, nn2Len; bool nn1Len_exists = get_len_value(lhs, nn1Len); bool nn2Len_exists = get_len_value(rhs, nn2Len); - expr * emptyStr = mk_string(""); + expr_ref emptyStr(mk_string(""), m); if (nn1Len_exists && nn1Len.is_zero()) { if (!in_same_eqc(lhs, emptyStr) && rhs != emptyStr) { @@ -7635,6 +8524,10 @@ namespace smt { } } + void theory_str::add_persisted_axiom(expr * a) { + m_persisted_axioms.push_back(a); + } + void theory_str::pop_scope_eh(unsigned num_scopes) { sLevel -= num_scopes; TRACE("str", tout << "pop " << num_scopes << " to " << sLevel << std::endl;); @@ -7680,6 +8573,11 @@ namespace smt { m_basicstr_axiom_todo.reset(); m_basicstr_axiom_todo = new_m_basicstr; + for (expr * e : m_persisted_axioms) { + TRACE("str", tout << "persist axiom: " << mk_pp(e, get_manager()) << std::endl;); + m_persisted_axiom_todo.push_back(e); + } + m_trail_stack.pop_scope(num_scopes); theory::pop_scope_eh(num_scopes); @@ -7700,6 +8598,27 @@ namespace smt { ); } + // returns true if needle appears as a subterm anywhere under haystack, + // or if needle appears in the same EQC as a subterm anywhere under haystack + bool theory_str::term_appears_as_subterm(expr * needle, expr * haystack) { + if (in_same_eqc(needle, haystack)) { + return true; + } + + if (is_app(haystack)) { + app * a_haystack = to_app(haystack); + for (unsigned i = 0; i < a_haystack->get_num_args(); ++i) { + expr * subterm = a_haystack->get_arg(i); + if (term_appears_as_subterm(needle, subterm)) { + return true; + } + } + } + + // not found + return false; + } + void theory_str::classify_ast_by_type(expr * node, std::map & varMap, std::map & concatMap, std::map & unrollMap) { @@ -8577,7 +9496,7 @@ namespace smt { bool Ival_exists = get_arith_value(a, Ival); if (Ival_exists) { TRACE("str", tout << "integer theory assigns " << mk_pp(a, m) << " = " << Ival.to_string() << std::endl;); - // if that value is not -1, we can assert (str.to-int S) = Ival --> S = "Ival" + // if that value is not -1, we can assert (str.to.int S) = Ival --> S = "Ival" if (!Ival.is_minus_one()) { zstring Ival_str(Ival.to_string().c_str()); expr_ref premise(ctx.mk_eq_atom(a, m_autil.mk_numeral(Ival, true)), m); @@ -8599,6 +9518,54 @@ namespace smt { // NOT_IMPLEMENTED_YET(); } + bool S_hasEqcValue; + expr * S_str = get_eqc_value(S, S_hasEqcValue); + if (S_hasEqcValue) { + zstring str; + u.str.is_string(S_str, str); + bool valid = true; + rational convertedRepresentation(0); + rational ten(10); + if (str.length() == 0) { + valid = false; + } else { + for (unsigned i = 0; i < str.length(); ++i) { + if (!('0' <= str[i] && str[i] <= '9')) { + valid = false; + break; + } else { + // accumulate + char digit = (int)str[i]; + std::string sDigit(1, digit); + int val = atoi(sDigit.c_str()); + convertedRepresentation = (ten * convertedRepresentation) + rational(val); + } + } + } + // TODO this duplicates code a bit, we can simplify the branch on "conclusion" only + if (valid) { + expr_ref premise(ctx.mk_eq_atom(S, mk_string(str)), m); + expr_ref conclusion(ctx.mk_eq_atom(a, m_autil.mk_numeral(convertedRepresentation, true)), m); + expr_ref axiom(rewrite_implication(premise, conclusion), m); + if (!string_int_axioms.contains(axiom)) { + string_int_axioms.insert(axiom); + assert_axiom(axiom); + m_trail_stack.push(insert_obj_trail(string_int_axioms, axiom)); + axiomAdd = true; + } + } else { + expr_ref premise(ctx.mk_eq_atom(S, mk_string(str)), m); + expr_ref conclusion(ctx.mk_eq_atom(a, m_autil.mk_numeral(rational::minus_one(), true)), m); + expr_ref axiom(rewrite_implication(premise, conclusion), m); + if (!string_int_axioms.contains(axiom)) { + string_int_axioms.insert(axiom); + assert_axiom(axiom); + m_trail_stack.push(insert_obj_trail(string_int_axioms, axiom)); + axiomAdd = true; + } + } + } + return axiomAdd; } @@ -8956,6 +9923,730 @@ namespace smt { } } + // regex automata + if (m_params.m_RegexAutomata) { + // TODO since heuristics might fail, the "no progress" flag might need to be handled specially here + bool regex_axiom_add = false; + for (obj_hashtable::iterator it = regex_terms.begin(); it != regex_terms.end(); ++it) { + expr * str_in_re = *it; + expr * str; + expr * re; + u.str.is_in_re(str_in_re, str, re); + lbool current_assignment = ctx.get_assignment(str_in_re); + TRACE("str", tout << "regex term: " << mk_pp(str, m) << " in " << mk_pp(re, m) << " : " << current_assignment << std::endl;); + if (current_assignment == l_undef) { + continue; + } + + if (!regex_terms_with_length_constraints.contains(str_in_re)) { + if (current_assignment == l_true && check_regex_length_linearity(re)) { + TRACE("str", tout << "regex length constraints expected to be linear -- generating and asserting them" << std::endl;); + + if (regex_term_to_length_constraint.contains(str_in_re)) { + // use existing length constraint + expr * top_level_length_constraint; + regex_term_to_length_constraint.find(str_in_re, top_level_length_constraint); + + ptr_vector extra_length_vars; + regex_term_to_extra_length_vars.find(str_in_re, extra_length_vars); + + assert_axiom(top_level_length_constraint); + for(ptr_vector::iterator it = extra_length_vars.begin(); it != extra_length_vars.end(); ++it) { + expr * v = *it; + refresh_theory_var(v); + expr_ref len_constraint(m_autil.mk_ge(v, m_autil.mk_numeral(rational::zero(), true)), m); + assert_axiom(len_constraint); + } + } else { + // generate new length constraint + expr_ref_vector extra_length_vars(m); + expr_ref _top_level_length_constraint = infer_all_regex_lengths(mk_strlen(str), re, extra_length_vars); + expr_ref top_level_length_constraint(_top_level_length_constraint, m); + th_rewriter rw(m); + rw(top_level_length_constraint); + TRACE("str", tout << "top-level length constraint: " << mk_pp(top_level_length_constraint, m) << std::endl;); + // assert and track length constraint + assert_axiom(top_level_length_constraint); + for(expr_ref_vector::iterator it = extra_length_vars.begin(); it != extra_length_vars.end(); ++it) { + expr * v = *it; + expr_ref len_constraint(m_autil.mk_ge(v, m_autil.mk_numeral(rational::zero(), true)), m); + assert_axiom(len_constraint); + } + + regex_term_to_length_constraint.insert(str_in_re, top_level_length_constraint); + ptr_vector vtmp; + for(expr_ref_vector::iterator it = extra_length_vars.begin(); it != extra_length_vars.end(); ++it) { + vtmp.push_back(*it); + } + regex_term_to_extra_length_vars.insert(str_in_re, vtmp); + } + + regex_terms_with_length_constraints.insert(str_in_re); + m_trail_stack.push(insert_obj_trail(regex_terms_with_length_constraints, str_in_re)); + regex_axiom_add = true; + } + } // re not in regex_terms_with_length_constraints + + rational exact_length_value; + if (get_len_value(str, exact_length_value)) { + TRACE("str", tout << "exact length of " << mk_pp(str, m) << " is " << exact_length_value << std::endl;); + + if (regex_terms_with_path_constraints.contains(str_in_re)) { + TRACE("str", tout << "term " << mk_pp(str_in_re, m) << " already has path constraints set up" << std::endl;); + continue; + } + + // find a consistent automaton for this term + bool found = false; + regex_automaton_under_assumptions assumption; + if (regex_automaton_assumptions.contains(re) && + !regex_automaton_assumptions[re].empty()){ + for (svector::iterator it = regex_automaton_assumptions[re].begin(); + it != regex_automaton_assumptions[re].end(); ++it) { + regex_automaton_under_assumptions autA = *it; + rational assumed_upper_bound, assumed_lower_bound; + bool assumes_upper_bound = autA.get_upper_bound(assumed_upper_bound); + bool assumes_lower_bound = autA.get_lower_bound(assumed_lower_bound); + if (!assumes_upper_bound && !assumes_lower_bound) { + // automaton with no assumptions is always usable + assumption = autA; + found = true; + break; + } + // TODO check consistency of bounds assumptions + } // foreach(a in regex_automaton_assumptions) + } + if (found) { + if (exact_length_value.is_zero()) { + // check consistency of 0-length solution with automaton + eautomaton * aut = assumption.get_automaton(); + bool zero_solution = false; + unsigned initial_state = aut->init(); + if (aut->is_final_state(initial_state)) { + zero_solution = true; + } else { + unsigned_vector eps_states; + aut->get_epsilon_closure(initial_state, eps_states); + for (unsigned_vector::iterator it = eps_states.begin(); it != eps_states.end(); ++it) { + unsigned state = *it; + if (aut->is_final_state(state)) { + zero_solution = true; + break; + } + } + } + + // now check polarity of automaton wrt. original term + if ( (current_assignment == l_true && !assumption.get_polarity()) + || (current_assignment == l_false && assumption.get_polarity())) { + // invert sense + zero_solution = !zero_solution; + } + + if (zero_solution) { + TRACE("str", tout << "zero-length solution OK -- asserting empty path constraint" << std::endl;); + expr_ref_vector lhs_terms(m); + if (current_assignment == l_true) { + lhs_terms.push_back(str_in_re); + } else { + lhs_terms.push_back(m.mk_not(str_in_re)); + } + lhs_terms.push_back(ctx.mk_eq_atom(mk_strlen(str), m_autil.mk_numeral(exact_length_value, true))); + expr_ref lhs(mk_and(lhs_terms), m); + expr_ref rhs(ctx.mk_eq_atom(str, mk_string("")), m); + assert_implication(lhs, rhs); + regex_terms_with_path_constraints.insert(str_in_re); + m_trail_stack.push(insert_obj_trail(regex_terms_with_path_constraints, str_in_re)); + } else { + TRACE("str", tout << "zero-length solution not admitted by this automaton -- asserting conflict clause" << std::endl;); + expr_ref_vector lhs_terms(m); + if (current_assignment == l_true) { + lhs_terms.push_back(str_in_re); + } else { + lhs_terms.push_back(m.mk_not(str_in_re)); + } + lhs_terms.push_back(ctx.mk_eq_atom(mk_strlen(str), m_autil.mk_numeral(exact_length_value, true))); + expr_ref lhs(mk_and(lhs_terms), m); + expr_ref conflict(m.mk_not(lhs), m); + assert_axiom(conflict); + } + regex_axiom_add = true; + regex_inc_counter(regex_length_attempt_count, re); + continue; + } else { + expr_ref pathConstraint(m); + expr_ref characterConstraints(m); + pathConstraint = generate_regex_path_constraints(str, assumption.get_automaton(), exact_length_value, characterConstraints); + TRACE("str", tout << "generated regex path constraint " << mk_pp(pathConstraint, m) << std::endl;); + TRACE("str", tout << "character constraints are " << mk_pp(characterConstraints, m) << std::endl;); + + expr_ref_vector lhs_terms(m); + if (current_assignment == l_true) { + lhs_terms.push_back(str_in_re); + } else { + lhs_terms.push_back(m.mk_not(str_in_re)); + } + lhs_terms.push_back(ctx.mk_eq_atom(mk_strlen(str), m_autil.mk_numeral(exact_length_value, true))); + expr_ref lhs(mk_and(lhs_terms), m); + + // If the path constraint comes out as "false", this means there are no paths of that length + // in the automaton. If the polarity is the same, we can assert a conflict clause. + // If the polarity is opposite, we ignore the path constraint. + + if (m.is_false(pathConstraint)) { + if ( (current_assignment == l_true && assumption.get_polarity()) + || (current_assignment == l_false && !assumption.get_polarity())) { + // automaton and constraint have same polarity -- assert conflict clause + TRACE("str", tout << "path constraint is false with matching polarity; asserting conflict clause" << std::endl;); + expr_ref conflict(m.mk_not(mk_and(lhs_terms)), m); + assert_axiom(conflict); + // don't set up "regex_terms_with_path_constraints" as a conflict clause is not a path constraint + } else { + // automaton and constraint have opposite polarity -- ignore path constraint + TRACE("str", tout << "path constraint is false with opposite polarity; ignoring path constraint" << std::endl;); + assert_implication(lhs, characterConstraints); + regex_terms_with_path_constraints.insert(str_in_re); + m_trail_stack.push(insert_obj_trail(regex_terms_with_path_constraints, str_in_re)); + } + regex_axiom_add = true; + } else { + // If the automaton was built with the same polarity as the constraint, + // assert directly. Otherwise, negate the path constraint + if ( (current_assignment == l_true && assumption.get_polarity()) + || (current_assignment == l_false && !assumption.get_polarity())) { + TRACE("str", tout << "automaton and regex term have same polarity" << std::endl;); + expr_ref rhs(m.mk_and(pathConstraint, characterConstraints), m); + assert_implication(lhs, rhs); + } else { + TRACE("str", tout << "automaton and regex term have opposite polarity" << std::endl;); + expr_ref rhs(m.mk_and(m.mk_not(pathConstraint), characterConstraints), m); + assert_implication(lhs, rhs); + } + regex_terms_with_path_constraints.insert(str_in_re); + m_trail_stack.push(insert_obj_trail(regex_terms_with_path_constraints, str_in_re)); + regex_axiom_add = true; + } + + // increment LengthAttemptCount + regex_inc_counter(regex_length_attempt_count, re); + + TRACE("str", + { + unsigned v = regex_get_counter(regex_length_attempt_count, re); + tout << "length attempt count for " << mk_pp(re, m) << " is " << v << std::endl; + }); + + continue; + } + } else { + // no automata available, or else all bounds assumptions are invalid + unsigned expected_complexity = estimate_regex_complexity(re); + if (expected_complexity <= m_params.m_RegexAutomata_DifficultyThreshold || regex_get_counter(regex_fail_count, str_in_re) >= m_params.m_RegexAutomata_FailedAutomatonThreshold) { + CTRACE("str", regex_get_counter(regex_fail_count, str_in_re) >= m_params.m_RegexAutomata_FailedAutomatonThreshold, + tout << "failed automaton threshold reached for " << mk_pp(str_in_re, m) << " -- automatically constructing full automaton" << std::endl;); + eautomaton * aut = m_mk_aut(re); + aut->compress(); + regex_automata.push_back(aut); + regex_automaton_under_assumptions new_aut(re, aut, true); + if (!regex_automaton_assumptions.contains(re)) { + regex_automaton_assumptions.insert(re, svector()); + } + regex_automaton_assumptions[re].push_back(new_aut); + TRACE("str", tout << "add new automaton for " << mk_pp(re, m) << ": no assumptions" << std::endl;); + regex_axiom_add = true; + find_automaton_initial_bounds(str_in_re, aut); + } else { + regex_inc_counter(regex_fail_count, str_in_re); + } + continue; + } + } // get_len_value() + expr_ref str_len(mk_strlen(str), m); + rational lower_bound_value; + rational upper_bound_value; + bool lower_bound_exists = lower_bound(str_len, lower_bound_value); + bool upper_bound_exists = upper_bound(str_len, upper_bound_value); + CTRACE("str", lower_bound_exists, tout << "lower bound of " << mk_pp(str, m) << " is " << lower_bound_value << std::endl;); + CTRACE("str", upper_bound_exists, tout << "upper bound of " << mk_pp(str, m) << " is " << upper_bound_value << std::endl;); + + bool new_lower_bound_info = true; + bool new_upper_bound_info = true; + // check last seen lower/upper bound to avoid performing duplicate work + if (regex_last_lower_bound.contains(str)) { + rational last_lb_value; + regex_last_lower_bound.find(str, last_lb_value); + if (last_lb_value == lower_bound_value) { + new_lower_bound_info = false; + } + } + if (regex_last_upper_bound.contains(str)) { + rational last_ub_value; + regex_last_upper_bound.find(str, last_ub_value); + if (last_ub_value == upper_bound_value) { + new_upper_bound_info = false; + } + } + + if (new_lower_bound_info) { + regex_last_lower_bound.insert(str, lower_bound_value); + } + if (new_upper_bound_info) { + regex_last_upper_bound.insert(str, upper_bound_value); + } + + if (upper_bound_exists && new_upper_bound_info) { + // check current assumptions + if (regex_automaton_assumptions.contains(re) && + !regex_automaton_assumptions[re].empty()){ + // one or more existing assumptions. + // see if the (current best) upper bound can be refined + // (note that if we have an automaton with no assumption, + // this automatically counts as best) + bool need_assumption = true; + regex_automaton_under_assumptions last_assumption; + rational last_ub = rational::minus_one(); + for (svector::iterator it = regex_automaton_assumptions[re].begin(); + it != regex_automaton_assumptions[re].end(); ++it) { + regex_automaton_under_assumptions autA = *it; + if ((current_assignment == l_true && autA.get_polarity() == false) + || (current_assignment == l_false && autA.get_polarity() == true)) { + // automaton uses incorrect polarity + continue; + } + rational this_ub; + if (autA.get_upper_bound(this_ub)) { + if (last_ub == rational::minus_one() || this_ub < last_ub) { + last_ub = this_ub; + last_assumption = autA; + } + } else { + need_assumption = false; + last_assumption = autA; + break; + } + } + if (!last_ub.is_minus_one() || !need_assumption) { + CTRACE("str", !need_assumption, tout << "using automaton with full length information" << std::endl;); + CTRACE("str", need_assumption, tout << "using automaton with assumed upper bound of " << last_ub << std::endl;); + + rational refined_upper_bound; + bool solution_at_upper_bound = refine_automaton_upper_bound(last_assumption.get_automaton(), + upper_bound_value, refined_upper_bound); + TRACE("str", tout << "refined upper bound is " << refined_upper_bound << + (solution_at_upper_bound?", solution at upper bound":", no solution at upper bound") << std::endl;); + + expr_ref_vector lhs(m); + if (current_assignment == l_false) { + lhs.push_back(m.mk_not(str_in_re)); + } else { + lhs.push_back(str_in_re); + } + if (need_assumption) { + lhs.push_back(m_autil.mk_le(str_len, m_autil.mk_numeral(last_ub, true))); + } + lhs.push_back(m_autil.mk_le(str_len, m_autil.mk_numeral(upper_bound_value, true))); + + expr_ref_vector rhs(m); + + if (solution_at_upper_bound) { + if (refined_upper_bound.is_minus_one()) { + // If there are solutions at the upper bound but not below it, make the bound exact. + rhs.push_back(ctx.mk_eq_atom(str_len, m_autil.mk_numeral(upper_bound_value, true))); + } else { + // If there are solutions at and below the upper bound, add an additional bound. + rhs.push_back(m.mk_or( + ctx.mk_eq_atom(str_len, m_autil.mk_numeral(upper_bound_value, true)), + m_autil.mk_le(str_len, m_autil.mk_numeral(refined_upper_bound, true)) + )); + } + } else { + if (refined_upper_bound.is_minus_one()) { + // If there are no solutions at or below the upper bound, assert a conflict clause. + rhs.push_back(m.mk_not(m_autil.mk_le(str_len, m_autil.mk_numeral(upper_bound_value, true)))); + } else { + // If there are solutions below the upper bound but not at it, refine the bound. + rhs.push_back(m_autil.mk_le(str_len, m_autil.mk_numeral(refined_upper_bound, true))); + } + } + + if (!rhs.empty()) { + expr_ref lhs_terms(mk_and(lhs), m); + expr_ref rhs_terms(mk_and(rhs), m); + assert_implication(lhs_terms, rhs_terms); + regex_axiom_add = true; + } + } + } else { + // no existing automata/assumptions. + // if it's easy to construct a full automaton for R, do so + unsigned expected_complexity = estimate_regex_complexity(re); + bool failureThresholdExceeded = (regex_get_counter(regex_fail_count, str_in_re) >= m_params.m_RegexAutomata_FailedAutomatonThreshold); + if (expected_complexity <= m_params.m_RegexAutomata_DifficultyThreshold || failureThresholdExceeded) { + eautomaton * aut = m_mk_aut(re); + aut->compress(); + regex_automata.push_back(aut); + regex_automaton_under_assumptions new_aut(re, aut, true); + if (!regex_automaton_assumptions.contains(re)) { + regex_automaton_assumptions.insert(re, svector()); + } + regex_automaton_assumptions[re].push_back(new_aut); + TRACE("str", tout << "add new automaton for " << mk_pp(re, m) << ": no assumptions" << std::endl;); + regex_axiom_add = true; + find_automaton_initial_bounds(str_in_re, aut); + } else { + // TODO check negation? + // TODO construct a partial automaton for R to the given upper bound? + if (false) { + + } else { + regex_inc_counter(regex_fail_count, str_in_re); + } + } + continue; + } + // if we have *any* automaton for R, and the upper bound is not too large, + // finitize the automaton (if we have not already done so) and assert all solutions + if (upper_bound_value < 50) { // TODO better metric for threshold + // NOT_IMPLEMENTED_YET(); // TODO(mtrberzi) + } + } else { // !upper_bound_exists + // no upper bound information + if (lower_bound_exists && !lower_bound_value.is_zero() && new_lower_bound_info) { + // nonzero lower bound, no upper bound + + // check current assumptions + if (regex_automaton_assumptions.contains(re) && + !regex_automaton_assumptions[re].empty()){ + // one or more existing assumptions. + // see if the (current best) lower bound can be refined + // (note that if we have an automaton with no assumption, + // this automatically counts as best) + bool need_assumption = true; + regex_automaton_under_assumptions last_assumption; + rational last_lb = rational::zero(); // the default + for (svector::iterator it = regex_automaton_assumptions[re].begin(); + it != regex_automaton_assumptions[re].end(); ++it) { + regex_automaton_under_assumptions autA = *it; + if ((current_assignment == l_true && autA.get_polarity() == false) + || (current_assignment == l_false && autA.get_polarity() == true)) { + // automaton uses incorrect polarity + continue; + } + rational this_lb; + if (autA.get_lower_bound(this_lb)) { + if (this_lb > last_lb) { + last_lb = this_lb; + last_assumption = autA; + } + } else { + need_assumption = false; + last_assumption = autA; + break; + } + } + if (!last_lb.is_zero() || !need_assumption) { + CTRACE("str", !need_assumption, tout << "using automaton with full length information" << std::endl;); + CTRACE("str", need_assumption, tout << "using automaton with assumed lower bound of " << last_lb << std::endl;); + rational refined_lower_bound; + bool solution_at_lower_bound = refine_automaton_lower_bound(last_assumption.get_automaton(), + lower_bound_value, refined_lower_bound); + TRACE("str", tout << "refined lower bound is " << refined_lower_bound << + (solution_at_lower_bound?", solution at lower bound":", no solution at lower bound") << std::endl;); + + expr_ref_vector lhs(m); + if (current_assignment == l_false) { + lhs.push_back(m.mk_not(str_in_re)); + } else { + lhs.push_back(str_in_re); + } + if (need_assumption) { + lhs.push_back(m_autil.mk_ge(str_len, m_autil.mk_numeral(last_lb, true))); + } + lhs.push_back(m_autil.mk_ge(str_len, m_autil.mk_numeral(lower_bound_value, true))); + + expr_ref_vector rhs(m); + + if (solution_at_lower_bound) { + if (refined_lower_bound.is_minus_one()) { + // If there are solutions at the lower bound but not above it, make the bound exact. + rhs.push_back(ctx.mk_eq_atom(str_len, m_autil.mk_numeral(lower_bound_value, true))); + } else { + // If there are solutions at and above the lower bound, add an additional bound. + // DISABLED as this is causing non-termination in the integer solver. --mtrberzi + /* + rhs.push_back(m.mk_or( + ctx.mk_eq_atom(str_len, m_autil.mk_numeral(lower_bound_value, true)), + m_autil.mk_ge(str_len, m_autil.mk_numeral(refined_lower_bound, true)) + )); + */ + } + } else { + if (refined_lower_bound.is_minus_one()) { + // If there are no solutions at or above the lower bound, assert a conflict clause. + rhs.push_back(m.mk_not(m_autil.mk_ge(str_len, m_autil.mk_numeral(lower_bound_value, true)))); + } else { + // If there are solutions above the lower bound but not at it, refine the bound. + rhs.push_back(m_autil.mk_ge(str_len, m_autil.mk_numeral(refined_lower_bound, true))); + } + } + + if (!rhs.empty()) { + expr_ref lhs_terms(mk_and(lhs), m); + expr_ref rhs_terms(mk_and(rhs), m); + assert_implication(lhs_terms, rhs_terms); + regex_axiom_add = true; + } + } + } else { + // no existing automata/assumptions. + // if it's easy to construct a full automaton for R, do so + unsigned expected_complexity = estimate_regex_complexity(re); + bool failureThresholdExceeded = (regex_get_counter(regex_fail_count, str_in_re) >= m_params.m_RegexAutomata_FailedAutomatonThreshold); + if (expected_complexity <= m_params.m_RegexAutomata_DifficultyThreshold || failureThresholdExceeded) { + eautomaton * aut = m_mk_aut(re); + aut->compress(); + regex_automata.push_back(aut); + regex_automaton_under_assumptions new_aut(re, aut, true); + if (!regex_automaton_assumptions.contains(re)) { + regex_automaton_assumptions.insert(re, svector()); + } + regex_automaton_assumptions[re].push_back(new_aut); + TRACE("str", tout << "add new automaton for " << mk_pp(re, m) << ": no assumptions" << std::endl;); + regex_axiom_add = true; + find_automaton_initial_bounds(str_in_re, aut); + } else { + // TODO check negation? + // TODO construct a partial automaton for R to the given lower bound? + if (false) { + + } else { + regex_inc_counter(regex_fail_count, str_in_re); + } + } + continue; + } + } else { // !lower_bound_exists + // no bounds information + // check for existing automata; + // try to construct an automaton if we don't have one yet + // and doing so without bounds is not difficult + bool existingAutomata = (regex_automaton_assumptions.contains(re) && !regex_automaton_assumptions[re].empty()); + bool failureThresholdExceeded = (regex_get_counter(regex_fail_count, str_in_re) >= m_params.m_RegexAutomata_FailedAutomatonThreshold); + if (!existingAutomata) { + unsigned expected_complexity = estimate_regex_complexity(re); + if (expected_complexity <= m_params.m_RegexAutomata_DifficultyThreshold + || failureThresholdExceeded) { + eautomaton * aut = m_mk_aut(re); + aut->compress(); + regex_automata.push_back(aut); + regex_automaton_under_assumptions new_aut(re, aut, true); + if (!regex_automaton_assumptions.contains(re)) { + regex_automaton_assumptions.insert(re, svector()); + } + regex_automaton_assumptions[re].push_back(new_aut); + TRACE("str", tout << "add new automaton for " << mk_pp(re, m) << ": no assumptions" << std::endl;); + regex_axiom_add = true; + find_automaton_initial_bounds(str_in_re, aut); + } else { + regex_inc_counter(regex_fail_count, str_in_re); + } + } else { + regex_inc_counter(regex_fail_count, str_in_re); + } + } + } + } // foreach (entry in regex_terms) + + for (obj_map >::iterator it = regex_terms_by_string.begin(); + it != regex_terms_by_string.end(); ++it) { + // TODO do we need to check equivalence classes of strings here? + + expr * str = it->m_key; + ptr_vector str_in_re_terms = it->m_value; + + svector intersect_constraints; + // we may find empty intersection before checking every constraint; + // this vector keeps track of which ones actually take part in intersection + svector used_intersect_constraints; + + // choose an automaton/assumption for each assigned (str.in.re) + // that's consistent with the current length information + for (ptr_vector::iterator term_it = str_in_re_terms.begin(); + term_it != str_in_re_terms.end(); ++term_it) { + expr * _unused; + expr * re; + SASSERT(u.str.is_in_re(*term_it)); + u.str.is_in_re(*term_it, _unused, re); + + rational exact_len; + bool has_exact_len = get_len_value(str, exact_len); + + rational lb, ub; + bool has_lower_bound = lower_bound(mk_strlen(str), lb); + bool has_upper_bound = upper_bound(mk_strlen(str), ub); + + if (regex_automaton_assumptions.contains(re) && + !regex_automaton_assumptions[re].empty()){ + for (svector::iterator aut_it = regex_automaton_assumptions[re].begin(); + aut_it != regex_automaton_assumptions[re].end(); ++aut_it) { + regex_automaton_under_assumptions aut = *aut_it; + rational aut_ub; + bool assume_ub = aut.get_upper_bound(aut_ub); + rational aut_lb; + bool assume_lb = aut.get_lower_bound(aut_lb); + bool consistent = true; + + if (assume_ub) { + // check consistency of assumed upper bound + if (has_exact_len) { + if (exact_len > aut_ub) { + consistent = false; + } + } else { + if (has_upper_bound && ub > aut_ub) { + consistent = false; + } + } + } + + if (assume_lb) { + // check consistency of assumed lower bound + if (has_exact_len) { + if (exact_len < aut_lb) { + consistent = false; + } + } else { + if (has_lower_bound && lb < aut_lb) { + consistent = false; + } + } + } + + if (consistent) { + intersect_constraints.push_back(aut); + break; + } + } + } + } // foreach(term in str_in_re_terms) + + eautomaton * aut_inter = NULL; + CTRACE("str", !intersect_constraints.empty(), tout << "check intersection of automata constraints for " << mk_pp(str, m) << std::endl;); + for (svector::iterator aut_it = intersect_constraints.begin(); + aut_it != intersect_constraints.end(); ++aut_it) { + regex_automaton_under_assumptions aut = *aut_it; + if (aut_inter == NULL) { + // start somewhere + aut_inter = aut.get_automaton(); + used_intersect_constraints.push_back(aut); + continue; + } + + TRACE("str", + { + unsigned v = regex_get_counter(regex_length_attempt_count, aut.get_regex_term()); + tout << "length attempt count of " << mk_pp(aut.get_regex_term(), m) << " is " << v + << ", threshold is " << m_params.m_RegexAutomata_LengthAttemptThreshold << std::endl; + }); + + if (regex_get_counter(regex_length_attempt_count, aut.get_regex_term()) >= m_params.m_RegexAutomata_LengthAttemptThreshold) { + unsigned intersectionDifficulty = estimate_automata_intersection_difficulty(aut_inter, aut.get_automaton()); + TRACE("str", tout << "intersection difficulty is " << intersectionDifficulty << std::endl;); + if (intersectionDifficulty <= m_params.m_RegexAutomata_IntersectionDifficultyThreshold + || regex_get_counter(regex_intersection_fail_count, aut.get_regex_term()) >= m_params.m_RegexAutomata_FailedIntersectionThreshold) { + + expr * str_in_re_term(u.re.mk_in_re(str, aut.get_regex_term())); + lbool current_assignment = ctx.get_assignment(str_in_re_term); + // if the assignment is consistent with our assumption, use the automaton directly; + // otherwise, complement it (and save that automaton for next time) + // TODO we should cache these intermediate results + // TODO do we need to push the intermediates into a vector for deletion anyway? + if ( (current_assignment == l_true && aut.get_polarity()) + || (current_assignment == l_false && !aut.get_polarity())) { + aut_inter = m_mk_aut.mk_product(aut_inter, aut.get_automaton()); + m_automata.push_back(aut_inter); + } else { + // need to complement first + expr_ref rc(u.re.mk_complement(aut.get_regex_term()), m); + eautomaton * aut_c = m_mk_aut(rc); + regex_automata.push_back(aut_c); + // TODO is there any way to build a complement automaton from an existing one? + // this discards length information + aut_inter = m_mk_aut.mk_product(aut_inter, aut_c); + m_automata.push_back(aut_inter); + } + used_intersect_constraints.push_back(aut); + if (aut_inter->is_empty()) { + break; + } + } else { + // failed intersection + regex_inc_counter(regex_intersection_fail_count, aut.get_regex_term()); + } + } + } // foreach(entry in intersect_constraints) + if (aut_inter != NULL) { + aut_inter->compress(); + } + TRACE("str", tout << "intersected " << used_intersect_constraints.size() << " constraints" << std::endl;); + + expr_ref_vector conflict_terms(m); + expr_ref conflict_lhs(m); + for (svector::iterator aut_it = used_intersect_constraints.begin(); + aut_it != used_intersect_constraints.end(); ++aut_it) { + regex_automaton_under_assumptions aut = *aut_it; + expr * str_in_re_term(u.re.mk_in_re(str, aut.get_regex_term())); + lbool current_assignment = ctx.get_assignment(str_in_re_term); + if (current_assignment == l_true) { + conflict_terms.push_back(str_in_re_term); + } else if (current_assignment == l_false) { + conflict_terms.push_back(m.mk_not(str_in_re_term)); + } + // add length assumptions, if any + rational ub; + if (aut.get_upper_bound(ub)) { + expr_ref ub_term(m_autil.mk_le(mk_strlen(str), m_autil.mk_numeral(ub, true)), m); + conflict_terms.push_back(ub_term); + } + rational lb; + if (aut.get_lower_bound(lb)) { + expr_ref lb_term(m_autil.mk_ge(mk_strlen(str), m_autil.mk_numeral(lb, true)), m); + conflict_terms.push_back(lb_term); + } + } + conflict_lhs = mk_and(conflict_terms); + + if (used_intersect_constraints.size() > 1 && aut_inter != NULL) { + // check whether the intersection is only the empty string + unsigned initial_state = aut_inter->init(); + if (aut_inter->final_states().size() == 1 && aut_inter->is_final_state(initial_state)) { + // initial state is final and it is the only final state + // if there are no moves from the initial state, + // the only solution is the empty string + if (aut_inter->get_moves_from(initial_state).empty()) { + TRACE("str", tout << "product automaton only accepts empty string" << std::endl;); + expr_ref rhs1(ctx.mk_eq_atom(str, mk_string("")), m); + expr_ref rhs2(ctx.mk_eq_atom(mk_strlen(str), m_autil.mk_numeral(rational::zero(), true)), m); + expr_ref rhs(m.mk_and(rhs1, rhs2), m); + assert_implication(conflict_lhs, rhs); + regex_axiom_add = true; + } + } + } + + if (aut_inter != NULL && aut_inter->is_empty()) { + TRACE("str", tout << "product automaton is empty; asserting conflict clause" << std::endl;); + expr_ref conflict_clause(m.mk_not(mk_and(conflict_terms)), m); + assert_axiom(conflict_clause); + add_persisted_axiom(conflict_clause); + regex_axiom_add = true; + } + } // foreach (entry in regex_terms_by_string) + if (regex_axiom_add) { + //return FC_CONTINUE; + } + } // RegexAutomata + bool needToAssignFreeVars = false; std::set free_variables; std::set unused_internal_variables; @@ -9012,6 +10703,27 @@ namespace smt { return FC_CONTINUE; } + // We must be be 100% certain that if there are any regex constraints, + // the string assignment for each variable is consistent with the automaton. + // The (probably) easiest way to do this is to ensure + // that we have path constraints set up for every assigned regex term. + if (m_params.m_RegexAutomata && !regex_terms.empty()) { + for (obj_hashtable::iterator it = regex_terms.begin(); it != regex_terms.end(); ++it) { + expr * str_in_re = *it; + expr * str; + expr * re; + u.str.is_in_re(str_in_re, str, re); + lbool current_assignment = ctx.get_assignment(str_in_re); + if (current_assignment == l_undef) { + continue; + } + if (!regex_terms_with_path_constraints.contains(str_in_re)) { + TRACE("str", tout << "assigned regex term " << mk_pp(str_in_re, m) << " has no path constraints -- continuing search" << std::endl;); + return FC_CONTINUE; + } + } // foreach (str.in.re in regex_terms) + } + if (unused_internal_variables.empty()) { TRACE("str", tout << "All variables are assigned. Done!" << std::endl;); return FC_DONE; @@ -10454,6 +12166,24 @@ namespace smt { SASSERT(lenTestAssert != NULL); return lenTestAssert; } else { + // if we are performing automata-based reasoning and the term associated with + // this length tester is in any way constrained by regex terms, + // do not perform value testing -- this term is not a free variable. + if (m_params.m_RegexAutomata) { + std::map, expr*>::iterator it = regex_in_bool_map.begin(); + for (; it != regex_in_bool_map.end(); ++it) { + expr * re = it->second; + expr * re_str = to_app(re)->get_arg(0); + // recursive descent through all subterms of re_str to see if any of them are + // - the same as freeVar + // - in the same EQC as freeVar + if (term_appears_as_subterm(freeVar, re_str)) { + TRACE("str", tout << "prevent value testing on free var " << mk_pp(freeVar, m) << " as it belongs to one or more regex constraints." << std::endl;); + return NULL; + } + } + } + TRACE("str", tout << "length is fixed; generating models for free var" << std::endl;); // length is fixed expr * valueAssert = gen_free_var_options(freeVar, effectiveLenInd, effectiveLenIndiStr, nullptr, zstring("")); diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h index 5378b05f3..419084091 100644 --- a/src/smt/theory_str.h +++ b/src/smt/theory_str.h @@ -20,9 +20,11 @@ #include "util/trail.h" #include "util/union_find.h" #include "util/scoped_ptr_vector.h" +#include "util/hashtable.h" #include "ast/ast_pp.h" #include "ast/arith_decl_plugin.h" #include "ast/rewriter/th_rewriter.h" +#include "ast/rewriter/seq_rewriter.h" #include "ast/seq_decl_plugin.h" #include "smt/smt_theory.h" #include "smt/params/theory_str_params.h" @@ -36,6 +38,7 @@ namespace smt { typedef hashtable symbol_set; +typedef int_hashtable > integer_set; class str_value_factory : public value_factory { seq_util u; @@ -148,6 +151,70 @@ public: bool matches(zstring input); }; +class regex_automaton_under_assumptions { +protected: + expr * re_term; + eautomaton * aut; + bool polarity; + + bool assume_lower_bound; + rational lower_bound; + + bool assume_upper_bound; + rational upper_bound; +public: + regex_automaton_under_assumptions() : + re_term(NULL), aut(NULL), polarity(false), + assume_lower_bound(false), assume_upper_bound(false) {} + + regex_automaton_under_assumptions(expr * re_term, eautomaton * aut, bool polarity) : + re_term(re_term), aut(aut), polarity(polarity), + assume_lower_bound(false), assume_upper_bound(false) {} + + void set_lower_bound(rational & lb) { + lower_bound = lb; + assume_lower_bound = true; + } + void unset_lower_bound() { + assume_lower_bound = false; + } + + void set_upper_bound(rational & ub) { + upper_bound = ub; + assume_upper_bound = true; + } + void unset_upper_bound() { + assume_upper_bound = false; + } + + bool get_lower_bound(rational & lb) const { + if (assume_lower_bound) { + lb = lower_bound; + return true; + } else { + return false; + } + } + + bool get_upper_bound(rational & ub) const { + if (assume_upper_bound) { + ub = upper_bound; + return true; + } else { + return false; + } + } + + eautomaton * get_automaton() const { return aut; } + expr * get_regex_term() const { return re_term; } + bool get_polarity() const { return polarity; } + + virtual ~regex_automaton_under_assumptions() { + // don't free str_in_re or aut; + // they are managed separately + } +}; + class theory_str : public theory { struct T_cut { @@ -250,6 +317,8 @@ protected: str_value_factory * m_factory; + re2automaton m_mk_aut; + // Unique identifier appended to unused variables to ensure that model construction // does not introduce equalities when they weren't enforced. unsigned m_unused_id; @@ -267,6 +336,10 @@ protected: // enode lists for library-aware/high-level string terms (e.g. substr, contains) ptr_vector m_library_aware_axiom_todo; + // list of axioms that are re-asserted every time the scope is popped + expr_ref_vector m_persisted_axioms; + expr_ref_vector m_persisted_axiom_todo; + // hashtable of all exprs for which we've already set up term-specific axioms -- // this prevents infinite recursive descent with respect to axioms that // include an occurrence of the term for which axioms are being generated @@ -320,7 +393,31 @@ protected: // TBD: do a curried map for determinism. std::map, expr*> regex_in_bool_map; obj_map > regex_in_var_reg_str_map; + + // regex automata + scoped_ptr_vector m_automata; + ptr_vector regex_automata; + obj_hashtable regex_terms; + obj_map > regex_terms_by_string; // S --> [ (str.in.re S *) ] + obj_map > regex_automaton_assumptions; // RegEx --> [ aut+assumptions ] obj_map regex_nfa_cache; // Regex term --> NFA + obj_hashtable regex_terms_with_path_constraints; // set of string terms which have had path constraints asserted in the current scope + obj_hashtable regex_terms_with_length_constraints; // set of regex terms which had had length constraints asserted in the current scope + obj_map regex_term_to_length_constraint; // (str.in.re S R) -> (length constraint over S wrt. R) + obj_map > regex_term_to_extra_length_vars; // extra length vars used in regex_term_to_length_constraint entries + + // keep track of the last lower/upper bound we saw for each string term + // so we don't perform duplicate work + obj_map regex_last_lower_bound; + obj_map regex_last_upper_bound; + + // each counter maps a (str.in.re) expression to an integer. + // use helper functions regex_inc_counter() and regex_get_counter() to access + obj_map regex_length_attempt_count; + obj_map regex_fail_count; + obj_map regex_intersection_fail_count; + + obj_map > string_chars; // S --> [S_0, S_1, ...] for character terms S_i svector char_set; std::map charSetLookupTable; @@ -439,14 +536,32 @@ protected: void instantiate_axiom_str_to_int(enode * e); void instantiate_axiom_int_to_str(enode * e); + void add_persisted_axiom(expr * a); + expr * mk_RegexIn(expr * str, expr * regexp); void instantiate_axiom_RegexIn(enode * e); app * mk_unroll(expr * n, expr * bound); - void process_unroll_eq_const_str(expr * unrollFunc, expr * constStr); void unroll_str2reg_constStr(expr * unrollFunc, expr * eqConstStr); void process_concat_eq_unroll(expr * concat, expr * unroll); + // regex automata and length-aware regex + unsigned estimate_regex_complexity(expr * re); + unsigned estimate_regex_complexity_under_complement(expr * re); + unsigned estimate_automata_intersection_difficulty(eautomaton * aut1, eautomaton * aut2); + bool check_regex_length_linearity(expr * re); + bool check_regex_length_linearity_helper(expr * re, bool already_star); + expr_ref infer_all_regex_lengths(expr * lenVar, expr * re, expr_ref_vector & freeVariables); + void check_subterm_lengths(expr * re, integer_set & lens); + void find_automaton_initial_bounds(expr * str_in_re, eautomaton * aut); + bool refine_automaton_lower_bound(eautomaton * aut, rational current_lower_bound, rational & refined_lower_bound); + bool refine_automaton_upper_bound(eautomaton * aut, rational current_upper_bound, rational & refined_upper_bound); + expr_ref generate_regex_path_constraints(expr * stringTerm, eautomaton * aut, rational lenVal, expr_ref & characterConstraints); + void aut_path_add_next(u_map& next, expr_ref_vector& trail, unsigned idx, expr* cond); + expr_ref aut_path_rewrite_constraint(expr * cond, expr * ch_var); + void regex_inc_counter(obj_map & counter_map, expr * key); + unsigned regex_get_counter(obj_map & counter_map, expr * key); + void set_up_axioms(expr * ex); void handle_equality(expr * lhs, expr * rhs); @@ -535,6 +650,7 @@ protected: std::map > & concat_eq_concat_map, std::map > & unrollGroupMap); + bool term_appears_as_subterm(expr * needle, expr * haystack); void classify_ast_by_type(expr * node, std::map & varMap, std::map & concatMap, std::map & unrollMap); void classify_ast_by_type_in_positive_context(std::map & varMap, @@ -623,6 +739,7 @@ protected: void new_diseq_eh(theory_var, theory_var) override; theory* mk_fresh(context*) override { return alloc(theory_str, get_manager(), m_params); } + void init(context * ctx) override; void init_search_eh() override; void add_theory_assumptions(expr_ref_vector & assumptions) override; lbool validate_unsat_core(expr_ref_vector & unsat_core) override; diff --git a/src/solver/smt_logics.cpp b/src/solver/smt_logics.cpp index 874f1cfcc..7ed2b0445 100644 --- a/src/solver/smt_logics.cpp +++ b/src/solver/smt_logics.cpp @@ -22,14 +22,14 @@ Revision History: bool smt_logics::supported_logic(symbol const & s) { - return logic_has_uf(s) || logic_is_all(s) || logic_has_fd(s) || + return logic_has_uf(s) || logic_is_all(s) || logic_has_fd(s) || logic_has_arith(s) || logic_has_bv(s) || logic_has_array(s) || logic_has_seq(s) || logic_has_str(s) || logic_has_horn(s) || logic_has_fpa(s); } bool smt_logics::logic_has_reals_only(symbol const& s) { - return + return s == "QF_RDL" || s == "QF_LRA" || s == "UFLRA" || @@ -84,8 +84,9 @@ bool smt_logics::logic_has_arith(symbol const & s) { s == "QF_BVFP" || s == "QF_S" || s == "ALL" || - s == "QF_FD" || - s == "HORN"; + s == "QF_FD" || + s == "HORN" || + s == "QF_FPLRA"; } bool smt_logics::logic_has_bv(symbol const & s) { @@ -137,7 +138,7 @@ bool smt_logics::logic_has_str(symbol const & s) { } bool smt_logics::logic_has_fpa(symbol const & s) { - return s == "QF_FP" || s == "QF_FPBV" || s == "QF_BVFP" || s == "ALL"; + return s == "QF_FP" || s == "QF_FPBV" || s == "QF_BVFP" || s == "QF_FPLRA" || s == "ALL"; } bool smt_logics::logic_has_uf(symbol const & 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/tactic/fpa/CMakeLists.txt b/src/tactic/fpa/CMakeLists.txt index a54212235..c647df7fc 100644 --- a/src/tactic/fpa/CMakeLists.txt +++ b/src/tactic/fpa/CMakeLists.txt @@ -3,6 +3,7 @@ z3_add_component(fpa_tactics fpa2bv_model_converter.cpp fpa2bv_tactic.cpp qffp_tactic.cpp + qffplra_tactic.cpp COMPONENT_DEPENDENCIES arith_tactics bv_tactics @@ -14,4 +15,5 @@ z3_add_component(fpa_tactics TACTIC_HEADERS fpa2bv_tactic.h qffp_tactic.h + qffplra_tactic.h ) diff --git a/src/tactic/fpa/fpa2bv_tactic.cpp b/src/tactic/fpa/fpa2bv_tactic.cpp index b5dba34f0..30babdd33 100644 --- a/src/tactic/fpa/fpa2bv_tactic.cpp +++ b/src/tactic/fpa/fpa2bv_tactic.cpp @@ -90,7 +90,7 @@ class fpa2bv_tactic : public tactic { expr * sgn, *sig, *exp; m_conv.split_fp(new_curr, sgn, exp, sig); result.back()->assert_expr(m.mk_eq(sgn, m_conv.bu().mk_numeral(0, 1))); - result.back()->assert_expr(m.mk_eq(exp, m_conv.bu().mk_numeral(-1, m_conv.bu().get_bv_size(exp)))); + result.back()->assert_expr(m.mk_eq(exp, m_conv.bu().mk_bv_neg(m_conv.bu().mk_numeral(1, m_conv.bu().get_bv_size(exp))))); result.back()->assert_expr(m.mk_eq(sig, m_conv.bu().mk_numeral(1, m_conv.bu().get_bv_size(sig)))); } } diff --git a/src/tactic/fpa/qffplra_tactic.cpp b/src/tactic/fpa/qffplra_tactic.cpp new file mode 100644 index 000000000..947a41111 --- /dev/null +++ b/src/tactic/fpa/qffplra_tactic.cpp @@ -0,0 +1,72 @@ +/*++ +Copyright (c) 2012 Microsoft Corporation + +Module Name: + + qffpalra_tactic.cpp + +Abstract: + + Tactic for QF_FPLRA benchmarks. + +Author: + + Christoph (cwinter) 2018-04-24 + +Notes: + +--*/ +#include "tactic/tactical.h" +#include "tactic/fpa/qffp_tactic.h" +#include "tactic/fpa/qffplra_tactic.h" + +tactic * mk_qffplra_tactic(ast_manager & m, params_ref const & p) { + tactic * st = mk_qffp_tactic(m, p); + st->updt_params(p); + return st; +} + +struct is_non_qffplra_predicate { + struct found {}; + ast_manager & m; + bv_util bu; + fpa_util fu; + arith_util au; + + is_non_qffplra_predicate(ast_manager & _m) : m(_m), bu(m), fu(m), au(m) {} + + void operator()(var *) { throw found(); } + + void operator()(quantifier *) { throw found(); } + + void operator()(app * n) { + sort * s = get_sort(n); + if (!m.is_bool(s) && !fu.is_float(s) && !fu.is_rm(s) && !bu.is_bv_sort(s) && !au.is_real(s)) + throw found(); + family_id fid = n->get_family_id(); + if (fid == m.get_basic_family_id() || + fid == fu.get_family_id() || + fid == bu.get_family_id() || + fid == au.get_family_id()) + return; + if (is_uninterp_const(n)) + return; + if (au.is_real(s)) + return; + + throw found(); + } +}; + +class is_qffplra_probe : public probe { +public: + result operator()(goal const & g) override { + return !test(g); + } + + ~is_qffplra_probe() override {} +}; + +probe * mk_is_qffplra_probe() { + return alloc(is_qffplra_probe); +} diff --git a/src/tactic/fpa/qffplra_tactic.h b/src/tactic/fpa/qffplra_tactic.h new file mode 100644 index 000000000..b5a741ac3 --- /dev/null +++ b/src/tactic/fpa/qffplra_tactic.h @@ -0,0 +1,38 @@ +#pragma once +/*++ +Copyright (c) 2012 Microsoft Corporation + +Module Name: + + qffplra_tactic.h + +Abstract: + + Tactic for QF_FPLRA benchmarks. + +Author: + + Christoph (cwinter) 2018-04-24 + +Notes: + + +--*/ +#ifndef QFFPLRA_TACTIC_H_ +#define QFFPLRA_TACTIC_H_ + +#include "util/params.h" +class ast_manager; +class tactic; + +tactic * mk_qffplra_tactic(ast_manager & m, params_ref const & p = params_ref()); +/* +ADD_TACTIC("qffplra", "(try to) solve goal using the tactic for QF_FPLRA.", "mk_qffplra_tactic(m, p)") +*/ + +probe * mk_is_qffplra_probe(); +/* +ADD_PROBE("is-qffplra", "true if the goal is in QF_FPLRA.", "mk_is_qffplra_probe()") +*/ + +#endif diff --git a/src/tactic/portfolio/default_tactic.cpp b/src/tactic/portfolio/default_tactic.cpp index 709fab6c8..51cda17cd 100644 --- a/src/tactic/portfolio/default_tactic.cpp +++ b/src/tactic/portfolio/default_tactic.cpp @@ -28,22 +28,25 @@ Notes: #include "tactic/arith/probe_arith.h" #include "tactic/smtlogics/quant_tactics.h" #include "tactic/fpa/qffp_tactic.h" +#include "tactic/fpa/qffplra_tactic.h" #include "tactic/smtlogics/qfaufbv_tactic.h" #include "tactic/smtlogics/qfauflia_tactic.h" tactic * mk_default_tactic(ast_manager & m, params_ref const & p) { tactic * st = using_params(and_then(mk_simplify_tactic(m), - cond(mk_is_qfbv_probe(), mk_qfbv_tactic(m), - cond(mk_is_qfaufbv_probe(), mk_qfaufbv_tactic(m), + cond(mk_is_qfbv_probe(), mk_qfbv_tactic(m), + cond(mk_is_qfaufbv_probe(), mk_qfaufbv_tactic(m), cond(mk_is_qflia_probe(), mk_qflia_tactic(m), cond(mk_is_qfauflia_probe(), mk_qfauflia_tactic(m), cond(mk_is_qflra_probe(), mk_qflra_tactic(m), cond(mk_is_qfnra_probe(), mk_qfnra_tactic(m), cond(mk_is_qfnia_probe(), mk_qfnia_tactic(m), - cond(mk_is_lira_probe(), mk_lira_tactic(m, p), - cond(mk_is_nra_probe(), mk_nra_tactic(m), + cond(mk_is_lira_probe(), mk_lira_tactic(m, p), + cond(mk_is_nra_probe(), mk_nra_tactic(m), cond(mk_is_qffp_probe(), mk_qffp_tactic(m, p), - mk_smt_tactic()))))))))))), + cond(mk_is_qffplra_probe(), mk_qffplra_tactic(m, p), + //cond(mk_is_qfufnra_probe(), mk_qfufnra_tactic(m, p), + mk_smt_tactic())))))))))))), p); return st; } diff --git a/src/tactic/sine_filter.cpp b/src/tactic/sine_filter.cpp index e7e07d04a..c5242e237 100644 --- a/src/tactic/sine_filter.cpp +++ b/src/tactic/sine_filter.cpp @@ -33,17 +33,17 @@ 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) override { @@ -54,7 +54,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); @@ -62,115 +62,120 @@ public: TRACE("sine", result[0]->display(tout);); SASSERT(g->is_well_sorted()); } - - 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)); } @@ -204,28 +209,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)); - } } } }; 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..a9f9ca757 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"; @@ -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); @@ -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/env_params.cpp b/src/util/env_params.cpp index c2b5f7974..3ba6df735 100644 --- a/src/util/env_params.cpp +++ b/src/util/env_params.cpp @@ -23,7 +23,7 @@ Notes: #include "util/memory_manager.h" void env_params::updt_params() { - params_ref p = gparams::get(); + params_ref const& p = gparams::get_ref(); set_verbosity_level(p.get_uint("verbose", get_verbosity_level())); enable_warning_messages(p.get_bool("warning", true)); memory::set_max_size(megabytes_to_bytes(p.get_uint("memory_max_size", 0))); diff --git a/src/util/gparams.cpp b/src/util/gparams.cpp index 7466c2f3e..cf8ed5087 100644 --- a/src/util/gparams.cpp +++ b/src/util/gparams.cpp @@ -104,10 +104,8 @@ public: ~imp() { reset(); - dictionary::iterator it = m_module_param_descrs.begin(); - dictionary::iterator end = m_module_param_descrs.end(); - for (; it != end; ++it) { - dealloc(it->m_value); + for (auto & kv : m_module_param_descrs) { + dealloc(kv.m_value); } } @@ -115,10 +113,8 @@ public: #pragma omp critical (gparams) { m_params.reset(); - dictionary::iterator it = m_module_params.begin(); - dictionary::iterator end = m_module_params.end(); - for (; it != end; ++it) { - dealloc(it->m_value); + for (auto & kv : m_module_params) { + dealloc(kv.m_value); } m_module_params.reset(); } @@ -439,14 +435,8 @@ public: return result; } - params_ref get() { - params_ref result; - TRACE("gparams", tout << "get() m_params: " << m_params << "\n";); - #pragma omp critical (gparams) - { - result = m_params; - } - return result; + params_ref const& get_ref() { + return m_params; } // ----------------------------------------------- @@ -466,16 +456,14 @@ public: out << "Example: pp.decimal=true\n"; out << "\n"; } - dictionary::iterator it = get_module_param_descrs().begin(); - dictionary::iterator end = get_module_param_descrs().end(); - for (; it != end; ++it) { - out << "[module] " << it->m_key; + for (auto & kv : get_module_param_descrs()) { + out << "[module] " << kv.m_key; char const * descr = nullptr; - if (get_module_descrs().find(it->m_key, descr)) { + if (get_module_descrs().find(kv.m_key, descr)) { out << ", description: " << descr; } out << "\n"; - it->m_value->display(out, indent + 4, smt2_style, include_descr); + kv.m_value->display(out, indent + 4, smt2_style, include_descr); } } } @@ -483,12 +471,10 @@ public: void display_modules(std::ostream & out) { #pragma omp critical (gparams) { - dictionary::iterator it = get_module_param_descrs().begin(); - dictionary::iterator end = get_module_param_descrs().end(); - for (; it != end; ++it) { - out << "[module] " << it->m_key; + for (auto & kv : get_module_param_descrs()) { + out << "[module] " << kv.m_key; char const * descr = nullptr; - if (get_module_descrs().find(it->m_key, descr)) { + if (get_module_descrs().find(kv.m_key, descr)) { out << ", description: " << descr; } out << "\n"; @@ -620,10 +606,10 @@ params_ref gparams::get_module(symbol const & module_name) { return g_imp->get_module(module_name); } -params_ref gparams::get() { - TRACE("gparams", tout << "gparams::get()\n";); +params_ref const& gparams::get_ref() { + TRACE("gparams", tout << "gparams::get_ref()\n";); SASSERT(g_imp != 0); - return g_imp->get(); + return g_imp->get_ref(); } void gparams::display(std::ostream & out, unsigned indent, bool smt2_style, bool include_descr) { diff --git a/src/util/gparams.h b/src/util/gparams.h index 7ddaf0ccb..5334b28d0 100644 --- a/src/util/gparams.h +++ b/src/util/gparams.h @@ -106,7 +106,8 @@ public: /** \brief Return the global parameter set (i.e., parameters that are not associated with any particular module). */ - static params_ref get(); + + static params_ref const& get_ref(); /** \brief Dump information about available parameters in the given output stream. 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..b8f481329 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)); } @@ -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_t)(sig(x) | 0x0010000000000000ull)); else qm.set(n, sig(x)); if (sgn(x)) qm.neg(n); - qm.set(d, 0x0010000000000000ull); + qm.set(d, (uint64_t)0x0010000000000000ull); int e = exp(x); if (e >= 0) qm.mul2k(n, (unsigned)e); @@ -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..7549a7bb3 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; @@ -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; @@ -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/params.cpp b/src/util/params.cpp index 787760ac1..d7e05cb00 100644 --- a/src/util/params.cpp +++ b/src/util/params.cpp @@ -332,20 +332,10 @@ public: reset(); } - void inc_ref() { - #pragma omp critical (params) - { - m_ref_count++; - } - } + void inc_ref() { m_ref_count++; } void dec_ref() { - bool is_last; SASSERT(m_ref_count > 0); - #pragma omp critical (params) - { - is_last = 0 == --m_ref_count; - } - if (is_last) dealloc(this); + if (--m_ref_count == 0) dealloc(this); } bool empty() const { return m_entries.empty(); } @@ -576,27 +566,25 @@ void params_ref::copy(params_ref const & src) { void params_ref::copy_core(params const * src) { if (src == nullptr) return; - svector::const_iterator it = src->m_entries.begin(); - svector::const_iterator end = src->m_entries.end(); - for (; it != end; ++it) { - switch (it->second.m_kind) { + for (auto const& p : src->m_entries) { + switch (p.second.m_kind) { case CPK_BOOL: - m_params->set_bool(it->first, it->second.m_bool_value); + m_params->set_bool(p.first, p.second.m_bool_value); break; case CPK_UINT: - m_params->set_uint(it->first, it->second.m_uint_value); + m_params->set_uint(p.first, p.second.m_uint_value); break; case CPK_DOUBLE: - m_params->set_double(it->first, it->second.m_double_value); + m_params->set_double(p.first, p.second.m_double_value); break; case CPK_NUMERAL: - m_params->set_rat(it->first, *(it->second.m_rat_value)); + m_params->set_rat(p.first, *(p.second.m_rat_value)); break; case CPK_SYMBOL: - m_params->set_sym(it->first, symbol::mk_symbol_from_c_ptr(it->second.m_sym_value)); + m_params->set_sym(p.first, symbol::mk_symbol_from_c_ptr(p.second.m_sym_value)); break; case CPK_STRING: - m_params->set_str(it->first, it->second.m_str_value); + m_params->set_str(p.first, p.second.m_str_value); break; default: UNREACHABLE(); 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/scoped_timer.cpp b/src/util/scoped_timer.cpp index a2a0cc269..56d40c47a 100644 --- a/src/util/scoped_timer.cpp +++ b/src/util/scoped_timer.cpp @@ -208,14 +208,22 @@ struct scoped_timer::imp { pthread_cond_signal(&m_condition_var); pthread_mutex_unlock(&m_mutex); - if (pthread_join(m_thread_id, nullptr) != 0) - throw default_exception("failed to join thread"); - if (pthread_mutex_destroy(&m_mutex) != 0) - throw default_exception("failed to destroy pthread mutex"); - if (pthread_cond_destroy(&m_condition_var) != 0) - 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"); + if (pthread_join(m_thread_id, nullptr) != 0) { + warning_msg("failed to join thread"); + return; + } + if (pthread_mutex_destroy(&m_mutex) != 0) { + warning_msg("failed to destroy pthread mutex"); + return; + } + if (pthread_cond_destroy(&m_condition_var) != 0) { + warning_msg("failed to destroy pthread condition variable"); + return; + } + if (pthread_attr_destroy(&m_attributes) != 0) { + warning_msg("failed to destroy pthread attributes object"); + return; + } #elif defined(_LINUX_) || defined(_FREEBSD_) || defined(_NETBSD_) // Linux & FreeBSD & NetBSD bool init = false; 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 529d99564..913191e87 100644 --- a/src/util/util.cpp +++ b/src/util/util.cpp @@ -96,7 +96,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 ec0ca307e..e087f552c 100644 --- a/src/util/util.h +++ b/src/util/util.h @@ -21,32 +21,26 @@ Revision History: #include "util/debug.h" #include "util/memory_manager.h" +#include "util/z3_omp.h" #include #include #include -#include"z3_omp.h" +#include #ifndef SIZE_MAX #define SIZE_MAX std::numeric_limits::max() #endif -#ifndef uint64 -typedef unsigned long long uint64; -#endif -static_assert(sizeof(uint64) == 8, "64 bits please"); +static_assert(sizeof(uint64_t) == 8, "64 bits please"); -#ifndef int64 -typedef long long int64; -#endif - -static_assert(sizeof(int64) == 8, "64 bits"); +static_assert(sizeof(int64_t) == 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 @@ -111,7 +105,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"); @@ -137,11 +131,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; }