mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-06 09:34:08 +00:00
Code Activity

merge

Browse source 
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner 2018-04-30 09:30:43 -07:00
parent 859c68c2ac b8193a0ae6
commit f525f43e43
155 changed files with 3188 additions and 1043 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
CMakeLists.txt
View file

@ -33,8 +33,8 @@ endif()
# Project version # Project version
################################################################################ ################################################################################
set(Z3_VERSION_MAJOR 4) set(Z3_VERSION_MAJOR 4)
set(Z3_VERSION_MINOR 6) set(Z3_VERSION_MINOR 7)
set(Z3_VERSION_PATCH 2) set(Z3_VERSION_PATCH 0)
set(Z3_VERSION_TWEAK 0) set(Z3_VERSION_TWEAK 0)
set(Z3_VERSION "${Z3_VERSION_MAJOR}.${Z3_VERSION_MINOR}.${Z3_VERSION_PATCH}.${Z3_VERSION_TWEAK}") 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 set(Z3_FULL_VERSION_STR "${Z3_VERSION}") # Note this might be modified

5
README.md
View file

@ -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 | | 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 [1]: #building-z3-on-windows-using-visual-studio-command-prompt
[2]: #building-z3-using-make-and-gccclang [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. See [``examples/python``](examples/python) for examples.
### ``Web Assembly``
[WebAssembly](https://github.com/cpitclaudel/z3.wasm) bindings are provided by Clément Pit-Claudel.

14
examples/c++/example.cpp
View file

@ -920,6 +920,19 @@ void enum_sort_example() {
std::cout << "2: " << result_goal.as_expr() << std::endl; 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() { void expr_vector_example() {
std::cout << "expr_vector example\n"; std::cout << "expr_vector example\n";
context c; context c;
@ -1179,6 +1192,7 @@ int main() {
incremental_example2(); std::cout << "\n"; incremental_example2(); std::cout << "\n";
incremental_example3(); std::cout << "\n"; incremental_example3(); std::cout << "\n";
enum_sort_example(); std::cout << "\n"; enum_sort_example(); std::cout << "\n";
tuple_example(); std::cout << "\n";
expr_vector_example(); std::cout << "\n"; expr_vector_example(); std::cout << "\n";
exists_expr_vector_example(); std::cout << "\n"; exists_expr_vector_example(); std::cout << "\n";
substitute_example(); std::cout << "\n"; substitute_example(); std::cout << "\n";

3
examples/c/test_capi.c
View file

@ -2452,7 +2452,6 @@ Z3_lbool ext_check(Z3_ext_context ctx) {
} }
printf("\n"); printf("\n");
} }
return result; return result;
} }
@ -2464,7 +2463,7 @@ void incremental_example1() {
Z3_context ctx = ext_ctx->m_context; Z3_context ctx = ext_ctx->m_context;
Z3_ast x, y, z, two, one; Z3_ast x, y, z, two, one;
unsigned c1, c2, c3, c4; unsigned c1, c2, c3, c4;
Z3_bool result; Z3_lbool result;
printf("\nincremental_example1\n"); printf("\nincremental_example1\n");
LOG_MSG("incremental_example1"); LOG_MSG("incremental_example1");

2
scripts/mk_project.py
View file

@ -9,7 +9,7 @@ from mk_util import *
# Z3 Project definition # Z3 Project definition
def init_project_def(): def init_project_def():
set_version(4, 6, 2, 0) set_version(4, 7, 0, 0)
add_lib('util', []) add_lib('util', [])
add_lib('polynomial', ['util'], 'math/polynomial') add_lib('polynomial', ['util'], 'math/polynomial')
add_lib('sat', ['util']) add_lib('sat', ['util'])

14
scripts/update_api.py
View file

@ -60,7 +60,7 @@ FIRST_OBJ_ID = 100
def is_obj(ty): def is_obj(ty):
return ty >= FIRST_OBJ_ID 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', 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' 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') java_wrapper = open(java_wrapperf, 'w')
pkg_str = package_name.replace('.', '_') pkg_str = package_name.replace('.', '_')
java_wrapper.write('// Automatically generated file\n') 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<jni.h>\n') java_wrapper.write('#include<jni.h>\n')
java_wrapper.write('#include<stdlib.h>\n') java_wrapper.write('#include<stdlib.h>\n')
java_wrapper.write('#include"z3.h"\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(" }\n")
log_c.write(" Au(a%s);\n" % sz) log_c.write(" Au(a%s);\n" % sz)
exe_c.write("in.get_uint_array(%s)" % i) 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("U(a%s[i]);" % i)
log_c.write(" }\n") log_c.write(" }\n")
log_c.write(" Au(a%s);\n" % sz) log_c.write(" Au(a%s);\n" % sz)
exe_c.write("in.get_int_array(%s)" % i) 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: else:
error ("unsupported parameter for %s, %s, %s" % (ty, name, p)) error ("unsupported parameter for %s, %s, %s" % (ty, name, p))
elif kind == OUT_ARRAY: elif kind == OUT_ARRAY:
@ -1655,7 +1657,7 @@ else:
if hasattr(builtins, "Z3_LIB_DIRS"): if hasattr(builtins, "Z3_LIB_DIRS"):
_all_dirs = 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: if v in os.environ:
lp = os.environ[v]; lp = os.environ[v];
lds = lp.split(';') if sys.platform in ('win32') else lp.split(':') lds = lp.split(';') if sys.platform in ('win32') else lp.split(':')

3
src/api/api_context.cpp
View file

@ -78,7 +78,6 @@ namespace api {
m_bv_util(m()), m_bv_util(m()),
m_datalog_util(m()), m_datalog_util(m()),
m_fpa_util(m()), m_fpa_util(m()),
m_dtutil(m()),
m_sutil(m()), m_sutil(m()),
m_last_result(m()), m_last_result(m()),
m_ast_trail(m()), m_ast_trail(m()),
@ -184,7 +183,7 @@ namespace api {
e = m_bv_util.mk_numeral(n, s); e = m_bv_util.mk_numeral(n, s);
} }
else if (fid == get_datalog_fid() && n.is_uint64()) { else if (fid == get_datalog_fid() && n.is_uint64()) {
uint64 sz; uint64_t sz;
if (m_datalog_util.try_get_size(s, sz) && if (m_datalog_util.try_get_size(s, sz) &&
sz <= n.get_uint64()) { sz <= n.get_uint64()) {
invoke_error_handler(Z3_INVALID_ARG); invoke_error_handler(Z3_INVALID_ARG);

7
src/api/api_context.h
View file

@ -61,7 +61,6 @@ namespace api {
bv_util m_bv_util; bv_util m_bv_util;
datalog::dl_decl_util m_datalog_util; datalog::dl_decl_util m_datalog_util;
fpa_util m_fpa_util; fpa_util m_fpa_util;
datatype_util m_dtutil;
seq_util m_sutil; seq_util m_sutil;
// Support for old solver API // Support for old solver API
@ -121,13 +120,13 @@ namespace api {
bool produce_models() const { return m_params.m_model; } bool produce_models() const { return m_params.m_model; }
bool produce_unsat_cores() const { return m_params.m_unsat_core; } bool produce_unsat_cores() const { return m_params.m_unsat_core; }
bool use_auto_config() const { return m_params.m_auto_config; } bool use_auto_config() const { return m_params.m_auto_config; }
unsigned get_timeout() { return params().m_timeout; } unsigned get_timeout() const { return m_params.m_timeout; }
unsigned get_rlimit() { return params().m_rlimit; } unsigned get_rlimit() const { return m_params.rlimit(); }
arith_util & autil() { return m_arith_util; } arith_util & autil() { return m_arith_util; }
bv_util & bvutil() { return m_bv_util; } bv_util & bvutil() { return m_bv_util; }
datalog::dl_decl_util & datalog_util() { return m_datalog_util; } datalog::dl_decl_util & datalog_util() { return m_datalog_util; }
fpa_util & fpautil() { return m_fpa_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; } seq_util& sutil() { return m_sutil; }
family_id get_basic_fid() const { return m_basic_fid; } family_id get_basic_fid() const { return m_basic_fid; }
family_id get_array_fid() const { return m_array_fid; } family_id get_array_fid() const { return m_array_fid; }

5
src/api/api_datalog.cpp
View file

@ -189,7 +189,7 @@ extern "C" {
Z3_CATCH_RETURN(nullptr); 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; Z3_TRY;
LOG_Z3_mk_finite_domain_sort(c, name, size); LOG_Z3_mk_finite_domain_sort(c, name, size);
RESET_ERROR_CODE(); RESET_ERROR_CODE();
@ -199,7 +199,7 @@ extern "C" {
Z3_CATCH_RETURN(nullptr); 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; Z3_TRY;
if (out) { if (out) {
*out = 0; *out = 0;
@ -215,7 +215,6 @@ extern "C" {
RESET_ERROR_CODE(); RESET_ERROR_CODE();
VERIFY(mk_c(c)->datalog_util().try_get_size(to_sort(s), *out)); VERIFY(mk_c(c)->datalog_util().try_get_size(to_sort(s), *out));
return Z3_TRUE; return Z3_TRUE;
Z3_CATCH_RETURN(Z3_FALSE); Z3_CATCH_RETURN(Z3_FALSE);
} }

6
src/api/api_fpa.cpp
View file

@ -358,7 +358,7 @@ extern "C" {
Z3_CATCH_RETURN(nullptr); 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; Z3_TRY;
LOG_Z3_mk_fpa_numeral_int64_uint64(c, sgn, exp, sig, ty); LOG_Z3_mk_fpa_numeral_int64_uint64(c, sgn, exp, sig, ty);
RESET_ERROR_CODE(); RESET_ERROR_CODE();
@ -1035,7 +1035,7 @@ extern "C" {
Z3_CATCH_RETURN(""); 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; Z3_TRY;
LOG_Z3_fpa_get_numeral_significand_uint64(c, t, n); LOG_Z3_fpa_get_numeral_significand_uint64(c, t, n);
RESET_ERROR_CODE(); RESET_ERROR_CODE();
@ -1113,7 +1113,7 @@ extern "C" {
Z3_CATCH_RETURN(""); 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; Z3_TRY;
LOG_Z3_fpa_get_numeral_exponent_int64(c, t, n, biased); LOG_Z3_fpa_get_numeral_exponent_int64(c, t, n, biased);
RESET_ERROR_CODE(); RESET_ERROR_CODE();

18
src/api/api_numeral.cpp
View file

@ -116,7 +116,7 @@ extern "C" {
Z3_CATCH_RETURN(nullptr); 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; Z3_TRY;
LOG_Z3_mk_int64(c, value, ty); LOG_Z3_mk_int64(c, value, ty);
RESET_ERROR_CODE(); RESET_ERROR_CODE();
@ -129,7 +129,7 @@ extern "C" {
Z3_CATCH_RETURN(nullptr); 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; Z3_TRY;
LOG_Z3_mk_unsigned_int64(c, value, ty); LOG_Z3_mk_unsigned_int64(c, value, ty);
RESET_ERROR_CODE(); RESET_ERROR_CODE();
@ -172,7 +172,7 @@ extern "C" {
if (mk_c(c)->bvutil().is_numeral(e, r, bv_size)) { if (mk_c(c)->bvutil().is_numeral(e, r, bv_size)) {
return Z3_TRUE; return Z3_TRUE;
} }
uint64 v; uint64_t v;
if (mk_c(c)->datalog_util().is_numeral(e, v)) { if (mk_c(c)->datalog_util().is_numeral(e, v)) {
r = rational(v, rational::ui64()); r = rational(v, rational::ui64());
return Z3_TRUE; return Z3_TRUE;
@ -262,7 +262,7 @@ extern "C" {
Z3_CATCH_RETURN(""); 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; 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. // 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); LOG_Z3_get_numeral_small(c, a, num, den);
@ -296,7 +296,7 @@ extern "C" {
SET_ERROR_CODE(Z3_INVALID_ARG); SET_ERROR_CODE(Z3_INVALID_ARG);
return Z3_FALSE; return Z3_FALSE;
} }
long long l; int64_t l;
if (Z3_get_numeral_int64(c, v, &l) && l >= INT_MIN && l <= INT_MAX) { if (Z3_get_numeral_int64(c, v, &l) && l >= INT_MIN && l <= INT_MAX) {
*i = static_cast<int>(l); *i = static_cast<int>(l);
return Z3_TRUE; return Z3_TRUE;
@ -314,7 +314,7 @@ extern "C" {
SET_ERROR_CODE(Z3_INVALID_ARG); SET_ERROR_CODE(Z3_INVALID_ARG);
return Z3_FALSE; return Z3_FALSE;
} }
unsigned long long l; uint64_t l;
if (Z3_get_numeral_uint64(c, v, &l) && (l <= 0xFFFFFFFF)) { if (Z3_get_numeral_uint64(c, v, &l) && (l <= 0xFFFFFFFF)) {
*u = static_cast<unsigned>(l); *u = static_cast<unsigned>(l);
return Z3_TRUE; return Z3_TRUE;
@ -323,7 +323,7 @@ extern "C" {
Z3_CATCH_RETURN(Z3_FALSE); 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; 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. // 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); LOG_Z3_get_numeral_uint64(c, v, u);
@ -343,7 +343,7 @@ extern "C" {
Z3_CATCH_RETURN(Z3_FALSE); 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; 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. // 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); LOG_Z3_get_numeral_int64(c, v, i);
@ -362,7 +362,7 @@ extern "C" {
Z3_CATCH_RETURN(Z3_FALSE); 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; 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. // 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); LOG_Z3_get_numeral_rational_int64(c, v, num, den);

2
src/api/api_stats.cpp
View file

@ -130,7 +130,7 @@ extern "C" {
Z3_CATCH_RETURN(0.0); 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(); return memory::get_allocation_size();
} }

76
src/api/c++/z3++.h
View file

@ -267,6 +267,15 @@ namespace z3 {
and in \c ts the predicates for testing if terms of the enumeration sort correspond to an enumeration. 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); 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. \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(int n);
expr int_val(unsigned n); expr int_val(unsigned n);
expr int_val(__int64 n); expr int_val(int64_t n);
expr int_val(__uint64 n); expr int_val(uint64_t n);
expr int_val(char const * n); expr int_val(char const * n);
expr real_val(int n, int d); expr real_val(int n, int d);
expr real_val(int n); expr real_val(int n);
expr real_val(unsigned n); expr real_val(unsigned n);
expr real_val(__int64 n); expr real_val(int64_t n);
expr real_val(__uint64 n); expr real_val(uint64_t n);
expr real_val(char const * n); expr real_val(char const * n);
expr bv_val(int n, unsigned sz); expr bv_val(int n, unsigned sz);
expr bv_val(unsigned n, unsigned sz); expr bv_val(unsigned n, unsigned sz);
expr bv_val(__int64 n, unsigned sz); expr bv_val(int64_t n, unsigned sz);
expr bv_val(__uint64 n, unsigned sz); expr bv_val(uint64_t n, unsigned sz);
expr bv_val(char const * n, unsigned sz); expr bv_val(char const * n, unsigned sz);
expr bv_val(unsigned n, bool const* bits); expr bv_val(unsigned n, bool const* bits);
@ -661,8 +670,8 @@ namespace z3 {
small integers, 64 bit integers or rational or decimal strings. small integers, 64 bit integers or rational or decimal strings.
*/ */
bool is_numeral() const { return kind() == Z3_NUMERAL_AST; } 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_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& i) const { bool r = 0 != Z3_get_numeral_uint64(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_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_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; } 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 \brief Return \c int64_t value of numeral, throw if result cannot fit in
__int64 \c int64_t.
\pre is_numeral() \pre is_numeral()
*/ */
__int64 get_numeral_int64() const { int64_t get_numeral_int64() const {
assert(is_numeral()); assert(is_numeral());
__int64 result = 0; int64_t result = 0;
if (!is_numeral_i64(result)) { if (!is_numeral_i64(result)) {
assert(ctx().enable_exceptions()); assert(ctx().enable_exceptions());
if (!ctx().enable_exceptions()) return 0; 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; return result;
} }
/** /**
\brief Return __uint64 value of numeral, throw if result cannot fit in \brief Return \c uint64_t value of numeral, throw if result cannot fit in
__uint64 \c uint64_t.
\pre is_numeral() \pre is_numeral()
*/ */
__uint64 get_numeral_uint64() const { uint64_t get_numeral_uint64() const {
assert(is_numeral()); assert(is_numeral());
__uint64 result = 0; uint64_t result = 0;
if (!is_numeral_u64(result)) { if (!is_numeral_u64(result)) {
assert(ctx().enable_exceptions()); assert(ctx().enable_exceptions());
if (!ctx().enable_exceptions()) return 0; 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; 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])); } 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; 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<Z3_symbol> _names(n);
array<Z3_sort> _sorts(n);
for (unsigned i = 0; i < n; i++) { _names[i] = Z3_mk_string_symbol(*this, names[i]); _sorts[i] = sorts[i]; }
array<Z3_func_decl> _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) { inline sort context::uninterpreted_sort(char const* name) {
Z3_symbol _name = Z3_mk_string_symbol(*this, name); Z3_symbol _name = Z3_mk_string_symbol(*this, name);
return to_sort(*this, Z3_mk_uninterpreted_sort(*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(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(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(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 n) { Z3_ast r = Z3_mk_unsigned_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::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, 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(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(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(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 n) { Z3_ast r = Z3_mk_unsigned_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::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(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(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(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 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(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(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) { inline expr context::bv_val(unsigned n, bool const* bits) {
array<Z3_bool> _bits(n); array<Z3_bool> _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) { 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); 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) { inline expr select(expr const & a, expr const & i) {
check_context(a, i); check_context(a, i);

4
src/api/dotnet/AlgebraicNum.cs
View file

@ -3,11 +3,11 @@ Copyright (c) 2012 Microsoft Corporation
Module Name: Module Name:
IntNum.cs AlgebraicNum.cs
Abstract: Abstract:
Z3 Managed API: Int Numerals Z3 Managed API: Algebraic Numerals
Author: Author:

4
src/api/dotnet/BitVecNum.cs
View file

@ -3,11 +3,11 @@ Copyright (c) 2012 Microsoft Corporation
Module Name: Module Name:
IntNum.cs BitVecNum.cs
Abstract: Abstract:
Z3 Managed API: Int Numerals Z3 Managed API: BitVec Numerals
Author: Author:

2
src/api/z3.h
View file

@ -22,6 +22,8 @@ Notes:
#define Z3_H_ #define Z3_H_
#include <stdio.h> #include <stdio.h>
#include <stdbool.h>
#include <stdint.h>
#include "z3_macros.h" #include "z3_macros.h"
#include "z3_api.h" #include "z3_api.h"
#include "z3_ast_containers.h" #include "z3_ast_containers.h"

40
src/api/z3_api.h
View file

@ -36,14 +36,6 @@ DEFINE_TYPE(Z3_fixedpoint);
DEFINE_TYPE(Z3_optimize); DEFINE_TYPE(Z3_optimize);
DEFINE_TYPE(Z3_rcf_num); DEFINE_TYPE(Z3_rcf_num);
#ifndef __int64
#define __int64 long long
#endif
#ifndef __uint64
#define __uint64 unsigned long long
#endif
/** \defgroup capi C API */ /** \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 *}. \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))) 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. \brief Create an array type.
@ -3200,26 +3192,26 @@ extern "C" {
/** /**
\brief Create a numeral of a int, bit-vector, or finite-domain sort. \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. It is slightly faster than #Z3_mk_numeral since it is not necessary to parse a string.
\sa Z3_mk_numeral \sa Z3_mk_numeral
def_API('Z3_mk_int64', AST, (_in(CONTEXT), _in(INT64), _in(SORT))) 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. \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. It is slightly faster than #Z3_mk_numeral since it is not necessary to parse a string.
\sa Z3_mk_numeral \sa Z3_mk_numeral
def_API('Z3_mk_unsigned_int64', AST, (_in(CONTEXT), _in(UINT64), _in(SORT))) 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. \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))) 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. \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))) 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 \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 \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 \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))) 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 \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 \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))) 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 \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 \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))) 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. \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, ()) 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);
/*@}*/ /*@}*/

6
src/api/z3_fpa.h
View file

@ -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))) 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 \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))) 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. \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))) 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. \brief Retrieves the exponent of a floating-point literal as a bit-vector expression.

4
src/api/z3_logger.h
View file

@ -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) 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) 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) I(int64_t 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) 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) 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) S(Z3_string str) { *g_z3_log << "S \"" << ll_escaped(str) << "\"\n"; g_z3_log->flush(); }
static void __declspec(noinline) Sy(Z3_symbol sym) { static void __declspec(noinline) Sy(Z3_symbol sym) {

42
src/api/z3_replayer.cpp
View file

@ -40,8 +40,8 @@ struct z3_replayer::imp {
int m_line; // line int m_line; // line
svector<char> m_string; svector<char> m_string;
symbol m_id; symbol m_id;
__int64 m_int64; int64_t m_int64;
__uint64 m_uint64; uint64_t m_uint64;
double m_double; double m_double;
float m_float; float m_float;
size_t m_ptr; size_t m_ptr;
@ -85,8 +85,8 @@ struct z3_replayer::imp {
struct value { struct value {
value_kind m_kind; value_kind m_kind;
union { union {
__int64 m_int; int64_t m_int;
__uint64 m_uint; uint64_t m_uint;
double m_double; double m_double;
char const * m_str; char const * m_str;
void * m_obj; void * m_obj;
@ -95,8 +95,8 @@ struct z3_replayer::imp {
value():m_kind(OBJECT), m_int(0) {} value():m_kind(OBJECT), m_int(0) {}
value(void * obj):m_kind(OBJECT), m_obj(obj) {} 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, 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, uint64_t u):m_kind(k), m_uint(u) {}
value(value_kind k, __int64 i):m_kind(k), m_int(i) {} 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, double d):m_kind(k), m_double(d) {}
value(value_kind k, float f):m_kind(k), m_float(f) {} 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(); unsigned asz = m_args.size();
if (sz > asz) if (sz > asz)
throw z3_replayer_exception("invalid array size"); throw z3_replayer_exception("invalid array size");
__uint64 aidx; uint64_t aidx;
value_kind nk; value_kind nk;
for (unsigned i = asz - sz; i < asz; i++) { for (unsigned i = asz - sz; i < asz; i++) {
if (m_args[i].m_kind != k) if (m_args[i].m_kind != k)
@ -400,7 +400,7 @@ struct z3_replayer::imp {
#define TICK_FREQUENCY 100000 #define TICK_FREQUENCY 100000
void parse() { void parse() {
unsigned long long counter = 0; uint64_t counter = 0;
unsigned tick = 0; unsigned tick = 0;
while (true) { while (true) {
IF_VERBOSE(1, { IF_VERBOSE(1, {
@ -577,7 +577,7 @@ struct z3_replayer::imp {
return static_cast<int>(m_args[pos].m_int); return static_cast<int>(m_args[pos].m_int);
} }
__int64 get_int64(unsigned pos) const { int64_t get_int64(unsigned pos) const {
check_arg(pos, INT64); check_arg(pos, INT64);
return m_args[pos].m_int; return m_args[pos].m_int;
} }
@ -587,7 +587,7 @@ struct z3_replayer::imp {
return static_cast<unsigned>(m_args[pos].m_uint); return static_cast<unsigned>(m_args[pos].m_uint);
} }
__uint64 get_uint64(unsigned pos) const { uint64_t get_uint64(unsigned pos) const {
check_arg(pos, UINT64); check_arg(pos, UINT64);
return m_args[pos].m_uint; return m_args[pos].m_uint;
} }
@ -630,6 +630,12 @@ struct z3_replayer::imp {
return m_int_arrays[idx].c_ptr(); return m_int_arrays[idx].c_ptr();
} }
bool * get_bool_array(unsigned pos) const {
check_arg(pos, UINT_ARRAY);
unsigned idx = static_cast<unsigned>(m_args[pos].m_uint);
return reinterpret_cast<bool*>(m_unsigned_arrays[idx].c_ptr());
}
Z3_symbol * get_symbol_array(unsigned pos) const { Z3_symbol * get_symbol_array(unsigned pos) const {
check_arg(pos, SYMBOL_ARRAY); check_arg(pos, SYMBOL_ARRAY);
unsigned idx = static_cast<unsigned>(m_args[pos].m_uint); unsigned idx = static_cast<unsigned>(m_args[pos].m_uint);
@ -650,7 +656,7 @@ struct z3_replayer::imp {
return reinterpret_cast<int*>(&(m_args[pos].m_int)); return reinterpret_cast<int*>(&(m_args[pos].m_int));
} }
__int64 * get_int64_addr(unsigned pos) { int64_t * get_int64_addr(unsigned pos) {
check_arg(pos, INT64); check_arg(pos, INT64);
return &(m_args[pos].m_int); return &(m_args[pos].m_int);
} }
@ -660,7 +666,7 @@ struct z3_replayer::imp {
return reinterpret_cast<unsigned*>(&(m_args[pos].m_uint)); return reinterpret_cast<unsigned*>(&(m_args[pos].m_uint));
} }
__uint64 * get_uint64_addr(unsigned pos) { uint64_t * get_uint64_addr(unsigned pos) {
check_arg(pos, UINT64); check_arg(pos, UINT64);
return &(m_args[pos].m_uint); return &(m_args[pos].m_uint);
} }
@ -725,11 +731,11 @@ unsigned z3_replayer::get_uint(unsigned pos) const {
return m_imp->get_uint(pos); 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); 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); 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); 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 { Z3_symbol * z3_replayer::get_symbol_array(unsigned pos) const {
return m_imp->get_symbol_array(pos); 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); 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); 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); 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); return m_imp->get_uint64_addr(pos);
} }

9
src/api/z3_replayer.h
View file

@ -40,8 +40,8 @@ public:
int get_int(unsigned pos) const; int get_int(unsigned pos) const;
unsigned get_uint(unsigned pos) const; unsigned get_uint(unsigned pos) const;
__int64 get_int64(unsigned pos) const; int64_t get_int64(unsigned pos) const;
__uint64 get_uint64(unsigned pos) const; uint64_t get_uint64(unsigned pos) const;
float get_float(unsigned pos) const; float get_float(unsigned pos) const;
double get_double(unsigned pos) const; double get_double(unsigned pos) const;
bool get_bool(unsigned pos) const; bool get_bool(unsigned pos) const;
@ -51,13 +51,14 @@ public:
unsigned * get_uint_array(unsigned pos) const; unsigned * get_uint_array(unsigned pos) const;
int * get_int_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; Z3_symbol * get_symbol_array(unsigned pos) const;
void ** get_obj_array(unsigned pos) const; void ** get_obj_array(unsigned pos) const;
int * get_int_addr(unsigned pos); 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); 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); Z3_string * get_str_addr(unsigned pos);
void ** get_obj_addr(unsigned pos); void ** get_obj_addr(unsigned pos);

7
src/ast/ast.cpp
View file

@ -2259,7 +2259,12 @@ var * ast_manager::mk_var(unsigned idx, sort * s) {
unsigned sz = var::get_obj_size(); unsigned sz = var::get_obj_size();
void * mem = allocate_node(sz); void * mem = allocate_node(sz);
var * new_node = new (mem) var(idx, s); 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) { app * ast_manager::mk_label(bool pos, unsigned num_names, symbol const * names, expr * n) {

12
src/ast/ast.h
View file

@ -298,11 +298,11 @@ class sort_size {
SS_FINITE_VERY_BIG, SS_FINITE_VERY_BIG,
SS_INFINITE SS_INFINITE
} m_kind; } m_kind;
uint64 m_size; // It is only meaningful if m_kind == SS_FINITE uint64_t m_size; // It is only meaningful if m_kind == SS_FINITE
sort_size(kind_t k, uint64 r):m_kind(k), m_size(r) {} sort_size(kind_t k, uint64_t r):m_kind(k), m_size(r) {}
public: public:
sort_size():m_kind(SS_INFINITE) {} 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) {} sort_size(sort_size const& other): m_kind(other.m_kind), m_size(other.m_size) {}
explicit sort_size(rational const& r) { explicit sort_size(rational const& r) {
if (r.is_uint64()) { if (r.is_uint64()) {
@ -316,7 +316,7 @@ public:
} }
static sort_size mk_infinite() { return sort_size(SS_INFINITE, 0); } 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_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_infinite() const { return m_kind == SS_INFINITE; }
bool is_very_big() const { return m_kind == SS_FINITE_VERY_BIG; } 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; } 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); 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) { 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): 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) { decl_info(family_id, k, num_parameters, parameters, private_parameters), m_num_elements(num_elements) {
} }

2
src/ast/ast_smt2_pp.cpp
View file

@ -395,7 +395,7 @@ format * smt2_pp_environment::pp_string_literal(app * t) {
} }
format * smt2_pp_environment::pp_datalog_literal(app * t) { format * smt2_pp_environment::pp_datalog_literal(app * t) {
uint64 v; uint64_t v;
VERIFY (get_dlutil().is_numeral(t, v)); VERIFY (get_dlutil().is_numeral(t, v));
std::ostringstream buffer; std::ostringstream buffer;
buffer << v; buffer << v;

2
src/ast/bv_decl_plugin.h
View file

@ -384,7 +384,7 @@ public:
app * mk_numeral(rational const & val, sort* s) const; app * mk_numeral(rational const & val, sort* s) const;
app * mk_numeral(rational const & val, unsigned bv_size) 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); sort * mk_sort(unsigned bv_size);
unsigned get_bv_size(sort const * s) const { unsigned get_bv_size(sort const * s) const {

1
src/ast/datatype_decl_plugin.cpp
View file

@ -390,6 +390,7 @@ namespace datatype {
TRACE("datatype", tout << "declaring " << datatypes[i]->name() << "\n";); TRACE("datatype", tout << "declaring " << datatypes[i]->name() << "\n";);
if (m_defs.find(datatypes[i]->name(), d)) { if (m_defs.find(datatypes[i]->name(), d)) {
TRACE("datatype", tout << "delete previous version for " << datatypes[i]->name() << "\n";); TRACE("datatype", tout << "delete previous version for " << datatypes[i]->name() << "\n";);
u().reset();
dealloc(d); dealloc(d);
} }
m_defs.insert(datatypes[i]->name(), datatypes[i]); m_defs.insert(datatypes[i]->name(), datatypes[i]);

3
src/ast/datatype_decl_plugin.h
View file

@ -239,7 +239,6 @@ namespace datatype {
map<symbol, def*, symbol_hash_proc, symbol_eq_proc> m_defs; map<symbol, def*, symbol_hash_proc, symbol_eq_proc> m_defs;
svector<symbol> m_def_block; svector<symbol> m_def_block;
unsigned m_class_id; unsigned m_class_id;
util & u() const;
void inherit(decl_plugin* other_p, ast_translation& tr) override; 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 const& get_def(sort* s) const { return *(m_defs[datatype_name(s)]); }
def& get_def(symbol const& s) { return *(m_defs[s]); } def& get_def(symbol const& s) { return *(m_defs[s]); }
bool is_declared(sort* s) const { return m_defs.contains(datatype_name(s)); } bool is_declared(sort* s) const { return m_defs.contains(datatype_name(s)); }
util & u() const;
private: private:
bool is_value_visit(expr * arg, ptr_buffer<app> & todo) const; bool is_value_visit(expr * arg, ptr_buffer<app> & todo) const;

12
src/ast/dl_decl_plugin.cpp
View file

@ -652,9 +652,9 @@ namespace datalog {
// create a constant belonging to a given finite domain. // 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)) { if (is_finite_sort(s)) {
uint64 sz = 0; uint64_t sz = 0;
if (try_get_size(s, sz) && sz <= value) { if (try_get_size(s, sz) && sz <= value) {
m.raise_exception("value is out of bounds"); m.raise_exception("value is out of bounds");
} }
@ -680,7 +680,7 @@ namespace datalog {
return nullptr; 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)) { if (is_numeral(e)) {
const app* c = to_app(e); const app* c = to_app(e);
SASSERT(c->get_decl()->get_num_parameters() == 2); SASSERT(c->get_decl()->get_num_parameters() == 2);
@ -693,7 +693,7 @@ namespace datalog {
return false; 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)) { if (is_numeral(e, v)) {
return true; return true;
} }
@ -724,7 +724,7 @@ namespace datalog {
return m.is_true(c) || m.is_false(c); 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) { if (domain_size == 0) {
std::stringstream sstm; std::stringstream sstm;
sstm << "Domain size of sort '" << name << "' may not be 0"; 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); 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(); sort_size sz = s->get_info()->get_num_elements();
if (sz.is_finite()) { if (sz.is_finite()) {
size = sz.size(); size = sz.size();

12
src/ast/dl_decl_plugin.h
View file

@ -122,7 +122,7 @@ namespace datalog {
// Contract for func_decl: // Contract for func_decl:
// parameters[0] - array sort // parameters[0] - array sort
// Contract for OP_DL_CONSTANT: // 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 // parameters[1] - a DL_FINITE_SORT sort of the constant
// Contract for others: // Contract for others:
// no parameters // no parameters
@ -166,7 +166,7 @@ namespace datalog {
dl_decl_util(ast_manager& m); dl_decl_util(ast_manager& m);
// create a constant belonging to a given finite domain. // create a constant belonging to a given finite domain.
// the options include the DL_FINITE_SORT, BV_SORT, and BOOL_SORT // 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); 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* 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 // Utilities for extracting constants
// from bit-vectors and finite domains. // 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; 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 { bool is_finite_sort(sort* s) const {
return is_sort_of(s, m_fid, DL_FINITE_SORT); return is_sort_of(s, m_fid, DL_FINITE_SORT);

23
src/ast/fpa/bv2fpa_converter.cpp
View file

@ -262,11 +262,11 @@ func_interp * bv2fpa_converter::convert_func_interp(model_core * mc, func_decl *
unsigned arity = bv_f->get_arity(); unsigned arity = bv_f->get_arity();
func_interp * bv_fi = mc->get_func_interp(bv_f); func_interp * bv_fi = mc->get_func_interp(bv_f);
result = alloc(func_interp, m, arity);
if (bv_fi) { if (bv_fi) {
fpa_rewriter rw(m); fpa_rewriter rw(m);
expr_ref ai(m); expr_ref ai(m);
result = alloc(func_interp, m, arity);
for (unsigned i = 0; i < bv_fi->num_entries(); i++) { for (unsigned i = 0; i < bv_fi->num_entries(); i++) {
func_entry const * bv_fe = bv_fi->get_entry(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 { else {
if (it->get_key().get_family_id() == m_fpa_util.get_fid()) { 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. // it->m_value contains the model for the unspecified cases of it->m_key.
target_model->register_decl(f, convert_func_interp(mc, f, it->m_value));
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);
} }
} }
} }

49
src/ast/fpa/fpa2bv_converter.cpp
View file

@ -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.is_int64(max_exp_diff));
SASSERT(m_mpz_manager.get_uint64(max_exp_diff) <= UINT_MAX); 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); SASSERT(max_exp_diff_ui64 <= UINT_MAX);
unsigned max_exp_diff_ui = (unsigned)max_exp_diff_ui64; unsigned max_exp_diff_ui = (unsigned)max_exp_diff_ui64;
m_mpz_manager.del(max_exp_diff); 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); expr_ref pow_2_sbitsm1(m), m1(m);
pow_2_sbitsm1 = m_bv_util.mk_numeral(fu().fm().m_powers2(sbits - 1), sbits); 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_sig, pow_2_sbitsm1, t1);
m_simp.mk_eq(a_exp, m1, t2); m_simp.mk_eq(a_exp, m1, t2);
m_simp.mk_and(t1, t2, tie); 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_rte, c421);
m_simp.mk_and(tie, rm_is_rta, c422); 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_c421", c421);
dbg_decouple("fpa2bv_r2i_c422", c422); 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); 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_ovf_exp = m_bv_util.mk_numeral(ovft, from_ebits+2);
first_udf_exp = m_bv_util.mk_concat( 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)); 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_ovf_exp", first_ovf_exp);
dbg_decouple("fpa2bv_to_float_first_udf_exp", first_udf_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); 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_bit = m_bv_util.mk_extract(bv_sz - 1, bv_sz - 1, x);
is_neg = m.mk_eq(is_neg_bit, bv1_1); 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); x_abs = m.mk_ite(is_neg, neg_x, x);
dbg_decouple("fpa2bv_to_fp_signed_is_neg", is_neg); dbg_decouple("fpa2bv_to_fp_signed_is_neg", is_neg);
// x_abs has an extra bit in the front. // 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(is_well_sorted(m, lz));
} }
SASSERT(m_bv_util.get_bv_size(sig_4) == sig_sz); 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); 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 = m_bv_util.mk_bv_sub(m_bv_util.mk_numeral(bv_sz - 2, bv_sz), lz);
// s_exp = (bv_sz-2) + (-lz) signed // s_exp = (bv_sz-2) + (-lz) signed
SASSERT(m_bv_util.get_bv_size(s_exp) == bv_sz); 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) unsigned exp_sz = ebits + 2; // (+2 for rounder)
exp_2 = m_bv_util.mk_extract(exp_sz - 1, 0, s_exp); exp_2 = m_bv_util.mk_extract(exp_sz - 1, 0, s_exp);
@ -2907,9 +2909,8 @@ void fpa2bv_converter::mk_to_fp_signed(func_decl * f, unsigned num, expr * const
mk_max_exp(exp_sz, max_exp); mk_max_exp(exp_sz, max_exp);
max_exp_bvsz = m_bv_util.mk_zero_extend(bv_sz - 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(
max_exp_bvsz, m_bv_util.mk_bv_add(max_exp_bvsz, m_bv_util.mk_numeral(1, bv_sz)),
m_bv_util.mk_numeral(1, bv_sz)),
s_exp); s_exp);
zero_sig_sz = m_bv_util.mk_numeral(0, sig_sz); zero_sig_sz = m_bv_util.mk_numeral(0, sig_sz);
sig_4 = m.mk_ite(exp_too_large, zero_sig_sz, sig_4); sig_4 = m.mk_ite(exp_too_large, zero_sig_sz, sig_4);
@ -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); mk_max_exp(exp_sz, max_exp);
max_exp_bvsz = m_bv_util.mk_zero_extend(bv_sz - 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, max_exp_bvsz,
m_bv_util.mk_numeral(1, bv_sz)), m_bv_util.mk_numeral(1, bv_sz)),
s_exp); 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); expr_ref exp_bv(m), exp_all_ones(m);
exp_bv = m_bv_util.mk_extract(ebits+sbits-2, sbits-1, result); 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); m_extra_assertions.push_back(exp_all_ones);
expr_ref sig_bv(m), sig_is_non_zero(m); 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_inc", inc);
dbg_decouple("fpa2bv_to_bv_pre_rounded", pre_rounded); 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) { 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_bv_neg(m_bv_util.mk_numeral(1, bv_sz)));
ul = m_bv_util.mk_zero_extend(3, 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 { 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))); 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); dbg_decouple("fpa2bv_to_bv_in_range", in_range);
expr_ref rounded(m); expr_ref rounded(m);

24
src/ast/rewriter/bv_rewriter.cpp
View file

@ -680,8 +680,8 @@ br_status bv_rewriter::mk_extract(unsigned high, unsigned low, expr * arg, expr_
if (v.is_neg()) if (v.is_neg())
mod(v, rational::power_of_two(sz), v); mod(v, rational::power_of_two(sz), v);
if (v.is_uint64()) { if (v.is_uint64()) {
uint64 u = v.get_uint64(); uint64_t u = v.get_uint64();
uint64 e = shift_right(u, low) & (shift_left(1ull, sz) - 1ull); uint64_t e = shift_right(u, low) & (shift_left(1ull, sz) - 1ull);
result = mk_numeral(numeral(e, numeral::ui64()), sz); result = mk_numeral(numeral(e, numeral::ui64()), sz);
return BR_DONE; 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(r1.is_uint64() && r2.is_uint64());
SASSERT(r2.get_uint64() < bv_size); 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()); numeral rn(r, numeral::ui64());
rn = m_util.norm(rn, bv_size); rn = m_util.norm(rn, bv_size);
result = mk_numeral(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) { if (bv_size <= 64) {
SASSERT(r1.is_uint64()); SASSERT(r1.is_uint64());
SASSERT(r2.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()); numeral rn(r, numeral::ui64());
rn = m_util.norm(rn, bv_size); rn = m_util.norm(rn, bv_size);
result = mk_numeral(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); bool is_num1 = is_numeral(arg1, r1, bv_size);
if (bv_size <= 64 && is_num1 && is_num2) { if (bv_size <= 64 && is_num1 && is_num2) {
uint64 n1 = r1.get_uint64(); uint64_t n1 = r1.get_uint64();
uint64 n2_orig = r2.get_uint64(); uint64_t n2_orig = r2.get_uint64();
uint64 n2 = n2_orig % bv_size; uint64_t n2 = n2_orig % bv_size;
SASSERT(n2 < 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; bool sign = (n1 & shift_left(1ull, bv_size - 1ull)) != 0;
if (n2_orig > n2) { if (n2_orig > n2) {
if (sign) { if (sign) {
@ -917,8 +917,8 @@ br_status bv_rewriter::mk_bv_ashr(expr * arg1, expr * arg2, expr_ref & result) {
} }
} }
else if (sign) { else if (sign) {
uint64 allone = shift_left(1ull, bv_size) - 1ull; uint64_t allone = shift_left(1ull, bv_size) - 1ull;
uint64 mask = ~(shift_left(1ull, bv_size - n2) - 1ull); uint64_t mask = ~(shift_left(1ull, bv_size - n2) - 1ull);
mask &= allone; mask &= allone;
r |= mask; r |= mask;
} }
@ -2021,7 +2021,7 @@ br_status bv_rewriter::mk_bv_ext_rotate_left(expr * arg1, expr * arg2, expr_ref
numeral r2; numeral r2;
unsigned bv_size; unsigned bv_size;
if (is_numeral(arg2, r2, bv_size)) { if (is_numeral(arg2, r2, bv_size)) {
unsigned shift = static_cast<unsigned>((r2 % numeral(bv_size)).get_uint64() % static_cast<uint64>(bv_size)); unsigned shift = static_cast<unsigned>((r2 % numeral(bv_size)).get_uint64() % static_cast<uint64_t>(bv_size));
return mk_bv_rotate_left(shift, arg1, result); return mk_bv_rotate_left(shift, arg1, result);
} }
return BR_FAILED; return BR_FAILED;
@ -2031,7 +2031,7 @@ br_status bv_rewriter::mk_bv_ext_rotate_right(expr * arg1, expr * arg2, expr_ref
numeral r2; numeral r2;
unsigned bv_size; unsigned bv_size;
if (is_numeral(arg2, r2, bv_size)) { if (is_numeral(arg2, r2, bv_size)) {
unsigned shift = static_cast<unsigned>((r2 % numeral(bv_size)).get_uint64() % static_cast<uint64>(bv_size)); unsigned shift = static_cast<unsigned>((r2 % numeral(bv_size)).get_uint64() % static_cast<uint64_t>(bv_size));
return mk_bv_rotate_right(shift, arg1, result); return mk_bv_rotate_right(shift, arg1, result);
} }
return BR_FAILED; return BR_FAILED;

2
src/ast/rewriter/dl_rewriter.cpp
View file

@ -22,7 +22,7 @@ Revision History:
br_status dl_rewriter::mk_app_core( br_status dl_rewriter::mk_app_core(
func_decl * f, unsigned num_args, expr* const* args, expr_ref& result) { func_decl * f, unsigned num_args, expr* const* args, expr_ref& result) {
ast_manager& m = result.get_manager(); ast_manager& m = result.get_manager();
uint64 v1, v2; uint64_t v1, v2;
switch(f->get_decl_kind()) { switch(f->get_decl_kind()) {
case datalog::OP_DL_LT: case datalog::OP_DL_LT:
if (m_util.is_numeral_ext(args[0], v1) && if (m_util.is_numeral_ext(args[0], v1) &&

2
src/ast/rewriter/fpa_rewriter.cpp
View file

@ -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_fm.is_nan(v)) {
if (m_hi_fp_unspecified) { if (m_hi_fp_unspecified) {
expr * args[4] = { bu.mk_numeral(0, 1), 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(0, x.get_sbits() - 2),
bu.mk_numeral(1, 1) }; bu.mk_numeral(1, 1) };
result = bu.mk_concat(4, args); result = bu.mk_concat(4, args);

8
src/ast/rewriter/seq_rewriter.cpp
View file

@ -200,6 +200,9 @@ void re2automaton::set_solver(expr_solver* solver) {
m_sa = alloc(symbolic_automata_t, sm, *m_ba.get()); 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* re2automaton::operator()(expr* e) {
eautomaton* r = re2aut(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); SASSERT(num_args == 2);
return mk_re_concat(args[0], args[1], result); return mk_re_concat(args[0], args[1], result);
case OP_RE_UNION: case OP_RE_UNION:
if (num_args == 1) {
result = args[0]; return BR_DONE;
}
SASSERT(num_args == 2); SASSERT(num_args == 2);
return mk_re_union(args[0], args[1], result); return mk_re_union(args[0], args[1], result);
case OP_RE_RANGE: 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; return BR_DONE;
} }
if (m_util.str.is_string(b, s2) && s2.length() == 0) { 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; return BR_REWRITE1;
} }
if (m_util.str.is_string(a, s1) && s1.length() == 0) { if (m_util.str.is_string(a, s1) && s1.length() == 0) {

5
src/ast/rewriter/seq_rewriter.h
View file

@ -53,7 +53,9 @@ public:
bool is_range() const { return m_ty == t_range; } bool is_range() const { return m_ty == t_range; }
sort* get_sort() const { return m_sort; } sort* get_sort() const { return m_sort; }
expr* get_char() const { SASSERT(is_char()); return m_t; } 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 { class sym_expr_manager {
@ -87,6 +89,7 @@ public:
~re2automaton(); ~re2automaton();
eautomaton* operator()(expr* e); eautomaton* operator()(expr* e);
void set_solver(expr_solver* solver); void set_solver(expr_solver* solver);
eautomaton* mk_product(eautomaton *a1, eautomaton *a2);
}; };
/** /**

5
src/ast/seq_decl_plugin.cpp
View file

@ -177,7 +177,7 @@ zstring zstring::replace(zstring const& src, zstring const& dst) const {
return zstring(*this); return zstring(*this);
} }
if (src.length() == 0) { if (src.length() == 0) {
return zstring(*this); return dst + zstring(*this);
} }
bool found = false; bool found = false;
for (unsigned i = 0; i < length(); ++i) { for (unsigned i = 0; i < length(); ++i) {
@ -213,6 +213,9 @@ std::string zstring::encode() const {
else if (ch == '\\') { else if (ch == '\\') {
strm << "\\\\"; strm << "\\\\";
} }
else if (ch >= 128) {
strm << "\\x" << std::hex << (unsigned)ch << std::dec;
}
else { else {
strm << (char)(ch); strm << (char)(ch);
} }

2
src/cmd_context/basic_cmds.cpp
View file

@ -502,7 +502,7 @@ public:
ctx.set_random_seed(to_unsigned(val)); ctx.set_random_seed(to_unsigned(val));
} }
else if (m_option == m_reproducible_resource_limit) { 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) { else if (m_option == m_verbosity) {
set_verbosity_level(to_unsigned(val)); set_verbosity_level(to_unsigned(val));

20
src/cmd_context/cmd_context.cpp
View file

@ -720,8 +720,8 @@ void cmd_context::init_manager_core(bool new_manager) {
} }
m_dt_eh = alloc(dt_eh, *this); m_dt_eh = alloc(dt_eh, *this);
m_pmanager->set_new_datatype_eh(m_dt_eh.get()); m_pmanager->set_new_datatype_eh(m_dt_eh.get());
if (!has_logic()) { if (!has_logic() && new_manager) {
TRACE("cmd_context", tout << "init manager\n";); TRACE("cmd_context", tout << "init manager " << m_logic << "\n";);
// add list type only if the logic is not specified. // add list type only if the logic is not specified.
// it prevents clashes with builtin types. // it prevents clashes with builtin types.
insert(pm().mk_plist_decl()); insert(pm().mk_plist_decl());
@ -759,6 +759,7 @@ void cmd_context::init_external_manager() {
} }
bool cmd_context::set_logic(symbol const & s) { bool cmd_context::set_logic(symbol const & s) {
TRACE("cmd_context", tout << s << "\n";);
if (has_logic()) if (has_logic())
throw cmd_exception("the logic has already been set"); throw cmd_exception("the logic has already been set");
if (has_manager() && m_main_ctx) if (has_manager() && m_main_ctx)
@ -1346,6 +1347,7 @@ void cmd_context::push() {
s.m_macros_stack_lim = m_macros_stack.size(); s.m_macros_stack_lim = m_macros_stack.size();
s.m_aux_pdecls_lim = m_aux_pdecls.size(); s.m_aux_pdecls_lim = m_aux_pdecls.size();
s.m_assertions_lim = m_assertions.size(); s.m_assertions_lim = m_assertions.size();
m().limit().push(m_params.rlimit());
if (m_solver) if (m_solver)
m_solver->push(); m_solver->push();
if (m_opt) if (m_opt)
@ -1369,9 +1371,10 @@ void cmd_context::restore_func_decls(unsigned old_sz) {
} }
void cmd_context::restore_psort_inst(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]; 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); m_psort_inst_stack.resize(old_sz);
} }
@ -1461,6 +1464,9 @@ void cmd_context::pop(unsigned n) {
restore_assertions(s.m_assertions_lim); restore_assertions(s.m_assertions_lim);
restore_psort_inst(s.m_psort_inst_stack_lim); restore_psort_inst(s.m_psort_inst_stack_lim);
m_scopes.shrink(new_lvl); 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);); TRACE("before_check_sat", dump_assertions(tout););
init_manager(); init_manager();
unsigned timeout = m_params.m_timeout; unsigned timeout = m_params.m_timeout;
unsigned rlimit = m_params.m_rlimit; unsigned rlimit = m_params.rlimit();
scoped_watch sw(*this); scoped_watch sw(*this);
lbool r; lbool r;
bool was_opt = false; 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) { 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 timeout = m_params.m_timeout;
unsigned rlimit = m_params.m_rlimit; unsigned rlimit = m_params.rlimit();
lbool r; lbool r;
m_check_sat_result = m_solver.get(); // solver itself stores the result. m_check_sat_result = m_solver.get(); // solver itself stores the result.
m_solver->set_progress_callback(this); 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) { if (m_owner.m_scopes.size() > 0) {
m_owner.pm().inc_ref(pd);
m_owner.m_psort_inst_stack.push_back(pd); m_owner.m_psort_inst_stack.push_back(pd);
} }
} }

2
src/cmd_context/context_params.cpp
View file

@ -135,7 +135,7 @@ void context_params::set(char const * param, char const * value) {
} }
void context_params::updt_params() { void context_params::updt_params() {
updt_params(gparams::get()); updt_params(gparams::get_ref());
} }
void context_params::updt_params(params_ref const & p) { void context_params::updt_params(params_ref const & p) {

5
src/cmd_context/context_params.h
View file

@ -27,6 +27,8 @@ class context_params {
void set_bool(bool & opt, char const * param, char const * value); void set_bool(bool & opt, char const * param, char const * value);
void set_uint(unsigned & opt, char const * param, char const * value); void set_uint(unsigned & opt, char const * param, char const * value);
unsigned m_rlimit;
public: public:
bool m_auto_config; bool m_auto_config;
bool m_proof; bool m_proof;
@ -42,10 +44,11 @@ public:
bool m_unsat_core; bool m_unsat_core;
bool m_smtlib2_compliant; // it must be here because it enable/disable the use of coercions in the ast_manager. 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_timeout;
unsigned m_rlimit;
unsigned rlimit() const { return m_rlimit; }
context_params(); context_params();
void set(char const * param, char const * value); void set(char const * param, char const * value);
void set_rlimit(unsigned lim) { m_rlimit = lim; }
void updt_params(); void updt_params();
void updt_params(params_ref const & p); void updt_params(params_ref const & p);
static void collect_param_descrs(param_descrs & d); static void collect_param_descrs(param_descrs & d);

2
src/cmd_context/extra_cmds/dbg_cmds.cpp
View file

@ -271,7 +271,7 @@ UNARY_CMD(elim_unused_vars_cmd, "dbg-elim-unused-vars", "<expr>", "eliminate unu
return; return;
} }
expr_ref r(ctx.m()); 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()); SASSERT(!is_quantifier(r) || !to_quantifier(r)->may_have_unused_vars());
ctx.display(ctx.regular_stream(), r); ctx.display(ctx.regular_stream(), r);
ctx.regular_stream() << std::endl; ctx.regular_stream() << std::endl;

4
src/cmd_context/tactic_cmds.cpp
View file

@ -207,7 +207,7 @@ public:
tref->set_logic(ctx.get_logic()); tref->set_logic(ctx.get_logic());
ast_manager & m = ctx.m(); ast_manager & m = ctx.m();
unsigned timeout = p.get_uint("timeout", ctx.params().m_timeout); 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; labels_vec labels;
goal_ref g = alloc(goal, m, ctx.produce_proofs(), ctx.produce_models(), ctx.produce_unsat_cores()); goal_ref g = alloc(goal, m, ctx.produce_proofs(), ctx.produce_models(), ctx.produce_unsat_cores());
assert_exprs_from(ctx, *g); assert_exprs_from(ctx, *g);
@ -323,7 +323,7 @@ public:
assert_exprs_from(ctx, *g); assert_exprs_from(ctx, *g);
unsigned timeout = p.get_uint("timeout", ctx.params().m_timeout); 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; goal_ref_buffer result_goals;

4
src/math/polynomial/polynomial.cpp
View file

@ -5479,7 +5479,7 @@ namespace polynomial {
} }
p_prime = derivative(p, x); p_prime = derivative(p, x);
resultant(p, p_prime, x, r); resultant(p, p_prime, x, r);
bool sign = (static_cast<uint64>(m) * static_cast<uint64>(m-1))%4 != 0; bool sign = (static_cast<uint64_t>(m) * static_cast<uint64_t>(m-1))%4 != 0;
TRACE("resultant", tout << "discriminant sign: " << sign << "\n";); TRACE("resultant", tout << "discriminant sign: " << sign << "\n";);
scoped_numeral lc(m_manager); scoped_numeral lc(m_manager);
if (const_coeff(p, x, m, lc)) { if (const_coeff(p, x, m, lc)) {
@ -6963,7 +6963,7 @@ namespace polynomial {
return m_imp->m().set_zp(p); 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); return m_imp->m().set_zp(p);
} }

4
src/math/polynomial/polynomial.h
View file

@ -218,7 +218,7 @@ namespace polynomial {
\brief Set manager as Z_p[X1, ..., Xn] \brief Set manager as Z_p[X1, ..., Xn]
*/ */
void set_zp(numeral const & p); void set_zp(numeral const & p);
void set_zp(uint64 p); void set_zp(uint64_t p);
/** /**
\brief Abstract event handler. \brief Abstract event handler.
@ -1043,7 +1043,7 @@ namespace polynomial {
scoped_numeral m_p; scoped_numeral m_p;
public: 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, 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(); } ~scoped_set_zp() { if (m_modular) m.set_zp(m_p); else m.set_z(); }
}; };
}; };

4
src/math/polynomial/upolynomial.h
View file

@ -153,7 +153,7 @@ namespace upolynomial {
\brief Set manager as Z_p[X] \brief Set manager as Z_p[X]
*/ */
void set_zp(numeral const & p) { m().set_zp(p); } 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(); void checkpoint();
@ -486,7 +486,7 @@ namespace upolynomial {
core_manager::scoped_numeral m_p; core_manager::scoped_numeral m_p;
public: 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, 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(); } ~scoped_set_zp() { if (m_modular) m.set_zp(m_p); else m.set_z(); }
}; };

6
src/math/polynomial/upolynomial_factorization.cpp
View file

@ -38,9 +38,9 @@ unsigned get_p_from_manager(zp_numeral_manager const & zp_nm) {
if (!nm.is_uint64(p)) { if (!nm.is_uint64(p)) {
throw upolynomial_exception("The prime number attempted in factorization is too big!"); 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<unsigned>(p_uint64); unsigned p_uint = static_cast<unsigned>(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!"); throw upolynomial_exception("The prime number attempted in factorization is too big!");
} }
return p_uint; 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) { while (trials < params.m_p_trials) {
upm.checkpoint(); upm.checkpoint();
// construct prime to check // construct prime to check
uint64 next_prime = prime_it.next(); uint64_t next_prime = prime_it.next();
if (next_prime > params.m_max_p) { if (next_prime > params.m_max_p) {
fs.push_back(f_pp, k); fs.push_back(f_pp, k);
return false; return false;

4
src/math/subpaving/subpaving.cpp
View file

@ -150,12 +150,12 @@ namespace subpaving {
void int2hwf(mpz const & a, hwf & o) { void int2hwf(mpz const & a, hwf & o) {
if (!m_qm.is_int64(a)) if (!m_qm.is_int64(a))
throw subpaving::exception(); throw subpaving::exception();
int64 val = m_qm.get_int64(a); int64_t val = m_qm.get_int64(a);
double dval = static_cast<double>(val); double dval = static_cast<double>(val);
m_ctx.nm().set(o, dval); m_ctx.nm().set(o, dval);
double _dval = m_ctx.nm().m().to_double(o); double _dval = m_ctx.nm().m().to_double(o);
// TODO check the following test // TODO check the following test
if (static_cast<int64>(_dval) != val) if (static_cast<int64_t>(_dval) != val)
throw subpaving::exception(); throw subpaving::exception();
} }

14
src/math/subpaving/subpaving_t.h
View file

@ -74,16 +74,16 @@ public:
}; };
protected: protected:
kind m_kind; kind m_kind;
uint64 m_timestamp; uint64_t m_timestamp;
public: public:
constraint(kind k):m_kind(k), m_timestamp(0) {} constraint(kind k):m_kind(k), m_timestamp(0) {}
kind get_kind() const { return m_kind; } kind get_kind() const { return m_kind; }
// Return the timestamp of the last propagation visit // 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 // 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_lower:1;
unsigned m_open:1; unsigned m_open:1;
unsigned m_mark:1; unsigned m_mark:1;
uint64 m_timestamp; uint64_t m_timestamp;
bound * m_prev; bound * m_prev;
justification m_jst; justification m_jst;
void set_timestamp(uint64 ts) { m_timestamp = ts; } void set_timestamp(uint64_t ts) { m_timestamp = ts; }
public: public:
var x() const { return static_cast<var>(m_x); } var x() const { return static_cast<var>(m_x); }
numeral const & value() const { return m_val; } numeral const & value() const { return m_val; }
numeral & value() { return m_val; } numeral & value() { return m_val; }
bool is_lower() const { return m_lower; } bool is_lower() const { return m_lower; }
bool is_open() const { return m_open; } 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; } bound * prev() const { return m_prev; }
justification jst() const { return m_jst; } justification jst() const { return m_jst; }
void display(std::ostream & out, numeral_manager & nm, display_var_proc const & proc = display_var_proc()); 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; id_gen m_node_id_gen;
uint64 m_timestamp; uint64_t m_timestamp;
node * m_root; node * m_root;
// m_leaf_head is the head of a doubly linked list of leaf nodes to be processed. // m_leaf_head is the head of a doubly linked list of leaf nodes to be processed.
node * m_leaf_head; node * m_leaf_head;

1
src/model/model_evaluator.cpp
View file

@ -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_decl* f = m_ar.get_as_array_func_decl(to_app(a));
func_interp* g = m_model.get_func_interp(f); func_interp* g = m_model.get_func_interp(f);
if (!g) return false;
unsigned sz = g->num_entries(); unsigned sz = g->num_entries();
unsigned arity = f->get_arity(); unsigned arity = f->get_arity();
unsigned base_sz = stores.size(); unsigned base_sz = stores.size();

20
src/muz/base/dl_context.cpp
View file

@ -45,7 +45,7 @@ namespace datalog {
protected: protected:
sort_ref m_sort; sort_ref m_sort;
bool m_limited_size; bool m_limited_size;
uint64 m_size; uint64_t m_size;
sort_domain(sort_kind k, context & ctx, sort * s) sort_domain(sort_kind k, context & ctx, sort * s)
: m_kind(k), m_sort(s, ctx.get_manager()) { : m_kind(k), m_sort(s, ctx.get_manager()) {
@ -103,15 +103,15 @@ namespace datalog {
}; };
class context::uint64_sort_domain : public sort_domain { class context::uint64_sort_domain : public sort_domain {
typedef map<uint64, finite_element, uint64_hash, default_eq<uint64> > el2num; typedef map<uint64_t, finite_element, uint64_hash, default_eq<uint64_t> > el2num;
typedef svector<uint64> num2el; typedef svector<uint64_t> num2el;
el2num m_el_numbers; el2num m_el_numbers;
num2el m_el_names; num2el m_el_names;
public: public:
uint64_sort_domain(context & ctx, sort * s) : sort_domain(SK_UINT64, ctx, s) {} 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 //we number symbols starting from zero, so table->size() is equal to the
//index of the symbol to be added next //index of the symbol to be added next
@ -368,14 +368,14 @@ namespace datalog {
return dom.get_number(sym); 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); sort_domain & dom0 = get_sort_domain(srt);
SASSERT(dom0.get_kind()==SK_UINT64); SASSERT(dom0.get_kind()==SK_UINT64);
uint64_sort_domain & dom = static_cast<uint64_sort_domain &>(dom0); uint64_sort_domain & dom = static_cast<uint64_sort_domain &>(dom0);
return dom.get_number(el); 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)) { if (has_sort_domain(srt)) {
SASSERT(num<=UINT_MAX); 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)) { if (!has_sort_domain(srt)) {
return false; return false;
} }
@ -394,18 +394,18 @@ namespace datalog {
return true; 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)) { if (get_decl_util().is_rule_sort(srt)) {
return 1; return 1;
} }
uint64 res; uint64_t res;
if (!try_get_sort_constant_count(srt, res)) { if (!try_get_sort_constant_count(srt, res)) {
const sort_size & sz = srt->get_num_elements(); const sort_size & sz = srt->get_num_elements();
if (sz.is_finite()) { if (sz.is_finite()) {
res = sz.size(); res = sz.size();
} }
else { else {
res = std::numeric_limits<uint64>::max(); res = std::numeric_limits<uint64_t>::max();
} }
} }
return res; return res;

10
src/muz/base/dl_context.h
View file

@ -61,7 +61,7 @@ namespace datalog {
class relation_manager; class relation_manager;
typedef sort * relation_sort; typedef sort * relation_sort;
typedef uint64 table_element; typedef uint64_t table_element;
typedef svector<table_element> table_fact; typedef svector<table_element> table_fact;
typedef app * relation_element; 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() ) \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. \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. \brief Assign names of variables used in the declaration of a predicate.

2
src/muz/base/dl_costs.cpp
View file

@ -141,7 +141,7 @@ namespace datalog {
} }
void cost_recorder::start(accounted_object * obj) { void cost_recorder::start(accounted_object * obj) {
uint64 curr_time = static_cast<uint64>(m_stopwatch->get_current_seconds()*1000); uint64_t curr_time = static_cast<uint64_t>(m_stopwatch->get_current_seconds()*1000);
if(m_obj) { if(m_obj) {
costs::time_type time_delta = static_cast<costs::time_type>(curr_time-m_last_time); costs::time_type time_delta = static_cast<costs::time_type>(curr_time-m_last_time);
costs & c = m_obj->get_current_costs(); costs & c = m_obj->get_current_costs();

2
src/muz/base/dl_costs.h
View file

@ -95,7 +95,7 @@ namespace datalog {
stopwatch * m_stopwatch; stopwatch * m_stopwatch;
bool m_running; bool m_running;
uint64 m_last_time; uint64_t m_last_time;
public: public:
cost_recorder(); cost_recorder();
~cost_recorder(); ~cost_recorder();

20
src/muz/base/dl_util.cpp
View file

@ -31,6 +31,10 @@ Revision History:
#include "muz/base/dl_rule.h" #include "muz/base/dl_rule.h"
#include "muz/base/dl_util.h" #include "muz/base/dl_util.h"
#include "util/stopwatch.h" #include "util/stopwatch.h"
#ifndef __STDC_FORMAT_MACROS
#define __STDC_FORMAT_MACROS
#endif
#include <inttypes.h>
namespace datalog { namespace datalog {
@ -165,7 +169,7 @@ namespace datalog {
} }
expr * arg = f->get_arg(i); expr * arg = f->get_arg(i);
uint64 sym_num; uint64_t sym_num;
SASSERT(is_app(arg)); SASSERT(is_app(arg));
VERIFY( ctx.get_decl_util().is_numeral_ext(to_app(arg), sym_num) ); VERIFY( ctx.get_decl_util().is_numeral_ext(to_app(arg), sym_num) );
relation_sort sort = pred_decl->get_domain(i); relation_sort sort = pred_decl->get_domain(i);
@ -626,11 +630,11 @@ namespace datalog {
return name.substr(ofs, count); 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 #if _WINDOWS
int converted = sscanf_s(s, "%I64u", &res); int converted = sscanf_s(s, "%" SCNu64, &res);
#else #else
int converted = sscanf(s, "%llu", &res); int converted = sscanf(s, "%" SCNu64, &res);
#endif #endif
if(converted==0) { if(converted==0) {
return false; return false;
@ -639,9 +643,9 @@ namespace datalog {
return true; return true;
} }
bool read_uint64(const char * & s, uint64 & res) { bool read_uint64(const char * & s, uint64_t & res) {
static const uint64 max_but_one_digit = ULLONG_MAX/10; static const uint64_t max_but_one_digit = ULLONG_MAX/10;
static const uint64 max_but_one_digit_safe = (ULLONG_MAX-9)/10; static const uint64_t max_but_one_digit_safe = (ULLONG_MAX-9)/10;
if(*s<'0' || *s>'9') { if(*s<'0' || *s>'9') {
return false; return false;
@ -669,7 +673,7 @@ namespace datalog {
return true; return true;
} }
std::string to_string(uint64 num) { std::string to_string(uint64_t num) {
std::stringstream stm; std::stringstream stm;
stm<<num; stm<<num;
return stm.str(); return stm.str();

6
src/muz/base/dl_util.h
View file

@ -602,8 +602,8 @@ namespace datalog {
\brief If it is possible to convert the beginning of \c s to uint64, \brief If it is possible to convert the beginning of \c s to uint64,
store the result of conversion and return true; otherwise return false. store the result of conversion and return true; otherwise return false.
*/ */
bool string_to_uint64(const char * s, uint64 & res); bool string_to_uint64(const char * s, uint64_t & res);
std::string to_string(uint64 num); std::string to_string(uint64_t num);
/** /**
\brief Read the sequence of decimal digits starting at \c s and interpret it as \brief Read the sequence of decimal digits starting at \c s and interpret it as
uint64. If successful, \c res will contain the read number and \c s will point uint64. If successful, \c res will contain the read number and \c s will point
@ -612,7 +612,7 @@ namespace datalog {
overflows, \c points to the character which caused the overflow and false is overflows, \c points to the character which caused the overflow and false is
returned. returned.
*/ */
bool read_uint64(const char * & s, uint64 & res); bool read_uint64(const char * & s, uint64_t & res);
}; };
#endif /* DL_UTIL_H_ */ #endif /* DL_UTIL_H_ */

4
src/muz/ddnf/ddnf.cpp
View file

@ -206,7 +206,7 @@ namespace datalog {
return find(t); return find(t);
} }
tbv* allocate(uint64 v, unsigned hi, unsigned lo) { tbv* allocate(uint64_t v, unsigned hi, unsigned lo) {
return m_tbv.allocate(v, hi, lo); return m_tbv.allocate(v, hi, lo);
} }
@ -437,7 +437,7 @@ namespace datalog {
} }
} }
tbv* allocate(unsigned num_bits, uint64 v, unsigned hi, unsigned lo) { tbv* allocate(unsigned num_bits, uint64_t v, unsigned hi, unsigned lo) {
return get(num_bits).allocate(v, hi, lo); return get(num_bits).allocate(v, hi, lo);
} }
void insert(unsigned num_bits, tbv const& t) { void insert(unsigned num_bits, tbv const& t) {

32
src/muz/fp/datalog_parser.cpp
View file

@ -979,7 +979,7 @@ protected:
if(!num.is_uint64()) { if(!num.is_uint64()) {
return unexpected(tok, "integer expected"); return unexpected(tok, "integer expected");
} }
uint64 int_num = num.get_uint64(); uint64_t int_num = num.get_uint64();
app * numeral = mk_symbol_const(int_num, s); app * numeral = mk_symbol_const(int_num, s);
args.push_back(numeral); args.push_back(numeral);
@ -1072,7 +1072,7 @@ protected:
} }
} }
sort * register_finite_sort(symbol name, uint64 domain_size, context::sort_kind k) { sort * register_finite_sort(symbol name, uint64_t domain_size, context::sort_kind k) {
if(m_sort_dict.contains(name.bare_str())) { if(m_sort_dict.contains(name.bare_str())) {
throw default_exception(default_exception::fmt(), "sort %s already declared", name.bare_str()); throw default_exception(default_exception::fmt(), "sort %s already declared", name.bare_str());
} }
@ -1102,7 +1102,7 @@ protected:
app* mk_const(symbol const& name, sort* s) { app* mk_const(symbol const& name, sort* s) {
app * res; app * res;
if(m_arith.is_int(s)) { if(m_arith.is_int(s)) {
uint64 val; uint64_t val;
if(!string_to_uint64(name.bare_str(), val)) { if(!string_to_uint64(name.bare_str(), val)) {
throw default_exception(default_exception::fmt(), "Invalid integer: \"%s\"", name.bare_str()); throw default_exception(default_exception::fmt(), "Invalid integer: \"%s\"", name.bare_str());
} }
@ -1117,7 +1117,7 @@ protected:
/** /**
\brief Make a constant for DK_SYMBOL sort out of an integer \brief Make a constant for DK_SYMBOL sort out of an integer
*/ */
app* mk_symbol_const(uint64 el, sort* s) { app* mk_symbol_const(uint64_t el, sort* s) {
app * res; app * res;
if(m_arith.is_int(s)) { if(m_arith.is_int(s)) {
res = m_arith.mk_numeral(rational(el, rational::ui64()), s); res = m_arith.mk_numeral(rational(el, rational::ui64()), s);
@ -1128,7 +1128,7 @@ protected:
} }
return res; return res;
} }
app* mk_const(uint64 el, sort* s) { app* mk_const(uint64_t el, sort* s) {
unsigned idx = m_context.get_constant_number(s, el); unsigned idx = m_context.get_constant_number(s, el);
app * res = m_decl_util.mk_numeral(idx, s); app * res = m_decl_util.mk_numeral(idx, s);
return res; return res;
@ -1137,7 +1137,7 @@ protected:
table_element mk_table_const(symbol const& name, sort* s) { table_element mk_table_const(symbol const& name, sort* s) {
return m_context.get_constant_number(s, name); return m_context.get_constant_number(s, name);
} }
table_element mk_table_const(uint64 el, sort* s) { table_element mk_table_const(uint64_t el, sort* s) {
return m_context.get_constant_number(s, el); return m_context.get_constant_number(s, el);
} }
}; };
@ -1169,9 +1169,9 @@ protected:
// ----------------------------------- // -----------------------------------
class wpa_parser_impl : public wpa_parser, dparser { class wpa_parser_impl : public wpa_parser, dparser {
typedef svector<uint64> uint64_vector; typedef svector<uint64_t> uint64_vector;
typedef hashtable<uint64, uint64_hash, default_eq<uint64> > uint64_set; typedef hashtable<uint64_t, uint64_hash, default_eq<uint64_t> > uint64_set;
typedef map<uint64, symbol, uint64_hash, default_eq<uint64> > num2sym; typedef map<uint64_t, symbol, uint64_hash, default_eq<uint64_t> > num2sym;
typedef map<symbol, uint64_set*, symbol_hash_proc, symbol_eq_proc> sym2nums; typedef map<symbol, uint64_set*, symbol_hash_proc, symbol_eq_proc> sym2nums;
num2sym m_number_names; num2sym m_number_names;
@ -1261,7 +1261,7 @@ private:
return true; 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()) { if(s==m_bool_sort.get() || s==m_short_sort.get()) {
res = mk_table_const(num, s); res = mk_table_const(num, s);
return true; return true;
@ -1332,7 +1332,7 @@ private:
if(*ptr==0) { if(*ptr==0) {
break; break;
} }
uint64 num; uint64_t num;
if(!read_uint64(ptr, num)) { if(!read_uint64(ptr, num)) {
throw default_exception(default_exception::fmt(), "number expected on line %d in file %s", throw default_exception(default_exception::fmt(), "number expected on line %d in file %s",
m_current_line, m_current_file.c_str()); m_current_line, m_current_file.c_str());
@ -1389,7 +1389,7 @@ private:
bool fact_fail = false; bool fact_fail = false;
fact.reset(); fact.reset();
for(unsigned i=0;i<pred_arity; i++) { for(unsigned i=0;i<pred_arity; i++) {
uint64 const_num = args[i]; uint64_t const_num = args[i];
table_element c; table_element c;
if(!inp_num_to_element(arg_sorts[i], const_num, c)) { if(!inp_num_to_element(arg_sorts[i], const_num, c)) {
fact_fail = true; fact_fail = true;
@ -1415,7 +1415,7 @@ private:
symbol sort_name = sit->m_key; symbol sort_name = sit->m_key;
uint64_set & sort_content = *sit->m_value; uint64_set & sort_content = *sit->m_value;
//the +1 is for a zero element which happens to appear in the problem files //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; // sort * s;
if(!m_use_map_names) { if(!m_use_map_names) {
/* s = */ register_finite_sort(sort_name, domain_size, context::SK_UINT64); /* 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 cit = sort_content.begin();
uint64_set::iterator cend = sort_content.end(); uint64_set::iterator cend = sort_content.end();
for(; cit!=cend; ++cit) { for(; cit!=cend; ++cit) {
uint64 const_num = *cit; uint64_t const_num = *cit;
inp_num_to_element(s, const_num); inp_num_to_element(s, const_num);
} }
*/ */
@ -1443,7 +1443,7 @@ private:
*ptr=0; *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); cut_off_comment(full_line);
if(full_line[0]==0) { if(full_line[0]==0) {
return false; return false;
@ -1515,7 +1515,7 @@ private:
m_current_line++; m_current_line++;
char * full_line = rdr.get_line(); char * full_line = rdr.get_line();
uint64 num; uint64_t num;
symbol el_name; symbol el_name;
if(!parse_map_line(full_line, num, el_name)) { if(!parse_map_line(full_line, num, el_name)) {

2
src/muz/rel/dl_base.cpp
View file

@ -384,7 +384,7 @@ namespace datalog {
VERIFY(sig.first_functional() == 1); VERIFY(sig.first_functional() == 1);
uint64 upper_bound = get_signature()[0]; uint64_t upper_bound = get_signature()[0];
bool empty_table = empty(); bool empty_table = empty();
if (upper_bound > (1 << 18)) { if (upper_bound > (1 << 18)) {

2
src/muz/rel/dl_base.h
View file

@ -832,7 +832,7 @@ namespace datalog {
class table_plugin; class table_plugin;
class table_base; class table_base;
typedef uint64 table_sort; typedef uint64_t table_sort;
typedef svector<table_sort> table_signature_base0; typedef svector<table_sort> table_signature_base0;
typedef uint64_hash table_sort_hash; typedef uint64_hash table_sort_hash;

10
src/muz/rel/dl_relation_manager.cpp
View file

@ -448,7 +448,7 @@ namespace datalog {
} }
std::string relation_manager::to_nice_string(const relation_element & el) const { std::string relation_manager::to_nice_string(const relation_element & el) const {
uint64 val; uint64_t val;
std::stringstream stm; std::stringstream stm;
if(get_context().get_decl_util().is_numeral_ext(el, val)) { if(get_context().get_decl_util().is_numeral_ext(el, val)) {
stm << 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::string relation_manager::to_nice_string(const relation_sort & s, const relation_element & el) const {
std::stringstream stm; std::stringstream stm;
uint64 val; uint64_t val;
if(get_context().get_decl_util().is_numeral_ext(el, val)) { if(get_context().get_decl_util().is_numeral_ext(el, val)) {
get_context().print_constant_name(s, val, stm); get_context().print_constant_name(s, val, stm);
} }
@ -1339,9 +1339,9 @@ namespace datalog {
class relation_manager::default_table_filter_not_equal_fn class relation_manager::default_table_filter_not_equal_fn
: public table_mutator_fn, auxiliary_table_filter_fn { : public table_mutator_fn, auxiliary_table_filter_fn {
unsigned m_column; unsigned m_column;
uint64 m_value; uint64_t m_value;
public: 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_column(column),
m_value(value) { m_value(value) {
} }
@ -1372,7 +1372,7 @@ namespace datalog {
return nullptr; return nullptr;
} }
dl_decl_util decl_util(m); dl_decl_util decl_util(m);
uint64 value = 0; uint64_t value = 0;
if (!decl_util.is_numeral_ext(y, value)) { if (!decl_util.is_numeral_ext(y, value)) {
return nullptr; return nullptr;
} }

4
src/muz/rel/dl_sparse_table.cpp
View file

@ -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); SASSERT(dom_size>0);
unsigned length = 0; unsigned length = 0;
@ -128,7 +128,7 @@ namespace datalog {
unsigned sig_sz = sig.size(); unsigned sig_sz = sig.size();
unsigned first_functional = sig_sz-m_functional_col_cnt; unsigned first_functional = sig_sz-m_functional_col_cnt;
for (unsigned i=0; i<sig_sz; i++) { for (unsigned i=0; i<sig_sz; i++) {
uint64 dom_size = sig[i]; uint64_t dom_size = sig[i];
unsigned length = get_domain_length(dom_size); unsigned length = get_domain_length(dom_size);
SASSERT(length>0); SASSERT(length>0);
SASSERT(length<=64); SASSERT(length<=64);

18
src/muz/rel/dl_sparse_table.h
View file

@ -153,7 +153,7 @@ namespace datalog {
variable. Otherwise \c m_reserve==NO_RESERVE. 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 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 m_data;
storage_indexer m_data_indexer; storage_indexer m_data_indexer;
@ -290,10 +290,10 @@ namespace datalog {
//the following two operations allow breaking of the object invariant! //the following two operations allow breaking of the object invariant!
void resize_data(size_t sz) { void resize_data(size_t sz) {
m_data_size = 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"); 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) { bool insert_offset(store_offset ofs) {
@ -321,8 +321,8 @@ namespace datalog {
class column_info { class column_info {
unsigned m_big_offset; unsigned m_big_offset;
unsigned m_small_offset; unsigned m_small_offset;
uint64 m_mask; uint64_t m_mask;
uint64 m_write_mask; uint64_t m_write_mask;
public: public:
unsigned m_offset; //!< in bits unsigned m_offset; //!< in bits
unsigned m_length; //!< in bits unsigned m_length; //!< in bits
@ -330,7 +330,7 @@ namespace datalog {
column_info(unsigned offset, unsigned length) \ column_info(unsigned offset, unsigned length) \
: m_big_offset(offset/8), : m_big_offset(offset/8),
m_small_offset(offset%8), m_small_offset(offset%8),
m_mask( length==64 ? ULLONG_MAX : (static_cast<uint64>(1)<<length)-1 ), m_mask( length==64 ? ULLONG_MAX : (static_cast<uint64_t>(1)<<length)-1 ),
m_write_mask( ~(m_mask<<m_small_offset) ), m_write_mask( ~(m_mask<<m_small_offset) ),
m_offset(offset), m_offset(offset),
m_length(length) { m_length(length) {
@ -338,15 +338,15 @@ namespace datalog {
SASSERT(length+m_small_offset<=64); SASSERT(length+m_small_offset<=64);
} }
table_element get(const char * rec) const { table_element get(const char * rec) const {
const uint64 * ptr = reinterpret_cast<const uint64*>(rec+m_big_offset); const uint64_t * ptr = reinterpret_cast<const uint64_t*>(rec+m_big_offset);
uint64 res = *ptr; uint64_t res = *ptr;
res>>=m_small_offset; res>>=m_small_offset;
res&=m_mask; res&=m_mask;
return res; return res;
} }
void set(char * rec, table_element val) const { void set(char * rec, table_element val) const {
SASSERT( (val&~m_mask)==0 ); //the value fits into the column SASSERT( (val&~m_mask)==0 ); //the value fits into the column
uint64 * ptr = reinterpret_cast<uint64*>(rec+m_big_offset); uint64_t * ptr = reinterpret_cast<uint64_t*>(rec+m_big_offset);
*ptr&=m_write_mask; *ptr&=m_write_mask;
*ptr|=val<<m_small_offset; *ptr|=val<<m_small_offset;
} }

4
src/muz/rel/doc.cpp
View file

@ -62,13 +62,13 @@ doc* doc_manager::allocate(tbv* t) {
doc* doc_manager::allocate(tbv const& src) { doc* doc_manager::allocate(tbv const& src) {
return allocate(m.allocate(src)); return allocate(m.allocate(src));
} }
doc* doc_manager::allocate(uint64 n) { doc* doc_manager::allocate(uint64_t n) {
return allocate(m.allocate(n)); return allocate(m.allocate(n));
} }
doc* doc_manager::allocate(rational const& r) { doc* doc_manager::allocate(rational const& r) {
return allocate(m.allocate(r)); return allocate(m.allocate(r));
} }
doc* doc_manager::allocate(uint64 n, unsigned hi, unsigned lo) { doc* doc_manager::allocate(uint64_t n, unsigned hi, unsigned lo) {
return allocate(m.allocate(n, hi, lo)); return allocate(m.allocate(n, hi, lo));
} }
doc* doc_manager::allocate(doc const& src, unsigned const* permutation) { doc* doc_manager::allocate(doc const& src, unsigned const* permutation) {

4
src/muz/rel/doc.h
View file

@ -61,9 +61,9 @@ public:
doc* allocate(doc const& src); doc* allocate(doc const& src);
doc* allocate(tbv const& src); doc* allocate(tbv const& src);
doc* allocate(tbv * src); doc* allocate(tbv * src);
doc* allocate(uint64 n); doc* allocate(uint64_t n);
doc* allocate(rational const& r); doc* allocate(rational const& r);
doc* allocate(uint64 n, unsigned hi, unsigned lo); doc* allocate(uint64_t n, unsigned hi, unsigned lo);
doc* allocate(doc const& src, unsigned const* permutation); doc* allocate(doc const& src, unsigned const* permutation);
void deallocate(doc* src); void deallocate(doc* src);
void copy(doc& dst, doc const& src); void copy(doc& dst, doc const& src);

2
src/muz/rel/rel_context.cpp
View file

@ -215,7 +215,7 @@ namespace datalog {
SASSERT(remaining_time_limit>restart_time); SASSERT(remaining_time_limit>restart_time);
remaining_time_limit -= restart_time; remaining_time_limit -= restart_time;
} }
uint64 new_restart_time = static_cast<uint64>(restart_time)*m_context.initial_restart_timeout(); uint64_t new_restart_time = static_cast<uint64_t>(restart_time)*m_context.initial_restart_timeout();
if (new_restart_time > UINT_MAX) { if (new_restart_time > UINT_MAX) {
restart_time = UINT_MAX; restart_time = UINT_MAX;
} }

6
src/muz/rel/tbv.cpp
View file

@ -72,7 +72,7 @@ tbv* tbv_manager::allocate(tbv const& bv) {
copy(*r, bv); copy(*r, bv);
return r; return r;
} }
tbv* tbv_manager::allocate(uint64 val) { tbv* tbv_manager::allocate(uint64_t val) {
tbv* v = allocate0(); tbv* v = allocate0();
for (unsigned bit = std::min(64u, num_tbits()); bit-- > 0;) { for (unsigned bit = std::min(64u, num_tbits()); bit-- > 0;) {
if (val & (1ULL << bit)) { if (val & (1ULL << bit)) {
@ -84,7 +84,7 @@ tbv* tbv_manager::allocate(uint64 val) {
return v; 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(); tbv* v = allocateX();
SASSERT(64 >= num_tbits() && num_tbits() > hi && hi >= lo); SASSERT(64 >= num_tbits() && num_tbits() > hi && hi >= lo);
set(*v, val, 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()); SASSERT(lo <= hi && hi < num_tbits());
for (unsigned i = 0; i < hi - lo + 1; ++i) { for (unsigned i = 0; i < hi - lo + 1; ++i) {
set(dst, lo + i, (val & (1ULL << i))?BIT_1:BIT_0); set(dst, lo + i, (val & (1ULL << i))?BIT_1:BIT_0);

6
src/muz/rel/tbv.h
View file

@ -51,9 +51,9 @@ public:
tbv* allocate0(); tbv* allocate0();
tbv* allocateX(); tbv* allocateX();
tbv* allocate(tbv const& bv); tbv* allocate(tbv const& bv);
tbv* allocate(uint64 n); tbv* allocate(uint64_t n);
tbv* allocate(rational const& r); 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(tbv const& bv, unsigned const* permutation);
tbv* allocate(char const* bv); tbv* allocate(char const* bv);
@ -80,7 +80,7 @@ public:
std::ostream& display(std::ostream& out, tbv const& b, unsigned hi, unsigned lo) const; std::ostream& display(std::ostream& out, tbv const& b, unsigned hi, unsigned lo) const;
tbv* project(bit_vector const& to_delete, tbv const& src); tbv* project(bit_vector const& to_delete, tbv const& src);
bool is_well_formed(tbv const& b) const; // - does not contain BIT_z; 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, rational const& r, unsigned hi, unsigned lo);
void set(tbv& dst, tbv const& other, unsigned hi, unsigned lo); void set(tbv& dst, tbv const& other, unsigned hi, unsigned lo);
void set(tbv& dst, unsigned index, tbit value); void set(tbv& dst, unsigned index, tbit value);

4
src/muz/rel/udoc_relation.cpp
View file

@ -261,7 +261,7 @@ namespace datalog {
num_bits = 1; num_bits = 1;
return true; return true;
} }
uint64 n, sz; uint64_t n, sz;
ast_manager& m = get_ast_manager(); ast_manager& m = get_ast_manager();
if (dl.is_numeral(e, n) && dl.try_get_size(m.get_sort(e), sz)) { if (dl.is_numeral(e, n) && dl.try_get_size(m.get_sort(e), sz)) {
num_bits = 0; num_bits = 0;
@ -277,7 +277,7 @@ namespace datalog {
return bv.get_bv_size(s); return bv.get_bv_size(s);
if (m.is_bool(s)) if (m.is_bool(s))
return 1; return 1;
uint64 sz; uint64_t sz;
if (dl.try_get_size(s, sz)) { if (dl.try_get_size(s, sz)) {
while (sz > 0) ++num_bits, sz /= 2; while (sz > 0) ++num_bits, sz /= 2;
return num_bits; return num_bits;

6
src/opt/opt_context.cpp
View file

@ -265,6 +265,9 @@ namespace opt {
normalize(); normalize();
internalize(); internalize();
update_solver(); update_solver();
if (contains_quantifiers()) {
warning_msg("optimization with quantified constraints is not supported");
}
#if 0 #if 0
if (is_qsat_opt()) { if (is_qsat_opt()) {
return run_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 && committed) m_optsmt.commit_assignment(index);
if (result == l_true && m_optsmt.is_unbounded(index, is_max) && contains_quantifiers()) { if (result == l_true && m_optsmt.is_unbounded(index, is_max) && contains_quantifiers()) {
throw default_exception("unbounded objectives on quantified constraints is not supported"); throw default_exception("unbounded objectives on quantified constraints is not supported");
result = l_undef;
} }
return result; return result;
} }
@ -1525,7 +1527,7 @@ namespace opt {
} }
void context::validate_model() { 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); expr_ref_vector fmls(m);
get_hard_constraints(fmls); get_hard_constraints(fmls);
expr_ref tmp(m); expr_ref tmp(m);

6
src/opt/wmax.cpp
View file

@ -84,6 +84,9 @@ namespace opt {
if (m.canceled()) { if (m.canceled()) {
is_sat = l_undef; is_sat = l_undef;
} }
if (is_sat == l_undef) {
break;
}
if (is_sat == l_false) { if (is_sat == l_false) {
TRACE("opt", tout << "Unsat\n";); TRACE("opt", tout << "Unsat\n";);
break; break;
@ -97,9 +100,6 @@ namespace opt {
//DEBUG_CODE(verify_cores(cores);); //DEBUG_CODE(verify_cores(cores););
s().assert_expr(fml); s().assert_expr(fml);
} }
else {
//DEBUG_CODE(verify_cores(cores););
}
update_cores(wth(), cores); update_cores(wth(), cores);
wth().init_min_cost(m_upper - m_lower); wth().init_min_cost(m_upper - m_lower);
trace_bounds("wmax"); trace_bounds("wmax");

3
src/parsers/smt2/smt2parser.cpp
View file

@ -951,8 +951,9 @@ namespace smt2 {
check_duplicate(d, line, pos); check_duplicate(d, line, pos);
d->commit(pm()); d->commit(pm());
check_rparen_next("invalid end of datatype declaration, ')' expected"); check_rparen("invalid end of datatype declaration, ')' expected");
m_ctx.print_success(); m_ctx.print_success();
next();
} }

2
src/parsers/util/pattern_validation.cpp
View file

@ -48,7 +48,7 @@ struct pattern_validation_functor {
bool is_forbidden(func_decl const * decl) { bool is_forbidden(func_decl const * decl) {
family_id fid = decl->get_family_id(); 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; return true;
if (fid == m_lfid) if (fid == m_lfid)
return true; return true;

8
src/qe/qe_dl_plugin.cpp
View file

@ -70,7 +70,7 @@ namespace qe {
return false; return false;
} }
eq_atoms& eqs = get_eqs(x.x(), fml); eq_atoms& eqs = get_eqs(x.x(), fml);
uint64 domain_size; uint64_t domain_size;
if (is_small_domain(x, eqs, domain_size)) { if (is_small_domain(x, eqs, domain_size)) {
num_branches = rational(domain_size, rational::ui64()); num_branches = rational(domain_size, rational::ui64());
} }
@ -84,7 +84,7 @@ namespace qe {
SASSERT(v.is_unsigned()); SASSERT(v.is_unsigned());
eq_atoms& eqs = get_eqs(x.x(), fml); eq_atoms& eqs = get_eqs(x.x(), fml);
unsigned uv = v.get_unsigned(); unsigned uv = v.get_unsigned();
uint64 domain_size; uint64_t domain_size;
if (is_small_domain(x, eqs, domain_size)) { if (is_small_domain(x, eqs, domain_size)) {
SASSERT(v < rational(domain_size, rational::ui64())); SASSERT(v < rational(domain_size, rational::ui64()));
assign_small_domain(x, eqs, uv); assign_small_domain(x, eqs, uv);
@ -98,7 +98,7 @@ namespace qe {
SASSERT(v.is_unsigned()); SASSERT(v.is_unsigned());
eq_atoms& eqs = get_eqs(x.x(), fml); eq_atoms& eqs = get_eqs(x.x(), fml);
unsigned uv = v.get_unsigned(); unsigned uv = v.get_unsigned();
uint64 domain_size; uint64_t domain_size;
if (is_small_domain(x, eqs, domain_size)) { if (is_small_domain(x, eqs, domain_size)) {
SASSERT(uv < domain_size); SASSERT(uv < domain_size);
subst_small_domain(x, eqs, uv, fml); subst_small_domain(x, eqs, uv, fml);
@ -115,7 +115,7 @@ namespace qe {
private: 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)); VERIFY(m_util.try_get_size(m.get_sort(x.x()), domain_size));
return domain_size < eqs.num_eqs() + eqs.num_neqs(); return domain_size < eqs.num_eqs() + eqs.num_neqs();
} }

70
src/sat/ba_solver.cpp
View file

@ -1020,14 +1020,14 @@ namespace sat {
SASSERT(v != null_bool_var); SASSERT(v != null_bool_var);
m_coeffs.reserve(v + 1, 0); m_coeffs.reserve(v + 1, 0);
int64 coeff0 = m_coeffs[v]; int64_t coeff0 = m_coeffs[v];
if (coeff0 == 0) { if (coeff0 == 0) {
m_active_vars.push_back(v); m_active_vars.push_back(v);
} }
int64 loffset = static_cast<int64>(offset); int64_t loffset = static_cast<int64_t>(offset);
int64 inc = l.sign() ? -loffset : loffset; int64_t inc = l.sign() ? -loffset : loffset;
int64 coeff1 = inc + coeff0; int64_t coeff1 = inc + coeff0;
m_coeffs[v] = coeff1; m_coeffs[v] = coeff1;
if (coeff1 > INT_MAX || coeff1 < INT_MIN) { if (coeff1 > INT_MAX || coeff1 < INT_MIN) {
m_overflow = true; m_overflow = true;
@ -1040,7 +1040,7 @@ namespace sat {
else if (coeff0 < 0 && inc > 0) { else if (coeff0 < 0 && inc > 0) {
inc_bound(coeff0 - std::min(0LL, coeff1)); inc_bound(coeff0 - std::min(0LL, coeff1));
} }
int64 lbound = static_cast<int64>(m_bound); int64_t lbound = static_cast<int64_t>(m_bound);
// reduce coefficient to be no larger than bound. // reduce coefficient to be no larger than bound.
if (coeff1 > lbound) { 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); return m_coeffs.get(v, 0);
} }
unsigned ba_solver::get_abs_coeff(bool_var v) const { 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) { if (c < INT_MIN+1 || c > UINT_MAX) {
m_overflow = true; m_overflow = true;
return UINT_MAX; return UINT_MAX;
@ -1065,7 +1065,7 @@ namespace sat {
} }
int ba_solver::get_int_coeff(bool_var v) const { 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) { if (c < INT_MIN || c > INT_MAX) {
m_overflow = true; m_overflow = true;
return 0; return 0;
@ -1073,12 +1073,12 @@ namespace sat {
return static_cast<int>(c); return static_cast<int>(c);
} }
void ba_solver::inc_bound(int64 i) { void ba_solver::inc_bound(int64_t i) {
if (i < INT_MIN || i > INT_MAX) { if (i < INT_MIN || i > INT_MAX) {
m_overflow = true; m_overflow = true;
return; return;
} }
int64 new_bound = m_bound; int64_t new_bound = m_bound;
new_bound += i; new_bound += i;
if (new_bound < 0) { if (new_bound < 0) {
m_overflow = true; m_overflow = true;
@ -1196,7 +1196,7 @@ namespace sat {
switch (cnstr.tag()) { switch (cnstr.tag()) {
case card_t: { case card_t: {
card& c = cnstr.to_card(); card& c = cnstr.to_card();
inc_bound(static_cast<int64>(offset) * c.k()); inc_bound(static_cast<int64_t>(offset) * c.k());
process_card(c, offset); process_card(c, offset);
break; break;
} }
@ -1269,7 +1269,7 @@ namespace sat {
js = s().m_justification[v]; js = s().m_justification[v];
offset = get_abs_coeff(v); offset = get_abs_coeff(v);
if (offset > m_bound) { if (offset > m_bound) {
int64 bound64 = static_cast<int64>(m_bound); int64_t bound64 = static_cast<int64_t>(m_bound);
m_coeffs[v] = (get_coeff(v) < 0) ? -bound64 : bound64; m_coeffs[v] = (get_coeff(v) < 0) ? -bound64 : bound64;
offset = m_bound; offset = m_bound;
DEBUG_CODE(active2pb(m_A);); DEBUG_CODE(active2pb(m_A););
@ -1323,8 +1323,8 @@ namespace sat {
} }
IF_VERBOSE(0, IF_VERBOSE(0,
active2pb(m_A); active2pb(m_A);
uint64 c = 0; uint64_t c = 0;
for (uint64 c1 : m_A.m_coeffs) c += c1; for (uint64_t c1 : m_A.m_coeffs) c += c1;
verbose_stream() << "sum of coefficients: " << c << "\n"; verbose_stream() << "sum of coefficients: " << c << "\n";
display(verbose_stream(), m_A, true); display(verbose_stream(), m_A, true);
verbose_stream() << "conflicting literal: " << s().m_not_l << "\n";); verbose_stream() << "conflicting literal: " << s().m_not_l << "\n";);
@ -1347,18 +1347,18 @@ namespace sat {
bool adjusted = false; bool adjusted = false;
adjust_conflict_level: adjust_conflict_level:
int64 bound64 = m_bound; int64_t bound64 = m_bound;
int64 slack = -bound64; int64_t slack = -bound64;
for (bool_var v : m_active_vars) { for (bool_var v : m_active_vars) {
slack += get_abs_coeff(v); slack += get_abs_coeff(v);
} }
m_lemma.reset(); m_lemma.reset();
m_lemma.push_back(null_literal); m_lemma.push_back(null_literal);
unsigned num_skipped = 0; 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) { for (unsigned i = 0; 0 <= slack && i < m_active_vars.size(); ++i) {
bool_var v = m_active_vars[i]; bool_var v = m_active_vars[i];
int64 coeff = get_coeff(v); int64_t coeff = get_coeff(v);
lbool val = value(v); lbool val = value(v);
bool is_true = val == l_true; bool is_true = val == l_true;
bool append = coeff != 0 && val != l_undef && (coeff < 0 == is_true); bool append = coeff != 0 && val != l_undef && (coeff < 0 == is_true);
@ -1434,7 +1434,7 @@ namespace sat {
continue; continue;
} }
if (m_bound < coeff) { if (m_bound < coeff) {
int64 bound64 = m_bound; int64_t bound64 = m_bound;
if (get_coeff(v) > 0) { if (get_coeff(v) > 0) {
m_coeffs[v] = bound64; m_coeffs[v] = bound64;
} }
@ -1474,7 +1474,7 @@ namespace sat {
inc_coeff(c[i], offset); inc_coeff(c[i], offset);
} }
if (lit != null_literal) { if (lit != null_literal) {
uint64 offset1 = static_cast<uint64>(offset) * c.k(); uint64_t offset1 = static_cast<uint64_t>(offset) * c.k();
if (offset1 > UINT_MAX) { if (offset1 > UINT_MAX) {
m_overflow = true; m_overflow = true;
} }
@ -3753,12 +3753,12 @@ namespace sat {
} }
bool ba_solver::validate_lemma() { bool ba_solver::validate_lemma() {
int64 bound64 = m_bound; int64_t bound64 = m_bound;
int64 val = -bound64; int64_t val = -bound64;
reset_active_var_set(); reset_active_var_set();
for (bool_var v : m_active_vars) { for (bool_var v : m_active_vars) {
if (m_active_var_set.contains(v)) continue; if (m_active_var_set.contains(v)) continue;
int64 coeff = get_coeff(v); int64_t coeff = get_coeff(v);
if (coeff == 0) continue; if (coeff == 0) continue;
m_active_var_set.insert(v); m_active_var_set.insert(v);
literal lit(v, false); literal lit(v, false);
@ -3782,7 +3782,7 @@ namespace sat {
p.reset(m_bound); p.reset(m_bound);
for (bool_var v : m_active_vars) { for (bool_var v : m_active_vars) {
if (m_active_var_set.contains(v)) continue; if (m_active_var_set.contains(v)) continue;
int64 coeff = get_coeff(v); int64_t coeff = get_coeff(v);
if (coeff == 0) continue; if (coeff == 0) continue;
m_active_var_set.insert(v); m_active_var_set.insert(v);
literal lit(v, coeff < 0); literal lit(v, coeff < 0);
@ -3794,7 +3794,7 @@ namespace sat {
ba_solver::constraint* ba_solver::active2constraint() { ba_solver::constraint* ba_solver::active2constraint() {
reset_active_var_set(); reset_active_var_set();
m_wlits.reset(); m_wlits.reset();
uint64 sum = 0; uint64_t sum = 0;
if (m_bound == 1) return 0; if (m_bound == 1) return 0;
if (m_overflow) return 0; if (m_overflow) return 0;
@ -3855,7 +3855,7 @@ namespace sat {
} }
std::sort(m_wlits.begin(), m_wlits.end(), compare_wlit()); std::sort(m_wlits.begin(), m_wlits.end(), compare_wlit());
unsigned k = 0; unsigned k = 0;
uint64 sum = 0, sum0 = 0; uint64_t sum = 0, sum0 = 0;
for (wliteral wl : m_wlits) { for (wliteral wl : m_wlits) {
if (sum >= m_bound) break; if (sum >= m_bound) break;
sum0 = sum; sum0 = sum;
@ -3986,15 +3986,15 @@ namespace sat {
bool ba_solver::validate_resolvent() { bool ba_solver::validate_resolvent() {
return true; return true;
u_map<uint64> coeffs; u_map<uint64_t> coeffs;
uint64 k = m_A.m_k + m_B.m_k; uint64_t k = m_A.m_k + m_B.m_k;
for (unsigned i = 0; i < m_A.m_lits.size(); ++i) { 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())); SASSERT(!coeffs.contains(m_A.m_lits[i].index()));
coeffs.insert(m_A.m_lits[i].index(), coeff); coeffs.insert(m_A.m_lits[i].index(), coeff);
} }
for (unsigned i = 0; i < m_B.m_lits.size(); ++i) { 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]; literal lit = m_B.m_lits[i];
if (coeffs.find((~lit).index(), coeff2)) { if (coeffs.find((~lit).index(), coeff2)) {
if (coeff1 == coeff2) { if (coeff1 == coeff2) {
@ -4022,7 +4022,7 @@ namespace sat {
// C is above the sum of A and B // C is above the sum of A and B
for (unsigned i = 0; i < m_C.m_lits.size(); ++i) { for (unsigned i = 0; i < m_C.m_lits.size(); ++i) {
literal lit = m_C.m_lits[i]; literal lit = m_C.m_lits[i];
uint64 coeff; uint64_t coeff;
if (coeffs.find(lit.index(), coeff)) { if (coeffs.find(lit.index(), coeff)) {
if (coeff > m_C.m_coeffs[i] && m_C.m_coeffs[i] < m_C.m_k) { if (coeff > m_C.m_coeffs[i] && m_C.m_coeffs[i] < m_C.m_k) {
goto violated; 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 \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<bool_var>& translation, ineq& a, ineq& b) { literal ba_solver::translate_to_sat(solver& s, u_map<bool_var>& translation, ineq& a, ineq& b) {
uint64 k0 = a.m_k; uint64_t k0 = a.m_k;
literal_vector lits; literal_vector lits;
for (unsigned k = 1; k < a.m_k - 1; ++k) { for (unsigned k = 1; k < a.m_k - 1; ++k) {
a.m_k = k; b.m_k = k0 - 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 { ba_solver::ineq ba_solver::negate(ineq const& a) const {
ineq result; ineq result;
uint64 sum = 0; uint64_t sum = 0;
for (unsigned i = 0; i < a.m_lits.size(); ++i) { for (unsigned i = 0; i < a.m_lits.size(); ++i) {
result.push(~a.m_lits[i], a.m_coeffs[i]); result.push(~a.m_lits[i], a.m_coeffs[i]);
sum += a.m_coeffs[i]; sum += a.m_coeffs[i];
@ -4170,9 +4170,9 @@ namespace sat {
return false; return false;
} }
} }
uint64 value = 0; uint64_t value = 0;
for (unsigned i = 0; i < p.m_lits.size(); ++i) { 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])) { if (!lits.contains(p.m_lits[i])) {
value += coeff; value += coeff;
} }

14
src/sat/ba_solver.h
View file

@ -205,11 +205,11 @@ namespace sat {
struct ineq { struct ineq {
literal_vector m_lits; literal_vector m_lits;
svector<uint64> m_coeffs; svector<uint64_t> m_coeffs;
uint64 m_k; uint64_t m_k;
ineq(): m_k(0) {} ineq(): m_k(0) {}
void reset(uint64 k) { m_lits.reset(); m_coeffs.reset(); m_k = k; } void reset(uint64_t 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 push(literal l, uint64_t c) { m_lits.push_back(l); m_coeffs.push_back(c); }
}; };
solver* m_solver; solver* m_solver;
@ -229,7 +229,7 @@ namespace sat {
// conflict resolution // conflict resolution
unsigned m_num_marks; unsigned m_num_marks;
unsigned m_conflict_lvl; unsigned m_conflict_lvl;
svector<int64> m_coeffs; svector<int64_t> m_coeffs;
svector<bool_var> m_active_vars; svector<bool_var> m_active_vars;
unsigned m_bound; unsigned m_bound;
tracked_uint_set m_active_var_set; tracked_uint_set m_active_var_set;
@ -426,11 +426,11 @@ namespace sat {
void reset_active_var_set(); void reset_active_var_set();
void normalize_active_coeffs(); void normalize_active_coeffs();
void inc_coeff(literal l, unsigned offset); 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; unsigned get_abs_coeff(bool_var v) const;
int get_int_coeff(bool_var v) const; int get_int_coeff(bool_var v) const;
unsigned get_bound() const; unsigned get_bound() const;
void inc_bound(int64 i); void inc_bound(int64_t i);
literal get_asserting_literal(literal conseq); literal get_asserting_literal(literal conseq);
void process_antecedent(literal l, unsigned offset); void process_antecedent(literal l, unsigned offset);

2
src/sat/sat_asymm_branch.cpp
View file

@ -105,7 +105,7 @@ namespace sat {
void asymm_branch::process(big* big, clause_vector& clauses) { 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()); std::stable_sort(clauses.begin(), clauses.end(), clause_size_lt());
m_counter -= clauses.size(); m_counter -= clauses.size();
clause_vector::iterator it = clauses.begin(); clause_vector::iterator it = clauses.begin();

4
src/sat/sat_asymm_branch.h
View file

@ -33,7 +33,7 @@ namespace sat {
solver & s; solver & s;
params_ref m_params; params_ref m_params;
int64 m_counter; int64_t m_counter;
random_gen m_rand; random_gen m_rand;
unsigned m_calls; unsigned m_calls;
@ -43,7 +43,7 @@ namespace sat {
unsigned m_asymm_branch_delay; unsigned m_asymm_branch_delay;
bool m_asymm_branch_sampled; bool m_asymm_branch_sampled;
bool m_asymm_branch_all; bool m_asymm_branch_all;
int64 m_asymm_branch_limit; int64_t m_asymm_branch_limit;
// stats // stats
unsigned m_elim_literals; unsigned m_elim_literals;

4
src/sat/sat_lookahead.cpp
View file

@ -47,7 +47,7 @@ namespace sat {
void lookahead::flip_prefix() { void lookahead::flip_prefix() {
if (m_trail_lim.size() < 64) { 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)); m_prefix = mask | (m_prefix & (mask - 1));
} }
} }
@ -909,7 +909,7 @@ namespace sat {
void lookahead::display_search_string() { void lookahead::display_search_string() {
printf("\r"); printf("\r");
uint64 q = m_prefix; uint64_t q = m_prefix;
unsigned depth = m_trail_lim.size(); unsigned depth = m_trail_lim.size();
unsigned d = std::min(63u, depth); unsigned d = std::min(63u, depth);
unsigned new_prefix_length = d; unsigned new_prefix_length = d;

10
src/sat/sat_lookahead.h
View file

@ -27,13 +27,13 @@ Notes:
namespace sat { namespace sat {
struct pp_prefix { struct pp_prefix {
uint64 m_prefix; uint64_t m_prefix;
unsigned m_depth; 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) { 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); unsigned d = std::min(63u, p.m_depth);
for (unsigned i = 0; i <= d; ++i) { for (unsigned i = 0; i <= d; ++i) {
if (0 != (p.m_prefix & (1ull << i))) out << "1"; else out << "0"; 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. double m_lookahead_reward; // metric associated with current lookahead1 literal.
literal_vector m_wstack; // windofall stack that is populated in lookahead1 mode literal_vector m_wstack; // windofall stack that is populated in lookahead1 mode
unsigned m_last_prefix_length; 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<prefix> m_vprefix; // var: prefix where variable participates in propagation svector<prefix> m_vprefix; // var: prefix where variable participates in propagation
unsigned m_rating_throttle; // throttle to recompute rating unsigned m_rating_throttle; // throttle to recompute rating
indexed_uint_set m_freevars; indexed_uint_set m_freevars;
@ -523,7 +523,7 @@ namespace sat {
void update_lookahead_reward(literal l, unsigned level); 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; } 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; } 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<uint64>(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<uint64_t>(m_config.m_dl_max_iterations + 1) < c_fixed_truth; }
unsigned do_double(literal l, unsigned& base); unsigned do_double(literal l, unsigned& base);
unsigned double_look(literal l, unsigned& base); unsigned double_look(literal l, unsigned& base);

6
src/sat/sat_solver.cpp
View file

@ -782,7 +782,7 @@ namespace sat {
} }
if (m_config.m_anti_exploration) { 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) { if (age > 0) {
double decay = pow(0.95, age); double decay = pow(0.95, age);
m_activity[v] = static_cast<unsigned>(m_activity[v] * decay); m_activity[v] = static_cast<unsigned>(m_activity[v] * decay);
@ -1032,7 +1032,7 @@ namespace sat {
return check_par(num_lits, lits); return check_par(num_lits, lits);
} }
flet<bool> _searching(m_searching, true); flet<bool> _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 = alloc(solver, m_params, m_rlimit);
m_clone->copy(*this); m_clone->copy(*this);
} }
@ -3101,7 +3101,7 @@ namespace sat {
SASSERT(value(v) == l_undef); SASSERT(value(v) == l_undef);
m_case_split_queue.unassign_var_eh(v); m_case_split_queue.unassign_var_eh(v);
if (m_config.m_branching_heuristic == BH_LRB) { 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) { if (interval > 0) {
auto activity = m_activity[v]; auto activity = m_activity[v];
auto reward = (m_config.m_reward_offset * (m_participated[v] + m_reasoned[v])) / interval; auto reward = (m_config.m_reward_offset * (m_participated[v] + m_reasoned[v])) / interval;

10
src/sat/sat_solver.h
View file

@ -120,11 +120,11 @@ namespace sat {
// branch variable selection: // branch variable selection:
svector<unsigned> m_activity; svector<unsigned> m_activity;
unsigned m_activity_inc; unsigned m_activity_inc;
svector<uint64> m_last_conflict; svector<uint64_t> m_last_conflict;
svector<uint64> m_last_propagation; svector<uint64_t> m_last_propagation;
svector<uint64> m_participated; svector<uint64_t> m_participated;
svector<uint64> m_canceled; svector<uint64_t> m_canceled;
svector<uint64> m_reasoned; svector<uint64_t> m_reasoned;
int m_action; int m_action;
double m_step_size; double m_step_size;
// phase // phase

2
src/sat/sat_solver/inc_sat_solver.cpp
View file

@ -816,7 +816,7 @@ private:
TRACE("sat", model_smt2_pp(tout, m, *mdl, 0);); 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";); IF_VERBOSE(0, verbose_stream() << "Verifying solution\n";);
model_evaluator eval(*mdl); model_evaluator eval(*mdl);
eval.set_model_completion(false); eval.set_model_completion(false);

2
src/shell/datalog_frontend.cpp
View file

@ -212,7 +212,7 @@ unsigned read_datalog(char const * file) {
if (early_termination) { if (early_termination) {
IF_VERBOSE(1, verbose_stream() << "restarting saturation\n";); IF_VERBOSE(1, verbose_stream() << "restarting saturation\n";);
uint64 new_timeout = static_cast<uint64>(timeout)*ctx.initial_restart_timeout(); uint64_t new_timeout = static_cast<uint64_t>(timeout)*ctx.initial_restart_timeout();
if(new_timeout>UINT_MAX) { if(new_timeout>UINT_MAX) {
timeout=UINT_MAX; timeout=UINT_MAX;
} }

4
src/shell/lp_frontend.cpp
View file

@ -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) { void run_solver(lp_params & params, char const * mps_file_name) {
reslimit rlim; reslimit rlim;
unsigned timeout = gparams::get().get_uint("timeout", 0); unsigned timeout = gparams::get_ref().get_uint("timeout", 0);
unsigned rlimit = gparams::get().get_uint("rlimit", 0); unsigned rlimit = gparams::get_ref().get_uint("rlimit", 0);
front_end_resource_limit lp_limit(rlim); front_end_resource_limit lp_limit(rlim);
scoped_rlimit _rlimit(rlim, rlimit); scoped_rlimit _rlimit(rlim, rlimit);

2
src/shell/opt_frontend.cpp
View file

@ -115,7 +115,7 @@ static unsigned parse_opt(std::istream& in, opt_format f) {
case l_undef: std::cout << "unknown\n"; break; 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; model_ref mdl;
opt.get_model(mdl); opt.get_model(mdl);
expr_ref_vector hard(m); expr_ref_vector hard(m);

6
src/smt/params/smt_params_helper.pyg
View file

@ -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.'), ('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.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.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.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', 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'), ('core.extend_patterns.max_distance', UINT, UINT_MAX, 'limits the distance of a pattern-extended unsat core'),

6
src/smt/params/theory_str_params.cpp
View file

@ -31,4 +31,10 @@ void theory_str_params::updt_params(params_ref const & _p) {
m_UseBinarySearch = p.str_use_binary_search(); m_UseBinarySearch = p.str_use_binary_search();
m_BinarySearchInitialUpperBound = p.str_binary_search_start(); m_BinarySearchInitialUpperBound = p.str_binary_search_start();
m_OverlapTheoryAwarePriority = p.str_overlap_priority(); 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();
} }

45
src/smt/params/theory_str_params.h
View file

@ -80,6 +80,43 @@ struct theory_str_params {
double m_OverlapTheoryAwarePriority; 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()): theory_str_params(params_ref const & p = params_ref()):
m_StrongArrangements(true), m_StrongArrangements(true),
m_AggressiveLengthTesting(false), m_AggressiveLengthTesting(false),
@ -91,7 +128,13 @@ struct theory_str_params {
m_FiniteOverlapModels(false), m_FiniteOverlapModels(false),
m_UseBinarySearch(false), m_UseBinarySearch(false),
m_BinarySearchInitialUpperBound(64), 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); updt_params(p);
} }

2
src/smt/smt_context.cpp
View file

@ -3980,7 +3980,7 @@ namespace smt {
#if 0 #if 0
{ {
static unsigned counter = 0; static unsigned counter = 0;
static uint64 total = 0; static uint64_t total = 0;
static unsigned max = 0; static unsigned max = 0;
counter++; counter++;
total += num_lits; total += num_lits;

19
src/smt/smt_enode.h
View file

@ -216,6 +216,15 @@ namespace smt {
return m_args; 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 { // unsigned get_id() const {
// return m_id; // return m_id;
// } // }
@ -285,6 +294,16 @@ namespace smt {
return m_commutative; 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 { unsigned get_num_parents() const {
return m_parents.size(); return m_parents.size();
} }

1
src/smt/smt_types.h
View file

@ -21,6 +21,7 @@ Revision History:
#include "util/list.h" #include "util/list.h"
#include "util/vector.h" #include "util/vector.h"
#include "util/hashtable.h"
#include "util/lbool.h" #include "util/lbool.h"
class model; class model;

183
src/smt/theory_datatype.cpp
View file

@ -36,6 +36,41 @@ namespace smt {
theory_id get_from_theory() const override { return null_theory_id; } 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) { theory* theory_datatype::mk_fresh(context* new_ctx) {
return alloc(theory_datatype, new_ctx->get_manager(), m_params); return alloc(theory_datatype, new_ctx->get_manager(), m_params);
@ -389,10 +424,11 @@ namespace smt {
final_check_status theory_datatype::final_check_eh() { final_check_status theory_datatype::final_check_eh() {
int num_vars = get_num_vars(); int num_vars = get_num_vars();
final_check_status r = FC_DONE; final_check_status r = FC_DONE;
final_check_st _guard(this); // RAII for managing state
for (int v = 0; v < num_vars; v++) { for (int v = 0; v < num_vars; v++) {
if (v == static_cast<int>(m_find.find(v))) { if (v == static_cast<int>(m_find.find(v))) {
enode * node = get_enode(v); enode * node = get_enode(v);
if (occurs_check(node)) { if (!oc_cycle_free(node) && occurs_check(node)) {
// conflict was detected... // conflict was detected...
// return... // return...
return FC_CONTINUE; return FC_CONTINUE;
@ -410,6 +446,73 @@ namespace smt {
return r; 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. \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: For example, occur_check(a1) returns true in the following set of equalities:
@ -418,17 +521,39 @@ namespace smt {
a3 = cons(v3, a1) a3 = cons(v3, a1)
*/ */
bool theory_datatype::occurs_check(enode * n) { bool theory_datatype::occurs_check(enode * n) {
TRACE("datatype", tout << "occurs check: #" << n->get_owner_id() << "\n";); TRACE("datatype", tout << "occurs check: #" << n->get_owner_id() << " " << mk_bounded_pp(n->get_owner(), get_manager()) << "\n";);
m_to_unmark.reset(); m_stats.m_occurs_check++;
m_used_eqs.reset();
m_main = n; bool res = false;
bool res = occurs_check_core(m_main); oc_push_stack(n);
unmark_enodes(m_to_unmark.size(), m_to_unmark.c_ptr());
// 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) { if (res) {
// m_used_eqs should contain conflict
context & ctx = get_context(); context & ctx = get_context();
region & r = ctx.get_region(); 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()))); 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"; tout << "occurs_check: true\n";
for (enode_pair const& p : m_used_eqs) { for (enode_pair const& p : m_used_eqs) {
tout << "eq: #" << p.first->get_owner_id() << " #" << p.second->get_owner_id() << "\n"; tout << "eq: #" << p.first->get_owner_id() << " #" << p.second->get_owner_id() << "\n";
@ -438,48 +563,6 @@ namespace smt {
return res; 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() { void theory_datatype::reset_eh() {
m_trail_stack.reset(); m_trail_stack.reset();
std::for_each(m_var_data.begin(), m_var_data.end(), delete_proc<var_data>()); std::for_each(m_var_data.begin(), m_var_data.end(), delete_proc<var_data>());

32
src/smt/theory_datatype.h
View file

@ -26,7 +26,6 @@ Revision History:
#include "smt/proto_model/datatype_factory.h" #include "smt/proto_model/datatype_factory.h"
namespace smt { namespace smt {
class theory_datatype : public theory { class theory_datatype : public theory {
typedef trail_stack<theory_datatype> th_trail_stack; typedef trail_stack<theory_datatype> th_trail_stack;
typedef union_find<theory_datatype> th_union_find; typedef union_find<theory_datatype> th_union_find;
@ -73,11 +72,36 @@ namespace smt {
void propagate_recognizer(theory_var v, enode * r); void propagate_recognizer(theory_var v, enode * r);
void sign_recognizer_conflict(enode * c, enode * r); void sign_recognizer_conflict(enode * c, enode * r);
typedef enum { ENTER, EXIT } stack_op;
typedef map<enode*, enode*, obj_ptr_hash<enode>, ptr_eq<enode> > parent_tbl;
typedef std::pair<stack_op, enode*> stack_entry;
ptr_vector<enode> m_to_unmark; ptr_vector<enode> m_to_unmark;
enode_pair_vector m_used_eqs; ptr_vector<enode> m_to_unmark2;
enode * m_main; enode_pair_vector m_used_eqs; // conflict, if any
parent_tbl m_parent; // parent explanation for occurs_check
svector<stack_entry> 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(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); void mk_split(theory_var v);

6
src/smt/theory_dl.cpp
View file

@ -182,7 +182,7 @@ namespace smt {
if (n->get_decl() != v) { if (n->get_decl() != v) {
expr* rep = m().mk_app(r, n); expr* rep = m().mk_app(r, n);
uint64 vl; uint64_t vl;
if (u().is_numeral_ext(n, vl)) { if (u().is_numeral_ext(n, vl)) {
assert_cnstr(m().mk_eq(rep, mk_bv_constant(vl, s))); assert_cnstr(m().mk_eq(rep, mk_bv_constant(vl, s)));
} }
@ -237,12 +237,12 @@ namespace smt {
return true; 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); return b().mk_numeral(rational(val, rational::ui64()), 64);
} }
app* max_value(sort* s) { app* max_value(sort* s) {
uint64 sz; uint64_t sz;
VERIFY(u().try_get_size(s, sz)); VERIFY(u().try_get_size(s, sz));
SASSERT(sz > 0); SASSERT(sz > 0);
return mk_bv_constant(sz-1, s); return mk_bv_constant(sz-1, s);

11
src/smt/theory_pb.cpp
View file

@ -500,7 +500,16 @@ namespace smt {
expr* arg = atom->get_arg(i); expr* arg = atom->get_arg(i);
literal l = compile_arg(arg); literal l = compile_arg(arg);
numeral c = pb.get_coeff(atom, i); numeral c = pb.get_coeff(atom, i);
switch (ctx.get_assignment(l)) {
case l_true:
k -= c;
break;
case l_false:
break;
default:
args.push_back(std::make_pair(l, c)); args.push_back(std::make_pair(l, c));
break;
}
} }
if (pb.is_at_most_k(atom) || pb.is_le(atom)) { if (pb.is_at_most_k(atom) || pb.is_le(atom)) {
// turn W <= k into -W >= -k // turn W <= k into -W >= -k
@ -512,7 +521,7 @@ namespace smt {
else { else {
SASSERT(pb.is_at_least_k(atom) || pb.is_ge(atom) || pb.is_eq(atom)); 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); //app_ref fml1(m), fml2(m);
//fml1 = c->to_expr(ctx, m); //fml1 = c->to_expr(ctx, m);
c->unique(); c->unique();

165
src/smt/theory_seq.cpp
View file

@ -134,8 +134,7 @@ void theory_seq::solution_map::pop_scope(unsigned num_scopes) {
if (num_scopes == 0) return; if (num_scopes == 0) return;
m_cache.reset(); m_cache.reset();
unsigned start = m_limit[m_limit.size() - num_scopes]; unsigned start = m_limit[m_limit.size() - num_scopes];
for (unsigned i = m_updates.size(); i > start; ) { for (unsigned i = m_updates.size(); i-- > start; ) {
--i;
if (m_updates[i] == INS) { if (m_updates[i] == INS) {
m_map.remove(m_lhs[i].get()); 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])) { if (ls.empty() || !is_var(ls[0])) {
return false; return false;
} }
for (unsigned i = 0; i < rs.size(); ++i) { for (expr* r : rs) {
if (!m_util.str.is_unit(rs[i])) { if (!m_util.str.is_unit(r)) {
return false; 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 theory_seq::branch_variable_mb() {
bool change = false; bool change = false;
for (unsigned i = 0; i < m_eqs.size(); ++i) { for (eq const& e : m_eqs) {
eq const& e = m_eqs[i];
vector<rational> len1, len2; vector<rational> len1, len2;
if (!is_complex(e)) { if (!is_complex(e)) {
continue; continue;
@ -1473,7 +1471,7 @@ bool theory_seq::add_solution(expr* l, expr* r, dependency* deps) {
if (l == r) { if (l == r) {
return false; 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_new_solution = true;
m_rep.update(l, r, deps); m_rep.update(l, r, deps);
enode* n1 = ensure_enode(l); 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; change = canonize(r, rs, dep2) || change;
deps = m_dm.mk_join(dep2, deps); deps = m_dm.mk_join(dep2, deps);
TRACE("seq", tout << l << " = " << r << " ==> "; 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)) { if (!ctx.inconsistent() && simplify_eq(ls, rs, deps)) {
return true; 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) { bool theory_seq::internalize_atom(app* a, bool) {
#if 1
return internalize_term(a); 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) { 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 theory_seq::check_int_string() {
bool change = false; bool change = false;
for (unsigned i = 0; i < m_int_string.size(); ++i) { for (expr * e : m_int_string) {
expr* e = m_int_string[i].get(), *n; expr* n = nullptr;
if (m_util.str.is_itos(e) && add_itos_val_axiom(e)) { if (m_util.str.is_itos(e) && add_itos_val_axiom(e)) {
change = true; change = true;
} }
@ -2358,9 +2302,21 @@ bool theory_seq::check_int_string() {
void theory_seq::add_stoi_axiom(expr* e) { void theory_seq::add_stoi_axiom(expr* e) {
TRACE("seq", tout << mk_pp(e, m) << "\n";); TRACE("seq", tout << mk_pp(e, m) << "\n";);
SASSERT(m_util.str.is_stoi(e)); expr* s = nullptr;
literal l = mk_simplified_literal(m_autil.mk_ge(e, arith_util(m).mk_int(-1))); 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); 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) { 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)); lits.push_back(~is_digit(ith_char));
nums.push_back(digit2int(ith_char)); nums.push_back(digit2int(ith_char));
} }
for (unsigned i = sz, c = 1; i-- > 0; c *= 10) { rational c(1);
coeff = m_autil.mk_int(c); 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()); nums[i] = m_autil.mk_mul(coeff, nums[i].get());
} }
num = m_autil.mk_add(nums.size(), nums.c_ptr()); 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) { 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()); m_factory = alloc(seq_factory, get_manager(), get_family_id(), mg.get_model());
mg.register_factory(m_factory); mg.register_factory(m_factory);
for (ne const& n : m_nqs) { 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) { void theory_seq::propagate_in_re(expr* n, bool is_true) {
TRACE("seq", tout << mk_pp(n, m) << " <- " << (is_true?"true":"false") << "\n";); TRACE("seq", tout << mk_pp(n, m) << " <- " << (is_true?"true":"false") << "\n";);
expr* e1 = nullptr, *e2 = nullptr; expr* s = nullptr, *re = nullptr;
VERIFY(m_util.str.is_in_re(n, e1, e2)); VERIFY(m_util.str.is_in_re(n, s, re));
expr_ref tmp(n, m); expr_ref tmp(n, m);
m_rewrite(tmp); m_rewrite(tmp);
@ -3450,21 +3412,21 @@ void theory_seq::propagate_in_re(expr* n, bool is_true) {
return; return;
} }
expr_ref e3(e2, m); expr_ref e3(re, m);
context& ctx = get_context(); context& ctx = get_context();
literal lit = ctx.get_literal(n); literal lit = ctx.get_literal(n);
if (!is_true) { if (!is_true) {
e3 = m_util.re.mk_complement(e2); e3 = m_util.re.mk_complement(re);
lit.neg(); lit.neg();
} }
eautomaton* a = get_automaton(e3); eautomaton* a = get_automaton(e3);
if (!a) return; 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) { for (unsigned i = 0; i < a->num_states(); ++i) {
literal acc = mk_accept(e1, len, e3, i); literal acc = mk_accept(s, len, e3, i);
literal rej = mk_reject(e1, 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)?acc:~acc);
add_axiom(a->is_final_state(i)?~rej:rej); 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; literal_vector lits;
lits.push_back(~lit); lits.push_back(~lit);
for (unsigned i = 0; i < states.size(); ++i) { for (unsigned st : states) {
lits.push_back(mk_accept(e1, zero, e3, states[i])); lits.push_back(mk_accept(s, zero, e3, st));
} }
if (lits.size() == 2) { if (lits.size() == 2) {
propagate_lit(nullptr, 1, &lit, lits[1]); propagate_lit(nullptr, 1, &lit, lits[1]);
@ -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) { theory_seq::dependency* theory_seq::mk_join(dependency* deps, literal_vector const& lits) {
for (unsigned i = 0; i < lits.size(); ++i) { for (literal l : lits) {
deps = mk_join(deps, lits[i]); deps = mk_join(deps, l);
} }
return deps; return deps;
} }
@ -4131,54 +4093,16 @@ void theory_seq::new_diseq_eh(theory_var v1, theory_var v2) {
TRACE("seq", tout << "new disequality " << get_context().get_scope_level() << ": " << eq << "\n";); TRACE("seq", tout << "new disequality " << get_context().get_scope_level() << ": " << eq << "\n";);
m_rewrite(eq); m_rewrite(eq);
if (!m.is_false(eq)) { if (!m.is_false(eq)) {
literal lit = mk_eq(e1, e2, false); literal lit = mk_eq(e1, e2, false);
if (m_util.str.is_empty(e2)) { if (m_util.str.is_empty(e2)) {
std::swap(e1, 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)); dependency* dep = m_dm.mk_leaf(assumption(~lit));
m_nqs.push_back(ne(e1, e2, dep)); m_nqs.push_back(ne(e1, e2, dep));
solve_nqs(m_nqs.size() - 1); solve_nqs(m_nqs.size() - 1);
} }
#endif
}
} }
void theory_seq::push_scope_eh() { void theory_seq::push_scope_eh() {
@ -4508,8 +4432,7 @@ bool theory_seq::add_reject2reject(expr* rej, bool& change) {
ensure_nth(~len_le_idx, s, idx); ensure_nth(~len_le_idx, s, idx);
literal_vector eqs; literal_vector eqs;
bool has_undef = false; bool has_undef = false;
for (unsigned i = 0; i < mvs.size(); ++i) { for (eautomaton::move const& mv : mvs) {
eautomaton::move const& mv = mvs[i];
literal eq = mk_literal(mv.t()->accept(nth)); literal eq = mk_literal(mv.t()->accept(nth));
switch (ctx.get_assignment(eq)) { switch (ctx.get_assignment(eq)) {
case l_false: case l_false:

2
src/smt/theory_seq.h
View file

@ -362,6 +362,7 @@ namespace smt {
void collect_statistics(::statistics & st) const override; void collect_statistics(::statistics & st) const override;
model_value_proc * mk_value(enode * n, model_generator & mg) override; model_value_proc * mk_value(enode * n, model_generator & mg) override;
void init_model(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_search_eh() override;
void init_model(expr_ref_vector const& es); void init_model(expr_ref_vector const& es);
@ -389,7 +390,6 @@ namespace smt {
vector<rational> const& ll, vector<rational> const& rl); vector<rational> const& ll, vector<rational> const& rl);
bool set_empty(expr* x); bool set_empty(expr* x);
bool is_complex(eq const& e); bool is_complex(eq const& e);
bool internalize_re(expr* e);
bool check_extensionality(); bool check_extensionality();
bool check_contains(); bool check_contains();

1750
src/smt/theory_str.cpp
View file

File diff suppressed because it is too large Load diff

119
src/smt/theory_str.h
View file

@ -20,9 +20,11 @@
#include "util/trail.h" #include "util/trail.h"
#include "util/union_find.h" #include "util/union_find.h"
#include "util/scoped_ptr_vector.h" #include "util/scoped_ptr_vector.h"
#include "util/hashtable.h"
#include "ast/ast_pp.h" #include "ast/ast_pp.h"
#include "ast/arith_decl_plugin.h" #include "ast/arith_decl_plugin.h"
#include "ast/rewriter/th_rewriter.h" #include "ast/rewriter/th_rewriter.h"
#include "ast/rewriter/seq_rewriter.h"
#include "ast/seq_decl_plugin.h" #include "ast/seq_decl_plugin.h"
#include "smt/smt_theory.h" #include "smt/smt_theory.h"
#include "smt/params/theory_str_params.h" #include "smt/params/theory_str_params.h"
@ -36,6 +38,7 @@
namespace smt { namespace smt {
typedef hashtable<symbol, symbol_hash_proc, symbol_eq_proc> symbol_set; typedef hashtable<symbol, symbol_hash_proc, symbol_eq_proc> symbol_set;
typedef int_hashtable<int_hash, default_eq<int> > integer_set;
class str_value_factory : public value_factory { class str_value_factory : public value_factory {
seq_util u; seq_util u;
@ -148,6 +151,70 @@ public:
bool matches(zstring input); 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 { class theory_str : public theory {
struct T_cut struct T_cut
{ {
@ -250,6 +317,8 @@ protected:
str_value_factory * m_factory; str_value_factory * m_factory;
re2automaton m_mk_aut;
// Unique identifier appended to unused variables to ensure that model construction // Unique identifier appended to unused variables to ensure that model construction
// does not introduce equalities when they weren't enforced. // does not introduce equalities when they weren't enforced.
unsigned m_unused_id; unsigned m_unused_id;
@ -267,6 +336,10 @@ protected:
// enode lists for library-aware/high-level string terms (e.g. substr, contains) // enode lists for library-aware/high-level string terms (e.g. substr, contains)
ptr_vector<enode> m_library_aware_axiom_todo; ptr_vector<enode> 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 -- // hashtable of all exprs for which we've already set up term-specific axioms --
// this prevents infinite recursive descent with respect to axioms that // this prevents infinite recursive descent with respect to axioms that
// include an occurrence of the term for which axioms are being generated // include an occurrence of the term for which axioms are being generated
@ -320,7 +393,31 @@ protected:
// TBD: do a curried map for determinism. // TBD: do a curried map for determinism.
std::map<std::pair<expr*, zstring>, expr*> regex_in_bool_map; std::map<std::pair<expr*, zstring>, expr*> regex_in_bool_map;
obj_map<expr, std::set<zstring> > regex_in_var_reg_str_map; obj_map<expr, std::set<zstring> > regex_in_var_reg_str_map;
// regex automata
scoped_ptr_vector<eautomaton> m_automata;
ptr_vector<eautomaton> regex_automata;
obj_hashtable<expr> regex_terms;
obj_map<expr, ptr_vector<expr> > regex_terms_by_string; // S --> [ (str.in.re S *) ]
obj_map<expr, svector<regex_automaton_under_assumptions> > regex_automaton_assumptions; // RegEx --> [ aut+assumptions ]
obj_map<expr, nfa> regex_nfa_cache; // Regex term --> NFA obj_map<expr, nfa> regex_nfa_cache; // Regex term --> NFA
obj_hashtable<expr> regex_terms_with_path_constraints; // set of string terms which have had path constraints asserted in the current scope
obj_hashtable<expr> regex_terms_with_length_constraints; // set of regex terms which had had length constraints asserted in the current scope
obj_map<expr, expr*> regex_term_to_length_constraint; // (str.in.re S R) -> (length constraint over S wrt. R)
obj_map<expr, ptr_vector<expr> > 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<expr, rational> regex_last_lower_bound;
obj_map<expr, rational> 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<expr, unsigned> regex_length_attempt_count;
obj_map<expr, unsigned> regex_fail_count;
obj_map<expr, unsigned> regex_intersection_fail_count;
obj_map<expr, ptr_vector<expr> > string_chars; // S --> [S_0, S_1, ...] for character terms S_i
svector<char> char_set; svector<char> char_set;
std::map<char, int> charSetLookupTable; std::map<char, int> charSetLookupTable;
@ -439,14 +536,32 @@ protected:
void instantiate_axiom_str_to_int(enode * e); void instantiate_axiom_str_to_int(enode * e);
void instantiate_axiom_int_to_str(enode * e); void instantiate_axiom_int_to_str(enode * e);
void add_persisted_axiom(expr * a);
expr * mk_RegexIn(expr * str, expr * regexp); expr * mk_RegexIn(expr * str, expr * regexp);
void instantiate_axiom_RegexIn(enode * e); void instantiate_axiom_RegexIn(enode * e);
app * mk_unroll(expr * n, expr * bound); app * mk_unroll(expr * n, expr * bound);
void process_unroll_eq_const_str(expr * unrollFunc, expr * constStr); void process_unroll_eq_const_str(expr * unrollFunc, expr * constStr);
void unroll_str2reg_constStr(expr * unrollFunc, expr * eqConstStr); void unroll_str2reg_constStr(expr * unrollFunc, expr * eqConstStr);
void process_concat_eq_unroll(expr * concat, expr * unroll); 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<expr*>& 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<expr, unsigned> & counter_map, expr * key);
unsigned regex_get_counter(obj_map<expr, unsigned> & counter_map, expr * key);
void set_up_axioms(expr * ex); void set_up_axioms(expr * ex);
void handle_equality(expr * lhs, expr * rhs); void handle_equality(expr * lhs, expr * rhs);
@ -535,6 +650,7 @@ protected:
std::map<expr*, std::map<expr*, int> > & concat_eq_concat_map, std::map<expr*, std::map<expr*, int> > & concat_eq_concat_map,
std::map<expr*, std::set<expr*> > & unrollGroupMap); std::map<expr*, std::set<expr*> > & unrollGroupMap);
bool term_appears_as_subterm(expr * needle, expr * haystack);
void classify_ast_by_type(expr * node, std::map<expr*, int> & varMap, void classify_ast_by_type(expr * node, std::map<expr*, int> & varMap,
std::map<expr*, int> & concatMap, std::map<expr*, int> & unrollMap); std::map<expr*, int> & concatMap, std::map<expr*, int> & unrollMap);
void classify_ast_by_type_in_positive_context(std::map<expr*, int> & varMap, void classify_ast_by_type_in_positive_context(std::map<expr*, int> & varMap,
@ -623,6 +739,7 @@ protected:
void new_diseq_eh(theory_var, theory_var) override; void new_diseq_eh(theory_var, theory_var) override;
theory* mk_fresh(context*) override { return alloc(theory_str, get_manager(), m_params); } theory* mk_fresh(context*) override { return alloc(theory_str, get_manager(), m_params); }
void init(context * ctx) override;
void init_search_eh() override; void init_search_eh() override;
void add_theory_assumptions(expr_ref_vector & assumptions) override; void add_theory_assumptions(expr_ref_vector & assumptions) override;
lbool validate_unsat_core(expr_ref_vector & unsat_core) override; lbool validate_unsat_core(expr_ref_vector & unsat_core) override;

Some files were not shown because too many files have changed in this diff Show more