mirror of
https://github.com/Z3Prover/z3
synced 2025-04-06 17:44:08 +00:00
Merge branch 'master' of https://github.com/Z3Prover/z3
This commit is contained in:
Yatao Li
commit
f5b874e0a3
1
.gitignore
vendored
1
.gitignore
vendored
|
|
@ -43,6 +43,7 @@ bld_dbg/*
|
||||||
bld_rel/*
|
bld_rel/*
|
||||||
bld_dbg_x64/*
|
bld_dbg_x64/*
|
||||||
bld_rel_x64/*
|
bld_rel_x64/*
|
||||||
|
.vscode
|
||||||
# Auto generated files.
|
# Auto generated files.
|
||||||
config.log
|
config.log
|
||||||
config.status
|
config.status
|
||||||
|
|
|
||||||
|
|
@ -34,7 +34,7 @@ endif()
|
||||||
################################################################################
|
################################################################################
|
||||||
set(Z3_VERSION_MAJOR 4)
|
set(Z3_VERSION_MAJOR 4)
|
||||||
set(Z3_VERSION_MINOR 8)
|
set(Z3_VERSION_MINOR 8)
|
||||||
set(Z3_VERSION_PATCH 0)
|
set(Z3_VERSION_PATCH 5)
|
||||||
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
|
||||||
|
|
@ -99,7 +99,7 @@ set(GIT_DIR "${CMAKE_SOURCE_DIR}/.git")
|
||||||
if (EXISTS "${GIT_DIR}")
|
if (EXISTS "${GIT_DIR}")
|
||||||
# Try to make CMake configure depend on the current git HEAD so that
|
# Try to make CMake configure depend on the current git HEAD so that
|
||||||
# a re-configure is triggered when the HEAD changes.
|
# a re-configure is triggered when the HEAD changes.
|
||||||
add_git_dir_dependency("${GIT_DIR}" ADD_GIT_DEP_SUCCESS)
|
add_git_dir_dependency("${CMAKE_SOURCE_DIR}" ADD_GIT_DEP_SUCCESS)
|
||||||
if (ADD_GIT_DEP_SUCCESS)
|
if (ADD_GIT_DEP_SUCCESS)
|
||||||
if (INCLUDE_GIT_HASH)
|
if (INCLUDE_GIT_HASH)
|
||||||
get_git_head_hash("${GIT_DIR}" Z3GITHASH)
|
get_git_head_hash("${GIT_DIR}" Z3GITHASH)
|
||||||
|
|
@ -205,9 +205,6 @@ message(STATUS "PYTHON_EXECUTABLE: ${PYTHON_EXECUTABLE}")
|
||||||
include(${CMAKE_SOURCE_DIR}/cmake/target_arch_detect.cmake)
|
include(${CMAKE_SOURCE_DIR}/cmake/target_arch_detect.cmake)
|
||||||
detect_target_architecture(TARGET_ARCHITECTURE)
|
detect_target_architecture(TARGET_ARCHITECTURE)
|
||||||
message(STATUS "Detected target architecture: ${TARGET_ARCHITECTURE}")
|
message(STATUS "Detected target architecture: ${TARGET_ARCHITECTURE}")
|
||||||
if ("${TARGET_ARCHITECTURE}" STREQUAL "x86_64")
|
|
||||||
list(APPEND Z3_COMPONENT_CXX_DEFINES "-D_AMD64_")
|
|
||||||
endif()
|
|
||||||
|
|
||||||
|
|
||||||
################################################################################
|
################################################################################
|
||||||
|
|
@ -240,7 +237,7 @@ if ("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
|
||||||
list(APPEND Z3_COMPONENT_CXX_DEFINES "-D_USE_THREAD_LOCAL")
|
list(APPEND Z3_COMPONENT_CXX_DEFINES "-D_USE_THREAD_LOCAL")
|
||||||
endif()
|
endif()
|
||||||
elseif ("${CMAKE_SYSTEM_NAME}" STREQUAL "Darwin")
|
elseif ("${CMAKE_SYSTEM_NAME}" STREQUAL "Darwin")
|
||||||
# Does OSX really not need any special flags?
|
# Does macOS really not need any special flags?
|
||||||
message(STATUS "Platform: Darwin")
|
message(STATUS "Platform: Darwin")
|
||||||
elseif ("${CMAKE_SYSTEM_NAME}" MATCHES "FreeBSD")
|
elseif ("${CMAKE_SYSTEM_NAME}" MATCHES "FreeBSD")
|
||||||
message(STATUS "Platform: FreeBSD")
|
message(STATUS "Platform: FreeBSD")
|
||||||
|
|
@ -380,9 +377,17 @@ endif()
|
||||||
################################################################################
|
################################################################################
|
||||||
# FIXME: Support ARM "-mfpu=vfp -mfloat-abi=hard"
|
# FIXME: Support ARM "-mfpu=vfp -mfloat-abi=hard"
|
||||||
if (("${TARGET_ARCHITECTURE}" STREQUAL "x86_64") OR ("${TARGET_ARCHITECTURE}" STREQUAL "i686"))
|
if (("${TARGET_ARCHITECTURE}" STREQUAL "x86_64") OR ("${TARGET_ARCHITECTURE}" STREQUAL "i686"))
|
||||||
if (("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU") OR ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang"))
|
if (("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU") OR ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") OR ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Intel"))
|
||||||
|
if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Intel")
|
||||||
|
# Intel's compiler requires linking with libiomp5
|
||||||
|
list(APPEND Z3_DEPENDENT_LIBS "iomp5")
|
||||||
|
endif()
|
||||||
set(SSE_FLAGS "-mfpmath=sse" "-msse" "-msse2")
|
set(SSE_FLAGS "-mfpmath=sse" "-msse" "-msse2")
|
||||||
# FIXME: Remove "x.." when CMP0054 is set to NEW
|
# FIXME: Remove "x.." when CMP0054 is set to NEW
|
||||||
|
elseif ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Intel")
|
||||||
|
set(SSE_FLAGS "-mfpmath=sse" "-msse" "-msse2")
|
||||||
|
# Intel's compiler requires linking with libiomp5
|
||||||
|
list(APPEND Z3_DEPENDENT_LIBS "iomp5")
|
||||||
elseif ("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xMSVC")
|
elseif ("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xMSVC")
|
||||||
set(SSE_FLAGS "/arch:SSE2")
|
set(SSE_FLAGS "/arch:SSE2")
|
||||||
else()
|
else()
|
||||||
|
|
@ -417,6 +422,15 @@ list(APPEND Z3_DEPENDENT_LIBS ${CMAKE_THREAD_LIBS_INIT})
|
||||||
################################################################################
|
################################################################################
|
||||||
include(${CMAKE_SOURCE_DIR}/cmake/compiler_warnings.cmake)
|
include(${CMAKE_SOURCE_DIR}/cmake/compiler_warnings.cmake)
|
||||||
|
|
||||||
|
################################################################################
|
||||||
|
# Save Clang optimization records
|
||||||
|
################################################################################
|
||||||
|
option(SAVE_CLANG_OPTIMIZATION_RECORDS "Enable saving Clang optimization records." OFF)
|
||||||
|
|
||||||
|
if (SAVE_CLANG_OPTIMIZATION_RECORDS)
|
||||||
|
z3_add_cxx_flag("-fsave-optimization-record" REQUIRED)
|
||||||
|
endif()
|
||||||
|
|
||||||
################################################################################
|
################################################################################
|
||||||
# If using Ninja, force color output for Clang (and gcc, disabled to check build).
|
# If using Ninja, force color output for Clang (and gcc, disabled to check build).
|
||||||
################################################################################
|
################################################################################
|
||||||
|
|
|
||||||
13
README.md
13
README.md
|
|
@ -5,16 +5,19 @@ under the [MIT license](LICENSE.txt).
|
||||||
|
|
||||||
If you are not familiar with Z3, you can start [here](https://github.com/Z3Prover/z3/wiki#background).
|
If you are not familiar with Z3, you can start [here](https://github.com/Z3Prover/z3/wiki#background).
|
||||||
|
|
||||||
|
Pre-built binaries for releases are available from [here](https://github.com/Z3Prover/z3/releases),
|
||||||
|
and nightly builds from [here](https://github.com/Z3Prover/bin/tree/master/nightly).
|
||||||
|
|
||||||
Z3 can be built using [Visual Studio][1], a [Makefile][2] or using [CMake][3]. It provides
|
Z3 can be built using [Visual Studio][1], a [Makefile][2] or using [CMake][3]. It provides
|
||||||
[bindings for several programming languages][4].
|
[bindings for several programming languages][4].
|
||||||
|
|
||||||
See the [release notes](RELEASE_NOTES) for notes on various stable releases of Z3.
|
See the [release notes](RELEASE_NOTES) for notes on various stable releases of Z3.
|
||||||
|
|
||||||
## Build status
|
## Build status
|
||||||
|
|
||||||
| Windows x64 | Windows x86 | Windows x64 | Ubuntu x64 | Debian x64 | OSX | TravisCI |
|
| Windows x64 | Windows x86 | Windows x64 | Ubuntu x64 | Debian x64 | macOS | TravisCI |
|
||||||
| ----------- | ----------- | ----------- | ---------- | ---------- | --- | -------- |
|
| ----------- | ----------- | ----------- | ---------- | ---------- | ----- | -------- |
|
||||||
[](https://z3build.visualstudio.com/Z3Build/_build/index?definitionId=4) | [](https://cz3.visualstudio.com/Z3/_build/index?definitionId=4) | [](https://cz3.visualstudio.com/Z3/_build/index?definitionId=7) | [](https://cz3.visualstudio.com/Z3/_build/index?definitionId=3) | [](https://cz3.visualstudio.com/Z3/_build/index?definitionId=5) | [](https://cz3.visualstudio.com/Z3/_build/index?definitionId=2) | [](https://travis-ci.org/Z3Prover/z3)
|
[](https://z3build.visualstudio.com/Z3Build/_build/index?definitionId=4) | [](https://cz3.visualstudio.com/Z3/_build/index?definitionId=4) | [](https://cz3.visualstudio.com/Z3/_build/index?definitionId=7) | [](https://cz3.visualstudio.com/Z3/_build/index?definitionId=3) | [](https://cz3.visualstudio.com/Z3/_build/index?definitionId=5) | [](https://cz3.visualstudio.com/Z3/_build/latest?definitionId=2) | [](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
|
||||||
|
|
@ -75,7 +78,7 @@ A 32 bit build should work similarly (but is untested); the same is true for 32/
|
||||||
By default, it will install z3 executable at ``PREFIX/bin``, libraries at
|
By default, it will install z3 executable at ``PREFIX/bin``, libraries at
|
||||||
``PREFIX/lib``, and include files at ``PREFIX/include``, where ``PREFIX``
|
``PREFIX/lib``, and include files at ``PREFIX/include``, where ``PREFIX``
|
||||||
installation prefix if inferred by the ``mk_make.py`` script. It is usually
|
installation prefix if inferred by the ``mk_make.py`` script. It is usually
|
||||||
``/usr`` for most Linux distros, and ``/usr/local`` for FreeBSD and OSX. Use
|
``/usr`` for most Linux distros, and ``/usr/local`` for FreeBSD and macOS. Use
|
||||||
the ``--prefix=`` command line option to change the install prefix. For example:
|
the ``--prefix=`` command line option to change the install prefix. For example:
|
||||||
|
|
||||||
```bash
|
```bash
|
||||||
|
|
|
||||||
|
|
@ -1,5 +1,33 @@
|
||||||
RELEASE NOTES
|
RELEASE NOTES
|
||||||
|
|
||||||
|
Version 4.8.4
|
||||||
|
=============
|
||||||
|
|
||||||
|
- Notes
|
||||||
|
- fixes bugs
|
||||||
|
- a substantial update to how the seq theory solver handles regular
|
||||||
|
expressions. Other performance improvements to the seq solver.
|
||||||
|
- Managed .NET DLLs include dotnet standard 1.4 on supported platforms.
|
||||||
|
- Windows Managed DLLs are strong signed in the released binaries.
|
||||||
|
|
||||||
|
Version 4.8.3
|
||||||
|
=============
|
||||||
|
- New features
|
||||||
|
- Native handling of recursive function definitions, thanks to Simon Cruanes
|
||||||
|
- PB rounding based option for conflict resolution when reasoning about PB constraints.
|
||||||
|
- Access to numeral constants as a double from the native API.
|
||||||
|
|
||||||
|
- Notes
|
||||||
|
- fixes several bugs discovered since the 4.8.1 release.
|
||||||
|
|
||||||
|
Version 4.8.2
|
||||||
|
=============
|
||||||
|
- Post-Release.
|
||||||
|
|
||||||
|
Version 4.8.1
|
||||||
|
=============
|
||||||
|
- Release. Bug-fix for 4.8.0
|
||||||
|
|
||||||
Version 4.8.0
|
Version 4.8.0
|
||||||
=============
|
=============
|
||||||
|
|
||||||
|
|
@ -21,7 +49,7 @@ Version 4.8.0
|
||||||
extracting models from apply_result have been replaced.
|
extracting models from apply_result have been replaced.
|
||||||
- An optional mode handles xor constraints using a custom xor propagator.
|
- An optional mode handles xor constraints using a custom xor propagator.
|
||||||
It is off by default and its value not demonstrated.
|
It is off by default and its value not demonstrated.
|
||||||
- The SAT solver includes new inprocessing technques that are available during simplification.
|
- The SAT solver includes new inprocessing techniques that are available during simplification.
|
||||||
It performs asymmetric tautology elimination by default, and one can turn on more powerful inprocessing techniques
|
It performs asymmetric tautology elimination by default, and one can turn on more powerful inprocessing techniques
|
||||||
(known as ACCE, ABCE, CCE). Asymmetric branching also uses features introduced in Lingeling by exploiting binary implication graphs.
|
(known as ACCE, ABCE, CCE). Asymmetric branching also uses features introduced in Lingeling by exploiting binary implication graphs.
|
||||||
Use sat.acce=true to enable the full repertoire of inprocessing methods. By default, clauses that are "eliminated" by acce are tagged
|
Use sat.acce=true to enable the full repertoire of inprocessing methods. By default, clauses that are "eliminated" by acce are tagged
|
||||||
|
|
@ -318,7 +346,7 @@ First source code release (October 2, 2012)
|
||||||
|
|
||||||
- Added support for numbers in scientific notation at Z3_ast Z3_mk_numeral(__in Z3_context c, __in Z3_string numeral, __in Z3_sort ty).
|
- Added support for numbers in scientific notation at Z3_ast Z3_mk_numeral(__in Z3_context c, __in Z3_string numeral, __in Z3_sort ty).
|
||||||
|
|
||||||
- New builtin symbols in the arithmetic theory: pi, euler, sin, cos, tan, asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh. The first two are constants, and the others are unary functions. These symbols are not available if the a SMT 2.0 logic is specified (e.g., QF_LRA, QF_NRA, QF_LIA, etc) because these symbols are not defined in these logics. That is, the new symbols are only available if the logic is not specified.
|
- New builtin symbols in the arithmetic theory: pi, euler, sin, cos, tan, asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh. The first two are constants, and the others are unary functions. These symbols are not available if a SMT 2.0 logic is specified (e.g., QF_LRA, QF_NRA, QF_LIA, etc) because these symbols are not defined in these logics. That is, the new symbols are only available if the logic is not specified.
|
||||||
|
|
||||||
Version 4.1
|
Version 4.1
|
||||||
===========
|
===========
|
||||||
|
|
|
||||||
|
|
@ -8,13 +8,13 @@
|
||||||
# FIXME: All the commented out defines should be removed once
|
# FIXME: All the commented out defines should be removed once
|
||||||
# we are confident it is correct to not set them.
|
# we are confident it is correct to not set them.
|
||||||
set(Z3_MSVC_LEGACY_DEFINES
|
set(Z3_MSVC_LEGACY_DEFINES
|
||||||
# Don't set `_DEBUG`. The old build sytem sets this but this
|
# Don't set `_DEBUG`. The old build system sets this but this
|
||||||
# is wrong. MSVC will set this depending on which runtime is being used.
|
# is wrong. MSVC will set this depending on which runtime is being used.
|
||||||
# See https://msdn.microsoft.com/en-us/library/b0084kay.aspx
|
# See https://msdn.microsoft.com/en-us/library/b0084kay.aspx
|
||||||
# _DEBUG
|
# _DEBUG
|
||||||
|
|
||||||
# The old build system only set `UNICODE` and `_UNICODE` for x86_64 release.
|
# The old build system only set `UNICODE` and `_UNICODE` for x86_64 release.
|
||||||
# That seems completly wrong so set it for all configurations.
|
# That seems completely wrong so set it for all configurations.
|
||||||
# According to https://blogs.msdn.microsoft.com/oldnewthing/20040212-00/?p=40643/
|
# According to https://blogs.msdn.microsoft.com/oldnewthing/20040212-00/?p=40643/
|
||||||
# `UNICODE` affects Windows headers and `_UNICODE` affects C runtime header files.
|
# `UNICODE` affects Windows headers and `_UNICODE` affects C runtime header files.
|
||||||
# There is some discussion of this define at https://msdn.microsoft.com/en-us/library/dybsewaf.aspx
|
# There is some discussion of this define at https://msdn.microsoft.com/en-us/library/dybsewaf.aspx
|
||||||
|
|
@ -116,7 +116,7 @@ z3_add_cxx_flag("/analyze-" REQUIRED)
|
||||||
################################################################################
|
################################################################################
|
||||||
|
|
||||||
# By default CMake enables incremental linking for Debug and RelWithDebInfo
|
# By default CMake enables incremental linking for Debug and RelWithDebInfo
|
||||||
# builds. The old build sytem disables it for all builds so try to do the same
|
# builds. The old build system disables it for all builds so try to do the same
|
||||||
# by changing all configurations if necessary
|
# by changing all configurations if necessary
|
||||||
string(TOUPPER "${available_build_types}" _build_types_as_upper)
|
string(TOUPPER "${available_build_types}" _build_types_as_upper)
|
||||||
foreach (_build_type ${_build_types_as_upper})
|
foreach (_build_type ${_build_types_as_upper})
|
||||||
|
|
|
||||||
|
|
@ -7,7 +7,7 @@ function(z3_expand_dependencies output_var)
|
||||||
if (ARGC LESS 2)
|
if (ARGC LESS 2)
|
||||||
message(FATAL_ERROR "Invalid number of arguments")
|
message(FATAL_ERROR "Invalid number of arguments")
|
||||||
endif()
|
endif()
|
||||||
# Remaing args should be component names
|
# Remaining args should be component names
|
||||||
set(_expanded_deps ${ARGN})
|
set(_expanded_deps ${ARGN})
|
||||||
set(_old_number_of_deps 0)
|
set(_old_number_of_deps 0)
|
||||||
list(LENGTH _expanded_deps _number_of_deps)
|
list(LENGTH _expanded_deps _number_of_deps)
|
||||||
|
|
@ -33,7 +33,7 @@ function(z3_add_component_dependencies_to_target target_name)
|
||||||
if (NOT (TARGET ${target_name}))
|
if (NOT (TARGET ${target_name}))
|
||||||
message(FATAL_ERROR "Target \"${target_name}\" does not exist")
|
message(FATAL_ERROR "Target \"${target_name}\" does not exist")
|
||||||
endif()
|
endif()
|
||||||
# Remaing args should be component names
|
# Remaining args should be component names
|
||||||
set(_expanded_deps ${ARGN})
|
set(_expanded_deps ${ARGN})
|
||||||
foreach (dependency ${_expanded_deps})
|
foreach (dependency ${_expanded_deps})
|
||||||
# Ensure this component's dependencies are built before this component.
|
# Ensure this component's dependencies are built before this component.
|
||||||
|
|
@ -219,7 +219,7 @@ macro(z3_add_component component_name)
|
||||||
# Record this component's dependencies
|
# Record this component's dependencies
|
||||||
foreach (dependency ${Z3_MOD_COMPONENT_DEPENDENCIES})
|
foreach (dependency ${Z3_MOD_COMPONENT_DEPENDENCIES})
|
||||||
if (NOT (TARGET ${dependency}))
|
if (NOT (TARGET ${dependency}))
|
||||||
message(FATAL_ERROR "Component \"${component_name}\" depends on a non existant component \"${dependency}\"")
|
message(FATAL_ERROR "Component \"${component_name}\" depends on a non existent component \"${dependency}\"")
|
||||||
endif()
|
endif()
|
||||||
set_property(GLOBAL APPEND PROPERTY Z3_${component_name}_DEPS "${dependency}")
|
set_property(GLOBAL APPEND PROPERTY Z3_${component_name}_DEPS "${dependency}")
|
||||||
endforeach()
|
endforeach()
|
||||||
|
|
|
||||||
|
|
@ -1,4 +1,4 @@
|
||||||
# Continous integration scripts
|
# Continuous integration scripts
|
||||||
|
|
||||||
## TravisCI
|
## TravisCI
|
||||||
|
|
||||||
|
|
@ -45,7 +45,7 @@ the future.
|
||||||
* `Z3_VERBOSE_BUILD_OUTPUT` - Show compile commands in CMake builds (`0` or `1`)
|
* `Z3_VERBOSE_BUILD_OUTPUT` - Show compile commands in CMake builds (`0` or `1`)
|
||||||
* `Z3_STATIC_BUILD` - Build Z3 binaries and libraries statically (`0` or `1`)
|
* `Z3_STATIC_BUILD` - Build Z3 binaries and libraries statically (`0` or `1`)
|
||||||
* `Z3_SYSTEM_TEST_GIT_REVISION` - Git revision of [z3test](https://github.com/Z3Prover/z3test). If empty lastest revision will be used.
|
* `Z3_SYSTEM_TEST_GIT_REVISION` - Git revision of [z3test](https://github.com/Z3Prover/z3test). If empty lastest revision will be used.
|
||||||
* `Z3_WARNINGS_AS_ERRORS` - Set the `WARNINGS_AS_ERRORS` CMake option pased to Z3 (`OFF`, `ON`, or `SERIOUS_ONLY`)
|
* `Z3_WARNINGS_AS_ERRORS` - Set the `WARNINGS_AS_ERRORS` CMake option passed to Z3 (`OFF`, `ON`, or `SERIOUS_ONLY`)
|
||||||
|
|
||||||
### Linux
|
### Linux
|
||||||
|
|
||||||
|
|
|
||||||
93
doc/design_recfuns.md
Normal file
93
doc/design_recfuns.md
Normal file
|
|
@ -0,0 +1,93 @@
|
||||||
|
# Design for handling recursive functions
|
||||||
|
|
||||||
|
Main source of inspiration is [Sutter, Köksal & Kuncak 2011],
|
||||||
|
as implemented in Leon, but the main
|
||||||
|
differences is that we should unroll function definitions directly from the
|
||||||
|
inside of Z3, in a backtracking way. Termination and fairness are ensured by
|
||||||
|
iterative-deepening on the maximum number of unrollings in a given branch.
|
||||||
|
|
||||||
|
## Unfolding
|
||||||
|
|
||||||
|
The idea is that every function definition `f(x1…xn) := rhs[x1…xn]` is
|
||||||
|
compiled into:
|
||||||
|
|
||||||
|
- a list of cases `A_f_i[x1…xn] => f(x1…xn) = rhs_i[x1…xn]`.
|
||||||
|
When `A_f_i[t1…tn]` becomes true in the model, `f(t1…tn)` is said to be
|
||||||
|
*unfolded* and the clause `A_f_i[t1…tn] => f(t1…tn) = rhs_i[t1…tn]`
|
||||||
|
is added as an auxiliary clause.
|
||||||
|
- a list of constraints `Γ_f_i[x1…xn] <=> A_f_i[x1…xn]`
|
||||||
|
that states when `A_f_i[x1…xn]` should be true, depending on inputs `x1…xn`.
|
||||||
|
For every term `f(t1…tn)` present in congruence closure, we
|
||||||
|
immediately add all the `Γ_f_i[t1…tn] <=> A_f_i[t1…tn]` as auxiliary clauses
|
||||||
|
(maybe during internalization of `f(t1…tn)`?).
|
||||||
|
|
||||||
|
where each `A_f_i[x1…xn]` is a special new predicate representing the
|
||||||
|
given case of `f`, and `rhs_i` does not contain any `ite`.
|
||||||
|
We assume pattern matching has been compiled to `ite` beforehand.
|
||||||
|
|
||||||
|
For example, `fact(n) := if n<2 then 1 else n * fact(n-1)` is compiled into:
|
||||||
|
|
||||||
|
- `A_fact_0[n] => fact(n) = 1`
|
||||||
|
- `A_fact_1[n] => fact(n) = n * fact(n-1)`
|
||||||
|
- `A_fact_0[n] <=> n < 2`
|
||||||
|
- `A_fact_1[n] <=> ¬(n < 2)`
|
||||||
|
|
||||||
|
The 2 first clauses are only added when `A_fact_0[t]` is true
|
||||||
|
(respectively `A_fact_1[t]` is true).
|
||||||
|
The 2 other clauses are added as soon as `fact(t)` is internalized.
|
||||||
|
|
||||||
|
## Termination
|
||||||
|
|
||||||
|
To ensure termination, we define variables:
|
||||||
|
|
||||||
|
- `unfold_depth: int`
|
||||||
|
- `current_max_unfold_depth: int`
|
||||||
|
- `global_max_unfold_depth: int`
|
||||||
|
|
||||||
|
and a special literal `[max_depth=$n]` for each `n:int`.
|
||||||
|
Solving is done under the local assumption
|
||||||
|
`[max_depth=$current_max_unfold_depth]` (this should be handled in some outer
|
||||||
|
loop, e.g. in a custom tactic).
|
||||||
|
|
||||||
|
Whenever `A_f_i[t1…tn]` becomes true (for any `f`), we increment
|
||||||
|
`unfold_depth`. If `unfold_depth > current_max_unfold_depth`, then
|
||||||
|
the conflict clause `[max_depth=$current_max_unfold_depth] => Γ => false`
|
||||||
|
where `Γ` is the conjunction of all `A_f_i[t1…tn]` true in the trail.
|
||||||
|
|
||||||
|
For non-recursive functions, we don't have to increment `unfold_depth`. Some other functions that are known
|
||||||
|
|
||||||
|
If the solver answers "SAT", we have a model.
|
||||||
|
Otherwise, if `[max_depth=$current_max_unfold_depth]` is part of the
|
||||||
|
unsat-core, then we increase `current_max_unfold_depth`.
|
||||||
|
If `current_max_unfold_depth == global_max_unfold_depth` then
|
||||||
|
we report "UNKNOWN" (reached global depth limit), otherwise we can
|
||||||
|
try to `solve()` again with the new assumption (higher depth limit).
|
||||||
|
|
||||||
|
## Tactic
|
||||||
|
|
||||||
|
there should be a parametrized tactic `funrec(t, n)` where `t` is the tactic
|
||||||
|
used to solve (under assumption that depth is limited to `current_max_unfold_depth`)
|
||||||
|
and `n` is an integer that is assigned to `global_max_unfold_depth`.
|
||||||
|
|
||||||
|
This way, to try and find models for a problem with recursive functions + LIA,
|
||||||
|
one could use something like `(funrec (then simplify dl smt) 100)`.
|
||||||
|
|
||||||
|
## Expected benefits
|
||||||
|
|
||||||
|
This addition to Z3 would bring many benefits compared to current alternatives (Leon, quantifiers, …)
|
||||||
|
|
||||||
|
- should be very fast and lightweight
|
||||||
|
(compared to Leon or quantifiers).
|
||||||
|
In particular, every function call is very lightweight even compared to Leon (no need for full model building, followed by unsat core extraction)
|
||||||
|
- possibility of answering "SAT" for any `QF_*` fragment +
|
||||||
|
recursive functions
|
||||||
|
- makes `define-funs-rec` a first-class citizen of the language, usable to model user-defined theories or to analyze functional
|
||||||
|
programs directly
|
||||||
|
|
||||||
|
## Optimizations
|
||||||
|
|
||||||
|
- maybe `C_f_i` literals should never be decided on
|
||||||
|
(they can always be propagated).
|
||||||
|
Even stronger: they should not be part of conflicts?
|
||||||
|
(i.e. tune conflict resolution to always resolve
|
||||||
|
these literals away, disregarding their level)
|
||||||
|
|
@ -944,7 +944,7 @@ HTML_STYLESHEET =
|
||||||
# user-defined cascading style sheet that is included after the standard
|
# user-defined cascading style sheet that is included after the standard
|
||||||
# style sheets created by doxygen. Using this option one can overrule
|
# style sheets created by doxygen. Using this option one can overrule
|
||||||
# certain style aspects. This is preferred over using HTML_STYLESHEET
|
# certain style aspects. This is preferred over using HTML_STYLESHEET
|
||||||
# since it does not replace the standard style sheet and is therefor more
|
# since it does not replace the standard style sheet and is therefore more
|
||||||
# robust against future updates. Doxygen will copy the style sheet file to
|
# robust against future updates. Doxygen will copy the style sheet file to
|
||||||
# the output directory.
|
# the output directory.
|
||||||
|
|
||||||
|
|
@ -1711,7 +1711,7 @@ UML_LOOK = NO
|
||||||
# the class node. If there are many fields or methods and many nodes the
|
# the class node. If there are many fields or methods and many nodes the
|
||||||
# graph may become too big to be useful. The UML_LIMIT_NUM_FIELDS
|
# graph may become too big to be useful. The UML_LIMIT_NUM_FIELDS
|
||||||
# threshold limits the number of items for each type to make the size more
|
# threshold limits the number of items for each type to make the size more
|
||||||
# managable. Set this to 0 for no limit. Note that the threshold may be
|
# manageable. Set this to 0 for no limit. Note that the threshold may be
|
||||||
# exceeded by 50% before the limit is enforced.
|
# exceeded by 50% before the limit is enforced.
|
||||||
|
|
||||||
UML_LIMIT_NUM_FIELDS = 10
|
UML_LIMIT_NUM_FIELDS = 10
|
||||||
|
|
|
||||||
|
|
@ -7,8 +7,8 @@ find_package(Z3
|
||||||
REQUIRED
|
REQUIRED
|
||||||
CONFIG
|
CONFIG
|
||||||
# `NO_DEFAULT_PATH` is set so that -DZ3_DIR has to be passed to find Z3.
|
# `NO_DEFAULT_PATH` is set so that -DZ3_DIR has to be passed to find Z3.
|
||||||
# This should prevent us from accidently picking up an installed
|
# This should prevent us from accidentally picking up an installed
|
||||||
# copy of Z3. This is here to benefit Z3's build sytem when building
|
# copy of Z3. This is here to benefit Z3's build system when building
|
||||||
# this project. When making your own project you probably shouldn't
|
# this project. When making your own project you probably shouldn't
|
||||||
# use this option.
|
# use this option.
|
||||||
NO_DEFAULT_PATH
|
NO_DEFAULT_PATH
|
||||||
|
|
|
||||||
|
|
@ -5,6 +5,6 @@ in the build directory.
|
||||||
|
|
||||||
This command will create the executable cpp_example.
|
This command will create the executable cpp_example.
|
||||||
On Windows, you can just execute it.
|
On Windows, you can just execute it.
|
||||||
On OSX and Linux, you must install z3 first using
|
On macOS and Linux, you must install z3 first using
|
||||||
sudo make install
|
sudo make install
|
||||||
OR update LD_LIBRARY_PATH (Linux) or DYLD_LIBRARY_PATH (OSX) with the build directory. You need that to be able to find the Z3 shared library.
|
OR update LD_LIBRARY_PATH (Linux) or DYLD_LIBRARY_PATH (macOS) with the build directory. You need that to be able to find the Z3 shared library.
|
||||||
|
|
|
||||||
|
|
@ -835,6 +835,17 @@ void tst_visit() {
|
||||||
visit(f);
|
visit(f);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void tst_numeral() {
|
||||||
|
context c;
|
||||||
|
expr x = c.real_val("1/3");
|
||||||
|
double d = 0;
|
||||||
|
if (!x.is_numeral(d)) {
|
||||||
|
std::cout << x << " is not recognized as a numeral\n";
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
std::cout << x << " is " << d << "\n";
|
||||||
|
}
|
||||||
|
|
||||||
void incremental_example1() {
|
void incremental_example1() {
|
||||||
std::cout << "incremental example1\n";
|
std::cout << "incremental example1\n";
|
||||||
context c;
|
context c;
|
||||||
|
|
@ -1179,6 +1190,20 @@ void mk_model_example() {
|
||||||
std::cout << m.eval(a + b < 2)<< std::endl;
|
std::cout << m.eval(a + b < 2)<< std::endl;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void recfun_example() {
|
||||||
|
std::cout << "recfun example\n";
|
||||||
|
context c;
|
||||||
|
expr x = c.int_const("x");
|
||||||
|
expr y = c.int_const("y");
|
||||||
|
expr b = c.bool_const("b");
|
||||||
|
sort I = c.int_sort();
|
||||||
|
sort B = c.bool_sort();
|
||||||
|
func_decl f = recfun("f", I, B, I);
|
||||||
|
expr_vector args(c);
|
||||||
|
args.push_back(x); args.push_back(b);
|
||||||
|
c.recdef(f, args, ite(b, x, f(x + 1, !b)));
|
||||||
|
prove(f(x,c.bool_val(false)) > x);
|
||||||
|
}
|
||||||
|
|
||||||
int main() {
|
int main() {
|
||||||
|
|
||||||
|
|
@ -1212,6 +1237,7 @@ int main() {
|
||||||
tactic_example9(); std::cout << "\n";
|
tactic_example9(); std::cout << "\n";
|
||||||
tactic_qe(); std::cout << "\n";
|
tactic_qe(); std::cout << "\n";
|
||||||
tst_visit(); std::cout << "\n";
|
tst_visit(); std::cout << "\n";
|
||||||
|
tst_numeral(); std::cout << "\n";
|
||||||
incremental_example1(); std::cout << "\n";
|
incremental_example1(); std::cout << "\n";
|
||||||
incremental_example2(); std::cout << "\n";
|
incremental_example2(); std::cout << "\n";
|
||||||
incremental_example3(); std::cout << "\n";
|
incremental_example3(); std::cout << "\n";
|
||||||
|
|
@ -1227,6 +1253,7 @@ int main() {
|
||||||
consequence_example(); std::cout << "\n";
|
consequence_example(); std::cout << "\n";
|
||||||
parse_example(); std::cout << "\n";
|
parse_example(); std::cout << "\n";
|
||||||
mk_model_example(); std::cout << "\n";
|
mk_model_example(); std::cout << "\n";
|
||||||
|
recfun_example(); std::cout << "\n";
|
||||||
std::cout << "done\n";
|
std::cout << "done\n";
|
||||||
}
|
}
|
||||||
catch (exception & ex) {
|
catch (exception & ex) {
|
||||||
|
|
|
||||||
|
|
@ -24,8 +24,8 @@ find_package(Z3
|
||||||
REQUIRED
|
REQUIRED
|
||||||
CONFIG
|
CONFIG
|
||||||
# `NO_DEFAULT_PATH` is set so that -DZ3_DIR has to be passed to find Z3.
|
# `NO_DEFAULT_PATH` is set so that -DZ3_DIR has to be passed to find Z3.
|
||||||
# This should prevent us from accidently picking up an installed
|
# This should prevent us from accidentally picking up an installed
|
||||||
# copy of Z3. This is here to benefit Z3's build sytem when building
|
# copy of Z3. This is here to benefit Z3's build system when building
|
||||||
# this project. When making your own project you probably shouldn't
|
# this project. When making your own project you probably shouldn't
|
||||||
# use this option.
|
# use this option.
|
||||||
NO_DEFAULT_PATH
|
NO_DEFAULT_PATH
|
||||||
|
|
|
||||||
|
|
@ -5,7 +5,7 @@ in the build directory.
|
||||||
|
|
||||||
This command will create the executable c_example.
|
This command will create the executable c_example.
|
||||||
On Windows, you can just execute it.
|
On Windows, you can just execute it.
|
||||||
On OSX and Linux, you must install z3 first using
|
On macOS and Linux, you must install z3 first using
|
||||||
sudo make install
|
sudo make install
|
||||||
OR update LD_LIBRARY_PATH (Linux) or DYLD_LIBRARY_PATH (OSX) with the build directory. You need that to be able to find the Z3 shared library.
|
OR update LD_LIBRARY_PATH (Linux) or DYLD_LIBRARY_PATH (macOS) with the build directory. You need that to be able to find the Z3 shared library.
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -241,7 +241,7 @@ void check(Z3_context ctx, Z3_solver s, Z3_lbool expected_result)
|
||||||
|
|
||||||
The context \c ctx is not modified by this function.
|
The context \c ctx is not modified by this function.
|
||||||
*/
|
*/
|
||||||
void prove(Z3_context ctx, Z3_solver s, Z3_ast f, Z3_bool is_valid)
|
void prove(Z3_context ctx, Z3_solver s, Z3_ast f, bool is_valid)
|
||||||
{
|
{
|
||||||
Z3_model m = 0;
|
Z3_model m = 0;
|
||||||
Z3_ast not_f;
|
Z3_ast not_f;
|
||||||
|
|
@ -379,6 +379,7 @@ void assert_comm_axiom(Z3_context ctx, Z3_solver s, Z3_func_decl f)
|
||||||
Z3_sort t;
|
Z3_sort t;
|
||||||
Z3_symbol f_name, t_name;
|
Z3_symbol f_name, t_name;
|
||||||
Z3_ast_vector q;
|
Z3_ast_vector q;
|
||||||
|
unsigned i;
|
||||||
|
|
||||||
t = Z3_get_range(ctx, f);
|
t = Z3_get_range(ctx, f);
|
||||||
|
|
||||||
|
|
@ -399,7 +400,7 @@ void assert_comm_axiom(Z3_context ctx, Z3_solver s, Z3_func_decl f)
|
||||||
1, &t_name, &t,
|
1, &t_name, &t,
|
||||||
1, &f_name, &f);
|
1, &f_name, &f);
|
||||||
printf("assert axiom:\n%s\n", Z3_ast_vector_to_string(ctx, q));
|
printf("assert axiom:\n%s\n", Z3_ast_vector_to_string(ctx, q));
|
||||||
for (unsigned i = 0; i < Z3_ast_vector_size(ctx, q); ++i) {
|
for (i = 0; i < Z3_ast_vector_size(ctx, q); ++i) {
|
||||||
Z3_solver_assert(ctx, s, Z3_ast_vector_get(ctx, q, i));
|
Z3_solver_assert(ctx, s, Z3_ast_vector_get(ctx, q, i));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
@ -638,7 +639,7 @@ void display_model(Z3_context c, FILE * out, Z3_model m)
|
||||||
Z3_symbol name;
|
Z3_symbol name;
|
||||||
Z3_func_decl cnst = Z3_model_get_const_decl(c, m, i);
|
Z3_func_decl cnst = Z3_model_get_const_decl(c, m, i);
|
||||||
Z3_ast a, v;
|
Z3_ast a, v;
|
||||||
Z3_bool ok;
|
bool ok;
|
||||||
name = Z3_get_decl_name(c, cnst);
|
name = Z3_get_decl_name(c, cnst);
|
||||||
display_symbol(c, out, name);
|
display_symbol(c, out, name);
|
||||||
fprintf(out, " = ");
|
fprintf(out, " = ");
|
||||||
|
|
@ -898,7 +899,7 @@ void prove_example1()
|
||||||
/* prove g(x) = g(y) */
|
/* prove g(x) = g(y) */
|
||||||
f = Z3_mk_eq(ctx, gx, gy);
|
f = Z3_mk_eq(ctx, gx, gy);
|
||||||
printf("prove: x = y implies g(x) = g(y)\n");
|
printf("prove: x = y implies g(x) = g(y)\n");
|
||||||
prove(ctx, s, f, Z3_TRUE);
|
prove(ctx, s, f, true);
|
||||||
|
|
||||||
/* create g(g(x)) */
|
/* create g(g(x)) */
|
||||||
ggx = mk_unary_app(ctx, g, gx);
|
ggx = mk_unary_app(ctx, g, gx);
|
||||||
|
|
@ -906,7 +907,7 @@ void prove_example1()
|
||||||
/* disprove g(g(x)) = g(y) */
|
/* disprove g(g(x)) = g(y) */
|
||||||
f = Z3_mk_eq(ctx, ggx, gy);
|
f = Z3_mk_eq(ctx, ggx, gy);
|
||||||
printf("disprove: x = y implies g(g(x)) = g(y)\n");
|
printf("disprove: x = y implies g(g(x)) = g(y)\n");
|
||||||
prove(ctx, s, f, Z3_FALSE);
|
prove(ctx, s, f, false);
|
||||||
|
|
||||||
del_solver(ctx, s);
|
del_solver(ctx, s);
|
||||||
Z3_del_context(ctx);
|
Z3_del_context(ctx);
|
||||||
|
|
@ -978,13 +979,13 @@ void prove_example2()
|
||||||
/* prove z < 0 */
|
/* prove z < 0 */
|
||||||
f = Z3_mk_lt(ctx, z, zero);
|
f = Z3_mk_lt(ctx, z, zero);
|
||||||
printf("prove: not(g(g(x) - g(y)) = g(z)), x + z <= y <= x implies z < 0\n");
|
printf("prove: not(g(g(x) - g(y)) = g(z)), x + z <= y <= x implies z < 0\n");
|
||||||
prove(ctx, s, f, Z3_TRUE);
|
prove(ctx, s, f, true);
|
||||||
|
|
||||||
/* disprove z < -1 */
|
/* disprove z < -1 */
|
||||||
minus_one = mk_int(ctx, -1);
|
minus_one = mk_int(ctx, -1);
|
||||||
f = Z3_mk_lt(ctx, z, minus_one);
|
f = Z3_mk_lt(ctx, z, minus_one);
|
||||||
printf("disprove: not(g(g(x) - g(y)) = g(z)), x + z <= y <= x implies z < -1\n");
|
printf("disprove: not(g(g(x) - g(y)) = g(z)), x + z <= y <= x implies z < -1\n");
|
||||||
prove(ctx, s, f, Z3_FALSE);
|
prove(ctx, s, f, false);
|
||||||
|
|
||||||
del_solver(ctx, s);
|
del_solver(ctx, s);
|
||||||
Z3_del_context(ctx);
|
Z3_del_context(ctx);
|
||||||
|
|
@ -1130,7 +1131,7 @@ void quantifier_example1()
|
||||||
/* prove f(x, y) = f(w, v) implies y = v */
|
/* prove f(x, y) = f(w, v) implies y = v */
|
||||||
p2 = Z3_mk_eq(ctx, y, v);
|
p2 = Z3_mk_eq(ctx, y, v);
|
||||||
printf("prove: f(x, y) = f(w, v) implies y = v\n");
|
printf("prove: f(x, y) = f(w, v) implies y = v\n");
|
||||||
prove(ctx, s, p2, Z3_TRUE);
|
prove(ctx, s, p2, true);
|
||||||
|
|
||||||
/* disprove f(x, y) = f(w, v) implies x = w */
|
/* disprove f(x, y) = f(w, v) implies x = w */
|
||||||
/* using check2 instead of prove */
|
/* using check2 instead of prove */
|
||||||
|
|
@ -1197,7 +1198,7 @@ void array_example1()
|
||||||
thm = Z3_mk_implies(ctx, antecedent, consequent);
|
thm = Z3_mk_implies(ctx, antecedent, consequent);
|
||||||
printf("prove: store(a1, i1, v1) = store(a2, i2, v2) implies (i1 = i3 or i2 = i3 or select(a1, i3) = select(a2, i3))\n");
|
printf("prove: store(a1, i1, v1) = store(a2, i2, v2) implies (i1 = i3 or i2 = i3 or select(a1, i3) = select(a2, i3))\n");
|
||||||
printf("%s\n", Z3_ast_to_string(ctx, thm));
|
printf("%s\n", Z3_ast_to_string(ctx, thm));
|
||||||
prove(ctx, s, thm, Z3_TRUE);
|
prove(ctx, s, thm, true);
|
||||||
|
|
||||||
del_solver(ctx, s);
|
del_solver(ctx, s);
|
||||||
Z3_del_context(ctx);
|
Z3_del_context(ctx);
|
||||||
|
|
@ -1338,13 +1339,13 @@ void tuple_example1()
|
||||||
eq2 = Z3_mk_eq(ctx, x, one);
|
eq2 = Z3_mk_eq(ctx, x, one);
|
||||||
thm = Z3_mk_implies(ctx, eq1, eq2);
|
thm = Z3_mk_implies(ctx, eq1, eq2);
|
||||||
printf("prove: get_x(mk_pair(x, y)) = 1 implies x = 1\n");
|
printf("prove: get_x(mk_pair(x, y)) = 1 implies x = 1\n");
|
||||||
prove(ctx, s, thm, Z3_TRUE);
|
prove(ctx, s, thm, true);
|
||||||
|
|
||||||
/* disprove that get_x(mk_pair(x,y)) == 1 implies y = 1*/
|
/* disprove that get_x(mk_pair(x,y)) == 1 implies y = 1*/
|
||||||
eq3 = Z3_mk_eq(ctx, y, one);
|
eq3 = Z3_mk_eq(ctx, y, one);
|
||||||
thm = Z3_mk_implies(ctx, eq1, eq3);
|
thm = Z3_mk_implies(ctx, eq1, eq3);
|
||||||
printf("disprove: get_x(mk_pair(x, y)) = 1 implies y = 1\n");
|
printf("disprove: get_x(mk_pair(x, y)) = 1 implies y = 1\n");
|
||||||
prove(ctx, s, thm, Z3_FALSE);
|
prove(ctx, s, thm, false);
|
||||||
}
|
}
|
||||||
|
|
||||||
{
|
{
|
||||||
|
|
@ -1365,12 +1366,12 @@ void tuple_example1()
|
||||||
consequent = Z3_mk_eq(ctx, p1, p2);
|
consequent = Z3_mk_eq(ctx, p1, p2);
|
||||||
thm = Z3_mk_implies(ctx, antecedent, consequent);
|
thm = Z3_mk_implies(ctx, antecedent, consequent);
|
||||||
printf("prove: get_x(p1) = get_x(p2) and get_y(p1) = get_y(p2) implies p1 = p2\n");
|
printf("prove: get_x(p1) = get_x(p2) and get_y(p1) = get_y(p2) implies p1 = p2\n");
|
||||||
prove(ctx, s, thm, Z3_TRUE);
|
prove(ctx, s, thm, true);
|
||||||
|
|
||||||
/* disprove that get_x(p1) = get_x(p2) implies p1 = p2 */
|
/* disprove that get_x(p1) = get_x(p2) implies p1 = p2 */
|
||||||
thm = Z3_mk_implies(ctx, antecedents[0], consequent);
|
thm = Z3_mk_implies(ctx, antecedents[0], consequent);
|
||||||
printf("disprove: get_x(p1) = get_x(p2) implies p1 = p2\n");
|
printf("disprove: get_x(p1) = get_x(p2) implies p1 = p2\n");
|
||||||
prove(ctx, s, thm, Z3_FALSE);
|
prove(ctx, s, thm, false);
|
||||||
}
|
}
|
||||||
|
|
||||||
{
|
{
|
||||||
|
|
@ -1389,14 +1390,14 @@ void tuple_example1()
|
||||||
consequent = Z3_mk_eq(ctx, x, ten);
|
consequent = Z3_mk_eq(ctx, x, ten);
|
||||||
thm = Z3_mk_implies(ctx, antecedent, consequent);
|
thm = Z3_mk_implies(ctx, antecedent, consequent);
|
||||||
printf("prove: p2 = update(p1, 0, 10) implies get_x(p2) = 10\n");
|
printf("prove: p2 = update(p1, 0, 10) implies get_x(p2) = 10\n");
|
||||||
prove(ctx, s, thm, Z3_TRUE);
|
prove(ctx, s, thm, true);
|
||||||
|
|
||||||
/* disprove that p2 = update(p1, 0, 10) implies get_y(p2) = 10 */
|
/* disprove that p2 = update(p1, 0, 10) implies get_y(p2) = 10 */
|
||||||
y = mk_unary_app(ctx, get_y_decl, p2);
|
y = mk_unary_app(ctx, get_y_decl, p2);
|
||||||
consequent = Z3_mk_eq(ctx, y, ten);
|
consequent = Z3_mk_eq(ctx, y, ten);
|
||||||
thm = Z3_mk_implies(ctx, antecedent, consequent);
|
thm = Z3_mk_implies(ctx, antecedent, consequent);
|
||||||
printf("disprove: p2 = update(p1, 0, 10) implies get_y(p2) = 10\n");
|
printf("disprove: p2 = update(p1, 0, 10) implies get_y(p2) = 10\n");
|
||||||
prove(ctx, s, thm, Z3_FALSE);
|
prove(ctx, s, thm, false);
|
||||||
}
|
}
|
||||||
|
|
||||||
del_solver(ctx, s);
|
del_solver(ctx, s);
|
||||||
|
|
@ -1428,7 +1429,7 @@ void bitvector_example1()
|
||||||
c2 = Z3_mk_bvsle(ctx, x_minus_ten, zero);
|
c2 = Z3_mk_bvsle(ctx, x_minus_ten, zero);
|
||||||
thm = Z3_mk_iff(ctx, c1, c2);
|
thm = Z3_mk_iff(ctx, c1, c2);
|
||||||
printf("disprove: x - 10 <= 0 IFF x <= 10 for (32-bit) machine integers\n");
|
printf("disprove: x - 10 <= 0 IFF x <= 10 for (32-bit) machine integers\n");
|
||||||
prove(ctx, s, thm, Z3_FALSE);
|
prove(ctx, s, thm, false);
|
||||||
|
|
||||||
del_solver(ctx, s);
|
del_solver(ctx, s);
|
||||||
Z3_del_context(ctx);
|
Z3_del_context(ctx);
|
||||||
|
|
@ -1644,6 +1645,7 @@ void parser_example2()
|
||||||
Z3_symbol names[2];
|
Z3_symbol names[2];
|
||||||
Z3_func_decl decls[2];
|
Z3_func_decl decls[2];
|
||||||
Z3_ast_vector f;
|
Z3_ast_vector f;
|
||||||
|
unsigned i;
|
||||||
|
|
||||||
printf("\nparser_example2\n");
|
printf("\nparser_example2\n");
|
||||||
LOG_MSG("parser_example2");
|
LOG_MSG("parser_example2");
|
||||||
|
|
@ -1668,7 +1670,7 @@ void parser_example2()
|
||||||
2, names, decls);
|
2, names, decls);
|
||||||
printf("formula: %s\n", Z3_ast_vector_to_string(ctx, f));
|
printf("formula: %s\n", Z3_ast_vector_to_string(ctx, f));
|
||||||
printf("assert axiom:\n%s\n", Z3_ast_vector_to_string(ctx, f));
|
printf("assert axiom:\n%s\n", Z3_ast_vector_to_string(ctx, f));
|
||||||
for (unsigned i = 0; i < Z3_ast_vector_size(ctx, f); ++i) {
|
for (i = 0; i < Z3_ast_vector_size(ctx, f); ++i) {
|
||||||
Z3_solver_assert(ctx, s, Z3_ast_vector_get(ctx, f, i));
|
Z3_solver_assert(ctx, s, Z3_ast_vector_get(ctx, f, i));
|
||||||
}
|
}
|
||||||
check(ctx, s, Z3_L_TRUE);
|
check(ctx, s, Z3_L_TRUE);
|
||||||
|
|
@ -1695,7 +1697,7 @@ void parser_example3()
|
||||||
LOG_MSG("parser_example3");
|
LOG_MSG("parser_example3");
|
||||||
|
|
||||||
cfg = Z3_mk_config();
|
cfg = Z3_mk_config();
|
||||||
/* See quantifer_example1 */
|
/* See quantifier_example1 */
|
||||||
Z3_set_param_value(cfg, "model", "true");
|
Z3_set_param_value(cfg, "model", "true");
|
||||||
ctx = mk_context_custom(cfg, error_handler);
|
ctx = mk_context_custom(cfg, error_handler);
|
||||||
Z3_del_config(cfg);
|
Z3_del_config(cfg);
|
||||||
|
|
@ -1715,7 +1717,7 @@ void parser_example3()
|
||||||
0, 0, 0,
|
0, 0, 0,
|
||||||
1, &g_name, &g);
|
1, &g_name, &g);
|
||||||
printf("formula: %s\n", Z3_ast_vector_to_string(ctx, thm));
|
printf("formula: %s\n", Z3_ast_vector_to_string(ctx, thm));
|
||||||
prove(ctx, s, Z3_ast_vector_get(ctx, thm, 0), Z3_TRUE);
|
prove(ctx, s, Z3_ast_vector_get(ctx, thm, 0), true);
|
||||||
|
|
||||||
del_solver(ctx, s);
|
del_solver(ctx, s);
|
||||||
Z3_del_context(ctx);
|
Z3_del_context(ctx);
|
||||||
|
|
@ -1779,13 +1781,13 @@ void numeral_example() {
|
||||||
n2 = Z3_mk_numeral(ctx, "0.5", real_ty);
|
n2 = Z3_mk_numeral(ctx, "0.5", real_ty);
|
||||||
printf("Numerals n1:%s", Z3_ast_to_string(ctx, n1));
|
printf("Numerals n1:%s", Z3_ast_to_string(ctx, n1));
|
||||||
printf(" n2:%s\n", Z3_ast_to_string(ctx, n2));
|
printf(" n2:%s\n", Z3_ast_to_string(ctx, n2));
|
||||||
prove(ctx, s, Z3_mk_eq(ctx, n1, n2), Z3_TRUE);
|
prove(ctx, s, Z3_mk_eq(ctx, n1, n2), true);
|
||||||
|
|
||||||
n1 = Z3_mk_numeral(ctx, "-1/3", real_ty);
|
n1 = Z3_mk_numeral(ctx, "-1/3", real_ty);
|
||||||
n2 = Z3_mk_numeral(ctx, "-0.33333333333333333333333333333333333333333333333333", real_ty);
|
n2 = Z3_mk_numeral(ctx, "-0.33333333333333333333333333333333333333333333333333", real_ty);
|
||||||
printf("Numerals n1:%s", Z3_ast_to_string(ctx, n1));
|
printf("Numerals n1:%s", Z3_ast_to_string(ctx, n1));
|
||||||
printf(" n2:%s\n", Z3_ast_to_string(ctx, n2));
|
printf(" n2:%s\n", Z3_ast_to_string(ctx, n2));
|
||||||
prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, n1, n2)), Z3_TRUE);
|
prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, n1, n2)), true);
|
||||||
del_solver(ctx, s);
|
del_solver(ctx, s);
|
||||||
Z3_del_context(ctx);
|
Z3_del_context(ctx);
|
||||||
}
|
}
|
||||||
|
|
@ -1850,14 +1852,14 @@ void enum_example() {
|
||||||
orange = Z3_mk_app(ctx, enum_consts[2], 0, 0);
|
orange = Z3_mk_app(ctx, enum_consts[2], 0, 0);
|
||||||
|
|
||||||
/* Apples are different from oranges */
|
/* Apples are different from oranges */
|
||||||
prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, apple, orange)), Z3_TRUE);
|
prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, apple, orange)), true);
|
||||||
|
|
||||||
/* Apples pass the apple test */
|
/* Apples pass the apple test */
|
||||||
prove(ctx, s, Z3_mk_app(ctx, enum_testers[0], 1, &apple), Z3_TRUE);
|
prove(ctx, s, Z3_mk_app(ctx, enum_testers[0], 1, &apple), true);
|
||||||
|
|
||||||
/* Oranges fail the apple test */
|
/* Oranges fail the apple test */
|
||||||
prove(ctx, s, Z3_mk_app(ctx, enum_testers[0], 1, &orange), Z3_FALSE);
|
prove(ctx, s, Z3_mk_app(ctx, enum_testers[0], 1, &orange), false);
|
||||||
prove(ctx, s, Z3_mk_not(ctx, Z3_mk_app(ctx, enum_testers[0], 1, &orange)), Z3_TRUE);
|
prove(ctx, s, Z3_mk_not(ctx, Z3_mk_app(ctx, enum_testers[0], 1, &orange)), true);
|
||||||
|
|
||||||
fruity = mk_var(ctx, "fruity", fruit);
|
fruity = mk_var(ctx, "fruity", fruit);
|
||||||
|
|
||||||
|
|
@ -1866,7 +1868,7 @@ void enum_example() {
|
||||||
ors[1] = Z3_mk_eq(ctx, fruity, banana);
|
ors[1] = Z3_mk_eq(ctx, fruity, banana);
|
||||||
ors[2] = Z3_mk_eq(ctx, fruity, orange);
|
ors[2] = Z3_mk_eq(ctx, fruity, orange);
|
||||||
|
|
||||||
prove(ctx, s, Z3_mk_or(ctx, 3, ors), Z3_TRUE);
|
prove(ctx, s, Z3_mk_or(ctx, 3, ors), true);
|
||||||
|
|
||||||
/* delete logical context */
|
/* delete logical context */
|
||||||
del_solver(ctx, s);
|
del_solver(ctx, s);
|
||||||
|
|
@ -1898,41 +1900,41 @@ void list_example() {
|
||||||
l2 = mk_binary_app(ctx, cons_decl, mk_int(ctx, 2), nil);
|
l2 = mk_binary_app(ctx, cons_decl, mk_int(ctx, 2), nil);
|
||||||
|
|
||||||
/* nil != cons(1, nil) */
|
/* nil != cons(1, nil) */
|
||||||
prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, nil, l1)), Z3_TRUE);
|
prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, nil, l1)), true);
|
||||||
|
|
||||||
/* cons(2,nil) != cons(1, nil) */
|
/* cons(2,nil) != cons(1, nil) */
|
||||||
prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, l1, l2)), Z3_TRUE);
|
prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, l1, l2)), true);
|
||||||
|
|
||||||
/* cons(x,nil) = cons(y, nil) => x = y */
|
/* cons(x,nil) = cons(y, nil) => x = y */
|
||||||
x = mk_var(ctx, "x", int_ty);
|
x = mk_var(ctx, "x", int_ty);
|
||||||
y = mk_var(ctx, "y", int_ty);
|
y = mk_var(ctx, "y", int_ty);
|
||||||
l1 = mk_binary_app(ctx, cons_decl, x, nil);
|
l1 = mk_binary_app(ctx, cons_decl, x, nil);
|
||||||
l2 = mk_binary_app(ctx, cons_decl, y, nil);
|
l2 = mk_binary_app(ctx, cons_decl, y, nil);
|
||||||
prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, x, y)), Z3_TRUE);
|
prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, x, y)), true);
|
||||||
|
|
||||||
/* cons(x,u) = cons(x, v) => u = v */
|
/* cons(x,u) = cons(x, v) => u = v */
|
||||||
u = mk_var(ctx, "u", int_list);
|
u = mk_var(ctx, "u", int_list);
|
||||||
v = mk_var(ctx, "v", int_list);
|
v = mk_var(ctx, "v", int_list);
|
||||||
l1 = mk_binary_app(ctx, cons_decl, x, u);
|
l1 = mk_binary_app(ctx, cons_decl, x, u);
|
||||||
l2 = mk_binary_app(ctx, cons_decl, y, v);
|
l2 = mk_binary_app(ctx, cons_decl, y, v);
|
||||||
prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, u, v)), Z3_TRUE);
|
prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, u, v)), true);
|
||||||
prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, x, y)), Z3_TRUE);
|
prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, x, y)), true);
|
||||||
|
|
||||||
/* is_nil(u) or is_cons(u) */
|
/* is_nil(u) or is_cons(u) */
|
||||||
ors[0] = Z3_mk_app(ctx, is_nil_decl, 1, &u);
|
ors[0] = Z3_mk_app(ctx, is_nil_decl, 1, &u);
|
||||||
ors[1] = Z3_mk_app(ctx, is_cons_decl, 1, &u);
|
ors[1] = Z3_mk_app(ctx, is_cons_decl, 1, &u);
|
||||||
prove(ctx, s, Z3_mk_or(ctx, 2, ors), Z3_TRUE);
|
prove(ctx, s, Z3_mk_or(ctx, 2, ors), true);
|
||||||
|
|
||||||
/* occurs check u != cons(x,u) */
|
/* occurs check u != cons(x,u) */
|
||||||
prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, u, l1)), Z3_TRUE);
|
prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, u, l1)), true);
|
||||||
|
|
||||||
/* destructors: is_cons(u) => u = cons(head(u),tail(u)) */
|
/* destructors: is_cons(u) => u = cons(head(u),tail(u)) */
|
||||||
fml1 = Z3_mk_eq(ctx, u, mk_binary_app(ctx, cons_decl, mk_unary_app(ctx, head_decl, u), mk_unary_app(ctx, tail_decl, u)));
|
fml1 = Z3_mk_eq(ctx, u, mk_binary_app(ctx, cons_decl, mk_unary_app(ctx, head_decl, u), mk_unary_app(ctx, tail_decl, u)));
|
||||||
fml = Z3_mk_implies(ctx, Z3_mk_app(ctx, is_cons_decl, 1, &u), fml1);
|
fml = Z3_mk_implies(ctx, Z3_mk_app(ctx, is_cons_decl, 1, &u), fml1);
|
||||||
printf("Formula %s\n", Z3_ast_to_string(ctx, fml));
|
printf("Formula %s\n", Z3_ast_to_string(ctx, fml));
|
||||||
prove(ctx, s, fml, Z3_TRUE);
|
prove(ctx, s, fml, true);
|
||||||
|
|
||||||
prove(ctx, s, fml1, Z3_FALSE);
|
prove(ctx, s, fml1, false);
|
||||||
|
|
||||||
/* delete logical context */
|
/* delete logical context */
|
||||||
del_solver(ctx, s);
|
del_solver(ctx, s);
|
||||||
|
|
@ -1980,7 +1982,7 @@ void tree_example() {
|
||||||
l2 = mk_binary_app(ctx, cons_decl, l1, nil);
|
l2 = mk_binary_app(ctx, cons_decl, l1, nil);
|
||||||
|
|
||||||
/* nil != cons(nil, nil) */
|
/* nil != cons(nil, nil) */
|
||||||
prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, nil, l1)), Z3_TRUE);
|
prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, nil, l1)), true);
|
||||||
|
|
||||||
/* cons(x,u) = cons(x, v) => u = v */
|
/* cons(x,u) = cons(x, v) => u = v */
|
||||||
u = mk_var(ctx, "u", cell);
|
u = mk_var(ctx, "u", cell);
|
||||||
|
|
@ -1989,24 +1991,24 @@ void tree_example() {
|
||||||
y = mk_var(ctx, "y", cell);
|
y = mk_var(ctx, "y", cell);
|
||||||
l1 = mk_binary_app(ctx, cons_decl, x, u);
|
l1 = mk_binary_app(ctx, cons_decl, x, u);
|
||||||
l2 = mk_binary_app(ctx, cons_decl, y, v);
|
l2 = mk_binary_app(ctx, cons_decl, y, v);
|
||||||
prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, u, v)), Z3_TRUE);
|
prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, u, v)), true);
|
||||||
prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, x, y)), Z3_TRUE);
|
prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, x, y)), true);
|
||||||
|
|
||||||
/* is_nil(u) or is_cons(u) */
|
/* is_nil(u) or is_cons(u) */
|
||||||
ors[0] = Z3_mk_app(ctx, is_nil_decl, 1, &u);
|
ors[0] = Z3_mk_app(ctx, is_nil_decl, 1, &u);
|
||||||
ors[1] = Z3_mk_app(ctx, is_cons_decl, 1, &u);
|
ors[1] = Z3_mk_app(ctx, is_cons_decl, 1, &u);
|
||||||
prove(ctx, s, Z3_mk_or(ctx, 2, ors), Z3_TRUE);
|
prove(ctx, s, Z3_mk_or(ctx, 2, ors), true);
|
||||||
|
|
||||||
/* occurs check u != cons(x,u) */
|
/* occurs check u != cons(x,u) */
|
||||||
prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, u, l1)), Z3_TRUE);
|
prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, u, l1)), true);
|
||||||
|
|
||||||
/* destructors: is_cons(u) => u = cons(car(u),cdr(u)) */
|
/* destructors: is_cons(u) => u = cons(car(u),cdr(u)) */
|
||||||
fml1 = Z3_mk_eq(ctx, u, mk_binary_app(ctx, cons_decl, mk_unary_app(ctx, car_decl, u), mk_unary_app(ctx, cdr_decl, u)));
|
fml1 = Z3_mk_eq(ctx, u, mk_binary_app(ctx, cons_decl, mk_unary_app(ctx, car_decl, u), mk_unary_app(ctx, cdr_decl, u)));
|
||||||
fml = Z3_mk_implies(ctx, Z3_mk_app(ctx, is_cons_decl, 1, &u), fml1);
|
fml = Z3_mk_implies(ctx, Z3_mk_app(ctx, is_cons_decl, 1, &u), fml1);
|
||||||
printf("Formula %s\n", Z3_ast_to_string(ctx, fml));
|
printf("Formula %s\n", Z3_ast_to_string(ctx, fml));
|
||||||
prove(ctx, s, fml, Z3_TRUE);
|
prove(ctx, s, fml, true);
|
||||||
|
|
||||||
prove(ctx, s, fml1, Z3_FALSE);
|
prove(ctx, s, fml1, false);
|
||||||
|
|
||||||
/* delete logical context */
|
/* delete logical context */
|
||||||
del_solver(ctx, s);
|
del_solver(ctx, s);
|
||||||
|
|
@ -2098,8 +2100,8 @@ void forest_example() {
|
||||||
|
|
||||||
|
|
||||||
/* nil != cons(nil,nil) */
|
/* nil != cons(nil,nil) */
|
||||||
prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, nil1, f1)), Z3_TRUE);
|
prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, nil1, f1)), true);
|
||||||
prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, nil2, t1)), Z3_TRUE);
|
prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, nil2, t1)), true);
|
||||||
|
|
||||||
|
|
||||||
/* cons(x,u) = cons(x, v) => u = v */
|
/* cons(x,u) = cons(x, v) => u = v */
|
||||||
|
|
@ -2109,16 +2111,16 @@ void forest_example() {
|
||||||
y = mk_var(ctx, "y", tree);
|
y = mk_var(ctx, "y", tree);
|
||||||
l1 = mk_binary_app(ctx, cons1_decl, x, u);
|
l1 = mk_binary_app(ctx, cons1_decl, x, u);
|
||||||
l2 = mk_binary_app(ctx, cons1_decl, y, v);
|
l2 = mk_binary_app(ctx, cons1_decl, y, v);
|
||||||
prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, u, v)), Z3_TRUE);
|
prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, u, v)), true);
|
||||||
prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, x, y)), Z3_TRUE);
|
prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, x, y)), true);
|
||||||
|
|
||||||
/* is_nil(u) or is_cons(u) */
|
/* is_nil(u) or is_cons(u) */
|
||||||
ors[0] = Z3_mk_app(ctx, is_nil1_decl, 1, &u);
|
ors[0] = Z3_mk_app(ctx, is_nil1_decl, 1, &u);
|
||||||
ors[1] = Z3_mk_app(ctx, is_cons1_decl, 1, &u);
|
ors[1] = Z3_mk_app(ctx, is_cons1_decl, 1, &u);
|
||||||
prove(ctx, s, Z3_mk_or(ctx, 2, ors), Z3_TRUE);
|
prove(ctx, s, Z3_mk_or(ctx, 2, ors), true);
|
||||||
|
|
||||||
/* occurs check u != cons(x,u) */
|
/* occurs check u != cons(x,u) */
|
||||||
prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, u, l1)), Z3_TRUE);
|
prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, u, l1)), true);
|
||||||
|
|
||||||
/* delete logical context */
|
/* delete logical context */
|
||||||
del_solver(ctx, s);
|
del_solver(ctx, s);
|
||||||
|
|
@ -2191,19 +2193,19 @@ void binary_tree_example() {
|
||||||
Z3_ast node3 = Z3_mk_app(ctx, node_decl, 3, args3);
|
Z3_ast node3 = Z3_mk_app(ctx, node_decl, 3, args3);
|
||||||
|
|
||||||
/* prove that nil != node1 */
|
/* prove that nil != node1 */
|
||||||
prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, nil, node1)), Z3_TRUE);
|
prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, nil, node1)), true);
|
||||||
|
|
||||||
/* prove that nil = left(node1) */
|
/* prove that nil = left(node1) */
|
||||||
prove(ctx, s, Z3_mk_eq(ctx, nil, mk_unary_app(ctx, left_decl, node1)), Z3_TRUE);
|
prove(ctx, s, Z3_mk_eq(ctx, nil, mk_unary_app(ctx, left_decl, node1)), true);
|
||||||
|
|
||||||
/* prove that node1 = right(node3) */
|
/* prove that node1 = right(node3) */
|
||||||
prove(ctx, s, Z3_mk_eq(ctx, node1, mk_unary_app(ctx, right_decl, node3)), Z3_TRUE);
|
prove(ctx, s, Z3_mk_eq(ctx, node1, mk_unary_app(ctx, right_decl, node3)), true);
|
||||||
|
|
||||||
/* prove that !is-nil(node2) */
|
/* prove that !is-nil(node2) */
|
||||||
prove(ctx, s, Z3_mk_not(ctx, mk_unary_app(ctx, is_nil_decl, node2)), Z3_TRUE);
|
prove(ctx, s, Z3_mk_not(ctx, mk_unary_app(ctx, is_nil_decl, node2)), true);
|
||||||
|
|
||||||
/* prove that value(node2) >= 0 */
|
/* prove that value(node2) >= 0 */
|
||||||
prove(ctx, s, Z3_mk_ge(ctx, mk_unary_app(ctx, value_decl, node2), mk_int(ctx, 0)), Z3_TRUE);
|
prove(ctx, s, Z3_mk_ge(ctx, mk_unary_app(ctx, value_decl, node2), mk_int(ctx, 0)), true);
|
||||||
}
|
}
|
||||||
|
|
||||||
/* delete logical context */
|
/* delete logical context */
|
||||||
|
|
@ -2302,7 +2304,7 @@ typedef struct {
|
||||||
// IMPORTANT: the fields m_answer_literals, m_retracted and m_num_answer_literals must be saved/restored
|
// IMPORTANT: the fields m_answer_literals, m_retracted and m_num_answer_literals must be saved/restored
|
||||||
// if push/pop operations are performed on m_context.
|
// if push/pop operations are performed on m_context.
|
||||||
Z3_ast m_answer_literals[MAX_RETRACTABLE_ASSERTIONS];
|
Z3_ast m_answer_literals[MAX_RETRACTABLE_ASSERTIONS];
|
||||||
Z3_bool m_retracted[MAX_RETRACTABLE_ASSERTIONS]; // true if the assertion was retracted.
|
bool m_retracted[MAX_RETRACTABLE_ASSERTIONS]; // true if the assertion was retracted.
|
||||||
unsigned m_num_answer_literals;
|
unsigned m_num_answer_literals;
|
||||||
} Z3_ext_context_struct;
|
} Z3_ext_context_struct;
|
||||||
|
|
||||||
|
|
@ -2345,7 +2347,7 @@ unsigned assert_retractable_cnstr(Z3_ext_context ctx, Z3_ast c) {
|
||||||
ans_lit = Z3_mk_fresh_const(ctx->m_context, "k", ty);
|
ans_lit = Z3_mk_fresh_const(ctx->m_context, "k", ty);
|
||||||
result = ctx->m_num_answer_literals;
|
result = ctx->m_num_answer_literals;
|
||||||
ctx->m_answer_literals[result] = ans_lit;
|
ctx->m_answer_literals[result] = ans_lit;
|
||||||
ctx->m_retracted[result] = Z3_FALSE;
|
ctx->m_retracted[result] = false;
|
||||||
ctx->m_num_answer_literals++;
|
ctx->m_num_answer_literals++;
|
||||||
// assert: c OR (not ans_lit)
|
// assert: c OR (not ans_lit)
|
||||||
args[0] = c;
|
args[0] = c;
|
||||||
|
|
@ -2361,7 +2363,7 @@ void retract_cnstr(Z3_ext_context ctx, unsigned id) {
|
||||||
if (id >= ctx->m_num_answer_literals) {
|
if (id >= ctx->m_num_answer_literals) {
|
||||||
exitf("invalid constraint id.");
|
exitf("invalid constraint id.");
|
||||||
}
|
}
|
||||||
ctx->m_retracted[id] = Z3_TRUE;
|
ctx->m_retracted[id] = true;
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
|
@ -2371,7 +2373,7 @@ void reassert_cnstr(Z3_ext_context ctx, unsigned id) {
|
||||||
if (id >= ctx->m_num_answer_literals) {
|
if (id >= ctx->m_num_answer_literals) {
|
||||||
exitf("invalid constraint id.");
|
exitf("invalid constraint id.");
|
||||||
}
|
}
|
||||||
ctx->m_retracted[id] = Z3_FALSE;
|
ctx->m_retracted[id] = false;
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
|
@ -2385,7 +2387,7 @@ Z3_lbool ext_check(Z3_ext_context ctx) {
|
||||||
unsigned core_size;
|
unsigned core_size;
|
||||||
unsigned i;
|
unsigned i;
|
||||||
for (i = 0; i < ctx->m_num_answer_literals; i++) {
|
for (i = 0; i < ctx->m_num_answer_literals; i++) {
|
||||||
if (ctx->m_retracted[i] == Z3_FALSE) {
|
if (ctx->m_retracted[i] == false) {
|
||||||
// Since the answer literal was not retracted, we added it as an assumption.
|
// Since the answer literal was not retracted, we added it as an assumption.
|
||||||
// Recall that we assert (C \/ (not ans_lit)). Therefore, adding ans_lit as an assumption has the effect of "asserting" C.
|
// Recall that we assert (C \/ (not ans_lit)). Therefore, adding ans_lit as an assumption has the effect of "asserting" C.
|
||||||
// If the constraint was "retracted" (ctx->m_retracted[i] == Z3_true), then we don't really need to add (not ans_lit) as an assumption.
|
// If the constraint was "retracted" (ctx->m_retracted[i] == Z3_true), then we don't really need to add (not ans_lit) as an assumption.
|
||||||
|
|
@ -2870,19 +2872,19 @@ void mk_model_example() {
|
||||||
/*num_args=*/2,
|
/*num_args=*/2,
|
||||||
/*args=*/addArgs);
|
/*args=*/addArgs);
|
||||||
Z3_ast aPlusBEval = NULL;
|
Z3_ast aPlusBEval = NULL;
|
||||||
Z3_bool aPlusBEvalSuccess =
|
bool aPlusBEvalSuccess =
|
||||||
Z3_model_eval(ctx, m, aPlusB,
|
Z3_model_eval(ctx, m, aPlusB,
|
||||||
/*model_completion=*/Z3_FALSE, &aPlusBEval);
|
/*model_completion=*/false, &aPlusBEval);
|
||||||
if (aPlusBEvalSuccess != Z3_TRUE) {
|
if (aPlusBEvalSuccess != true) {
|
||||||
printf("Failed to evaluate model\n");
|
printf("Failed to evaluate model\n");
|
||||||
exit(1);
|
exit(1);
|
||||||
}
|
}
|
||||||
|
|
||||||
{
|
{
|
||||||
int aPlusBValue = 0;
|
int aPlusBValue = 0;
|
||||||
Z3_bool getAPlusBValueSuccess =
|
bool getAPlusBValueSuccess =
|
||||||
Z3_get_numeral_int(ctx, aPlusBEval, &aPlusBValue);
|
Z3_get_numeral_int(ctx, aPlusBEval, &aPlusBValue);
|
||||||
if (getAPlusBValueSuccess != Z3_TRUE) {
|
if (getAPlusBValueSuccess != true) {
|
||||||
printf("Failed to get integer value for a+b\n");
|
printf("Failed to get integer value for a+b\n");
|
||||||
exit(1);
|
exit(1);
|
||||||
}
|
}
|
||||||
|
|
@ -2904,18 +2906,18 @@ void mk_model_example() {
|
||||||
/*num_args=*/3,
|
/*num_args=*/3,
|
||||||
/*args=*/arrayAddArgs);
|
/*args=*/arrayAddArgs);
|
||||||
Z3_ast arrayAddEval = NULL;
|
Z3_ast arrayAddEval = NULL;
|
||||||
Z3_bool arrayAddEvalSuccess =
|
bool arrayAddEvalSuccess =
|
||||||
Z3_model_eval(ctx, m, arrayAdd,
|
Z3_model_eval(ctx, m, arrayAdd,
|
||||||
/*model_completion=*/Z3_FALSE, &arrayAddEval);
|
/*model_completion=*/false, &arrayAddEval);
|
||||||
if (arrayAddEvalSuccess != Z3_TRUE) {
|
if (arrayAddEvalSuccess != true) {
|
||||||
printf("Failed to evaluate model\n");
|
printf("Failed to evaluate model\n");
|
||||||
exit(1);
|
exit(1);
|
||||||
}
|
}
|
||||||
{
|
{
|
||||||
int arrayAddValue = 0;
|
int arrayAddValue = 0;
|
||||||
Z3_bool getArrayAddValueSuccess =
|
bool getArrayAddValueSuccess =
|
||||||
Z3_get_numeral_int(ctx, arrayAddEval, &arrayAddValue);
|
Z3_get_numeral_int(ctx, arrayAddEval, &arrayAddValue);
|
||||||
if (getArrayAddValueSuccess != Z3_TRUE) {
|
if (getArrayAddValueSuccess != true) {
|
||||||
printf("Failed to get integer value for c[0] + c[1] + c[2]\n");
|
printf("Failed to get integer value for c[0] + c[1] + c[2]\n");
|
||||||
exit(1);
|
exit(1);
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -363,10 +363,10 @@ namespace test_mapi
|
||||||
|
|
||||||
Console.WriteLine("Model = " + s.Model);
|
Console.WriteLine("Model = " + s.Model);
|
||||||
|
|
||||||
Console.WriteLine("Interpretation of MyArray:\n" + s.Model.FuncInterp(aex.FuncDecl));
|
//Console.WriteLine("Interpretation of MyArray:\n" + s.Model.ConstInterp(aex.FuncDecl));
|
||||||
Console.WriteLine("Interpretation of x:\n" + s.Model.ConstInterp(xc));
|
Console.WriteLine("Interpretation of x:\n" + s.Model.ConstInterp(xc));
|
||||||
Console.WriteLine("Interpretation of f:\n" + s.Model.FuncInterp(fd));
|
Console.WriteLine("Interpretation of f:\n" + s.Model.FuncInterp(fd));
|
||||||
Console.WriteLine("Interpretation of MyArray as Term:\n" + s.Model.FuncInterp(aex.FuncDecl));
|
//Console.WriteLine("Interpretation of MyArray as Term:\n" + s.Model.ConstInterp(aex.FuncDecl));
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
|
|
|
||||||
|
|
@ -10,5 +10,5 @@ which can be run on Windows via
|
||||||
|
|
||||||
On Linux and FreeBSD, we must use
|
On Linux and FreeBSD, we must use
|
||||||
LD_LIBRARY_PATH=. java -cp com.microsoft.z3.jar:. JavaExample
|
LD_LIBRARY_PATH=. java -cp com.microsoft.z3.jar:. JavaExample
|
||||||
On OSX, the corresponding option is DYLD_LIBRARY_PATH:
|
On macOS, the corresponding option is DYLD_LIBRARY_PATH:
|
||||||
DYLD_LIBRARY_PATH=. java -cp com.microsoft.z3.jar:. JavaExample
|
DYLD_LIBRARY_PATH=. java -cp com.microsoft.z3.jar:. JavaExample
|
||||||
|
|
|
||||||
|
|
@ -11,8 +11,8 @@ find_package(Z3
|
||||||
REQUIRED
|
REQUIRED
|
||||||
CONFIG
|
CONFIG
|
||||||
# `NO_DEFAULT_PATH` is set so that -DZ3_DIR has to be passed to find Z3.
|
# `NO_DEFAULT_PATH` is set so that -DZ3_DIR has to be passed to find Z3.
|
||||||
# This should prevent us from accidently picking up an installed
|
# This should prevent us from accidentally picking up an installed
|
||||||
# copy of Z3. This is here to benefit Z3's build sytem when building
|
# copy of Z3. This is here to benefit Z3's build system when building
|
||||||
# this project. When making your own project you probably shouldn't
|
# this project. When making your own project you probably shouldn't
|
||||||
# use this option.
|
# use this option.
|
||||||
NO_DEFAULT_PATH
|
NO_DEFAULT_PATH
|
||||||
|
|
|
||||||
|
|
@ -5,8 +5,8 @@ in the build directory.
|
||||||
|
|
||||||
This command will create the executable maxsat.
|
This command will create the executable maxsat.
|
||||||
On Windows, you can just execute it.
|
On Windows, you can just execute it.
|
||||||
On OSX and Linux, you must install z3 first using
|
On macOS and Linux, you must install z3 first using
|
||||||
sudo make install
|
sudo make install
|
||||||
OR update LD_LIBRARY_PATH (Linux) or DYLD_LIBRARY_PATH (OSX) with the build directory. You need that to be able to find the Z3 shared library.
|
OR update LD_LIBRARY_PATH (Linux) or DYLD_LIBRARY_PATH (macOS) with the build directory. You need that to be able to find the Z3 shared library.
|
||||||
|
|
||||||
This directory contains a test file (ex.smt) that can be used as input for the maxsat test application.
|
This directory contains a test file (ex.smt) that can be used as input for the maxsat test application.
|
||||||
|
|
|
||||||
|
|
@ -138,7 +138,7 @@ void assert_hard_constraints(Z3_context ctx, Z3_solver s, unsigned num_cnstrs, Z
|
||||||
|
|
||||||
/**
|
/**
|
||||||
\brief Assert soft constraints stored in the given array.
|
\brief Assert soft constraints stored in the given array.
|
||||||
This funtion will assert each soft-constraint C_i as (C_i or k_i) where k_i is a fresh boolean variable.
|
This function will assert each soft-constraint C_i as (C_i or k_i) where k_i is a fresh boolean variable.
|
||||||
It will also return an array containing these fresh variables.
|
It will also return an array containing these fresh variables.
|
||||||
*/
|
*/
|
||||||
Z3_ast * assert_soft_constraints(Z3_context ctx, Z3_solver s, unsigned num_cnstrs, Z3_ast * cnstrs)
|
Z3_ast * assert_soft_constraints(Z3_context ctx, Z3_solver s, unsigned num_cnstrs, Z3_ast * cnstrs)
|
||||||
|
|
@ -382,7 +382,7 @@ unsigned get_num_disabled_soft_constraints(Z3_context ctx, Z3_model m, unsigned
|
||||||
Z3_ast t = Z3_mk_true(ctx);
|
Z3_ast t = Z3_mk_true(ctx);
|
||||||
for (i = 0; i < num_soft_cnstrs; i++) {
|
for (i = 0; i < num_soft_cnstrs; i++) {
|
||||||
Z3_ast val;
|
Z3_ast val;
|
||||||
if (Z3_model_eval(ctx, m, aux_vars[i], 1, &val) == Z3_TRUE) {
|
if (Z3_model_eval(ctx, m, aux_vars[i], 1, &val) == true) {
|
||||||
// printf("%s", Z3_ast_to_string(ctx, aux_vars[i]));
|
// printf("%s", Z3_ast_to_string(ctx, aux_vars[i]));
|
||||||
// printf(" -> %s\n", Z3_ast_to_string(ctx, val));
|
// printf(" -> %s\n", Z3_ast_to_string(ctx, val));
|
||||||
if (Z3_is_eq_ast(ctx, val, t)) {
|
if (Z3_is_eq_ast(ctx, val, t)) {
|
||||||
|
|
@ -565,7 +565,7 @@ int fu_malik_maxsat(Z3_context ctx, Z3_solver s, unsigned num_hard_cnstrs, Z3_as
|
||||||
|
|
||||||
/**
|
/**
|
||||||
\brief Finds the maximal number of assumptions that can be satisfied.
|
\brief Finds the maximal number of assumptions that can be satisfied.
|
||||||
An assumption is any formula preceeded with the :assumption keyword.
|
An assumption is any formula preceded with the :assumption keyword.
|
||||||
"Hard" constraints can be supported by using the :formula keyword.
|
"Hard" constraints can be supported by using the :formula keyword.
|
||||||
|
|
||||||
Input: file in SMT-LIB format, and MaxSAT algorithm to be used: 0 - Naive, 1 - Fu&Malik's algo.
|
Input: file in SMT-LIB format, and MaxSAT algorithm to be used: 0 - Naive, 1 - Fu&Malik's algo.
|
||||||
|
|
|
||||||
|
|
@ -20,4 +20,4 @@ ocamlfind ocamlopt -o ml_example -package Z3 -linkpkg ml_example.ml
|
||||||
|
|
||||||
Note that the resulting binaries depend on the shared z3 library
|
Note that the resulting binaries depend on the shared z3 library
|
||||||
(libz3.dll/.so/.dylb), which needs to be in the PATH (Windows), LD_LIBRARY_PATH
|
(libz3.dll/.so/.dylb), which needs to be in the PATH (Windows), LD_LIBRARY_PATH
|
||||||
(Linux), or DYLD_LIBRARY_PATH (OSX).
|
(Linux), or DYLD_LIBRARY_PATH (macOS).
|
||||||
|
|
|
||||||
|
|
@ -226,7 +226,7 @@ namespace Microsoft.SolverFoundation.Plugin.Z3
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Adds a MSF variable with the coresponding assertion to the Z3 variables.
|
/// Adds a MSF variable with the corresponding assertion to the Z3 variables.
|
||||||
/// </summary>
|
/// </summary>
|
||||||
/// <param name="vid">The MSF id of the variable</param>
|
/// <param name="vid">The MSF id of the variable</param>
|
||||||
internal void AddVariable(int vid)
|
internal void AddVariable(int vid)
|
||||||
|
|
|
||||||
|
|
@ -33,14 +33,14 @@ namespace Microsoft.SolverFoundation.Plugin.Z3
|
||||||
|
|
||||||
#region Solver construction and destruction
|
#region Solver construction and destruction
|
||||||
|
|
||||||
/// <summary>Constructor that initializes the base clases</summary>
|
/// <summary>Constructor that initializes the base classes</summary>
|
||||||
public Z3MILPSolver() : base(null)
|
public Z3MILPSolver() : base(null)
|
||||||
{
|
{
|
||||||
_result = LinearResult.Feasible;
|
_result = LinearResult.Feasible;
|
||||||
_solver = new Z3BaseSolver(this);
|
_solver = new Z3BaseSolver(this);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>Constructor that initializes the base clases</summary>
|
/// <summary>Constructor that initializes the base classes</summary>
|
||||||
public Z3MILPSolver(ISolverEnvironment context) : this() { }
|
public Z3MILPSolver(ISolverEnvironment context) : this() { }
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
|
|
|
||||||
|
|
@ -29,13 +29,13 @@ namespace Microsoft.SolverFoundation.Plugin.Z3
|
||||||
private NonlinearResult _result;
|
private NonlinearResult _result;
|
||||||
private Z3BaseSolver _solver;
|
private Z3BaseSolver _solver;
|
||||||
|
|
||||||
/// <summary>Constructor that initializes the base clases</summary>
|
/// <summary>Constructor that initializes the base classes</summary>
|
||||||
public Z3TermSolver() : base(null)
|
public Z3TermSolver() : base(null)
|
||||||
{
|
{
|
||||||
_solver = new Z3BaseSolver(this);
|
_solver = new Z3BaseSolver(this);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>Constructor that initializes the base clases</summary>
|
/// <summary>Constructor that initializes the base classes</summary>
|
||||||
public Z3TermSolver(ISolverEnvironment context) : this() { }
|
public Z3TermSolver(ISolverEnvironment context) : this() { }
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
|
|
|
||||||
50
examples/python/data/horn1.smt2
Normal file
50
examples/python/data/horn1.smt2
Normal file
|
|
@ -0,0 +1,50 @@
|
||||||
|
(declare-rel Goal (Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool))
|
||||||
|
(declare-rel Invariant (Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool))
|
||||||
|
(declare-var A Bool)
|
||||||
|
(declare-var B Bool)
|
||||||
|
(declare-var C Bool)
|
||||||
|
(declare-var D Bool)
|
||||||
|
(declare-var E Bool)
|
||||||
|
(declare-var F Bool)
|
||||||
|
(declare-var G Bool)
|
||||||
|
(declare-var H Bool)
|
||||||
|
(declare-var I Bool)
|
||||||
|
(declare-var J Bool)
|
||||||
|
(declare-var K Bool)
|
||||||
|
(declare-var L Bool)
|
||||||
|
(declare-var M Bool)
|
||||||
|
(declare-var N Bool)
|
||||||
|
(declare-var O Bool)
|
||||||
|
(declare-var P Bool)
|
||||||
|
(declare-var Q Bool)
|
||||||
|
(declare-var R Bool)
|
||||||
|
(declare-var S Bool)
|
||||||
|
(declare-var T Bool)
|
||||||
|
(declare-var U Bool)
|
||||||
|
(declare-var V Bool)
|
||||||
|
(declare-var W Bool)
|
||||||
|
(declare-var X Bool)
|
||||||
|
(rule (=> (not (or L K J I H G F E D C B A)) (Invariant L K J I H G F E D C B A)))
|
||||||
|
(rule (let ((a!1 (and (Invariant X W V U T S R Q P O N M)
|
||||||
|
(=> (not (and true)) (not F))
|
||||||
|
(=> (not (and true)) (not E))
|
||||||
|
(=> (not (and W)) (not D))
|
||||||
|
(=> (not (and W)) (not C))
|
||||||
|
(=> (not (and U)) (not B))
|
||||||
|
(=> (not (and U)) (not A))
|
||||||
|
(= L (xor F X))
|
||||||
|
(= K (xor E W))
|
||||||
|
(= J (xor D V))
|
||||||
|
(= I (xor C U))
|
||||||
|
(= H (xor B T))
|
||||||
|
(= G (xor A S))
|
||||||
|
(=> D (not E))
|
||||||
|
(=> C (not E))
|
||||||
|
(=> B (not C))
|
||||||
|
(=> A (not C))
|
||||||
|
((_ at-most 5) L K J I H G))))
|
||||||
|
(=> a!1 (Invariant L K J I H G F E D C B A))))
|
||||||
|
(rule (=> (and (Invariant L K J I H G F E D C B A) L (not K) J (not I) H G)
|
||||||
|
(Goal L K J I H G F E D C B A)))
|
||||||
|
|
||||||
|
(query Goal)
|
||||||
44
examples/python/data/horn2.smt2
Normal file
44
examples/python/data/horn2.smt2
Normal file
|
|
@ -0,0 +1,44 @@
|
||||||
|
(declare-rel Invariant (Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool))
|
||||||
|
(declare-rel Goal (Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool))
|
||||||
|
(declare-var A Bool)
|
||||||
|
(declare-var B Bool)
|
||||||
|
(declare-var C Bool)
|
||||||
|
(declare-var D Bool)
|
||||||
|
(declare-var E Bool)
|
||||||
|
(declare-var F Bool)
|
||||||
|
(declare-var G Bool)
|
||||||
|
(declare-var H Bool)
|
||||||
|
(declare-var I Bool)
|
||||||
|
(declare-var J Bool)
|
||||||
|
(declare-var K Bool)
|
||||||
|
(declare-var L Bool)
|
||||||
|
(declare-var M Bool)
|
||||||
|
(declare-var N Bool)
|
||||||
|
(declare-var O Bool)
|
||||||
|
(declare-var P Bool)
|
||||||
|
(declare-var Q Bool)
|
||||||
|
(declare-var R Bool)
|
||||||
|
(declare-var S Bool)
|
||||||
|
(declare-var T Bool)
|
||||||
|
(rule (=> (not (or J I H G F E D C B A)) (Invariant J I H G F E D C B A)))
|
||||||
|
(rule (let ((a!1 (and (Invariant T S R Q P O N M L K)
|
||||||
|
(=> (not (and true)) (not E))
|
||||||
|
(=> (not (and T)) (not D))
|
||||||
|
(=> (not (and S)) (not C))
|
||||||
|
(=> (not (and R)) (not B))
|
||||||
|
(=> (not (and Q)) (not A))
|
||||||
|
(= J (xor E T))
|
||||||
|
(= I (xor D S))
|
||||||
|
(= H (xor C R))
|
||||||
|
(= G (xor B Q))
|
||||||
|
(= F (xor A P))
|
||||||
|
(=> D (not E))
|
||||||
|
(=> C (not D))
|
||||||
|
(=> B (not C))
|
||||||
|
(=> A (not B))
|
||||||
|
((_ at-most 3) J I H G F))))
|
||||||
|
(=> a!1 (Invariant J I H G F E D C B A))))
|
||||||
|
(rule (=> (and (Invariant J I H G F E D C B A) (not J) (not I) (not H) (not G) F)
|
||||||
|
(Goal J I H G F E D C B A)))
|
||||||
|
|
||||||
|
(query Goal)
|
||||||
17
examples/python/data/horn3.smt2
Normal file
17
examples/python/data/horn3.smt2
Normal file
|
|
@ -0,0 +1,17 @@
|
||||||
|
(declare-rel Invariant (Bool))
|
||||||
|
(declare-rel Goal ())
|
||||||
|
(declare-var l0 Bool)
|
||||||
|
(declare-var l2 Bool)
|
||||||
|
(declare-var l4 Bool)
|
||||||
|
(declare-var l6 Bool)
|
||||||
|
(declare-var l8 Bool)
|
||||||
|
(declare-var l10 Bool)
|
||||||
|
(rule (=> (not (or l4)) (Invariant l4)))
|
||||||
|
(rule (=> (and (Invariant l4)
|
||||||
|
(= (and (not l4) (not l2)) l6)
|
||||||
|
(= (and l4 l2) l8)
|
||||||
|
(= (and (not l8) (not l6)) l10)
|
||||||
|
) (Invariant l10)))
|
||||||
|
(rule (=> (and (Invariant l4)
|
||||||
|
l4) Goal))
|
||||||
|
(query Goal)
|
||||||
99
examples/python/data/horn4.smt2
Normal file
99
examples/python/data/horn4.smt2
Normal file
|
|
@ -0,0 +1,99 @@
|
||||||
|
(declare-rel Invariant (Bool Bool Bool Bool Bool Bool))
|
||||||
|
(declare-rel Goal ())
|
||||||
|
(declare-var l0 Bool)
|
||||||
|
(declare-var l2 Bool)
|
||||||
|
(declare-var l4 Bool)
|
||||||
|
(declare-var l6 Bool)
|
||||||
|
(declare-var l8 Bool)
|
||||||
|
(declare-var l10 Bool)
|
||||||
|
(declare-var l12 Bool)
|
||||||
|
(declare-var l14 Bool)
|
||||||
|
(declare-var l16 Bool)
|
||||||
|
(declare-var l18 Bool)
|
||||||
|
(declare-var l20 Bool)
|
||||||
|
(declare-var l22 Bool)
|
||||||
|
(declare-var l24 Bool)
|
||||||
|
(declare-var l26 Bool)
|
||||||
|
(declare-var l28 Bool)
|
||||||
|
(declare-var l30 Bool)
|
||||||
|
(declare-var l32 Bool)
|
||||||
|
(declare-var l34 Bool)
|
||||||
|
(declare-var l36 Bool)
|
||||||
|
(declare-var l38 Bool)
|
||||||
|
(declare-var l40 Bool)
|
||||||
|
(declare-var l42 Bool)
|
||||||
|
(declare-var l44 Bool)
|
||||||
|
(declare-var l46 Bool)
|
||||||
|
(declare-var l48 Bool)
|
||||||
|
(declare-var l50 Bool)
|
||||||
|
(declare-var l52 Bool)
|
||||||
|
(declare-var l54 Bool)
|
||||||
|
(declare-var l56 Bool)
|
||||||
|
(declare-var l58 Bool)
|
||||||
|
(declare-var l60 Bool)
|
||||||
|
(declare-var l62 Bool)
|
||||||
|
(declare-var l64 Bool)
|
||||||
|
(declare-var l66 Bool)
|
||||||
|
(declare-var l68 Bool)
|
||||||
|
(declare-var l70 Bool)
|
||||||
|
(declare-var l72 Bool)
|
||||||
|
(declare-var l74 Bool)
|
||||||
|
(declare-var l76 Bool)
|
||||||
|
(declare-var l78 Bool)
|
||||||
|
(declare-var l80 Bool)
|
||||||
|
(declare-var l82 Bool)
|
||||||
|
(declare-var l84 Bool)
|
||||||
|
(declare-var l86 Bool)
|
||||||
|
(rule (=> (not (or l4 l6 l8 l10 l12 l14)) (Invariant l4 l6 l8 l10 l12 l14)))
|
||||||
|
(rule (=> (and (Invariant l4 l6 l8 l10 l12 l14)
|
||||||
|
(= (and l6 (not l4)) l16)
|
||||||
|
(= (and l10 (not l8)) l18)
|
||||||
|
(= (and l18 l16) l20)
|
||||||
|
(= (and (not l14) (not l12)) l22)
|
||||||
|
(= (and l22 l20) l24)
|
||||||
|
(= (and (not l24) (not l4)) l26)
|
||||||
|
(= (and (not l6) l4) l28)
|
||||||
|
(= (and (not l28) (not l16)) l30)
|
||||||
|
(= (and (not l30) (not l24)) l32)
|
||||||
|
(= (and l6 l4) l34)
|
||||||
|
(= (and (not l34) l8) l36)
|
||||||
|
(= (and l34 (not l8)) l38)
|
||||||
|
(= (and (not l38) (not l36)) l40)
|
||||||
|
(= (and (not l40) (not l24)) l42)
|
||||||
|
(= (and l34 l8) l44)
|
||||||
|
(= (and (not l44) l10) l46)
|
||||||
|
(= (and l44 (not l10)) l48)
|
||||||
|
(= (and (not l48) (not l46)) l50)
|
||||||
|
(= (and (not l50) (not l24)) l52)
|
||||||
|
(= (and l10 l8) l54)
|
||||||
|
(= (and l54 l34) l56)
|
||||||
|
(= (and (not l56) l12) l58)
|
||||||
|
(= (and l56 (not l12)) l60)
|
||||||
|
(= (and (not l60) (not l58)) l62)
|
||||||
|
(= (and (not l62) (not l24)) l64)
|
||||||
|
(= (and l56 l12) l66)
|
||||||
|
(= (and (not l66) l14) l68)
|
||||||
|
(= (and l66 (not l14)) l70)
|
||||||
|
(= (and (not l70) (not l68)) l72)
|
||||||
|
(= (and (not l72) (not l24)) l74)
|
||||||
|
(= (and l6 l4) l76)
|
||||||
|
(= (and (not l76) l18) l78)
|
||||||
|
(= (and (not l78) l10) l80)
|
||||||
|
(= (and (not l80) l22) l82)
|
||||||
|
(= (and (not l82) (not l24)) l84)
|
||||||
|
(= (and l84 (not l0)) l86)
|
||||||
|
) (Invariant l26 l32 l42 l52 l64 l74)))
|
||||||
|
(rule (=> (and (Invariant l4 l6 l8 l10 l12 l14)
|
||||||
|
(= (and l84 (not l0)) l86)
|
||||||
|
(= (and (not l82) (not l24)) l84)
|
||||||
|
(= (and (not l80) l22) l82)
|
||||||
|
(= (and (not l78) l10) l80)
|
||||||
|
(= (and (not l76) l18) l78)
|
||||||
|
(= (and l6 l4) l76)
|
||||||
|
(= (and l10 (not l8)) l18)
|
||||||
|
(= (and (not l14) (not l12)) l22)
|
||||||
|
(= (and l22 l20) l24)
|
||||||
|
(= (and l18 l16) l20)
|
||||||
|
(= (and l6 (not l4)) l16)
|
||||||
|
l86) Goal))
|
||||||
|
(query Goal)
|
||||||
21
examples/python/data/horn5.smt2
Normal file
21
examples/python/data/horn5.smt2
Normal file
|
|
@ -0,0 +1,21 @@
|
||||||
|
(declare-rel Invariant (Bool Bool Bool Bool))
|
||||||
|
(declare-rel Goal ())
|
||||||
|
(declare-var l0 Bool)
|
||||||
|
(declare-var l2 Bool)
|
||||||
|
(declare-var l4 Bool)
|
||||||
|
(declare-var l6 Bool)
|
||||||
|
(declare-var l8 Bool)
|
||||||
|
(declare-var l10 Bool)
|
||||||
|
(declare-var l12 Bool)
|
||||||
|
(declare-var l14 Bool)
|
||||||
|
(declare-var l16 Bool)
|
||||||
|
(rule (=> (not (or l4 l6 l8 l10)) (Invariant l4 l6 l8 l10)))
|
||||||
|
(rule (=> (and (Invariant l4 l6 l8 l10)
|
||||||
|
(= (and l6 l4) l12)
|
||||||
|
(= (and l12 l8) l14)
|
||||||
|
(= (and l10 (not l0)) l16)
|
||||||
|
) (Invariant l12 l8 l0 l14)))
|
||||||
|
(rule (=> (and (Invariant l4 l6 l8 l10)
|
||||||
|
(= (and l10 (not l0)) l16)
|
||||||
|
l16) Goal))
|
||||||
|
(query Goal)
|
||||||
292
examples/python/data/horn6.smt2
Normal file
292
examples/python/data/horn6.smt2
Normal file
|
|
@ -0,0 +1,292 @@
|
||||||
|
(declare-rel Invariant (Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool))
|
||||||
|
(declare-rel Goal ())
|
||||||
|
(declare-var l0 Bool)
|
||||||
|
(declare-var l2 Bool)
|
||||||
|
(declare-var l4 Bool)
|
||||||
|
(declare-var l6 Bool)
|
||||||
|
(declare-var l8 Bool)
|
||||||
|
(declare-var l10 Bool)
|
||||||
|
(declare-var l12 Bool)
|
||||||
|
(declare-var l14 Bool)
|
||||||
|
(declare-var l16 Bool)
|
||||||
|
(declare-var l18 Bool)
|
||||||
|
(declare-var l20 Bool)
|
||||||
|
(declare-var l22 Bool)
|
||||||
|
(declare-var l24 Bool)
|
||||||
|
(declare-var l26 Bool)
|
||||||
|
(declare-var l28 Bool)
|
||||||
|
(declare-var l30 Bool)
|
||||||
|
(declare-var l32 Bool)
|
||||||
|
(declare-var l34 Bool)
|
||||||
|
(declare-var l36 Bool)
|
||||||
|
(declare-var l38 Bool)
|
||||||
|
(declare-var l40 Bool)
|
||||||
|
(declare-var l42 Bool)
|
||||||
|
(declare-var l44 Bool)
|
||||||
|
(declare-var l46 Bool)
|
||||||
|
(declare-var l48 Bool)
|
||||||
|
(declare-var l50 Bool)
|
||||||
|
(declare-var l52 Bool)
|
||||||
|
(declare-var l54 Bool)
|
||||||
|
(declare-var l56 Bool)
|
||||||
|
(declare-var l58 Bool)
|
||||||
|
(declare-var l60 Bool)
|
||||||
|
(declare-var l62 Bool)
|
||||||
|
(declare-var l64 Bool)
|
||||||
|
(declare-var l66 Bool)
|
||||||
|
(declare-var l68 Bool)
|
||||||
|
(declare-var l70 Bool)
|
||||||
|
(declare-var l72 Bool)
|
||||||
|
(declare-var l74 Bool)
|
||||||
|
(declare-var l76 Bool)
|
||||||
|
(declare-var l78 Bool)
|
||||||
|
(declare-var l80 Bool)
|
||||||
|
(declare-var l82 Bool)
|
||||||
|
(declare-var l84 Bool)
|
||||||
|
(declare-var l86 Bool)
|
||||||
|
(declare-var l88 Bool)
|
||||||
|
(declare-var l90 Bool)
|
||||||
|
(declare-var l92 Bool)
|
||||||
|
(declare-var l94 Bool)
|
||||||
|
(declare-var l96 Bool)
|
||||||
|
(declare-var l98 Bool)
|
||||||
|
(declare-var l100 Bool)
|
||||||
|
(declare-var l102 Bool)
|
||||||
|
(declare-var l104 Bool)
|
||||||
|
(declare-var l106 Bool)
|
||||||
|
(declare-var l108 Bool)
|
||||||
|
(declare-var l110 Bool)
|
||||||
|
(declare-var l112 Bool)
|
||||||
|
(declare-var l114 Bool)
|
||||||
|
(declare-var l116 Bool)
|
||||||
|
(declare-var l118 Bool)
|
||||||
|
(declare-var l120 Bool)
|
||||||
|
(declare-var l122 Bool)
|
||||||
|
(declare-var l124 Bool)
|
||||||
|
(declare-var l126 Bool)
|
||||||
|
(declare-var l128 Bool)
|
||||||
|
(declare-var l130 Bool)
|
||||||
|
(declare-var l132 Bool)
|
||||||
|
(declare-var l134 Bool)
|
||||||
|
(declare-var l136 Bool)
|
||||||
|
(declare-var l138 Bool)
|
||||||
|
(declare-var l140 Bool)
|
||||||
|
(declare-var l142 Bool)
|
||||||
|
(declare-var l144 Bool)
|
||||||
|
(declare-var l146 Bool)
|
||||||
|
(declare-var l148 Bool)
|
||||||
|
(declare-var l150 Bool)
|
||||||
|
(declare-var l152 Bool)
|
||||||
|
(declare-var l154 Bool)
|
||||||
|
(declare-var l156 Bool)
|
||||||
|
(declare-var l158 Bool)
|
||||||
|
(declare-var l160 Bool)
|
||||||
|
(declare-var l162 Bool)
|
||||||
|
(declare-var l164 Bool)
|
||||||
|
(declare-var l166 Bool)
|
||||||
|
(declare-var l168 Bool)
|
||||||
|
(declare-var l170 Bool)
|
||||||
|
(declare-var l172 Bool)
|
||||||
|
(declare-var l174 Bool)
|
||||||
|
(declare-var l176 Bool)
|
||||||
|
(declare-var l178 Bool)
|
||||||
|
(declare-var l180 Bool)
|
||||||
|
(declare-var l182 Bool)
|
||||||
|
(declare-var l184 Bool)
|
||||||
|
(declare-var l186 Bool)
|
||||||
|
(declare-var l188 Bool)
|
||||||
|
(declare-var l190 Bool)
|
||||||
|
(declare-var l192 Bool)
|
||||||
|
(declare-var l194 Bool)
|
||||||
|
(declare-var l196 Bool)
|
||||||
|
(declare-var l198 Bool)
|
||||||
|
(declare-var l200 Bool)
|
||||||
|
(declare-var l202 Bool)
|
||||||
|
(declare-var l204 Bool)
|
||||||
|
(declare-var l206 Bool)
|
||||||
|
(declare-var l208 Bool)
|
||||||
|
(declare-var l210 Bool)
|
||||||
|
(declare-var l212 Bool)
|
||||||
|
(declare-var l214 Bool)
|
||||||
|
(declare-var l216 Bool)
|
||||||
|
(declare-var l218 Bool)
|
||||||
|
(declare-var l220 Bool)
|
||||||
|
(declare-var l222 Bool)
|
||||||
|
(declare-var l224 Bool)
|
||||||
|
(declare-var l226 Bool)
|
||||||
|
(declare-var l228 Bool)
|
||||||
|
(declare-var l230 Bool)
|
||||||
|
(declare-var l232 Bool)
|
||||||
|
(declare-var l234 Bool)
|
||||||
|
(declare-var l236 Bool)
|
||||||
|
(declare-var l238 Bool)
|
||||||
|
(declare-var l240 Bool)
|
||||||
|
(declare-var l242 Bool)
|
||||||
|
(declare-var l244 Bool)
|
||||||
|
(declare-var l246 Bool)
|
||||||
|
(declare-var l248 Bool)
|
||||||
|
(declare-var l250 Bool)
|
||||||
|
(declare-var l252 Bool)
|
||||||
|
(declare-var l254 Bool)
|
||||||
|
(declare-var l256 Bool)
|
||||||
|
(declare-var l258 Bool)
|
||||||
|
(declare-var l260 Bool)
|
||||||
|
(declare-var l262 Bool)
|
||||||
|
(declare-var l264 Bool)
|
||||||
|
(declare-var l266 Bool)
|
||||||
|
(declare-var l268 Bool)
|
||||||
|
(declare-var l270 Bool)
|
||||||
|
(declare-var l272 Bool)
|
||||||
|
(declare-var l274 Bool)
|
||||||
|
(declare-var l276 Bool)
|
||||||
|
(declare-var l278 Bool)
|
||||||
|
(declare-var l280 Bool)
|
||||||
|
(declare-var l282 Bool)
|
||||||
|
(declare-var l284 Bool)
|
||||||
|
(declare-var l286 Bool)
|
||||||
|
(declare-var l288 Bool)
|
||||||
|
(declare-var l290 Bool)
|
||||||
|
(declare-var l292 Bool)
|
||||||
|
(declare-var l294 Bool)
|
||||||
|
(declare-var l296 Bool)
|
||||||
|
(declare-var l298 Bool)
|
||||||
|
(declare-var l300 Bool)
|
||||||
|
(declare-var l302 Bool)
|
||||||
|
(declare-var l304 Bool)
|
||||||
|
(declare-var l306 Bool)
|
||||||
|
(declare-var l308 Bool)
|
||||||
|
(declare-var l310 Bool)
|
||||||
|
(declare-var l312 Bool)
|
||||||
|
(declare-var l314 Bool)
|
||||||
|
(declare-var l316 Bool)
|
||||||
|
(rule (=> (not (or l8 l10 l12 l14 l16 l18 l20 l22 l24 l26 l28 l30 l32 l34 l36 l38 l40 l42 l44 l46 l48 l50 l52 l54 l56 l58 l60 l62 l64 l66 l68 l70 l72 l74)) (Invariant l8 l10 l12 l14 l16 l18 l20 l22 l24 l26 l28 l30 l32 l34 l36 l38 l40 l42 l44 l46 l48 l50 l52 l54 l56 l58 l60 l62 l64 l66 l68 l70 l72 l74)))
|
||||||
|
(rule (=> (and (Invariant l8 l10 l12 l14 l16 l18 l20 l22 l24 l26 l28 l30 l32 l34 l36 l38 l40 l42 l44 l46 l48 l50 l52 l54 l56 l58 l60 l62 l64 l66 l68 l70 l72 l74)
|
||||||
|
(= (and (not l20) (not l14)) l76)
|
||||||
|
(= (and (not l76) l8) l78)
|
||||||
|
(= (and l20 l14) l80)
|
||||||
|
(= (and (not l80) (not l78)) l82)
|
||||||
|
(= (and (not l28) l8) l84)
|
||||||
|
(= (and (not l84) l10) l86)
|
||||||
|
(= (and l18 l12) l88)
|
||||||
|
(= (and l88 l38) l90)
|
||||||
|
(= (and (not l24) (not l8)) l92)
|
||||||
|
(= (and l92 (not l26)) l94)
|
||||||
|
(= (and l94 l28) l96)
|
||||||
|
(= (and l96 (not l90)) l98)
|
||||||
|
(= (and (not l98) (not l86)) l100)
|
||||||
|
(= (and l38 l18) l102)
|
||||||
|
(= (and l102 l12) l104)
|
||||||
|
(= (and (not l104) (not l26)) l106)
|
||||||
|
(= (and l24 (not l16)) l108)
|
||||||
|
(= (and l108 (not l32)) l110)
|
||||||
|
(= (and l110 l106) l112)
|
||||||
|
(= (and (not l32) l14) l114)
|
||||||
|
(= (and (not l114) (not l112)) l116)
|
||||||
|
(= (and (not l114) l16) l118)
|
||||||
|
(= (and l32 (not l14)) l120)
|
||||||
|
(= (and l120 l106) l122)
|
||||||
|
(= (and l122 l24) l124)
|
||||||
|
(= (and (not l124) (not l118)) l126)
|
||||||
|
(= (and l26 (not l22)) l128)
|
||||||
|
(= (and l128 (not l36)) l130)
|
||||||
|
(= (and (not l36) l20) l132)
|
||||||
|
(= (and l130 (not l90)) l134)
|
||||||
|
(= (and (not l134) (not l132)) l136)
|
||||||
|
(= (and (not l132) l22) l138)
|
||||||
|
(= (and l26 (not l20)) l140)
|
||||||
|
(= (and l140 l36) l142)
|
||||||
|
(= (and l142 (not l90)) l144)
|
||||||
|
(= (and (not l144) (not l138)) l146)
|
||||||
|
(= (and (not l106) l24) l148)
|
||||||
|
(= (and l106 (not l24)) l150)
|
||||||
|
(= (and (not l150) (not l148)) l152)
|
||||||
|
(= (and (not l90) l24) l154)
|
||||||
|
(= (and l90 l26) l156)
|
||||||
|
(= (and (not l156) (not l154)) l158)
|
||||||
|
(= (and (not l30) l2) l160)
|
||||||
|
(= (and l28 (not l2)) l162)
|
||||||
|
(= (and (not l162) (not l160)) l164)
|
||||||
|
(= (and l28 l2) l166)
|
||||||
|
(= (and (not l166) l30) l168)
|
||||||
|
(= (and (not l30) l28) l170)
|
||||||
|
(= (and l170 l8) l172)
|
||||||
|
(= (and (not l172) (not l168)) l174)
|
||||||
|
(= (and (not l34) l4) l176)
|
||||||
|
(= (and l32 (not l4)) l178)
|
||||||
|
(= (and (not l178) (not l176)) l180)
|
||||||
|
(= (and l32 l4) l182)
|
||||||
|
(= (and (not l182) l34) l184)
|
||||||
|
(= (and (not l34) l32) l186)
|
||||||
|
(= (and l186 l14) l188)
|
||||||
|
(= (and (not l188) (not l184)) l190)
|
||||||
|
(= (and (not l40) l6) l192)
|
||||||
|
(= (and l36 (not l6)) l194)
|
||||||
|
(= (and (not l194) (not l192)) l196)
|
||||||
|
(= (and (not l24) (not l10)) l198)
|
||||||
|
(= (and l198 (not l26)) l200)
|
||||||
|
(= (and l200 (not l28)) l202)
|
||||||
|
(= (and l202 (not l90)) l204)
|
||||||
|
(= (and (not l204) (not l84)) l206)
|
||||||
|
(= (and l36 l6) l208)
|
||||||
|
(= (and (not l208) l40) l210)
|
||||||
|
(= (and (not l40) l36) l212)
|
||||||
|
(= (and l212 l20) l214)
|
||||||
|
(= (and (not l214) (not l210)) l216)
|
||||||
|
(= (and l62 l44) l218)
|
||||||
|
(= (and l52 l46) l220)
|
||||||
|
(= (and l220 l72) l222)
|
||||||
|
(= (and (not l60) (not l58)) l224)
|
||||||
|
(= (and l224 l62) l226)
|
||||||
|
(= (and l226 (not l222)) l228)
|
||||||
|
(= (and (not l228) (not l218)) l230)
|
||||||
|
(= (and (not l222) (not l60)) l232)
|
||||||
|
(= (and (not l66) l58) l234)
|
||||||
|
(= (and (not l66) l48) l236)
|
||||||
|
(= (and l234 l232) l238)
|
||||||
|
(= (and (not l238) (not l236)) l240)
|
||||||
|
(= (and l66 l50) l242)
|
||||||
|
(= (and l66 (not l48)) l244)
|
||||||
|
(= (and l244 l232) l246)
|
||||||
|
(= (and l246 l58) l248)
|
||||||
|
(= (and (not l248) (not l242)) l250)
|
||||||
|
(= (and (not l70) l60) l252)
|
||||||
|
(= (and (not l70) l54) l254)
|
||||||
|
(= (and l252 (not l222)) l256)
|
||||||
|
(= (and (not l256) (not l254)) l258)
|
||||||
|
(= (and l70 l56) l260)
|
||||||
|
(= (and l70 l60) l262)
|
||||||
|
(= (and l262 (not l222)) l264)
|
||||||
|
(= (and (not l264) (not l260)) l266)
|
||||||
|
(= (and (not l232) l58) l268)
|
||||||
|
(= (and l232 (not l58)) l270)
|
||||||
|
(= (and (not l270) (not l268)) l272)
|
||||||
|
(= (and l222 l60) l274)
|
||||||
|
(= (and (not l222) l58) l276)
|
||||||
|
(= (and (not l276) (not l274)) l278)
|
||||||
|
(= (and l62 (not l2)) l280)
|
||||||
|
(= (and (not l64) l2) l282)
|
||||||
|
(= (and (not l282) (not l280)) l284)
|
||||||
|
(= (and l62 l42) l286)
|
||||||
|
(= (and l286 (not l284)) l288)
|
||||||
|
(= (and l66 (not l4)) l290)
|
||||||
|
(= (and (not l68) l4) l292)
|
||||||
|
(= (and (not l292) (not l290)) l294)
|
||||||
|
(= (and (not l244) l66) l296)
|
||||||
|
(= (and l296 (not l294)) l298)
|
||||||
|
(= (and l70 (not l6)) l300)
|
||||||
|
(= (and (not l74) l6) l302)
|
||||||
|
(= (and (not l302) (not l300)) l304)
|
||||||
|
(= (and l224 (not l62)) l306)
|
||||||
|
(= (and (not l62) l42) l308)
|
||||||
|
(= (and l306 (not l222)) l310)
|
||||||
|
(= (and (not l310) (not l308)) l312)
|
||||||
|
(= (and l70 l54) l314)
|
||||||
|
(= (and l314 (not l304)) l316)
|
||||||
|
) (Invariant l86 l100 l116 l118 l126 l136 l138 l146 l152 l158 l164 l174 l180 l190 l196 l206 l216 l218 l230 l240 l242 l250 l258 l260 l266 l272 l278 l284 l288 l294 l298 l304 l312 l316)))
|
||||||
|
(rule (=> (and (Invariant l8 l10 l12 l14 l16 l18 l20 l22 l24 l26 l28 l30 l32 l34 l36 l38 l40 l42 l44 l46 l48 l50 l52 l54 l56 l58 l60 l62 l64 l66 l68 l70 l72 l74)
|
||||||
|
(= (and (not l80) (not l78)) l82)
|
||||||
|
(= (and l20 l14) l80)
|
||||||
|
(= (and (not l76) l8) l78)
|
||||||
|
(= (and (not l20) (not l14)) l76)
|
||||||
|
(not l82)) Goal))
|
||||||
|
(query Goal)
|
||||||
|
|
@ -20,7 +20,7 @@
|
||||||
# export PYTHONPATH=MYZ3/bin/python
|
# export PYTHONPATH=MYZ3/bin/python
|
||||||
# python example.py
|
# python example.py
|
||||||
|
|
||||||
# Running this example on OSX:
|
# Running this example on macOS:
|
||||||
# export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH:MYZ3/bin
|
# export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH:MYZ3/bin
|
||||||
# export PYTHONPATH=MYZ3/bin/python
|
# export PYTHONPATH=MYZ3/bin/python
|
||||||
# python example.py
|
# python example.py
|
||||||
|
|
|
||||||
469
examples/python/mini_ic3.py
Normal file
469
examples/python/mini_ic3.py
Normal file
|
|
@ -0,0 +1,469 @@
|
||||||
|
from z3 import *
|
||||||
|
import heapq
|
||||||
|
|
||||||
|
|
||||||
|
# Simplistic (and fragile) converter from
|
||||||
|
# a class of Horn clauses corresponding to
|
||||||
|
# a transition system into a transition system
|
||||||
|
# representation as <init, trans, goal>
|
||||||
|
# It assumes it is given three Horn clauses
|
||||||
|
# of the form:
|
||||||
|
# init(x) => Invariant(x)
|
||||||
|
# Invariant(x) and trans(x,x') => Invariant(x')
|
||||||
|
# Invariant(x) and goal(x) => Goal(x)
|
||||||
|
# where Invariant and Goal are uninterpreted predicates
|
||||||
|
|
||||||
|
class Horn2Transitions:
|
||||||
|
def __init__(self):
|
||||||
|
self.trans = True
|
||||||
|
self.init = True
|
||||||
|
self.inputs = []
|
||||||
|
self.goal = True
|
||||||
|
self.index = 0
|
||||||
|
|
||||||
|
def parse(self, file):
|
||||||
|
fp = Fixedpoint()
|
||||||
|
goals = fp.parse_file(file)
|
||||||
|
for r in fp.get_rules():
|
||||||
|
if not is_quantifier(r):
|
||||||
|
continue
|
||||||
|
b = r.body()
|
||||||
|
if not is_implies(b):
|
||||||
|
continue
|
||||||
|
f = b.arg(0)
|
||||||
|
g = b.arg(1)
|
||||||
|
if self.is_goal(f, g):
|
||||||
|
continue
|
||||||
|
if self.is_transition(f, g):
|
||||||
|
continue
|
||||||
|
if self.is_init(f, g):
|
||||||
|
continue
|
||||||
|
|
||||||
|
def is_pred(self, p, name):
|
||||||
|
return is_app(p) and p.decl().name() == name
|
||||||
|
|
||||||
|
def is_goal(self, body, head):
|
||||||
|
if not self.is_pred(head, "Goal"):
|
||||||
|
return False
|
||||||
|
pred, inv = self.is_body(body)
|
||||||
|
if pred is None:
|
||||||
|
return False
|
||||||
|
self.goal = self.subst_vars("x", inv, pred)
|
||||||
|
self.goal = self.subst_vars("i", self.goal, self.goal)
|
||||||
|
self.inputs += self.vars
|
||||||
|
self.inputs = list(set(self.inputs))
|
||||||
|
return True
|
||||||
|
|
||||||
|
def is_body(self, body):
|
||||||
|
if not is_and(body):
|
||||||
|
return None, None
|
||||||
|
fmls = [f for f in body.children() if self.is_inv(f) is None]
|
||||||
|
inv = None
|
||||||
|
for f in body.children():
|
||||||
|
if self.is_inv(f) is not None:
|
||||||
|
inv = f;
|
||||||
|
break
|
||||||
|
return And(fmls), inv
|
||||||
|
|
||||||
|
def is_inv(self, f):
|
||||||
|
if self.is_pred(f, "Invariant"):
|
||||||
|
return f
|
||||||
|
return None
|
||||||
|
|
||||||
|
def is_transition(self, body, head):
|
||||||
|
pred, inv0 = self.is_body(body)
|
||||||
|
if pred is None:
|
||||||
|
return False
|
||||||
|
inv1 = self.is_inv(head)
|
||||||
|
if inv1 is None:
|
||||||
|
return False
|
||||||
|
pred = self.subst_vars("x", inv0, pred)
|
||||||
|
self.xs = self.vars
|
||||||
|
pred = self.subst_vars("xn", inv1, pred)
|
||||||
|
self.xns = self.vars
|
||||||
|
pred = self.subst_vars("i", pred, pred)
|
||||||
|
self.inputs += self.vars
|
||||||
|
self.inputs = list(set(self.inputs))
|
||||||
|
self.trans = pred
|
||||||
|
return True
|
||||||
|
|
||||||
|
def is_init(self, body, head):
|
||||||
|
for f in body.children():
|
||||||
|
if self.is_inv(f) is not None:
|
||||||
|
return False
|
||||||
|
inv = self.is_inv(head)
|
||||||
|
if inv is None:
|
||||||
|
return False
|
||||||
|
self.init = self.subst_vars("x", inv, body)
|
||||||
|
return True
|
||||||
|
|
||||||
|
def subst_vars(self, prefix, inv, fml):
|
||||||
|
subst = self.mk_subst(prefix, inv)
|
||||||
|
self.vars = [ v for (k,v) in subst ]
|
||||||
|
return substitute(fml, subst)
|
||||||
|
|
||||||
|
def mk_subst(self, prefix, inv):
|
||||||
|
self.index = 0
|
||||||
|
if self.is_inv(inv) is not None:
|
||||||
|
return [(f, self.mk_bool(prefix)) for f in inv.children()]
|
||||||
|
else:
|
||||||
|
vars = self.get_vars(inv)
|
||||||
|
return [(f, self.mk_bool(prefix)) for f in vars]
|
||||||
|
|
||||||
|
def mk_bool(self, prefix):
|
||||||
|
self.index += 1
|
||||||
|
return Bool("%s%d" % (prefix, self.index))
|
||||||
|
|
||||||
|
def get_vars(self, f, rs=[]):
|
||||||
|
if is_var(f):
|
||||||
|
return z3util.vset(rs + [f], str)
|
||||||
|
else:
|
||||||
|
for f_ in f.children():
|
||||||
|
rs = self.get_vars(f_, rs)
|
||||||
|
return z3util.vset(rs, str)
|
||||||
|
|
||||||
|
# Produce a finite domain solver.
|
||||||
|
# The theory QF_FD covers bit-vector formulas
|
||||||
|
# and pseudo-Boolean constraints.
|
||||||
|
# By default cardinality and pseudo-Boolean
|
||||||
|
# constraints are converted to clauses. To override
|
||||||
|
# this default for cardinality constraints
|
||||||
|
# we set sat.cardinality.solver to True
|
||||||
|
|
||||||
|
def fd_solver():
|
||||||
|
s = SolverFor("QF_FD")
|
||||||
|
s.set("sat.cardinality.solver", True)
|
||||||
|
return s
|
||||||
|
|
||||||
|
|
||||||
|
# negate, avoid double negation
|
||||||
|
def negate(f):
|
||||||
|
if is_not(f):
|
||||||
|
return f.arg(0)
|
||||||
|
else:
|
||||||
|
return Not(f)
|
||||||
|
|
||||||
|
def cube2clause(cube):
|
||||||
|
return Or([negate(f) for f in cube])
|
||||||
|
|
||||||
|
class State:
|
||||||
|
def __init__(self, s):
|
||||||
|
self.R = set([])
|
||||||
|
self.solver = s
|
||||||
|
|
||||||
|
def add(self, clause):
|
||||||
|
if clause not in self.R:
|
||||||
|
self.R |= { clause }
|
||||||
|
self.solver.add(clause)
|
||||||
|
|
||||||
|
class Goal:
|
||||||
|
def __init__(self, cube, parent, level):
|
||||||
|
self.level = level
|
||||||
|
self.cube = cube
|
||||||
|
self.parent = parent
|
||||||
|
|
||||||
|
def is_seq(f):
|
||||||
|
return isinstance(f, list) or isinstance(f, tuple) or isinstance(f, AstVector)
|
||||||
|
|
||||||
|
# Check if the initial state is bad
|
||||||
|
def check_disjoint(a, b):
|
||||||
|
s = fd_solver()
|
||||||
|
s.add(a)
|
||||||
|
s.add(b)
|
||||||
|
return unsat == s.check()
|
||||||
|
|
||||||
|
|
||||||
|
# Remove clauses that are subsumed
|
||||||
|
def prune(R):
|
||||||
|
removed = set([])
|
||||||
|
s = fd_solver()
|
||||||
|
for f1 in R:
|
||||||
|
s.push()
|
||||||
|
for f2 in R:
|
||||||
|
if f2 not in removed:
|
||||||
|
s.add(Not(f2) if f1.eq(f2) else f2)
|
||||||
|
if s.check() == unsat:
|
||||||
|
removed |= { f1 }
|
||||||
|
s.pop()
|
||||||
|
return R - removed
|
||||||
|
|
||||||
|
class MiniIC3:
|
||||||
|
def __init__(self, init, trans, goal, x0, inputs, xn):
|
||||||
|
self.x0 = x0
|
||||||
|
self.inputs = inputs
|
||||||
|
self.xn = xn
|
||||||
|
self.init = init
|
||||||
|
self.bad = goal
|
||||||
|
self.trans = trans
|
||||||
|
self.min_cube_solver = fd_solver()
|
||||||
|
self.min_cube_solver.add(Not(trans))
|
||||||
|
self.goals = []
|
||||||
|
s = State(fd_solver())
|
||||||
|
s.add(init)
|
||||||
|
s.solver.add(trans)
|
||||||
|
self.states = [s]
|
||||||
|
self.s_bad = fd_solver()
|
||||||
|
self.s_good = fd_solver()
|
||||||
|
self.s_bad.add(self.bad)
|
||||||
|
self.s_good.add(Not(self.bad))
|
||||||
|
|
||||||
|
def next(self, f):
|
||||||
|
if is_seq(f):
|
||||||
|
return [self.next(f1) for f1 in f]
|
||||||
|
return substitute(f, zip(self.x0, self.xn))
|
||||||
|
|
||||||
|
def prev(self, f):
|
||||||
|
if is_seq(f):
|
||||||
|
return [self.prev(f1) for f1 in f]
|
||||||
|
return substitute(f, zip(self.xn, self.x0))
|
||||||
|
|
||||||
|
def add_solver(self):
|
||||||
|
s = fd_solver()
|
||||||
|
s.add(self.trans)
|
||||||
|
self.states += [State(s)]
|
||||||
|
|
||||||
|
def R(self, i):
|
||||||
|
return And(self.states[i].R)
|
||||||
|
|
||||||
|
# Check if there are two states next to each other that have the same clauses.
|
||||||
|
def is_valid(self):
|
||||||
|
i = 1
|
||||||
|
while i + 1 < len(self.states):
|
||||||
|
if not (self.states[i].R - self.states[i+1].R):
|
||||||
|
return And(prune(self.states[i].R))
|
||||||
|
i += 1
|
||||||
|
return None
|
||||||
|
|
||||||
|
def value2literal(self, m, x):
|
||||||
|
value = m.eval(x)
|
||||||
|
if is_true(value):
|
||||||
|
return x
|
||||||
|
if is_false(value):
|
||||||
|
return Not(x)
|
||||||
|
return None
|
||||||
|
|
||||||
|
def values2literals(self, m, xs):
|
||||||
|
p = [self.value2literal(m, x) for x in xs]
|
||||||
|
return [x for x in p if x is not None]
|
||||||
|
|
||||||
|
def project0(self, m):
|
||||||
|
return self.values2literals(m, self.x0)
|
||||||
|
|
||||||
|
def projectI(self, m):
|
||||||
|
return self.values2literals(m, self.inputs)
|
||||||
|
|
||||||
|
def projectN(self, m):
|
||||||
|
return self.values2literals(m, self.xn)
|
||||||
|
|
||||||
|
# Determine if there is a cube for the current state
|
||||||
|
# that is potentially reachable.
|
||||||
|
def unfold(self):
|
||||||
|
core = []
|
||||||
|
self.s_bad.push()
|
||||||
|
R = self.R(len(self.states)-1)
|
||||||
|
self.s_bad.add(R)
|
||||||
|
is_sat = self.s_bad.check()
|
||||||
|
if is_sat == sat:
|
||||||
|
m = self.s_bad.model()
|
||||||
|
cube = self.project0(m)
|
||||||
|
props = cube + self.projectI(m)
|
||||||
|
self.s_good.push()
|
||||||
|
self.s_good.add(R)
|
||||||
|
is_sat2 = self.s_good.check(props)
|
||||||
|
assert is_sat2 == unsat
|
||||||
|
core = self.s_good.unsat_core()
|
||||||
|
core = [c for c in core if c in set(cube)]
|
||||||
|
self.s_good.pop()
|
||||||
|
self.s_bad.pop()
|
||||||
|
return is_sat, core
|
||||||
|
|
||||||
|
# Block a cube by asserting the clause corresponding to its negation
|
||||||
|
def block_cube(self, i, cube):
|
||||||
|
self.assert_clause(i, cube2clause(cube))
|
||||||
|
|
||||||
|
# Add a clause to levels 0 until i
|
||||||
|
def assert_clause(self, i, clause):
|
||||||
|
for j in range(i + 1):
|
||||||
|
self.states[j].add(clause)
|
||||||
|
|
||||||
|
# minimize cube that is core of Dual solver.
|
||||||
|
# this assumes that props & cube => Trans
|
||||||
|
def minimize_cube(self, cube, inputs, lits):
|
||||||
|
is_sat = self.min_cube_solver.check(lits + [c for c in cube] + [i for i in inputs])
|
||||||
|
assert is_sat == unsat
|
||||||
|
core = self.min_cube_solver.unsat_core()
|
||||||
|
assert core
|
||||||
|
return [c for c in core if c in set(cube)]
|
||||||
|
|
||||||
|
# push a goal on a heap
|
||||||
|
def push_heap(self, goal):
|
||||||
|
heapq.heappush(self.goals, (goal.level, goal))
|
||||||
|
|
||||||
|
# A state s0 and level f0 such that
|
||||||
|
# not(s0) is f0-1 inductive
|
||||||
|
def ic3_blocked(self, s0, f0):
|
||||||
|
self.push_heap(Goal(self.next(s0), None, f0))
|
||||||
|
while self.goals:
|
||||||
|
f, g = heapq.heappop(self.goals)
|
||||||
|
sys.stdout.write("%d." % f)
|
||||||
|
sys.stdout.flush()
|
||||||
|
# Not(g.cube) is f-1 invariant
|
||||||
|
if f == 0:
|
||||||
|
print("")
|
||||||
|
return g
|
||||||
|
cube, f, is_sat = self.is_inductive(f, g.cube)
|
||||||
|
if is_sat == unsat:
|
||||||
|
self.block_cube(f, self.prev(cube))
|
||||||
|
if f < f0:
|
||||||
|
self.push_heap(Goal(g.cube, g.parent, f + 1))
|
||||||
|
elif is_sat == sat:
|
||||||
|
self.push_heap(Goal(cube, g, f - 1))
|
||||||
|
self.push_heap(g)
|
||||||
|
else:
|
||||||
|
return is_sat
|
||||||
|
print("")
|
||||||
|
return None
|
||||||
|
|
||||||
|
# Rudimentary generalization:
|
||||||
|
# If the cube is already unsat with respect to transition relation
|
||||||
|
# extract a core (not necessarily minimal)
|
||||||
|
# otherwise, just return the cube.
|
||||||
|
def generalize(self, cube, f):
|
||||||
|
s = self.states[f - 1].solver
|
||||||
|
if unsat == s.check(cube):
|
||||||
|
core = s.unsat_core()
|
||||||
|
if not check_disjoint(self.init, self.prev(And(core))):
|
||||||
|
return core, f
|
||||||
|
return cube, f
|
||||||
|
|
||||||
|
# Check if the negation of cube is inductive at level f
|
||||||
|
def is_inductive(self, f, cube):
|
||||||
|
s = self.states[f - 1].solver
|
||||||
|
s.push()
|
||||||
|
s.add(self.prev(Not(And(cube))))
|
||||||
|
is_sat = s.check(cube)
|
||||||
|
if is_sat == sat:
|
||||||
|
m = s.model()
|
||||||
|
s.pop()
|
||||||
|
if is_sat == sat:
|
||||||
|
cube = self.next(self.minimize_cube(self.project0(m), self.projectI(m), self.projectN(m)))
|
||||||
|
elif is_sat == unsat:
|
||||||
|
cube, f = self.generalize(cube, f)
|
||||||
|
return cube, f, is_sat
|
||||||
|
|
||||||
|
def run(self):
|
||||||
|
if not check_disjoint(self.init, self.bad):
|
||||||
|
return "goal is reached in initial state"
|
||||||
|
level = 0
|
||||||
|
while True:
|
||||||
|
inv = self.is_valid()
|
||||||
|
if inv is not None:
|
||||||
|
return inv
|
||||||
|
is_sat, cube = self.unfold()
|
||||||
|
if is_sat == unsat:
|
||||||
|
level += 1
|
||||||
|
print("Unfold %d" % level)
|
||||||
|
sys.stdout.flush()
|
||||||
|
self.add_solver()
|
||||||
|
elif is_sat == sat:
|
||||||
|
cex = self.ic3_blocked(cube, level)
|
||||||
|
if cex is not None:
|
||||||
|
return cex
|
||||||
|
else:
|
||||||
|
return is_sat
|
||||||
|
|
||||||
|
def test(file):
|
||||||
|
h2t = Horn2Transitions()
|
||||||
|
h2t.parse(file)
|
||||||
|
mp = MiniIC3(h2t.init, h2t.trans, h2t.goal, h2t.xs, h2t.inputs, h2t.xns)
|
||||||
|
result = mp.run()
|
||||||
|
if isinstance(result, Goal):
|
||||||
|
g = result
|
||||||
|
print("Trace")
|
||||||
|
while g:
|
||||||
|
print(g.level, g.cube)
|
||||||
|
g = g.parent
|
||||||
|
return
|
||||||
|
if isinstance(result, ExprRef):
|
||||||
|
print("Invariant:\n%s " % result)
|
||||||
|
return
|
||||||
|
print(result)
|
||||||
|
|
||||||
|
test("data/horn1.smt2")
|
||||||
|
test("data/horn2.smt2")
|
||||||
|
test("data/horn3.smt2")
|
||||||
|
test("data/horn4.smt2")
|
||||||
|
test("data/horn5.smt2")
|
||||||
|
test("data/horn6.smt2")
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
"""
|
||||||
|
# TBD: Quip variant of IC3
|
||||||
|
|
||||||
|
must = True
|
||||||
|
may = False
|
||||||
|
|
||||||
|
class QGoal:
|
||||||
|
def __init__(self, cube, parent, level, must):
|
||||||
|
self.level = level
|
||||||
|
self.cube = cube
|
||||||
|
self.parent = parent
|
||||||
|
self.must = must
|
||||||
|
|
||||||
|
class Quip(MiniIC3):
|
||||||
|
|
||||||
|
# prev & tras -> r', such that r' intersects with cube
|
||||||
|
def add_reachable(self, prev, cube):
|
||||||
|
s = fd_solver()
|
||||||
|
s.add(self.trans)
|
||||||
|
s.add(prev)
|
||||||
|
s.add(Or(cube))
|
||||||
|
is_sat = s.check()
|
||||||
|
assert is_sat == sat
|
||||||
|
m = s.model();
|
||||||
|
result = self.values2literals(m, cube)
|
||||||
|
assert result
|
||||||
|
self.reachable.add(result)
|
||||||
|
|
||||||
|
# A state s0 and level f0 such that
|
||||||
|
# not(s0) is f0-1 inductive
|
||||||
|
def quip_blocked(self, s0, f0):
|
||||||
|
self.push_heap(QGoal(self.next(s0), None, f0, must))
|
||||||
|
while self.goals:
|
||||||
|
f, g = heapq.heappop(self.goals)
|
||||||
|
sys.stdout.write("%d." % f)
|
||||||
|
sys.stdout.flush()
|
||||||
|
if f == 0:
|
||||||
|
if g.must:
|
||||||
|
print("")
|
||||||
|
return g
|
||||||
|
self.add_reachable(self.init, p.parent.cube)
|
||||||
|
continue
|
||||||
|
|
||||||
|
# TBD
|
||||||
|
return None
|
||||||
|
|
||||||
|
|
||||||
|
def run(self):
|
||||||
|
if not check_disjoint(self.init, self.bad):
|
||||||
|
return "goal is reached in initial state"
|
||||||
|
level = 0
|
||||||
|
while True:
|
||||||
|
inv = self.is_valid()
|
||||||
|
if inv is not None:
|
||||||
|
return inv
|
||||||
|
is_sat, cube = self.unfold()
|
||||||
|
if is_sat == unsat:
|
||||||
|
level += 1
|
||||||
|
print("Unfold %d" % level)
|
||||||
|
sys.stdout.flush()
|
||||||
|
self.add_solver()
|
||||||
|
elif is_sat == sat:
|
||||||
|
cex = self.quipie_blocked(cube, level)
|
||||||
|
if cex is not None:
|
||||||
|
return cex
|
||||||
|
else:
|
||||||
|
return is_sat
|
||||||
|
|
||||||
|
"""
|
||||||
149
examples/python/rc2.py
Normal file
149
examples/python/rc2.py
Normal file
|
|
@ -0,0 +1,149 @@
|
||||||
|
# RC2 algorithm
|
||||||
|
# basic version with some optimizations
|
||||||
|
# - process soft constraints in order of highest values first.
|
||||||
|
# - extract multiple cores, not just one
|
||||||
|
# - use built-in cardinality constraints, cheap core minimization.
|
||||||
|
#
|
||||||
|
# See also https://github.com/pysathq/pysat and papers in CP 2014, JSAT 2015.
|
||||||
|
|
||||||
|
from z3 import *
|
||||||
|
|
||||||
|
def tt(s, f):
|
||||||
|
return is_true(s.model().eval(f))
|
||||||
|
|
||||||
|
def add(Ws, f, w):
|
||||||
|
Ws[f] = w + (Ws[f] if f in Ws else 0)
|
||||||
|
|
||||||
|
def sub(Ws, f, w):
|
||||||
|
w1 = Ws[f]
|
||||||
|
if w1 > w:
|
||||||
|
Ws[f] = w1 - w
|
||||||
|
else:
|
||||||
|
del(Ws[f])
|
||||||
|
|
||||||
|
class RC2:
|
||||||
|
|
||||||
|
def __init__(self, s):
|
||||||
|
self.bounds = {}
|
||||||
|
self.names = {}
|
||||||
|
self.solver = s
|
||||||
|
self.solver.set("sat.cardinality.solver", True)
|
||||||
|
self.solver.set("sat.core.minimize", True)
|
||||||
|
self.solver.set("sat.core.minimize_partial", True)
|
||||||
|
|
||||||
|
def at_most(self, S, k):
|
||||||
|
fml = simplify(AtMost(S + [k]))
|
||||||
|
if fml in self.names:
|
||||||
|
return self.names[fml]
|
||||||
|
name = Bool("%s" % fml)
|
||||||
|
self.solver.add(Implies(name, fml))
|
||||||
|
self.bounds[name] = (S, k)
|
||||||
|
sel.names[fml] = name
|
||||||
|
return name
|
||||||
|
|
||||||
|
def print_cost(self):
|
||||||
|
print("cost [", self.min_cost, ":", self.max_cost, "]")
|
||||||
|
|
||||||
|
def update_max_cost(self):
|
||||||
|
self.max_cost = min(self.max_cost, self.get_cost())
|
||||||
|
self.print_cost()
|
||||||
|
|
||||||
|
# sort W, and incrementally add elements of W
|
||||||
|
# in sorted order to prefer cores with high weight.
|
||||||
|
def check(self, Ws):
|
||||||
|
ws = sorted(list(Ws), lambda f,w : -w)
|
||||||
|
# print(ws)
|
||||||
|
i = 0
|
||||||
|
while i < len(ws):
|
||||||
|
j = i
|
||||||
|
# increment j until making 5% progress or exhausting equal weight entries
|
||||||
|
while (j < len(ws) and ws[j][1] == ws[i][1]) or (i > 0 and (i - j)*20 < len(ws)):
|
||||||
|
j += 1
|
||||||
|
i = j
|
||||||
|
r = self.solver.check(ws[j][0] for j in range(i))
|
||||||
|
if r == sat:
|
||||||
|
self.update_max_cost()
|
||||||
|
else:
|
||||||
|
return r
|
||||||
|
return sat
|
||||||
|
|
||||||
|
def get_cost(self):
|
||||||
|
return sum(self.Ws0[c] for c in self.Ws0 if not tt(self.solver, c))
|
||||||
|
|
||||||
|
# Retrieve independendent cores from Ws
|
||||||
|
def get_cores(self, Ws):
|
||||||
|
cores = []
|
||||||
|
while unsat == self.check(Ws):
|
||||||
|
core = list(self.solver.unsat_core())
|
||||||
|
print (self.solver.statistics())
|
||||||
|
if not core:
|
||||||
|
return unsat
|
||||||
|
w = min([Ws[c] for c in core])
|
||||||
|
for f in core:
|
||||||
|
sub(Ws, f, w)
|
||||||
|
cores += [(core, w)]
|
||||||
|
self.update_max_cost()
|
||||||
|
return cores
|
||||||
|
|
||||||
|
# Add new soft constraints to replace core
|
||||||
|
# with weight w. Allow to weaken at most
|
||||||
|
# one element of core. Elements that are
|
||||||
|
# cardinality constraints are weakened by
|
||||||
|
# increasing their bounds. Non-cardinality
|
||||||
|
# constraints are weakened to "true". They
|
||||||
|
# correspond to the constraint Not(s) <= 0,
|
||||||
|
# so weakening produces Not(s) <= 1, which
|
||||||
|
# is a tautology.
|
||||||
|
def update_bounds(self, Ws, core, w):
|
||||||
|
for f in core:
|
||||||
|
if f in self.bounds:
|
||||||
|
S, k = self.bounds[f]
|
||||||
|
if k + 1 < len(S):
|
||||||
|
add(Ws, self.at_most(S, k + 1), w)
|
||||||
|
add(Ws, self.at_most([mk_not(f) for f in core], 1), w)
|
||||||
|
|
||||||
|
# Ws are weighted soft constraints
|
||||||
|
# Whenever there is an unsatisfiable core over ws
|
||||||
|
# increase the limit of each soft constraint from a bound
|
||||||
|
# and create a soft constraint that limits the number of
|
||||||
|
# increased bounds to be at most one.
|
||||||
|
def maxsat(self, Ws):
|
||||||
|
self.min_cost = 0
|
||||||
|
self.max_cost = sum(Ws[c] for c in Ws)
|
||||||
|
self.Ws0 = Ws.copy()
|
||||||
|
while True:
|
||||||
|
cores = self.get_cores(Ws)
|
||||||
|
if not cores:
|
||||||
|
break
|
||||||
|
if cores == unsat:
|
||||||
|
return unsat
|
||||||
|
for (core, w) in cores:
|
||||||
|
self.min_cost += w
|
||||||
|
self.print_cost()
|
||||||
|
self.update_bounds(Ws, core, w)
|
||||||
|
return sel.min_cost, { f for f in self.Ws0 if not tt(self.solver, f) }
|
||||||
|
|
||||||
|
def from_file(self, file):
|
||||||
|
opt = Optimize()
|
||||||
|
opt.from_file(file)
|
||||||
|
self.solver.add(opt.assertions())
|
||||||
|
obj = opt.objectives()[0]
|
||||||
|
Ws = {}
|
||||||
|
for f in obj.children():
|
||||||
|
assert(f.arg(1).as_long() == 0)
|
||||||
|
add(Ws, f.arg(0), f.arg(2).as_long())
|
||||||
|
return self.maxsat(Ws)
|
||||||
|
|
||||||
|
def main(file):
|
||||||
|
s = SolverFor("QF_FD")
|
||||||
|
rc2 = RC2(s)
|
||||||
|
set_param(verbose=0)
|
||||||
|
cost, falses = rc2.from_file(file)
|
||||||
|
print(cost)
|
||||||
|
print(s.statistics())
|
||||||
|
|
||||||
|
if len(sys.argv) > 1:
|
||||||
|
main(sys.argv[1])
|
||||||
|
|
||||||
|
# main(<myfile>)
|
||||||
|
|
||||||
|
|
@ -7,8 +7,8 @@ find_package(Z3
|
||||||
REQUIRED
|
REQUIRED
|
||||||
CONFIG
|
CONFIG
|
||||||
# `NO_DEFAULT_PATH` is set so that -DZ3_DIR has to be passed to find Z3.
|
# `NO_DEFAULT_PATH` is set so that -DZ3_DIR has to be passed to find Z3.
|
||||||
# This should prevent us from accidently picking up an installed
|
# This should prevent us from accidentally picking up an installed
|
||||||
# copy of Z3. This is here to benefit Z3's build sytem when building
|
# copy of Z3. This is here to benefit Z3's build system when building
|
||||||
# this project. When making your own project you probably shouldn't
|
# this project. When making your own project you probably shouldn't
|
||||||
# use this option.
|
# use this option.
|
||||||
NO_DEFAULT_PATH
|
NO_DEFAULT_PATH
|
||||||
|
|
|
||||||
|
|
@ -5,9 +5,9 @@ in the build directory.
|
||||||
|
|
||||||
This command will create the executable tptp.
|
This command will create the executable tptp.
|
||||||
On Windows, you can just execute it.
|
On Windows, you can just execute it.
|
||||||
On OSX and Linux, you must install z3 first using
|
On macOS and Linux, you must install z3 first using
|
||||||
sudo make install
|
sudo make install
|
||||||
OR update LD_LIBRARY_PATH (Linux) or DYLD_LIBRARY_PATH (OSX)
|
OR update LD_LIBRARY_PATH (Linux) or DYLD_LIBRARY_PATH (macOS)
|
||||||
with the build directory. You need that to be able to
|
with the build directory. You need that to be able to
|
||||||
find the Z3 shared library.
|
find the Z3 shared library.
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -233,7 +233,7 @@ class env {
|
||||||
|
|
||||||
void check_arity(unsigned num_args, unsigned arity) {
|
void check_arity(unsigned num_args, unsigned arity) {
|
||||||
if (num_args != arity) {
|
if (num_args != arity) {
|
||||||
throw failure_ex("arity missmatch");
|
throw failure_ex("arity mismatch");
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -1337,7 +1337,7 @@ public:
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
else if (e.is_quantifier()) {
|
else if (e.is_quantifier()) {
|
||||||
Z3_bool is_forall = Z3_is_quantifier_forall(ctx, e);
|
bool is_forall = Z3_is_quantifier_forall(ctx, e);
|
||||||
unsigned nb = Z3_get_quantifier_num_bound(ctx, e);
|
unsigned nb = Z3_get_quantifier_num_bound(ctx, e);
|
||||||
|
|
||||||
out << (is_forall?"!":"?") << "[";
|
out << (is_forall?"!":"?") << "[";
|
||||||
|
|
|
||||||
0
noarch/repodata.json
Normal file
0
noarch/repodata.json
Normal file
BIN
noarch/repodata.json.bz2
Normal file
BIN
noarch/repodata.json.bz2
Normal file
Binary file not shown.
22
package/Microsoft.Z3.x64.nuspec
Normal file
22
package/Microsoft.Z3.x64.nuspec
Normal file
|
|
@ -0,0 +1,22 @@
|
||||||
|
<?xml version="1.0" encoding="utf-8"?>
|
||||||
|
<package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
|
||||||
|
<metadata>
|
||||||
|
<id>Microsoft.Z3.x64</id>
|
||||||
|
<version>$(releaseVersion)</version>
|
||||||
|
<copyright>© Microsoft Corporation. All rights reserved.</copyright>
|
||||||
|
<authors>Microsoft</authors>
|
||||||
|
<iconUrl>https://raw.githubusercontent.com/Z3Prover/z3/$(releaseCommitHash)/package/icon.jpg</iconUrl>
|
||||||
|
<projectUrl>https://github.com/Z3Prover/z3</projectUrl>
|
||||||
|
<licenseUrl>https://raw.githubusercontent.com/Z3Prover/z3/$(releaseCommitHash)/LICENSE.txt</licenseUrl>
|
||||||
|
<repository
|
||||||
|
type="git"
|
||||||
|
url="https://github.com/Z3Prover/z3.git"
|
||||||
|
branch="master"
|
||||||
|
commit="$(releaseCommitHash)"
|
||||||
|
/>
|
||||||
|
<requireLicenseAcceptance>true</requireLicenseAcceptance>
|
||||||
|
<description>Z3 is a satisfiability modulo theories solver from Microsoft Research.</description>
|
||||||
|
<tags>smt constraint solver theorem prover</tags>
|
||||||
|
<language>en</language>
|
||||||
|
</metadata>
|
||||||
|
</package>
|
||||||
10
package/Microsoft.Z3.x64.targets
Normal file
10
package/Microsoft.Z3.x64.targets
Normal file
|
|
@ -0,0 +1,10 @@
|
||||||
|
<?xml version="1.0" encoding="utf-8"?>
|
||||||
|
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||||
|
<ItemGroup>
|
||||||
|
<None Include="$(MSBuildThisFileDirectory)libz3.dll">
|
||||||
|
<Visible>false</Visible>
|
||||||
|
<Link>libz3.dll</Link>
|
||||||
|
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
|
||||||
|
</None>
|
||||||
|
</ItemGroup>
|
||||||
|
</Project>
|
||||||
34
package/PackageCreationDirections.md
Normal file
34
package/PackageCreationDirections.md
Normal file
|
|
@ -0,0 +1,34 @@
|
||||||
|
# Z3 NuGet packaging
|
||||||
|
|
||||||
|
## Creation
|
||||||
|
|
||||||
|
1. After tagging a commit for release, sign Microsoft.Z3.dll and libz3.dll (both x86 and x64 versions) with Microsoft's Authenticode certificate
|
||||||
|
2. Test the signed DLLs with the `Get-AuthenticodeSignature` PowerShell commandlet
|
||||||
|
3. Create the following directory structure for the x64 package (for x86, substitute the "x64" strings for "x86" and use x86 DLLs):
|
||||||
|
```
|
||||||
|
+-- Microsoft.Z3.x64
|
||||||
|
| +-- Microsoft.Z3.x64.nuspec
|
||||||
|
| +-- lib
|
||||||
|
| +-- net40
|
||||||
|
| +-- Microsoft.Z3.dll
|
||||||
|
| +-- build
|
||||||
|
| +-- Microsoft.Z3.x64.targets
|
||||||
|
| +-- libz3.dll
|
||||||
|
```
|
||||||
|
4. Open the nuspec file and fill in the appropriate macro values:
|
||||||
|
* $(releaseVersion) - the Z3 version being released in this package
|
||||||
|
* $(releaseCommitHash) - hash of the release commit (there are several of these)
|
||||||
|
5. Run `nuget pack Microsoft.Z3.x64\Microsoft.Z3.x64.nuspec`
|
||||||
|
6. Test the resulting nupkg file (described below) then submit the package for signing before uploading to NuGet.org
|
||||||
|
|
||||||
|
## Testing
|
||||||
|
|
||||||
|
1. Create a directory on your machine at C:\nuget-test-source
|
||||||
|
2. Put the Microsoft.Z3.x64.nupkg file in the directory
|
||||||
|
3. Open Visual Studio 2017, create a new C# project, then right click the project and click "Manage NuGet packages"
|
||||||
|
4. Add a new package source - your C:\nuget-test-source directory
|
||||||
|
5. Find the Microsoft.Z3.x64 package, ensuring in preview window that icon is present and all fields correct
|
||||||
|
6. Install the Microsoft.Z3.x64 package, ensuring you are asked to accept the license
|
||||||
|
7. Build your project. Check the output directory to ensure both Microsoft.Z3.dll and libz3.dll are present
|
||||||
|
8. Import Microsoft.Z3 to your project then add a simple line of code like `using (var ctx = new Context()) { }`; build then run your project to ensure the assemblies load properly
|
||||||
|
|
||||||
BIN
package/icon.jpg
Normal file
BIN
package/icon.jpg
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 45 KiB |
|
|
@ -692,31 +692,35 @@ def mk_install_tactic_cpp_internal(h_files_full_path, path):
|
||||||
fout.write('#include "cmd_context/tactic_cmds.h"\n')
|
fout.write('#include "cmd_context/tactic_cmds.h"\n')
|
||||||
fout.write('#include "cmd_context/cmd_context.h"\n')
|
fout.write('#include "cmd_context/cmd_context.h"\n')
|
||||||
tactic_pat = re.compile('[ \t]*ADD_TACTIC\(.*\)')
|
tactic_pat = re.compile('[ \t]*ADD_TACTIC\(.*\)')
|
||||||
probe_pat = re.compile('[ \t]*ADD_PROBE\(.*\)')
|
probe_pat = re.compile('[ \t]*ADD_PROBE\(.*\)')
|
||||||
for h_file in sorted_headers_by_component(h_files_full_path):
|
for h_file in sorted_headers_by_component(h_files_full_path):
|
||||||
added_include = False
|
added_include = False
|
||||||
with open(h_file, 'r') as fin:
|
try:
|
||||||
for line in fin:
|
with open(h_file, 'r') as fin:
|
||||||
if tactic_pat.match(line):
|
for line in fin:
|
||||||
if not added_include:
|
if tactic_pat.match(line):
|
||||||
added_include = True
|
if not added_include:
|
||||||
fout.write('#include "%s"\n' % path_after_src(h_file))
|
added_include = True
|
||||||
try:
|
fout.write('#include "%s"\n' % path_after_src(h_file))
|
||||||
eval(line.strip('\n '), eval_globals, None)
|
try:
|
||||||
except Exception as e:
|
eval(line.strip('\n '), eval_globals, None)
|
||||||
_logger.error("Failed processing ADD_TACTIC command at '{}'\n{}".format(
|
except Exception as e:
|
||||||
fullname, line))
|
_logger.error("Failed processing ADD_TACTIC command at '{}'\n{}".format(
|
||||||
raise e
|
fullname, line))
|
||||||
if probe_pat.match(line):
|
raise e
|
||||||
if not added_include:
|
if probe_pat.match(line):
|
||||||
added_include = True
|
if not added_include:
|
||||||
fout.write('#include "%s"\n' % path_after_src(h_file))
|
added_include = True
|
||||||
try:
|
fout.write('#include "%s"\n' % path_after_src(h_file))
|
||||||
eval(line.strip('\n '), eval_globals, None)
|
try:
|
||||||
except Exception as e:
|
eval(line.strip('\n '), eval_globals, None)
|
||||||
_logger.error("Failed processing ADD_PROBE command at '{}'\n{}".format(
|
except Exception as e:
|
||||||
fullname, line))
|
_logger.error("Failed processing ADD_PROBE command at '{}'\n{}".format(
|
||||||
raise e
|
fullname, line))
|
||||||
|
raise e
|
||||||
|
except Exception as e:
|
||||||
|
_logger.error("Failed to read file {}\n".format(h_file))
|
||||||
|
raise e
|
||||||
# First pass will just generate the tactic factories
|
# First pass will just generate the tactic factories
|
||||||
fout.write('#define ADD_TACTIC_CMD(NAME, DESCR, CODE) ctx.insert(alloc(tactic_cmd, symbol(NAME), DESCR, [](ast_manager &m, const params_ref &p) { return CODE; }))\n')
|
fout.write('#define ADD_TACTIC_CMD(NAME, DESCR, CODE) ctx.insert(alloc(tactic_cmd, symbol(NAME), DESCR, [](ast_manager &m, const params_ref &p) { return CODE; }))\n')
|
||||||
fout.write('#define ADD_PROBE(NAME, DESCR, PROBE) ctx.insert(alloc(probe_info, symbol(NAME), DESCR, PROBE))\n')
|
fout.write('#define ADD_PROBE(NAME, DESCR, PROBE) ctx.insert(alloc(probe_info, symbol(NAME), DESCR, PROBE))\n')
|
||||||
|
|
|
||||||
118
scripts/mk_nuget_release.py
Normal file
118
scripts/mk_nuget_release.py
Normal file
|
|
@ -0,0 +1,118 @@
|
||||||
|
#
|
||||||
|
# Copyright (c) 2018 Microsoft Corporation
|
||||||
|
#
|
||||||
|
|
||||||
|
# 1. download releases from github
|
||||||
|
# 2. copy over libz3.dll for the different architectures
|
||||||
|
# 3. copy over Microsoft.Z3.dll from suitable distribution
|
||||||
|
# 4. copy nuspec file from packages
|
||||||
|
# 5. call nuget pack
|
||||||
|
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import urllib.request
|
||||||
|
import zipfile
|
||||||
|
import sys
|
||||||
|
import os.path
|
||||||
|
import shutil
|
||||||
|
import subprocess
|
||||||
|
import mk_util
|
||||||
|
import mk_project
|
||||||
|
|
||||||
|
data = json.loads(urllib.request.urlopen("https://api.github.com/repos/Z3Prover/z3/releases/latest").read().decode())
|
||||||
|
|
||||||
|
version_str = data['tag_name']
|
||||||
|
|
||||||
|
print(version_str)
|
||||||
|
|
||||||
|
def mk_dir(d):
|
||||||
|
if not os.path.exists(d):
|
||||||
|
os.makedirs(d)
|
||||||
|
|
||||||
|
def download_installs():
|
||||||
|
for asset in data['assets']:
|
||||||
|
url = asset['browser_download_url']
|
||||||
|
name = asset['name']
|
||||||
|
print("Downloading ", url)
|
||||||
|
sys.stdout.flush()
|
||||||
|
urllib.request.urlretrieve(url, "packages/%s" % name)
|
||||||
|
|
||||||
|
os_info = {"z64-ubuntu-14" : ('so', 'ubuntu.14.04-x64'),
|
||||||
|
'ubuntu-16' : ('so', 'ubuntu.16.04-x64'),
|
||||||
|
'x64-win' : ('dll', 'win-x64'),
|
||||||
|
'x86-win' : ('dll', 'win-x86'),
|
||||||
|
'osx' : ('dylib', 'macos'),
|
||||||
|
'debian' : ('so', 'debian.8-x64') }
|
||||||
|
|
||||||
|
def classify_package(f):
|
||||||
|
for os_name in os_info:
|
||||||
|
if os_name in f:
|
||||||
|
ext, dst = os_info[os_name]
|
||||||
|
return os_name, f[:-4], ext, dst
|
||||||
|
return None
|
||||||
|
|
||||||
|
def unpack():
|
||||||
|
shutil.rmtree("out", ignore_errors=True)
|
||||||
|
# unzip files in packages
|
||||||
|
# out
|
||||||
|
# +- runtimes
|
||||||
|
# +- win-x64
|
||||||
|
# +- win-x86
|
||||||
|
# +- ubuntu.16.04-x64
|
||||||
|
# +- ubuntu.14.04-x64
|
||||||
|
# +- debian.8-x64
|
||||||
|
# +- macos
|
||||||
|
# +
|
||||||
|
for f in os.listdir("packages"):
|
||||||
|
print(f)
|
||||||
|
if f.endswith(".zip") and classify_package(f):
|
||||||
|
os_name, package_dir, ext, dst = classify_package(f)
|
||||||
|
path = os.path.abspath(os.path.join("packages", f))
|
||||||
|
zip_ref = zipfile.ZipFile(path, 'r')
|
||||||
|
zip_ref.extract("%s/bin/libz3.%s" % (package_dir, ext), "tmp")
|
||||||
|
mk_dir("out/runtimes/%s/native" % dst)
|
||||||
|
shutil.move("tmp/%s/bin/libz3.%s" % (package_dir, ext), "out/runtimes/%s/native/." % dst, "/y")
|
||||||
|
if "x64-win" in f:
|
||||||
|
mk_dir("out/lib/netstandard1.4/")
|
||||||
|
for b in ["Microsoft.Z3.dll"]:
|
||||||
|
zip_ref.extract("%s/bin/%s" % (package_dir, b), "tmp")
|
||||||
|
shutil.move("tmp/%s/bin/%s" % (package_dir, b), "out/lib/netstandard1.4/%s" % b)
|
||||||
|
|
||||||
|
def create_nuget_spec():
|
||||||
|
contents = """<?xml version="1.0" encoding="utf-8"?>
|
||||||
|
<package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
|
||||||
|
<metadata>
|
||||||
|
<id>Microsoft.Z3</id>
|
||||||
|
<version>%s</version>
|
||||||
|
<authors>Microsoft</authors>
|
||||||
|
<description>Z3 is a satisfiability modulo theories solver from Microsoft Research.</description>
|
||||||
|
<copyright>Copyright Microsoft Corporation. All rights reserved.</copyright>
|
||||||
|
<tags>smt constraint solver theorem prover</tags>
|
||||||
|
<iconUrl>https://raw.githubusercontent.com/Z3Prover/z3/master/package/icon.jpg</iconUrl>
|
||||||
|
<projectUrl>https://github.com/Z3Prover/z3</projectUrl>
|
||||||
|
<licenseUrl>https://raw.githubusercontent.com/Z3Prover/z3/master/LICENSE.txt</licenseUrl>
|
||||||
|
<repository
|
||||||
|
type="git"
|
||||||
|
url="https://github.com/Z3Prover/z3.git"
|
||||||
|
branch="master"
|
||||||
|
/>
|
||||||
|
<requireLicenseAcceptance>true</requireLicenseAcceptance>
|
||||||
|
<language>en</language>
|
||||||
|
</metadata>
|
||||||
|
</package>"""
|
||||||
|
|
||||||
|
with open("out/Microsoft.Z3.nuspec", 'w') as f:
|
||||||
|
f.write(contents % version_str[3:])
|
||||||
|
|
||||||
|
def create_nuget_package():
|
||||||
|
subprocess.call(["nuget", "pack"], cwd="out")
|
||||||
|
|
||||||
|
def main():
|
||||||
|
mk_dir("packages")
|
||||||
|
download_installs()
|
||||||
|
unpack()
|
||||||
|
create_nuget_spec()
|
||||||
|
create_nuget_package()
|
||||||
|
|
||||||
|
|
||||||
|
main()
|
||||||
|
|
@ -7,10 +7,13 @@
|
||||||
############################################
|
############################################
|
||||||
from mk_util import *
|
from mk_util import *
|
||||||
|
|
||||||
|
def init_version():
|
||||||
|
set_version(4, 8, 5, 0)
|
||||||
|
|
||||||
# Z3 Project definition
|
# Z3 Project definition
|
||||||
def init_project_def():
|
def init_project_def():
|
||||||
set_version(4, 8, 0, 0)
|
init_version()
|
||||||
add_lib('util', [])
|
add_lib('util', [], includes2install = ['z3_version.h'])
|
||||||
add_lib('polynomial', ['util'], 'math/polynomial')
|
add_lib('polynomial', ['util'], 'math/polynomial')
|
||||||
add_lib('sat', ['util'])
|
add_lib('sat', ['util'])
|
||||||
add_lib('nlsat', ['polynomial', 'sat'])
|
add_lib('nlsat', ['polynomial', 'sat'])
|
||||||
|
|
@ -84,6 +87,7 @@ def init_project_def():
|
||||||
export_files=API_files,
|
export_files=API_files,
|
||||||
staging_link='python')
|
staging_link='python')
|
||||||
add_dot_net_dll('dotnet', ['api_dll'], 'api/dotnet', dll_name='Microsoft.Z3', assembly_info_dir='Properties', default_key_file='src/api/dotnet/Microsoft.Z3.snk')
|
add_dot_net_dll('dotnet', ['api_dll'], 'api/dotnet', dll_name='Microsoft.Z3', assembly_info_dir='Properties', default_key_file='src/api/dotnet/Microsoft.Z3.snk')
|
||||||
|
add_dot_net_core_dll('dotnetcore', ['api_dll'], 'api/dotnet', dll_name='Microsoft.Z3', assembly_info_dir='Properties', default_key_file='src/api/dotnet/Microsoft.Z3.snk')
|
||||||
add_java_dll('java', ['api_dll'], 'api/java', dll_name='libz3java', package_name="com.microsoft.z3", manifest_file='manifest')
|
add_java_dll('java', ['api_dll'], 'api/java', dll_name='libz3java', package_name="com.microsoft.z3", manifest_file='manifest')
|
||||||
add_ml_lib('ml', ['api_dll'], 'api/ml', lib_name='libz3ml')
|
add_ml_lib('ml', ['api_dll'], 'api/ml', lib_name='libz3ml')
|
||||||
add_hlib('cpp', 'api/c++', includes2install=['z3++.h'])
|
add_hlib('cpp', 'api/c++', includes2install=['z3++.h'])
|
||||||
|
|
|
||||||
|
|
@ -23,6 +23,7 @@ VERBOSE=True
|
||||||
DIST_DIR='dist'
|
DIST_DIR='dist'
|
||||||
FORCE_MK=False
|
FORCE_MK=False
|
||||||
DOTNET_ENABLED=True
|
DOTNET_ENABLED=True
|
||||||
|
DOTNET_CORE_ENABLED=False
|
||||||
DOTNET_KEY_FILE=None
|
DOTNET_KEY_FILE=None
|
||||||
JAVA_ENABLED=True
|
JAVA_ENABLED=True
|
||||||
GIT_HASH=False
|
GIT_HASH=False
|
||||||
|
|
@ -55,6 +56,7 @@ def display_help():
|
||||||
print(" -b <sudir>, --build=<subdir> subdirectory where x86 and x64 Z3 versions will be built (default: build-dist).")
|
print(" -b <sudir>, --build=<subdir> subdirectory where x86 and x64 Z3 versions will be built (default: build-dist).")
|
||||||
print(" -f, --force force script to regenerate Makefiles.")
|
print(" -f, --force force script to regenerate Makefiles.")
|
||||||
print(" --nodotnet do not include .NET bindings in the binary distribution files.")
|
print(" --nodotnet do not include .NET bindings in the binary distribution files.")
|
||||||
|
print(" --dotnetcore build for dotnet core.")
|
||||||
print(" --dotnet-key=<file> sign the .NET assembly with the private key in <file>.")
|
print(" --dotnet-key=<file> sign the .NET assembly with the private key in <file>.")
|
||||||
print(" --nojava do not include Java bindings in the binary distribution files.")
|
print(" --nojava do not include Java bindings in the binary distribution files.")
|
||||||
print(" --nopython do not include Python bindings in the binary distribution files.")
|
print(" --nopython do not include Python bindings in the binary distribution files.")
|
||||||
|
|
@ -63,7 +65,7 @@ def display_help():
|
||||||
|
|
||||||
# Parse configuration option for mk_make script
|
# Parse configuration option for mk_make script
|
||||||
def parse_options():
|
def parse_options():
|
||||||
global FORCE_MK, JAVA_ENABLED, GIT_HASH, DOTNET_ENABLED, DOTNET_KEY_FILE
|
global FORCE_MK, JAVA_ENABLED, GIT_HASH, DOTNET_ENABLED, DOTNET_CORE_ENABLED, DOTNET_KEY_FILE
|
||||||
path = BUILD_DIR
|
path = BUILD_DIR
|
||||||
options, remainder = getopt.gnu_getopt(sys.argv[1:], 'b:hsf', ['build=',
|
options, remainder = getopt.gnu_getopt(sys.argv[1:], 'b:hsf', ['build=',
|
||||||
'help',
|
'help',
|
||||||
|
|
@ -71,6 +73,7 @@ def parse_options():
|
||||||
'force',
|
'force',
|
||||||
'nojava',
|
'nojava',
|
||||||
'nodotnet',
|
'nodotnet',
|
||||||
|
'dotnetcore',
|
||||||
'dotnet-key=',
|
'dotnet-key=',
|
||||||
'githash',
|
'githash',
|
||||||
'nopython'
|
'nopython'
|
||||||
|
|
@ -88,6 +91,9 @@ def parse_options():
|
||||||
FORCE_MK = True
|
FORCE_MK = True
|
||||||
elif opt == '--nodotnet':
|
elif opt == '--nodotnet':
|
||||||
DOTNET_ENABLED = False
|
DOTNET_ENABLED = False
|
||||||
|
elif opt == '--dotnetcore':
|
||||||
|
DOTNET_CORE_ENABLED = True
|
||||||
|
DOTNET_ENABLED = False
|
||||||
elif opt == '--nopython':
|
elif opt == '--nopython':
|
||||||
PYTHON_ENABLED = False
|
PYTHON_ENABLED = False
|
||||||
elif opt == '--dotnet-key':
|
elif opt == '--dotnet-key':
|
||||||
|
|
@ -108,7 +114,11 @@ def check_build_dir(path):
|
||||||
def mk_build_dir(path):
|
def mk_build_dir(path):
|
||||||
if not check_build_dir(path) or FORCE_MK:
|
if not check_build_dir(path) or FORCE_MK:
|
||||||
opts = ["python", os.path.join('scripts', 'mk_make.py'), "-b", path, "--staticlib"]
|
opts = ["python", os.path.join('scripts', 'mk_make.py'), "-b", path, "--staticlib"]
|
||||||
if DOTNET_ENABLED:
|
if DOTNET_CORE_ENABLED:
|
||||||
|
opts.append('--dotnetcore')
|
||||||
|
if not DOTNET_KEY_FILE is None:
|
||||||
|
opts.append('--dotnet-key=' + DOTNET_KEY_FILE)
|
||||||
|
elif DOTNET_ENABLED:
|
||||||
opts.append('--dotnet')
|
opts.append('--dotnet')
|
||||||
if not DOTNET_KEY_FILE is None:
|
if not DOTNET_KEY_FILE is None:
|
||||||
opts.append('--dotnet-key=' + DOTNET_KEY_FILE)
|
opts.append('--dotnet-key=' + DOTNET_KEY_FILE)
|
||||||
|
|
@ -186,7 +196,8 @@ def mk_dist_dir():
|
||||||
build_path = BUILD_DIR
|
build_path = BUILD_DIR
|
||||||
dist_path = os.path.join(DIST_DIR, get_z3_name())
|
dist_path = os.path.join(DIST_DIR, get_z3_name())
|
||||||
mk_dir(dist_path)
|
mk_dir(dist_path)
|
||||||
mk_util.DOTNET_ENABLED = DOTNET_ENABLED
|
mk_util.DOTNET_CORE_ENABLED = DOTNET_CORE_ENABLED
|
||||||
|
mk_util.DOTNET_ENABLED = DOTNET_ENABLED
|
||||||
mk_util.DOTNET_KEY_FILE = DOTNET_KEY_FILE
|
mk_util.DOTNET_KEY_FILE = DOTNET_KEY_FILE
|
||||||
mk_util.JAVA_ENABLED = JAVA_ENABLED
|
mk_util.JAVA_ENABLED = JAVA_ENABLED
|
||||||
mk_util.PYTHON_ENABLED = PYTHON_ENABLED
|
mk_util.PYTHON_ENABLED = PYTHON_ENABLED
|
||||||
|
|
|
||||||
|
|
@ -37,6 +37,7 @@ OCAMLOPT=getenv("OCAMLOPT", "ocamlopt")
|
||||||
OCAML_LIB=getenv("OCAML_LIB", None)
|
OCAML_LIB=getenv("OCAML_LIB", None)
|
||||||
OCAMLFIND=getenv("OCAMLFIND", "ocamlfind")
|
OCAMLFIND=getenv("OCAMLFIND", "ocamlfind")
|
||||||
CSC=getenv("CSC", None)
|
CSC=getenv("CSC", None)
|
||||||
|
DOTNET="dotnet"
|
||||||
GACUTIL=getenv("GACUTIL", 'gacutil')
|
GACUTIL=getenv("GACUTIL", 'gacutil')
|
||||||
# Standard install directories relative to PREFIX
|
# Standard install directories relative to PREFIX
|
||||||
INSTALL_BIN_DIR=getenv("Z3_INSTALL_BIN_DIR", "bin")
|
INSTALL_BIN_DIR=getenv("Z3_INSTALL_BIN_DIR", "bin")
|
||||||
|
|
@ -60,6 +61,7 @@ PATTERN_COMPONENT='pattern'
|
||||||
UTIL_COMPONENT='util'
|
UTIL_COMPONENT='util'
|
||||||
API_COMPONENT='api'
|
API_COMPONENT='api'
|
||||||
DOTNET_COMPONENT='dotnet'
|
DOTNET_COMPONENT='dotnet'
|
||||||
|
DOTNET_CORE_COMPONENT='dotnetcore'
|
||||||
JAVA_COMPONENT='java'
|
JAVA_COMPONENT='java'
|
||||||
ML_COMPONENT='ml'
|
ML_COMPONENT='ml'
|
||||||
CPP_COMPONENT='cpp'
|
CPP_COMPONENT='cpp'
|
||||||
|
|
@ -87,6 +89,8 @@ VS_PROJ = False
|
||||||
TRACE = False
|
TRACE = False
|
||||||
PYTHON_ENABLED=False
|
PYTHON_ENABLED=False
|
||||||
DOTNET_ENABLED=False
|
DOTNET_ENABLED=False
|
||||||
|
DOTNET_CORE_ENABLED=False
|
||||||
|
ESRP_SIGN=False
|
||||||
DOTNET_KEY_FILE=getenv("Z3_DOTNET_KEY_FILE", None)
|
DOTNET_KEY_FILE=getenv("Z3_DOTNET_KEY_FILE", None)
|
||||||
JAVA_ENABLED=False
|
JAVA_ENABLED=False
|
||||||
ML_ENABLED=False
|
ML_ENABLED=False
|
||||||
|
|
@ -396,7 +400,7 @@ def check_java():
|
||||||
libdirs = m.group(1).split(',')
|
libdirs = m.group(1).split(',')
|
||||||
for libdir in libdirs:
|
for libdir in libdirs:
|
||||||
q = os.path.dirname(libdir)
|
q = os.path.dirname(libdir)
|
||||||
if cdirs.count(q) == 0:
|
if cdirs.count(q) == 0 and len(q) > 0:
|
||||||
cdirs.append(q)
|
cdirs.append(q)
|
||||||
t.close()
|
t.close()
|
||||||
|
|
||||||
|
|
@ -452,6 +456,13 @@ def check_dotnet():
|
||||||
if r != 0:
|
if r != 0:
|
||||||
raise MKException('Failed testing gacutil. Set environment variable GACUTIL with the path to gacutil.')
|
raise MKException('Failed testing gacutil. Set environment variable GACUTIL with the path to gacutil.')
|
||||||
|
|
||||||
|
def check_dotnet_core():
|
||||||
|
if not IS_WINDOWS:
|
||||||
|
return
|
||||||
|
r = exec_cmd([DOTNET, '--help'])
|
||||||
|
if r != 0:
|
||||||
|
raise MKException('Failed testing dotnet. Make sure to install and configure dotnet core utilities')
|
||||||
|
|
||||||
def check_ml():
|
def check_ml():
|
||||||
t = TempFile('hello.ml')
|
t = TempFile('hello.ml')
|
||||||
t.add('print_string "Hello world!\n";;')
|
t.add('print_string "Hello world!\n";;')
|
||||||
|
|
@ -553,6 +564,11 @@ def set_version(major, minor, build, revision):
|
||||||
def get_version():
|
def get_version():
|
||||||
return (VER_MAJOR, VER_MINOR, VER_BUILD, VER_REVISION)
|
return (VER_MAJOR, VER_MINOR, VER_BUILD, VER_REVISION)
|
||||||
|
|
||||||
|
def get_version_string(n):
|
||||||
|
if n == 3:
|
||||||
|
return "{}.{}.{}".format(VER_MAJOR,VER_MINOR,VER_BUILD)
|
||||||
|
return "{}.{}.{}.{}".format(VER_MAJOR,VER_MINOR,VER_BUILD,VER_REVISION)
|
||||||
|
|
||||||
def build_static_lib():
|
def build_static_lib():
|
||||||
return STATIC_LIB
|
return STATIC_LIB
|
||||||
|
|
||||||
|
|
@ -652,6 +668,7 @@ def display_help(exit_code):
|
||||||
if IS_WINDOWS:
|
if IS_WINDOWS:
|
||||||
print(" -v, --vsproj generate Visual Studio Project Files.")
|
print(" -v, --vsproj generate Visual Studio Project Files.")
|
||||||
print(" --optimize generate optimized code during linking.")
|
print(" --optimize generate optimized code during linking.")
|
||||||
|
print(" --dotnetcore generate .NET platform bindings.")
|
||||||
print(" --dotnet generate .NET bindings.")
|
print(" --dotnet generate .NET bindings.")
|
||||||
print(" --dotnet-key=<file> sign the .NET assembly using the private key in <file>.")
|
print(" --dotnet-key=<file> sign the .NET assembly using the private key in <file>.")
|
||||||
print(" --java generate Java bindings.")
|
print(" --java generate Java bindings.")
|
||||||
|
|
@ -690,14 +707,14 @@ def display_help(exit_code):
|
||||||
# Parse configuration option for mk_make script
|
# Parse configuration option for mk_make script
|
||||||
def parse_options():
|
def parse_options():
|
||||||
global VERBOSE, DEBUG_MODE, IS_WINDOWS, VS_X64, ONLY_MAKEFILES, SHOW_CPPS, VS_PROJ, TRACE, VS_PAR, VS_PAR_NUM
|
global VERBOSE, DEBUG_MODE, IS_WINDOWS, VS_X64, ONLY_MAKEFILES, SHOW_CPPS, VS_PROJ, TRACE, VS_PAR, VS_PAR_NUM
|
||||||
global DOTNET_ENABLED, DOTNET_KEY_FILE, JAVA_ENABLED, ML_ENABLED, JS_ENABLED, STATIC_LIB, STATIC_BIN, PREFIX, GMP, PYTHON_PACKAGE_DIR, GPROF, GIT_HASH, GIT_DESCRIBE, PYTHON_INSTALL_ENABLED, PYTHON_ENABLED
|
global DOTNET_ENABLED, DOTNET_CORE_ENABLED, DOTNET_KEY_FILE, JAVA_ENABLED, ML_ENABLED, JS_ENABLED, STATIC_LIB, STATIC_BIN, PREFIX, GMP, PYTHON_PACKAGE_DIR, GPROF, GIT_HASH, GIT_DESCRIBE, PYTHON_INSTALL_ENABLED, PYTHON_ENABLED, ESRP_SIGN
|
||||||
global LINUX_X64, SLOW_OPTIMIZE, USE_OMP, LOG_SYNC
|
global LINUX_X64, SLOW_OPTIMIZE, USE_OMP, LOG_SYNC
|
||||||
global GUARD_CF, ALWAYS_DYNAMIC_BASE
|
global GUARD_CF, ALWAYS_DYNAMIC_BASE
|
||||||
try:
|
try:
|
||||||
options, remainder = getopt.gnu_getopt(sys.argv[1:],
|
options, remainder = getopt.gnu_getopt(sys.argv[1:],
|
||||||
'b:df:sxhmcvtnp:gj',
|
'b:df:sxhmcvtnp:gj',
|
||||||
['build=', 'debug', 'silent', 'x64', 'help', 'makefiles', 'showcpp', 'vsproj', 'guardcf',
|
['build=', 'debug', 'silent', 'x64', 'help', 'makefiles', 'showcpp', 'vsproj', 'guardcf',
|
||||||
'trace', 'dotnet', 'dotnet-key=', 'staticlib', 'prefix=', 'gmp', 'java', 'parallel=', 'gprof', 'js',
|
'trace', 'dotnet', 'dotnetcore', 'dotnet-key=', 'esrp', 'staticlib', 'prefix=', 'gmp', 'java', 'parallel=', 'gprof', 'js',
|
||||||
'githash=', 'git-describe', 'x86', 'ml', 'optimize', 'noomp', 'pypkgdir=', 'python', 'staticbin', 'log-sync'])
|
'githash=', 'git-describe', 'x86', 'ml', 'optimize', 'noomp', 'pypkgdir=', 'python', 'staticbin', 'log-sync'])
|
||||||
except:
|
except:
|
||||||
print("ERROR: Invalid command line option")
|
print("ERROR: Invalid command line option")
|
||||||
|
|
@ -731,8 +748,12 @@ def parse_options():
|
||||||
TRACE = True
|
TRACE = True
|
||||||
elif opt in ('-.net', '--dotnet'):
|
elif opt in ('-.net', '--dotnet'):
|
||||||
DOTNET_ENABLED = True
|
DOTNET_ENABLED = True
|
||||||
|
elif opt in ('--dotnetcore',):
|
||||||
|
DOTNET_CORE_ENABLED = True
|
||||||
elif opt in ('--dotnet-key'):
|
elif opt in ('--dotnet-key'):
|
||||||
DOTNET_KEY_FILE = arg
|
DOTNET_KEY_FILE = arg
|
||||||
|
elif opt in ('--esrp'):
|
||||||
|
ESRP_SIGN = True
|
||||||
elif opt in ('--staticlib'):
|
elif opt in ('--staticlib'):
|
||||||
STATIC_LIB = True
|
STATIC_LIB = True
|
||||||
elif opt in ('--staticbin'):
|
elif opt in ('--staticbin'):
|
||||||
|
|
@ -887,6 +908,9 @@ def is_js_enabled():
|
||||||
def is_dotnet_enabled():
|
def is_dotnet_enabled():
|
||||||
return DOTNET_ENABLED
|
return DOTNET_ENABLED
|
||||||
|
|
||||||
|
def is_dotnet_core_enabled():
|
||||||
|
return DOTNET_CORE_ENABLED
|
||||||
|
|
||||||
def is_python_enabled():
|
def is_python_enabled():
|
||||||
return PYTHON_ENABLED
|
return PYTHON_ENABLED
|
||||||
|
|
||||||
|
|
@ -1606,6 +1630,23 @@ class PythonInstallComponent(Component):
|
||||||
def mk_makefile(self, out):
|
def mk_makefile(self, out):
|
||||||
return
|
return
|
||||||
|
|
||||||
|
def set_key_file(self):
|
||||||
|
global DOTNET_KEY_FILE
|
||||||
|
# We need to give the assembly a strong name so that it
|
||||||
|
# can be installed into the GAC with ``make install``
|
||||||
|
if not DOTNET_KEY_FILE is None:
|
||||||
|
self.key_file = DOTNET_KEY_FILE
|
||||||
|
|
||||||
|
if not self.key_file is None:
|
||||||
|
if os.path.isfile(self.key_file):
|
||||||
|
self.key_file = os.path.abspath(self.key_file)
|
||||||
|
elif os.path.isfile(os.path.join(self.src_dir, self.key_file)):
|
||||||
|
self.key_file = os.path.abspath(os.path.join(self.src_dir, self.key_file))
|
||||||
|
else:
|
||||||
|
print("Keyfile '%s' could not be found; %s.dll will be unsigned." % (self.key_file, self.dll_name))
|
||||||
|
self.key_file = None
|
||||||
|
|
||||||
|
|
||||||
class DotNetDLLComponent(Component):
|
class DotNetDLLComponent(Component):
|
||||||
def __init__(self, name, dll_name, path, deps, assembly_info_dir, default_key_file):
|
def __init__(self, name, dll_name, path, deps, assembly_info_dir, default_key_file):
|
||||||
Component.__init__(self, name, path, deps)
|
Component.__init__(self, name, path, deps)
|
||||||
|
|
@ -1625,11 +1666,7 @@ class DotNetDLLComponent(Component):
|
||||||
pkg_config_template = os.path.join(self.src_dir, '{}.pc.in'.format(self.gac_pkg_name()))
|
pkg_config_template = os.path.join(self.src_dir, '{}.pc.in'.format(self.gac_pkg_name()))
|
||||||
substitutions = { 'PREFIX': PREFIX,
|
substitutions = { 'PREFIX': PREFIX,
|
||||||
'GAC_PKG_NAME': self.gac_pkg_name(),
|
'GAC_PKG_NAME': self.gac_pkg_name(),
|
||||||
'VERSION': "{}.{}.{}.{}".format(
|
'VERSION': get_version_string(4)
|
||||||
VER_MAJOR,
|
|
||||||
VER_MINOR,
|
|
||||||
VER_BUILD,
|
|
||||||
VER_REVISION)
|
|
||||||
}
|
}
|
||||||
pkg_config_output = os.path.join(BUILD_DIR,
|
pkg_config_output = os.path.join(BUILD_DIR,
|
||||||
self.build_dir,
|
self.build_dir,
|
||||||
|
|
@ -1668,25 +1705,10 @@ class DotNetDLLComponent(Component):
|
||||||
'/noconfig',
|
'/noconfig',
|
||||||
'/nostdlib+',
|
'/nostdlib+',
|
||||||
'/reference:mscorlib.dll',
|
'/reference:mscorlib.dll',
|
||||||
# Under mono this isn't neccessary as mono will search the system
|
|
||||||
# library paths for libz3.so
|
|
||||||
'/linkresource:{}.dll'.format(get_component(Z3_DLL_COMPONENT).dll_name),
|
|
||||||
]
|
]
|
||||||
)
|
)
|
||||||
|
|
||||||
# We need to give the assembly a strong name so that it
|
set_key_file(self)
|
||||||
# can be installed into the GAC with ``make install``
|
|
||||||
if not DOTNET_KEY_FILE is None:
|
|
||||||
self.key_file = DOTNET_KEY_FILE
|
|
||||||
|
|
||||||
if not self.key_file is None:
|
|
||||||
if os.path.isfile(self.key_file):
|
|
||||||
self.key_file = os.path.abspath(self.key_file)
|
|
||||||
elif os.path.isfile(os.path.join(self.src_dir, self.key_file)):
|
|
||||||
self.key_file = os.path.abspath(os.path.join(self.src_dir, self.key_file))
|
|
||||||
else:
|
|
||||||
print("Keyfile '%s' could not be found; %s.dll will be unsigned." % (self.key_file, self.dll_name))
|
|
||||||
self.key_file = None
|
|
||||||
|
|
||||||
if not self.key_file is None:
|
if not self.key_file is None:
|
||||||
print("%s.dll will be signed using key '%s'." % (self.dll_name, self.key_file))
|
print("%s.dll will be signed using key '%s'." % (self.dll_name, self.key_file))
|
||||||
|
|
@ -1814,6 +1836,204 @@ class DotNetDLLComponent(Component):
|
||||||
pkg_config_file = os.path.join('lib','pkgconfig','{}.pc'.format(self.gac_pkg_name()))
|
pkg_config_file = os.path.join('lib','pkgconfig','{}.pc'.format(self.gac_pkg_name()))
|
||||||
MakeRuleCmd.remove_installed_files(out, pkg_config_file)
|
MakeRuleCmd.remove_installed_files(out, pkg_config_file)
|
||||||
|
|
||||||
|
|
||||||
|
# build for dotnet core
|
||||||
|
class DotNetCoreDLLComponent(Component):
|
||||||
|
def __init__(self, name, dll_name, path, deps, assembly_info_dir, default_key_file):
|
||||||
|
Component.__init__(self, name, path, deps)
|
||||||
|
if dll_name is None:
|
||||||
|
dll_name = name
|
||||||
|
if assembly_info_dir is None:
|
||||||
|
assembly_info_dir = "."
|
||||||
|
self.dll_name = dll_name
|
||||||
|
self.assembly_info_dir = assembly_info_dir
|
||||||
|
self.key_file = default_key_file
|
||||||
|
|
||||||
|
|
||||||
|
def mk_makefile(self, out):
|
||||||
|
if not is_dotnet_core_enabled():
|
||||||
|
return
|
||||||
|
cs_fp_files = []
|
||||||
|
for cs_file in get_cs_files(self.src_dir):
|
||||||
|
cs_fp_files.append(os.path.join(self.to_src_dir, cs_file))
|
||||||
|
if self.assembly_info_dir != '.':
|
||||||
|
for cs_file in get_cs_files(os.path.join(self.src_dir, self.assembly_info_dir)):
|
||||||
|
cs_fp_files.append(os.path.join(self.to_src_dir, self.assembly_info_dir, cs_file))
|
||||||
|
dllfile = '%s.dll' % self.dll_name
|
||||||
|
out.write('%s: %s$(SO_EXT)' % (dllfile, get_component(Z3_DLL_COMPONENT).dll_name))
|
||||||
|
for cs_file in cs_fp_files:
|
||||||
|
out.write(' ')
|
||||||
|
out.write(cs_file)
|
||||||
|
out.write('\n')
|
||||||
|
|
||||||
|
set_key_file(self)
|
||||||
|
key = ""
|
||||||
|
if not self.key_file is None:
|
||||||
|
key = "<AssemblyOriginatorKeyFile>%s</AssemblyOriginatorKeyFile>" % self.key_file
|
||||||
|
key += "\n<SignAssembly>true</SignAssembly>"
|
||||||
|
|
||||||
|
if VS_X64:
|
||||||
|
platform = 'x64'
|
||||||
|
elif VS_ARM:
|
||||||
|
platform = 'ARM'
|
||||||
|
else:
|
||||||
|
platform = 'x86'
|
||||||
|
|
||||||
|
version = get_version_string(3)
|
||||||
|
|
||||||
|
core_csproj_str = """<Project Sdk="Microsoft.NET.Sdk">
|
||||||
|
|
||||||
|
<PropertyGroup>
|
||||||
|
<TargetFramework>netstandard1.4</TargetFramework>
|
||||||
|
<PlatformTarget>%s</PlatformTarget>
|
||||||
|
<DefineConstants>$(DefineConstants);DOTNET_CORE</DefineConstants>
|
||||||
|
<DebugType>portable</DebugType>
|
||||||
|
<AssemblyName>Microsoft.Z3</AssemblyName>
|
||||||
|
<OutputType>Library</OutputType>
|
||||||
|
<PackageId>Microsoft.Z3</PackageId>
|
||||||
|
<RuntimeFrameworkVersion>1.0.4</RuntimeFrameworkVersion>
|
||||||
|
<Version>%s</Version>
|
||||||
|
<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
|
||||||
|
<Authors>Microsoft</Authors>
|
||||||
|
<Company>Microsoft</Company>
|
||||||
|
<Description>Z3 is a satisfiability modulo theories solver from Microsoft Research.</Description>
|
||||||
|
<Copyright>Copyright Microsoft Corporation. All rights reserved.</Copyright>
|
||||||
|
<PackageTags>smt constraint solver theorem prover</PackageTags>
|
||||||
|
%s
|
||||||
|
</PropertyGroup>
|
||||||
|
|
||||||
|
<ItemGroup>
|
||||||
|
<Compile Include="..\%s\*.cs" Exclude="bin\**;obj\**;**\*.xproj;packages\**" />
|
||||||
|
</ItemGroup>
|
||||||
|
|
||||||
|
</Project>""" % (platform, version, key, self.to_src_dir)
|
||||||
|
|
||||||
|
mk_dir(os.path.join(BUILD_DIR, 'dotnet'))
|
||||||
|
csproj = os.path.join('dotnet', 'z3.csproj')
|
||||||
|
with open(os.path.join(BUILD_DIR, csproj), 'w') as ous:
|
||||||
|
ous.write(core_csproj_str)
|
||||||
|
|
||||||
|
dotnetCmdLine = [DOTNET, "build", csproj]
|
||||||
|
|
||||||
|
dotnetCmdLine.extend(['-c'])
|
||||||
|
if DEBUG_MODE:
|
||||||
|
dotnetCmdLine.extend(['Debug'])
|
||||||
|
else:
|
||||||
|
dotnetCmdLine.extend(['Release'])
|
||||||
|
|
||||||
|
path = os.path.join(os.path.abspath(BUILD_DIR), ".")
|
||||||
|
dotnetCmdLine.extend(['-o', path])
|
||||||
|
|
||||||
|
MakeRuleCmd.write_cmd(out, ' '.join(dotnetCmdLine))
|
||||||
|
self.sign_esrp(out)
|
||||||
|
out.write('\n')
|
||||||
|
out.write('%s: %s\n\n' % (self.name, dllfile))
|
||||||
|
|
||||||
|
def sign_esrp(self, out):
|
||||||
|
global ESRP_SIGNx
|
||||||
|
print("esrp-sign", ESRP_SIGN)
|
||||||
|
if not ESRP_SIGN:
|
||||||
|
return
|
||||||
|
|
||||||
|
import uuid
|
||||||
|
guid = str(uuid.uuid4())
|
||||||
|
path = os.path.abspath(BUILD_DIR).replace("\\","\\\\")
|
||||||
|
assemblySignStr = """
|
||||||
|
{
|
||||||
|
"Version": "1.0.0",
|
||||||
|
"SignBatches"
|
||||||
|
:
|
||||||
|
[
|
||||||
|
{
|
||||||
|
"SourceLocationType": "UNC",
|
||||||
|
"SourceRootDirectory": "%s",
|
||||||
|
"DestinationLocationType": "UNC",
|
||||||
|
"DestinationRootDirectory": "c:\\\\ESRP\\\\output",
|
||||||
|
"SignRequestFiles": [
|
||||||
|
{
|
||||||
|
"CustomerCorrelationId": "%s",
|
||||||
|
"SourceLocation": "libz3.dll",
|
||||||
|
"DestinationLocation": "libz3.dll"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"CustomerCorrelationId": "%s",
|
||||||
|
"SourceLocation": "Microsoft.Z3.dll",
|
||||||
|
"DestinationLocation": "Microsoft.Z3.dll"
|
||||||
|
}
|
||||||
|
],
|
||||||
|
"SigningInfo": {
|
||||||
|
"Operations": [
|
||||||
|
{
|
||||||
|
"KeyCode" : "CP-230012",
|
||||||
|
"OperationCode" : "SigntoolSign",
|
||||||
|
"Parameters" : {
|
||||||
|
"OpusName": "Microsoft",
|
||||||
|
"OpusInfo": "http://www.microsoft.com",
|
||||||
|
"FileDigest": "/fd \\"SHA256\\"",
|
||||||
|
"PageHash": "/NPH",
|
||||||
|
"TimeStamp": "/tr \\"http://rfc3161.gtm.corp.microsoft.com/TSS/HttpTspServer\\" /td sha256"
|
||||||
|
},
|
||||||
|
"ToolName" : "sign",
|
||||||
|
"ToolVersion" : "1.0"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"KeyCode" : "CP-230012",
|
||||||
|
"OperationCode" : "SigntoolVerify",
|
||||||
|
"Parameters" : {},
|
||||||
|
"ToolName" : "sign",
|
||||||
|
"ToolVersion" : "1.0"
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
} """ % (path, guid, guid)
|
||||||
|
assemblySign = os.path.join(os.path.abspath(BUILD_DIR), 'dotnet', 'assembly-sign-input.json')
|
||||||
|
with open(assemblySign, 'w') as ous:
|
||||||
|
ous.write(assemblySignStr)
|
||||||
|
outputFile = os.path.join(os.path.abspath(BUILD_DIR), 'dotnet', "esrp-out.json")
|
||||||
|
esrpCmdLine = ["esrpclient.exe", "sign", "-a", "C:\\esrp\\config\\authorization.json", "-p", "C:\\esrp\\config\\policy.json", "-i", assemblySign, "-o", outputFile]
|
||||||
|
MakeRuleCmd.write_cmd(out, ' '.join(esrpCmdLine))
|
||||||
|
MakeRuleCmd.write_cmd(out, "move /Y C:\\esrp\\output\\libz3.dll .")
|
||||||
|
MakeRuleCmd.write_cmd(out, "move /Y C:\\esrp\\output\\Microsoft.Z3.dll .")
|
||||||
|
|
||||||
|
|
||||||
|
def main_component(self):
|
||||||
|
return is_dotnet_core_enabled()
|
||||||
|
|
||||||
|
def has_assembly_info(self):
|
||||||
|
# TBD: is this required for dotnet core given that version numbers are in z3.csproj file?
|
||||||
|
return True
|
||||||
|
|
||||||
|
|
||||||
|
def mk_win_dist(self, build_path, dist_path):
|
||||||
|
if is_dotnet_core_enabled():
|
||||||
|
mk_dir(os.path.join(dist_path, INSTALL_BIN_DIR))
|
||||||
|
shutil.copy('%s.dll' % os.path.join(build_path, self.dll_name),
|
||||||
|
'%s.dll' % os.path.join(dist_path, INSTALL_BIN_DIR, self.dll_name))
|
||||||
|
shutil.copy('%s.deps.json' % os.path.join(build_path, self.dll_name),
|
||||||
|
'%s.deps.json' % os.path.join(dist_path, INSTALL_BIN_DIR, self.dll_name))
|
||||||
|
if DEBUG_MODE:
|
||||||
|
shutil.copy('%s.pdb' % os.path.join(build_path, self.dll_name),
|
||||||
|
'%s.pdb' % os.path.join(dist_path, INSTALL_BIN_DIR, self.dll_name))
|
||||||
|
|
||||||
|
def mk_unix_dist(self, build_path, dist_path):
|
||||||
|
if is_dotnet_core_enabled():
|
||||||
|
mk_dir(os.path.join(dist_path, INSTALL_BIN_DIR))
|
||||||
|
shutil.copy('%s.dll' % os.path.join(build_path, self.dll_name),
|
||||||
|
'%s.dll' % os.path.join(dist_path, INSTALL_BIN_DIR, self.dll_name))
|
||||||
|
shutil.copy('%s.deps.json' % os.path.join(build_path, self.dll_name),
|
||||||
|
'%s.deps.json' % os.path.join(dist_path, INSTALL_BIN_DIR, self.dll_name))
|
||||||
|
|
||||||
|
def mk_install_deps(self, out):
|
||||||
|
pass
|
||||||
|
|
||||||
|
def mk_install(self, out):
|
||||||
|
pass
|
||||||
|
|
||||||
|
def mk_uninstall(self, out):
|
||||||
|
pass
|
||||||
|
|
||||||
class JavaDLLComponent(Component):
|
class JavaDLLComponent(Component):
|
||||||
def __init__(self, name, dll_name, package_name, manifest_file, path, deps):
|
def __init__(self, name, dll_name, package_name, manifest_file, path, deps):
|
||||||
Component.__init__(self, name, path, deps)
|
Component.__init__(self, name, path, deps)
|
||||||
|
|
@ -2204,7 +2424,7 @@ class DotNetExampleComponent(ExampleComponent):
|
||||||
ExampleComponent.__init__(self, name, path)
|
ExampleComponent.__init__(self, name, path)
|
||||||
|
|
||||||
def is_example(self):
|
def is_example(self):
|
||||||
return is_dotnet_enabled()
|
return is_dotnet_enabled() or is_dotnet_core_enabled()
|
||||||
|
|
||||||
def mk_makefile(self, out):
|
def mk_makefile(self, out):
|
||||||
if is_dotnet_enabled():
|
if is_dotnet_enabled():
|
||||||
|
|
@ -2232,6 +2452,48 @@ class DotNetExampleComponent(ExampleComponent):
|
||||||
out.write(os.path.join(relative_path, csfile))
|
out.write(os.path.join(relative_path, csfile))
|
||||||
out.write('\n')
|
out.write('\n')
|
||||||
out.write('_ex_%s: %s\n\n' % (self.name, exefile))
|
out.write('_ex_%s: %s\n\n' % (self.name, exefile))
|
||||||
|
if is_dotnet_core_enabled():
|
||||||
|
proj_name = 'dotnet_example.csproj'
|
||||||
|
out.write('_ex_%s:' % self.name)
|
||||||
|
for csfile in get_cs_files(self.ex_dir):
|
||||||
|
out.write(' ')
|
||||||
|
out.write(os.path.join(self.to_ex_dir, csfile))
|
||||||
|
|
||||||
|
mk_dir(os.path.join(BUILD_DIR, 'dotnet_example'))
|
||||||
|
csproj = os.path.join('dotnet_example', proj_name)
|
||||||
|
if VS_X64:
|
||||||
|
platform = 'x64'
|
||||||
|
elif VS_ARM:
|
||||||
|
platform = 'ARM'
|
||||||
|
else:
|
||||||
|
platform = 'x86'
|
||||||
|
|
||||||
|
dotnet_proj_str = """<Project Sdk="Microsoft.NET.Sdk">
|
||||||
|
<PropertyGroup>
|
||||||
|
<OutputType>Exe</OutputType>
|
||||||
|
<TargetFramework>netcoreapp2.0</TargetFramework>
|
||||||
|
<PlatformTarget>%s</PlatformTarget>
|
||||||
|
</PropertyGroup>
|
||||||
|
<ItemGroup>
|
||||||
|
<Compile Include="..\%s/*.cs" />
|
||||||
|
<Reference Include="Microsoft.Z3">
|
||||||
|
<HintPath>..\Microsoft.Z3.dll</HintPath>
|
||||||
|
</Reference>
|
||||||
|
</ItemGroup>
|
||||||
|
</Project>""" % (platform, self.to_ex_dir)
|
||||||
|
|
||||||
|
with open(os.path.join(BUILD_DIR, csproj), 'w') as ous:
|
||||||
|
ous.write(dotnet_proj_str)
|
||||||
|
|
||||||
|
out.write('\n')
|
||||||
|
dotnetCmdLine = [DOTNET, "build", csproj]
|
||||||
|
dotnetCmdLine.extend(['-c'])
|
||||||
|
if DEBUG_MODE:
|
||||||
|
dotnetCmdLine.extend(['Debug'])
|
||||||
|
else:
|
||||||
|
dotnetCmdLine.extend(['Release'])
|
||||||
|
MakeRuleCmd.write_cmd(out, ' '.join(dotnetCmdLine))
|
||||||
|
out.write('\n')
|
||||||
|
|
||||||
class JavaExampleComponent(ExampleComponent):
|
class JavaExampleComponent(ExampleComponent):
|
||||||
def __init__(self, name, path):
|
def __init__(self, name, path):
|
||||||
|
|
@ -2350,6 +2612,10 @@ def add_dot_net_dll(name, deps=[], path=None, dll_name=None, assembly_info_dir=N
|
||||||
c = DotNetDLLComponent(name, dll_name, path, deps, assembly_info_dir, default_key_file)
|
c = DotNetDLLComponent(name, dll_name, path, deps, assembly_info_dir, default_key_file)
|
||||||
reg_component(name, c)
|
reg_component(name, c)
|
||||||
|
|
||||||
|
def add_dot_net_core_dll(name, deps=[], path=None, dll_name=None, assembly_info_dir=None, default_key_file=None):
|
||||||
|
c = DotNetCoreDLLComponent(name, dll_name, path, deps, assembly_info_dir, default_key_file)
|
||||||
|
reg_component(name, c)
|
||||||
|
|
||||||
def add_java_dll(name, deps=[], path=None, dll_name=None, package_name=None, manifest_file=None):
|
def add_java_dll(name, deps=[], path=None, dll_name=None, package_name=None, manifest_file=None):
|
||||||
c = JavaDLLComponent(name, dll_name, package_name, manifest_file, path, deps)
|
c = JavaDLLComponent(name, dll_name, package_name, manifest_file, path, deps)
|
||||||
reg_component(name, c)
|
reg_component(name, c)
|
||||||
|
|
@ -2442,7 +2708,7 @@ def mk_config():
|
||||||
'SLINK_FLAGS=/nologo /LDd\n' % static_opt)
|
'SLINK_FLAGS=/nologo /LDd\n' % static_opt)
|
||||||
if VS_X64:
|
if VS_X64:
|
||||||
config.write(
|
config.write(
|
||||||
'CXXFLAGS=/c /Zi /nologo /W3 /WX- /Od /Oy- /D WIN32 /D _AMD64_ /D _DEBUG /D Z3DEBUG /D _CONSOLE /D _TRACE /D _WINDOWS /Gm- /EHsc /RTC1 /GS /fp:precise /Zc:wchar_t /Zc:forScope /Gd /analyze- %s %s\n' % (extra_opt, static_opt))
|
'CXXFLAGS=/c /Zi /nologo /W3 /WX- /Od /Oy- /D WIN32 /D _DEBUG /D Z3DEBUG /D _CONSOLE /D _TRACE /D _WINDOWS /Gm- /EHsc /RTC1 /GS /fp:precise /Zc:wchar_t /Zc:forScope /Gd /analyze- %s %s\n' % (extra_opt, static_opt))
|
||||||
config.write(
|
config.write(
|
||||||
'LINK_EXTRA_FLAGS=/link /DEBUG /MACHINE:X64 /SUBSYSTEM:CONSOLE /INCREMENTAL:NO /STACK:8388608 /OPT:REF /OPT:ICF /TLBID:1 /DYNAMICBASE /NXCOMPAT %s\n'
|
'LINK_EXTRA_FLAGS=/link /DEBUG /MACHINE:X64 /SUBSYSTEM:CONSOLE /INCREMENTAL:NO /STACK:8388608 /OPT:REF /OPT:ICF /TLBID:1 /DYNAMICBASE /NXCOMPAT %s\n'
|
||||||
'SLINK_EXTRA_FLAGS=/link /DEBUG /MACHINE:X64 /SUBSYSTEM:WINDOWS /INCREMENTAL:NO /STACK:8388608 /OPT:REF /OPT:ICF /TLBID:1 %s %s\n' % (link_extra_opt, maybe_disable_dynamic_base, link_extra_opt))
|
'SLINK_EXTRA_FLAGS=/link /DEBUG /MACHINE:X64 /SUBSYSTEM:WINDOWS /INCREMENTAL:NO /STACK:8388608 /OPT:REF /OPT:ICF /TLBID:1 %s %s\n' % (link_extra_opt, maybe_disable_dynamic_base, link_extra_opt))
|
||||||
|
|
@ -2467,7 +2733,7 @@ def mk_config():
|
||||||
extra_opt = '%s /D _TRACE ' % extra_opt
|
extra_opt = '%s /D _TRACE ' % extra_opt
|
||||||
if VS_X64:
|
if VS_X64:
|
||||||
config.write(
|
config.write(
|
||||||
'CXXFLAGS=/c%s /Zi /nologo /W3 /WX- /O2 /D _EXTERNAL_RELEASE /D WIN32 /D NDEBUG /D _LIB /D _WINDOWS /D _AMD64_ /D _UNICODE /D UNICODE /Gm- /EHsc /GS /fp:precise /Zc:wchar_t /Zc:forScope /Gd /TP %s %s\n' % (GL, extra_opt, static_opt))
|
'CXXFLAGS=/c%s /Zi /nologo /W3 /WX- /O2 /D _EXTERNAL_RELEASE /D WIN32 /D NDEBUG /D _LIB /D _WINDOWS /D _UNICODE /D UNICODE /Gm- /EHsc /GS /fp:precise /Zc:wchar_t /Zc:forScope /Gd /TP %s %s\n' % (GL, extra_opt, static_opt))
|
||||||
config.write(
|
config.write(
|
||||||
'LINK_EXTRA_FLAGS=/link%s /MACHINE:X64 /SUBSYSTEM:CONSOLE /INCREMENTAL:NO /STACK:8388608 %s\n'
|
'LINK_EXTRA_FLAGS=/link%s /MACHINE:X64 /SUBSYSTEM:CONSOLE /INCREMENTAL:NO /STACK:8388608 %s\n'
|
||||||
'SLINK_EXTRA_FLAGS=/link%s /MACHINE:X64 /SUBSYSTEM:WINDOWS /INCREMENTAL:NO /STACK:8388608 %s\n' % (LTCG, link_extra_opt, LTCG, link_extra_opt))
|
'SLINK_EXTRA_FLAGS=/link%s /MACHINE:X64 /SUBSYSTEM:WINDOWS /INCREMENTAL:NO /STACK:8388608 %s\n' % (LTCG, link_extra_opt, LTCG, link_extra_opt))
|
||||||
|
|
@ -2589,7 +2855,6 @@ def mk_config():
|
||||||
if is64():
|
if is64():
|
||||||
if not sysname.startswith('CYGWIN') and not sysname.startswith('MSYS') and not sysname.startswith('MINGW'):
|
if not sysname.startswith('CYGWIN') and not sysname.startswith('MSYS') and not sysname.startswith('MINGW'):
|
||||||
CXXFLAGS = '%s -fPIC' % CXXFLAGS
|
CXXFLAGS = '%s -fPIC' % CXXFLAGS
|
||||||
CPPFLAGS = '%s -D_AMD64_' % CPPFLAGS
|
|
||||||
if sysname == 'Linux':
|
if sysname == 'Linux':
|
||||||
CPPFLAGS = '%s -D_USE_THREAD_LOCAL' % CPPFLAGS
|
CPPFLAGS = '%s -D_USE_THREAD_LOCAL' % CPPFLAGS
|
||||||
elif not LINUX_X64:
|
elif not LINUX_X64:
|
||||||
|
|
@ -2657,6 +2922,8 @@ def mk_config():
|
||||||
if is_dotnet_enabled():
|
if is_dotnet_enabled():
|
||||||
print('C# Compiler: %s' % CSC)
|
print('C# Compiler: %s' % CSC)
|
||||||
print('GAC utility: %s' % GACUTIL)
|
print('GAC utility: %s' % GACUTIL)
|
||||||
|
if is_dotnet_core_enabled():
|
||||||
|
print('C# Compiler: %s' % DOTNET)
|
||||||
|
|
||||||
config.close()
|
config.close()
|
||||||
|
|
||||||
|
|
@ -2805,8 +3072,8 @@ def get_full_version_string(major, minor, build, revision):
|
||||||
# Update files with the version number
|
# Update files with the version number
|
||||||
def mk_version_dot_h(major, minor, build, revision):
|
def mk_version_dot_h(major, minor, build, revision):
|
||||||
c = get_component(UTIL_COMPONENT)
|
c = get_component(UTIL_COMPONENT)
|
||||||
version_template = os.path.join(c.src_dir, 'version.h.in')
|
version_template = os.path.join(c.src_dir, 'z3_version.h.in')
|
||||||
version_header_output = os.path.join(c.src_dir, 'version.h')
|
version_header_output = os.path.join(c.src_dir, 'z3_version.h')
|
||||||
# Note the substitution names are what is used by the CMake
|
# Note the substitution names are what is used by the CMake
|
||||||
# builds system. If you change these you should change them
|
# builds system. If you change these you should change them
|
||||||
# in the CMake build too
|
# in the CMake build too
|
||||||
|
|
@ -2982,6 +3249,9 @@ def mk_bindings(api_files):
|
||||||
dotnet_output_dir = None
|
dotnet_output_dir = None
|
||||||
if is_dotnet_enabled():
|
if is_dotnet_enabled():
|
||||||
dotnet_output_dir = get_component('dotnet').src_dir
|
dotnet_output_dir = get_component('dotnet').src_dir
|
||||||
|
elif is_dotnet_core_enabled():
|
||||||
|
dotnet_output_dir = os.path.join(BUILD_DIR, 'dotnet')
|
||||||
|
mk_dir(dotnet_output_dir)
|
||||||
java_output_dir = None
|
java_output_dir = None
|
||||||
java_package_name = None
|
java_package_name = None
|
||||||
if is_java_enabled():
|
if is_java_enabled():
|
||||||
|
|
@ -3010,7 +3280,10 @@ def mk_bindings(api_files):
|
||||||
mk_z3consts_ml(api_files)
|
mk_z3consts_ml(api_files)
|
||||||
if is_dotnet_enabled():
|
if is_dotnet_enabled():
|
||||||
check_dotnet()
|
check_dotnet()
|
||||||
mk_z3consts_dotnet(api_files)
|
mk_z3consts_dotnet(api_files, dotnet_output_dir)
|
||||||
|
if is_dotnet_core_enabled():
|
||||||
|
check_dotnet_core()
|
||||||
|
mk_z3consts_dotnet(api_files, dotnet_output_dir)
|
||||||
|
|
||||||
# Extract enumeration types from API files, and add python definitions.
|
# Extract enumeration types from API files, and add python definitions.
|
||||||
def mk_z3consts_py(api_files):
|
def mk_z3consts_py(api_files):
|
||||||
|
|
@ -3027,14 +3300,16 @@ def mk_z3consts_py(api_files):
|
||||||
print("Generated '{}".format(generated_file))
|
print("Generated '{}".format(generated_file))
|
||||||
|
|
||||||
# Extract enumeration types from z3_api.h, and add .Net definitions
|
# Extract enumeration types from z3_api.h, and add .Net definitions
|
||||||
def mk_z3consts_dotnet(api_files):
|
def mk_z3consts_dotnet(api_files, output_dir):
|
||||||
dotnet = get_component(DOTNET_COMPONENT)
|
dotnet = get_component(DOTNET_COMPONENT)
|
||||||
|
if not dotnet:
|
||||||
|
dotnet = get_component(DOTNET_CORE_COMPONENT)
|
||||||
full_path_api_files = []
|
full_path_api_files = []
|
||||||
for api_file in api_files:
|
for api_file in api_files:
|
||||||
api_file_c = dotnet.find_file(api_file, dotnet.name)
|
api_file_c = dotnet.find_file(api_file, dotnet.name)
|
||||||
api_file = os.path.join(api_file_c.src_dir, api_file)
|
api_file = os.path.join(api_file_c.src_dir, api_file)
|
||||||
full_path_api_files.append(api_file)
|
full_path_api_files.append(api_file)
|
||||||
generated_file = mk_genfile_common.mk_z3consts_dotnet_internal(full_path_api_files, dotnet.src_dir)
|
generated_file = mk_genfile_common.mk_z3consts_dotnet_internal(full_path_api_files, output_dir)
|
||||||
if VERBOSE:
|
if VERBOSE:
|
||||||
print("Generated '{}".format(generated_file))
|
print("Generated '{}".format(generated_file))
|
||||||
|
|
||||||
|
|
@ -3279,7 +3554,7 @@ class MakeRuleCmd(object):
|
||||||
needed commands used in Makefile rules
|
needed commands used in Makefile rules
|
||||||
Note that several of the method are meant for use during ``make
|
Note that several of the method are meant for use during ``make
|
||||||
install`` and ``make uninstall``. These methods correctly use
|
install`` and ``make uninstall``. These methods correctly use
|
||||||
``$(PREFIX)`` and ``$(DESTDIR)`` and therefore are preferrable
|
``$(PREFIX)`` and ``$(DESTDIR)`` and therefore are preferable
|
||||||
to writing commands manually which can be error prone.
|
to writing commands manually which can be error prone.
|
||||||
"""
|
"""
|
||||||
@classmethod
|
@classmethod
|
||||||
|
|
|
||||||
|
|
@ -25,6 +25,8 @@ VERBOSE=True
|
||||||
DIST_DIR='dist'
|
DIST_DIR='dist'
|
||||||
FORCE_MK=False
|
FORCE_MK=False
|
||||||
DOTNET_ENABLED=True
|
DOTNET_ENABLED=True
|
||||||
|
DOTNET_CORE_ENABLED=False
|
||||||
|
ESRP_SIGN=False
|
||||||
DOTNET_KEY_FILE=None
|
DOTNET_KEY_FILE=None
|
||||||
JAVA_ENABLED=True
|
JAVA_ENABLED=True
|
||||||
GIT_HASH=False
|
GIT_HASH=False
|
||||||
|
|
@ -62,7 +64,9 @@ def display_help():
|
||||||
print(" -b <sudir>, --build=<subdir> subdirectory where x86 and x64 Z3 versions will be built (default: build-dist).")
|
print(" -b <sudir>, --build=<subdir> subdirectory where x86 and x64 Z3 versions will be built (default: build-dist).")
|
||||||
print(" -f, --force force script to regenerate Makefiles.")
|
print(" -f, --force force script to regenerate Makefiles.")
|
||||||
print(" --nodotnet do not include .NET bindings in the binary distribution files.")
|
print(" --nodotnet do not include .NET bindings in the binary distribution files.")
|
||||||
|
print(" --dotnetcore build for dotnet core.")
|
||||||
print(" --dotnet-key=<file> sign the .NET assembly with the private key in <file>.")
|
print(" --dotnet-key=<file> sign the .NET assembly with the private key in <file>.")
|
||||||
|
print(" --esrp sign with esrp.")
|
||||||
print(" --nojava do not include Java bindings in the binary distribution files.")
|
print(" --nojava do not include Java bindings in the binary distribution files.")
|
||||||
print(" --nopython do not include Python bindings in the binary distribution files.")
|
print(" --nopython do not include Python bindings in the binary distribution files.")
|
||||||
print(" --githash include git hash in the Zip file.")
|
print(" --githash include git hash in the Zip file.")
|
||||||
|
|
@ -72,7 +76,7 @@ def display_help():
|
||||||
|
|
||||||
# Parse configuration option for mk_make script
|
# Parse configuration option for mk_make script
|
||||||
def parse_options():
|
def parse_options():
|
||||||
global FORCE_MK, JAVA_ENABLED, GIT_HASH, DOTNET_ENABLED, DOTNET_KEY_FILE, PYTHON_ENABLED, X86ONLY, X64ONLY
|
global FORCE_MK, JAVA_ENABLED, GIT_HASH, DOTNET_ENABLED, DOTNET_CORE_ENABLED, DOTNET_KEY_FILE, PYTHON_ENABLED, X86ONLY, X64ONLY, ESRP_SIGN
|
||||||
path = BUILD_DIR
|
path = BUILD_DIR
|
||||||
options, remainder = getopt.gnu_getopt(sys.argv[1:], 'b:hsf', ['build=',
|
options, remainder = getopt.gnu_getopt(sys.argv[1:], 'b:hsf', ['build=',
|
||||||
'help',
|
'help',
|
||||||
|
|
@ -80,7 +84,9 @@ def parse_options():
|
||||||
'force',
|
'force',
|
||||||
'nojava',
|
'nojava',
|
||||||
'nodotnet',
|
'nodotnet',
|
||||||
|
'dotnetcore',
|
||||||
'dotnet-key=',
|
'dotnet-key=',
|
||||||
|
'esrp',
|
||||||
'githash',
|
'githash',
|
||||||
'nopython',
|
'nopython',
|
||||||
'x86-only',
|
'x86-only',
|
||||||
|
|
@ -99,10 +105,15 @@ def parse_options():
|
||||||
FORCE_MK = True
|
FORCE_MK = True
|
||||||
elif opt == '--nodotnet':
|
elif opt == '--nodotnet':
|
||||||
DOTNET_ENABLED = False
|
DOTNET_ENABLED = False
|
||||||
|
elif opt == '--dotnetcore':
|
||||||
|
DOTNET_CORE_ENABLED = True
|
||||||
|
DOTNET_ENABLED = False
|
||||||
elif opt == '--nopython':
|
elif opt == '--nopython':
|
||||||
PYTHON_ENABLED = False
|
PYTHON_ENABLED = False
|
||||||
elif opt == '--dotnet-key':
|
elif opt == '--dotnet-key':
|
||||||
DOTNET_KEY_FILE = arg
|
DOTNET_KEY_FILE = arg
|
||||||
|
elif opt == '--esrp':
|
||||||
|
ESRP_SIGN = True
|
||||||
elif opt == '--nojava':
|
elif opt == '--nojava':
|
||||||
JAVA_ENABLED = False
|
JAVA_ENABLED = False
|
||||||
elif opt == '--githash':
|
elif opt == '--githash':
|
||||||
|
|
@ -124,7 +135,11 @@ def mk_build_dir(path, x64):
|
||||||
if not check_build_dir(path) or FORCE_MK:
|
if not check_build_dir(path) or FORCE_MK:
|
||||||
parallel = '--parallel=' + MAKEJOBS
|
parallel = '--parallel=' + MAKEJOBS
|
||||||
opts = ["python", os.path.join('scripts', 'mk_make.py'), parallel, "-b", path]
|
opts = ["python", os.path.join('scripts', 'mk_make.py'), parallel, "-b", path]
|
||||||
if DOTNET_ENABLED:
|
if DOTNET_CORE_ENABLED:
|
||||||
|
opts.append('--dotnetcore')
|
||||||
|
if not DOTNET_KEY_FILE is None:
|
||||||
|
opts.append('--dotnet-key=' + DOTNET_KEY_FILE)
|
||||||
|
elif DOTNET_ENABLED:
|
||||||
opts.append('--dotnet')
|
opts.append('--dotnet')
|
||||||
if not DOTNET_KEY_FILE is None:
|
if not DOTNET_KEY_FILE is None:
|
||||||
opts.append('--dotnet-key=' + DOTNET_KEY_FILE)
|
opts.append('--dotnet-key=' + DOTNET_KEY_FILE)
|
||||||
|
|
@ -132,6 +147,8 @@ def mk_build_dir(path, x64):
|
||||||
opts.append('--java')
|
opts.append('--java')
|
||||||
if x64:
|
if x64:
|
||||||
opts.append('-x')
|
opts.append('-x')
|
||||||
|
if ESRP_SIGN:
|
||||||
|
opts.append('--esrp')
|
||||||
if GIT_HASH:
|
if GIT_HASH:
|
||||||
opts.append('--githash=%s' % mk_util.git_hash())
|
opts.append('--githash=%s' % mk_util.git_hash())
|
||||||
opts.append('--git-describe')
|
opts.append('--git-describe')
|
||||||
|
|
@ -200,6 +217,7 @@ def get_z3_name(x64):
|
||||||
return 'z3-%s.%s.%s-%s-win' % (major, minor, build, platform)
|
return 'z3-%s.%s.%s-%s-win' % (major, minor, build, platform)
|
||||||
|
|
||||||
def mk_dist_dir(x64):
|
def mk_dist_dir(x64):
|
||||||
|
global ESRP_SIGN
|
||||||
if x64:
|
if x64:
|
||||||
platform = "x64"
|
platform = "x64"
|
||||||
build_path = BUILD_X64_DIR
|
build_path = BUILD_X64_DIR
|
||||||
|
|
@ -208,7 +226,11 @@ def mk_dist_dir(x64):
|
||||||
build_path = BUILD_X86_DIR
|
build_path = BUILD_X86_DIR
|
||||||
dist_path = os.path.join(DIST_DIR, get_z3_name(x64))
|
dist_path = os.path.join(DIST_DIR, get_z3_name(x64))
|
||||||
mk_dir(dist_path)
|
mk_dir(dist_path)
|
||||||
mk_util.DOTNET_ENABLED = DOTNET_ENABLED
|
mk_util.ESRP_SIGN = ESRP_SIGN
|
||||||
|
if DOTNET_CORE_ENABLED:
|
||||||
|
mk_util.DOTNET_CORE_ENABLED = True
|
||||||
|
else:
|
||||||
|
mk_util.DOTNET_ENABLED = DOTNET_ENABLED
|
||||||
mk_util.DOTNET_KEY_FILE = DOTNET_KEY_FILE
|
mk_util.DOTNET_KEY_FILE = DOTNET_KEY_FILE
|
||||||
mk_util.JAVA_ENABLED = JAVA_ENABLED
|
mk_util.JAVA_ENABLED = JAVA_ENABLED
|
||||||
mk_util.PYTHON_ENABLED = PYTHON_ENABLED
|
mk_util.PYTHON_ENABLED = PYTHON_ENABLED
|
||||||
|
|
@ -257,19 +279,30 @@ def cp_vs_runtime(x64):
|
||||||
else:
|
else:
|
||||||
platform = "x86"
|
platform = "x86"
|
||||||
vcdir = os.environ['VCINSTALLDIR']
|
vcdir = os.environ['VCINSTALLDIR']
|
||||||
path = '%sredist\\%s' % (vcdir, platform)
|
path = '%sredist' % vcdir
|
||||||
VS_RUNTIME_FILES = []
|
vs_runtime_files = []
|
||||||
|
print("Walking %s" % path)
|
||||||
|
# Everything changes with every release of VS
|
||||||
|
# Prior versions of VS had DLLs under "redist\x64"
|
||||||
|
# There are now several variants of redistributables
|
||||||
|
# The naming convention defies my understanding so
|
||||||
|
# we use a "check_root" filter to find some hopefully suitable
|
||||||
|
# redistributable.
|
||||||
|
def check_root(root):
|
||||||
|
return platform in root and ("CRT" in root or "MP" in root) and "onecore" not in root and "debug" not in root
|
||||||
for root, dirs, files in os.walk(path):
|
for root, dirs, files in os.walk(path):
|
||||||
for filename in files:
|
for filename in files:
|
||||||
if fnmatch(filename, '*.dll'):
|
if fnmatch(filename, '*.dll') and check_root(root):
|
||||||
|
print("Checking %s %s" % (root, filename))
|
||||||
for pat in VS_RUNTIME_PATS:
|
for pat in VS_RUNTIME_PATS:
|
||||||
if pat.match(filename):
|
if pat.match(filename):
|
||||||
fname = os.path.join(root, filename)
|
fname = os.path.join(root, filename)
|
||||||
if not os.path.isdir(fname):
|
if not os.path.isdir(fname):
|
||||||
VS_RUNTIME_FILES.append(fname)
|
vs_runtime_files.append(fname)
|
||||||
|
if not vs_runtime_files:
|
||||||
|
raise MKException("Did not find any runtime files to include")
|
||||||
bin_dist_path = os.path.join(DIST_DIR, get_dist_path(x64), 'bin')
|
bin_dist_path = os.path.join(DIST_DIR, get_dist_path(x64), 'bin')
|
||||||
for f in VS_RUNTIME_FILES:
|
for f in vs_runtime_files:
|
||||||
shutil.copy(f, bin_dist_path)
|
shutil.copy(f, bin_dist_path)
|
||||||
if is_verbose():
|
if is_verbose():
|
||||||
print("Copied '%s' to '%s'" % (f, bin_dist_path))
|
print("Copied '%s' to '%s'" % (f, bin_dist_path))
|
||||||
|
|
|
||||||
|
|
@ -61,7 +61,7 @@ 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_t', UINT64 : 'uint64_t', 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 : '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'
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -584,7 +584,7 @@ def mk_java(java_dir, package_name):
|
||||||
java_wrapper.write('extern "C" {\n')
|
java_wrapper.write('extern "C" {\n')
|
||||||
java_wrapper.write('#endif\n\n')
|
java_wrapper.write('#endif\n\n')
|
||||||
java_wrapper.write('#ifdef __GNUC__\n#if __GNUC__ >= 4\n#define DLL_VIS __attribute__ ((visibility ("default")))\n#else\n#define DLL_VIS\n#endif\n#else\n#define DLL_VIS\n#endif\n\n')
|
java_wrapper.write('#ifdef __GNUC__\n#if __GNUC__ >= 4\n#define DLL_VIS __attribute__ ((visibility ("default")))\n#else\n#define DLL_VIS\n#endif\n#else\n#define DLL_VIS\n#endif\n\n')
|
||||||
java_wrapper.write('#if defined(_M_X64) || defined(_AMD64_)\n\n')
|
java_wrapper.write('#if defined(__LP64__) || defined(_WIN64)\n\n')
|
||||||
java_wrapper.write('#define GETLONGAELEMS(T,OLD,NEW) \\\n')
|
java_wrapper.write('#define GETLONGAELEMS(T,OLD,NEW) \\\n')
|
||||||
java_wrapper.write(' T * NEW = (OLD == 0) ? 0 : (T*) jenv->GetLongArrayElements(OLD, NULL);\n')
|
java_wrapper.write(' T * NEW = (OLD == 0) ? 0 : (T*) jenv->GetLongArrayElements(OLD, NULL);\n')
|
||||||
java_wrapper.write('#define RELEASELONGAELEMS(OLD,NEW) \\\n')
|
java_wrapper.write('#define RELEASELONGAELEMS(OLD,NEW) \\\n')
|
||||||
|
|
@ -1227,7 +1227,7 @@ def ml_has_plus_type(ts):
|
||||||
def ml_unwrap(t, ts, s):
|
def ml_unwrap(t, ts, s):
|
||||||
if t == STRING:
|
if t == STRING:
|
||||||
return '(' + ts + ') String_val(' + s + ')'
|
return '(' + ts + ') String_val(' + s + ')'
|
||||||
elif t == BOOL or (type2str(t) == 'Z3_bool'):
|
elif t == BOOL or (type2str(t) == 'bool'):
|
||||||
return '(' + ts + ') Bool_val(' + s + ')'
|
return '(' + ts + ') Bool_val(' + s + ')'
|
||||||
elif t == INT or t == PRINT_MODE or t == ERROR_CODE:
|
elif t == INT or t == PRINT_MODE or t == ERROR_CODE:
|
||||||
return '(' + ts + ') Int_val(' + s + ')'
|
return '(' + ts + ') Int_val(' + s + ')'
|
||||||
|
|
@ -1248,7 +1248,7 @@ def ml_unwrap(t, ts, s):
|
||||||
def ml_set_wrap(t, d, n):
|
def ml_set_wrap(t, d, n):
|
||||||
if t == VOID:
|
if t == VOID:
|
||||||
return d + ' = Val_unit;'
|
return d + ' = Val_unit;'
|
||||||
elif t == BOOL or (type2str(t) == 'Z3_bool'):
|
elif t == BOOL or (type2str(t) == 'bool'):
|
||||||
return d + ' = Val_bool(' + n + ');'
|
return d + ' = Val_bool(' + n + ');'
|
||||||
elif t == INT or t == UINT or t == PRINT_MODE or t == ERROR_CODE:
|
elif t == INT or t == UINT or t == PRINT_MODE or t == ERROR_CODE:
|
||||||
return d + ' = Val_int(' + n + ');'
|
return d + ' = Val_int(' + n + ');'
|
||||||
|
|
@ -1263,7 +1263,7 @@ def ml_set_wrap(t, d, n):
|
||||||
return '*(' + pts + '*)Data_custom_val(' + d + ') = ' + n + ';'
|
return '*(' + pts + '*)Data_custom_val(' + d + ') = ' + n + ';'
|
||||||
|
|
||||||
def ml_alloc_and_store(t, lhs, rhs):
|
def ml_alloc_and_store(t, lhs, rhs):
|
||||||
if t == VOID or t == BOOL or t == INT or t == UINT or t == PRINT_MODE or t == ERROR_CODE or t == INT64 or t == UINT64 or t == DOUBLE or t == STRING or (type2str(t) == 'Z3_bool'):
|
if t == VOID or t == BOOL or t == INT or t == UINT or t == PRINT_MODE or t == ERROR_CODE or t == INT64 or t == UINT64 or t == DOUBLE or t == STRING or (type2str(t) == 'bool'):
|
||||||
return ml_set_wrap(t, lhs, rhs)
|
return ml_set_wrap(t, lhs, rhs)
|
||||||
else:
|
else:
|
||||||
pts = ml_plus_type(type2str(t))
|
pts = ml_plus_type(type2str(t))
|
||||||
|
|
@ -1328,6 +1328,17 @@ def mk_ml(ml_src_dir, ml_output_dir):
|
||||||
|
|
||||||
mk_z3native_stubs_c(ml_src_dir, ml_output_dir)
|
mk_z3native_stubs_c(ml_src_dir, ml_output_dir)
|
||||||
|
|
||||||
|
z3_long_funs = frozenset([
|
||||||
|
'Z3_solver_check',
|
||||||
|
'Z3_solver_check_assumptions',
|
||||||
|
'Z3_simplify',
|
||||||
|
'Z3_simplify_ex',
|
||||||
|
])
|
||||||
|
|
||||||
|
z3_ml_overrides = frozenset([
|
||||||
|
'Z3_mk_config'
|
||||||
|
])
|
||||||
|
|
||||||
def mk_z3native_stubs_c(ml_src_dir, ml_output_dir): # C interface
|
def mk_z3native_stubs_c(ml_src_dir, ml_output_dir): # C interface
|
||||||
ml_wrapperf = os.path.join(ml_output_dir, 'z3native_stubs.c')
|
ml_wrapperf = os.path.join(ml_output_dir, 'z3native_stubs.c')
|
||||||
ml_wrapper = open(ml_wrapperf, 'w')
|
ml_wrapper = open(ml_wrapperf, 'w')
|
||||||
|
|
@ -1339,6 +1350,10 @@ def mk_z3native_stubs_c(ml_src_dir, ml_output_dir): # C interface
|
||||||
ml_pref.close()
|
ml_pref.close()
|
||||||
|
|
||||||
for name, result, params in _dotnet_decls:
|
for name, result, params in _dotnet_decls:
|
||||||
|
|
||||||
|
if name in z3_ml_overrides:
|
||||||
|
continue
|
||||||
|
|
||||||
ip = inparams(params)
|
ip = inparams(params)
|
||||||
op = outparams(params)
|
op = outparams(params)
|
||||||
ap = arrayparams(params)
|
ap = arrayparams(params)
|
||||||
|
|
@ -1491,6 +1506,10 @@ def mk_z3native_stubs_c(ml_src_dir, ml_output_dir): # C interface
|
||||||
ml_wrapper.write(' assert(_iter == Val_emptylist);\n\n')
|
ml_wrapper.write(' assert(_iter == Val_emptylist);\n\n')
|
||||||
i = i + 1
|
i = i + 1
|
||||||
|
|
||||||
|
release_caml_gc= name in z3_long_funs
|
||||||
|
if release_caml_gc:
|
||||||
|
ml_wrapper.write('\n caml_release_runtime_system();\n')
|
||||||
|
|
||||||
ml_wrapper.write('\n /* invoke Z3 function */\n ')
|
ml_wrapper.write('\n /* invoke Z3 function */\n ')
|
||||||
if result != VOID:
|
if result != VOID:
|
||||||
ts = type2str(result)
|
ts = type2str(result)
|
||||||
|
|
@ -1499,6 +1518,7 @@ def mk_z3native_stubs_c(ml_src_dir, ml_output_dir): # C interface
|
||||||
else:
|
else:
|
||||||
ml_wrapper.write('z3rv = ')
|
ml_wrapper.write('z3rv = ')
|
||||||
|
|
||||||
|
|
||||||
# invoke procedure
|
# invoke procedure
|
||||||
ml_wrapper.write('%s(' % name)
|
ml_wrapper.write('%s(' % name)
|
||||||
i = 0
|
i = 0
|
||||||
|
|
@ -1516,6 +1536,14 @@ def mk_z3native_stubs_c(ml_src_dir, ml_output_dir): # C interface
|
||||||
i = i + 1
|
i = i + 1
|
||||||
ml_wrapper.write(');\n')
|
ml_wrapper.write(');\n')
|
||||||
|
|
||||||
|
if name in NULLWrapped:
|
||||||
|
ml_wrapper.write(' if (z3rv_m == NULL) {\n')
|
||||||
|
ml_wrapper.write(' caml_raise_with_string(*caml_named_value("Z3EXCEPTION"), "Object allocation failed");\n')
|
||||||
|
ml_wrapper.write(' }\n')
|
||||||
|
|
||||||
|
if release_caml_gc:
|
||||||
|
ml_wrapper.write('\n caml_acquire_runtime_system();\n')
|
||||||
|
|
||||||
if have_context and name not in Unwrapped:
|
if have_context and name not in Unwrapped:
|
||||||
ml_wrapper.write(' ec = Z3_get_error_code(ctx_p->ctx);\n')
|
ml_wrapper.write(' ec = Z3_get_error_code(ctx_p->ctx);\n')
|
||||||
ml_wrapper.write(' if (ec != Z3_OK) {\n')
|
ml_wrapper.write(' if (ec != Z3_OK) {\n')
|
||||||
|
|
@ -1868,7 +1896,7 @@ def generate_files(api_files,
|
||||||
mk_dotnet_wrappers(dotnet_file)
|
mk_dotnet_wrappers(dotnet_file)
|
||||||
if mk_util.is_verbose():
|
if mk_util.is_verbose():
|
||||||
print("Generated '{}'".format(dotnet_file.name))
|
print("Generated '{}'".format(dotnet_file.name))
|
||||||
|
|
||||||
if java_output_dir:
|
if java_output_dir:
|
||||||
mk_java(java_output_dir, java_package_name)
|
mk_java(java_output_dir, java_package_name)
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -166,6 +166,8 @@ foreach (header ${libz3_public_headers})
|
||||||
set_property(TARGET libz3 APPEND PROPERTY
|
set_property(TARGET libz3 APPEND PROPERTY
|
||||||
PUBLIC_HEADER "${CMAKE_SOURCE_DIR}/src/api/${header}")
|
PUBLIC_HEADER "${CMAKE_SOURCE_DIR}/src/api/${header}")
|
||||||
endforeach()
|
endforeach()
|
||||||
|
set_property(TARGET libz3 APPEND PROPERTY
|
||||||
|
PUBLIC_HEADER "${CMAKE_CURRENT_BINARY_DIR}/util/z3_version.h")
|
||||||
|
|
||||||
install(TARGETS libz3
|
install(TARGETS libz3
|
||||||
EXPORT Z3_EXPORTED_TARGETS
|
EXPORT Z3_EXPORTED_TARGETS
|
||||||
|
|
|
||||||
|
|
@ -220,7 +220,7 @@ lbool lackr::lazy() {
|
||||||
lackr_model_constructor mc(m_m, m_info);
|
lackr_model_constructor mc(m_m, m_info);
|
||||||
push_abstraction();
|
push_abstraction();
|
||||||
unsigned ackr_head = 0;
|
unsigned ackr_head = 0;
|
||||||
while (1) {
|
while (true) {
|
||||||
m_st.m_it++;
|
m_st.m_it++;
|
||||||
checkpoint();
|
checkpoint();
|
||||||
TRACE("lackr", tout << "lazy check: " << m_st.m_it << "\n";);
|
TRACE("lackr", tout << "lazy check: " << m_st.m_it << "\n";);
|
||||||
|
|
|
||||||
|
|
@ -102,7 +102,7 @@ class lackr {
|
||||||
//
|
//
|
||||||
// Introduce congruence ackermann lemma for the two given terms.
|
// Introduce congruence ackermann lemma for the two given terms.
|
||||||
//
|
//
|
||||||
bool ackr(app * const t1, app * const t2);
|
bool ackr(app * t1, app * t2);
|
||||||
|
|
||||||
//
|
//
|
||||||
// Introduce the ackermann lemma for each pair of terms.
|
// Introduce the ackermann lemma for each pair of terms.
|
||||||
|
|
|
||||||
|
|
@ -276,7 +276,7 @@ struct lackr_model_constructor::imp {
|
||||||
SASSERT(a->get_num_args() == 0);
|
SASSERT(a->get_num_args() == 0);
|
||||||
func_decl * const fd = a->get_decl();
|
func_decl * const fd = a->get_decl();
|
||||||
expr * val = m_abstr_model->get_const_interp(fd);
|
expr * val = m_abstr_model->get_const_interp(fd);
|
||||||
if (val == nullptr) { // TODO: avoid model completetion?
|
if (val == nullptr) { // TODO: avoid model completion?
|
||||||
sort * s = fd->get_range();
|
sort * s = fd->get_range();
|
||||||
val = m_abstr_model->get_some_value(s);
|
val = m_abstr_model->get_some_value(s);
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -79,23 +79,23 @@ extern "C" {
|
||||||
_c->autil().is_irrational_algebraic_numeral(to_expr(a)));
|
_c->autil().is_irrational_algebraic_numeral(to_expr(a)));
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_algebraic_is_value(Z3_context c, Z3_ast a) {
|
bool Z3_API Z3_algebraic_is_value(Z3_context c, Z3_ast a) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_algebraic_is_value(c, a);
|
LOG_Z3_algebraic_is_value(c, a);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
return Z3_algebraic_is_value_core(c, a) ? Z3_TRUE : Z3_FALSE;
|
return Z3_algebraic_is_value_core(c, a);
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_algebraic_is_pos(Z3_context c, Z3_ast a) {
|
bool Z3_API Z3_algebraic_is_pos(Z3_context c, Z3_ast a) {
|
||||||
return Z3_algebraic_sign(c, a) > 0;
|
return Z3_algebraic_sign(c, a) > 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_algebraic_is_neg(Z3_context c, Z3_ast a) {
|
bool Z3_API Z3_algebraic_is_neg(Z3_context c, Z3_ast a) {
|
||||||
return Z3_algebraic_sign(c, a) < 0;
|
return Z3_algebraic_sign(c, a) < 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_algebraic_is_zero(Z3_context c, Z3_ast a) {
|
bool Z3_API Z3_algebraic_is_zero(Z3_context c, Z3_ast a) {
|
||||||
return Z3_algebraic_sign(c, a) == 0;
|
return Z3_algebraic_sign(c, a) == 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -283,32 +283,32 @@ extern "C" {
|
||||||
r = _am.IRAT_PRED(av, bv); \
|
r = _am.IRAT_PRED(av, bv); \
|
||||||
} \
|
} \
|
||||||
} \
|
} \
|
||||||
return r ? Z3_TRUE : Z3_FALSE;
|
return r;
|
||||||
|
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_algebraic_lt(Z3_context c, Z3_ast a, Z3_ast b) {
|
bool Z3_API Z3_algebraic_lt(Z3_context c, Z3_ast a, Z3_ast b) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_algebraic_lt(c, a, b);
|
LOG_Z3_algebraic_lt(c, a, b);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
CHECK_IS_ALGEBRAIC(a, 0);
|
CHECK_IS_ALGEBRAIC(a, 0);
|
||||||
CHECK_IS_ALGEBRAIC(b, 0);
|
CHECK_IS_ALGEBRAIC(b, 0);
|
||||||
BIN_PRED(<,lt);
|
BIN_PRED(<,lt);
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_algebraic_gt(Z3_context c, Z3_ast a, Z3_ast b) {
|
bool Z3_API Z3_algebraic_gt(Z3_context c, Z3_ast a, Z3_ast b) {
|
||||||
return Z3_algebraic_lt(c, b, a);
|
return Z3_algebraic_lt(c, b, a);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_algebraic_le(Z3_context c, Z3_ast a, Z3_ast b) {
|
bool Z3_API Z3_algebraic_le(Z3_context c, Z3_ast a, Z3_ast b) {
|
||||||
return !Z3_algebraic_lt(c, b, a);
|
return !Z3_algebraic_lt(c, b, a);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_algebraic_ge(Z3_context c, Z3_ast a, Z3_ast b) {
|
bool Z3_API Z3_algebraic_ge(Z3_context c, Z3_ast a, Z3_ast b) {
|
||||||
return !Z3_algebraic_lt(c, a, b);
|
return !Z3_algebraic_lt(c, a, b);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_algebraic_eq(Z3_context c, Z3_ast a, Z3_ast b) {
|
bool Z3_API Z3_algebraic_eq(Z3_context c, Z3_ast a, Z3_ast b) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_algebraic_eq(c, a, b);
|
LOG_Z3_algebraic_eq(c, a, b);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
|
|
@ -318,7 +318,7 @@ extern "C" {
|
||||||
Z3_CATCH_RETURN(0);
|
Z3_CATCH_RETURN(0);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_algebraic_neq(Z3_context c, Z3_ast a, Z3_ast b) {
|
bool Z3_API Z3_algebraic_neq(Z3_context c, Z3_ast a, Z3_ast b) {
|
||||||
return !Z3_algebraic_eq(c, a, b);
|
return !Z3_algebraic_eq(c, a, b);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -119,9 +119,9 @@ extern "C" {
|
||||||
Z3_CATCH_RETURN(nullptr);
|
Z3_CATCH_RETURN(nullptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_is_algebraic_number(Z3_context c, Z3_ast a) {
|
bool Z3_API Z3_is_algebraic_number(Z3_context c, Z3_ast a) {
|
||||||
LOG_Z3_is_algebraic_number(c, a);
|
LOG_Z3_is_algebraic_number(c, a);
|
||||||
return mk_c(c)->autil().is_irrational_algebraic_numeral(to_expr(a)) ? Z3_TRUE : Z3_FALSE;
|
return mk_c(c)->autil().is_irrational_algebraic_numeral(to_expr(a));
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_ast Z3_API Z3_get_algebraic_number_lower(Z3_context c, Z3_ast a, unsigned precision) {
|
Z3_ast Z3_API Z3_get_algebraic_number_lower(Z3_context c, Z3_ast a, unsigned precision) {
|
||||||
|
|
|
||||||
|
|
@ -33,11 +33,15 @@ Revision History:
|
||||||
#include "ast/rewriter/th_rewriter.h"
|
#include "ast/rewriter/th_rewriter.h"
|
||||||
#include "ast/rewriter/var_subst.h"
|
#include "ast/rewriter/var_subst.h"
|
||||||
#include "ast/rewriter/expr_safe_replace.h"
|
#include "ast/rewriter/expr_safe_replace.h"
|
||||||
|
#include "ast/rewriter/recfun_replace.h"
|
||||||
|
#include "ast/rewriter/seq_rewriter.h"
|
||||||
#include "ast/pp.h"
|
#include "ast/pp.h"
|
||||||
#include "util/scoped_ctrl_c.h"
|
#include "util/scoped_ctrl_c.h"
|
||||||
#include "util/cancel_eh.h"
|
#include "util/cancel_eh.h"
|
||||||
#include "util/scoped_timer.h"
|
#include "util/scoped_timer.h"
|
||||||
#include "ast/pp_params.hpp"
|
#include "ast/pp_params.hpp"
|
||||||
|
#include "ast/expr_abstract.h"
|
||||||
|
|
||||||
|
|
||||||
extern bool is_numeral_sort(Z3_context c, Z3_sort ty);
|
extern bool is_numeral_sort(Z3_context c, Z3_sort ty);
|
||||||
|
|
||||||
|
|
@ -70,7 +74,7 @@ extern "C" {
|
||||||
Z3_CATCH_RETURN(nullptr);
|
Z3_CATCH_RETURN(nullptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_is_eq_sort(Z3_context c, Z3_sort s1, Z3_sort s2) {
|
bool Z3_API Z3_is_eq_sort(Z3_context c, Z3_sort s1, Z3_sort s2) {
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
return s1 == s2;
|
return s1 == s2;
|
||||||
}
|
}
|
||||||
|
|
@ -85,12 +89,12 @@ extern "C" {
|
||||||
Z3_CATCH_RETURN(nullptr);
|
Z3_CATCH_RETURN(nullptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_is_eq_ast(Z3_context c, Z3_ast s1, Z3_ast s2) {
|
bool Z3_API Z3_is_eq_ast(Z3_context c, Z3_ast s1, Z3_ast s2) {
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
return s1 == s2;
|
return s1 == s2;
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_is_eq_func_decl(Z3_context c, Z3_func_decl s1, Z3_func_decl s2) {
|
bool Z3_API Z3_is_eq_func_decl(Z3_context c, Z3_func_decl s1, Z3_func_decl s2) {
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
return s1 == s2;
|
return s1 == s2;
|
||||||
}
|
}
|
||||||
|
|
@ -110,6 +114,55 @@ extern "C" {
|
||||||
Z3_CATCH_RETURN(nullptr);
|
Z3_CATCH_RETURN(nullptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
Z3_func_decl Z3_API Z3_mk_rec_func_decl(Z3_context c, Z3_symbol s, unsigned domain_size, Z3_sort const* domain,
|
||||||
|
Z3_sort range) {
|
||||||
|
Z3_TRY;
|
||||||
|
LOG_Z3_mk_rec_func_decl(c, s, domain_size, domain, range);
|
||||||
|
RESET_ERROR_CODE();
|
||||||
|
//
|
||||||
|
recfun::promise_def def =
|
||||||
|
mk_c(c)->recfun().get_plugin().mk_def(to_symbol(s),
|
||||||
|
domain_size,
|
||||||
|
to_sorts(domain),
|
||||||
|
to_sort(range));
|
||||||
|
func_decl* d = def.get_def()->get_decl();
|
||||||
|
mk_c(c)->save_ast_trail(d);
|
||||||
|
RETURN_Z3(of_func_decl(d));
|
||||||
|
Z3_CATCH_RETURN(nullptr);
|
||||||
|
}
|
||||||
|
|
||||||
|
void Z3_API Z3_add_rec_def(Z3_context c, Z3_func_decl f, unsigned n, Z3_ast args[], Z3_ast body) {
|
||||||
|
Z3_TRY;
|
||||||
|
LOG_Z3_add_rec_def(c, f, n, args, body);
|
||||||
|
func_decl* d = to_func_decl(f);
|
||||||
|
ast_manager& m = mk_c(c)->m();
|
||||||
|
recfun::decl::plugin& p = mk_c(c)->recfun().get_plugin();
|
||||||
|
expr_ref abs_body(m);
|
||||||
|
expr_ref_vector _args(m);
|
||||||
|
var_ref_vector _vars(m);
|
||||||
|
for (unsigned i = 0; i < n; ++i) {
|
||||||
|
_args.push_back(to_expr(args[i]));
|
||||||
|
_vars.push_back(m.mk_var(n - i - 1, m.get_sort(_args.back())));
|
||||||
|
if (m.get_sort(_args.back()) != d->get_domain(i)) {
|
||||||
|
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
expr_abstract(m, 0, n, _args.c_ptr(), to_expr(body), abs_body);
|
||||||
|
recfun::promise_def pd = p.get_promise_def(d);
|
||||||
|
if (!pd.get_def()) {
|
||||||
|
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
if (m.get_sort(abs_body) != d->get_range()) {
|
||||||
|
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
recfun_replace replace(m);
|
||||||
|
p.set_definition(replace, pd, n, _vars.c_ptr(), abs_body);
|
||||||
|
Z3_CATCH;
|
||||||
|
}
|
||||||
|
|
||||||
Z3_ast Z3_API Z3_mk_app(Z3_context c, Z3_func_decl d, unsigned num_args, Z3_ast const * args) {
|
Z3_ast Z3_API Z3_mk_app(Z3_context c, Z3_func_decl d, unsigned num_args, Z3_ast const * args) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_mk_app(c, d, num_args, args);
|
LOG_Z3_mk_app(c, d, num_args, args);
|
||||||
|
|
@ -256,12 +309,12 @@ extern "C" {
|
||||||
return to_sort(s)->get_id();
|
return to_sort(s)->get_id();
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_is_well_sorted(Z3_context c, Z3_ast t) {
|
bool Z3_API Z3_is_well_sorted(Z3_context c, Z3_ast t) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_is_well_sorted(c, t);
|
LOG_Z3_is_well_sorted(c, t);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
return is_well_sorted(mk_c(c)->m(), to_expr(t));
|
return is_well_sorted(mk_c(c)->m(), to_expr(t));
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_symbol_kind Z3_API Z3_get_symbol_kind(Z3_context c, Z3_symbol s) {
|
Z3_symbol_kind Z3_API Z3_get_symbol_kind(Z3_context c, Z3_symbol s) {
|
||||||
|
|
@ -331,7 +384,7 @@ extern "C" {
|
||||||
return to_ast(a)->hash();
|
return to_ast(a)->hash();
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_is_app(Z3_context c, Z3_ast a) {
|
bool Z3_API Z3_is_app(Z3_context c, Z3_ast a) {
|
||||||
LOG_Z3_is_app(c, a);
|
LOG_Z3_is_app(c, a);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
return a != nullptr && is_app(reinterpret_cast<ast*>(a));
|
return a != nullptr && is_app(reinterpret_cast<ast*>(a));
|
||||||
|
|
@ -468,7 +521,7 @@ extern "C" {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_get_decl_symbol_parameter(c, d, idx);
|
LOG_Z3_get_decl_symbol_parameter(c, d, idx);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
CHECK_VALID_AST(d, 0);
|
CHECK_VALID_AST(d, nullptr);
|
||||||
if (idx >= to_func_decl(d)->get_num_parameters()) {
|
if (idx >= to_func_decl(d)->get_num_parameters()) {
|
||||||
SET_ERROR_CODE(Z3_IOB, nullptr);
|
SET_ERROR_CODE(Z3_IOB, nullptr);
|
||||||
return nullptr;
|
return nullptr;
|
||||||
|
|
@ -486,7 +539,7 @@ extern "C" {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_get_decl_sort_parameter(c, d, idx);
|
LOG_Z3_get_decl_sort_parameter(c, d, idx);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
CHECK_VALID_AST(d, 0);
|
CHECK_VALID_AST(d, nullptr);
|
||||||
if (idx >= to_func_decl(d)->get_num_parameters()) {
|
if (idx >= to_func_decl(d)->get_num_parameters()) {
|
||||||
SET_ERROR_CODE(Z3_IOB, nullptr);
|
SET_ERROR_CODE(Z3_IOB, nullptr);
|
||||||
RETURN_Z3(nullptr);
|
RETURN_Z3(nullptr);
|
||||||
|
|
@ -504,7 +557,7 @@ extern "C" {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_get_decl_ast_parameter(c, d, idx);
|
LOG_Z3_get_decl_ast_parameter(c, d, idx);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
CHECK_VALID_AST(d, 0);
|
CHECK_VALID_AST(d, nullptr);
|
||||||
if (idx >= to_func_decl(d)->get_num_parameters()) {
|
if (idx >= to_func_decl(d)->get_num_parameters()) {
|
||||||
SET_ERROR_CODE(Z3_IOB, nullptr);
|
SET_ERROR_CODE(Z3_IOB, nullptr);
|
||||||
RETURN_Z3(nullptr);
|
RETURN_Z3(nullptr);
|
||||||
|
|
@ -522,7 +575,7 @@ extern "C" {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_get_decl_func_decl_parameter(c, d, idx);
|
LOG_Z3_get_decl_func_decl_parameter(c, d, idx);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
CHECK_VALID_AST(d, 0);
|
CHECK_VALID_AST(d, nullptr);
|
||||||
if (idx >= to_func_decl(d)->get_num_parameters()) {
|
if (idx >= to_func_decl(d)->get_num_parameters()) {
|
||||||
SET_ERROR_CODE(Z3_IOB, nullptr);
|
SET_ERROR_CODE(Z3_IOB, nullptr);
|
||||||
RETURN_Z3(nullptr);
|
RETURN_Z3(nullptr);
|
||||||
|
|
@ -596,7 +649,7 @@ extern "C" {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_get_domain(c, d, i);
|
LOG_Z3_get_domain(c, d, i);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
CHECK_VALID_AST(d, 0);
|
CHECK_VALID_AST(d, nullptr);
|
||||||
if (i >= to_func_decl(d)->get_arity()) {
|
if (i >= to_func_decl(d)->get_arity()) {
|
||||||
SET_ERROR_CODE(Z3_IOB, nullptr);
|
SET_ERROR_CODE(Z3_IOB, nullptr);
|
||||||
RETURN_Z3(nullptr);
|
RETURN_Z3(nullptr);
|
||||||
|
|
@ -681,6 +734,7 @@ extern "C" {
|
||||||
Z3_CATCH_RETURN(Z3_L_UNDEF);
|
Z3_CATCH_RETURN(Z3_L_UNDEF);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
static Z3_ast simplify(Z3_context c, Z3_ast _a, Z3_params _p) {
|
static Z3_ast simplify(Z3_context c, Z3_ast _a, Z3_params _p) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
|
|
@ -690,6 +744,7 @@ extern "C" {
|
||||||
unsigned timeout = p.get_uint("timeout", mk_c(c)->get_timeout());
|
unsigned timeout = p.get_uint("timeout", mk_c(c)->get_timeout());
|
||||||
bool use_ctrl_c = p.get_bool("ctrl_c", false);
|
bool use_ctrl_c = p.get_bool("ctrl_c", false);
|
||||||
th_rewriter m_rw(m, p);
|
th_rewriter m_rw(m, p);
|
||||||
|
m_rw.set_solver(alloc(api::seq_expr_solver, m, p));
|
||||||
expr_ref result(m);
|
expr_ref result(m);
|
||||||
cancel_eh<reslimit> eh(m.limit());
|
cancel_eh<reslimit> eh(m.limit());
|
||||||
api::context::set_interruptable si(*(mk_c(c)), eh);
|
api::context::set_interruptable si(*(mk_c(c)), eh);
|
||||||
|
|
|
||||||
|
|
@ -57,12 +57,12 @@ extern "C" {
|
||||||
Z3_CATCH;
|
Z3_CATCH;
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_ast_map_contains(Z3_context c, Z3_ast_map m, Z3_ast k) {
|
bool Z3_API Z3_ast_map_contains(Z3_context c, Z3_ast_map m, Z3_ast k) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_ast_map_contains(c, m, k);
|
LOG_Z3_ast_map_contains(c, m, k);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
return to_ast_map_ref(m).contains(to_ast(k));
|
return to_ast_map_ref(m).contains(to_ast(k));
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_ast Z3_API Z3_ast_map_find(Z3_context c, Z3_ast_map m, Z3_ast k) {
|
Z3_ast Z3_API Z3_ast_map_find(Z3_context c, Z3_ast_map m, Z3_ast k) {
|
||||||
|
|
|
||||||
|
|
@ -106,7 +106,7 @@ Z3_ast Z3_API NAME(Z3_context c, unsigned i, Z3_ast n) { \
|
||||||
MK_BV_PUNARY(Z3_mk_rotate_right, OP_ROTATE_RIGHT);
|
MK_BV_PUNARY(Z3_mk_rotate_right, OP_ROTATE_RIGHT);
|
||||||
MK_BV_PUNARY(Z3_mk_int2bv, OP_INT2BV);
|
MK_BV_PUNARY(Z3_mk_int2bv, OP_INT2BV);
|
||||||
|
|
||||||
Z3_ast Z3_API Z3_mk_bv2int(Z3_context c, Z3_ast n, Z3_bool is_signed) {
|
Z3_ast Z3_API Z3_mk_bv2int(Z3_context c, Z3_ast n, bool is_signed) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_mk_bv2int(c, n, is_signed);
|
LOG_Z3_mk_bv2int(c, n, is_signed);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
|
|
@ -186,7 +186,7 @@ Z3_ast Z3_API NAME(Z3_context c, unsigned i, Z3_ast n) { \
|
||||||
return Z3_mk_int(c, -1, s);
|
return Z3_mk_int(c, -1, s);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_ast Z3_API Z3_mk_bvadd_no_overflow(Z3_context c, Z3_ast t1, Z3_ast t2, Z3_bool is_signed) {
|
Z3_ast Z3_API Z3_mk_bvadd_no_overflow(Z3_context c, Z3_ast t1, Z3_ast t2, bool is_signed) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
if (is_signed) {
|
if (is_signed) {
|
||||||
|
|
@ -286,7 +286,7 @@ Z3_ast Z3_API NAME(Z3_context c, unsigned i, Z3_ast n) { \
|
||||||
Z3_CATCH_RETURN(nullptr);
|
Z3_CATCH_RETURN(nullptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_ast Z3_API Z3_mk_bvsub_no_underflow(Z3_context c, Z3_ast t1, Z3_ast t2, Z3_bool is_signed) {
|
Z3_ast Z3_API Z3_mk_bvsub_no_underflow(Z3_context c, Z3_ast t1, Z3_ast t2, bool is_signed) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
if (is_signed) {
|
if (is_signed) {
|
||||||
|
|
@ -311,7 +311,7 @@ Z3_ast Z3_API NAME(Z3_context c, unsigned i, Z3_ast n) { \
|
||||||
Z3_CATCH_RETURN(nullptr);
|
Z3_CATCH_RETURN(nullptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_ast Z3_API Z3_mk_bvmul_no_overflow(Z3_context c, Z3_ast n1, Z3_ast n2, Z3_bool is_signed) {
|
Z3_ast Z3_API Z3_mk_bvmul_no_overflow(Z3_context c, Z3_ast n1, Z3_ast n2, bool is_signed) {
|
||||||
LOG_Z3_mk_bvmul_no_overflow(c, n1, n2, is_signed);
|
LOG_Z3_mk_bvmul_no_overflow(c, n1, n2, is_signed);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
if (is_signed) {
|
if (is_signed) {
|
||||||
|
|
|
||||||
|
|
@ -57,21 +57,28 @@ extern "C" {
|
||||||
try {
|
try {
|
||||||
g_Z3_global_param_get_buffer = gparams::get_value(param_id);
|
g_Z3_global_param_get_buffer = gparams::get_value(param_id);
|
||||||
*param_value = g_Z3_global_param_get_buffer.c_str();
|
*param_value = g_Z3_global_param_get_buffer.c_str();
|
||||||
return Z3_TRUE;
|
return true;
|
||||||
}
|
}
|
||||||
catch (z3_exception & ex) {
|
catch (z3_exception & ex) {
|
||||||
// The error handler is only available for contexts
|
// The error handler is only available for contexts
|
||||||
// Just throw a warning.
|
// Just throw a warning.
|
||||||
warning_msg("%s", ex.msg());
|
warning_msg("%s", ex.msg());
|
||||||
return Z3_FALSE;
|
return false;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_config Z3_API Z3_mk_config(void) {
|
Z3_config Z3_API Z3_mk_config(void) {
|
||||||
memory::initialize(UINT_MAX);
|
try {
|
||||||
LOG_Z3_mk_config();
|
memory::initialize(UINT_MAX);
|
||||||
Z3_config r = reinterpret_cast<Z3_config>(alloc(context_params));
|
LOG_Z3_mk_config();
|
||||||
RETURN_Z3(r);
|
Z3_config r = reinterpret_cast<Z3_config>(alloc(context_params));
|
||||||
|
RETURN_Z3(r);
|
||||||
|
} catch (z3_exception & ex) {
|
||||||
|
// The error handler is only available for contexts
|
||||||
|
// Just throw a warning.
|
||||||
|
warning_msg("%s", ex.msg());
|
||||||
|
return nullptr;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void Z3_API Z3_del_config(Z3_config c) {
|
void Z3_API Z3_del_config(Z3_config c) {
|
||||||
|
|
|
||||||
|
|
@ -19,7 +19,7 @@ Revision History:
|
||||||
--*/
|
--*/
|
||||||
#include<typeinfo>
|
#include<typeinfo>
|
||||||
#include "api/api_context.h"
|
#include "api/api_context.h"
|
||||||
#include "util/version.h"
|
#include "util/z3_version.h"
|
||||||
#include "ast/ast_pp.h"
|
#include "ast/ast_pp.h"
|
||||||
#include "ast/ast_ll_pp.h"
|
#include "ast/ast_ll_pp.h"
|
||||||
#include "api/api_log_macros.h"
|
#include "api/api_log_macros.h"
|
||||||
|
|
@ -79,6 +79,7 @@ namespace api {
|
||||||
m_datalog_util(m()),
|
m_datalog_util(m()),
|
||||||
m_fpa_util(m()),
|
m_fpa_util(m()),
|
||||||
m_sutil(m()),
|
m_sutil(m()),
|
||||||
|
m_recfun(m()),
|
||||||
m_last_result(m()),
|
m_last_result(m()),
|
||||||
m_ast_trail(m()),
|
m_ast_trail(m()),
|
||||||
m_pmanager(m_limit) {
|
m_pmanager(m_limit) {
|
||||||
|
|
@ -108,13 +109,10 @@ namespace api {
|
||||||
|
|
||||||
context::~context() {
|
context::~context() {
|
||||||
m_last_obj = nullptr;
|
m_last_obj = nullptr;
|
||||||
u_map<api::object*>::iterator it = m_allocated_objects.begin();
|
for (auto& kv : m_allocated_objects) {
|
||||||
while (it != m_allocated_objects.end()) {
|
api::object* val = kv.m_value;
|
||||||
api::object* val = it->m_value;
|
DEBUG_CODE(warning_msg("Uncollected memory: %d: %s", kv.m_key, typeid(*val).name()););
|
||||||
DEBUG_CODE(warning_msg("Uncollected memory: %d: %s", it->m_key, typeid(*val).name()););
|
|
||||||
m_allocated_objects.remove(it->m_key);
|
|
||||||
dealloc(val);
|
dealloc(val);
|
||||||
it = m_allocated_objects.begin();
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -219,7 +217,7 @@ namespace api {
|
||||||
if (m_user_ref_count) {
|
if (m_user_ref_count) {
|
||||||
// Corner case bug: n may be in m_last_result, and this is the only reference to n.
|
// Corner case bug: n may be in m_last_result, and this is the only reference to n.
|
||||||
// When, we execute reset() it is deleted
|
// When, we execute reset() it is deleted
|
||||||
// To avoid this bug, I bump the reference counter before reseting m_last_result
|
// To avoid this bug, I bump the reference counter before resetting m_last_result
|
||||||
ast_ref node(n, m());
|
ast_ref node(n, m());
|
||||||
m_last_result.reset();
|
m_last_result.reset();
|
||||||
m_last_result.push_back(std::move(node));
|
m_last_result.push_back(std::move(node));
|
||||||
|
|
@ -362,7 +360,7 @@ extern "C" {
|
||||||
Z3_CATCH;
|
Z3_CATCH;
|
||||||
}
|
}
|
||||||
|
|
||||||
void Z3_API Z3_toggle_warning_messages(Z3_bool enabled) {
|
void Z3_API Z3_toggle_warning_messages(bool enabled) {
|
||||||
LOG_Z3_toggle_warning_messages(enabled);
|
LOG_Z3_toggle_warning_messages(enabled);
|
||||||
enable_warning_messages(enabled != 0);
|
enable_warning_messages(enabled != 0);
|
||||||
}
|
}
|
||||||
|
|
@ -439,7 +437,6 @@ extern "C" {
|
||||||
void Z3_API Z3_set_error_handler(Z3_context c, Z3_error_handler h) {
|
void Z3_API Z3_set_error_handler(Z3_context c, Z3_error_handler h) {
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
mk_c(c)->set_error_handler(h);
|
mk_c(c)->set_error_handler(h);
|
||||||
// [Leo]: using exception handling, we don't need global error handlers anymore
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void Z3_API Z3_set_error(Z3_context c, Z3_error_code e) {
|
void Z3_API Z3_set_error(Z3_context c, Z3_error_code e) {
|
||||||
|
|
@ -489,9 +486,3 @@ extern "C" {
|
||||||
}
|
}
|
||||||
|
|
||||||
};
|
};
|
||||||
|
|
||||||
Z3_API ast_manager& Z3_get_manager(Z3_context c) {
|
|
||||||
return mk_c(c)->m();
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -29,6 +29,7 @@ Revision History:
|
||||||
#include "ast/datatype_decl_plugin.h"
|
#include "ast/datatype_decl_plugin.h"
|
||||||
#include "ast/dl_decl_plugin.h"
|
#include "ast/dl_decl_plugin.h"
|
||||||
#include "ast/fpa_decl_plugin.h"
|
#include "ast/fpa_decl_plugin.h"
|
||||||
|
#include "ast/recfun_decl_plugin.h"
|
||||||
#include "smt/smt_kernel.h"
|
#include "smt/smt_kernel.h"
|
||||||
#include "smt/params/smt_params.h"
|
#include "smt/params/smt_params.h"
|
||||||
#include "util/event_handler.h"
|
#include "util/event_handler.h"
|
||||||
|
|
@ -37,6 +38,9 @@ Revision History:
|
||||||
#include "cmd_context/cmd_context.h"
|
#include "cmd_context/cmd_context.h"
|
||||||
#include "api/api_polynomial.h"
|
#include "api/api_polynomial.h"
|
||||||
#include "util/hashtable.h"
|
#include "util/hashtable.h"
|
||||||
|
#include "ast/rewriter/seq_rewriter.h"
|
||||||
|
#include "smt/smt_solver.h"
|
||||||
|
#include "solver/solver.h"
|
||||||
|
|
||||||
namespace smtlib {
|
namespace smtlib {
|
||||||
class parser;
|
class parser;
|
||||||
|
|
@ -48,6 +52,24 @@ namespace realclosure {
|
||||||
|
|
||||||
namespace api {
|
namespace api {
|
||||||
|
|
||||||
|
class seq_expr_solver : public expr_solver {
|
||||||
|
ast_manager& m;
|
||||||
|
params_ref const& p;
|
||||||
|
solver_ref s;
|
||||||
|
public:
|
||||||
|
seq_expr_solver(ast_manager& m, params_ref const& p): m(m), p(p) {}
|
||||||
|
lbool check_sat(expr* e) {
|
||||||
|
if (!s) {
|
||||||
|
s = mk_smt_solver(m, p, symbol("ALL"));
|
||||||
|
}
|
||||||
|
s->push();
|
||||||
|
s->assert_expr(e);
|
||||||
|
lbool r = s->check_sat();
|
||||||
|
s->pop(1);
|
||||||
|
return r;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
class context : public tactic_manager {
|
class context : public tactic_manager {
|
||||||
struct add_plugins { add_plugins(ast_manager & m); };
|
struct add_plugins { add_plugins(ast_manager & m); };
|
||||||
|
|
@ -62,6 +84,7 @@ namespace api {
|
||||||
datalog::dl_decl_util m_datalog_util;
|
datalog::dl_decl_util m_datalog_util;
|
||||||
fpa_util m_fpa_util;
|
fpa_util m_fpa_util;
|
||||||
seq_util m_sutil;
|
seq_util m_sutil;
|
||||||
|
recfun::util m_recfun;
|
||||||
|
|
||||||
// Support for old solver API
|
// Support for old solver API
|
||||||
smt_params m_fparams;
|
smt_params m_fparams;
|
||||||
|
|
@ -128,6 +151,7 @@ namespace api {
|
||||||
fpa_util & fpautil() { return m_fpa_util; }
|
fpa_util & fpautil() { return m_fpa_util; }
|
||||||
datatype_util& dtutil() { return m_dt_plugin->u(); }
|
datatype_util& dtutil() { return m_dt_plugin->u(); }
|
||||||
seq_util& sutil() { return m_sutil; }
|
seq_util& sutil() { return m_sutil; }
|
||||||
|
recfun::util& recfun() { return m_recfun; }
|
||||||
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; }
|
||||||
family_id get_arith_fid() const { return m_arith_fid; }
|
family_id get_arith_fid() const { return m_arith_fid; }
|
||||||
|
|
|
||||||
|
|
@ -199,23 +199,23 @@ 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_t * out) {
|
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;
|
||||||
}
|
}
|
||||||
if (Z3_get_sort_kind(c, s) != Z3_FINITE_DOMAIN_SORT) {
|
if (Z3_get_sort_kind(c, s) != Z3_FINITE_DOMAIN_SORT) {
|
||||||
return Z3_FALSE;
|
return false;
|
||||||
}
|
}
|
||||||
if (!out) {
|
if (!out) {
|
||||||
return Z3_FALSE;
|
return false;
|
||||||
}
|
}
|
||||||
// must start loggging here, since function uses Z3_get_sort_kind above
|
// must start logging here, since function uses Z3_get_sort_kind above
|
||||||
LOG_Z3_get_finite_domain_sort_size(c, s, out);
|
LOG_Z3_get_finite_domain_sort_size(c, s, out);
|
||||||
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 true;
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_fixedpoint Z3_API Z3_mk_fixedpoint(Z3_context c) {
|
Z3_fixedpoint Z3_API Z3_mk_fixedpoint(Z3_context c) {
|
||||||
|
|
@ -379,10 +379,8 @@ extern "C" {
|
||||||
for (unsigned i = 0; i < coll.m_rules.size(); ++i) {
|
for (unsigned i = 0; i < coll.m_rules.size(); ++i) {
|
||||||
to_fixedpoint_ref(d)->add_rule(coll.m_rules[i].get(), coll.m_names[i]);
|
to_fixedpoint_ref(d)->add_rule(coll.m_rules[i].get(), coll.m_names[i]);
|
||||||
}
|
}
|
||||||
ptr_vector<expr>::const_iterator it = ctx.begin_assertions();
|
for (expr * e : ctx.assertions()) {
|
||||||
ptr_vector<expr>::const_iterator end = ctx.end_assertions();
|
to_fixedpoint_ref(d)->ctx().assert_expr(e);
|
||||||
for (; it != end; ++it) {
|
|
||||||
to_fixedpoint_ref(d)->ctx().assert_expr(*it);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
return of_ast_vector(v);
|
return of_ast_vector(v);
|
||||||
|
|
@ -717,6 +715,4 @@ extern "C" {
|
||||||
Z3_CATCH_RETURN(nullptr);
|
Z3_CATCH_RETURN(nullptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
};
|
};
|
||||||
|
|
|
||||||
|
|
@ -232,7 +232,7 @@ extern "C" {
|
||||||
Z3_CATCH_RETURN(nullptr);
|
Z3_CATCH_RETURN(nullptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_ast Z3_API Z3_mk_fpa_inf(Z3_context c, Z3_sort s, Z3_bool negative) {
|
Z3_ast Z3_API Z3_mk_fpa_inf(Z3_context c, Z3_sort s, bool negative) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_mk_fpa_inf(c, s, negative);
|
LOG_Z3_mk_fpa_inf(c, s, negative);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
|
|
@ -242,14 +242,14 @@ extern "C" {
|
||||||
RETURN_Z3(nullptr);
|
RETURN_Z3(nullptr);
|
||||||
}
|
}
|
||||||
api::context * ctx = mk_c(c);
|
api::context * ctx = mk_c(c);
|
||||||
expr * a = negative != 0 ? ctx->fpautil().mk_ninf(to_sort(s)) :
|
expr * a = negative ? ctx->fpautil().mk_ninf(to_sort(s)) :
|
||||||
ctx->fpautil().mk_pinf(to_sort(s));
|
ctx->fpautil().mk_pinf(to_sort(s));
|
||||||
ctx->save_ast_trail(a);
|
ctx->save_ast_trail(a);
|
||||||
RETURN_Z3(of_expr(a));
|
RETURN_Z3(of_expr(a));
|
||||||
Z3_CATCH_RETURN(nullptr);
|
Z3_CATCH_RETURN(nullptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_ast Z3_API Z3_mk_fpa_zero(Z3_context c, Z3_sort s, Z3_bool negative) {
|
Z3_ast Z3_API Z3_mk_fpa_zero(Z3_context c, Z3_sort s, bool negative) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_mk_fpa_inf(c, s, negative);
|
LOG_Z3_mk_fpa_inf(c, s, negative);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
|
|
@ -259,8 +259,8 @@ extern "C" {
|
||||||
RETURN_Z3(nullptr);
|
RETURN_Z3(nullptr);
|
||||||
}
|
}
|
||||||
api::context * ctx = mk_c(c);
|
api::context * ctx = mk_c(c);
|
||||||
expr * a = negative != 0 ? ctx->fpautil().mk_nzero(to_sort(s)) :
|
expr * a = negative ? ctx->fpautil().mk_nzero(to_sort(s)) :
|
||||||
ctx->fpautil().mk_pzero(to_sort(s));
|
ctx->fpautil().mk_pzero(to_sort(s));
|
||||||
ctx->save_ast_trail(a);
|
ctx->save_ast_trail(a);
|
||||||
RETURN_Z3(of_expr(a));
|
RETURN_Z3(of_expr(a));
|
||||||
Z3_CATCH_RETURN(nullptr);
|
Z3_CATCH_RETURN(nullptr);
|
||||||
|
|
@ -338,7 +338,7 @@ extern "C" {
|
||||||
Z3_CATCH_RETURN(nullptr);
|
Z3_CATCH_RETURN(nullptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_ast Z3_API Z3_mk_fpa_numeral_int_uint(Z3_context c, Z3_bool sgn, signed exp, unsigned sig, Z3_sort ty) {
|
Z3_ast Z3_API Z3_mk_fpa_numeral_int_uint(Z3_context c, bool sgn, signed exp, unsigned 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();
|
||||||
|
|
@ -351,14 +351,14 @@ extern "C" {
|
||||||
ctx->fpautil().fm().set(tmp,
|
ctx->fpautil().fm().set(tmp,
|
||||||
ctx->fpautil().get_ebits(to_sort(ty)),
|
ctx->fpautil().get_ebits(to_sort(ty)),
|
||||||
ctx->fpautil().get_sbits(to_sort(ty)),
|
ctx->fpautil().get_sbits(to_sort(ty)),
|
||||||
sgn != 0, exp, sig);
|
sgn, exp, sig);
|
||||||
expr * a = ctx->fpautil().mk_value(tmp);
|
expr * a = ctx->fpautil().mk_value(tmp);
|
||||||
ctx->save_ast_trail(a);
|
ctx->save_ast_trail(a);
|
||||||
RETURN_Z3(of_expr(a));
|
RETURN_Z3(of_expr(a));
|
||||||
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_t exp, uint64_t sig, Z3_sort ty) {
|
Z3_ast Z3_API Z3_mk_fpa_numeral_int64_uint64(Z3_context c, 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();
|
||||||
|
|
@ -371,7 +371,7 @@ extern "C" {
|
||||||
ctx->fpautil().fm().set(tmp,
|
ctx->fpautil().fm().set(tmp,
|
||||||
ctx->fpautil().get_ebits(to_sort(ty)),
|
ctx->fpautil().get_ebits(to_sort(ty)),
|
||||||
ctx->fpautil().get_sbits(to_sort(ty)),
|
ctx->fpautil().get_sbits(to_sort(ty)),
|
||||||
sgn != 0, exp, sig);
|
sgn, exp, sig);
|
||||||
expr * a = ctx->fpautil().mk_value(tmp);
|
expr * a = ctx->fpautil().mk_value(tmp);
|
||||||
ctx->save_ast_trail(a);
|
ctx->save_ast_trail(a);
|
||||||
RETURN_Z3(of_expr(a));
|
RETURN_Z3(of_expr(a));
|
||||||
|
|
@ -905,7 +905,7 @@ extern "C" {
|
||||||
Z3_CATCH_RETURN(0);
|
Z3_CATCH_RETURN(0);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_fpa_get_numeral_sign(Z3_context c, Z3_ast t, int * sgn) {
|
bool Z3_API Z3_fpa_get_numeral_sign(Z3_context c, Z3_ast t, int * sgn) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_fpa_get_numeral_sign(c, t, sgn);
|
LOG_Z3_fpa_get_numeral_sign(c, t, sgn);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
|
|
@ -913,7 +913,7 @@ extern "C" {
|
||||||
CHECK_VALID_AST(t, 0);
|
CHECK_VALID_AST(t, 0);
|
||||||
if (sgn == nullptr) {
|
if (sgn == nullptr) {
|
||||||
SET_ERROR_CODE(Z3_INVALID_ARG, "sign cannot be a nullpointer");
|
SET_ERROR_CODE(Z3_INVALID_ARG, "sign cannot be a nullpointer");
|
||||||
return 0;
|
return false;
|
||||||
}
|
}
|
||||||
ast_manager & m = mk_c(c)->m();
|
ast_manager & m = mk_c(c)->m();
|
||||||
mpf_manager & mpfm = mk_c(c)->fpautil().fm();
|
mpf_manager & mpfm = mk_c(c)->fpautil().fm();
|
||||||
|
|
@ -922,13 +922,13 @@ extern "C" {
|
||||||
expr * e = to_expr(t);
|
expr * e = to_expr(t);
|
||||||
if (!is_app(e) || is_app_of(e, fid, OP_FPA_NAN) || !is_fp(c, t)) {
|
if (!is_app(e) || is_app_of(e, fid, OP_FPA_NAN) || !is_fp(c, t)) {
|
||||||
SET_ERROR_CODE(Z3_INVALID_ARG, "invalid expression argument, expecting a valid fp, not a NaN");
|
SET_ERROR_CODE(Z3_INVALID_ARG, "invalid expression argument, expecting a valid fp, not a NaN");
|
||||||
return 0;
|
return false;
|
||||||
}
|
}
|
||||||
scoped_mpf val(mpfm);
|
scoped_mpf val(mpfm);
|
||||||
bool r = plugin->is_numeral(to_expr(t), val);
|
bool r = plugin->is_numeral(to_expr(t), val);
|
||||||
if (!r || mpfm.is_nan(val)) {
|
if (!r || mpfm.is_nan(val)) {
|
||||||
SET_ERROR_CODE(Z3_INVALID_ARG, "invalid expression argument, expecting a valid fp, not a NaN");
|
SET_ERROR_CODE(Z3_INVALID_ARG, "invalid expression argument, expecting a valid fp, not a NaN");
|
||||||
return 0;
|
return false;
|
||||||
}
|
}
|
||||||
*sgn = mpfm.sgn(val);
|
*sgn = mpfm.sgn(val);
|
||||||
return r;
|
return r;
|
||||||
|
|
@ -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_t * n) {
|
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();
|
||||||
|
|
@ -1043,7 +1043,7 @@ extern "C" {
|
||||||
CHECK_VALID_AST(t, 0);
|
CHECK_VALID_AST(t, 0);
|
||||||
if (n == nullptr) {
|
if (n == nullptr) {
|
||||||
SET_ERROR_CODE(Z3_INVALID_ARG, "invalid nullptr argument");
|
SET_ERROR_CODE(Z3_INVALID_ARG, "invalid nullptr argument");
|
||||||
return 0;
|
return false;
|
||||||
}
|
}
|
||||||
ast_manager & m = mk_c(c)->m();
|
ast_manager & m = mk_c(c)->m();
|
||||||
mpf_manager & mpfm = mk_c(c)->fpautil().fm();
|
mpf_manager & mpfm = mk_c(c)->fpautil().fm();
|
||||||
|
|
@ -1055,7 +1055,7 @@ extern "C" {
|
||||||
if (!is_app(e) || is_app_of(e, fid, OP_FPA_NAN) || !is_fp(c, t)) {
|
if (!is_app(e) || is_app_of(e, fid, OP_FPA_NAN) || !is_fp(c, t)) {
|
||||||
SET_ERROR_CODE(Z3_INVALID_ARG, "invalid expression argument, expecting a valid fp, not a NaN");
|
SET_ERROR_CODE(Z3_INVALID_ARG, "invalid expression argument, expecting a valid fp, not a NaN");
|
||||||
*n = 0;
|
*n = 0;
|
||||||
return 0;
|
return false;
|
||||||
}
|
}
|
||||||
scoped_mpf val(mpfm);
|
scoped_mpf val(mpfm);
|
||||||
bool r = plugin->is_numeral(e, val);
|
bool r = plugin->is_numeral(e, val);
|
||||||
|
|
@ -1065,14 +1065,14 @@ extern "C" {
|
||||||
!mpzm.is_uint64(z)) {
|
!mpzm.is_uint64(z)) {
|
||||||
SET_ERROR_CODE(Z3_INVALID_ARG, "invalid expression argument, expecting a valid fp, not a NaN");
|
SET_ERROR_CODE(Z3_INVALID_ARG, "invalid expression argument, expecting a valid fp, not a NaN");
|
||||||
*n = 0;
|
*n = 0;
|
||||||
return 0;
|
return false;
|
||||||
}
|
}
|
||||||
*n = mpzm.get_uint64(z);
|
*n = mpzm.get_uint64(z);
|
||||||
return 1;
|
return true;
|
||||||
Z3_CATCH_RETURN(0);
|
Z3_CATCH_RETURN(0);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_string Z3_API Z3_fpa_get_numeral_exponent_string(Z3_context c, Z3_ast t, Z3_bool biased) {
|
Z3_string Z3_API Z3_fpa_get_numeral_exponent_string(Z3_context c, Z3_ast t, bool biased) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_fpa_get_numeral_exponent_string(c, t, biased);
|
LOG_Z3_fpa_get_numeral_exponent_string(c, t, biased);
|
||||||
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_t * n, Z3_bool biased) {
|
bool Z3_API Z3_fpa_get_numeral_exponent_int64(Z3_context c, Z3_ast t, int64_t * n, 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();
|
||||||
|
|
@ -1121,7 +1121,7 @@ extern "C" {
|
||||||
CHECK_VALID_AST(t, 0);
|
CHECK_VALID_AST(t, 0);
|
||||||
if (n == nullptr) {
|
if (n == nullptr) {
|
||||||
SET_ERROR_CODE(Z3_INVALID_ARG, "invalid null argument");
|
SET_ERROR_CODE(Z3_INVALID_ARG, "invalid null argument");
|
||||||
return 0;
|
return false;
|
||||||
}
|
}
|
||||||
ast_manager & m = mk_c(c)->m();
|
ast_manager & m = mk_c(c)->m();
|
||||||
mpf_manager & mpfm = mk_c(c)->fpautil().fm();
|
mpf_manager & mpfm = mk_c(c)->fpautil().fm();
|
||||||
|
|
@ -1132,14 +1132,14 @@ extern "C" {
|
||||||
if (!is_app(e) || is_app_of(e, fid, OP_FPA_NAN) || !is_fp(c, t)) {
|
if (!is_app(e) || is_app_of(e, fid, OP_FPA_NAN) || !is_fp(c, t)) {
|
||||||
SET_ERROR_CODE(Z3_INVALID_ARG, "invalid expression argument, expecting a valid fp, not a NaN");
|
SET_ERROR_CODE(Z3_INVALID_ARG, "invalid expression argument, expecting a valid fp, not a NaN");
|
||||||
*n = 0;
|
*n = 0;
|
||||||
return 0;
|
return false;
|
||||||
}
|
}
|
||||||
scoped_mpf val(mpfm);
|
scoped_mpf val(mpfm);
|
||||||
bool r = plugin->is_numeral(e, val);
|
bool r = plugin->is_numeral(e, val);
|
||||||
if (!r || !(mpfm.is_normal(val) || mpfm.is_denormal(val) || mpfm.is_zero(val) || mpfm.is_inf(val))) {
|
if (!r || !(mpfm.is_normal(val) || mpfm.is_denormal(val) || mpfm.is_zero(val) || mpfm.is_inf(val))) {
|
||||||
SET_ERROR_CODE(Z3_INVALID_ARG, "invalid expression argument, expecting a valid fp, not a NaN");
|
SET_ERROR_CODE(Z3_INVALID_ARG, "invalid expression argument, expecting a valid fp, not a NaN");
|
||||||
*n = 0;
|
*n = 0;
|
||||||
return 0;
|
return false;
|
||||||
}
|
}
|
||||||
unsigned ebits = val.get().get_ebits();
|
unsigned ebits = val.get().get_ebits();
|
||||||
if (biased) {
|
if (biased) {
|
||||||
|
|
@ -1153,11 +1153,11 @@ extern "C" {
|
||||||
mpfm.is_denormal(val) ? mpfm.mk_min_exp(ebits) :
|
mpfm.is_denormal(val) ? mpfm.mk_min_exp(ebits) :
|
||||||
mpfm.exp(val);
|
mpfm.exp(val);
|
||||||
}
|
}
|
||||||
return 1;
|
return true;
|
||||||
Z3_CATCH_RETURN(0);
|
Z3_CATCH_RETURN(0);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_ast Z3_API Z3_fpa_get_numeral_exponent_bv(Z3_context c, Z3_ast t, Z3_bool biased) {
|
Z3_ast Z3_API Z3_fpa_get_numeral_exponent_bv(Z3_context c, Z3_ast t, bool biased) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_fpa_get_numeral_exponent_bv(c, t, biased);
|
LOG_Z3_fpa_get_numeral_exponent_bv(c, t, biased);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
|
|
@ -1232,7 +1232,7 @@ extern "C" {
|
||||||
Z3_CATCH_RETURN(nullptr);
|
Z3_CATCH_RETURN(nullptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_fpa_is_numeral_nan(Z3_context c, Z3_ast t) {
|
bool Z3_API Z3_fpa_is_numeral_nan(Z3_context c, Z3_ast t) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_fpa_is_numeral_nan(c, t);
|
LOG_Z3_fpa_is_numeral_nan(c, t);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
|
|
@ -1240,13 +1240,13 @@ extern "C" {
|
||||||
fpa_util & fu = ctx->fpautil();
|
fpa_util & fu = ctx->fpautil();
|
||||||
if (!is_expr(t) || !fu.is_numeral(to_expr(t))) {
|
if (!is_expr(t) || !fu.is_numeral(to_expr(t))) {
|
||||||
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
||||||
return 0;
|
return false;
|
||||||
}
|
}
|
||||||
return fu.is_nan(to_expr(t));
|
return fu.is_nan(to_expr(t));
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_fpa_is_numeral_inf(Z3_context c, Z3_ast t) {
|
bool Z3_API Z3_fpa_is_numeral_inf(Z3_context c, Z3_ast t) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_fpa_is_numeral_inf(c, t);
|
LOG_Z3_fpa_is_numeral_inf(c, t);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
|
|
@ -1254,13 +1254,13 @@ extern "C" {
|
||||||
fpa_util & fu = ctx->fpautil();
|
fpa_util & fu = ctx->fpautil();
|
||||||
if (!is_expr(t) || !fu.is_numeral(to_expr(t))) {
|
if (!is_expr(t) || !fu.is_numeral(to_expr(t))) {
|
||||||
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
||||||
return 0;
|
return false;
|
||||||
}
|
}
|
||||||
return fu.is_inf(to_expr(t));
|
return fu.is_inf(to_expr(t));
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_fpa_is_numeral_zero(Z3_context c, Z3_ast t) {
|
bool Z3_API Z3_fpa_is_numeral_zero(Z3_context c, Z3_ast t) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_fpa_is_numeral_zero(c, t);
|
LOG_Z3_fpa_is_numeral_zero(c, t);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
|
|
@ -1268,13 +1268,13 @@ extern "C" {
|
||||||
fpa_util & fu = ctx->fpautil();
|
fpa_util & fu = ctx->fpautil();
|
||||||
if (!is_expr(t) || !fu.is_numeral(to_expr(t))) {
|
if (!is_expr(t) || !fu.is_numeral(to_expr(t))) {
|
||||||
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
||||||
return 0;
|
return false;
|
||||||
}
|
}
|
||||||
return fu.is_zero(to_expr(t));
|
return fu.is_zero(to_expr(t));
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_fpa_is_numeral_normal(Z3_context c, Z3_ast t) {
|
bool Z3_API Z3_fpa_is_numeral_normal(Z3_context c, Z3_ast t) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_fpa_is_numeral_normal(c, t);
|
LOG_Z3_fpa_is_numeral_normal(c, t);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
|
|
@ -1282,13 +1282,13 @@ extern "C" {
|
||||||
fpa_util & fu = ctx->fpautil();
|
fpa_util & fu = ctx->fpautil();
|
||||||
if (!is_expr(t) || !fu.is_numeral(to_expr(t))) {
|
if (!is_expr(t) || !fu.is_numeral(to_expr(t))) {
|
||||||
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
||||||
return 0;
|
return false;
|
||||||
}
|
}
|
||||||
return fu.is_normal(to_expr(t));
|
return fu.is_normal(to_expr(t));
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_fpa_is_numeral_subnormal(Z3_context c, Z3_ast t) {
|
bool Z3_API Z3_fpa_is_numeral_subnormal(Z3_context c, Z3_ast t) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_fpa_is_numeral_subnormal(c, t);
|
LOG_Z3_fpa_is_numeral_subnormal(c, t);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
|
|
@ -1296,13 +1296,13 @@ extern "C" {
|
||||||
fpa_util & fu = ctx->fpautil();
|
fpa_util & fu = ctx->fpautil();
|
||||||
if (!is_expr(t) || !fu.is_numeral(to_expr(t))) {
|
if (!is_expr(t) || !fu.is_numeral(to_expr(t))) {
|
||||||
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
||||||
return 0;
|
return false;
|
||||||
}
|
}
|
||||||
return fu.is_subnormal(to_expr(t));
|
return fu.is_subnormal(to_expr(t));
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_fpa_is_numeral_positive(Z3_context c, Z3_ast t) {
|
bool Z3_API Z3_fpa_is_numeral_positive(Z3_context c, Z3_ast t) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_fpa_is_numeral_positive(c, t);
|
LOG_Z3_fpa_is_numeral_positive(c, t);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
|
|
@ -1310,13 +1310,13 @@ extern "C" {
|
||||||
fpa_util & fu = ctx->fpautil();
|
fpa_util & fu = ctx->fpautil();
|
||||||
if (!is_expr(t) || !fu.is_numeral(to_expr(t))) {
|
if (!is_expr(t) || !fu.is_numeral(to_expr(t))) {
|
||||||
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
||||||
return 0;
|
return false;
|
||||||
}
|
}
|
||||||
return fu.is_positive(to_expr(t));
|
return fu.is_positive(to_expr(t));
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_fpa_is_numeral_negative(Z3_context c, Z3_ast t) {
|
bool Z3_API Z3_fpa_is_numeral_negative(Z3_context c, Z3_ast t) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_fpa_is_numeral_negative(c, t);
|
LOG_Z3_fpa_is_numeral_negative(c, t);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
|
|
@ -1324,10 +1324,10 @@ extern "C" {
|
||||||
fpa_util & fu = ctx->fpautil();
|
fpa_util & fu = ctx->fpautil();
|
||||||
if (!is_expr(t) || !fu.is_numeral(to_expr(t))) {
|
if (!is_expr(t) || !fu.is_numeral(to_expr(t))) {
|
||||||
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
||||||
return 0;
|
return false;
|
||||||
}
|
}
|
||||||
return fu.is_negative(to_expr(t));
|
return fu.is_negative(to_expr(t));
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
};
|
};
|
||||||
|
|
|
||||||
|
|
@ -25,7 +25,7 @@ Revision History:
|
||||||
|
|
||||||
extern "C" {
|
extern "C" {
|
||||||
|
|
||||||
Z3_goal Z3_API Z3_mk_goal(Z3_context c, Z3_bool models, Z3_bool unsat_cores, Z3_bool proofs) {
|
Z3_goal Z3_API Z3_mk_goal(Z3_context c, bool models, bool unsat_cores, bool proofs) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_mk_goal(c, models, unsat_cores, proofs);
|
LOG_Z3_mk_goal(c, models, unsat_cores, proofs);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
|
|
@ -82,12 +82,12 @@ extern "C" {
|
||||||
Z3_CATCH;
|
Z3_CATCH;
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_goal_inconsistent(Z3_context c, Z3_goal g) {
|
bool Z3_API Z3_goal_inconsistent(Z3_context c, Z3_goal g) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_goal_inconsistent(c, g);
|
LOG_Z3_goal_inconsistent(c, g);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
return to_goal_ref(g)->inconsistent();
|
return to_goal_ref(g)->inconsistent();
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
unsigned Z3_API Z3_goal_depth(Z3_context c, Z3_goal g) {
|
unsigned Z3_API Z3_goal_depth(Z3_context c, Z3_goal g) {
|
||||||
|
|
@ -136,20 +136,20 @@ extern "C" {
|
||||||
Z3_CATCH_RETURN(0);
|
Z3_CATCH_RETURN(0);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_goal_is_decided_sat(Z3_context c, Z3_goal g) {
|
bool Z3_API Z3_goal_is_decided_sat(Z3_context c, Z3_goal g) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_goal_is_decided_sat(c, g);
|
LOG_Z3_goal_is_decided_sat(c, g);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
return to_goal_ref(g)->is_decided_sat();
|
return to_goal_ref(g)->is_decided_sat();
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_goal_is_decided_unsat(Z3_context c, Z3_goal g) {
|
bool Z3_API Z3_goal_is_decided_unsat(Z3_context c, Z3_goal g) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_goal_is_decided_unsat(c, g);
|
LOG_Z3_goal_is_decided_unsat(c, g);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
return to_goal_ref(g)->is_decided_unsat();
|
return to_goal_ref(g)->is_decided_unsat();
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_model Z3_API Z3_goal_convert_model(Z3_context c, Z3_goal g, Z3_model m) {
|
Z3_model Z3_API Z3_goal_convert_model(Z3_context c, Z3_goal g, Z3_model m) {
|
||||||
|
|
@ -163,7 +163,7 @@ extern "C" {
|
||||||
if (to_goal_ref(g)->mc())
|
if (to_goal_ref(g)->mc())
|
||||||
(*to_goal_ref(g)->mc())(m_ref->m_model);
|
(*to_goal_ref(g)->mc())(m_ref->m_model);
|
||||||
RETURN_Z3(of_model(m_ref));
|
RETURN_Z3(of_model(m_ref));
|
||||||
Z3_CATCH_RETURN(0);
|
Z3_CATCH_RETURN(nullptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_goal Z3_API Z3_goal_translate(Z3_context c, Z3_goal g, Z3_context target) {
|
Z3_goal Z3_API Z3_goal_translate(Z3_context c, Z3_goal g, Z3_context target) {
|
||||||
|
|
|
||||||
|
|
@ -19,7 +19,7 @@ Revision History:
|
||||||
#include "api/z3.h"
|
#include "api/z3.h"
|
||||||
#include "api/api_log_macros.h"
|
#include "api/api_log_macros.h"
|
||||||
#include "util/util.h"
|
#include "util/util.h"
|
||||||
#include "util/version.h"
|
#include "util/z3_version.h"
|
||||||
|
|
||||||
std::ostream * g_z3_log = nullptr;
|
std::ostream * g_z3_log = nullptr;
|
||||||
bool g_z3_log_enabled = false;
|
bool g_z3_log_enabled = false;
|
||||||
|
|
@ -33,8 +33,8 @@ extern "C" {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_open_log(Z3_string filename) {
|
bool Z3_API Z3_open_log(Z3_string filename) {
|
||||||
Z3_bool res = Z3_TRUE;
|
bool res = true;
|
||||||
|
|
||||||
#ifdef Z3_LOG_SYNC
|
#ifdef Z3_LOG_SYNC
|
||||||
#pragma omp critical (z3_log)
|
#pragma omp critical (z3_log)
|
||||||
|
|
@ -46,7 +46,7 @@ extern "C" {
|
||||||
if (g_z3_log->bad() || g_z3_log->fail()) {
|
if (g_z3_log->bad() || g_z3_log->fail()) {
|
||||||
dealloc(g_z3_log);
|
dealloc(g_z3_log);
|
||||||
g_z3_log = nullptr;
|
g_z3_log = nullptr;
|
||||||
res = Z3_FALSE;
|
res = false;
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
*g_z3_log << "V \"" << Z3_MAJOR_VERSION << "." << Z3_MINOR_VERSION << "." << Z3_BUILD_NUMBER << "." << Z3_REVISION_NUMBER << " " << __DATE__ << "\"\n";
|
*g_z3_log << "V \"" << Z3_MAJOR_VERSION << "." << Z3_MINOR_VERSION << "." << Z3_BUILD_NUMBER << "." << Z3_REVISION_NUMBER << " " << __DATE__ << "\"\n";
|
||||||
|
|
|
||||||
|
|
@ -75,16 +75,12 @@ extern "C" {
|
||||||
Z3_CATCH_RETURN(nullptr);
|
Z3_CATCH_RETURN(nullptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_model_has_interp(Z3_context c, Z3_model m, Z3_func_decl a) {
|
bool Z3_API Z3_model_has_interp(Z3_context c, Z3_model m, Z3_func_decl a) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_model_has_interp(c, m, a);
|
LOG_Z3_model_has_interp(c, m, a);
|
||||||
CHECK_NON_NULL(m, 0);
|
CHECK_NON_NULL(m, 0);
|
||||||
if (to_model_ref(m)->has_interpretation(to_func_decl(a))) {
|
return to_model_ref(m)->has_interpretation(to_func_decl(a));
|
||||||
return Z3_TRUE;
|
Z3_CATCH_RETURN(false);
|
||||||
} else {
|
|
||||||
return Z3_FALSE;
|
|
||||||
}
|
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_func_interp Z3_API Z3_model_get_func_interp(Z3_context c, Z3_model m, Z3_func_decl f) {
|
Z3_func_interp Z3_API Z3_model_get_func_interp(Z3_context c, Z3_model m, Z3_func_decl f) {
|
||||||
|
|
@ -157,20 +153,23 @@ extern "C" {
|
||||||
Z3_CATCH_RETURN(nullptr);
|
Z3_CATCH_RETURN(nullptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_model_eval(Z3_context c, Z3_model m, Z3_ast t, Z3_bool model_completion, Z3_ast * v) {
|
bool Z3_API Z3_model_eval(Z3_context c, Z3_model m, Z3_ast t, bool model_completion, Z3_ast * v) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_model_eval(c, m, t, model_completion, v);
|
LOG_Z3_model_eval(c, m, t, model_completion, v);
|
||||||
if (v) *v = nullptr;
|
if (v) *v = nullptr;
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
CHECK_NON_NULL(m, Z3_FALSE);
|
CHECK_NON_NULL(m, false);
|
||||||
CHECK_IS_EXPR(t, Z3_FALSE);
|
CHECK_IS_EXPR(t, false);
|
||||||
model * _m = to_model_ref(m);
|
model * _m = to_model_ref(m);
|
||||||
expr_ref result(mk_c(c)->m());
|
params_ref p;
|
||||||
model::scoped_model_completion _scm(*_m, model_completion == Z3_TRUE);
|
ast_manager& mgr = mk_c(c)->m();
|
||||||
|
_m->set_solver(alloc(api::seq_expr_solver, mgr, p));
|
||||||
|
expr_ref result(mgr);
|
||||||
|
model::scoped_model_completion _scm(*_m, model_completion);
|
||||||
result = (*_m)(to_expr(t));
|
result = (*_m)(to_expr(t));
|
||||||
mk_c(c)->save_ast_trail(result.get());
|
mk_c(c)->save_ast_trail(result.get());
|
||||||
*v = of_ast(result.get());
|
*v = of_ast(result.get());
|
||||||
RETURN_Z3_model_eval Z3_TRUE;
|
RETURN_Z3_model_eval true;
|
||||||
Z3_CATCH_RETURN(0);
|
Z3_CATCH_RETURN(0);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -225,12 +224,12 @@ extern "C" {
|
||||||
Z3_CATCH_RETURN(nullptr);
|
Z3_CATCH_RETURN(nullptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_is_as_array(Z3_context c, Z3_ast a) {
|
bool Z3_API Z3_is_as_array(Z3_context c, Z3_ast a) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_is_as_array(c, a);
|
LOG_Z3_is_as_array(c, a);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
return a && is_expr(to_ast(a)) && is_app_of(to_expr(a), mk_c(c)->get_array_fid(), OP_AS_ARRAY);
|
return a && is_expr(to_ast(a)) && is_app_of(to_expr(a), mk_c(c)->get_array_fid(), OP_AS_ARRAY);
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_func_decl Z3_API Z3_get_as_array_func_decl(Z3_context c, Z3_ast a) {
|
Z3_func_decl Z3_API Z3_get_as_array_func_decl(Z3_context c, Z3_ast a) {
|
||||||
|
|
@ -472,7 +471,7 @@ extern "C" {
|
||||||
model_smt2_pp(buffer, mk_c(c)->m(), *(to_model_ref(m)), 0);
|
model_smt2_pp(buffer, mk_c(c)->m(), *(to_model_ref(m)), 0);
|
||||||
// Hack for removing the trailing '\n'
|
// Hack for removing the trailing '\n'
|
||||||
result = buffer.str();
|
result = buffer.str();
|
||||||
if (result.size() != 0)
|
if (!result.empty())
|
||||||
result.resize(result.size()-1);
|
result.resize(result.size()-1);
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
|
|
|
||||||
|
|
@ -142,11 +142,11 @@ extern "C" {
|
||||||
Z3_CATCH_RETURN(nullptr);
|
Z3_CATCH_RETURN(nullptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_is_numeral_ast(Z3_context c, Z3_ast a) {
|
bool Z3_API Z3_is_numeral_ast(Z3_context c, Z3_ast a) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_is_numeral_ast(c, a);
|
LOG_Z3_is_numeral_ast(c, a);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
CHECK_IS_EXPR(a, Z3_FALSE);
|
CHECK_IS_EXPR(a, false);
|
||||||
expr* e = to_expr(a);
|
expr* e = to_expr(a);
|
||||||
return
|
return
|
||||||
mk_c(c)->autil().is_numeral(e) ||
|
mk_c(c)->autil().is_numeral(e) ||
|
||||||
|
|
@ -154,29 +154,29 @@ extern "C" {
|
||||||
mk_c(c)->fpautil().is_numeral(e) ||
|
mk_c(c)->fpautil().is_numeral(e) ||
|
||||||
mk_c(c)->fpautil().is_rm_numeral(e) ||
|
mk_c(c)->fpautil().is_rm_numeral(e) ||
|
||||||
mk_c(c)->datalog_util().is_numeral_ext(e);
|
mk_c(c)->datalog_util().is_numeral_ext(e);
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_get_numeral_rational(Z3_context c, Z3_ast a, rational& r) {
|
bool Z3_API Z3_get_numeral_rational(Z3_context c, Z3_ast a, rational& r) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
// This function is not part of the public API
|
// This function is not part of the public API
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
CHECK_IS_EXPR(a, Z3_FALSE);
|
CHECK_IS_EXPR(a, false);
|
||||||
expr* e = to_expr(a);
|
expr* e = to_expr(a);
|
||||||
if (mk_c(c)->autil().is_numeral(e, r)) {
|
if (mk_c(c)->autil().is_numeral(e, r)) {
|
||||||
return Z3_TRUE;
|
return true;
|
||||||
}
|
}
|
||||||
unsigned bv_size;
|
unsigned bv_size;
|
||||||
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 true;
|
||||||
}
|
}
|
||||||
uint64_t 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 true;
|
||||||
}
|
}
|
||||||
return Z3_FALSE;
|
return false;
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -187,8 +187,8 @@ extern "C" {
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
CHECK_IS_EXPR(a, "");
|
CHECK_IS_EXPR(a, "");
|
||||||
rational r;
|
rational r;
|
||||||
Z3_bool ok = Z3_get_numeral_rational(c, a, r);
|
bool ok = Z3_get_numeral_rational(c, a, r);
|
||||||
if (ok == Z3_TRUE) {
|
if (ok) {
|
||||||
return mk_c(c)->mk_external_string(r.to_string());
|
return mk_c(c)->mk_external_string(r.to_string());
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
|
|
@ -198,19 +198,19 @@ extern "C" {
|
||||||
mpf_rounding_mode rm;
|
mpf_rounding_mode rm;
|
||||||
if (mk_c(c)->fpautil().is_rm_numeral(to_expr(a), rm)) {
|
if (mk_c(c)->fpautil().is_rm_numeral(to_expr(a), rm)) {
|
||||||
switch (rm) {
|
switch (rm) {
|
||||||
case OP_FPA_RM_NEAREST_TIES_TO_EVEN:
|
case MPF_ROUND_NEAREST_TEVEN:
|
||||||
return mk_c(c)->mk_external_string("roundNearestTiesToEven");
|
return mk_c(c)->mk_external_string("roundNearestTiesToEven");
|
||||||
break;
|
break;
|
||||||
case OP_FPA_RM_NEAREST_TIES_TO_AWAY:
|
case MPF_ROUND_NEAREST_TAWAY:
|
||||||
return mk_c(c)->mk_external_string("roundNearestTiesToAway");
|
return mk_c(c)->mk_external_string("roundNearestTiesToAway");
|
||||||
break;
|
break;
|
||||||
case OP_FPA_RM_TOWARD_POSITIVE:
|
case MPF_ROUND_TOWARD_POSITIVE:
|
||||||
return mk_c(c)->mk_external_string("roundTowardPositive");
|
return mk_c(c)->mk_external_string("roundTowardPositive");
|
||||||
break;
|
break;
|
||||||
case OP_FPA_RM_TOWARD_NEGATIVE:
|
case MPF_ROUND_TOWARD_NEGATIVE:
|
||||||
return mk_c(c)->mk_external_string("roundTowardNegative");
|
return mk_c(c)->mk_external_string("roundTowardNegative");
|
||||||
break;
|
break;
|
||||||
case OP_FPA_RM_TOWARD_ZERO:
|
case MPF_ROUND_TOWARD_ZERO:
|
||||||
default:
|
default:
|
||||||
return mk_c(c)->mk_external_string("roundTowardZero");
|
return mk_c(c)->mk_external_string("roundTowardZero");
|
||||||
break;
|
break;
|
||||||
|
|
@ -227,6 +227,11 @@ extern "C" {
|
||||||
Z3_CATCH_RETURN("");
|
Z3_CATCH_RETURN("");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
double Z3_API Z3_get_numeral_double(Z3_context c, Z3_ast a) {
|
||||||
|
Z3_string s = Z3_get_numeral_decimal_string(c, a, 12);
|
||||||
|
return std::stod(std::string(s));
|
||||||
|
}
|
||||||
|
|
||||||
Z3_string Z3_API Z3_get_numeral_decimal_string(Z3_context c, Z3_ast a, unsigned precision) {
|
Z3_string Z3_API Z3_get_numeral_decimal_string(Z3_context c, Z3_ast a, unsigned precision) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_get_numeral_decimal_string(c, a, precision);
|
LOG_Z3_get_numeral_decimal_string(c, a, precision);
|
||||||
|
|
@ -247,8 +252,8 @@ extern "C" {
|
||||||
am.display_decimal(buffer, n, precision);
|
am.display_decimal(buffer, n, precision);
|
||||||
return mk_c(c)->mk_external_string(buffer.str());
|
return mk_c(c)->mk_external_string(buffer.str());
|
||||||
}
|
}
|
||||||
Z3_bool ok = Z3_get_numeral_rational(c, a, r);
|
bool ok = Z3_get_numeral_rational(c, a, r);
|
||||||
if (ok == Z3_TRUE) {
|
if (ok) {
|
||||||
return mk_c(c)->mk_external_string(r.to_string());
|
return mk_c(c)->mk_external_string(r.to_string());
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
|
|
@ -258,124 +263,124 @@ extern "C" {
|
||||||
Z3_CATCH_RETURN("");
|
Z3_CATCH_RETURN("");
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_get_numeral_small(Z3_context c, Z3_ast a, int64_t* num, int64_t* den) {
|
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);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
CHECK_IS_EXPR(a, Z3_FALSE);
|
CHECK_IS_EXPR(a, false);
|
||||||
rational r;
|
rational r;
|
||||||
Z3_bool ok = Z3_get_numeral_rational(c, a, r);
|
bool ok = Z3_get_numeral_rational(c, a, r);
|
||||||
if (ok == Z3_TRUE) {
|
if (ok) {
|
||||||
rational n = numerator(r);
|
rational n = numerator(r);
|
||||||
rational d = denominator(r);
|
rational d = denominator(r);
|
||||||
if (n.is_int64() && d.is_int64()) {
|
if (n.is_int64() && d.is_int64()) {
|
||||||
*num = n.get_int64();
|
*num = n.get_int64();
|
||||||
*den = d.get_int64();
|
*den = d.get_int64();
|
||||||
return Z3_TRUE;
|
return true;
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
return Z3_FALSE;
|
return false;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
||||||
return Z3_FALSE;
|
return false;
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_get_numeral_int(Z3_context c, Z3_ast v, int* i) {
|
bool Z3_API Z3_get_numeral_int(Z3_context c, Z3_ast v, int* i) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
// This function invokes Z3_get_numeral_int64, but it is still ok to add LOG command here because it does not return a Z3 object.
|
// This function invokes Z3_get_numeral_int64, but it is still ok to add LOG command here because it does not return a Z3 object.
|
||||||
LOG_Z3_get_numeral_int(c, v, i);
|
LOG_Z3_get_numeral_int(c, v, i);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
CHECK_IS_EXPR(v, Z3_FALSE);
|
CHECK_IS_EXPR(v, false);
|
||||||
if (!i) {
|
if (!i) {
|
||||||
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
||||||
return Z3_FALSE;
|
return false;
|
||||||
}
|
}
|
||||||
int64_t 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 true;
|
||||||
}
|
}
|
||||||
return Z3_FALSE;
|
return false;
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_get_numeral_uint(Z3_context c, Z3_ast v, unsigned* u) {
|
bool Z3_API Z3_get_numeral_uint(Z3_context c, Z3_ast v, unsigned* u) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
// This function invokes Z3_get_numeral_uint64, but it is still ok to add LOG command here because it does not return a Z3 object.
|
// This function invokes Z3_get_numeral_uint64, but it is still ok to add LOG command here because it does not return a Z3 object.
|
||||||
LOG_Z3_get_numeral_uint(c, v, u);
|
LOG_Z3_get_numeral_uint(c, v, u);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
CHECK_IS_EXPR(v, Z3_FALSE);
|
CHECK_IS_EXPR(v, false);
|
||||||
if (!u) {
|
if (!u) {
|
||||||
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
||||||
return Z3_FALSE;
|
return false;
|
||||||
}
|
}
|
||||||
uint64_t 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 true;
|
||||||
}
|
}
|
||||||
return Z3_FALSE;
|
return false;
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_get_numeral_uint64(Z3_context c, Z3_ast v, uint64_t* u) {
|
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);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
CHECK_IS_EXPR(v, Z3_FALSE);
|
CHECK_IS_EXPR(v, false);
|
||||||
if (!u) {
|
if (!u) {
|
||||||
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
||||||
return Z3_FALSE;
|
return false;
|
||||||
}
|
}
|
||||||
rational r;
|
rational r;
|
||||||
Z3_bool ok = Z3_get_numeral_rational(c, v, r);
|
bool ok = Z3_get_numeral_rational(c, v, r);
|
||||||
SASSERT(u);
|
SASSERT(u);
|
||||||
if (ok == Z3_TRUE && r.is_uint64()) {
|
if (ok && r.is_uint64()) {
|
||||||
*u = r.get_uint64();
|
*u = r.get_uint64();
|
||||||
return ok;
|
return ok;
|
||||||
}
|
}
|
||||||
return Z3_FALSE;
|
return false;
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_get_numeral_int64(Z3_context c, Z3_ast v, int64_t* i) {
|
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);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
CHECK_IS_EXPR(v, Z3_FALSE);
|
CHECK_IS_EXPR(v, false);
|
||||||
if (!i) {
|
if (!i) {
|
||||||
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
||||||
return Z3_FALSE;
|
return false;
|
||||||
}
|
}
|
||||||
rational r;
|
rational r;
|
||||||
Z3_bool ok = Z3_get_numeral_rational(c, v, r);
|
bool ok = Z3_get_numeral_rational(c, v, r);
|
||||||
if (ok == Z3_TRUE && r.is_int64()) {
|
if (ok && r.is_int64()) {
|
||||||
*i = r.get_int64();
|
*i = r.get_int64();
|
||||||
return ok;
|
return ok;
|
||||||
}
|
}
|
||||||
return Z3_FALSE;
|
return false;
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_get_numeral_rational_int64(Z3_context c, Z3_ast v, int64_t* num, int64_t* den) {
|
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);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
CHECK_IS_EXPR(v, Z3_FALSE);
|
CHECK_IS_EXPR(v, false);
|
||||||
if (!num || !den) {
|
if (!num || !den) {
|
||||||
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
|
||||||
return Z3_FALSE;
|
return false;
|
||||||
}
|
}
|
||||||
rational r;
|
rational r;
|
||||||
Z3_bool ok = Z3_get_numeral_rational(c, v, r);
|
bool ok = Z3_get_numeral_rational(c, v, r);
|
||||||
if (ok != Z3_TRUE) {
|
if (ok != true) {
|
||||||
return ok;
|
return ok;
|
||||||
}
|
}
|
||||||
rational n = numerator(r);
|
rational n = numerator(r);
|
||||||
|
|
@ -385,11 +390,11 @@ extern "C" {
|
||||||
*den = d.get_int64();
|
*den = d.get_int64();
|
||||||
return ok;
|
return ok;
|
||||||
}
|
}
|
||||||
return Z3_FALSE;
|
return false;
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_ast Z3_API Z3_mk_bv_numeral(Z3_context c, unsigned sz, Z3_bool const* bits) {
|
Z3_ast Z3_API Z3_mk_bv_numeral(Z3_context c, unsigned sz, bool const* bits) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_mk_bv_numeral(c, sz, bits);
|
LOG_Z3_mk_bv_numeral(c, sz, bits);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
|
|
|
||||||
|
|
@ -124,10 +124,16 @@ extern "C" {
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
Z3_lbool Z3_API Z3_optimize_check(Z3_context c, Z3_optimize o) {
|
Z3_lbool Z3_API Z3_optimize_check(Z3_context c, Z3_optimize o, unsigned num_assumptions, Z3_ast const assumptions[]) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_optimize_check(c, o);
|
LOG_Z3_optimize_check(c, o, num_assumptions, assumptions);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
|
for (unsigned i = 0; i < num_assumptions; i++) {
|
||||||
|
if (!is_expr(to_ast(assumptions[i]))) {
|
||||||
|
SET_ERROR_CODE(Z3_INVALID_ARG, "assumption is not an expression");
|
||||||
|
return Z3_L_UNDEF;
|
||||||
|
}
|
||||||
|
}
|
||||||
lbool r = l_undef;
|
lbool r = l_undef;
|
||||||
cancel_eh<reslimit> eh(mk_c(c)->m().limit());
|
cancel_eh<reslimit> eh(mk_c(c)->m().limit());
|
||||||
unsigned timeout = to_optimize_ptr(o)->get_params().get_uint("timeout", mk_c(c)->get_timeout());
|
unsigned timeout = to_optimize_ptr(o)->get_params().get_uint("timeout", mk_c(c)->get_timeout());
|
||||||
|
|
@ -137,7 +143,9 @@ extern "C" {
|
||||||
scoped_timer timer(timeout, &eh);
|
scoped_timer timer(timeout, &eh);
|
||||||
scoped_rlimit _rlimit(mk_c(c)->m().limit(), rlimit);
|
scoped_rlimit _rlimit(mk_c(c)->m().limit(), rlimit);
|
||||||
try {
|
try {
|
||||||
r = to_optimize_ptr(o)->optimize();
|
expr_ref_vector asms(mk_c(c)->m());
|
||||||
|
asms.append(num_assumptions, to_exprs(assumptions));
|
||||||
|
r = to_optimize_ptr(o)->optimize(asms);
|
||||||
}
|
}
|
||||||
catch (z3_exception& ex) {
|
catch (z3_exception& ex) {
|
||||||
if (!mk_c(c)->m().canceled()) {
|
if (!mk_c(c)->m().canceled()) {
|
||||||
|
|
@ -157,6 +165,22 @@ extern "C" {
|
||||||
Z3_CATCH_RETURN(Z3_L_UNDEF);
|
Z3_CATCH_RETURN(Z3_L_UNDEF);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
Z3_ast_vector Z3_API Z3_optimize_get_unsat_core(Z3_context c, Z3_optimize o) {
|
||||||
|
Z3_TRY;
|
||||||
|
LOG_Z3_optimize_get_unsat_core(c, o);
|
||||||
|
RESET_ERROR_CODE();
|
||||||
|
expr_ref_vector core(mk_c(c)->m());
|
||||||
|
to_optimize_ptr(o)->get_unsat_core(core);
|
||||||
|
Z3_ast_vector_ref * v = alloc(Z3_ast_vector_ref, *mk_c(c), mk_c(c)->m());
|
||||||
|
mk_c(c)->save_object(v);
|
||||||
|
for (expr* e : core) {
|
||||||
|
v->m_ast_vector.push_back(e);
|
||||||
|
}
|
||||||
|
RETURN_Z3(of_ast_vector(v));
|
||||||
|
Z3_CATCH_RETURN(nullptr);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
Z3_string Z3_API Z3_optimize_get_reason_unknown(Z3_context c, Z3_optimize o) {
|
Z3_string Z3_API Z3_optimize_get_reason_unknown(Z3_context c, Z3_optimize o) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_optimize_to_string(c, o);
|
LOG_Z3_optimize_to_string(c, o);
|
||||||
|
|
@ -330,10 +354,8 @@ extern "C" {
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
ptr_vector<expr>::const_iterator it = ctx->begin_assertions();
|
for (expr * e : ctx->assertions()) {
|
||||||
ptr_vector<expr>::const_iterator end = ctx->end_assertions();
|
to_optimize_ptr(opt)->add_hard_constraint(e);
|
||||||
for (; it != end; ++it) {
|
|
||||||
to_optimize_ptr(opt)->add_hard_constraint(*it);
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -62,11 +62,11 @@ extern "C" {
|
||||||
/**
|
/**
|
||||||
\brief Add a Boolean parameter \c k with value \c v to the parameter set \c p.
|
\brief Add a Boolean parameter \c k with value \c v to the parameter set \c p.
|
||||||
*/
|
*/
|
||||||
void Z3_API Z3_params_set_bool(Z3_context c, Z3_params p, Z3_symbol k, Z3_bool v) {
|
void Z3_API Z3_params_set_bool(Z3_context c, Z3_params p, Z3_symbol k, bool v) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_params_set_bool(c, p, k, v);
|
LOG_Z3_params_set_bool(c, p, k, v);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
to_params(p)->m_params.set_bool(norm_param_name(to_symbol(k)).c_str(), v != 0);
|
to_params(p)->m_params.set_bool(norm_param_name(to_symbol(k)).c_str(), v);
|
||||||
Z3_CATCH;
|
Z3_CATCH;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -71,10 +71,8 @@ extern "C" {
|
||||||
SET_ERROR_CODE(Z3_PARSER_ERROR, errstrm.str().c_str());
|
SET_ERROR_CODE(Z3_PARSER_ERROR, errstrm.str().c_str());
|
||||||
return of_ast_vector(v);
|
return of_ast_vector(v);
|
||||||
}
|
}
|
||||||
ptr_vector<expr>::const_iterator it = ctx->begin_assertions();
|
for (expr * e : ctx->assertions()) {
|
||||||
ptr_vector<expr>::const_iterator end = ctx->end_assertions();
|
v->m_ast_vector.push_back(e);
|
||||||
for (; it != end; ++it) {
|
|
||||||
v->m_ast_vector.push_back(*it);
|
|
||||||
}
|
}
|
||||||
return of_ast_vector(v);
|
return of_ast_vector(v);
|
||||||
Z3_CATCH_RETURN(nullptr);
|
Z3_CATCH_RETURN(nullptr);
|
||||||
|
|
|
||||||
|
|
@ -1,5 +1,5 @@
|
||||||
/*++
|
/*++
|
||||||
Copyright (c) Microsoft Corporation, Arive Gurfinkel 2017
|
Copyright (c) Microsoft Corporation, Arie Gurfinkel 2017
|
||||||
|
|
||||||
Module Name:
|
Module Name:
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -26,7 +26,7 @@ extern "C" {
|
||||||
|
|
||||||
Z3_ast Z3_API Z3_mk_quantifier(
|
Z3_ast Z3_API Z3_mk_quantifier(
|
||||||
Z3_context c,
|
Z3_context c,
|
||||||
Z3_bool is_forall,
|
bool is_forall,
|
||||||
unsigned weight,
|
unsigned weight,
|
||||||
unsigned num_patterns, Z3_pattern const patterns[],
|
unsigned num_patterns, Z3_pattern const patterns[],
|
||||||
unsigned num_decls, Z3_sort const sorts[],
|
unsigned num_decls, Z3_sort const sorts[],
|
||||||
|
|
@ -50,7 +50,7 @@ extern "C" {
|
||||||
|
|
||||||
Z3_ast mk_quantifier_ex_core(
|
Z3_ast mk_quantifier_ex_core(
|
||||||
Z3_context c,
|
Z3_context c,
|
||||||
Z3_bool is_forall,
|
bool is_forall,
|
||||||
unsigned weight,
|
unsigned weight,
|
||||||
Z3_symbol quantifier_id,
|
Z3_symbol quantifier_id,
|
||||||
Z3_symbol skolem_id,
|
Z3_symbol skolem_id,
|
||||||
|
|
@ -109,7 +109,7 @@ extern "C" {
|
||||||
|
|
||||||
Z3_ast Z3_API Z3_mk_quantifier_ex(
|
Z3_ast Z3_API Z3_mk_quantifier_ex(
|
||||||
Z3_context c,
|
Z3_context c,
|
||||||
Z3_bool is_forall,
|
bool is_forall,
|
||||||
unsigned weight,
|
unsigned weight,
|
||||||
Z3_symbol quantifier_id,
|
Z3_symbol quantifier_id,
|
||||||
Z3_symbol skolem_id,
|
Z3_symbol skolem_id,
|
||||||
|
|
@ -132,7 +132,7 @@ extern "C" {
|
||||||
unsigned num_decls, Z3_sort const types[],
|
unsigned num_decls, Z3_sort const types[],
|
||||||
Z3_symbol const decl_names[],
|
Z3_symbol const decl_names[],
|
||||||
Z3_ast body) {
|
Z3_ast body) {
|
||||||
return Z3_mk_quantifier(c, 1, weight, num_patterns, patterns, num_decls, types, decl_names, body);
|
return Z3_mk_quantifier(c, true, weight, num_patterns, patterns, num_decls, types, decl_names, body);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_ast Z3_API Z3_mk_exists(Z3_context c,
|
Z3_ast Z3_API Z3_mk_exists(Z3_context c,
|
||||||
|
|
@ -141,7 +141,7 @@ extern "C" {
|
||||||
unsigned num_decls, Z3_sort const types[],
|
unsigned num_decls, Z3_sort const types[],
|
||||||
Z3_symbol const decl_names[],
|
Z3_symbol const decl_names[],
|
||||||
Z3_ast body) {
|
Z3_ast body) {
|
||||||
return Z3_mk_quantifier(c, 0, weight, num_patterns, patterns, num_decls, types, decl_names, body);
|
return Z3_mk_quantifier(c, false, weight, num_patterns, patterns, num_decls, types, decl_names, body);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_ast Z3_API Z3_mk_lambda(Z3_context c,
|
Z3_ast Z3_API Z3_mk_lambda(Z3_context c,
|
||||||
|
|
@ -155,7 +155,7 @@ extern "C" {
|
||||||
expr_ref result(mk_c(c)->m());
|
expr_ref result(mk_c(c)->m());
|
||||||
if (num_decls == 0) {
|
if (num_decls == 0) {
|
||||||
SET_ERROR_CODE(Z3_INVALID_USAGE, nullptr);
|
SET_ERROR_CODE(Z3_INVALID_USAGE, nullptr);
|
||||||
RETURN_Z3(0);
|
RETURN_Z3(nullptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
sort* const* ts = reinterpret_cast<sort * const*>(types);
|
sort* const* ts = reinterpret_cast<sort * const*>(types);
|
||||||
|
|
@ -166,7 +166,7 @@ extern "C" {
|
||||||
result = mk_c(c)->m().mk_lambda(names.size(), ts, names.c_ptr(), to_expr(body));
|
result = mk_c(c)->m().mk_lambda(names.size(), ts, names.c_ptr(), to_expr(body));
|
||||||
mk_c(c)->save_ast_trail(result.get());
|
mk_c(c)->save_ast_trail(result.get());
|
||||||
return of_ast(result.get());
|
return of_ast(result.get());
|
||||||
Z3_CATCH_RETURN(0);
|
Z3_CATCH_RETURN(nullptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_ast Z3_API Z3_mk_lambda_const(Z3_context c,
|
Z3_ast Z3_API Z3_mk_lambda_const(Z3_context c,
|
||||||
|
|
@ -178,7 +178,7 @@ extern "C" {
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
if (num_decls == 0) {
|
if (num_decls == 0) {
|
||||||
SET_ERROR_CODE(Z3_INVALID_USAGE, nullptr);
|
SET_ERROR_CODE(Z3_INVALID_USAGE, nullptr);
|
||||||
RETURN_Z3(0);
|
RETURN_Z3(nullptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
svector<symbol> _names;
|
svector<symbol> _names;
|
||||||
|
|
@ -196,12 +196,12 @@ extern "C" {
|
||||||
result = mk_c(c)->m().mk_lambda(_vars.size(), _vars.c_ptr(), _names.c_ptr(), result);
|
result = mk_c(c)->m().mk_lambda(_vars.size(), _vars.c_ptr(), _names.c_ptr(), result);
|
||||||
mk_c(c)->save_ast_trail(result.get());
|
mk_c(c)->save_ast_trail(result.get());
|
||||||
return of_ast(result.get());
|
return of_ast(result.get());
|
||||||
Z3_CATCH_RETURN(0);
|
Z3_CATCH_RETURN(nullptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
Z3_ast Z3_API Z3_mk_quantifier_const_ex(Z3_context c,
|
Z3_ast Z3_API Z3_mk_quantifier_const_ex(Z3_context c,
|
||||||
Z3_bool is_forall,
|
bool is_forall,
|
||||||
unsigned weight,
|
unsigned weight,
|
||||||
Z3_symbol quantifier_id,
|
Z3_symbol quantifier_id,
|
||||||
Z3_symbol skolem_id,
|
Z3_symbol skolem_id,
|
||||||
|
|
@ -283,7 +283,7 @@ extern "C" {
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_ast Z3_API Z3_mk_quantifier_const(Z3_context c,
|
Z3_ast Z3_API Z3_mk_quantifier_const(Z3_context c,
|
||||||
Z3_bool is_forall,
|
bool is_forall,
|
||||||
unsigned weight,
|
unsigned weight,
|
||||||
unsigned num_bound,
|
unsigned num_bound,
|
||||||
Z3_app const bound[],
|
Z3_app const bound[],
|
||||||
|
|
@ -343,28 +343,28 @@ extern "C" {
|
||||||
Z3_CATCH_RETURN(nullptr);
|
Z3_CATCH_RETURN(nullptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_is_quantifier_forall(Z3_context c, Z3_ast a) {
|
bool Z3_API Z3_is_quantifier_forall(Z3_context c, Z3_ast a) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_is_quantifier_forall(c, a);
|
LOG_Z3_is_quantifier_forall(c, a);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
return ::is_forall(to_ast(a)) ? Z3_TRUE : Z3_FALSE;
|
return ::is_forall(to_ast(a));
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_is_quantifier_exists(Z3_context c, Z3_ast a) {
|
bool Z3_API Z3_is_quantifier_exists(Z3_context c, Z3_ast a) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_is_quantifier_exists(c, a);
|
LOG_Z3_is_quantifier_exists(c, a);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
return ::is_exists(to_ast(a)) ? Z3_TRUE : Z3_FALSE;
|
return ::is_exists(to_ast(a));
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_is_lambda(Z3_context c, Z3_ast a) {
|
bool Z3_API Z3_is_lambda(Z3_context c, Z3_ast a) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_is_lambda(c, a);
|
LOG_Z3_is_lambda(c, a);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
return ::is_lambda(to_ast(a)) ? Z3_TRUE : Z3_FALSE;
|
return ::is_lambda(to_ast(a));
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -214,67 +214,67 @@ extern "C" {
|
||||||
Z3_CATCH_RETURN(nullptr);
|
Z3_CATCH_RETURN(nullptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_rcf_lt(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) {
|
bool Z3_API Z3_rcf_lt(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_rcf_lt(c, a, b);
|
LOG_Z3_rcf_lt(c, a, b);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
reset_rcf_cancel(c);
|
reset_rcf_cancel(c);
|
||||||
return rcfm(c).lt(to_rcnumeral(a), to_rcnumeral(b));
|
return rcfm(c).lt(to_rcnumeral(a), to_rcnumeral(b));
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_rcf_gt(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) {
|
bool Z3_API Z3_rcf_gt(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_rcf_gt(c, a, b);
|
LOG_Z3_rcf_gt(c, a, b);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
reset_rcf_cancel(c);
|
reset_rcf_cancel(c);
|
||||||
return rcfm(c).gt(to_rcnumeral(a), to_rcnumeral(b));
|
return rcfm(c).gt(to_rcnumeral(a), to_rcnumeral(b));
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_rcf_le(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) {
|
bool Z3_API Z3_rcf_le(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_rcf_le(c, a, b);
|
LOG_Z3_rcf_le(c, a, b);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
reset_rcf_cancel(c);
|
reset_rcf_cancel(c);
|
||||||
return rcfm(c).le(to_rcnumeral(a), to_rcnumeral(b));
|
return rcfm(c).le(to_rcnumeral(a), to_rcnumeral(b));
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_rcf_ge(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) {
|
bool Z3_API Z3_rcf_ge(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_rcf_ge(c, a, b);
|
LOG_Z3_rcf_ge(c, a, b);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
reset_rcf_cancel(c);
|
reset_rcf_cancel(c);
|
||||||
return rcfm(c).ge(to_rcnumeral(a), to_rcnumeral(b));
|
return rcfm(c).ge(to_rcnumeral(a), to_rcnumeral(b));
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_rcf_eq(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) {
|
bool Z3_API Z3_rcf_eq(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_rcf_eq(c, a, b);
|
LOG_Z3_rcf_eq(c, a, b);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
reset_rcf_cancel(c);
|
reset_rcf_cancel(c);
|
||||||
return rcfm(c).eq(to_rcnumeral(a), to_rcnumeral(b));
|
return rcfm(c).eq(to_rcnumeral(a), to_rcnumeral(b));
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_rcf_neq(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) {
|
bool Z3_API Z3_rcf_neq(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_rcf_neq(c, a, b);
|
LOG_Z3_rcf_neq(c, a, b);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
reset_rcf_cancel(c);
|
reset_rcf_cancel(c);
|
||||||
return rcfm(c).neq(to_rcnumeral(a), to_rcnumeral(b));
|
return rcfm(c).neq(to_rcnumeral(a), to_rcnumeral(b));
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_string Z3_API Z3_rcf_num_to_string(Z3_context c, Z3_rcf_num a, Z3_bool compact, Z3_bool html) {
|
Z3_string Z3_API Z3_rcf_num_to_string(Z3_context c, Z3_rcf_num a, bool compact, bool html) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_rcf_num_to_string(c, a, compact, html);
|
LOG_Z3_rcf_num_to_string(c, a, compact, html);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
reset_rcf_cancel(c);
|
reset_rcf_cancel(c);
|
||||||
std::ostringstream buffer;
|
std::ostringstream buffer;
|
||||||
rcfm(c).display(buffer, to_rcnumeral(a), compact != 0, html != 0);
|
rcfm(c).display(buffer, to_rcnumeral(a), compact, html);
|
||||||
return mk_c(c)->mk_external_string(buffer.str());
|
return mk_c(c)->mk_external_string(buffer.str());
|
||||||
Z3_CATCH_RETURN("");
|
Z3_CATCH_RETURN("");
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -65,40 +65,36 @@ extern "C" {
|
||||||
Z3_CATCH_RETURN(nullptr);
|
Z3_CATCH_RETURN(nullptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_is_seq_sort(Z3_context c, Z3_sort s) {
|
bool Z3_API Z3_is_seq_sort(Z3_context c, Z3_sort s) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_is_seq_sort(c, s);
|
LOG_Z3_is_seq_sort(c, s);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
bool result = mk_c(c)->sutil().is_seq(to_sort(s));
|
return mk_c(c)->sutil().is_seq(to_sort(s));
|
||||||
return result?Z3_TRUE:Z3_FALSE;
|
Z3_CATCH_RETURN(false);
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_is_re_sort(Z3_context c, Z3_sort s) {
|
bool Z3_API Z3_is_re_sort(Z3_context c, Z3_sort s) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_is_re_sort(c, s);
|
LOG_Z3_is_re_sort(c, s);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
bool result = mk_c(c)->sutil().is_re(to_sort(s));
|
return mk_c(c)->sutil().is_re(to_sort(s));
|
||||||
return result?Z3_TRUE:Z3_FALSE;
|
Z3_CATCH_RETURN(false);
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_is_string_sort(Z3_context c, Z3_sort s) {
|
bool Z3_API Z3_is_string_sort(Z3_context c, Z3_sort s) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_is_string_sort(c, s);
|
LOG_Z3_is_string_sort(c, s);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
bool result = mk_c(c)->sutil().is_string(to_sort(s));
|
return mk_c(c)->sutil().is_string(to_sort(s));
|
||||||
return result?Z3_TRUE:Z3_FALSE;
|
Z3_CATCH_RETURN(false);
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_is_string(Z3_context c, Z3_ast s) {
|
bool Z3_API Z3_is_string(Z3_context c, Z3_ast s) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_is_string(c, s);
|
LOG_Z3_is_string(c, s);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
bool result = mk_c(c)->sutil().str.is_string(to_expr(s));
|
return mk_c(c)->sutil().str.is_string(to_expr(s));
|
||||||
return result?Z3_TRUE:Z3_FALSE;
|
Z3_CATCH_RETURN(false);
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_string Z3_API Z3_get_string(Z3_context c, Z3_ast s) {
|
Z3_string Z3_API Z3_get_string(Z3_context c, Z3_ast s) {
|
||||||
|
|
@ -110,8 +106,8 @@ extern "C" {
|
||||||
SET_ERROR_CODE(Z3_INVALID_ARG, "expression is not a string literal");
|
SET_ERROR_CODE(Z3_INVALID_ARG, "expression is not a string literal");
|
||||||
return "";
|
return "";
|
||||||
}
|
}
|
||||||
std::string result = str.encode();
|
std::string s = str.encode();
|
||||||
return mk_c(c)->mk_external_string(result);
|
return mk_c(c)->mk_external_string(s);
|
||||||
Z3_CATCH_RETURN("");
|
Z3_CATCH_RETURN("");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -157,10 +157,8 @@ extern "C" {
|
||||||
bool initialized = to_solver(s)->m_solver.get() != nullptr;
|
bool initialized = to_solver(s)->m_solver.get() != nullptr;
|
||||||
if (!initialized)
|
if (!initialized)
|
||||||
init_solver(c, s);
|
init_solver(c, s);
|
||||||
ptr_vector<expr>::const_iterator it = ctx->begin_assertions();
|
for (expr * e : ctx->assertions()) {
|
||||||
ptr_vector<expr>::const_iterator end = ctx->end_assertions();
|
to_solver_ref(s)->assert_expr(e);
|
||||||
for (; it != end; ++it) {
|
|
||||||
to_solver_ref(s)->assert_expr(*it);
|
|
||||||
}
|
}
|
||||||
to_solver_ref(s)->set_model_converter(ctx->get_model_converter());
|
to_solver_ref(s)->set_model_converter(ctx->get_model_converter());
|
||||||
}
|
}
|
||||||
|
|
@ -179,16 +177,24 @@ extern "C" {
|
||||||
LOG_Z3_solver_from_file(c, s, file_name);
|
LOG_Z3_solver_from_file(c, s, file_name);
|
||||||
char const* ext = get_extension(file_name);
|
char const* ext = get_extension(file_name);
|
||||||
std::ifstream is(file_name);
|
std::ifstream is(file_name);
|
||||||
|
init_solver(c, s);
|
||||||
if (!is) {
|
if (!is) {
|
||||||
SET_ERROR_CODE(Z3_FILE_ACCESS_ERROR, nullptr);
|
SET_ERROR_CODE(Z3_FILE_ACCESS_ERROR, nullptr);
|
||||||
}
|
}
|
||||||
else if (ext && std::string("dimacs") == ext) {
|
else if (ext && std::string("dimacs") == ext) {
|
||||||
ast_manager& m = to_solver_ref(s)->get_manager();
|
ast_manager& m = to_solver_ref(s)->get_manager();
|
||||||
|
std::stringstream err;
|
||||||
sat::solver solver(to_solver_ref(s)->get_params(), m.limit());
|
sat::solver solver(to_solver_ref(s)->get_params(), m.limit());
|
||||||
parse_dimacs(is, solver);
|
if (!parse_dimacs(is, err, solver)) {
|
||||||
|
SET_ERROR_CODE(Z3_PARSER_ERROR, err.str().c_str());
|
||||||
|
return;
|
||||||
|
}
|
||||||
sat2goal s2g;
|
sat2goal s2g;
|
||||||
ref<sat2goal::mc> mc;
|
ref<sat2goal::mc> mc;
|
||||||
atom2bool_var a2b(m);
|
atom2bool_var a2b(m);
|
||||||
|
for (unsigned v = 0; v < solver.num_vars(); ++v) {
|
||||||
|
a2b.insert(m.mk_const(symbol(v), m.mk_bool_sort()), v);
|
||||||
|
}
|
||||||
goal g(m);
|
goal g(m);
|
||||||
s2g(solver, a2b, to_solver_ref(s)->get_params(), g, mc);
|
s2g(solver, a2b, to_solver_ref(s)->get_params(), g, mc);
|
||||||
for (unsigned i = 0; i < g.size(); ++i) {
|
for (unsigned i = 0; i < g.size(); ++i) {
|
||||||
|
|
@ -368,7 +374,22 @@ extern "C" {
|
||||||
v->m_ast_vector.push_back(f);
|
v->m_ast_vector.push_back(f);
|
||||||
}
|
}
|
||||||
RETURN_Z3(of_ast_vector(v));
|
RETURN_Z3(of_ast_vector(v));
|
||||||
Z3_CATCH_RETURN(0);
|
Z3_CATCH_RETURN(nullptr);
|
||||||
|
}
|
||||||
|
|
||||||
|
Z3_ast_vector Z3_API Z3_solver_get_non_units(Z3_context c, Z3_solver s) {
|
||||||
|
Z3_TRY;
|
||||||
|
LOG_Z3_solver_get_non_units(c, s);
|
||||||
|
RESET_ERROR_CODE();
|
||||||
|
init_solver(c, s);
|
||||||
|
Z3_ast_vector_ref * v = alloc(Z3_ast_vector_ref, *mk_c(c), mk_c(c)->m());
|
||||||
|
mk_c(c)->save_object(v);
|
||||||
|
expr_ref_vector fmls = to_solver_ref(s)->get_non_units(mk_c(c)->m());
|
||||||
|
for (expr* f : fmls) {
|
||||||
|
v->m_ast_vector.push_back(f);
|
||||||
|
}
|
||||||
|
RETURN_Z3(of_ast_vector(v));
|
||||||
|
Z3_CATCH_RETURN(nullptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
static Z3_lbool _solver_check(Z3_context c, Z3_solver s, unsigned num_assumptions, Z3_ast const assumptions[]) {
|
static Z3_lbool _solver_check(Z3_context c, Z3_solver s, unsigned num_assumptions, Z3_ast const assumptions[]) {
|
||||||
|
|
@ -615,7 +636,7 @@ extern "C" {
|
||||||
}
|
}
|
||||||
catch (z3_exception & ex) {
|
catch (z3_exception & ex) {
|
||||||
mk_c(c)->handle_exception(ex);
|
mk_c(c)->handle_exception(ex);
|
||||||
return 0;
|
return nullptr;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
Z3_ast_vector_ref * v = alloc(Z3_ast_vector_ref, *mk_c(c), mk_c(c)->m());
|
Z3_ast_vector_ref * v = alloc(Z3_ast_vector_ref, *mk_c(c), mk_c(c)->m());
|
||||||
|
|
@ -628,7 +649,7 @@ extern "C" {
|
||||||
to_ast_vector_ref(vs).push_back(a);
|
to_ast_vector_ref(vs).push_back(a);
|
||||||
}
|
}
|
||||||
RETURN_Z3(of_ast_vector(v));
|
RETURN_Z3(of_ast_vector(v));
|
||||||
Z3_CATCH_RETURN(0);
|
Z3_CATCH_RETURN(nullptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -74,28 +74,28 @@ extern "C" {
|
||||||
Z3_CATCH_RETURN("");
|
Z3_CATCH_RETURN("");
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_stats_is_uint(Z3_context c, Z3_stats s, unsigned idx) {
|
bool Z3_API Z3_stats_is_uint(Z3_context c, Z3_stats s, unsigned idx) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_stats_is_uint(c, s, idx);
|
LOG_Z3_stats_is_uint(c, s, idx);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
if (idx >= to_stats_ref(s).size()) {
|
if (idx >= to_stats_ref(s).size()) {
|
||||||
SET_ERROR_CODE(Z3_IOB, nullptr);
|
SET_ERROR_CODE(Z3_IOB, nullptr);
|
||||||
return Z3_FALSE;
|
return false;
|
||||||
}
|
}
|
||||||
return to_stats_ref(s).is_uint(idx);
|
return to_stats_ref(s).is_uint(idx);
|
||||||
Z3_CATCH_RETURN(0);
|
Z3_CATCH_RETURN(0);
|
||||||
}
|
}
|
||||||
|
|
||||||
Z3_bool Z3_API Z3_stats_is_double(Z3_context c, Z3_stats s, unsigned idx) {
|
bool Z3_API Z3_stats_is_double(Z3_context c, Z3_stats s, unsigned idx) {
|
||||||
Z3_TRY;
|
Z3_TRY;
|
||||||
LOG_Z3_stats_is_double(c, s, idx);
|
LOG_Z3_stats_is_double(c, s, idx);
|
||||||
RESET_ERROR_CODE();
|
RESET_ERROR_CODE();
|
||||||
if (idx >= to_stats_ref(s).size()) {
|
if (idx >= to_stats_ref(s).size()) {
|
||||||
SET_ERROR_CODE(Z3_IOB, nullptr);
|
SET_ERROR_CODE(Z3_IOB, nullptr);
|
||||||
return Z3_FALSE;
|
return false;
|
||||||
}
|
}
|
||||||
return !to_stats_ref(s).is_uint(idx);
|
return !to_stats_ref(s).is_uint(idx);
|
||||||
Z3_CATCH_RETURN(Z3_FALSE);
|
Z3_CATCH_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
unsigned Z3_API Z3_stats_get_uint_value(Z3_context c, Z3_stats s, unsigned idx) {
|
unsigned Z3_API Z3_stats_get_uint_value(Z3_context c, Z3_stats s, unsigned idx) {
|
||||||
|
|
|
||||||
File diff suppressed because it is too large
Load diff
|
|
@ -17,17 +17,16 @@ Notes:
|
||||||
|
|
||||||
--*/
|
--*/
|
||||||
|
|
||||||
|
using System.Diagnostics;
|
||||||
using System;
|
using System;
|
||||||
using System.Collections;
|
using System.Collections;
|
||||||
using System.Collections.Generic;
|
using System.Collections.Generic;
|
||||||
using System.Diagnostics.Contracts;
|
|
||||||
|
|
||||||
namespace Microsoft.Z3
|
namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// The abstract syntax tree (AST) class.
|
/// The abstract syntax tree (AST) class.
|
||||||
/// </summary>
|
/// </summary>
|
||||||
[ContractVerification(true)]
|
|
||||||
public class AST : Z3Object, IComparable
|
public class AST : Z3Object, IComparable
|
||||||
{
|
{
|
||||||
/// <summary>
|
/// <summary>
|
||||||
|
|
@ -114,8 +113,7 @@ namespace Microsoft.Z3
|
||||||
/// <returns>A copy of the AST which is associated with <paramref name="ctx"/></returns>
|
/// <returns>A copy of the AST which is associated with <paramref name="ctx"/></returns>
|
||||||
public AST Translate(Context ctx)
|
public AST Translate(Context ctx)
|
||||||
{
|
{
|
||||||
Contract.Requires(ctx != null);
|
Debug.Assert(ctx != null);
|
||||||
Contract.Ensures(Contract.Result<AST>() != null);
|
|
||||||
|
|
||||||
if (ReferenceEquals(Context, ctx))
|
if (ReferenceEquals(Context, ctx))
|
||||||
return this;
|
return this;
|
||||||
|
|
@ -202,14 +200,13 @@ namespace Microsoft.Z3
|
||||||
/// </summary>
|
/// </summary>
|
||||||
public string SExpr()
|
public string SExpr()
|
||||||
{
|
{
|
||||||
Contract.Ensures(Contract.Result<string>() != null);
|
|
||||||
|
|
||||||
return Native.Z3_ast_to_string(Context.nCtx, NativeObject);
|
return Native.Z3_ast_to_string(Context.nCtx, NativeObject);
|
||||||
}
|
}
|
||||||
|
|
||||||
#region Internal
|
#region Internal
|
||||||
internal AST(Context ctx) : base(ctx) { Contract.Requires(ctx != null); }
|
internal AST(Context ctx) : base(ctx) { Debug.Assert(ctx != null); }
|
||||||
internal AST(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); }
|
internal AST(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); }
|
||||||
|
|
||||||
internal class DecRefQueue : IDecRefQueue
|
internal class DecRefQueue : IDecRefQueue
|
||||||
{
|
{
|
||||||
|
|
@ -246,8 +243,7 @@ namespace Microsoft.Z3
|
||||||
|
|
||||||
internal static AST Create(Context ctx, IntPtr obj)
|
internal static AST Create(Context ctx, IntPtr obj)
|
||||||
{
|
{
|
||||||
Contract.Requires(ctx != null);
|
Debug.Assert(ctx != null);
|
||||||
Contract.Ensures(Contract.Result<AST>() != null);
|
|
||||||
|
|
||||||
switch ((Z3_ast_kind)Native.Z3_get_ast_kind(ctx.nCtx, obj))
|
switch ((Z3_ast_kind)Native.Z3_get_ast_kind(ctx.nCtx, obj))
|
||||||
{
|
{
|
||||||
|
|
|
||||||
|
|
@ -17,15 +17,14 @@ Notes:
|
||||||
|
|
||||||
--*/
|
--*/
|
||||||
|
|
||||||
|
using System.Diagnostics;
|
||||||
using System;
|
using System;
|
||||||
using System.Diagnostics.Contracts;
|
|
||||||
|
|
||||||
namespace Microsoft.Z3
|
namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Map from AST to AST
|
/// Map from AST to AST
|
||||||
/// </summary>
|
/// </summary>
|
||||||
[ContractVerification(true)]
|
|
||||||
internal class ASTMap : Z3Object
|
internal class ASTMap : Z3Object
|
||||||
{
|
{
|
||||||
/// <summary>
|
/// <summary>
|
||||||
|
|
@ -35,7 +34,7 @@ namespace Microsoft.Z3
|
||||||
/// <returns>True if <paramref name="k"/> is a key in the map, false otherwise.</returns>
|
/// <returns>True if <paramref name="k"/> is a key in the map, false otherwise.</returns>
|
||||||
public bool Contains(AST k)
|
public bool Contains(AST k)
|
||||||
{
|
{
|
||||||
Contract.Requires(k != null);
|
Debug.Assert(k != null);
|
||||||
|
|
||||||
return 0 != Native.Z3_ast_map_contains(Context.nCtx, NativeObject, k.NativeObject);
|
return 0 != Native.Z3_ast_map_contains(Context.nCtx, NativeObject, k.NativeObject);
|
||||||
}
|
}
|
||||||
|
|
@ -49,8 +48,7 @@ namespace Microsoft.Z3
|
||||||
/// <param name="k">An AST</param>
|
/// <param name="k">An AST</param>
|
||||||
public AST Find(AST k)
|
public AST Find(AST k)
|
||||||
{
|
{
|
||||||
Contract.Requires(k != null);
|
Debug.Assert(k != null);
|
||||||
Contract.Ensures(Contract.Result<AST>() != null);
|
|
||||||
|
|
||||||
return new AST(Context, Native.Z3_ast_map_find(Context.nCtx, NativeObject, k.NativeObject));
|
return new AST(Context, Native.Z3_ast_map_find(Context.nCtx, NativeObject, k.NativeObject));
|
||||||
}
|
}
|
||||||
|
|
@ -62,8 +60,8 @@ namespace Microsoft.Z3
|
||||||
/// <param name="v">The value AST</param>
|
/// <param name="v">The value AST</param>
|
||||||
public void Insert(AST k, AST v)
|
public void Insert(AST k, AST v)
|
||||||
{
|
{
|
||||||
Contract.Requires(k != null);
|
Debug.Assert(k != null);
|
||||||
Contract.Requires(v != null);
|
Debug.Assert(v != null);
|
||||||
|
|
||||||
Native.Z3_ast_map_insert(Context.nCtx, NativeObject, k.NativeObject, v.NativeObject);
|
Native.Z3_ast_map_insert(Context.nCtx, NativeObject, k.NativeObject, v.NativeObject);
|
||||||
}
|
}
|
||||||
|
|
@ -74,7 +72,7 @@ namespace Microsoft.Z3
|
||||||
/// <param name="k">An AST</param>
|
/// <param name="k">An AST</param>
|
||||||
public void Erase(AST k)
|
public void Erase(AST k)
|
||||||
{
|
{
|
||||||
Contract.Requires(k != null);
|
Debug.Assert(k != null);
|
||||||
|
|
||||||
Native.Z3_ast_map_erase(Context.nCtx, NativeObject, k.NativeObject);
|
Native.Z3_ast_map_erase(Context.nCtx, NativeObject, k.NativeObject);
|
||||||
}
|
}
|
||||||
|
|
@ -119,12 +117,12 @@ namespace Microsoft.Z3
|
||||||
internal ASTMap(Context ctx, IntPtr obj)
|
internal ASTMap(Context ctx, IntPtr obj)
|
||||||
: base(ctx, obj)
|
: base(ctx, obj)
|
||||||
{
|
{
|
||||||
Contract.Requires(ctx != null);
|
Debug.Assert(ctx != null);
|
||||||
}
|
}
|
||||||
internal ASTMap(Context ctx)
|
internal ASTMap(Context ctx)
|
||||||
: base(ctx, Native.Z3_mk_ast_map(ctx.nCtx))
|
: base(ctx, Native.Z3_mk_ast_map(ctx.nCtx))
|
||||||
{
|
{
|
||||||
Contract.Requires(ctx != null);
|
Debug.Assert(ctx != null);
|
||||||
}
|
}
|
||||||
|
|
||||||
internal class DecRefQueue : IDecRefQueue
|
internal class DecRefQueue : IDecRefQueue
|
||||||
|
|
|
||||||
|
|
@ -17,8 +17,8 @@ Notes:
|
||||||
|
|
||||||
--*/
|
--*/
|
||||||
|
|
||||||
|
using System.Diagnostics;
|
||||||
using System;
|
using System;
|
||||||
using System.Diagnostics.Contracts;
|
|
||||||
|
|
||||||
namespace Microsoft.Z3
|
namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
|
|
@ -45,13 +45,12 @@ namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
get
|
get
|
||||||
{
|
{
|
||||||
Contract.Ensures(Contract.Result<AST>() != null);
|
|
||||||
|
|
||||||
return new AST(Context, Native.Z3_ast_vector_get(Context.nCtx, NativeObject, i));
|
return new AST(Context, Native.Z3_ast_vector_get(Context.nCtx, NativeObject, i));
|
||||||
}
|
}
|
||||||
set
|
set
|
||||||
{
|
{
|
||||||
Contract.Requires(value != null);
|
Debug.Assert(value != null);
|
||||||
|
|
||||||
Native.Z3_ast_vector_set(Context.nCtx, NativeObject, i, value.NativeObject);
|
Native.Z3_ast_vector_set(Context.nCtx, NativeObject, i, value.NativeObject);
|
||||||
}
|
}
|
||||||
|
|
@ -73,7 +72,7 @@ namespace Microsoft.Z3
|
||||||
/// <param name="a">An AST</param>
|
/// <param name="a">An AST</param>
|
||||||
public void Push(AST a)
|
public void Push(AST a)
|
||||||
{
|
{
|
||||||
Contract.Requires(a != null);
|
Debug.Assert(a != null);
|
||||||
|
|
||||||
Native.Z3_ast_vector_push(Context.nCtx, NativeObject, a.NativeObject);
|
Native.Z3_ast_vector_push(Context.nCtx, NativeObject, a.NativeObject);
|
||||||
}
|
}
|
||||||
|
|
@ -85,8 +84,7 @@ namespace Microsoft.Z3
|
||||||
/// <returns>A new ASTVector</returns>
|
/// <returns>A new ASTVector</returns>
|
||||||
public ASTVector Translate(Context ctx)
|
public ASTVector Translate(Context ctx)
|
||||||
{
|
{
|
||||||
Contract.Requires(ctx != null);
|
Debug.Assert(ctx != null);
|
||||||
Contract.Ensures(Contract.Result<ASTVector>() != null);
|
|
||||||
|
|
||||||
return new ASTVector(Context, Native.Z3_ast_vector_translate(Context.nCtx, NativeObject, ctx.nCtx));
|
return new ASTVector(Context, Native.Z3_ast_vector_translate(Context.nCtx, NativeObject, ctx.nCtx));
|
||||||
}
|
}
|
||||||
|
|
@ -232,8 +230,8 @@ namespace Microsoft.Z3
|
||||||
}
|
}
|
||||||
|
|
||||||
#region Internal
|
#region Internal
|
||||||
internal ASTVector(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); }
|
internal ASTVector(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); }
|
||||||
internal ASTVector(Context ctx) : base(ctx, Native.Z3_mk_ast_vector(ctx.nCtx)) { Contract.Requires(ctx != null); }
|
internal ASTVector(Context ctx) : base(ctx, Native.Z3_mk_ast_vector(ctx.nCtx)) { Debug.Assert(ctx != null); }
|
||||||
|
|
||||||
internal class DecRefQueue : IDecRefQueue
|
internal class DecRefQueue : IDecRefQueue
|
||||||
{
|
{
|
||||||
|
|
|
||||||
|
|
@ -16,8 +16,8 @@ Author:
|
||||||
Notes:
|
Notes:
|
||||||
|
|
||||||
--*/
|
--*/
|
||||||
|
using System.Diagnostics;
|
||||||
using System;
|
using System;
|
||||||
using System.Diagnostics.Contracts;
|
|
||||||
|
|
||||||
#if !FRAMEWORK_LT_4
|
#if !FRAMEWORK_LT_4
|
||||||
using System.Numerics;
|
using System.Numerics;
|
||||||
|
|
@ -28,7 +28,6 @@ namespace Microsoft.Z3
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Algebraic numbers
|
/// Algebraic numbers
|
||||||
/// </summary>
|
/// </summary>
|
||||||
[ContractVerification(true)]
|
|
||||||
public class AlgebraicNum : ArithExpr
|
public class AlgebraicNum : ArithExpr
|
||||||
{
|
{
|
||||||
/// <summary>
|
/// <summary>
|
||||||
|
|
@ -40,7 +39,6 @@ namespace Microsoft.Z3
|
||||||
/// <returns>A numeral Expr of sort Real</returns>
|
/// <returns>A numeral Expr of sort Real</returns>
|
||||||
public RatNum ToUpper(uint precision)
|
public RatNum ToUpper(uint precision)
|
||||||
{
|
{
|
||||||
Contract.Ensures(Contract.Result<RatNum>() != null);
|
|
||||||
|
|
||||||
return new RatNum(Context, Native.Z3_get_algebraic_number_upper(Context.nCtx, NativeObject, precision));
|
return new RatNum(Context, Native.Z3_get_algebraic_number_upper(Context.nCtx, NativeObject, precision));
|
||||||
}
|
}
|
||||||
|
|
@ -54,7 +52,6 @@ namespace Microsoft.Z3
|
||||||
/// <returns>A numeral Expr of sort Real</returns>
|
/// <returns>A numeral Expr of sort Real</returns>
|
||||||
public RatNum ToLower(uint precision)
|
public RatNum ToLower(uint precision)
|
||||||
{
|
{
|
||||||
Contract.Ensures(Contract.Result<RatNum>() != null);
|
|
||||||
|
|
||||||
return new RatNum(Context, Native.Z3_get_algebraic_number_lower(Context.nCtx, NativeObject, precision));
|
return new RatNum(Context, Native.Z3_get_algebraic_number_lower(Context.nCtx, NativeObject, precision));
|
||||||
}
|
}
|
||||||
|
|
@ -65,7 +62,6 @@ namespace Microsoft.Z3
|
||||||
/// <remarks>The result has at most <paramref name="precision"/> decimal places.</remarks>
|
/// <remarks>The result has at most <paramref name="precision"/> decimal places.</remarks>
|
||||||
public string ToDecimal(uint precision)
|
public string ToDecimal(uint precision)
|
||||||
{
|
{
|
||||||
Contract.Ensures(Contract.Result<string>() != null);
|
|
||||||
|
|
||||||
return Native.Z3_get_numeral_decimal_string(Context.nCtx, NativeObject, precision);
|
return Native.Z3_get_numeral_decimal_string(Context.nCtx, NativeObject, precision);
|
||||||
}
|
}
|
||||||
|
|
@ -74,7 +70,7 @@ namespace Microsoft.Z3
|
||||||
internal AlgebraicNum(Context ctx, IntPtr obj)
|
internal AlgebraicNum(Context ctx, IntPtr obj)
|
||||||
: base(ctx, obj)
|
: base(ctx, obj)
|
||||||
{
|
{
|
||||||
Contract.Requires(ctx != null);
|
Debug.Assert(ctx != null);
|
||||||
}
|
}
|
||||||
#endregion
|
#endregion
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -17,8 +17,8 @@ Notes:
|
||||||
|
|
||||||
--*/
|
--*/
|
||||||
|
|
||||||
|
using System.Diagnostics;
|
||||||
using System;
|
using System;
|
||||||
using System.Diagnostics.Contracts;
|
|
||||||
|
|
||||||
namespace Microsoft.Z3
|
namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
|
|
@ -26,7 +26,6 @@ namespace Microsoft.Z3
|
||||||
/// ApplyResult objects represent the result of an application of a
|
/// ApplyResult objects represent the result of an application of a
|
||||||
/// tactic to a goal. It contains the subgoals that were produced.
|
/// tactic to a goal. It contains the subgoals that were produced.
|
||||||
/// </summary>
|
/// </summary>
|
||||||
[ContractVerification(true)]
|
|
||||||
public class ApplyResult : Z3Object
|
public class ApplyResult : Z3Object
|
||||||
{
|
{
|
||||||
/// <summary>
|
/// <summary>
|
||||||
|
|
@ -44,8 +43,6 @@ namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
get
|
get
|
||||||
{
|
{
|
||||||
Contract.Ensures(Contract.Result<Goal[]>() != null);
|
|
||||||
Contract.Ensures(Contract.Result<Goal[]>().Length == this.NumSubgoals);
|
|
||||||
|
|
||||||
uint n = NumSubgoals;
|
uint n = NumSubgoals;
|
||||||
Goal[] res = new Goal[n];
|
Goal[] res = new Goal[n];
|
||||||
|
|
@ -67,7 +64,7 @@ namespace Microsoft.Z3
|
||||||
internal ApplyResult(Context ctx, IntPtr obj)
|
internal ApplyResult(Context ctx, IntPtr obj)
|
||||||
: base(ctx, obj)
|
: base(ctx, obj)
|
||||||
{
|
{
|
||||||
Contract.Requires(ctx != null);
|
Debug.Assert(ctx != null);
|
||||||
}
|
}
|
||||||
|
|
||||||
internal class DecRefQueue : IDecRefQueue
|
internal class DecRefQueue : IDecRefQueue
|
||||||
|
|
|
||||||
|
|
@ -16,12 +16,12 @@ Author:
|
||||||
Notes:
|
Notes:
|
||||||
|
|
||||||
--*/
|
--*/
|
||||||
|
using System.Diagnostics;
|
||||||
using System;
|
using System;
|
||||||
using System.Collections.Generic;
|
using System.Collections.Generic;
|
||||||
using System.Linq;
|
using System.Linq;
|
||||||
using System.Text;
|
using System.Text;
|
||||||
|
|
||||||
using System.Diagnostics.Contracts;
|
|
||||||
|
|
||||||
namespace Microsoft.Z3
|
namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
|
|
@ -35,7 +35,7 @@ namespace Microsoft.Z3
|
||||||
internal ArithExpr(Context ctx, IntPtr obj)
|
internal ArithExpr(Context ctx, IntPtr obj)
|
||||||
: base(ctx, obj)
|
: base(ctx, obj)
|
||||||
{
|
{
|
||||||
Contract.Requires(ctx != null);
|
Debug.Assert(ctx != null);
|
||||||
}
|
}
|
||||||
#endregion
|
#endregion
|
||||||
|
|
||||||
|
|
@ -45,7 +45,7 @@ namespace Microsoft.Z3
|
||||||
|
|
||||||
private static ArithExpr MkNum(ArithExpr e, double d) { return (ArithExpr)e.Context.MkNumeral(d.ToString(), e.Context.MkRealSort()); }
|
private static ArithExpr MkNum(ArithExpr e, double d) { return (ArithExpr)e.Context.MkNumeral(d.ToString(), e.Context.MkRealSort()); }
|
||||||
|
|
||||||
/// <summary> Operator overloading for arithmetical divsion operator (over reals) </summary>
|
/// <summary> Operator overloading for arithmetical division operator (over reals) </summary>
|
||||||
public static ArithExpr operator /(ArithExpr a, ArithExpr b) { return a.Context.MkDiv(a, b); }
|
public static ArithExpr operator /(ArithExpr a, ArithExpr b) { return a.Context.MkDiv(a, b); }
|
||||||
|
|
||||||
/// <summary> Operator overloading for arithmetical operator </summary>
|
/// <summary> Operator overloading for arithmetical operator </summary>
|
||||||
|
|
|
||||||
|
|
@ -17,8 +17,8 @@ Notes:
|
||||||
|
|
||||||
--*/
|
--*/
|
||||||
|
|
||||||
|
using System.Diagnostics;
|
||||||
using System;
|
using System;
|
||||||
using System.Diagnostics.Contracts;
|
|
||||||
|
|
||||||
namespace Microsoft.Z3
|
namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
|
|
@ -28,7 +28,7 @@ namespace Microsoft.Z3
|
||||||
public class ArithSort : Sort
|
public class ArithSort : Sort
|
||||||
{
|
{
|
||||||
#region Internal
|
#region Internal
|
||||||
internal ArithSort(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); }
|
internal ArithSort(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); }
|
||||||
#endregion
|
#endregion
|
||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -16,12 +16,12 @@ Author:
|
||||||
Notes:
|
Notes:
|
||||||
|
|
||||||
--*/
|
--*/
|
||||||
|
using System.Diagnostics;
|
||||||
using System;
|
using System;
|
||||||
using System.Collections.Generic;
|
using System.Collections.Generic;
|
||||||
using System.Linq;
|
using System.Linq;
|
||||||
using System.Text;
|
using System.Text;
|
||||||
|
|
||||||
using System.Diagnostics.Contracts;
|
|
||||||
|
|
||||||
namespace Microsoft.Z3
|
namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
|
|
@ -35,7 +35,7 @@ namespace Microsoft.Z3
|
||||||
internal ArrayExpr(Context ctx, IntPtr obj)
|
internal ArrayExpr(Context ctx, IntPtr obj)
|
||||||
: base(ctx, obj)
|
: base(ctx, obj)
|
||||||
{
|
{
|
||||||
Contract.Requires(ctx != null);
|
Debug.Assert(ctx != null);
|
||||||
}
|
}
|
||||||
#endregion
|
#endregion
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -17,15 +17,14 @@ Notes:
|
||||||
|
|
||||||
--*/
|
--*/
|
||||||
|
|
||||||
|
using System.Diagnostics;
|
||||||
using System;
|
using System;
|
||||||
using System.Diagnostics.Contracts;
|
|
||||||
|
|
||||||
namespace Microsoft.Z3
|
namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Array sorts.
|
/// Array sorts.
|
||||||
/// </summary>
|
/// </summary>
|
||||||
[ContractVerification(true)]
|
|
||||||
public class ArraySort : Sort
|
public class ArraySort : Sort
|
||||||
{
|
{
|
||||||
/// <summary>
|
/// <summary>
|
||||||
|
|
@ -35,7 +34,6 @@ namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
get
|
get
|
||||||
{
|
{
|
||||||
Contract.Ensures(Contract.Result<Sort>() != null);
|
|
||||||
|
|
||||||
return Sort.Create(Context, Native.Z3_get_array_sort_domain(Context.nCtx, NativeObject));
|
return Sort.Create(Context, Native.Z3_get_array_sort_domain(Context.nCtx, NativeObject));
|
||||||
}
|
}
|
||||||
|
|
@ -48,27 +46,26 @@ namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
get
|
get
|
||||||
{
|
{
|
||||||
Contract.Ensures(Contract.Result<Sort>() != null);
|
|
||||||
|
|
||||||
return Sort.Create(Context, Native.Z3_get_array_sort_range(Context.nCtx, NativeObject));
|
return Sort.Create(Context, Native.Z3_get_array_sort_range(Context.nCtx, NativeObject));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#region Internal
|
#region Internal
|
||||||
internal ArraySort(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); }
|
internal ArraySort(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); }
|
||||||
internal ArraySort(Context ctx, Sort domain, Sort range)
|
internal ArraySort(Context ctx, Sort domain, Sort range)
|
||||||
: base(ctx, Native.Z3_mk_array_sort(ctx.nCtx, domain.NativeObject, range.NativeObject))
|
: base(ctx, Native.Z3_mk_array_sort(ctx.nCtx, domain.NativeObject, range.NativeObject))
|
||||||
{
|
{
|
||||||
Contract.Requires(ctx != null);
|
Debug.Assert(ctx != null);
|
||||||
Contract.Requires(domain != null);
|
Debug.Assert(domain != null);
|
||||||
Contract.Requires(range != null);
|
Debug.Assert(range != null);
|
||||||
}
|
}
|
||||||
internal ArraySort(Context ctx, Sort[] domain, Sort range)
|
internal ArraySort(Context ctx, Sort[] domain, Sort range)
|
||||||
: base(ctx, Native.Z3_mk_array_sort_n(ctx.nCtx, (uint)domain.Length, AST.ArrayToNative(domain), range.NativeObject))
|
: base(ctx, Native.Z3_mk_array_sort_n(ctx.nCtx, (uint)domain.Length, AST.ArrayToNative(domain), range.NativeObject))
|
||||||
{
|
{
|
||||||
Contract.Requires(ctx != null);
|
Debug.Assert(ctx != null);
|
||||||
Contract.Requires(domain != null);
|
Debug.Assert(domain != null);
|
||||||
Contract.Requires(range != null);
|
Debug.Assert(range != null);
|
||||||
}
|
}
|
||||||
#endregion
|
#endregion
|
||||||
};
|
};
|
||||||
|
|
|
||||||
|
|
@ -16,12 +16,12 @@ Author:
|
||||||
Notes:
|
Notes:
|
||||||
|
|
||||||
--*/
|
--*/
|
||||||
|
using System.Diagnostics;
|
||||||
using System;
|
using System;
|
||||||
using System.Collections.Generic;
|
using System.Collections.Generic;
|
||||||
using System.Linq;
|
using System.Linq;
|
||||||
using System.Text;
|
using System.Text;
|
||||||
|
|
||||||
using System.Diagnostics.Contracts;
|
|
||||||
|
|
||||||
namespace Microsoft.Z3
|
namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
|
|
@ -41,7 +41,7 @@ namespace Microsoft.Z3
|
||||||
|
|
||||||
#region Internal
|
#region Internal
|
||||||
/// <summary> Constructor for BitVecExpr </summary>
|
/// <summary> Constructor for BitVecExpr </summary>
|
||||||
internal BitVecExpr(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); }
|
internal BitVecExpr(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); }
|
||||||
#endregion
|
#endregion
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -16,8 +16,8 @@ Author:
|
||||||
Notes:
|
Notes:
|
||||||
|
|
||||||
--*/
|
--*/
|
||||||
|
using System.Diagnostics;
|
||||||
using System;
|
using System;
|
||||||
using System.Diagnostics.Contracts;
|
|
||||||
|
|
||||||
#if !FRAMEWORK_LT_4
|
#if !FRAMEWORK_LT_4
|
||||||
using System.Numerics;
|
using System.Numerics;
|
||||||
|
|
@ -28,7 +28,6 @@ namespace Microsoft.Z3
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Bit-vector numerals
|
/// Bit-vector numerals
|
||||||
/// </summary>
|
/// </summary>
|
||||||
[ContractVerification(true)]
|
|
||||||
public class BitVecNum : BitVecExpr
|
public class BitVecNum : BitVecExpr
|
||||||
{
|
{
|
||||||
/// <summary>
|
/// <summary>
|
||||||
|
|
@ -109,7 +108,7 @@ namespace Microsoft.Z3
|
||||||
}
|
}
|
||||||
|
|
||||||
#region Internal
|
#region Internal
|
||||||
internal BitVecNum(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); }
|
internal BitVecNum(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); }
|
||||||
#endregion
|
#endregion
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -17,8 +17,8 @@ Notes:
|
||||||
|
|
||||||
--*/
|
--*/
|
||||||
|
|
||||||
|
using System.Diagnostics;
|
||||||
using System;
|
using System;
|
||||||
using System.Diagnostics.Contracts;
|
|
||||||
|
|
||||||
namespace Microsoft.Z3
|
namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
|
|
@ -36,7 +36,7 @@ namespace Microsoft.Z3
|
||||||
}
|
}
|
||||||
|
|
||||||
#region Internal
|
#region Internal
|
||||||
internal BitVecSort(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); }
|
internal BitVecSort(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); }
|
||||||
#endregion
|
#endregion
|
||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -16,12 +16,12 @@ Author:
|
||||||
Notes:
|
Notes:
|
||||||
|
|
||||||
--*/
|
--*/
|
||||||
|
using System.Diagnostics;
|
||||||
using System;
|
using System;
|
||||||
using System.Collections.Generic;
|
using System.Collections.Generic;
|
||||||
using System.Linq;
|
using System.Linq;
|
||||||
using System.Text;
|
using System.Text;
|
||||||
|
|
||||||
using System.Diagnostics.Contracts;
|
|
||||||
|
|
||||||
namespace Microsoft.Z3
|
namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
|
|
@ -32,7 +32,7 @@ namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
#region Internal
|
#region Internal
|
||||||
/// <summary> Constructor for BoolExpr </summary>
|
/// <summary> Constructor for BoolExpr </summary>
|
||||||
internal BoolExpr(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); }
|
internal BoolExpr(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); }
|
||||||
#endregion
|
#endregion
|
||||||
|
|
||||||
#region Operators
|
#region Operators
|
||||||
|
|
|
||||||
|
|
@ -17,8 +17,8 @@ Notes:
|
||||||
|
|
||||||
--*/
|
--*/
|
||||||
|
|
||||||
|
using System.Diagnostics;
|
||||||
using System;
|
using System;
|
||||||
using System.Diagnostics.Contracts;
|
|
||||||
|
|
||||||
namespace Microsoft.Z3
|
namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
|
|
@ -28,8 +28,8 @@ namespace Microsoft.Z3
|
||||||
public class BoolSort : Sort
|
public class BoolSort : Sort
|
||||||
{
|
{
|
||||||
#region Internal
|
#region Internal
|
||||||
internal BoolSort(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); }
|
internal BoolSort(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); }
|
||||||
internal BoolSort(Context ctx) : base(ctx, Native.Z3_mk_bool_sort(ctx.nCtx)) { Contract.Requires(ctx != null); }
|
internal BoolSort(Context ctx) : base(ctx, Native.Z3_mk_bool_sort(ctx.nCtx)) { Debug.Assert(ctx != null); }
|
||||||
#endregion
|
#endregion
|
||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -17,15 +17,14 @@ Notes:
|
||||||
|
|
||||||
--*/
|
--*/
|
||||||
|
|
||||||
|
using System.Diagnostics;
|
||||||
using System;
|
using System;
|
||||||
using System.Diagnostics.Contracts;
|
|
||||||
|
|
||||||
namespace Microsoft.Z3
|
namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Constructors are used for datatype sorts.
|
/// Constructors are used for datatype sorts.
|
||||||
/// </summary>
|
/// </summary>
|
||||||
[ContractVerification(true)]
|
|
||||||
public class Constructor : Z3Object
|
public class Constructor : Z3Object
|
||||||
{
|
{
|
||||||
/// <summary>
|
/// <summary>
|
||||||
|
|
@ -46,7 +45,6 @@ namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
get
|
get
|
||||||
{
|
{
|
||||||
Contract.Ensures(Contract.Result<FuncDecl>() != null);
|
|
||||||
IntPtr constructor = IntPtr.Zero;
|
IntPtr constructor = IntPtr.Zero;
|
||||||
IntPtr tester = IntPtr.Zero;
|
IntPtr tester = IntPtr.Zero;
|
||||||
IntPtr[] accessors = new IntPtr[n];
|
IntPtr[] accessors = new IntPtr[n];
|
||||||
|
|
@ -62,7 +60,6 @@ namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
get
|
get
|
||||||
{
|
{
|
||||||
Contract.Ensures(Contract.Result<FuncDecl>() != null);
|
|
||||||
IntPtr constructor = IntPtr.Zero;
|
IntPtr constructor = IntPtr.Zero;
|
||||||
IntPtr tester = IntPtr.Zero;
|
IntPtr tester = IntPtr.Zero;
|
||||||
IntPtr[] accessors = new IntPtr[n];
|
IntPtr[] accessors = new IntPtr[n];
|
||||||
|
|
@ -78,7 +75,6 @@ namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
get
|
get
|
||||||
{
|
{
|
||||||
Contract.Ensures(Contract.Result<FuncDecl[]>() != null);
|
|
||||||
IntPtr constructor = IntPtr.Zero;
|
IntPtr constructor = IntPtr.Zero;
|
||||||
IntPtr tester = IntPtr.Zero;
|
IntPtr tester = IntPtr.Zero;
|
||||||
IntPtr[] accessors = new IntPtr[n];
|
IntPtr[] accessors = new IntPtr[n];
|
||||||
|
|
@ -105,9 +101,9 @@ namespace Microsoft.Z3
|
||||||
Sort[] sorts, uint[] sortRefs)
|
Sort[] sorts, uint[] sortRefs)
|
||||||
: base(ctx)
|
: base(ctx)
|
||||||
{
|
{
|
||||||
Contract.Requires(ctx != null);
|
Debug.Assert(ctx != null);
|
||||||
Contract.Requires(name != null);
|
Debug.Assert(name != null);
|
||||||
Contract.Requires(recognizer != null);
|
Debug.Assert(recognizer != null);
|
||||||
|
|
||||||
n = AST.ArrayLength(fieldNames);
|
n = AST.ArrayLength(fieldNames);
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -17,12 +17,12 @@ Notes:
|
||||||
|
|
||||||
--*/
|
--*/
|
||||||
|
|
||||||
|
using System.Diagnostics;
|
||||||
using System;
|
using System;
|
||||||
using System.Collections.Generic;
|
using System.Collections.Generic;
|
||||||
using System.Linq;
|
using System.Linq;
|
||||||
using System.Text;
|
using System.Text;
|
||||||
|
|
||||||
using System.Diagnostics.Contracts;
|
|
||||||
|
|
||||||
namespace Microsoft.Z3
|
namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
|
|
@ -43,14 +43,14 @@ namespace Microsoft.Z3
|
||||||
internal ConstructorList(Context ctx, IntPtr obj)
|
internal ConstructorList(Context ctx, IntPtr obj)
|
||||||
: base(ctx, obj)
|
: base(ctx, obj)
|
||||||
{
|
{
|
||||||
Contract.Requires(ctx != null);
|
Debug.Assert(ctx != null);
|
||||||
}
|
}
|
||||||
|
|
||||||
internal ConstructorList(Context ctx, Constructor[] constructors)
|
internal ConstructorList(Context ctx, Constructor[] constructors)
|
||||||
: base(ctx)
|
: base(ctx)
|
||||||
{
|
{
|
||||||
Contract.Requires(ctx != null);
|
Debug.Assert(ctx != null);
|
||||||
Contract.Requires(constructors != null);
|
Debug.Assert(constructors != null);
|
||||||
|
|
||||||
NativeObject = Native.Z3_mk_constructor_list(Context.nCtx, (uint)constructors.Length, Constructor.ArrayToNative(constructors));
|
NativeObject = Native.Z3_mk_constructor_list(Context.nCtx, (uint)constructors.Length, Constructor.ArrayToNative(constructors));
|
||||||
}
|
}
|
||||||
|
|
|
||||||
File diff suppressed because it is too large
Load diff
|
|
@ -16,12 +16,12 @@ Author:
|
||||||
Notes:
|
Notes:
|
||||||
|
|
||||||
--*/
|
--*/
|
||||||
|
using System.Diagnostics;
|
||||||
using System;
|
using System;
|
||||||
using System.Collections.Generic;
|
using System.Collections.Generic;
|
||||||
using System.Linq;
|
using System.Linq;
|
||||||
using System.Text;
|
using System.Text;
|
||||||
|
|
||||||
using System.Diagnostics.Contracts;
|
|
||||||
|
|
||||||
namespace Microsoft.Z3
|
namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
|
|
@ -35,7 +35,7 @@ namespace Microsoft.Z3
|
||||||
internal DatatypeExpr(Context ctx, IntPtr obj)
|
internal DatatypeExpr(Context ctx, IntPtr obj)
|
||||||
: base(ctx, obj)
|
: base(ctx, obj)
|
||||||
{
|
{
|
||||||
Contract.Requires(ctx != null);
|
Debug.Assert(ctx != null);
|
||||||
}
|
}
|
||||||
#endregion
|
#endregion
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -17,15 +17,14 @@ Notes:
|
||||||
|
|
||||||
--*/
|
--*/
|
||||||
|
|
||||||
|
using System.Diagnostics;
|
||||||
using System;
|
using System;
|
||||||
using System.Diagnostics.Contracts;
|
|
||||||
|
|
||||||
namespace Microsoft.Z3
|
namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Datatype sorts.
|
/// Datatype sorts.
|
||||||
/// </summary>
|
/// </summary>
|
||||||
[ContractVerification(true)]
|
|
||||||
public class DatatypeSort : Sort
|
public class DatatypeSort : Sort
|
||||||
{
|
{
|
||||||
/// <summary>
|
/// <summary>
|
||||||
|
|
@ -43,7 +42,6 @@ namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
get
|
get
|
||||||
{
|
{
|
||||||
Contract.Ensures(Contract.Result<FuncDecl[]>() != null);
|
|
||||||
|
|
||||||
uint n = NumConstructors;
|
uint n = NumConstructors;
|
||||||
FuncDecl[] res = new FuncDecl[n];
|
FuncDecl[] res = new FuncDecl[n];
|
||||||
|
|
@ -60,7 +58,6 @@ namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
get
|
get
|
||||||
{
|
{
|
||||||
Contract.Ensures(Contract.Result<FuncDecl[]>() != null);
|
|
||||||
|
|
||||||
uint n = NumConstructors;
|
uint n = NumConstructors;
|
||||||
FuncDecl[] res = new FuncDecl[n];
|
FuncDecl[] res = new FuncDecl[n];
|
||||||
|
|
@ -77,7 +74,6 @@ namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
get
|
get
|
||||||
{
|
{
|
||||||
Contract.Ensures(Contract.Result<FuncDecl[][]>() != null);
|
|
||||||
|
|
||||||
uint n = NumConstructors;
|
uint n = NumConstructors;
|
||||||
FuncDecl[][] res = new FuncDecl[n][];
|
FuncDecl[][] res = new FuncDecl[n][];
|
||||||
|
|
@ -95,14 +91,14 @@ namespace Microsoft.Z3
|
||||||
}
|
}
|
||||||
|
|
||||||
#region Internal
|
#region Internal
|
||||||
internal DatatypeSort(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); }
|
internal DatatypeSort(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); }
|
||||||
|
|
||||||
internal DatatypeSort(Context ctx, Symbol name, Constructor[] constructors)
|
internal DatatypeSort(Context ctx, Symbol name, Constructor[] constructors)
|
||||||
: base(ctx, Native.Z3_mk_datatype(ctx.nCtx, name.NativeObject, (uint)constructors.Length, ArrayToNative(constructors)))
|
: base(ctx, Native.Z3_mk_datatype(ctx.nCtx, name.NativeObject, (uint)constructors.Length, ArrayToNative(constructors)))
|
||||||
{
|
{
|
||||||
Contract.Requires(ctx != null);
|
Debug.Assert(ctx != null);
|
||||||
Contract.Requires(name != null);
|
Debug.Assert(name != null);
|
||||||
Contract.Requires(constructors != null);
|
Debug.Assert(constructors != null);
|
||||||
}
|
}
|
||||||
#endregion
|
#endregion
|
||||||
};
|
};
|
||||||
|
|
|
||||||
|
|
@ -17,17 +17,16 @@ Author:
|
||||||
Notes:
|
Notes:
|
||||||
|
|
||||||
--*/
|
--*/
|
||||||
|
using System.Diagnostics;
|
||||||
using System;
|
using System;
|
||||||
using System.Collections.Generic;
|
using System.Collections.Generic;
|
||||||
using System.Runtime.InteropServices;
|
using System.Runtime.InteropServices;
|
||||||
using System.Diagnostics.Contracts;
|
|
||||||
|
|
||||||
namespace Microsoft.Z3
|
namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// The main interaction with Z3 happens via the Context.
|
/// The main interaction with Z3 happens via the Context.
|
||||||
/// </summary>
|
/// </summary>
|
||||||
[ContractVerification(true)]
|
|
||||||
public class Deprecated
|
public class Deprecated
|
||||||
{
|
{
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -17,15 +17,14 @@ Notes:
|
||||||
|
|
||||||
--*/
|
--*/
|
||||||
|
|
||||||
|
using System.Diagnostics;
|
||||||
using System;
|
using System;
|
||||||
using System.Diagnostics.Contracts;
|
|
||||||
|
|
||||||
namespace Microsoft.Z3
|
namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Enumeration sorts.
|
/// Enumeration sorts.
|
||||||
/// </summary>
|
/// </summary>
|
||||||
[ContractVerification(true)]
|
|
||||||
public class EnumSort : Sort
|
public class EnumSort : Sort
|
||||||
{
|
{
|
||||||
/// <summary>
|
/// <summary>
|
||||||
|
|
@ -35,7 +34,6 @@ namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
get
|
get
|
||||||
{
|
{
|
||||||
Contract.Ensures(Contract.Result<FuncDecl[]>() != null);
|
|
||||||
uint n = Native.Z3_get_datatype_sort_num_constructors(Context.nCtx, NativeObject);
|
uint n = Native.Z3_get_datatype_sort_num_constructors(Context.nCtx, NativeObject);
|
||||||
FuncDecl[] t = new FuncDecl[n];
|
FuncDecl[] t = new FuncDecl[n];
|
||||||
for (uint i = 0; i < n; i++)
|
for (uint i = 0; i < n; i++)
|
||||||
|
|
@ -61,7 +59,6 @@ namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
get
|
get
|
||||||
{
|
{
|
||||||
Contract.Ensures(Contract.Result<Expr[]>() != null);
|
|
||||||
FuncDecl[] cds = ConstDecls;
|
FuncDecl[] cds = ConstDecls;
|
||||||
Expr[] t = new Expr[cds.Length];
|
Expr[] t = new Expr[cds.Length];
|
||||||
for (uint i = 0; i < t.Length; i++)
|
for (uint i = 0; i < t.Length; i++)
|
||||||
|
|
@ -87,7 +84,6 @@ namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
get
|
get
|
||||||
{
|
{
|
||||||
Contract.Ensures(Contract.Result<FuncDecl[]>() != null);
|
|
||||||
uint n = Native.Z3_get_datatype_sort_num_constructors(Context.nCtx, NativeObject);
|
uint n = Native.Z3_get_datatype_sort_num_constructors(Context.nCtx, NativeObject);
|
||||||
FuncDecl[] t = new FuncDecl[n];
|
FuncDecl[] t = new FuncDecl[n];
|
||||||
for (uint i = 0; i < n; i++)
|
for (uint i = 0; i < n; i++)
|
||||||
|
|
@ -110,9 +106,9 @@ namespace Microsoft.Z3
|
||||||
internal EnumSort(Context ctx, Symbol name, Symbol[] enumNames)
|
internal EnumSort(Context ctx, Symbol name, Symbol[] enumNames)
|
||||||
: base(ctx, IntPtr.Zero)
|
: base(ctx, IntPtr.Zero)
|
||||||
{
|
{
|
||||||
Contract.Requires(ctx != null);
|
Debug.Assert(ctx != null);
|
||||||
Contract.Requires(name != null);
|
Debug.Assert(name != null);
|
||||||
Contract.Requires(enumNames != null);
|
Debug.Assert(enumNames != null);
|
||||||
|
|
||||||
int n = enumNames.Length;
|
int n = enumNames.Length;
|
||||||
IntPtr[] n_constdecls = new IntPtr[n];
|
IntPtr[] n_constdecls = new IntPtr[n];
|
||||||
|
|
|
||||||
|
|
@ -17,15 +17,16 @@ Notes:
|
||||||
|
|
||||||
--*/
|
--*/
|
||||||
|
|
||||||
|
using System.Diagnostics;
|
||||||
using System;
|
using System;
|
||||||
using System.Diagnostics.Contracts;
|
using System.Linq;
|
||||||
|
|
||||||
|
|
||||||
namespace Microsoft.Z3
|
namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Expressions are terms.
|
/// Expressions are terms.
|
||||||
/// </summary>
|
/// </summary>
|
||||||
[ContractVerification(true)]
|
|
||||||
public class Expr : AST
|
public class Expr : AST
|
||||||
{
|
{
|
||||||
/// <summary>
|
/// <summary>
|
||||||
|
|
@ -35,7 +36,6 @@ namespace Microsoft.Z3
|
||||||
/// <seealso cref="Context.SimplifyHelp"/>
|
/// <seealso cref="Context.SimplifyHelp"/>
|
||||||
public Expr Simplify(Params p = null)
|
public Expr Simplify(Params p = null)
|
||||||
{
|
{
|
||||||
Contract.Ensures(Contract.Result<Expr>() != null);
|
|
||||||
|
|
||||||
if (p == null)
|
if (p == null)
|
||||||
return Expr.Create(Context, Native.Z3_simplify(Context.nCtx, NativeObject));
|
return Expr.Create(Context, Native.Z3_simplify(Context.nCtx, NativeObject));
|
||||||
|
|
@ -50,7 +50,6 @@ namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
get
|
get
|
||||||
{
|
{
|
||||||
Contract.Ensures(Contract.Result<FuncDecl>() != null);
|
|
||||||
return new FuncDecl(Context, Native.Z3_get_app_decl(Context.nCtx, NativeObject));
|
return new FuncDecl(Context, Native.Z3_get_app_decl(Context.nCtx, NativeObject));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
@ -79,7 +78,6 @@ namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
get
|
get
|
||||||
{
|
{
|
||||||
Contract.Ensures(Contract.Result<Expr[]>() != null);
|
|
||||||
|
|
||||||
uint n = NumArgs;
|
uint n = NumArgs;
|
||||||
Expr[] res = new Expr[n];
|
Expr[] res = new Expr[n];
|
||||||
|
|
@ -94,7 +92,6 @@ namespace Microsoft.Z3
|
||||||
/// </summary>
|
/// </summary>
|
||||||
public Expr Arg(uint i)
|
public Expr Arg(uint i)
|
||||||
{
|
{
|
||||||
Contract.Ensures(Contract.Result<Expr>() != null);
|
|
||||||
return Expr.Create(Context, Native.Z3_get_app_arg(Context.nCtx, NativeObject, i));
|
return Expr.Create(Context, Native.Z3_get_app_arg(Context.nCtx, NativeObject, i));
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -104,8 +101,8 @@ namespace Microsoft.Z3
|
||||||
/// </summary>
|
/// </summary>
|
||||||
public void Update(Expr[] args)
|
public void Update(Expr[] args)
|
||||||
{
|
{
|
||||||
Contract.Requires(args != null);
|
Debug.Assert(args != null);
|
||||||
Contract.Requires(Contract.ForAll(args, a => a != null));
|
Debug.Assert(args.All(a => a != null));
|
||||||
|
|
||||||
Context.CheckContextMatch<Expr>(args);
|
Context.CheckContextMatch<Expr>(args);
|
||||||
if (IsApp && args.Length != NumArgs)
|
if (IsApp && args.Length != NumArgs)
|
||||||
|
|
@ -123,11 +120,10 @@ namespace Microsoft.Z3
|
||||||
/// </remarks>
|
/// </remarks>
|
||||||
public Expr Substitute(Expr[] from, Expr[] to)
|
public Expr Substitute(Expr[] from, Expr[] to)
|
||||||
{
|
{
|
||||||
Contract.Requires(from != null);
|
Debug.Assert(from != null);
|
||||||
Contract.Requires(to != null);
|
Debug.Assert(to != null);
|
||||||
Contract.Requires(Contract.ForAll(from, f => f != null));
|
Debug.Assert(from.All(f => f != null));
|
||||||
Contract.Requires(Contract.ForAll(to, t => t != null));
|
Debug.Assert(to.All(t => t != null));
|
||||||
Contract.Ensures(Contract.Result<Expr>() != null);
|
|
||||||
|
|
||||||
Context.CheckContextMatch<Expr>(from);
|
Context.CheckContextMatch<Expr>(from);
|
||||||
Context.CheckContextMatch<Expr>(to);
|
Context.CheckContextMatch<Expr>(to);
|
||||||
|
|
@ -142,9 +138,8 @@ namespace Microsoft.Z3
|
||||||
/// <seealso cref="Substitute(Expr[],Expr[])"/>
|
/// <seealso cref="Substitute(Expr[],Expr[])"/>
|
||||||
public Expr Substitute(Expr from, Expr to)
|
public Expr Substitute(Expr from, Expr to)
|
||||||
{
|
{
|
||||||
Contract.Requires(from != null);
|
Debug.Assert(from != null);
|
||||||
Contract.Requires(to != null);
|
Debug.Assert(to != null);
|
||||||
Contract.Ensures(Contract.Result<Expr>() != null);
|
|
||||||
|
|
||||||
return Substitute(new Expr[] { from }, new Expr[] { to });
|
return Substitute(new Expr[] { from }, new Expr[] { to });
|
||||||
}
|
}
|
||||||
|
|
@ -157,9 +152,8 @@ namespace Microsoft.Z3
|
||||||
/// </remarks>
|
/// </remarks>
|
||||||
public Expr SubstituteVars(Expr[] to)
|
public Expr SubstituteVars(Expr[] to)
|
||||||
{
|
{
|
||||||
Contract.Requires(to != null);
|
Debug.Assert(to != null);
|
||||||
Contract.Requires(Contract.ForAll(to, t => t != null));
|
Debug.Assert(to.All(t => t != null));
|
||||||
Contract.Ensures(Contract.Result<Expr>() != null);
|
|
||||||
|
|
||||||
Context.CheckContextMatch<Expr>(to);
|
Context.CheckContextMatch<Expr>(to);
|
||||||
return Expr.Create(Context, Native.Z3_substitute_vars(Context.nCtx, NativeObject, (uint)to.Length, Expr.ArrayToNative(to)));
|
return Expr.Create(Context, Native.Z3_substitute_vars(Context.nCtx, NativeObject, (uint)to.Length, Expr.ArrayToNative(to)));
|
||||||
|
|
@ -207,7 +201,6 @@ namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
get
|
get
|
||||||
{
|
{
|
||||||
Contract.Ensures(Contract.Result<Sort>() != null);
|
|
||||||
return Sort.Create(Context, Native.Z3_get_sort(Context.nCtx, NativeObject));
|
return Sort.Create(Context, Native.Z3_get_sort(Context.nCtx, NativeObject));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
@ -332,7 +325,7 @@ namespace Microsoft.Z3
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Retrieve bound of at-most
|
/// Retrieve bound of at-most
|
||||||
/// </summary>
|
/// </summary>
|
||||||
public uint AtMostBound { get { Contract.Requires(IsAtMost); return (uint)FuncDecl.Parameters[0].Int; } }
|
public uint AtMostBound { get { Debug.Assert(IsAtMost); return (uint)FuncDecl.Parameters[0].Int; } }
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Indicates whether the term is at-least
|
/// Indicates whether the term is at-least
|
||||||
|
|
@ -342,7 +335,7 @@ namespace Microsoft.Z3
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Retrieve bound of at-least
|
/// Retrieve bound of at-least
|
||||||
/// </summary>
|
/// </summary>
|
||||||
public uint AtLeastBound { get { Contract.Requires(IsAtLeast); return (uint)FuncDecl.Parameters[0].Int; } }
|
public uint AtLeastBound { get { Debug.Assert(IsAtLeast); return (uint)FuncDecl.Parameters[0].Int; } }
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Indicates whether the term is pbeq
|
/// Indicates whether the term is pbeq
|
||||||
|
|
@ -842,7 +835,7 @@ namespace Microsoft.Z3
|
||||||
public string String { get { return Native.Z3_get_string(Context.nCtx, NativeObject); } }
|
public string String { get { return Native.Z3_get_string(Context.nCtx, NativeObject); } }
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Check whether expression is a concatentation.
|
/// Check whether expression is a concatenation.
|
||||||
/// </summary>
|
/// </summary>
|
||||||
/// <returns>a Boolean</returns>
|
/// <returns>a Boolean</returns>
|
||||||
public bool IsConcat { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SEQ_CONCAT; } }
|
public bool IsConcat { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SEQ_CONCAT; } }
|
||||||
|
|
@ -1816,8 +1809,6 @@ namespace Microsoft.Z3
|
||||||
if (!IsVar)
|
if (!IsVar)
|
||||||
throw new Z3Exception("Term is not a bound variable.");
|
throw new Z3Exception("Term is not a bound variable.");
|
||||||
|
|
||||||
Contract.EndContractBlock();
|
|
||||||
|
|
||||||
return Native.Z3_get_index_value(Context.nCtx, NativeObject);
|
return Native.Z3_get_index_value(Context.nCtx, NativeObject);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
@ -1827,10 +1818,9 @@ namespace Microsoft.Z3
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Constructor for Expr
|
/// Constructor for Expr
|
||||||
/// </summary>
|
/// </summary>
|
||||||
internal protected Expr(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); }
|
internal protected Expr(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); }
|
||||||
|
|
||||||
#if DEBUG
|
#if DEBUG
|
||||||
[Pure]
|
|
||||||
internal override void CheckNativeObject(IntPtr obj)
|
internal override void CheckNativeObject(IntPtr obj)
|
||||||
{
|
{
|
||||||
if (Native.Z3_is_app(Context.nCtx, obj) == 0 &&
|
if (Native.Z3_is_app(Context.nCtx, obj) == 0 &&
|
||||||
|
|
@ -1841,12 +1831,10 @@ namespace Microsoft.Z3
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
[Pure]
|
|
||||||
internal static Expr Create(Context ctx, FuncDecl f, params Expr[] arguments)
|
internal static Expr Create(Context ctx, FuncDecl f, params Expr[] arguments)
|
||||||
{
|
{
|
||||||
Contract.Requires(ctx != null);
|
Debug.Assert(ctx != null);
|
||||||
Contract.Requires(f != null);
|
Debug.Assert(f != null);
|
||||||
Contract.Ensures(Contract.Result<Expr>() != null);
|
|
||||||
|
|
||||||
IntPtr obj = Native.Z3_mk_app(ctx.nCtx, f.NativeObject,
|
IntPtr obj = Native.Z3_mk_app(ctx.nCtx, f.NativeObject,
|
||||||
AST.ArrayLength(arguments),
|
AST.ArrayLength(arguments),
|
||||||
|
|
@ -1854,11 +1842,9 @@ namespace Microsoft.Z3
|
||||||
return Create(ctx, obj);
|
return Create(ctx, obj);
|
||||||
}
|
}
|
||||||
|
|
||||||
[Pure]
|
|
||||||
new internal static Expr Create(Context ctx, IntPtr obj)
|
new internal static Expr Create(Context ctx, IntPtr obj)
|
||||||
{
|
{
|
||||||
Contract.Requires(ctx != null);
|
Debug.Assert(ctx != null);
|
||||||
Contract.Ensures(Contract.Result<Expr>() != null);
|
|
||||||
|
|
||||||
Z3_ast_kind k = (Z3_ast_kind)Native.Z3_get_ast_kind(ctx.nCtx, obj);
|
Z3_ast_kind k = (Z3_ast_kind)Native.Z3_get_ast_kind(ctx.nCtx, obj);
|
||||||
if (k == Z3_ast_kind.Z3_QUANTIFIER_AST)
|
if (k == Z3_ast_kind.Z3_QUANTIFIER_AST)
|
||||||
|
|
|
||||||
|
|
@ -16,12 +16,12 @@ Author:
|
||||||
Notes:
|
Notes:
|
||||||
|
|
||||||
--*/
|
--*/
|
||||||
|
using System.Diagnostics;
|
||||||
using System;
|
using System;
|
||||||
using System.Collections.Generic;
|
using System.Collections.Generic;
|
||||||
using System.Linq;
|
using System.Linq;
|
||||||
using System.Text;
|
using System.Text;
|
||||||
|
|
||||||
using System.Diagnostics.Contracts;
|
|
||||||
|
|
||||||
namespace Microsoft.Z3
|
namespace Microsoft.Z3
|
||||||
{
|
{
|
||||||
|
|
@ -45,7 +45,7 @@ namespace Microsoft.Z3
|
||||||
internal FPExpr(Context ctx, IntPtr obj)
|
internal FPExpr(Context ctx, IntPtr obj)
|
||||||
: base(ctx, obj)
|
: base(ctx, obj)
|
||||||
{
|
{
|
||||||
Contract.Requires(ctx != null);
|
Debug.Assert(ctx != null);
|
||||||
}
|
}
|
||||||
#endregion
|
#endregion
|
||||||
}
|
}
|
||||||
|
|
|
||||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue