diff options
| author | anwu1219 <haozewu@stanford.edu> | 2018-09-25 10:58:08 -0700 |
|---|---|---|
| committer | anwu1219 <haozewu@stanford.edu> | 2018-09-25 10:58:08 -0700 |
| commit | 5590206f1f6f1bff5a68fee071fc236c86af53e1 (patch) | |
| tree | bb7faa96099fa8b55b1b1143e884fa0bf0d64329 | |
| parent | fa85f7665365c4eeaaa0d84284718239f1d059c4 (diff) | |
| parent | f4ce78488ae41b4effc140edfc35cbba79d2dcd4 (diff) | |
Merge branch 'master' of https://github.com/CVC4/CVC4
96 files changed, 8188 insertions, 823 deletions
diff --git a/.travis.yml b/.travis.yml index 044e43d45..d8b1fc993 100644 --- a/.travis.yml +++ b/.travis.yml @@ -11,32 +11,29 @@ cache: - apt - ccache -# We need more than 4G memory for compiling CVC4. Hence, we cannot switch -# to container-based virtualization environments since they only provide 4G of -# memory. We will stick with the VM-based environments for now. -sudo: required +sudo: false dist: trusty env: global: - - TEST_GROUPS=2 - CCACHE_COMPRESS=1 addons: apt: sources: - ubuntu-toolchain-r-test packages: &common_deps - - libgmp-dev - - libboost-dev - - libboost-thread-dev - - swig3.0 - - libcln-dev - - openjdk-7-jdk - antlr3 - - libantlr3c-dev - - ant-optional + - cmake - cxxtest - - libreadline-dev + - junit4 + - libantlr3c-dev + - libboost-dev # Remove with autotools build + - libboost-thread-dev # Remove with autotools build + - libcln-dev + - libgmp-dev + - libhamcrest-java + - openjdk-7-jdk + - swig3.0 before_install: - eval "${MATRIX_EVAL}" # Clang does not play nice with ccache (at least the versions offered by @@ -50,10 +47,7 @@ before_install: sudo ln -s $(which ccache) /usr/lib/ccache/clang++ fi before_script: - - export JAVA_HOME=/usr/lib/jvm/java-7-openjdk-amd64 - - export PATH=$PATH:$JAVA_HOME/bin - - export JAVA_CPPFLAGS=-I$JAVA_HOME/include - - ./autogen.sh + export JAVA_HOME=/usr/lib/jvm/java-7-openjdk-amd64 script: - ccache -M 1G - ccache -z @@ -64,8 +58,7 @@ script: normal="$(echo -e '\033[0m')" red="$normal$(echo -e '\033[01;31m')" green="$normal$(echo -e '\033[01;32m')" configureCVC4() { echo "CVC4 config - $TRAVIS_CVC4_CONFIG"; - ./configure --enable-unit-testing $TRAVIS_CVC4_CONFIG || - (echo; echo "Trying to print config.log"; cat builds/config.log; error "CONFIGURE FAILED"); + ./configure.sh --name=build --unit-testing $TRAVIS_CVC4_CONFIG } error() { echo; @@ -73,22 +66,29 @@ script: echo; exit 1; } - makeDistcheck() { - make V=1 -j2 distcheck REGRESSION_LEVEL=0 CVC4_REGRESSION_ARGS='--no-early-exit' || - error "DISTCHECK (WITH NEWTHEORY TESTS) FAILED"; + makeAutotools() { + ./autogen.sh + ./configure debug --with-lfsc --disable-debug-symbols + make -j2 check REGRESSION_LEVEL=0 CVC4_REGRESSION_ARGS='--no-early-exit' || error "AUTOTOOLS BUILD/UNIT/SYSTEM/REGRESSION TEST FAILED" } + # makeDistcheck() { + # make V=1 -j2 distcheck REGRESSION_LEVEL=0 CVC4_REGRESSION_ARGS='--no-early-exit' || + # error "DISTCHECK (WITH NEWTHEORY TESTS) FAILED"; + # } makeCheck() { - make V=1 -j2 check REGRESSION_LEVEL=0 CVC4_REGRESSION_ARGS='--no-early-exit' || error "BUILD/UNIT/SYSTEM/REGRESSION TEST FAILED" + cd build + make -j2 check ARGS='-LE regress[1-4]' CVC4_REGRESSION_ARGS='--no-early-exit' || error "BUILD/UNIT/SYSTEM/REGRESSION TEST FAILED" } makeExamples() { - make V=1 -j2 examples || error "COULD NOT BUILD EXAMPLES${normal}"; - } - addNewTheoryTest() { - contrib/new-theory test_newtheory || error "NEWTHEORY FAILED"; - grep -q '^THEORIES *=.* test_newtheory' src/Makefile.theories || error "NEWTHEORY FAILED"; - contrib/new-theory --alternate test_newtheory test_newalttheory || error "NEWTHEORY-ALTERNATE FAILED"; - grep -q '^THEORIES *=.* test_newalttheory' src/Makefile.theories || error "NEWTHEORY-ALTERNATE FAILED"; + cd build + make -j2 examples || error "COULD NOT BUILD EXAMPLES${normal}"; } + # addNewTheoryTest() { + # contrib/new-theory test_newtheory || error "NEWTHEORY FAILED"; + # grep -q '^THEORIES *=.* test_newtheory' src/Makefile.theories || error "NEWTHEORY FAILED"; + # contrib/new-theory --alternate test_newtheory test_newalttheory || error "NEWTHEORY-ALTERNATE FAILED"; + # grep -q '^THEORIES *=.* test_newalttheory' src/Makefile.theories || error "NEWTHEORY-ALTERNATE FAILED"; + # } run() { echo "travis_fold:start:$1" echo "Running $1" @@ -96,10 +96,11 @@ script: echo "travis_fold:end:$1" } [ -n "$TRAVIS_CVC4" ] && [ -n "$TRAVIS_WITH_LFSC" ] && run contrib/get-lfsc-checker - [ -n "$TRAVIS_CVC4" ] && [ -n "$TRAVIS_CVC4_DISTCHECK" ] && run addNewTheoryTest - [ -n "$TRAVIS_CVC4" ] && run configureCVC4 - [ -n "$TRAVIS_CVC4" ] && [ -n "$TRAVIS_CVC4_DISTCHECK" ] && run makeDistcheck - [ -n "$TRAVIS_CVC4" ] && [ -z "$TRAVIS_CVC4_DISTCHECK" ] && run makeCheck && run makeExamples + [ -n "$TRAVIS_AUTOTOOLS" ] && run makeAutotools + # [ -n "$TRAVIS_CVC4" ] && [ -n "$TRAVIS_CVC4_DISTCHECK" ] && run addNewTheoryTest + [ -n "$TRAVIS_CVC4" ] && [ -z "$TRAVIS_AUTOTOOLS" ] && run configureCVC4 + # [ -n "$TRAVIS_CVC4" ] && [ -n "$TRAVIS_CVC4_DISTCHECK" ] && run makeDistcheck + [ -n "$TRAVIS_CVC4" ] && [ -z "$TRAVIS_CVC4_DISTCHECK" ] && [ -z "$TRAVIS_AUTOTOOLS" ] && run makeCheck && run makeExamples [ -z "$TRAVIS_CVC4" ] && error "Unknown Travis-CI configuration" echo "travis_fold:end:load_script" - echo; echo "${green}EVERYTHING SEEMED TO PASS!${normal}" @@ -110,18 +111,23 @@ matrix: # Test with GCC - compiler: gcc env: - - TRAVIS_CVC4=yes TRAVIS_WITH_LFSC=yes TRAVIS_CVC4_CONFIG='production --enable-language-bindings=java,c --with-lfsc' + - TRAVIS_CVC4=yes TRAVIS_WITH_LFSC=yes TRAVIS_CVC4_CONFIG='production --language-bindings=java --lfsc' + - compiler: gcc + env: + - TRAVIS_CVC4=yes TRAVIS_WITH_LFSC=yes TRAVIS_CVC4_CONFIG='debug --lfsc --no-debug-symbols' + + # Add autotools build until cmake is the default - compiler: gcc env: - - TRAVIS_CVC4=yes TRAVIS_WITH_LFSC=yes TRAVIS_CVC4_CONFIG='debug --with-lfsc --disable-debug-symbols' + - TRAVIS_CVC4=yes TRAVIS_WITH_LFSC=yes TRAVIS_AUTOTOOLS=yes # # Test with Clang - compiler: clang env: - - TRAVIS_CVC4=yes TRAVIS_WITH_LFSC=yes TRAVIS_CVC4_CONFIG='debug --with-cln --enable-gpl --disable-debug-symbols --disable-proof' + - TRAVIS_CVC4=yes TRAVIS_WITH_LFSC=yes TRAVIS_CVC4_CONFIG='debug --cln --gpl --no-debug-symbols --no-proofs' - compiler: clang env: - - TRAVIS_CVC4=yes TRAVIS_CVC4_DISTCHECK=yes TRAVIS_CVC4_CONFIG='--enable-proof' + - TRAVIS_CVC4=yes TRAVIS_CVC4_DISTCHECK=yes TRAVIS_CVC4_CONFIG='--proofs' notifications: email: on_success: change diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 000000000..453f1bcf7 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,551 @@ +cmake_minimum_required(VERSION 3.1) + +#-----------------------------------------------------------------------------# +# Project configuration + +project(cvc4) + +set(CVC4_MAJOR 1) # Major component of the version of CVC4. +set(CVC4_MINOR 7) # Minor component of the version of CVC4. +set(CVC4_RELEASE 0) # Release component of the version of CVC4. + +# Extraversion component of the version of CVC4. +set(CVC4_EXTRAVERSION "-prerelease") + +# Shared library versioning. Increment SOVERSION for every new CVC4 release. +set(CVC4_SOVERSION 5) + +# Full release string for CVC4. +if(CVC4_RELEASE) + set(CVC4_RELEASE_STRING + "${CVC4_MAJOR}.${CVC4_MINOR}.${CVC4_RELEASE}${CVC4_EXTRAVERSION}") +else() + set(CVC4_RELEASE_STRING "${CVC4_MAJOR}.${CVC4_MINOR}${CVC4_EXTRAVERSION}") +endif() + +set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake) +set(CMAKE_C_STANDARD 99) +set(CMAKE_CXX_STANDARD 11) + +#-----------------------------------------------------------------------------# + +include(Helpers) + +#-----------------------------------------------------------------------------# +# User options + +# License +option(ENABLE_GPL "Enable GPL dependencies") + +# General build options +# +# >> 3-valued: IGNORE ON OFF +# > allows to detect if set by user (default: IGNORE) +# > only necessary for options set for build types +cvc4_option(ENABLE_ASAN "Enable ASAN build") +cvc4_option(ENABLE_ASSERTIONS "Enable assertions") +cvc4_option(ENABLE_DEBUG_SYMBOLS "Enable debug symbols") +cvc4_option(ENABLE_DUMPING "Enable dumping") +cvc4_option(ENABLE_MUZZLE "Suppress ALL non-result output") +cvc4_option(ENABLE_OPTIMIZED "Enable optimization") +cvc4_option(ENABLE_PORTFOLIO "Enable portfolio support") +cvc4_option(ENABLE_PROOFS "Enable proof support") +cvc4_option(ENABLE_REPLAY "Enable the replay feature") +cvc4_option(ENABLE_STATISTICS "Enable statistics") +cvc4_option(ENABLE_TRACING "Enable tracing") +cvc4_option(ENABLE_UNIT_TESTING "Enable unit testing") +cvc4_option(ENABLE_VALGRIND "Enable valgrind instrumentation") +cvc4_option(ENABLE_SHARED "Build as shared library") +# >> 2-valued: ON OFF +# > for options where we don't need to detect if set by user (default: OFF) +option(ENABLE_BEST "Enable dependencies known to give best performance") +option(ENABLE_COVERAGE "Enable support for gcov coverage testing") +option(ENABLE_DEBUG_CONTEXT_MM "Enable the debug context memory manager") +option(ENABLE_PROFILING "Enable support for gprof profiling") + +# Optional dependencies +# +# >> 3-valued: IGNORE ON OFF +# > allows to detect if set by user (default: IGNORE) +# > only necessary for options set for ENABLE_BEST +cvc4_option(USE_ABC "Use ABC for AIG bit-blasting") +cvc4_option(USE_CLN "Use CLN instead of GMP") +cvc4_option(USE_GLPK "Use GLPK simplex solver") +cvc4_option(USE_READLINE "Use readline for better interactive support") +# >> 2-valued: ON OFF +# > for options where we don't need to detect if set by user (default: OFF) +option(USE_CADICAL "Use CaDiCaL SAT solver") +option(USE_CRYPTOMINISAT "Use CryptoMiniSat SAT solver") +option(USE_LFSC "Use LFSC proof checker") +option(USE_SYMFPU "Use SymFPU for floating point support") +option(USE_PYTHON2 "Prefer using Python 2 (for Python bindings)") +option(USE_PYTHON3 "Prefer using Python 3 (for Python bindings)") + +# Custom install directories for dependencies +# If no directory is provided by the user, we first check if the dependency was +# installed via the corresponding contrib/get-* script and if not found, we +# check the intalled system version. If the user provides a directory we +# immediately fail if the dependency was not found at the specified location. +set(ABC_DIR "" CACHE STRING "Set ABC install directory") +set(ANTLR_DIR "" CACHE STRING "Set ANTLR3 install directory") +set(CADICAL_DIR "" CACHE STRING "Set CaDiCaL install directory") +set(CRYPTOMINISAT_DIR "" CACHE STRING "Set CryptoMiniSat install directory") +set(GLPK_DIR "" CACHE STRING "Set GLPK install directory") +set(GMP_DIR "" CACHE STRING "Set GMP install directory") +set(LFSC_DIR "" CACHE STRING "Set LFSC install directory") +set(SYMFPU_DIR "" CACHE STRING "Set SymFPU install directory") + +# Prepend binaries with prefix on make install +set(PROGRAM_PREFIX "" CACHE STRING "Program prefix on make install") + +# Supported language bindings +option(BUILD_BINDINGS_JAVA "Build Java bindings") +option(BUILD_BINDINGS_PYTHON "Build Python bindings") + +#-----------------------------------------------------------------------------# +# Internal cmake variables + +set(OPTIMIZATION_LEVEL 3) +set(GPL_LIBS "") + +#-----------------------------------------------------------------------------# +# Determine number of threads available, used to configure (default) parallel +# execution of custom test targets (can be overriden with ARGS=-jN). + +include(ProcessorCount) +ProcessorCount(CTEST_NTHREADS) +if(CTEST_NTHREADS EQUAL 0) + set(CTEST_NTHREADS 1) +endif() + +#-----------------------------------------------------------------------------# +# Build types + +# Note: Module CodeCoverage requires the name of the debug build to conform +# to cmake standards (first letter uppercase). +set(BUILD_TYPES Production Debug Testing Competition) + +if(ENABLE_ASAN) + set(CMAKE_BUILD_TYPE Debug) +endif() + +# Set the default build type to Production +if(NOT CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE + Production CACHE STRING "Options are: ${BUILD_TYPES}" FORCE) + # Provide drop down menu options in cmake-gui + set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS ${BUILD_TYPES}) +endif() + +# Check if specified build type is valid. +list(FIND BUILD_TYPES ${CMAKE_BUILD_TYPE} FOUND_BUILD_TYPE) +if(${FOUND_BUILD_TYPE} EQUAL -1) + message(FATAL_ERROR + "'${CMAKE_BUILD_TYPE}' is not a valid build type. " + "Available builds are: ${BUILD_TYPES}") +endif() + +message(STATUS "Building ${CMAKE_BUILD_TYPE} build") +include(Config${CMAKE_BUILD_TYPE}) + +#-----------------------------------------------------------------------------# +# Compiler flags + +add_check_c_cxx_flag("-O${OPTIMIZATION_LEVEL}") +add_check_c_cxx_flag("-Wall") +add_check_c_flag("-fexceptions") +add_check_c_cxx_flag("-Wno-deprecated") +add_check_cxx_flag("-Wsuggest-override") +add_check_cxx_flag("-Wnon-virtual-dtor") + +# Temporarily disable -Wclass-memaccess to suppress 'no trivial copy-assignment' +# cdlist.h warnings. Remove when fixed. +add_check_cxx_flag("-Wno-class-memaccess") + +#-----------------------------------------------------------------------------# +# Option defaults (three-valued options (cvc4_option(...))) +# +# These options are only set if their value is IGNORE. Otherwise, the user +# already set the option, which we don't want to overwrite. + +cvc4_set_option(ENABLE_SHARED ON) + +#-----------------------------------------------------------------------------# +# Set options for best configuration + +if(ENABLE_BEST) + cvc4_set_option(USE_ABC ON) + cvc4_set_option(USE_CADICAL ON) + cvc4_set_option(USE_CLN ON) + cvc4_set_option(USE_CRYPTOMINISAT ON) + cvc4_set_option(USE_GLPK ON) + cvc4_set_option(USE_READLINE ON) +endif() + +# Only enable unit testing if assertions are enabled. Otherwise, unit tests +# that expect AssertionException to be thrown will fail. +if(NOT ENABLE_ASSERTIONS) + set(ENABLE_UNIT_TESTING OFF) +endif() + +# Never build unit tests as static binaries, otherwise we'll end up with +# ~300MB per unit test. +if(ENABLE_UNIT_TESTING) + set(ENABLE_SHARED ON) +endif() + +#-----------------------------------------------------------------------------# +# Shared/static libraries +# +# This needs to be set before any find_package(...) command since we want to +# search for static libraries with suffix .a. + +if(ENABLE_SHARED) + set(BUILD_SHARED_LIBS ON) +else() + set(CMAKE_FIND_LIBRARY_SUFFIXES ".a ${CMAKE_FIND_LIBRARY_SUFFIXES}") + set(BUILD_SHARED_LIBS OFF) + # This is required to force find_package(Boost) to use static libraries. + set(Boost_USE_STATIC_LIBS ON) +endif() + +#-----------------------------------------------------------------------------# +# Enable the ctest testing framework + +# This needs to be enabled here rather than in subdirectory test in order to +# allow calling ctest from the root build directory. +enable_testing() + +#-----------------------------------------------------------------------------# +# Check options, find packages and configure build. + +if(USE_PYTHON2) + find_package(PythonInterp 2.7 REQUIRED) +elseif(USE_PYTHON3) + find_package(PythonInterp 3 REQUIRED) +else() + find_package(PythonInterp REQUIRED) +endif() + +set(GMP_HOME ${GMP_DIR}) +find_package(GMP REQUIRED) + +if(ENABLE_ASAN) + # -fsanitize=address requires CMAKE_REQUIRED_FLAGS to be explicitely set, + # otherwise the -fsanitize=address check will fail while linking. + set(CMAKE_REQUIRED_FLAGS -fsanitize=address) + add_required_c_cxx_flag("-fsanitize=address") + unset(CMAKE_REQUIRED_FLAGS) + add_required_c_cxx_flag("-fno-omit-frame-pointer") + add_check_c_cxx_flag("-fsanitize-recover=address") +endif() + +if(ENABLE_ASSERTIONS) + add_definitions(-DCVC4_ASSERTIONS) +else() + add_definitions(-DNDEBUG) +endif() + +if(ENABLE_COVERAGE) + include(CodeCoverage) + APPEND_COVERAGE_COMPILER_FLAGS() + add_definitions(-DCVC4_COVERAGE) + setup_target_for_coverage_lcov( + NAME coverage + EXECUTABLE ctest -j${CTEST_NTHREADS} $(ARGS) + DEPENDENCIES cvc4-bin) +endif() + +if(ENABLE_DEBUG_CONTEXT_MM) + add_definitions(-DCVC4_DEBUG_CONTEXT_MEMORY_MANAGER) +endif() + +if(ENABLE_DEBUG_SYMBOLS) + add_check_c_cxx_flag("-ggdb3") +endif() + +if(ENABLE_MUZZLE) + add_definitions(-DCVC4_MUZZLE) +endif() + +# This check needs to come before the USE_CLN check. +if(ENABLE_PORTFOLIO) + find_package(Boost 1.50.0 REQUIRED COMPONENTS thread) + if (ENABLE_DUMPING) + message(FATAL_ERROR "Dumping not supported with a portfolio build.") + endif() + # Disable CLN for portfolio builds since it is not thread safe (uses an + # unlocked hash table internally). + if(USE_CLN) + message(WARNING "Disabling CLN support since portfolio is enabled.") + set(USE_CLN OFF) + endif() + set(THREADS_PREFER_PTHREAD_FLAG ON) + find_package(Threads REQUIRED) + if(THREADS_HAVE_PTHREAD_ARG) + add_c_cxx_flag(-pthread) + endif() + add_definitions(-DCVC4_PORTFOLIO) + set(BOOST_HAS_THREAD_ATTR 1) +endif() + +# This has to be processed after ENABLE_PORTFOLIO (disables dumping support). +if(ENABLE_DUMPING) + add_definitions(-DCVC4_DUMPING) +endif() + +if(ENABLE_PROFILING) + add_definitions(-DCVC4_PROFILING) + add_check_c_cxx_flag("-pg") +endif() + +if(ENABLE_PROOFS) + set(RUN_REGRESSION_ARGS ${RUN_REGRESSION_ARGS} --enable-proof) + add_definitions(-DCVC4_PROOF) +endif() + +if(ENABLE_REPLAY) + add_definitions(-DCVC4_REPLAY) +endif() + +if(ENABLE_TRACING) + add_definitions(-DCVC4_TRACING) +endif() + +if(ENABLE_UNIT_TESTING) + find_package(CxxTest REQUIRED) +endif() + +if(ENABLE_STATISTICS) + add_definitions(-DCVC4_STATISTICS_ON) +endif() + +if(ENABLE_VALGRIND) + find_package(Valgrind REQUIRED) + add_definitions(-DCVC4_VALGRIND) +endif() + +if(USE_ABC) + set(ABC_HOME "${ABC_DIR}") + find_package(ABC REQUIRED) + add_definitions(-DCVC4_USE_ABC ${ABC_ARCH_FLAGS}) +endif() + +if(USE_CADICAL) + set(CaDiCaL_HOME ${CADICAL_DIR}) + find_package(CaDiCaL REQUIRED) + add_definitions(-DCVC4_USE_CADICAL) +endif() + +if(USE_CLN) + set(GPL_LIBS "${GPL_LIBS} cln") + find_package(CLN 1.2.2 REQUIRED) + set(CVC4_USE_CLN_IMP 1) + set(CVC4_USE_GMP_IMP 0) +else() + set(CVC4_USE_CLN_IMP 0) + set(CVC4_USE_GMP_IMP 1) +endif() + +if(USE_CRYPTOMINISAT) + # CryptoMiniSat requires pthreads support + set(THREADS_PREFER_PTHREAD_FLAG ON) + find_package(Threads REQUIRED) + if(THREADS_HAVE_PTHREAD_ARG) + add_c_cxx_flag(-pthread) + endif() + set(CryptoMiniSat_HOME ${CRYPTOMINISAT_DIR}) + find_package(CryptoMiniSat REQUIRED) + add_definitions(-DCVC4_USE_CRYPTOMINISAT) +endif() + +if(USE_GLPK) + set(GPL_LIBS "${GPL_LIBS} glpk") + set(GLPK_HOME ${GLPK_DIR}) + find_package(GLPK REQUIRED) + add_definitions(-DCVC4_USE_GLPK) +endif() + +if(USE_LFSC) + set(RUN_REGRESSION_ARGS ${RUN_REGRESSION_ARGS} --with-lfsc) + set(LFSC_HOME ${LFSC_DIR}) + find_package(LFSC REQUIRED) + add_definitions(-DCVC4_USE_LFSC) +endif() + +if(USE_READLINE) + set(GPL_LIBS "${GPL_LIBS} readline") + find_package(Readline REQUIRED) + set(HAVE_LIBREADLINE 1) + if(Readline_COMPENTRY_FUNC_RETURNS_CHARPTR) + set(READLINE_COMPENTRY_FUNC_RETURNS_CHARP 1) + endif() +endif() + +if(USE_SYMFPU) + set(SymFPU_HOME ${SYMFPU_DIR}) + find_package(SymFPU REQUIRED) + add_definitions(-DCVC4_USE_SYMFPU) + set(CVC4_USE_SYMFPU 1) +else() + set(CVC4_USE_SYMFPU 0) +endif() + +if(GPL_LIBS) + if(NOT ENABLE_GPL) + message(FATAL_ERROR + "Bad configuration detected: BSD-licensed code only, but also requested " + "GPLed libraries: ${GPL_LIBS}") + endif() + set(CVC4_GPL_DEPS 1) +endif() + +#-----------------------------------------------------------------------------# +# Generate CVC4's cvc4autoconfig.h header + +include(ConfigureCVC4) +configure_file(cvc4autoconfig.new.h.in cvc4autoconfig.h) +include_directories(${CMAKE_CURRENT_BINARY_DIR}) + +#-----------------------------------------------------------------------------# +# Add subdirectories + +# signatures needs to come before src since it adds source files to libcvc4. +if(ENABLE_PROOFS) + add_subdirectory(proofs/signatures) +endif() + +add_subdirectory(doc) +add_subdirectory(examples EXCLUDE_FROM_ALL) # excluded from all target +add_subdirectory(src) +add_subdirectory(test) + +if(BUILD_BINDINGS_JAVA OR BUILD_BINDINGS_PYTHON) + add_subdirectory(src/bindings) +endif() + +#-----------------------------------------------------------------------------# +# Print build configuration + +# Convert build type to lower case. +string(TOLOWER ${CMAKE_BUILD_TYPE} CVC4_BUILD_PROFILE_STRING) + +# Get all definitions added via add_definitions. +get_directory_property(CVC4_DEFINITIONS COMPILE_DEFINITIONS) +string(REPLACE ";" " " CVC4_DEFINITIONS "${CVC4_DEFINITIONS}") + +message("CVC4 ${CVC4_RELEASE_STRING}") +message("") +message("Build profile : ${CVC4_BUILD_PROFILE_STRING}") +message("") +print_config("GPL :" ENABLE_GPL) +print_config("Best configuration :" ENABLE_BEST) +print_config("Optimized :" ENABLE_OPTIMIZED) +print_config("Optimization level :" OPTIMIZATION_LEVEL) +message("") +print_config("Assertions :" ENABLE_ASSERTIONS) +print_config("Debug symbols :" ENABLE_DEBUG_SYMBOLS) +print_config("Debug context mem mgr:" ENABLE_DEBUG_CONTEXT_MM) +message("") +print_config("Dumping :" ENABLE_DUMPING) +print_config("Muzzle :" ENABLE_MUZZLE) +print_config("Proofs :" ENABLE_PROOFS) +print_config("Replay :" ENABLE_REPLAY) +print_config("Statistics :" ENABLE_STATISTICS) +print_config("Tracing :" ENABLE_TRACING) +message("") +print_config("Asan :" ENABLE_ASAN) +print_config("Coverage (gcov) :" ENABLE_COVERAGE) +print_config("Profiling (gprof) :" ENABLE_PROFILING) +print_config("Unit tests :" ENABLE_UNIT_TESTING) +print_config("Valgrind :" ENABLE_VALGRIND) +message("") +print_config("Shared libs :" ENABLE_SHARED) +print_config("Java bindings :" BUILD_BINDINGS_JAVA) +print_config("Python bindings :" BUILD_BINDINGS_PYTHON) +print_config("Python2 :" USE_PYTHON2) +print_config("Python3 :" USE_PYTHON3) +message("") +print_config("Portfolio :" ENABLE_PORTFOLIO) +message("") +print_config("ABC :" USE_ABC) +print_config("CaDiCaL :" USE_CADICAL) +print_config("CryptoMiniSat :" USE_CRYPTOMINISAT) +print_config("GLPK :" USE_GLPK) +print_config("LFSC :" USE_LFSC) + +if(CVC4_USE_CLN_IMP) + message("MP library : cln") +else() + message("MP library : gmp") +endif() +print_config("Readline :" ${USE_READLINE}) +print_config("SymFPU :" ${USE_SYMFPU}) +message("") +if(ABC_DIR) + message("ABC dir : ${ABC_DIR}") +endif() +if(ANTLR_DIR) + message("ANTLR dir : ${ANTLR_DIR}") +endif() +if(CADICAL_DIR) + message("CADICAL dir : ${CADICAL_DIR}") +endif() +if(CRYPTOMINISAT_DIR) + message("CRYPTOMINISAT dir : ${CRYPTOMINISAT_DIR}") +endif() +if(GLPK_DIR) + message("GLPK dir : ${GLPK_DIR}") +endif() +if(GMP_DIR) + message("GMP dir : ${GMP_DIR}") +endif() +if(LFSC_DIR) + message("LFSC dir : ${LFSC_DIR}") +endif() +if(SYMFPU_DIR) + message("SYMFPU dir : ${SYMFPU_DIR}") +endif() +message("") +message("CPPLAGS (-D...) : ${CVC4_DEFINITIONS}") +message("CXXFLAGS : ${CMAKE_CXX_FLAGS}") +message("CFLAGS : ${CMAKE_C_FLAGS}") +message("") +message("Install prefix : ${CMAKE_INSTALL_PREFIX}") +message("") + +if(GPL_LIBS) + message( + "CVC4 license : GPLv3 (due to optional libraries; see below)" + "\n" + "\n" + "Please note that CVC4 will be built against the following GPLed libraries:" + "\n" + "${GPL_LIBS}" + "\n" + "As these libraries are covered under the GPLv3, so is this build of CVC4." + "\n" + "CVC4 is also available to you under the terms of the (modified) BSD license." + "\n" + "If you prefer to license CVC4 under those terms, please configure CVC4 to" + "\n" + "disable all optional GPLed library dependencies (-DENABLE_BSD_ONLY=ON)." + ) +else() + message( + "CVC4 license : modified BSD" + "\n" + "\n" + "Note that this configuration is NOT built against any GPL'ed libraries, so" + "\n" + "it is covered by the (modified) BSD license. This is, however, not the best" + "\n" + "performing configuration of CVC4. To build against GPL'ed libraries which" + "\n" + "improve CVC4's performance, re-configure with '-DENABLE_GPL -DENABLE_BEST'." + ) +endif() + +message("") +message("Now just type make, followed by make check or make install.") +message("") diff --git a/cmake/CodeCoverage.cmake b/cmake/CodeCoverage.cmake new file mode 100644 index 000000000..932c3d066 --- /dev/null +++ b/cmake/CodeCoverage.cmake @@ -0,0 +1,303 @@ +# Copyright (c) 2012 - 2017, Lars Bilke +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without modification, +# are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# 3. Neither the name of the copyright holder nor the names of its contributors +# may be used to endorse or promote products derived from this software without +# specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +# CHANGES: +# +# 2012-01-31, Lars Bilke +# - Enable Code Coverage +# +# 2013-09-17, Joakim Söderberg +# - Added support for Clang. +# - Some additional usage instructions. +# +# 2016-02-03, Lars Bilke +# - Refactored functions to use named parameters +# +# 2017-06-02, Lars Bilke +# - Merged with modified version from github.com/ufz/ogs +# +# +# USAGE: +# +# 1. Copy this file into your cmake modules path. +# +# 2. Add the following line to your CMakeLists.txt: +# include(CodeCoverage) +# +# 3. Append necessary compiler flags: +# APPEND_COVERAGE_COMPILER_FLAGS() +# +# 4. If you need to exclude additional directories from the report, specify them +# using the COVERAGE_LCOV_EXCLUDES variable before calling SETUP_TARGET_FOR_COVERAGE_LCOV. +# Example: +# set(COVERAGE_LCOV_EXCLUDES 'dir1/*' 'dir2/*') +# +# 5. Use the functions described below to create a custom make target which +# runs your test executable and produces a code coverage report. +# +# 6. Build a Debug build: +# cmake -DCMAKE_BUILD_TYPE=Debug .. +# make +# make my_coverage_target +# + +include(CMakeParseArguments) + +# Check prereqs +find_program( GCOV_PATH gcov ) +find_program( LCOV_PATH NAMES lcov lcov.bat lcov.exe lcov.perl) +find_program( GENHTML_PATH NAMES genhtml genhtml.perl genhtml.bat ) +find_program( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/scripts/test) +find_program( SIMPLE_PYTHON_EXECUTABLE python ) + +if(NOT GCOV_PATH) + message(FATAL_ERROR "gcov not found! Aborting...") +endif() # NOT GCOV_PATH + +if("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang") + if("${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS 3) + message(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...") + endif() +elseif(NOT CMAKE_COMPILER_IS_GNUCXX) + message(FATAL_ERROR "Compiler is not GNU gcc! Aborting...") +endif() + +set(COVERAGE_COMPILER_FLAGS "-g -O0 --coverage -fprofile-arcs -ftest-coverage" + CACHE INTERNAL "") + +set(CMAKE_CXX_FLAGS_COVERAGE + ${COVERAGE_COMPILER_FLAGS} + CACHE STRING "Flags used by the C++ compiler during coverage builds." + FORCE ) +set(CMAKE_C_FLAGS_COVERAGE + ${COVERAGE_COMPILER_FLAGS} + CACHE STRING "Flags used by the C compiler during coverage builds." + FORCE ) +set(CMAKE_EXE_LINKER_FLAGS_COVERAGE + "" + CACHE STRING "Flags used for linking binaries during coverage builds." + FORCE ) +set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE + "" + CACHE STRING "Flags used by the shared libraries linker during coverage builds." + FORCE ) +mark_as_advanced( + CMAKE_CXX_FLAGS_COVERAGE + CMAKE_C_FLAGS_COVERAGE + CMAKE_EXE_LINKER_FLAGS_COVERAGE + CMAKE_SHARED_LINKER_FLAGS_COVERAGE ) + +if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug") + message(WARNING "Code coverage results with an optimised (non-Debug) build may be misleading") +endif() # NOT CMAKE_BUILD_TYPE STREQUAL "Debug" + +if(CMAKE_C_COMPILER_ID STREQUAL "GNU") + link_libraries(gcov) +else() + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage") +endif() + +# Defines a target for running and collection code coverage information +# Builds dependencies, runs the given executable and outputs reports. +# NOTE! The executable should always have a ZERO as exit code otherwise +# the coverage generation will not complete. +# +# SETUP_TARGET_FOR_COVERAGE_LCOV( +# NAME testrunner_coverage # New target name +# EXECUTABLE testrunner -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR +# DEPENDENCIES testrunner # Dependencies to build first +# ) +function(SETUP_TARGET_FOR_COVERAGE_LCOV) + + set(options NONE) + set(oneValueArgs NAME) + set(multiValueArgs EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES) + cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + if(NOT LCOV_PATH) + message(FATAL_ERROR "lcov not found! Aborting...") + endif() # NOT LCOV_PATH + + if(NOT GENHTML_PATH) + message(FATAL_ERROR "genhtml not found! Aborting...") + endif() # NOT GENHTML_PATH + + # Setup target + add_custom_target(${Coverage_NAME} + + # Cleanup lcov + COMMAND ${LCOV_PATH} --directory . --zerocounters + # Create baseline to make sure untouched files show up in the report + COMMAND ${LCOV_PATH} -c -i -d . -o ${Coverage_NAME}.base + + # Run tests + COMMAND ${Coverage_EXECUTABLE} + + # Capturing lcov counters and generating report + COMMAND ${LCOV_PATH} --directory . --capture --output-file ${Coverage_NAME}.info + # add baseline counters + COMMAND ${LCOV_PATH} -a ${Coverage_NAME}.base -a ${Coverage_NAME}.info --output-file ${Coverage_NAME}.total + COMMAND ${LCOV_PATH} --remove ${Coverage_NAME}.total ${COVERAGE_LCOV_EXCLUDES} --output-file ${PROJECT_BINARY_DIR}/${Coverage_NAME}.info.cleaned + COMMAND ${GENHTML_PATH} -o ${Coverage_NAME} ${PROJECT_BINARY_DIR}/${Coverage_NAME}.info.cleaned + COMMAND ${CMAKE_COMMAND} -E remove ${Coverage_NAME}.base ${Coverage_NAME}.total ${PROJECT_BINARY_DIR}/${Coverage_NAME}.info.cleaned + + WORKING_DIRECTORY ${PROJECT_BINARY_DIR} + DEPENDS ${Coverage_DEPENDENCIES} + COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report." + ) + + # Show where to find the lcov info report + add_custom_command(TARGET ${Coverage_NAME} POST_BUILD + COMMAND ; + COMMENT "Lcov code coverage info report saved in ${Coverage_NAME}.info." + ) + + # Show info where to find the report + add_custom_command(TARGET ${Coverage_NAME} POST_BUILD + COMMAND ; + COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report." + ) + +endfunction() # SETUP_TARGET_FOR_COVERAGE_LCOV + +# Defines a target for running and collection code coverage information +# Builds dependencies, runs the given executable and outputs reports. +# NOTE! The executable should always have a ZERO as exit code otherwise +# the coverage generation will not complete. +# +# SETUP_TARGET_FOR_COVERAGE_GCOVR_XML( +# NAME ctest_coverage # New target name +# EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR +# DEPENDENCIES executable_target # Dependencies to build first +# ) +function(SETUP_TARGET_FOR_COVERAGE_GCOVR_XML) + + set(options NONE) + set(oneValueArgs NAME) + set(multiValueArgs EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES) + cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + if(NOT SIMPLE_PYTHON_EXECUTABLE) + message(FATAL_ERROR "python not found! Aborting...") + endif() # NOT SIMPLE_PYTHON_EXECUTABLE + + if(NOT GCOVR_PATH) + message(FATAL_ERROR "gcovr not found! Aborting...") + endif() # NOT GCOVR_PATH + + # Combine excludes to several -e arguments + set(GCOVR_EXCLUDES "") + foreach(EXCLUDE ${COVERAGE_GCOVR_EXCLUDES}) + list(APPEND GCOVR_EXCLUDES "-e") + list(APPEND GCOVR_EXCLUDES "${EXCLUDE}") + endforeach() + + add_custom_target(${Coverage_NAME} + # Run tests + ${Coverage_EXECUTABLE} + + # Running gcovr + COMMAND ${GCOVR_PATH} --xml + -r ${PROJECT_SOURCE_DIR} ${GCOVR_EXCLUDES} + --object-directory=${PROJECT_BINARY_DIR} + -o ${Coverage_NAME}.xml + WORKING_DIRECTORY ${PROJECT_BINARY_DIR} + DEPENDS ${Coverage_DEPENDENCIES} + COMMENT "Running gcovr to produce Cobertura code coverage report." + ) + + # Show info where to find the report + add_custom_command(TARGET ${Coverage_NAME} POST_BUILD + COMMAND ; + COMMENT "Cobertura code coverage report saved in ${Coverage_NAME}.xml." + ) + +endfunction() # SETUP_TARGET_FOR_COVERAGE_GCOVR_XML + +# Defines a target for running and collection code coverage information +# Builds dependencies, runs the given executable and outputs reports. +# NOTE! The executable should always have a ZERO as exit code otherwise +# the coverage generation will not complete. +# +# SETUP_TARGET_FOR_COVERAGE_GCOVR_HTML( +# NAME ctest_coverage # New target name +# EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR +# DEPENDENCIES executable_target # Dependencies to build first +# ) +function(SETUP_TARGET_FOR_COVERAGE_GCOVR_HTML) + + set(options NONE) + set(oneValueArgs NAME) + set(multiValueArgs EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES) + cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + if(NOT SIMPLE_PYTHON_EXECUTABLE) + message(FATAL_ERROR "python not found! Aborting...") + endif() # NOT SIMPLE_PYTHON_EXECUTABLE + + if(NOT GCOVR_PATH) + message(FATAL_ERROR "gcovr not found! Aborting...") + endif() # NOT GCOVR_PATH + + # Combine excludes to several -e arguments + set(GCOVR_EXCLUDES "") + foreach(EXCLUDE ${COVERAGE_GCOVR_EXCLUDES}) + list(APPEND GCOVR_EXCLUDES "-e") + list(APPEND GCOVR_EXCLUDES "${EXCLUDE}") + endforeach() + + add_custom_target(${Coverage_NAME} + # Run tests + ${Coverage_EXECUTABLE} + + # Create folder + COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/${Coverage_NAME} + + # Running gcovr + COMMAND ${GCOVR_PATH} --html --html-details + -r ${PROJECT_SOURCE_DIR} ${GCOVR_EXCLUDES} + --object-directory=${PROJECT_BINARY_DIR} + -o ${Coverage_NAME}/index.html + WORKING_DIRECTORY ${PROJECT_BINARY_DIR} + DEPENDS ${Coverage_DEPENDENCIES} + COMMENT "Running gcovr to produce HTML code coverage report." + ) + + # Show info where to find the report + add_custom_command(TARGET ${Coverage_NAME} POST_BUILD + COMMAND ; + COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report." + ) + +endfunction() # SETUP_TARGET_FOR_COVERAGE_GCOVR_HTML + +function(APPEND_COVERAGE_COMPILER_FLAGS) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE) + message(STATUS "Appending code coverage compiler flags: ${COVERAGE_COMPILER_FLAGS}") +endfunction() # APPEND_COVERAGE_COMPILER_FLAGS diff --git a/cmake/ConfigCompetition.cmake b/cmake/ConfigCompetition.cmake new file mode 100644 index 000000000..f40cd46be --- /dev/null +++ b/cmake/ConfigCompetition.cmake @@ -0,0 +1,28 @@ +add_definitions(-DCVC4_COMPETITION_MODE) +add_check_c_cxx_flag("-funroll-all-loops") +add_check_c_cxx_flag("-fexpensive-optimizations") +add_check_c_cxx_flag("-fno-enforce-eh-specs") +# OPTLEVEL=9 +# enable_optimized=yes +cvc4_set_option(ENABLE_OPTIMIZED ON) +set(OPTIMIZATION_LEVEL 9) +# enable_debug_symbols=no +cvc4_set_option(ENABLE_DEBUG_SYMBOLS OFF) +# enable_statistics=no +cvc4_set_option(ENABLE_STATISTICS OFF) +# enable_replay=no +cvc4_set_option(ENABLE_REPLAY OFF) +# enable_assertions=no +cvc4_set_option(ENABLE_ASSERTIONS OFF) +# enable_proof=no +cvc4_set_option(ENABLE_PROOFS OFF) +# enable_tracing=no +cvc4_set_option(ENABLE_TRACING OFF) +# enable_dumping=no +cvc4_set_option(ENABLE_DUMPING OFF) +# enable_muzzle=yes +cvc4_set_option(ENABLE_MUZZLE ON) +# enable_valgrind=no +# enable_shared=no +cvc4_set_option(ENABLE_SHARED OFF) +cvc4_set_option(ENABLE_UNIT_TESTING OFF) diff --git a/cmake/ConfigDebug.cmake b/cmake/ConfigDebug.cmake new file mode 100644 index 000000000..9c9f5ec10 --- /dev/null +++ b/cmake/ConfigDebug.cmake @@ -0,0 +1,34 @@ +add_definitions(-DCVC4_DEBUG) +set(CVC4_DEBUG 1) +add_check_c_cxx_flag("-fno-inline") +# enable_optimized=no +cvc4_set_option(ENABLE_OPTIMIZED OFF) +set(OPTIMIZATION_LEVEL 0) +add_c_cxx_flag("-Og") +# enable_debug_symbols=yes +cvc4_set_option(ENABLE_DEBUG_SYMBOLS ON) +# enable_statistics=yes +cvc4_set_option(ENABLE_STATISTICS ON) +# enable_replay=yes +cvc4_set_option(ENABLE_REPLAY ON) +# enable_assertions=yes +cvc4_set_option(ENABLE_ASSERTIONS ON) +# enable_proof=yes +cvc4_set_option(ENABLE_PROOFS ON) +# enable_tracing=yes +cvc4_set_option(ENABLE_TRACING ON) +# enable_dumping=yes +if(ENABLE_PORTFOLIO) + if(ENABLE_DUMPING) + message(FATAL_ERROR "Dumping not supported with a portfolio build.") + else() + message(WARNING + "Disabling dumping support, not supported with a portfolio build.") + endif() +else() + cvc4_set_option(ENABLE_DUMPING ON) +endif() +# enable_muzzle=no +cvc4_set_option(ENABLE_MUZZLE OFF) +# enable_valgrind=optional +cvc4_set_option(ENABLE_UNIT_TESTING ON) diff --git a/cmake/ConfigProduction.cmake b/cmake/ConfigProduction.cmake new file mode 100644 index 000000000..db63507a7 --- /dev/null +++ b/cmake/ConfigProduction.cmake @@ -0,0 +1,31 @@ +# OPTLEVEL=3 +# enable_optimized=yes +cvc4_set_option(ENABLE_OPTIMIZED ON) +set(OPTIMIZATION_LEVEL 3) +# enable_debug_symbols=no +cvc4_set_option(ENABLE_DEBUG_SYMBOLS OFF) +# enable_statistics=yes +cvc4_set_option(ENABLE_STATISTICS ON) +# enable_replay=no +cvc4_set_option(ENABLE_REPLAY OFF) +# enable_assertions=no +cvc4_set_option(ENABLE_ASSERTIONS OFF) +# enable_proof=yes +cvc4_set_option(ENABLE_PROOFS ON) +# enable_tracing=no +cvc4_set_option(ENABLE_TRACING OFF) +# enable_dumping=yes +if(ENABLE_PORTFOLIO) + if(ENABLE_DUMPING) + message(FATAL_ERROR "Dumping not supported with a portfolio build.") + else() + message(WARNING + "Disabling dumping support, not supported with a portfolio build.") + endif() +else() + cvc4_set_option(ENABLE_DUMPING ON) +endif() +# enable_muzzle=no +cvc4_set_option(ENABLE_MUZZLE OFF) +# enable_valgrind=no +cvc4_set_option(ENABLE_UNIT_TESTING OFF) diff --git a/cmake/ConfigTesting.cmake b/cmake/ConfigTesting.cmake new file mode 100644 index 000000000..3c995e421 --- /dev/null +++ b/cmake/ConfigTesting.cmake @@ -0,0 +1,31 @@ +# OPTLEVEL=2 +# enable_optimized=yes +cvc4_set_option(ENABLE_OPTIMIZED ON) +set(OPTIMIZATION_LEVEL 2) +# enable_debug_symbols=yes +cvc4_set_option(ENABLE_DEBUG_SYMBOLS ON) +# enable_statistics=yes +cvc4_set_option(ENABLE_STATISTICS ON) +# enable_replay=yes +cvc4_set_option(ENABLE_REPLAY ON) +# enable_assertions=yes +cvc4_set_option(ENABLE_ASSERTIONS ON) +# enable_proof=yes +cvc4_set_option(ENABLE_PROOFS ON) +# enable_tracing=yes +cvc4_set_option(ENABLE_TRACING ON) +# enable_dumping=yes +if(ENABLE_PORTFOLIO) + if(ENABLE_DUMPING) + message(FATAL_ERROR "Dumping not supported with a portfolio build.") + else() + message(WARNING + "Disabling dumping support, not supported with a portfolio build.") + endif() +else() + cvc4_set_option(ENABLE_DUMPING ON) +endif() +# enable_muzzle=no +cvc4_set_option(ENABLE_MUZZLE OFF) +# enable_valgrind=no +cvc4_set_option(ENABLE_UNIT_TESTING ON) diff --git a/cmake/ConfigureCVC4.cmake b/cmake/ConfigureCVC4.cmake new file mode 100644 index 000000000..cfbd1a1c2 --- /dev/null +++ b/cmake/ConfigureCVC4.cmake @@ -0,0 +1,83 @@ +include(CheckCXXSourceCompiles) +include(CheckIncludeFile) +include(CheckIncludeFileCXX) +include(CheckSymbolExists) + +# Check whether "long" and "int64_t" are distinct types w.r.t. overloading. +# Even if they have the same size, they can be distinct, and some platforms +# can have problems with ambiguous function calls when auto-converting +# int64_t to long, and others will complain if you overload a function +# that takes an int64_t with one that takes a long (giving a redefinition +# error). So we have to keep both happy. Probably the same underlying +# issue as the hash specialization below, but let's check separately +# for flexibility. +check_cxx_source_compiles( + " + #include <stdint.h> + void foo(long) {} + void foo(int64_t) {} + int main() { return 0; } + " + CVC4_NEED_INT64_T_OVERLOADS +) +if(NOT CVC4_NEED_INT64_T_OVERLOADS) + set(CVC4_NEED_INT64_T_OVERLOADS 0) +endif() + +# Check to see if this version/architecture of GNU C++ explicitly +# instantiates std::hash<uint64_t> or not. Some do, some don't. +# See src/util/hash.h. +check_cxx_source_compiles( + " + #include <cstdint> + #include <functional> + namespace std { template<> struct hash<uint64_t> {}; } + int main() { return 0; } + " + CVC4_NEED_HASH_UINT64_T_OVERLOAD +) +if(CVC4_NEED_HASH_UINT64_T_OVERLOAD) + add_definitions(-DCVC4_NEED_HASH_UINT64_T) +endif() + +check_include_file(unistd.h HAVE_UNISTD_H) +check_include_file_cxx(ext/stdio_filebuf.h HAVE_EXT_STDIO_FILEBUF_H) + +# For Windows builds check if clock_gettime is available via -lpthread +# (pthread_time.h). +if(CVC4_WINDOWS_BUILD) + set(CMAKE_REQUIRED_FLAGS -pthread) + check_symbol_exists(clock_gettime "time.h" HAVE_CLOCK_GETTIME) + unset(CMAKE_REQUIRED_FLAGS) + if(HAVE_CLOCK_GETTIME) + add_c_cxx_flag(-pthread) + endif() +else() + check_symbol_exists(clock_gettime "time.h" HAVE_CLOCK_GETTIME) +endif() +check_symbol_exists(ffs "strings.h" HAVE_FFS) +check_symbol_exists(optreset "getopt.h" HAVE_DECL_OPTRESET) +check_symbol_exists(sigaltstack "signal.h" HAVE_SIGALTSTACK) +check_symbol_exists(strerror_r "string.h" HAVE_STRERROR_R) +check_symbol_exists(strtok_r "string.h" HAVE_STRTOK_R) + +# Determine if we have the POSIX (int) or GNU (char *) variant of strerror_r. +check_c_source_compiles( + " + #include <string.h> + int main(void) + { + char buf[1]; + char c = *strerror_r(0, buf, 0); + return 0; + } + " + STRERROR_R_CHAR_P +) + +# Defined if using the CLN multi-precision arithmetic library. +set(CVC4_CLN_IMP ${CVC4_USE_CLN_IMP}) +# Defined if using the GMP multi-precision arithmetic library. +set(CVC4_GMP_IMP ${CVC4_USE_GMP_IMP}) +# Define the full name of this package. +set(PACKAGE_NAME "${PROJECT_NAME}") diff --git a/cmake/FindABC.cmake b/cmake/FindABC.cmake new file mode 100644 index 000000000..c44019739 --- /dev/null +++ b/cmake/FindABC.cmake @@ -0,0 +1,41 @@ +# Find ABC +# ABC_FOUND - system has ABC lib +# ABC_INCLUDE_DIR - the ABC include directory +# ABC_LIBRARIES - Libraries needed to use ABC +# ABC_ARCH_FLAGS - Platform specific compile flags + + +# Check default location of ABC built with contrib/get-abc. +if(NOT ABC_HOME) + set(ABC_HOME ${PROJECT_SOURCE_DIR}/abc/alanmi-abc-53f39c11b58d) +endif() + +# Note: We don't check the system version since ABC does not provide a default +# install rule. +find_path(ABC_INCLUDE_DIR + NAMES base/abc/abc.h + PATHS ${ABC_HOME}/src + NO_DEFAULT_PATH) +find_library(ABC_LIBRARIES + NAMES abc + PATHS ${ABC_HOME} + NO_DEFAULT_PATH) +find_program(ABC_ARCH_FLAGS_PROG + NAMES arch_flags + PATHS ${ABC_HOME} + NO_DEFAULT_PATH) + +if(ABC_ARCH_FLAGS_PROG) + execute_process(COMMAND ${ABC_ARCH_FLAGS_PROG} + OUTPUT_VARIABLE ABC_ARCH_FLAGS) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(ABC + DEFAULT_MSG + ABC_INCLUDE_DIR ABC_LIBRARIES ABC_ARCH_FLAGS) + +mark_as_advanced(ABC_INCLUDE_DIR ABC_LIBRARIES ABC_ARCH_FLAGS) +if(ABC_LIBRARIES) + message(STATUS "Found ABC libs: ${ABC_LIBRARIES}") +endif() diff --git a/cmake/FindANTLR.cmake b/cmake/FindANTLR.cmake new file mode 100644 index 000000000..5f574247b --- /dev/null +++ b/cmake/FindANTLR.cmake @@ -0,0 +1,53 @@ +# Find ANTLR +# ANTLR_FOUND - system has ANTLR lib +# ANTLR_BINARY - the ANTLR binary +# ANTLR_INCLUDE_DIR - the ANTLR include directory +# ANTLR_LIBRARIES - Libraries needed to use ANTLR + + +# Check default location of ANTLR built with contrib/get-antlr-3.4. +# If the user provides a directory we will not search the default paths and +# fail if ANTLR was not found in the specified directory. +if(NOT ANTLR_HOME) + set(ANTLR_HOME ${PROJECT_SOURCE_DIR}/antlr-3.4) + set(CHECK_SYSTEM_VERSION TRUE) +endif() + +find_program(ANTLR_BINARY + NAMES antlr3 + PATHS ${ANTLR_HOME}/bin + NO_DEFAULT_PATH) +find_path(ANTLR_INCLUDE_DIR + NAMES antlr3.h + PATHS ${ANTLR_HOME}/include + NO_DEFAULT_PATH) +find_library(ANTLR_LIBRARIES + NAMES antlr3c antlr3c-static + PATHS ${ANTLR_HOME}/lib + NO_DEFAULT_PATH) + +if(CHECK_SYSTEM_VERSION) + find_program(ANTLR_BINARY NAMES antlr3) + find_path(ANTLR_INCLUDE_DIR NAMES antlr3.h) + find_library(ANTLR_LIBRARIES NAMES antlr3c) +endif() + +# Check if antlr3FileStreamNew is available. If not we have to +# define CVC4_ANTLR3_OLD_INPUT_STREAM (src/parser/CMakeLists.txt). +if(ANTLR_INCLUDE_DIR) + include(CheckSymbolExists) + set(CMAKE_REQUIRED_INCLUDES ${ANTLR_INCLUDE_DIR}) + set(CMAKE_REQUIRED_LIBRARIES ${ANTLR_LIBRARIES}) + check_symbol_exists( + antlr3FileStreamNew "antlr3defs.h" HAVE_ANTLR3_FILE_STREAM_NEW) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args( + ANTLR DEFAULT_MSG ANTLR_BINARY ANTLR_INCLUDE_DIR ANTLR_LIBRARIES) + +mark_as_advanced(ANTLR_BINARY ANTLR_INCLUDE_DIR ANTLR_LIBRARIES + HAVE_ANTLR3_FILE_STREAM_NEW) +if(ANTLR_LIBRARIES) + message(STATUS "Found ANTLR libs: ${ANTLR_LIBRARIES}") +endif() diff --git a/cmake/FindCLN.cmake b/cmake/FindCLN.cmake new file mode 100644 index 000000000..7b2e6f0f4 --- /dev/null +++ b/cmake/FindCLN.cmake @@ -0,0 +1,30 @@ +# Find CLN +# CLN_FOUND - system has CLN lib +# CLN_INCLUDE_DIR - the CLN include directory +# CLN_LIBRARIES - Libraries needed to use CLN + +find_path(CLN_INCLUDE_DIR NAMES cln/cln.h) +find_library(CLN_LIBRARIES NAMES cln) + + +if(CLN_INCLUDE_DIR) + file(STRINGS + "${CLN_INCLUDE_DIR}/cln/version.h" version_info + REGEX "^#define[ \t]+CL_VERSION_.*") + string(REGEX REPLACE + "^.*_MAJOR[ \t]+([0-9]+).*" "\\1" version_major "${version_info}") + string(REGEX REPLACE + "^.*_MINOR[ \t]+([0-9]+).*" "\\1" version_minor "${version_info}") + string(REGEX REPLACE + "^.*_PATCHLEVEL[ \t]+([0-9]+).*" "\\1" version_patch "${version_info}") + set(CLN_VERSION ${version_major}.${version_minor}.${version_patch}) + + include(FindPackageHandleStandardArgs) + find_package_handle_standard_args(CLN + REQUIRED_VARS CLN_INCLUDE_DIR CLN_LIBRARIES + VERSION_VAR CLN_VERSION) + mark_as_advanced(CLN_INCLUDE_DIR CLN_LIBRARIES) +endif() +if(CLN_LIBRARIES) + message(STATUS "Found CLN libs: ${CLN_LIBRARIES}") +endif() diff --git a/cmake/FindCaDiCaL.cmake b/cmake/FindCaDiCaL.cmake new file mode 100644 index 000000000..bd7de319a --- /dev/null +++ b/cmake/FindCaDiCaL.cmake @@ -0,0 +1,37 @@ +# Find CaDiCaL +# CaDiCaL_FOUND - system has CaDiCaL lib +# CaDiCaL_INCLUDE_DIR - the CaDiCaL include directory +# CaDiCaL_LIBRARIES - Libraries needed to use CaDiCaL + + +# Check default location of CaDiCaL built with contrib/get-cadical. +# If the user provides a directory we will not search the default paths and +# fail if CaDiCaL was not found in the specified directory. +if(NOT CaDiCaL_HOME) + set(CaDiCaL_HOME ${PROJECT_SOURCE_DIR}/cadical) + set(CHECK_SYSTEM_VERSION TRUE) +endif() + +find_path(CaDiCaL_INCLUDE_DIR + NAMES cadical.hpp + PATHS ${CaDiCaL_HOME}/src + NO_DEFAULT_PATH) +find_library(CaDiCaL_LIBRARIES + NAMES cadical + PATHS ${CaDiCaL_HOME}/build + NO_DEFAULT_PATH) + +if(CHECK_SYSTEM_VERSION) + find_path(CaDiCaL_INCLUDE_DIR NAMES cadical.hpp) + find_library(CaDiCaL_LIBRARIES NAMES cadical) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(CaDiCaL + DEFAULT_MSG + CaDiCaL_INCLUDE_DIR CaDiCaL_LIBRARIES) + +mark_as_advanced(CaDiCaL_INCLUDE_DIR CaDiCaL_LIBRARIES) +if(CaDiCaL_LIBRARIES) + message(STATUS "Found CaDiCaL libs: ${CaDiCaL_LIBRARIES}") +endif() diff --git a/cmake/FindCryptoMiniSat.cmake b/cmake/FindCryptoMiniSat.cmake new file mode 100644 index 000000000..7806b242d --- /dev/null +++ b/cmake/FindCryptoMiniSat.cmake @@ -0,0 +1,37 @@ +# Find CryptoMiniSat +# CryptoMiniSat_FOUND - system has CryptoMiniSat lib +# CryptoMiniSat_INCLUDE_DIR - the CryptoMiniSat include directory +# CryptoMiniSat_LIBRARIES - Libraries needed to use CryptoMiniSat + + +# Check default location of CryptoMiniSat built with contrib/get-cryptominisat. +# If the user provides a directory we will not search the default paths and +# fail if CryptoMiniSat was not found in the specified directory. +if(NOT CryptoMiniSat_HOME) + set(CryptoMiniSat_HOME ${PROJECT_SOURCE_DIR}/cryptominisat5/install) + set(CHECK_SYSTEM_VERSION TRUE) +endif() + +find_path(CryptoMiniSat_INCLUDE_DIR + NAMES cryptominisat5/cryptominisat.h + PATHS ${CryptoMiniSat_HOME}/include + NO_DEFAULT_PATH) +find_library(CryptoMiniSat_LIBRARIES + NAMES cryptominisat5 + PATHS ${CryptoMiniSat_HOME}/lib + NO_DEFAULT_PATH) + +if(CHECK_SYSTEM_VERSION) + find_path(CryptoMiniSat_INCLUDE_DIR NAMES cryptominisat5/cryptominisat.h) + find_library(CryptoMiniSat_LIBRARIES NAMES cryptominisat5) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(CryptoMiniSat + DEFAULT_MSG + CryptoMiniSat_INCLUDE_DIR CryptoMiniSat_LIBRARIES) + +mark_as_advanced(CryptoMiniSat_INCLUDE_DIR CryptoMiniSat_LIBRARIES) +if(CryptoMiniSat_LIBRARIES) + message(STATUS "Found CryptoMiniSat libs: ${CryptoMiniSat_LIBRARIES}") +endif() diff --git a/cmake/FindGLPK.cmake b/cmake/FindGLPK.cmake new file mode 100644 index 000000000..1587ca821 --- /dev/null +++ b/cmake/FindGLPK.cmake @@ -0,0 +1,49 @@ +# Find GLPK-cut-log +# GLPK_FOUND - system has GLPK lib +# GLPK_INCLUDE_DIR - the GLPK include directory +# GLPK_LIBRARIES - Libraries needed to use GLPK + + +# Check default location of GLPK built with contrib/get-glpk-cut-log. +# If the user provides a directory we will not search the default paths and +# fail if GLPK was not found in the specified directory. +if(NOT GLPK_HOME) + set(GLPK_HOME ${PROJECT_SOURCE_DIR}/glpk-cut-log) + set(CHECK_SYSTEM_VERSION TRUE) +endif() + +find_path(GLPK_INCLUDE_DIR + NAMES glpk.h + PATHS ${GLPK_HOME}/include + NO_DEFAULT_PATH) +find_library(GLPK_LIBRARIES + NAMES glpk + PATHS ${GLPK_HOME}/lib + NO_DEFAULT_PATH) + +if(CHECK_SYSTEM_VERSION) + find_path(GLPK_INCLUDE_DIR NAMES glpk.h) + find_library(GLPK_LIBRARIES NAMES glpk) +endif() + +# Check if we really have GLPK-cut-log. +if(GLPK_INCLUDE_DIR) + include(CheckSymbolExists) + set(CMAKE_REQUIRED_INCLUDES ${GLPK_INCLUDE_DIR}) + set(CMAKE_REQUIRED_LIBRARIES ${GLPK_LIBRARIES} m) + check_symbol_exists(glp_ios_get_cut "glpk.h" HAVE_GLPK_CUT_LOG) + if(NOT HAVE_GLPK_CUT_LOG) + message(FATAL_ERROR "Could not link against GLPK-cut-log. " + "Did you forget to install GLPK-cut-log?") + endif() +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(GLPK + DEFAULT_MSG + GLPK_INCLUDE_DIR GLPK_LIBRARIES) + +mark_as_advanced(GLPK_INCLUDE_DIR GLPK_LIBRARIES) +if(GLPK_LIBRARIES) + message(STATUS "Found GLPK libs: ${GLPK_LIBRARIES}") +endif() diff --git a/cmake/FindGMP.cmake b/cmake/FindGMP.cmake new file mode 100644 index 000000000..8125a583b --- /dev/null +++ b/cmake/FindGMP.cmake @@ -0,0 +1,35 @@ +# Find GMP +# GMP_FOUND - system has GMP lib +# GMP_INCLUDE_DIR - the GMP include directory +# GMP_LIBRARIES - Libraries needed to use GMP + + +# Check default location of GMP built with contrib/get-gmp. +# If the user provides a directory we will not search the default paths and +# fail if GMP was not found in the specified directory. +if(NOT GMP_HOME) + set(GMP_HOME ${PROJECT_SOURCE_DIR}/gmp-6.1.2) + set(CHECK_SYSTEM_VERSION TRUE) +endif() + +find_path(GMP_INCLUDE_DIR + NAMES gmp.h gmpxx.h + PATHS ${GMP_HOME}/include + NO_DEFAULT_PATH) +find_library(GMP_LIBRARIES + NAMES gmp + PATHS ${GMP_HOME}/lib + NO_DEFAULT_PATH) + +if(CHECK_SYSTEM_VERSION) + find_path(GMP_INCLUDE_DIR NAMES gmp.h gmpxx.h) + find_library(GMP_LIBRARIES NAMES gmp) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(GMP DEFAULT_MSG GMP_INCLUDE_DIR GMP_LIBRARIES) + +mark_as_advanced(GMP_INCLUDE_DIR GMP_LIBRARIES) +if(GMP_LIBRARIES) + message(STATUS "Found GMP libs: ${GMP_LIBRARIES}") +endif() diff --git a/cmake/FindHamcrest.cmake b/cmake/FindHamcrest.cmake new file mode 100644 index 000000000..96fde96ba --- /dev/null +++ b/cmake/FindHamcrest.cmake @@ -0,0 +1,13 @@ +# Find Hamcrest +# Hamcrest_FOUND - system has Hamcrest lib +# Hamcrest_JAR - the Hamcrest jar file + +find_package(Java REQUIRED) +include(UseJava) + +find_jar(Hamcrest_JAR hamcrest-core) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(Hamcrest DEFAULT_MSG Hamcrest_JAR) + +mark_as_advanced(Hamcrest_JAR) diff --git a/cmake/FindJUnit.cmake b/cmake/FindJUnit.cmake new file mode 100644 index 000000000..1fd4ebb2d --- /dev/null +++ b/cmake/FindJUnit.cmake @@ -0,0 +1,26 @@ +# Find JUnit +# JUnit_FOUND - system has JUnit lib +# JUnit_JAR - JUnit jar file +# JUnit_JAR_DEPS - JUnit jar dependencies + +find_package(Java REQUIRED) +include(UseJava) +find_package(Hamcrest REQUIRED) + +find_jar(JUnit_JAR NAMES junit junit4) + +if(JUnit_JAR) + set(JUnit_JAR_DEPS ${Hamcrest_JAR}) + # Determine version of JUnit + execute_process( + COMMAND ${Java_JAVA_EXECUTABLE} -cp ${JUnit_JAR} junit.runner.Version + OUTPUT_VARIABLE JUnit_VERSION + OUTPUT_STRIP_TRAILING_WHITESPACE) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(JUnit + REQUIRED_VARS JUnit_JAR JUnit_JAR_DEPS + VERSION_VAR JUnit_VERSION) + +mark_as_advanced(JUnit_JAR JUnit_JAR_DEPS) diff --git a/cmake/FindLFSC.cmake b/cmake/FindLFSC.cmake new file mode 100644 index 000000000..7a666839b --- /dev/null +++ b/cmake/FindLFSC.cmake @@ -0,0 +1,37 @@ +# Find LFSC +# LFSC_FOUND - system has LFSC lib +# LFSC_INCLUDE_DIR - the LFSC include directory +# LFSC_LIBRARIES - Libraries needed to use LFSC + + +# Check default location of LFSC built with contrib/get-lfsc. +# If the user provides a directory we will not search the default paths and +# fail if LFSC was not found in the specified directory. +if(NOT LFSC_HOME) + set(LFSC_HOME ${PROJECT_SOURCE_DIR}/lfsc-checker/install) + set(CHECK_SYSTEM_VERSION TRUE) +endif() + +find_path(LFSC_INCLUDE_DIR + NAMES lfscc.h + PATHS ${LFSC_HOME}/include + NO_DEFAULT_PATH) +find_library(LFSC_LIBRARIES + NAMES lfscc + PATHS ${LFSC_HOME}/lib + NO_DEFAULT_PATH) + +if(CHECK_SYSTEM_VERSION) + find_path(LFSC_INCLUDE_DIR NAMES lfscc.h) + find_library(LFSC_LIBRARIES NAMES lfscc) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(LFSC + DEFAULT_MSG + LFSC_INCLUDE_DIR LFSC_LIBRARIES) + +mark_as_advanced(LFSC_INCLUDE_DIR LFSC_LIBRARIES) +if(LFSC_LIBRARIES) + message(STATUS "Found LFSC libs: ${LFSC_LIBRARIES}") +endif() diff --git a/cmake/FindReadline.cmake b/cmake/FindReadline.cmake new file mode 100644 index 000000000..edac03027 --- /dev/null +++ b/cmake/FindReadline.cmake @@ -0,0 +1,69 @@ +# Find Readline +# Readline_FOUND - system has Readline lib +# Readline_INCLUDE_DIR - the Readline include directory +# Readline_LIBRARIES - Libraries needed to use Readline +# Readline_COMPENTRY_FUNC_RETURNS_CHARPTR - Indicates if compentry function +# returns a (char *) + +find_path(Readline_INCLUDE_DIR NAMES readline/readline.h) +find_library(Readline_LIBRARIES NAMES readline) + +# Try to compile and link a simple program against readline. 'libs' can be +# used to specify additional required libraries. +function(try_compile_readline libs _result) + set(CMAKE_REQUIRED_QUIET TRUE) + set(CMAKE_REQUIRED_LIBRARIES ${Readline_LIBRARIES} ${libs}) + check_cxx_source_compiles( + " + #include <stdio.h> + #include <readline/readline.h> + int main() { readline(\"\"); return 0; } + " + ${_result} + ) + set(${_result} ${${_result}} PARENT_SCOPE) +endfunction() + +if(Readline_INCLUDE_DIR) + # We only need to figure out readline's additional libraries dependencies if + # we compile static. + # Note: It might be the case that we need to check for more/other libraries + # depending on what the installed version of readline is linked against + # (e.g., termcap, ncurses, ...). + find_library(TINFO_LIBRARY tinfo) + try_compile_readline(${TINFO_LIBRARY} OK) + if(OK) + list(APPEND Readline_LIBRARIES ${TINFO_LIBRARY}) + else() + message(FATAL_ERROR + "Could not link against readline. " + "Check CMakeError.log for more details") + endif() + + # Check which standard of readline is installed on the system. + # https://github.com/CVC4/CVC4/issues/702 + include(CheckCXXSourceCompiles) + set(CMAKE_REQUIRED_QUIET TRUE) + set(CMAKE_REQUIRED_LIBRARIES ${Readline_LIBRARIES}) + check_cxx_source_compiles( + "#include <stdio.h> + #include <readline/readline.h> + char* foo(const char*, int) { return (char*)0; } + int main() { rl_completion_entry_function = foo; return 0; }" + Readline_COMPENTRY_FUNC_RETURNS_CHARPTR + ) + unset(CMAKE_REQUIRED_QUIET) + unset(CMAKE_REQUIRED_LIBRARIES) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(Readline + DEFAULT_MSG Readline_INCLUDE_DIR Readline_LIBRARIES) +mark_as_advanced( + Readline_INCLUDE_DIR + Readline_LIBRARIES + Readline_COMPENTRY_FUNC_RETURNS_CHARPTR +) +if(Readline_LIBRARIES) + message(STATUS "Found Readline libs: ${Readline_LIBRARIES}") +endif() diff --git a/cmake/FindSymFPU.cmake b/cmake/FindSymFPU.cmake new file mode 100644 index 000000000..f0f9ebf0f --- /dev/null +++ b/cmake/FindSymFPU.cmake @@ -0,0 +1,26 @@ +# Find SymFPU +# SymFPU_FOUND - system has SymFPU lib +# SymFPU_INCLUDE_DIR - the SymFPU include directory + + +# Check default location of SymFPU built with contrib/get-symfpu. +# If the user provides a directory we will not search the default paths and +# fail if SymFPU was not found in the specified directory. +if(NOT SymFPU_HOME) + set(SymFPU_HOME ${PROJECT_SOURCE_DIR}/symfpu-CVC4) + set(CHECK_SYSTEM_VERSION TRUE) +endif() + +find_path(SymFPU_INCLUDE_DIR + NAMES symfpu/core/unpackedFloat.h + PATHS ${SymFPU_HOME} + NO_DEFAULT_PATH) + +if(CHECK_SYSTEM_VERSION) + find_path(SymFPU_INCLUDE_DIR NAMES symfpu/core/unpackedFloat.h) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(SymFPU DEFAULT_MSG SymFPU_INCLUDE_DIR) + +mark_as_advanced(SymFPU_INCLUDE_DIR) diff --git a/cmake/FindValgrind.cmake b/cmake/FindValgrind.cmake new file mode 100644 index 000000000..4c5cb1d28 --- /dev/null +++ b/cmake/FindValgrind.cmake @@ -0,0 +1,11 @@ +# Find Valgrind +# Valgrind_FOUND - system has Valgrind lib +# Valgrind_INCLUDE_DIR - the Valgrind include directory +# +# Note: We only require the valgrind/memcheck.h header, so we don't check if +# the valgrind executable is installed. + +find_path(Valgrind_INCLUDE_DIR NAMES valgrind/memcheck.h) + +find_package_handle_standard_args(Valgrind REQUIRED_VARS Valgrind_INCLUDE_DIR) +mark_as_advanced(Valgrind_INCLUDE_DIR) diff --git a/cmake/Helpers.cmake b/cmake/Helpers.cmake new file mode 100644 index 000000000..692e32900 --- /dev/null +++ b/cmake/Helpers.cmake @@ -0,0 +1,157 @@ +include(CheckCCompilerFlag) +include(CheckCXXCompilerFlag) + +# Add a C flag to the global list of C flags. +macro(add_c_flag flag) + if(CMAKE_C_FLAGS) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}") + else() + set(CMAKE_C_FLAGS "${flag}") + endif() + message(STATUS "Configuring with C flag '${flag}'") +endmacro() + +# Add a CXX flag to the global list of CXX flags. +macro(add_cxx_flag flag) + if(CMAKE_CXX_FLAGS) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}") + else() + set(CMAKE_CXX_FLAGS "${flag}") + endif() + message(STATUS "Configuring with CXX flag '${flag}'") +endmacro() + +# Add a C and CXX flag to the global list of C/CXX flags. +macro(add_c_cxx_flag flag) + add_c_flag(${flag}) + add_cxx_flag(${flag}) +endmacro() + +# Check if C flag is supported and add to global list of C flags. +macro(add_check_c_flag flag) + string(REGEX REPLACE "[-=]" "_" flagname ${flag}) + check_c_compiler_flag("${flag}" HAVE_FLAG${flagname}) + if(HAVE_FLAG${flagname}) + add_c_flag(${flag}) + endif() +endmacro() + +# Check if CXX flag is supported and add to global list of CXX flags. +macro(add_check_cxx_flag flag) + string(REGEX REPLACE "[-=]" "_" flagname ${flag}) + check_cxx_compiler_flag("${flag}" HAVE_FLAG${flagname}) + if(HAVE_FLAG${flagname}) + add_cxx_flag(${flag}) + endif() +endmacro() + +# Check if C/CXX flag is supported and add to global list of C/CXX flags. +macro(add_check_c_cxx_flag flag) + add_check_c_flag(${flag}) + add_check_cxx_flag(${flag}) +endmacro() + +# Add required CXX flag. Configuration fails if the CXX flag is not supported +# by the compiler. +macro(add_required_cxx_flag flag) + string(REGEX REPLACE "[-=]" "_" flagnamename ${flag}) + check_cxx_compiler_flag("${flag}" HAVE_FLAG${flagname}) + if (NOT HAVE_FLAG${flagname}) + message(FATAL_ERROR "Required compiler flag ${flag} not supported") + endif() + add_cxx_flag(${flag}) +endmacro() + +# Add required C flag. Configuration fails if the C flag is not supported by +# the compiler. +macro(add_required_c_flag flag) + string(REGEX REPLACE "[-=]" "_" flagname ${flag}) + check_c_compiler_flag("${flag}" HAVE_FLAG${flagname}) + if (NOT HAVE_FLAG${flagname}) + message(FATAL_ERROR "Required compiler flag ${flag} not supported") + endif() + add_c_flag(${flag}) +endmacro() + +# Add requied C/CXX flag. Configuration fails if the C/CXX flag is not +# supported by the compiler. +macro(add_required_c_cxx_flag flag) + add_required_c_flag(${flag}) + add_required_cxx_flag(${flag}) +endmacro() + +# CVC4 Boolean options are three-valued to detect if an option was set by the +# user. The available values are: IGNORE (default), ON, OFF +# Default options do not override options that were set by the user, i.e., +# cvc4_set_option only sets an option if it's value is still IGNORE. +# This e.g., allows the user to disable proofs for debug builds (where proofs +# are enabled by default). +macro(cvc4_option var description) + set(${var} IGNORE CACHE STRING "${description}") + # Provide drop down menu options in cmake-gui + set_property(CACHE ${var} PROPERTY STRINGS IGNORE ON OFF) +endmacro() + +# Only set option if the user did not set an option. +macro(cvc4_set_option var value) + if(${var} STREQUAL "IGNORE") + set(${var} ${value}) + endif() +endmacro() + +# Prepend 'prepand_value' to each element of the list 'in_list'. The result +# is stored in 'out_list'. +function(list_prepend in_list prepand_value out_list) + foreach(_elem ${${in_list}}) + list(APPEND ${out_list} "${prepand_value}${_elem}") + endforeach() + set(${out_list} ${${out_list}} PARENT_SCOPE) +endfunction() + +# Helper to print the configuration of a 2-valued or 3-valued option 'var' +# with prefix 'str'. +macro(print_config str var) + if(${var} STREQUAL "ON") + set(OPT_VAL_STR "on") + else() + set(OPT_VAL_STR "off") + endif() + message("${str} ${OPT_VAL_STR}") +endmacro() + + +# Collect all source files that are required to build libcvc4 in LIBCVC4_SRCS +# or LIBCVC4_GEN_SRCS. If GENERATED is the first argument the sources are +# added to LIBCVC4_GEN_SRCS. All sources are prepended with the absolute +# current path path. CMAKE_CURRENT_BINARY_DIR is prepended +# to generated source files. +macro(libcvc4_add_sources) + set(_sources ${ARGV}) + + # Check if the first argument is GENERATED. + list(GET _sources 0 _generated) + if(${_generated} STREQUAL "GENERATED") + list(REMOVE_AT _sources 0) + set(_cur_path ${CMAKE_CURRENT_BINARY_DIR}) + set(_append_to LIBCVC4_GEN_SRCS) + else() + set(_cur_path ${CMAKE_CURRENT_SOURCE_DIR}) + set(_append_to LIBCVC4_SRCS) + endif() + + # Prepend source files with current path. + foreach(_src ${_sources}) + list(APPEND ${_append_to} "${_cur_path}/${_src}") + endforeach() + + file(RELATIVE_PATH + _rel_path "${PROJECT_SOURCE_DIR}/src" "${CMAKE_CURRENT_SOURCE_DIR}") + + # Make changes to list ${_append_to} visible to the parent scope if not + # called from src/. + # Note: ${_append_to} refers to the variable name whereas ${${_append_to}} + # refers to the contents of the variable. + if(_rel_path) + set(${_append_to} ${${_append_to}} PARENT_SCOPE) + endif() +endmacro() diff --git a/cmake/Toolchain-mingw64.cmake b/cmake/Toolchain-mingw64.cmake new file mode 100644 index 000000000..85c0622ed --- /dev/null +++ b/cmake/Toolchain-mingw64.cmake @@ -0,0 +1,23 @@ +# Toolchain file for building for Windows from Ubuntu. +# +# Use: cmake .. -DCMAKE_TOOLCHAIN_FILE=../cmake/Toolchain-mingw64.cmake + +SET(CMAKE_SYSTEM_NAME Windows) + +set(TOOLCHAIN_PREFIX x86_64-w64-mingw32) + +SET(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}-gcc) +SET(CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}-g++) +SET(CMAKE_RC_COMPILER ${TOOLCHAIN_PREFIX}-windres) + +# Set target environment path +SET(CMAKE_FIND_ROOT_PATH /usr/${TOOLCHAIN_PREFIX}) + +# Adjust the default behaviour of the find_XXX() commands: +# search headers and libraries in the target environment, search +# programs in the host environment +set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY BOTH) +set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE BOTH) + +set(CVC4_WINDOWS_BUILD TRUE) diff --git a/configure.sh b/configure.sh new file mode 100755 index 000000000..16764dd8a --- /dev/null +++ b/configure.sh @@ -0,0 +1,424 @@ +#!/bin/sh +#--------------------------------------------------------------------------# + +usage () { +cat <<EOF +Usage: $0 [<build type>] [<option> ...] + +Build types: + production + debug + testing + competition + + +General options; + -h, --help display this help and exit + --prefix=STR install directory + --program-prefix=STR prefix of binaries prepended on make install + --name=STR use custom build directory name (optionally: +path) + --best turn on dependencies known to give best performance + --gpl permit GPL dependencies, if available + --win64 cross-compile for Windows 64 bit + + +Features: +The following flags enable optional features (disable with --no-<option name>). + --static build static libraries and binaries [default=no] + --proofs support for proof generation + --optimized optimize the build + --debug-symbols include debug symbols + --valgrind Valgrind instrumentation + --debug-context-mm use the debug context memory manager + --statistics include statistics + --replay turn on the replay feature + --assertions turn on assertions + --tracing include tracing code + --dumping include dumping code + --muzzle complete silence (no non-result output) + --coverage support for gcov coverage testing + --profiling support for gprof profiling + --unit-testing support for unit testing + --python2 prefer using Python 2 (also for Python bindings) + --python3 prefer using Python 3 (also for Python bindings) + +The following options configure parameterized features. + + --language-bindings[=java,python,all] + specify language bindings to build + +Optional Packages: +The following flags enable optional packages (disable with --no-<option name>). + --cln use CLN instead of GMP + --gmp use GMP instead of CLN + --glpk use GLPK simplex solver + --abc use the ABC AIG library + --cadical use the CaDiCaL SAT solver + --cryptominisat use the CryptoMiniSat sat solver + --lfsc use the LFSC proof checker + --symfpu use SymFPU for floating point solver + --portfolio build the multithreaded portfolio version of CVC4 + (pcvc4) + --readline support the readline library + +Optional Path to Optional Packages: + --abc-dir=PATH path to top level of ABC source tree + --antlr-dir=PATH path to ANTLR C headers and libraries + --cadical-dir=PATH path to top level of CaDiCaL source tree + --cryptominisat-dir=PATH path to top level of CryptoMiniSat source tree + --cxxtest-dir=DIR path to CxxTest installation + --glpk-dir=PATH path to top level of GLPK installation + --gmp-dir=PATH path to top level of GMP installation + --lfsc-dir=PATH path to top level of LFSC source tree + --symfpu-dir=PATH path to top level of SymFPU source tree + +Report bugs to <cvc4-bugs@cs.stanford.edu>. +EOF + exit 0 +} + +#--------------------------------------------------------------------------# + +die () { + echo "*** configure.sh: $*" 1>&2 + exit 1 +} + +msg () { + echo "[configure.sh] $*" +} + +#--------------------------------------------------------------------------# + +[ ! -e src/theory ] && die "$0 not called from CVC4 base directory" + +#--------------------------------------------------------------------------# + +build_dir=build +install_prefix=default +program_prefix="" + +#--------------------------------------------------------------------------# + +buildtype=default + +abc=default +asan=default +assertions=default +best=default +cadical=default +cln=default +coverage=default +cryptominisat=default +debug_symbols=default +debug_context_mm=default +dumping=default +gpl=default +win64=default +glpk=default +lfsc=default +muzzle=default +optimized=default +portfolio=default +proofs=default +replay=default +shared=default +statistics=default +symfpu=default +tracing=default +unit_testing=default +python2=default +python3=default +valgrind=default +profiling=default +readline=default + +language_bindings_java=default +language_bindings_python=default + +abc_dir=default +antlr_dir=default +cadical_dir=default +cryptominisat_dir=default +glpk_dir=default +gmp_dir=default +lfsc_dir=default +symfpu_dir=default + +#--------------------------------------------------------------------------# + +while [ $# -gt 0 ] +do + case $1 in + + -h|--help) usage;; + + --abc) abc=ON;; + --no-abc) abc=OFF;; + + --asan) asan=ON;; + --no-asan) asan=OFF;; + + --assertions) assertions=ON;; + --no-assertions) assertions=OFF;; + + --best) best=ON;; + --no-best) best=OFF;; + + --prefix) die "missing argument to $1 (try -h)" ;; + --prefix=*) + install_prefix=${1##*=} + # Check if install_prefix is an absolute path and if not, make it + # absolute. + case $install_prefix in + /*) ;; # absolute path + *) install_prefix=$(pwd)/$install_prefix ;; # make absolute path + esac + ;; + + --program-prefix) die "missing argument to $1 (try -h)" ;; + --program-prefix=*) program_prefix=${1##*=} ;; + + --name) die "missing argument to $1 (try -h)" ;; + --name=*) build_dir=${1##*=} ;; + + --cadical) cadical=ON;; + --no-cadical) cadical=OFF;; + + --cln) cln=ON;; + --no-cln) cln=OFF;; + + --coverage) coverage=ON;; + --no-coverage) coverage=OFF;; + + --cryptominisat) cryptominisat=ON;; + --no-cryptominisat) cryptominisat=OFF;; + + --debug-symbols) debug_symbols=ON;; + --no-debug-symbols) debug_symbols=OFF;; + + --debug-context-memory-manager) debug_context_mm=ON;; + --no-debug-context-memory-manager) debug_context_mm=OFF;; + + --dumping) dumping=ON;; + --no-dumping) dumping=OFF;; + + --gpl) gpl=ON;; + --no-gpl) gpl=OFF;; + + --win64) win64=ON;; + --no-win64) win64=OFF;; + + --glpk) glpk=ON;; + --no-glpk) glpk=OFF;; + + --lfsc) lfsc=ON;; + --no-lfsc) lfsc=OFF;; + + --muzzle) muzzle=ON;; + --no-muzzle) muzzle=OFF;; + + --optimized) optimized=ON;; + --no-optimized) optimized=OFF;; + + --portfolio) portfolio=ON;; + --no-portfolio) portfolio=OFF;; + + --proofs) proofs=ON;; + --no-proofs) proofs=OFF;; + + --replay) replay=ON;; + --no-replay) replay=OFF;; + + --static) shared=OFF;; + --no-static) shared=ON;; + + --statistics) statistics=ON;; + --no-statistics) statistics=OFF;; + + --symfpu) symfpu=ON;; + --no-symfpu) symfpu=OFF;; + + --tracing) tracing=ON;; + --no-tracing) tracing=OFF;; + + --unit-testing) unit_testing=ON;; + --no-unit-testing) unit_testing=OFF;; + + --python2) python2=ON;; + --no-python2) python2=OFF;; + + --python3) python3=ON;; + --no-python3) python3=OFF;; + + --valgrind) valgrind=ON;; + --no-valgrind) valgrind=OFF;; + + --profiling) profiling=ON;; + --no-profiling) profiling=OFF;; + + --readline) readline=ON;; + --no-readline) readline=OFF;; + + --language-bindings) die "missing argument to $1 (try -h)" ;; + --language-bindings=*) + lang="${1##*=}" + IFS=',' + for l in $lang; do + case $l in + java) language_bindings_java=ON ;; + python) language_bindings_python=ON ;; + all) + language_bindings_python=ON + language_bindings_java=ON ;; + *) die "invalid language binding '$l' specified (try -h)" ;; + esac + done + unset IFS + ;; + + --abc-dir) die "missing argument to $1 (try -h)" ;; + --abc-dir=*) abc_dir=${1##*=} ;; + + --antlr-dir) die "missing argument to $1 (try -h)" ;; + --antlr-dir=*) antlr_dir=${1##*=} ;; + + --cadical-dir) die "missing argument to $1 (try -h)" ;; + --cadical-dir=*) cadical_dir=${1##*=} ;; + + --cryptominisat-dir) die "missing argument to $1 (try -h)" ;; + --cryptominisat-dir=*) cryptominisat_dir=${1##*=} ;; + + --glpk-dir) die "missing argument to $1 (try -h)" ;; + --glpk-dir=*) glpk_dir=${1##*=} ;; + + --gmp-dir) die "missing argument to $1 (try -h)" ;; + --gmp-dir=*) gmp_dir=${1##*=} ;; + + --lfsc-dir) die "missing argument to $1 (try -h)" ;; + --lfsc-dir=*) lfsc_dir=${1##*=} ;; + + --symfpu-dir) die "missing argument to $1 (try -h)" ;; + --symfpu-dir=*) symfpu_dir=${1##*=} ;; + + -*) die "invalid option '$1' (try -h)";; + + *) case $1 in + production) buildtype=Production;; + debug) buildtype=Debug;; + testing) buildtype=Testing;; + competition) buildtype=Competition;; + *) die "invalid build type (try -h)";; + esac + ;; + esac + shift +done + +#--------------------------------------------------------------------------# + +cmake_opts="" + +[ $buildtype != default ] \ + && cmake_opts="$cmake_opts -DCMAKE_BUILD_TYPE=$buildtype" + +[ $asan != default ] \ + && cmake_opts="$cmake_opts -DENABLE_ASAN=$asan" +[ $assertions != default ] \ + && cmake_opts="$cmake_opts -DENABLE_ASSERTIONS=$assertions" +[ $best != default ] \ + && cmake_opts="$cmake_opts -DENABLE_BEST=$best" +[ $coverage != default ] \ + && cmake_opts="$cmake_opts -DENABLE_COVERAGE=$coverage" +[ $debug_symbols != default ] \ + && cmake_opts="$cmake_opts -DENABLE_DEBUG_SYMBOLS=$debug_symbols" +[ $debug_context_mm != default ] \ + && cmake_opts="$cmake_opts -DENABLE_DEBUG_CONTEXT_MM=$debug_context_mm" +[ $dumping != default ] \ + && cmake_opts="$cmake_opts -DENABLE_DUMPING=$dumping" +[ $gpl != default ] \ + && cmake_opts="$cmake_opts -DENABLE_GPL=$gpl" +[ $win64 != default ] \ + && cmake_opts="$cmake_opts -DCMAKE_TOOLCHAIN_FILE=../cmake/Toolchain-mingw64.cmake" +[ $muzzle != default ] \ + && cmake_opts="$cmake_opts -DENABLE_MUZZLE=$muzzle" +[ $optimized != default ] \ + && cmake_opts="$cmake_opts -DENABLE_OPTIMIZED=$optimized" +[ $portfolio != default ] \ + && cmake_opts="$cmake_opts -DENABLE_PORTFOLIO=$portfolio" +[ $proofs != default ] \ + && cmake_opts="$cmake_opts -DENABLE_PROOFS=$proofs" +[ $replay != default ] \ + && cmake_opts="$cmake_opts -DENABLE_REPLAY=$replay" +[ $shared != default ] \ + && cmake_opts="$cmake_opts -DENABLE_SHARED=$shared" +[ $statistics != default ] \ + && cmake_opts="$cmake_opts -DENABLE_STATISTICS=$statistics" +[ $tracing != default ] \ + && cmake_opts="$cmake_opts -DENABLE_TRACING=$tracing" +[ $unit_testing != default ] \ + && cmake_opts="$cmake_opts -DENABLE_UNIT_TESTING=$unit_testing" +[ $python2 != default ] \ + && cmake_opts="$cmake_opts -DUSE_PYTHON2=$python2" +[ $python3 != default ] \ + && cmake_opts="$cmake_opts -DUSE_PYTHON3=$python3" +[ $valgrind != default ] \ + && cmake_opts="$cmake_opts -DENABLE_VALGRIND=$valgrind" +[ $profiling != default ] \ + && cmake_opts="$cmake_opts -DENABLE_PROFILING=$profiling" +[ $readline != default ] \ + && cmake_opts="$cmake_opts -DUSE_READLINE=$readline" +[ $abc != default ] \ + && cmake_opts="$cmake_opts -DUSE_ABC=$abc" +[ $cadical != default ] \ + && cmake_opts="$cmake_opts -DUSE_CADICAL=$cadical" +[ $cln != default ] \ + && cmake_opts="$cmake_opts -DUSE_CLN=$cln" +[ $cryptominisat != default ] \ + && cmake_opts="$cmake_opts -DUSE_CRYPTOMINISAT=$cryptominisat" +[ $glpk != default ] \ + && cmake_opts="$cmake_opts -DUSE_GLPK=$glpk" +[ $lfsc != default ] \ + && cmake_opts="$cmake_opts -DUSE_LFSC=$lfsc" +[ $symfpu != default ] \ + && cmake_opts="$cmake_opts -DUSE_SYMFPU=$symfpu" + +[ $language_bindings_java != default ] \ + && cmake_opts="$cmake_opts -DBUILD_BINDINGS_JAVA=$language_bindings_java" +[ $language_bindings_python != default ] \ + && cmake_opts="$cmake_opts -DBUILD_BINDINGS_PYTHON=$language_bindings_python" + +[ "$abc_dir" != default ] \ + && cmake_opts="$cmake_opts -DABC_DIR=$abc_dir" +[ "$antlr_dir" != default ] \ + && cmake_opts="$cmake_opts -DANTLR_DIR=$antlr_dir" +[ "$cadical_dir" != default ] \ + && cmake_opts="$cmake_opts -DCADICAL_DIR=$cadical_dir" +[ "$cryptominisat_dir" != default ] \ + && cmake_opts="$cmake_opts -DCRYPTOMINISAT_DIR=$cryptominisat_dir" +[ "$glpk_dir" != default ] \ + && cmake_opts="$cmake_opts -DGLPK_DIR=$glpk_dir" +[ "$gmp_dir" != default ] \ + && cmake_opts="$cmake_opts -DGMP_DIR=$gmp_dir" +[ "$lfsc_dir" != default ] \ + && cmake_opts="$cmake_opts -DLFSC_DIR=$lfsc_dir" +[ "$symfpu_dir" != default ] \ + && cmake_opts="$cmake_opts -DSYMFPU_DIR=$symfpu_dir" +[ "$install_prefix" != default ] \ + && cmake_opts="$cmake_opts -DCMAKE_INSTALL_PREFIX=$install_prefix" +[ -n "$program_prefix" ] \ + && cmake_opts="$cmake_opts -DPROGRAM_PREFIX=$program_prefix" + +root_dir=$(pwd) + +# The cmake toolchain can't be changed once it is configured in $build_dir. +# Thus, remove $build_dir and create an empty directory. +[ $win64 = ON ] && [ -e "$build_dir" ] && rm -r "$build_dir" +mkdir -p "$build_dir" + +cd "$build_dir" || exit 1 + +[ -e CMakeCache.txt ] && rm CMakeCache.txt +build_dir_escaped=$(echo "$build_dir" | sed 's/\//\\\//g') +cmake "$root_dir" $cmake_opts 2>&1 | \ + sed "s/^Now just/Now change to '$build_dir_escaped' and/" diff --git a/contrib/get-win-dependencies b/contrib/get-win-dependencies index 5ca969f6b..f3fbd6cf7 100755 --- a/contrib/get-win-dependencies +++ b/contrib/get-win-dependencies @@ -24,7 +24,7 @@ while getopts ":s" opt; do done if [ -z "$HOST" ]; then - HOST=i686-w64-mingw32 + HOST=x86_64-w64-mingw32 echo "WARNING:" echo "WARNING: Using default HOST value: $HOST" echo "WARNING: You should probably run this script like this:" diff --git a/cvc4autoconfig.new.h.in b/cvc4autoconfig.new.h.in new file mode 100644 index 000000000..ce8aeb5da --- /dev/null +++ b/cvc4autoconfig.new.h.in @@ -0,0 +1,67 @@ +#ifndef __CVC4__CVC4AUTOCONFIG_H +#define __CVC4__CVC4AUTOCONFIG_H + +/* Major component of the version of CVC4. */ +#define CVC4_MAJOR @CVC4_MAJOR@ + +/* Minor component of the version of CVC4. */ +#define CVC4_MINOR @CVC4_MINOR@ + +/* Release component of the version of CVC4. */ +#define CVC4_RELEASE @CVC4_RELEASE@ + +/* Extraversion component of the version of CVC4. */ +#define CVC4_EXTRAVERSION "@CVC4_EXTRAVERSION@" + +/* Full release string for CVC4. */ +#define CVC4_RELEASE_STRING "@CVC4_RELEASE_STRING@" + +/* Full name of this package. */ +#define PACKAGE_NAME "@PACKAGE_NAME@" + +/* Define to 1 if CVC4 is built with (optional) GPLed library dependencies. */ +#cmakedefine01 CVC4_GPL_DEPS + +/* Define to use the CLN multi-precision arithmetic library. */ +#cmakedefine CVC4_CLN_IMP + +/* Define to use the GMP multi-precision arithmetic library. */ +#cmakedefine CVC4_GMP_IMP + +/* Define to 1 if Boost threading library has support for thread attributes. */ +#cmakedefine01 BOOST_HAS_THREAD_ATTR + +/* Define if `clock_gettime' is supported by the platform. */ +#cmakedefine HAVE_CLOCK_GETTIME + +/* Define to 1 if the declaration of `optreset' is available. */ +#cmakedefine01 HAVE_DECL_OPTRESET + +/* Define to 1 if the <ext/stdio_filebuf.h> header file is available. */ +#cmakedefine01 HAVE_EXT_STDIO_FILEBUF_H + +/* Define if `ffs' is supported by the platform. */ +#cmakedefine HAVE_FFS + +/* Define to 1 to use libreadline. */ +#cmakedefine01 HAVE_LIBREADLINE + +/* Define if `sigaltstack' is supported by the platform. */ +#cmakedefine HAVE_SIGALTSTACK + +/* Define to 1 if `strerror_r' is supported by the platform. */ +#cmakedefine01 HAVE_STRERROR_R + +/* Define if `strtok_r' is supported by the platform. */ +#cmakedefine HAVE_STRTOK_R + +/* Define to 1 if the <unistd.h> header file is available. */ +#cmakedefine01 HAVE_UNISTD_H + +/* Define to 1 if `rl_completion_entry_function' returns (char *). */ +#cmakedefine01 READLINE_COMPENTRY_FUNC_RETURNS_CHARP + +/* Define to 1 if `strerror_r' returns (char *). */ +#cmakedefine01 STRERROR_R_CHAR_P + +#endif /* __CVC4__CVC4AUTOCONFIG_H */ diff --git a/doc/CMakeLists.txt b/doc/CMakeLists.txt new file mode 100644 index 000000000..5f71dd2b4 --- /dev/null +++ b/doc/CMakeLists.txt @@ -0,0 +1,48 @@ +#-----------------------------------------------------------------------------# +# Set variables required for the documentation *.in files + +string(TIMESTAMP MAN_DATE "%Y-%m-%d") +set(VERSION CVC4_RELEASE_STRING) + +#-----------------------------------------------------------------------------# +# Generate files + +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/SmtEngine.3cvc_template.in + ${CMAKE_CURRENT_BINARY_DIR}/SmtEngine.3cvc_template) + +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/cvc4.1_template.in + ${CMAKE_CURRENT_BINARY_DIR}/cvc4.1_template) + +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/cvc4.5.in + ${CMAKE_CURRENT_BINARY_DIR}/cvc4.5) + +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/libcvc4.3.in + ${CMAKE_CURRENT_BINARY_DIR}/libcvc4.3) + +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/libcvc4parser.3.in + ${CMAKE_CURRENT_BINARY_DIR}/libcvc4parser.3) + +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/options.3cvc_template.in + ${CMAKE_CURRENT_BINARY_DIR}/options.3cvc_template) + +#-----------------------------------------------------------------------------# +# Install man pages + +install(FILES ${CMAKE_CURRENT_BINARY_DIR}/cvc4.1 DESTINATION share/man/man1) +install(FILES ${CMAKE_CURRENT_BINARY_DIR}/cvc4.5 DESTINATION share/man/man5) +if(ENABLE_PORTFOLIO) + install(FILES ${CMAKE_CURRENT_BINARY_DIR}/cvc4.1 DESTINATION share/man/man1 + RENAME pcvc4.1) +endif() +install(FILES + ${CMAKE_CURRENT_BINARY_DIR}/libcvc4.3 + ${CMAKE_CURRENT_BINARY_DIR}/libcvc4parser.3 + ${CMAKE_CURRENT_BINARY_DIR}/options.3cvc + ${CMAKE_CURRENT_BINARY_DIR}/SmtEngine.3cvc + DESTINATION share/man/man3) diff --git a/doc/libcvc4.3.in b/doc/libcvc4.3.in index 279c18954..1db5b3c2d 100644 --- a/doc/libcvc4.3.in +++ b/doc/libcvc4.3.in @@ -61,4 +61,4 @@ is used primarily to make assertions, check satisfiability/validity, and extract Additionally, the CVC4 wiki contains useful information about the design and internals of CVC4. It is maintained at -.BR http://goedel.cs.stanford.edu/wiki/ . +.BR http://cvc4.cs.stanford.edu/wiki/ . diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt new file mode 100644 index 000000000..33d341ac8 --- /dev/null +++ b/examples/CMakeLists.txt @@ -0,0 +1,98 @@ +include_directories(${PROJECT_SOURCE_DIR}/src) +include_directories(${PROJECT_SOURCE_DIR}/src/include) +include_directories(${CMAKE_BINARY_DIR}/src) + +# Some of the examples require boost. Enable these examples if boost is +# installed. +find_package(Boost) + +set(EXAMPLES_BIN_DIR ${CMAKE_BINARY_DIR}/bin/examples) + +# Create target examples. +# +# Only builds the examples, but does not run them. To run and build all +# examples, use target runexamples (below). +# Use macro cvc4_add_example to add examples. +add_custom_target(examples) + +# Create target runexamples. +# Builds and runs all examples. +add_custom_target(runexamples + COMMAND ctest --output-on-failure -L "example" -j${NTHREADS} $(ARGS) + DEPENDS examples) + +# Add example target and create test to run example with ctest. +# +# > name: The name of the example +# > src_files: The list of source files passed as string "src1 src2 ..." +# (alternative: "src1;src2;..."). If empty, <name>.cpp is assumed. +# > libs: The list of libraries to link the example against, passed as either +# - a list variable: set(<list name> <libs1> <libs2> ...) and pass +# as "${<list name>}" +# - a string: pass as "lib1 lib2 ..." (alternative: "lib1;lib2;...") +# > output_dir: Determines the examples subdirectory and is empty (passed as +# empty string) for the examples root directory (this) +# > ARGN: Any additional arguments passed to the macro are interpreted as +# as arguments to the test executable. +macro(cvc4_add_example name src_files libs output_dir) + # The build target is created without the path prefix (not supported), + # e.g., for '<output_dir>/myexample.cpp' + # we create build target 'myexample' + # and build it with 'make myexample'. + # As a consequence, all build target names must be globally unique. + if("${src_files}" STREQUAL "") + set(src_files_list ${name}.cpp) + else() + string(REPLACE " " ";" src_files_list "${src_files}") + endif() + add_executable(${name} EXCLUDE_FROM_ALL ${src_files_list}) + string(REPLACE " " ";" libs_list "${libs_list}") + target_link_libraries(${name} ${libs}) + add_dependencies(examples ${name}) + # The test target is prefixed with test identifier 'example/' and the path, + # e.g., for '<output_dir>/myexample.cpp' + # we create test target 'example/<output_dir>/myexample' + # and run it with 'ctest -R "example/<output_dir>/myunittest"'. + set(example_bin_dir ${EXAMPLES_BIN_DIR}/${output_dir}) + if("${output_dir}" STREQUAL "") + set(example_test example/${name}) + else() + set(example_test example/${output_dir}/${name}) + endif() + set_target_properties(${name} + PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${example_bin_dir}) + add_test(${example_test} ${example_bin_dir}/${name} ${ARGN}) + set_tests_properties(${example_test} PROPERTIES LABELS "example") +endmacro() + +set(EXAMPLES_LINK_LIBS cvc4 cvc4parser) +cvc4_add_example(simple_vc_cxx "" "${EXAMPLES_LINK_LIBS}" "") +cvc4_add_example(simple_vc_quant_cxx "" "${EXAMPLES_LINK_LIBS}" "") +cvc4_add_example(translator "" "${EXAMPLES_LINK_LIBS}" "") + +if(BUILD_BINDINGS_JAVA) + find_package(Java REQUIRED) + set(EXAMPLES_JAVA_CLASSPATH "${CMAKE_BINARY_DIR}/src/bindings/java/CVC4.jar") + add_custom_target(SimpleVCjava + COMMAND + ${Java_JAVAC_EXECUTABLE} + -cp ${EXAMPLES_JAVA_CLASSPATH} ${CMAKE_CURRENT_SOURCE_DIR}/SimpleVC.java + -d ${CMAKE_BINARY_DIR}/bin/examples + DEPENDS cvc4jar) + add_dependencies(examples SimpleVCjava) + add_test( + NAME example/SimpleVCjava + COMMAND + ${Java_JAVA_EXECUTABLE} + -Djava.library.path=${CMAKE_BINARY_DIR}/src/bindings/java/ + -cp "${EXAMPLES_JAVA_CLASSPATH}:${CMAKE_BINARY_DIR}/bin/examples/" + SimpleVC + ) + set_tests_properties(example/SimpleVCjava PROPERTIES LABELS "example") +endif() + +add_subdirectory(api) +add_subdirectory(hashsmt) +add_subdirectory(nra-translate) +add_subdirectory(sets-translate) + diff --git a/examples/api/CMakeLists.txt b/examples/api/CMakeLists.txt new file mode 100644 index 000000000..c78c50466 --- /dev/null +++ b/examples/api/CMakeLists.txt @@ -0,0 +1,30 @@ +set(CVC4_EXAMPLES_API + bitvectors + bitvectors-new + bitvectors_and_arrays + bitvectors_and_arrays-new + combination + combination-new + datatypes + datatypes-new + extract + extract-new + helloworld + helloworld-new + linear_arith + linear_arith-new + sets + sets-new + strings + strings-new +) + +set(EXAMPLES_API_LINK_LIBS cvc4 cvc4parser) +foreach(example ${CVC4_EXAMPLES_API}) + cvc4_add_example(${example} + "" "${EXAMPLES_API_LINK_LIBS}" "api") +endforeach() + +if(BUILD_BINDINGS_JAVA) + add_subdirectory(java) +endif() diff --git a/examples/api/java/CMakeLists.txt b/examples/api/java/CMakeLists.txt new file mode 100644 index 000000000..76a55151e --- /dev/null +++ b/examples/api/java/CMakeLists.txt @@ -0,0 +1,36 @@ +set(EXAMPLES_API_JAVA_BIN_DIR ${EXAMPLES_BIN_DIR}/api/java) +file(MAKE_DIRECTORY ${EXAMPLES_API_JAVA_BIN_DIR}) + +set(EXAMPLES_API_JAVA + BitVectors + BitVectorsAndArrays + ## disabled until bindings for the new API are in place (issue #2284) + #CVC4Streams + Combination + Datatypes + HelloWorld + LinearArith + ## disabled until bindings for the new API are in place (issue #2284) + #PipedInput + Strings +) + +foreach(example ${EXAMPLES_API_JAVA}) + add_custom_target(${example} + COMMAND + ${Java_JAVAC_EXECUTABLE} + -cp ${EXAMPLES_JAVA_CLASSPATH} ${CMAKE_CURRENT_SOURCE_DIR}/${example}.java + -d ${EXAMPLES_API_JAVA_BIN_DIR} + DEPENDS cvc4jar) + add_dependencies(examples ${example}) + set(example_test example/api/java/${example}) + add_test( + NAME ${example_test} + COMMAND + ${Java_JAVA_EXECUTABLE} + -Djava.library.path=${CMAKE_BINARY_DIR}/src/bindings/java/ + -cp "${EXAMPLES_JAVA_CLASSPATH}:${CMAKE_BINARY_DIR}/bin/examples/api/java/" + ${example} + ) + set_tests_properties(${example_test} PROPERTIES LABELS "example") +endforeach() diff --git a/examples/hashsmt/CMakeLists.txt b/examples/hashsmt/CMakeLists.txt new file mode 100644 index 000000000..ff696b403 --- /dev/null +++ b/examples/hashsmt/CMakeLists.txt @@ -0,0 +1,13 @@ +include_directories(.) + +set(EXAMPLES_HASHSMT_LINK_LIBS cvc4) + +if(Boost_FOUND) + cvc4_add_example(sha1_inversion + "sha1_inversion.cpp word.cpp" "${EXAMPLES_HASHSMT_LINK_LIBS}" "hashsmt" + "a" "sha1_inversion.outfile") # arguments to binary (for testing) +endif() + +cvc4_add_example(sha1_collision + "sha1_collision.cpp word.cpp" "${EXAMPLES_HASHSMT_LINK_LIBS}" "hashsmt" + "1" "1" "sha1_collision.outfile") # arguments to binary (for testing) diff --git a/examples/hashsmt/sha1_collision.cpp b/examples/hashsmt/sha1_collision.cpp index 49e028614..352707455 100644 --- a/examples/hashsmt/sha1_collision.cpp +++ b/examples/hashsmt/sha1_collision.cpp @@ -22,7 +22,6 @@ * Author: dejan */ -#include <boost/uuid/sha1.hpp> #include <fstream> #include <iostream> #include <sstream> diff --git a/examples/nra-translate/CMakeLists.txt b/examples/nra-translate/CMakeLists.txt new file mode 100644 index 000000000..b719ac2a4 --- /dev/null +++ b/examples/nra-translate/CMakeLists.txt @@ -0,0 +1,24 @@ +set(EXAMPLES_NRA_TRANSLATE_BIN_DIR ${EXAMPLES_BIN_DIR}/nra-translate) + +set(CVC4_EXAMPLES_NRA_TRANSLATE + normalize + smt2info + smt2todreal + smt2toisat + smt2tomathematica + smt2toqepcad + smt2toredlog +) + +set(EXAMPLES_NRA_TRANSLATE_LINK_LIBS cvc4 cvc4parser) +foreach(example ${CVC4_EXAMPLES_NRA_TRANSLATE}) + cvc4_add_example(${example} + "" "${EXAMPLES_NRA_TRANSLATE_LINK_LIBS}" "nra-translate" + # arguments to binary (for testing) + # input file is required by all tests + ${CMAKE_CURRENT_SOURCE_DIR}/nra-translate-example-input.smt2 + # This is a dummy argument for smt2toredlog (argument is only printed, can + # be anything for testing purposes). We pass this to all examples since the + # other examples ignore additional arguments. + "foo") +endforeach() diff --git a/examples/nra-translate/nra-translate-example-input.smt2 b/examples/nra-translate/nra-translate-example-input.smt2 new file mode 100644 index 000000000..229c46d4a --- /dev/null +++ b/examples/nra-translate/nra-translate-example-input.smt2 @@ -0,0 +1,11 @@ +(set-logic QF_NRA) +(set-info :smt-lib-version 2.0) +(set-info :status sat) +(declare-fun x () Real) +(declare-fun y () Real) +(declare-fun n () Real) + +(assert (= (+ x n) 0)) +(assert (= (+ y n) 1)) + +(check-sat) diff --git a/examples/sets-translate/CMakeLists.txt b/examples/sets-translate/CMakeLists.txt new file mode 100644 index 000000000..1c34d3aaf --- /dev/null +++ b/examples/sets-translate/CMakeLists.txt @@ -0,0 +1,14 @@ +if(Boost_FOUND) + set(EXAMPLES_SETS_TRANSLATE_LINK_LIBS cvc4 cvc4parser) + cvc4_add_example(sets2arrays + "sets_translate.cpp" "${EXAMPLES_SETS_TRANSLATE_LINK_LIBS}" "sets-translate" + # argument to binary (for testing) + ${CMAKE_CURRENT_SOURCE_DIR}/sets-translate-example-input.smt2) + + cvc4_add_example(sets2axioms + "sets_translate.cpp" "${EXAMPLES_SETS_TRANSLATE_LINK_LIBS}" "sets-translate" + # argument to binary (for testing) + ${CMAKE_CURRENT_SOURCE_DIR}/sets-translate-example-input.smt2) + target_compile_definitions(sets2axioms PRIVATE -DENABLE_AXIOMS) +endif() + diff --git a/examples/sets-translate/sets-translate-example-input.smt2 b/examples/sets-translate/sets-translate-example-input.smt2 new file mode 100644 index 000000000..3bf1a9b6a --- /dev/null +++ b/examples/sets-translate/sets-translate-example-input.smt2 @@ -0,0 +1,22 @@ +; COMMAND-LINE: --finite-model-find +; EXPECT: sat +(set-logic ALL) +(declare-sort Atom 0) + +(declare-fun k (Atom Atom) (Set Atom)) + +(declare-fun t0 () Atom) +(declare-fun t1 () Atom) +(declare-fun t2 () Atom) +(declare-fun v () Atom) +(declare-fun b2 () Atom) + +(assert (forall ((b Atom)) (or +(member v (k t0 b)) +(member v (k t1 b)) +) )) + +(assert (not (member v (k t2 b2)))) + +(check-sat) + diff --git a/proofs/signatures/CMakeLists.txt b/proofs/signatures/CMakeLists.txt new file mode 100644 index 000000000..8af026952 --- /dev/null +++ b/proofs/signatures/CMakeLists.txt @@ -0,0 +1,34 @@ +# These CORE_PLFs are combined to give a "master signature" against which +# proofs are checked internally when using --check-proofs. To add support for +# more theories, just list them here in the same order you would to the LFSC +# proof-checker binary. + +set(core_signature_files + sat.plf + smt.plf + th_base.plf + th_arrays.plf + th_bv.plf + th_bv_bitblast.plf + th_bv_rewrites.plf + th_real.plf + th_int.plf +) + +set(CORE_SIGNATURES "") + +foreach(f ${core_signature_files}) + file(READ ${f} tmp) + set(CORE_SIGNATURES "${CORE_SIGNATURES}\n${tmp}") +endforeach(f) + +string(REPLACE "\\" "\\\\" CORE_SIGNATURES "${CORE_SIGNATURES}") +string(REPLACE "\"" "\\\"" CORE_SIGNATURES "${CORE_SIGNATURES}") +string(REPLACE "\n" "\\n\\\n" CORE_SIGNATURES "${CORE_SIGNATURES}") + +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/signatures.cpp.in + ${CMAKE_CURRENT_BINARY_DIR}/signatures.cpp) + +libcvc4_add_sources(GENERATED signatures.cpp) +install(FILES ${core_signature_files} DESTINATION share/cvc4) diff --git a/proofs/signatures/signatures.cpp.in b/proofs/signatures/signatures.cpp.in new file mode 100644 index 000000000..37c152b2f --- /dev/null +++ b/proofs/signatures/signatures.cpp.in @@ -0,0 +1,10 @@ +namespace CVC4 { +namespace proof { + +extern const char *const plf_signatures; +const char *const plf_signatures = "\ +@CORE_SIGNATURES@\ +"; + +} // namespace proof +} // namespace CVC4 diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt new file mode 100644 index 000000000..9948b0ec9 --- /dev/null +++ b/src/CMakeLists.txt @@ -0,0 +1,880 @@ +#-----------------------------------------------------------------------------# +# Collect libcvc4 source files + +libcvc4_add_sources( + api/cvc4cpp.cpp + api/cvc4cpp.h + api/cvc4cppkind.h + context/backtrackable.h + context/cddense_set.h + context/cdhashmap.h + context/cdhashmap_forward.h + context/cdhashset.h + context/cdhashset_forward.h + context/cdinsert_hashmap.h + context/cdinsert_hashmap_forward.h + context/cdlist.h + context/cdlist_forward.h + context/cdmaybe.h + context/cdo.h + context/cdqueue.h + context/cdtrail_queue.h + context/context.cpp + context/context.h + context/context_mm.cpp + context/context_mm.h + decision/decision_attributes.h + decision/decision_engine.cpp + decision/decision_engine.h + decision/decision_strategy.h + decision/justification_heuristic.cpp + decision/justification_heuristic.h + lib/clock_gettime.c + lib/clock_gettime.h + lib/ffs.c + lib/ffs.h + lib/replacements.h + lib/strtok_r.c + lib/strtok_r.h + preprocessing/assertion_pipeline.cpp + preprocessing/assertion_pipeline.h + preprocessing/passes/apply_substs.cpp + preprocessing/passes/apply_substs.h + preprocessing/passes/apply_to_const.cpp + preprocessing/passes/apply_to_const.h + preprocessing/passes/bool_to_bv.cpp + preprocessing/passes/bool_to_bv.h + preprocessing/passes/bv_abstraction.cpp + preprocessing/passes/bv_abstraction.h + preprocessing/passes/bv_ackermann.cpp + preprocessing/passes/bv_ackermann.h + preprocessing/passes/bv_eager_atoms.cpp + preprocessing/passes/bv_eager_atoms.h + preprocessing/passes/bv_gauss.cpp + preprocessing/passes/bv_gauss.h + preprocessing/passes/bv_intro_pow2.cpp + preprocessing/passes/bv_intro_pow2.h + preprocessing/passes/bv_to_bool.cpp + preprocessing/passes/bv_to_bool.h + preprocessing/passes/extended_rewriter_pass.cpp + preprocessing/passes/extended_rewriter_pass.h + preprocessing/passes/global_negate.cpp + preprocessing/passes/global_negate.h + preprocessing/passes/int_to_bv.cpp + preprocessing/passes/int_to_bv.h + preprocessing/passes/ite_removal.cpp + preprocessing/passes/ite_removal.h + preprocessing/passes/ite_simp.cpp + preprocessing/passes/ite_simp.h + preprocessing/passes/miplib_trick.cpp + preprocessing/passes/miplib_trick.h + preprocessing/passes/nl_ext_purify.cpp + preprocessing/passes/nl_ext_purify.h + preprocessing/passes/non_clausal_simp.cpp + preprocessing/passes/non_clausal_simp.h + preprocessing/passes/pseudo_boolean_processor.cpp + preprocessing/passes/pseudo_boolean_processor.h + preprocessing/passes/quantifier_macros.cpp + preprocessing/passes/quantifier_macros.h + preprocessing/passes/quantifiers_preprocess.cpp + preprocessing/passes/quantifiers_preprocess.h + preprocessing/passes/real_to_int.cpp + preprocessing/passes/real_to_int.h + preprocessing/passes/rewrite.cpp + preprocessing/passes/rewrite.h + preprocessing/passes/sep_skolem_emp.cpp + preprocessing/passes/sep_skolem_emp.h + preprocessing/passes/sort_infer.cpp + preprocessing/passes/sort_infer.h + preprocessing/passes/static_learning.cpp + preprocessing/passes/static_learning.h + preprocessing/passes/sygus_inference.cpp + preprocessing/passes/sygus_inference.h + preprocessing/passes/symmetry_breaker.cpp + preprocessing/passes/symmetry_breaker.h + preprocessing/passes/symmetry_detect.cpp + preprocessing/passes/symmetry_detect.h + preprocessing/passes/synth_rew_rules.cpp + preprocessing/passes/synth_rew_rules.h + preprocessing/passes/theory_preprocess.cpp + preprocessing/passes/theory_preprocess.h + preprocessing/passes/unconstrained_simplifier.cpp + preprocessing/passes/unconstrained_simplifier.h + preprocessing/preprocessing_pass.cpp + preprocessing/preprocessing_pass.h + preprocessing/preprocessing_pass_context.cpp + preprocessing/preprocessing_pass_context.h + preprocessing/preprocessing_pass_registry.cpp + preprocessing/preprocessing_pass_registry.h + preprocessing/util/ite_utilities.cpp + preprocessing/util/ite_utilities.h + printer/ast/ast_printer.cpp + printer/ast/ast_printer.h + printer/cvc/cvc_printer.cpp + printer/cvc/cvc_printer.h + printer/dagification_visitor.cpp + printer/dagification_visitor.h + printer/printer.cpp + printer/printer.h + printer/smt2/smt2_printer.cpp + printer/smt2/smt2_printer.h + printer/sygus_print_callback.cpp + printer/sygus_print_callback.h + printer/tptp/tptp_printer.cpp + printer/tptp/tptp_printer.h + proof/arith_proof.cpp + proof/arith_proof.h + proof/array_proof.cpp + proof/array_proof.h + proof/bitvector_proof.cpp + proof/bitvector_proof.h + proof/clause_id.h + proof/cnf_proof.cpp + proof/cnf_proof.h + proof/lemma_proof.cpp + proof/lemma_proof.h + proof/lfsc_proof_printer.cpp + proof/lfsc_proof_printer.h + proof/proof.h + proof/proof_manager.cpp + proof/proof_manager.h + proof/proof_output_channel.cpp + proof/proof_output_channel.h + proof/proof_utils.cpp + proof/proof_utils.h + proof/sat_proof.h + proof/sat_proof_implementation.h + proof/simplify_boolean_node.cpp + proof/simplify_boolean_node.h + proof/skolemization_manager.cpp + proof/skolemization_manager.h + proof/theory_proof.cpp + proof/theory_proof.h + proof/uf_proof.cpp + proof/uf_proof.h + proof/unsat_core.cpp + proof/unsat_core.h + prop/bvminisat/bvminisat.cpp + prop/bvminisat/bvminisat.h + prop/bvminisat/core/Dimacs.h + prop/bvminisat/core/Solver.cc + prop/bvminisat/core/Solver.h + prop/bvminisat/core/SolverTypes.h + prop/bvminisat/mtl/Alg.h + prop/bvminisat/mtl/Alloc.h + prop/bvminisat/mtl/Heap.h + prop/bvminisat/mtl/IntTypes.h + prop/bvminisat/mtl/Map.h + prop/bvminisat/mtl/Queue.h + prop/bvminisat/mtl/Sort.h + prop/bvminisat/mtl/Vec.h + prop/bvminisat/mtl/XAlloc.h + prop/bvminisat/simp/SimpSolver.cc + prop/bvminisat/simp/SimpSolver.h + prop/bvminisat/utils/Options.h + prop/cadical.cpp + prop/cadical.h + prop/cnf_stream.cpp + prop/cnf_stream.h + prop/cryptominisat.cpp + prop/cryptominisat.h + prop/minisat/core/Dimacs.h + prop/minisat/core/Solver.cc + prop/minisat/core/Solver.h + prop/minisat/core/SolverTypes.h + prop/minisat/minisat.cpp + prop/minisat/minisat.h + prop/minisat/mtl/Alg.h + prop/minisat/mtl/Alloc.h + prop/minisat/mtl/Heap.h + prop/minisat/mtl/IntTypes.h + prop/minisat/mtl/Map.h + prop/minisat/mtl/Queue.h + prop/minisat/mtl/Sort.h + prop/minisat/mtl/Vec.h + prop/minisat/mtl/XAlloc.h + prop/minisat/simp/SimpSolver.cc + prop/minisat/simp/SimpSolver.h + prop/minisat/utils/Options.h + prop/prop_engine.cpp + prop/prop_engine.h + prop/registrar.h + prop/sat_solver.h + prop/sat_solver_factory.cpp + prop/sat_solver_factory.h + prop/sat_solver_types.h + prop/theory_proxy.cpp + prop/theory_proxy.h + smt/command.cpp + smt/command.h + smt/command_list.cpp + smt/command_list.h + smt/dump.cpp + smt/dump.h + smt/logic_exception.h + smt/logic_request.cpp + smt/logic_request.h + smt/managed_ostreams.cpp + smt/managed_ostreams.h + smt/model.cpp + smt/model.h + smt/model_core_builder.cpp + smt/model_core_builder.h + smt/smt_engine.cpp + smt/smt_engine.h + smt/smt_engine_check_proof.cpp + smt/smt_engine_scope.cpp + smt/smt_engine_scope.h + smt/smt_statistics_registry.cpp + smt/smt_statistics_registry.h + smt/term_formula_removal.cpp + smt/term_formula_removal.h + smt/update_ostream.h + smt_util/boolean_simplification.cpp + smt_util/boolean_simplification.h + smt_util/lemma_channels.cpp + smt_util/lemma_channels.h + smt_util/lemma_input_channel.h + smt_util/lemma_output_channel.h + smt_util/nary_builder.cpp + smt_util/nary_builder.h + smt_util/node_visitor.h + theory/arith/approx_simplex.cpp + theory/arith/approx_simplex.h + theory/arith/arith_ite_utils.cpp + theory/arith/arith_ite_utils.h + theory/arith/arith_msum.cpp + theory/arith/arith_msum.h + theory/arith/arith_rewriter.cpp + theory/arith/arith_rewriter.h + theory/arith/arith_static_learner.cpp + theory/arith/arith_static_learner.h + theory/arith/arith_utilities.h + theory/arith/arithvar.cpp + theory/arith/arithvar.h + theory/arith/attempt_solution_simplex.cpp + theory/arith/attempt_solution_simplex.h + theory/arith/bound_counts.h + theory/arith/callbacks.cpp + theory/arith/callbacks.h + theory/arith/congruence_manager.cpp + theory/arith/congruence_manager.h + theory/arith/constraint.cpp + theory/arith/constraint.h + theory/arith/constraint_forward.h + theory/arith/cut_log.cpp + theory/arith/cut_log.h + theory/arith/delta_rational.cpp + theory/arith/delta_rational.h + theory/arith/dio_solver.cpp + theory/arith/dio_solver.h + theory/arith/dual_simplex.cpp + theory/arith/dual_simplex.h + theory/arith/error_set.cpp + theory/arith/error_set.h + theory/arith/fc_simplex.cpp + theory/arith/fc_simplex.h + theory/arith/infer_bounds.cpp + theory/arith/infer_bounds.h + theory/arith/linear_equality.cpp + theory/arith/linear_equality.h + theory/arith/matrix.cpp + theory/arith/matrix.h + theory/arith/nonlinear_extension.cpp + theory/arith/nonlinear_extension.h + theory/arith/normal_form.cpp + theory/arith/normal_form.h + theory/arith/partial_model.cpp + theory/arith/partial_model.h + theory/arith/simplex.cpp + theory/arith/simplex.h + theory/arith/simplex_update.cpp + theory/arith/simplex_update.h + theory/arith/soi_simplex.cpp + theory/arith/soi_simplex.h + theory/arith/tableau.cpp + theory/arith/tableau.h + theory/arith/tableau_sizes.cpp + theory/arith/tableau_sizes.h + theory/arith/theory_arith.cpp + theory/arith/theory_arith.h + theory/arith/theory_arith_private.cpp + theory/arith/theory_arith_private.h + theory/arith/theory_arith_private_forward.h + theory/arith/theory_arith_type_rules.h + theory/arith/type_enumerator.h + theory/arrays/array_info.cpp + theory/arrays/array_info.h + theory/arrays/array_proof_reconstruction.cpp + theory/arrays/array_proof_reconstruction.h + theory/arrays/static_fact_manager.cpp + theory/arrays/static_fact_manager.h + theory/arrays/theory_arrays.cpp + theory/arrays/theory_arrays.h + theory/arrays/theory_arrays_rewriter.cpp + theory/arrays/theory_arrays_rewriter.h + theory/arrays/theory_arrays_type_rules.h + theory/arrays/type_enumerator.h + theory/arrays/union_find.cpp + theory/arrays/union_find.h + theory/assertion.cpp + theory/assertion.h + theory/atom_requests.cpp + theory/atom_requests.h + theory/booleans/circuit_propagator.cpp + theory/booleans/circuit_propagator.h + theory/booleans/theory_bool.cpp + theory/booleans/theory_bool.h + theory/booleans/theory_bool_rewriter.cpp + theory/booleans/theory_bool_rewriter.h + theory/booleans/theory_bool_type_rules.h + theory/booleans/type_enumerator.h + theory/builtin/theory_builtin.cpp + theory/builtin/theory_builtin.h + theory/builtin/theory_builtin_rewriter.cpp + theory/builtin/theory_builtin_rewriter.h + theory/builtin/theory_builtin_type_rules.h + theory/builtin/type_enumerator.cpp + theory/builtin/type_enumerator.h + theory/bv/abstraction.cpp + theory/bv/abstraction.h + theory/bv/bitblast/aig_bitblaster.cpp + theory/bv/bitblast/aig_bitblaster.h + theory/bv/bitblast/bitblast_strategies_template.h + theory/bv/bitblast/bitblast_utils.h + theory/bv/bitblast/bitblaster.h + theory/bv/bitblast/eager_bitblaster.cpp + theory/bv/bitblast/eager_bitblaster.h + theory/bv/bitblast/lazy_bitblaster.cpp + theory/bv/bitblast/lazy_bitblaster.h + theory/bv/bv_eager_solver.cpp + theory/bv/bv_eager_solver.h + theory/bv/bv_inequality_graph.cpp + theory/bv/bv_inequality_graph.h + theory/bv/bv_quick_check.cpp + theory/bv/bv_quick_check.h + theory/bv/bv_subtheory.h + theory/bv/bv_subtheory_algebraic.cpp + theory/bv/bv_subtheory_algebraic.h + theory/bv/bv_subtheory_bitblast.cpp + theory/bv/bv_subtheory_bitblast.h + theory/bv/bv_subtheory_core.cpp + theory/bv/bv_subtheory_core.h + theory/bv/bv_subtheory_inequality.cpp + theory/bv/bv_subtheory_inequality.h + theory/bv/slicer.cpp + theory/bv/slicer.h + theory/bv/theory_bv.cpp + theory/bv/theory_bv.h + theory/bv/theory_bv_rewrite_rules.h + theory/bv/theory_bv_rewrite_rules_constant_evaluation.h + theory/bv/theory_bv_rewrite_rules_core.h + theory/bv/theory_bv_rewrite_rules_normalization.h + theory/bv/theory_bv_rewrite_rules_operator_elimination.h + theory/bv/theory_bv_rewrite_rules_simplification.h + theory/bv/theory_bv_rewriter.cpp + theory/bv/theory_bv_rewriter.h + theory/bv/theory_bv_type_rules.h + theory/bv/theory_bv_utils.cpp + theory/bv/theory_bv_utils.h + theory/bv/type_enumerator.h + theory/care_graph.h + theory/datatypes/datatypes_rewriter.cpp + theory/datatypes/datatypes_rewriter.h + theory/datatypes/datatypes_sygus.cpp + theory/datatypes/datatypes_sygus.h + theory/datatypes/sygus_simple_sym.cpp + theory/datatypes/sygus_simple_sym.h + theory/datatypes/theory_datatypes.cpp + theory/datatypes/theory_datatypes.h + theory/datatypes/theory_datatypes_type_rules.h + theory/datatypes/type_enumerator.cpp + theory/datatypes/type_enumerator.h + theory/decision_manager.cpp + theory/decision_manager.h + theory/decision_strategy.cpp + theory/decision_strategy.h + theory/evaluator.cpp + theory/evaluator.h + theory/ext_theory.cpp + theory/ext_theory.h + theory/fp/fp_converter.cpp + theory/fp/fp_converter.h + theory/fp/theory_fp.cpp + theory/fp/theory_fp.h + theory/fp/theory_fp_rewriter.cpp + theory/fp/theory_fp_rewriter.h + theory/fp/theory_fp_type_rules.h + theory/fp/type_enumerator.h + theory/idl/idl_assertion.cpp + theory/idl/idl_assertion.h + theory/idl/idl_assertion_db.cpp + theory/idl/idl_assertion_db.h + theory/idl/idl_model.cpp + theory/idl/idl_model.h + theory/idl/theory_idl.cpp + theory/idl/theory_idl.h + theory/interrupted.h + theory/logic_info.cpp + theory/logic_info.h + theory/output_channel.h + theory/quantifiers/alpha_equivalence.cpp + theory/quantifiers/alpha_equivalence.h + theory/quantifiers/anti_skolem.cpp + theory/quantifiers/anti_skolem.h + theory/quantifiers/bv_inverter.cpp + theory/quantifiers/bv_inverter.h + theory/quantifiers/candidate_rewrite_database.cpp + theory/quantifiers/candidate_rewrite_database.h + theory/quantifiers/candidate_rewrite_filter.cpp + theory/quantifiers/candidate_rewrite_filter.h + theory/quantifiers/cegqi/ceg_arith_instantiator.cpp + theory/quantifiers/cegqi/ceg_arith_instantiator.h + theory/quantifiers/cegqi/ceg_bv_instantiator.cpp + theory/quantifiers/cegqi/ceg_bv_instantiator.h + theory/quantifiers/cegqi/ceg_dt_instantiator.cpp + theory/quantifiers/cegqi/ceg_dt_instantiator.h + theory/quantifiers/cegqi/ceg_epr_instantiator.cpp + theory/quantifiers/cegqi/ceg_epr_instantiator.h + theory/quantifiers/cegqi/ceg_instantiator.cpp + theory/quantifiers/cegqi/ceg_instantiator.h + theory/quantifiers/cegqi/inst_strategy_cegqi.cpp + theory/quantifiers/cegqi/inst_strategy_cegqi.h + theory/quantifiers/conjecture_generator.cpp + theory/quantifiers/conjecture_generator.h + theory/quantifiers/dynamic_rewrite.cpp + theory/quantifiers/dynamic_rewrite.h + theory/quantifiers/ematching/candidate_generator.cpp + theory/quantifiers/ematching/candidate_generator.h + theory/quantifiers/ematching/ho_trigger.cpp + theory/quantifiers/ematching/ho_trigger.h + theory/quantifiers/ematching/inst_match_generator.cpp + theory/quantifiers/ematching/inst_match_generator.h + theory/quantifiers/ematching/inst_strategy_e_matching.cpp + theory/quantifiers/ematching/inst_strategy_e_matching.h + theory/quantifiers/ematching/instantiation_engine.cpp + theory/quantifiers/ematching/instantiation_engine.h + theory/quantifiers/ematching/trigger.cpp + theory/quantifiers/ematching/trigger.h + theory/quantifiers/equality_infer.cpp + theory/quantifiers/equality_infer.h + theory/quantifiers/equality_query.cpp + theory/quantifiers/equality_query.h + theory/quantifiers/expr_miner.cpp + theory/quantifiers/expr_miner.h + theory/quantifiers/expr_miner_manager.cpp + theory/quantifiers/expr_miner_manager.h + theory/quantifiers/extended_rewrite.cpp + theory/quantifiers/extended_rewrite.h + theory/quantifiers/first_order_model.cpp + theory/quantifiers/first_order_model.h + theory/quantifiers/fmf/ambqi_builder.cpp + theory/quantifiers/fmf/ambqi_builder.h + theory/quantifiers/fmf/bounded_integers.cpp + theory/quantifiers/fmf/bounded_integers.h + theory/quantifiers/fmf/full_model_check.cpp + theory/quantifiers/fmf/full_model_check.h + theory/quantifiers/fmf/model_builder.cpp + theory/quantifiers/fmf/model_builder.h + theory/quantifiers/fmf/model_engine.cpp + theory/quantifiers/fmf/model_engine.h + theory/quantifiers/fun_def_process.cpp + theory/quantifiers/fun_def_process.h + theory/quantifiers/inst_match.cpp + theory/quantifiers/inst_match.h + theory/quantifiers/inst_match_trie.cpp + theory/quantifiers/inst_match_trie.h + theory/quantifiers/inst_propagator.cpp + theory/quantifiers/inst_propagator.h + theory/quantifiers/inst_strategy_enumerative.cpp + theory/quantifiers/inst_strategy_enumerative.h + theory/quantifiers/instantiate.cpp + theory/quantifiers/instantiate.h + theory/quantifiers/lazy_trie.cpp + theory/quantifiers/lazy_trie.h + theory/quantifiers/local_theory_ext.cpp + theory/quantifiers/local_theory_ext.h + theory/quantifiers/quant_conflict_find.cpp + theory/quantifiers/quant_conflict_find.h + theory/quantifiers/quant_epr.cpp + theory/quantifiers/quant_epr.h + theory/quantifiers/quant_relevance.cpp + theory/quantifiers/quant_relevance.h + theory/quantifiers/quant_split.cpp + theory/quantifiers/quant_split.h + theory/quantifiers/quant_util.cpp + theory/quantifiers/quant_util.h + theory/quantifiers/quantifiers_attributes.cpp + theory/quantifiers/quantifiers_attributes.h + theory/quantifiers/quantifiers_rewriter.cpp + theory/quantifiers/quantifiers_rewriter.h + theory/quantifiers/relevant_domain.cpp + theory/quantifiers/relevant_domain.h + theory/quantifiers/rewrite_engine.cpp + theory/quantifiers/rewrite_engine.h + theory/quantifiers/single_inv_partition.cpp + theory/quantifiers/single_inv_partition.h + theory/quantifiers/skolemize.cpp + theory/quantifiers/skolemize.h + theory/quantifiers/sygus/ce_guided_single_inv.cpp + theory/quantifiers/sygus/ce_guided_single_inv.h + theory/quantifiers/sygus/ce_guided_single_inv_sol.cpp + theory/quantifiers/sygus/ce_guided_single_inv_sol.h + theory/quantifiers/sygus/cegis.cpp + theory/quantifiers/sygus/cegis.h + theory/quantifiers/sygus/cegis_unif.cpp + theory/quantifiers/sygus/cegis_unif.h + theory/quantifiers/sygus/sygus_eval_unfold.cpp + theory/quantifiers/sygus/sygus_eval_unfold.h + theory/quantifiers/sygus/sygus_explain.cpp + theory/quantifiers/sygus/sygus_explain.h + theory/quantifiers/sygus/sygus_grammar_cons.cpp + theory/quantifiers/sygus/sygus_grammar_cons.h + theory/quantifiers/sygus/sygus_grammar_norm.cpp + theory/quantifiers/sygus/sygus_grammar_norm.h + theory/quantifiers/sygus/sygus_grammar_red.cpp + theory/quantifiers/sygus/sygus_grammar_red.h + theory/quantifiers/sygus/sygus_invariance.cpp + theory/quantifiers/sygus/sygus_invariance.h + theory/quantifiers/sygus/sygus_module.cpp + theory/quantifiers/sygus/sygus_module.h + theory/quantifiers/sygus/sygus_pbe.cpp + theory/quantifiers/sygus/sygus_pbe.h + theory/quantifiers/sygus/sygus_process_conj.cpp + theory/quantifiers/sygus/sygus_process_conj.h + theory/quantifiers/sygus/sygus_repair_const.cpp + theory/quantifiers/sygus/sygus_repair_const.h + theory/quantifiers/sygus/sygus_unif.cpp + theory/quantifiers/sygus/sygus_unif.h + theory/quantifiers/sygus/sygus_unif_io.cpp + theory/quantifiers/sygus/sygus_unif_io.h + theory/quantifiers/sygus/sygus_unif_rl.cpp + theory/quantifiers/sygus/sygus_unif_rl.h + theory/quantifiers/sygus/sygus_unif_strat.cpp + theory/quantifiers/sygus/sygus_unif_strat.h + theory/quantifiers/sygus/synth_conjecture.cpp + theory/quantifiers/sygus/synth_conjecture.h + theory/quantifiers/sygus/synth_engine.cpp + theory/quantifiers/sygus/synth_engine.h + theory/quantifiers/sygus/term_database_sygus.cpp + theory/quantifiers/sygus/term_database_sygus.h + theory/quantifiers/sygus_sampler.cpp + theory/quantifiers/sygus_sampler.h + theory/quantifiers/term_canonize.cpp + theory/quantifiers/term_canonize.h + theory/quantifiers/term_database.cpp + theory/quantifiers/term_database.h + theory/quantifiers/term_enumeration.cpp + theory/quantifiers/term_enumeration.h + theory/quantifiers/term_util.cpp + theory/quantifiers/term_util.h + theory/quantifiers/theory_quantifiers.cpp + theory/quantifiers/theory_quantifiers.h + theory/quantifiers/theory_quantifiers_type_rules.h + theory/quantifiers_engine.cpp + theory/quantifiers_engine.h + theory/rep_set.cpp + theory/rep_set.h + theory/rewriter.cpp + theory/rewriter.h + theory/rewriter_attributes.h + theory/sep/theory_sep.cpp + theory/sep/theory_sep.h + theory/sep/theory_sep_rewriter.cpp + theory/sep/theory_sep_rewriter.h + theory/sep/theory_sep_type_rules.h + theory/sets/normal_form.h + theory/sets/rels_utils.h + theory/sets/theory_sets.cpp + theory/sets/theory_sets.h + theory/sets/theory_sets_private.cpp + theory/sets/theory_sets_private.h + theory/sets/theory_sets_rels.cpp + theory/sets/theory_sets_rels.h + theory/sets/theory_sets_rewriter.cpp + theory/sets/theory_sets_rewriter.h + theory/sets/theory_sets_type_enumerator.h + theory/sets/theory_sets_type_rules.h + theory/shared_terms_database.cpp + theory/shared_terms_database.h + theory/sort_inference.cpp + theory/sort_inference.h + theory/strings/regexp_elim.cpp + theory/strings/regexp_elim.h + theory/strings/regexp_operation.cpp + theory/strings/regexp_operation.h + theory/strings/skolem_cache.cpp + theory/strings/skolem_cache.h + theory/strings/theory_strings.cpp + theory/strings/theory_strings.h + theory/strings/theory_strings_preprocess.cpp + theory/strings/theory_strings_preprocess.h + theory/strings/theory_strings_rewriter.cpp + theory/strings/theory_strings_rewriter.h + theory/strings/theory_strings_type_rules.h + theory/strings/type_enumerator.h + theory/subs_minimize.cpp + theory/subs_minimize.h + theory/substitutions.cpp + theory/substitutions.h + theory/term_registration_visitor.cpp + theory/term_registration_visitor.h + theory/theory.cpp + theory/theory.h + theory/theory_engine.cpp + theory/theory_engine.h + theory/theory_model.cpp + theory/theory_model.h + theory/theory_model_builder.cpp + theory/theory_model_builder.h + theory/theory_registrar.h + theory/theory_test_utils.h + theory/type_enumerator.h + theory/type_set.cpp + theory/type_set.h + theory/uf/equality_engine.cpp + theory/uf/equality_engine.h + theory/uf/equality_engine_types.h + theory/uf/symmetry_breaker.cpp + theory/uf/symmetry_breaker.h + theory/uf/theory_uf.cpp + theory/uf/theory_uf.h + theory/uf/theory_uf_model.cpp + theory/uf/theory_uf_model.h + theory/uf/theory_uf_rewriter.h + theory/uf/theory_uf_strong_solver.cpp + theory/uf/theory_uf_strong_solver.h + theory/uf/theory_uf_type_rules.h + theory/valuation.cpp + theory/valuation.h +) + +#-----------------------------------------------------------------------------# +# Add required include paths for this and all subdirectories. + +include_directories(include) +include_directories(. ${CMAKE_CURRENT_BINARY_DIR}) + +#-----------------------------------------------------------------------------# +# IMPORTANT: The order of the theories is important. It affects the order in +# which theory solvers are called/initialized internally. For example, strings +# depends on arith, quantifiers needs to come as the very last. +# See issue https://github.com/CVC4/CVC4/issues/2517 for more details. + +set(KINDS_FILES + ${PROJECT_SOURCE_DIR}/src/theory/builtin/kinds + ${PROJECT_SOURCE_DIR}/src/theory/booleans/kinds + ${PROJECT_SOURCE_DIR}/src/theory/uf/kinds + ${PROJECT_SOURCE_DIR}/src/theory/arith/kinds + ${PROJECT_SOURCE_DIR}/src/theory/bv/kinds + ${PROJECT_SOURCE_DIR}/src/theory/fp/kinds + ${PROJECT_SOURCE_DIR}/src/theory/arrays/kinds + ${PROJECT_SOURCE_DIR}/src/theory/datatypes/kinds + ${PROJECT_SOURCE_DIR}/src/theory/sep/kinds + ${PROJECT_SOURCE_DIR}/src/theory/sets/kinds + ${PROJECT_SOURCE_DIR}/src/theory/strings/kinds + ${PROJECT_SOURCE_DIR}/src/theory/quantifiers/kinds + ${PROJECT_SOURCE_DIR}/src/theory/idl/kinds) + +#-----------------------------------------------------------------------------# +# Add subdirectories + +add_subdirectory(base) +add_subdirectory(expr) +add_subdirectory(options) +add_subdirectory(parser) +add_subdirectory(theory) +add_subdirectory(util) + +#-----------------------------------------------------------------------------# +# All sources for libcvc4 are now collected in LIBCVC4_SRCS and (if generated) +# LIBCVC4_GEN_SRCS (via libcvc4_add_sources). We can now build libcvc4. + +set_source_files_properties(${LIBCVC4_GEN_SRCS} PROPERTIES GENERATED TRUE) +add_library(cvc4 ${LIBCVC4_SRCS} ${LIBCVC4_GEN_SRCS}) +install(TARGETS cvc4 DESTINATION lib) + +set_target_properties(cvc4 PROPERTIES SOVERSION ${CVC4_SOVERSION}) +target_compile_definitions(cvc4 + PRIVATE + -D__BUILDING_CVC4LIB + -D__STDC_LIMIT_MACROS + -D__STDC_FORMAT_MACROS +) +# Add libcvc4 dependencies for generated sources. +add_dependencies(cvc4 gen-expr gen-options gen-tags gen-theory) + +# Add library/include dependencies +if(ENABLE_VALGRIND) + target_include_directories(cvc4 PUBLIC ${Valgrind_INCLUDE_DIR}) +endif() +if(USE_ABC) + target_link_libraries(cvc4 ${ABC_LIBRARIES}) + target_include_directories(cvc4 PUBLIC ${ABC_INCLUDE_DIR}) +endif() +if(USE_CADICAL) + target_link_libraries(cvc4 ${CaDiCaL_LIBRARIES}) + target_include_directories(cvc4 PUBLIC ${CaDiCaL_INCLUDE_DIR}) +endif() +if(USE_CLN) + target_link_libraries(cvc4 ${CLN_LIBRARIES}) + target_include_directories(cvc4 PUBLIC ${CLN_INCLUDE_DIR}) +endif() +if(USE_CRYPTOMINISAT) + target_link_libraries(cvc4 ${CryptoMiniSat_LIBRARIES}) + target_include_directories(cvc4 PUBLIC ${CryptoMiniSat_INCLUDE_DIR}) +endif() +if(USE_GLPK) + target_link_libraries(cvc4 ${GLPK_LIBRARIES}) + target_include_directories(cvc4 PUBLIC ${GLPK_INCLUDE_DIR}) +endif() +if(USE_LFSC) + target_link_libraries(cvc4 ${LFSC_LIBRARIES}) + target_include_directories(cvc4 PUBLIC ${LFSC_INCLUDE_DIR}) +endif() +if(USE_SYMFPU) + target_include_directories(cvc4 PUBLIC ${SymFPU_INCLUDE_DIR}) +endif() + +# Note: When linked statically GMP needs to be linked after CLN since CLN +# depends on GMP. +target_link_libraries(cvc4 ${GMP_LIBRARIES}) +target_include_directories(cvc4 PUBLIC ${GMP_INCLUDE_DIR}) + +#-----------------------------------------------------------------------------# +# Visit main subdirectory after creating target cvc4. For target main, we have +# to manually add library dependencies since we can't use +# target_link_libraries(...) with object libraries for cmake versions <= 3.12. +# Thus, we can only visit main as soon as all dependencies for cvc4 are set up. + +add_subdirectory(main) + +#-----------------------------------------------------------------------------# +# Note: +# We define all install commands for all public headers here in one +# place so that we can easily remove them as soon as we enforce the new +# C++ API. +# +# All (generated) headers that either include cvc4_public.h or +# cvc4parser_public.h need to be listed explicitly here. +# +install(FILES + api/cvc4cpp.h + api/cvc4cppkind.h + DESTINATION + include/api) +install(FILES + base/configuration.h + base/exception.h + base/listener.h + base/modal_exception.h + DESTINATION + include/base) +install(FILES + context/cdhashmap_forward.h + context/cdhashset_forward.h + context/cdinsert_hashmap_forward.h + context/cdlist_forward.h + DESTINATION + include/context) +install(FILES + include/cvc4.h + include/cvc4_public.h + include/cvc4parser_public.h + DESTINATION + include) +install(FILES + expr/array.h + expr/array_store_all.h + expr/ascription_type.h + expr/chain.h + expr/datatype.h + expr/emptyset.h + expr/expr_iomanip.h + expr/expr_stream.h + expr/pickler.h + expr/record.h + expr/symbol_table.h + expr/type.h + expr/uninterpreted_constant.h + expr/variable_type_map.h + ${CMAKE_CURRENT_BINARY_DIR}/expr/expr.h + ${CMAKE_CURRENT_BINARY_DIR}/expr/kind.h + ${CMAKE_CURRENT_BINARY_DIR}/expr/expr_manager.h + DESTINATION + include/expr) +install(FILES + options/argument_extender.h + options/arith_heuristic_pivot_rule.h + options/arith_propagation_mode.h + options/arith_unate_lemma_mode.h + options/datatypes_modes.h + options/language.h + options/option_exception.h + options/options.h + options/printer_modes.h + options/quantifiers_modes.h + options/set_language.h + options/simplification_mode.h + options/sygus_out_mode.h + options/theoryof_mode.h + DESTINATION + include/options) +install(FILES + parser/input.h + parser/parser.h + parser/parser_builder.h + parser/parser_exception.h + DESTINATION + include/parser) +install(FILES + printer/sygus_print_callback.h + DESTINATION + include/printer) +install(FILES + proof/unsat_core.h + DESTINATION + include/proof) +install(FILES + smt/command.h + smt/logic_exception.h + smt/smt_engine.h + DESTINATION + include/smt) +install(FILES + smt_util/lemma_channels.h + smt_util/lemma_input_channel.h + smt_util/lemma_output_channel.h + DESTINATION + include/smt_util) +install(FILES + theory/logic_info.h + DESTINATION + include/theory) +install(FILES + util/abstract_value.h + util/bitvector.h + util/bool.h + util/cardinality.h + util/channel.h + util/divisible.h + util/gmp_util.h + util/hash.h + util/integer_cln_imp.h + util/integer_gmp_imp.h + util/maybe.h + util/proof.h + util/rational_cln_imp.h + util/rational_gmp_imp.h + util/regexp.h + util/resource_manager.h + util/result.h + util/sexpr.h + util/statistics.h + util/tuple.h + util/unsafe_interrupt_exception.h + ${CMAKE_CURRENT_BINARY_DIR}/util/floatingpoint.h + ${CMAKE_CURRENT_BINARY_DIR}/util/integer.h + ${CMAKE_CURRENT_BINARY_DIR}/util/rational.h + DESTINATION + include/util) diff --git a/src/api/cvc4cpp.cpp b/src/api/cvc4cpp.cpp index a3b951dd2..c626b7275 100644 --- a/src/api/cvc4cpp.cpp +++ b/src/api/cvc4cpp.cpp @@ -21,6 +21,8 @@ #include "expr/expr.h" #include "expr/expr_manager.h" #include "expr/kind.h" +#include "expr/metakind.h" +#include "expr/node_manager.h" #include "expr/type.h" #include "options/main_options.h" #include "options/options.h" @@ -566,6 +568,20 @@ CVC4::Kind extToIntKind(Kind k) } return it->second; } + +uint32_t minArity(Kind k) +{ + Assert(isDefinedKind(k)); + Assert(isDefinedIntKind(extToIntKind(k))); + return CVC4::ExprManager::minArity(extToIntKind(k)); +} + +uint32_t maxArity(Kind k) +{ + Assert(isDefinedKind(k)); + Assert(isDefinedIntKind(extToIntKind(k))); + return CVC4::ExprManager::maxArity(extToIntKind(k)); +} } // namespace std::string kindToString(Kind k) @@ -625,6 +641,10 @@ class CVC4ApiExceptionStream CVC4_API_CHECK(cond) << "Invalid kind '" << kindToString(kind) \ << "', expected " << expected_kind_str; +#define CVC4_API_ARG_CHECK_EXPECTED(cond, arg, expected_arg_str) \ + CVC4_API_CHECK(cond) << "Invalid argument '" << (arg).toString() << "' for " \ + << #arg << ", expected " << expected_arg_str; + } // namespace /* -------------------------------------------------------------------------- */ @@ -708,7 +728,6 @@ Sort::~Sort() {} Sort& Sort::operator=(const Sort& s) { - // CHECK: valid sort s? if (this != &s) { *d_type = *s.d_type; @@ -716,119 +735,43 @@ Sort& Sort::operator=(const Sort& s) return *this; } -bool Sort::operator==(const Sort& s) const -{ - // CHECK: valid sort s? - return *d_type == *s.d_type; -} +bool Sort::operator==(const Sort& s) const { return *d_type == *s.d_type; } -bool Sort::operator!=(const Sort& s) const -{ - // CHECK: valid sort s? - return *d_type != *s.d_type; -} +bool Sort::operator!=(const Sort& s) const { return *d_type != *s.d_type; } -bool Sort::isBoolean() const -{ - // CHECK: valid sort s? - return d_type->isBoolean(); -} +bool Sort::isBoolean() const { return d_type->isBoolean(); } -bool Sort::isInteger() const -{ - // CHECK: valid sort s? - return d_type->isInteger(); -} +bool Sort::isInteger() const { return d_type->isInteger(); } -bool Sort::isReal() const -{ - // CHECK: valid sort s? - return d_type->isReal(); -} +bool Sort::isReal() const { return d_type->isReal(); } -bool Sort::isString() const -{ - // CHECK: valid sort s? - return d_type->isString(); -} +bool Sort::isString() const { return d_type->isString(); } -bool Sort::isRegExp() const -{ - // CHECK: valid sort s? - return d_type->isRegExp(); -} +bool Sort::isRegExp() const { return d_type->isRegExp(); } -bool Sort::isRoundingMode() const -{ - // CHECK: valid sort s? - return d_type->isRoundingMode(); -} +bool Sort::isRoundingMode() const { return d_type->isRoundingMode(); } -bool Sort::isBitVector() const -{ - // CHECK: valid sort s? - return d_type->isBitVector(); -} +bool Sort::isBitVector() const { return d_type->isBitVector(); } -bool Sort::isFloatingPoint() const -{ - // CHECK: valid sort s? - return d_type->isFloatingPoint(); -} +bool Sort::isFloatingPoint() const { return d_type->isFloatingPoint(); } -bool Sort::isDatatype() const -{ - // CHECK: valid sort s? - return d_type->isDatatype(); -} +bool Sort::isDatatype() const { return d_type->isDatatype(); } -bool Sort::isFunction() const -{ - // CHECK: valid sort s? - return d_type->isFunction(); -} +bool Sort::isFunction() const { return d_type->isFunction(); } -bool Sort::isPredicate() const -{ - // CHECK: valid sort s? - return d_type->isPredicate(); -} +bool Sort::isPredicate() const { return d_type->isPredicate(); } -bool Sort::isTuple() const -{ - // CHECK: valid sort s? - return d_type->isTuple(); -} +bool Sort::isTuple() const { return d_type->isTuple(); } -bool Sort::isRecord() const -{ - // CHECK: valid sort s? - return d_type->isRecord(); -} +bool Sort::isRecord() const { return d_type->isRecord(); } -bool Sort::isArray() const -{ - // CHECK: valid sort s? - return d_type->isArray(); -} +bool Sort::isArray() const { return d_type->isArray(); } -bool Sort::isSet() const -{ - // CHECK: valid sort s? - return d_type->isSet(); -} +bool Sort::isSet() const { return d_type->isSet(); } -bool Sort::isUninterpretedSort() const -{ - // CHECK: valid sort s? - return d_type->isSort(); -} +bool Sort::isUninterpretedSort() const { return d_type->isSort(); } -bool Sort::isSortConstructor() const -{ - // CHECK: valid sort s? - return d_type->isSortConstructor(); -} +bool Sort::isSortConstructor() const { return d_type->isSortConstructor(); } Datatype Sort::getDatatype() const { @@ -855,11 +798,7 @@ Sort Sort::instantiate(const std::vector<Sort>& params) const return static_cast<SortConstructorType*>(d_type.get())->instantiate(tparams); } -std::string Sort::toString() const -{ - // CHECK: valid sort s? - return d_type->toString(); -} +std::string Sort::toString() const { return d_type->toString(); } // !!! This is only temporarily available until the parser is fully migrated // to the new API. !!! @@ -888,7 +827,6 @@ Term::~Term() {} Term& Term::operator=(const Term& t) { - // CHECK: expr managers must match if (this != &t) { *d_expr = *t.d_expr; @@ -896,17 +834,9 @@ Term& Term::operator=(const Term& t) return *this; } -bool Term::operator==(const Term& t) const -{ - // CHECK: expr managers must match - return *d_expr == *t.d_expr; -} +bool Term::operator==(const Term& t) const { return *d_expr == *t.d_expr; } -bool Term::operator!=(const Term& t) const -{ - // CHECK: expr managers must match - return *d_expr != *t.d_expr; -} +bool Term::operator!=(const Term& t) const { return *d_expr != *t.d_expr; } Kind Term::getKind() const { return intToExtKind(d_expr->getKind()); } @@ -1069,7 +999,6 @@ OpTerm::~OpTerm() {} OpTerm& OpTerm::operator=(const OpTerm& t) { - // CHECK: expr managers must match if (this != &t) { *d_expr = *t.d_expr; @@ -1077,17 +1006,9 @@ OpTerm& OpTerm::operator=(const OpTerm& t) return *this; } -bool OpTerm::operator==(const OpTerm& t) const -{ - // CHECK: expr managers must match - return *d_expr == *t.d_expr; -} +bool OpTerm::operator==(const OpTerm& t) const { return *d_expr == *t.d_expr; } -bool OpTerm::operator!=(const OpTerm& t) const -{ - // CHECK: expr managers must match - return *d_expr != *t.d_expr; -} +bool OpTerm::operator!=(const OpTerm& t) const { return *d_expr != *t.d_expr; } Kind OpTerm::getKind() const { return intToExtKind(d_expr->getKind()); } @@ -1535,7 +1456,7 @@ size_t RoundingModeHashFunction::operator()(const RoundingMode& rm) const Solver::Solver(Options* opts) { - Options* o = opts == nullptr ? new Options() : opts; + Options* o = opts == nullptr ? new Options() : opts; d_exprMgr.reset(new ExprManager(*o)); d_smtEngine.reset(new SmtEngine(d_exprMgr.get())); d_rng.reset(new Random((*o)[options::seed])); @@ -1566,8 +1487,6 @@ Sort Solver::getRoundingmodeSort(void) const Sort Solver::mkArraySort(Sort indexSort, Sort elemSort) const { - // CHECK: indexSort exists - // CHECK: elemSort exists return d_exprMgr->mkArrayType(*indexSort.d_type, *elemSort.d_type); } @@ -1585,8 +1504,6 @@ Sort Solver::mkDatatypeSort(DatatypeDecl dtypedecl) const Sort Solver::mkFunctionSort(Sort domain, Sort range) const { - // CHECK: domain exists - // CHECK: range exists // CHECK: // domain.isFirstClass() // else "can not create function type for domain type that is not @@ -1603,8 +1520,6 @@ Sort Solver::mkFunctionSort(Sort domain, Sort range) const Sort Solver::mkFunctionSort(const std::vector<Sort>& argSorts, Sort range) const { - // CHECK: for all s in argSorts, s exists - // CHECK: range exists // CHECK: argSorts.size() >= 1 // CHECK: // for (unsigned i = 0; i < argSorts.size(); ++ i) @@ -1629,7 +1544,6 @@ Sort Solver::mkParamSort(const std::string& symbol) const Sort Solver::mkPredicateSort(const std::vector<Sort>& sorts) const { - // CHECK: for all s in sorts, s exists // CHECK: sorts.size() >= 1 // CHECK: // for (unsigned i = 0; i < sorts.size(); ++ i) @@ -1663,7 +1577,6 @@ Sort Solver::mkUninterpretedSort(const std::string& symbol) const Sort Solver::mkTupleSort(const std::vector<Sort>& sorts) const { - // CHECK: for all s in sorts, s exists // CHECK: // for (unsigned i = 0; i < sorts.size(); ++ i) // !sorts[i].isFunctionLike() @@ -1849,7 +1762,6 @@ Term Solver::mkBitVector(std::string& s, uint32_t base) const Term Solver::mkConst(RoundingMode rm) const { - // CHECK: valid rm? return d_exprMgr->mkConst(s_rmodes.at(rm)); } @@ -2007,9 +1919,12 @@ Term Solver::mkConst(Kind kind, uint32_t arg1, uint64_t arg2) const Term Solver::mkConst(Kind kind, uint32_t arg1, uint32_t arg2, Term arg3) const { - // CHECK: arg 3 is bit-vector constant CVC4_API_KIND_CHECK_EXPECTED( kind == CONST_FLOATINGPOINT, kind, "CONST_FLOATINGPOINT"); + CVC4_API_ARG_CHECK_EXPECTED( + arg3.getSort().isBitVector() && arg3.d_expr->isConst(), + arg3, + "bit-vector constant"); return d_exprMgr->mkConst( CVC4::FloatingPoint(arg1, arg2, arg3.d_expr->getConst<BitVector>())); } @@ -2019,31 +1934,77 @@ Term Solver::mkConst(Kind kind, uint32_t arg1, uint32_t arg2, Term arg3) const Term Solver::mkVar(const std::string& symbol, Sort sort) const { - // CHECK: sort exists? return d_exprMgr->mkVar(symbol, *sort.d_type); } -Term Solver::mkVar(Sort sort) const -{ - // CHECK: sort exists? - return d_exprMgr->mkVar(*sort.d_type); -} +Term Solver::mkVar(Sort sort) const { return d_exprMgr->mkVar(*sort.d_type); } Term Solver::mkBoundVar(const std::string& symbol, Sort sort) const { - // CHECK: sort exists? return d_exprMgr->mkBoundVar(symbol, *sort.d_type); } Term Solver::mkBoundVar(Sort sort) const { - // CHECK: sort exists? return d_exprMgr->mkBoundVar(*sort.d_type); } /* Create terms */ /* -------------------------------------------------------------------------- */ +void Solver::checkMkTerm(Kind kind, uint32_t nchildren) const +{ + CVC4_API_KIND_CHECK(kind); + Assert(isDefinedIntKind(extToIntKind(kind))); + const CVC4::kind::MetaKind mk = kind::metaKindOf(extToIntKind(kind)); + CVC4_API_KIND_CHECK_EXPECTED( + mk == kind::metakind::PARAMETERIZED || mk == kind::metakind::OPERATOR, + kind, + "Only operator-style terms are created with mkTerm(), " + "to create variables and constants see mkVar(), mkBoundVar(), " + "and mkConst()."); + if (nchildren) + { + const uint32_t n = + nchildren - (mk == CVC4::kind::metakind::PARAMETERIZED ? 1 : 0); + CVC4_API_KIND_CHECK_EXPECTED( + n >= minArity(kind) && n <= maxArity(kind), + kind, + "Terms with kind " << kindToString(kind) << " must have at least " + << minArity(kind) << " children and at most " + << maxArity(kind) + << " children (the one under construction has " << n + << ")"); + } +} + +void Solver::checkMkOpTerm(OpTerm opTerm, uint32_t nchildren) const +{ + const Kind kind = opTerm.getKind(); + Assert(isDefinedIntKind(extToIntKind(kind))); + const CVC4::Kind int_kind = extToIntKind(kind); + const CVC4::Kind int_op_kind = + NodeManager::operatorToKind(opTerm.d_expr->getNode()); + CVC4_API_ARG_CHECK_EXPECTED( + int_kind == kind::BUILTIN + || CVC4::kind::metaKindOf(int_op_kind) + == kind::metakind::PARAMETERIZED, + opTerm, + "This term constructor is for parameterized kinds only"); + if (nchildren) + { + uint32_t min_arity = ExprManager::minArity(int_op_kind); + uint32_t max_arity = ExprManager::maxArity(int_op_kind); + CVC4_API_KIND_CHECK_EXPECTED( + nchildren >= min_arity && nchildren <= max_arity, + kind, + "Terms with kind " << kindToString(kind) << " must have at least " + << min_arity << " children and at most " << max_arity + << " children (the one under construction has " + << nchildren << ")"); + } +} + Term Solver::mkTerm(Kind kind) const { CVC4_API_KIND_CHECK_EXPECTED( @@ -2069,71 +2030,19 @@ Term Solver::mkTerm(Kind kind, Sort sort) const Term Solver::mkTerm(Kind kind, Term child) const { - // CHECK: - // NodeManager::fromExprManager(d_exprMgr) - // == NodeManager::fromExprManager(child.getExprManager()) - // CHECK: - // const Metakind mk = kind::metaKindOf(kind); - // mk != kind::metakind::PARAMETERIZED && mk != kind::metakind::OPERATOR - // else "Only operator-style expressions are made with mkExpr(); " - // "to make variables and constants, see mkVar(), mkBoundVar(), " - // "and mkConst()." - // CHECK: - // const unsigned n = 1 - (mk == kind::metakind::PARAMETERIZED ? 1 : 0); - // n < minArity(kind) || n > maxArity(kind) - // else "Exprs with kind %s must have at least %u children and " - // "at most %u children (the one under construction has %u)" - CVC4_API_KIND_CHECK(kind); - CVC4::Kind k = extToIntKind(kind); - Assert(isDefinedIntKind(k)); - return d_exprMgr->mkExpr(k, *child.d_expr); + checkMkTerm(kind, 1); + return d_exprMgr->mkExpr(extToIntKind(kind), *child.d_expr); } Term Solver::mkTerm(Kind kind, Term child1, Term child2) const { - CVC4_API_KIND_CHECK(kind); - // CHECK: - // NodeManager::fromExprManager(d_exprMgr) - // == NodeManager::fromExprManager(child1.getExprManager()) - // NodeManager::fromExprManager(d_exprMgr) - // == NodeManager::fromExprManager(child2.getExprManager()) - // CHECK: - // const Metakind mk = kind::metaKindOf(kind); - // mk != kind::metakind::PARAMETERIZED && mk != kind::metakind::OPERATOR - // else "Only operator-style expressions are made with mkExpr(); " - // "to make variables and constants, see mkVar(), mkBoundVar(), " - // "and mkConst()." - // CHECK: - // const unsigned n = 2 - (mk == kind::metakind::PARAMETERIZED ? 1 : 0); - // n < minArity(kind) || n > maxArity(kind) - // else "Exprs with kind %s must have at least %u children and " - // "at most %u children (the one under construction has %u)" - CVC4::Kind k = extToIntKind(kind); - Assert(isDefinedIntKind(k)); - return d_exprMgr->mkExpr(k, *child1.d_expr, *child2.d_expr); + checkMkTerm(kind, 2); + return d_exprMgr->mkExpr(extToIntKind(kind), *child1.d_expr, *child2.d_expr); } Term Solver::mkTerm(Kind kind, Term child1, Term child2, Term child3) const { - // CHECK: - // NodeManager::fromExprManager(d_exprMgr) - // == NodeManager::fromExprManager(child1.getExprManager()) - // NodeManager::fromExprManager(d_exprMgr) - // == NodeManager::fromExprManager(child2.getExprManager()) - // NodeManager::fromExprManager(d_exprMgr) - // == NodeManager::fromExprManager(child3.getExprManager()) - // CHECK: - // const Metakind mk = kind::metaKindOf(kind); - // mk != kind::metakind::PARAMETERIZED && mk != kind::metakind::OPERATOR - // else "Only operator-style expressions are made with mkExpr(); " - // "to make variables and constants, see mkVar(), mkBoundVar(), " - // "and mkConst()." - // CHECK: - // const unsigned n = 3 - (mk == kind::metakind::PARAMETERIZED ? 1 : 0); - // n < minArity(kind) || n > maxArity(kind) - // else "Exprs with kind %s must have at least %u children and " - // "at most %u children (the one under construction has %u)" - CVC4_API_KIND_CHECK(kind); + checkMkTerm(kind, 3); std::vector<Expr> echildren{*child1.d_expr, *child2.d_expr, *child3.d_expr}; CVC4::Kind k = extToIntKind(kind); Assert(isDefinedIntKind(k)); @@ -2143,22 +2052,7 @@ Term Solver::mkTerm(Kind kind, Term child1, Term child2, Term child3) const Term Solver::mkTerm(Kind kind, const std::vector<Term>& children) const { - // CHECK: - // for c in children: - // NodeManager::fromExprManager(d_exprMgr) - // == NodeManager::fromExprManager(c.getExprManager()) - // CHECK: - // const Metakind mk = kind::metaKindOf(kind); - // mk != kind::metakind::PARAMETERIZED && mk != kind::metakind::OPERATOR - // else "Only operator-style expressions are made with mkExpr(); " - // "to make variables and constants, see mkVar(), mkBoundVar(), " - // "and mkConst()." - // CHECK: - // const unsigned n = children.size() - (mk == kind::metakind::PARAMETERIZED ? - // 1 : 0); n < minArity(kind) || n > maxArity(kind) else "Exprs with kind %s - // must have at least %u children and " - // "at most %u children (the one under construction has %u)" - CVC4_API_KIND_CHECK(kind); + checkMkTerm(kind, children.size()); std::vector<Expr> echildren = termVectorToExprs(children); CVC4::Kind k = extToIntKind(kind); Assert(isDefinedIntKind(k)); @@ -2168,102 +2062,32 @@ Term Solver::mkTerm(Kind kind, const std::vector<Term>& children) const Term Solver::mkTerm(OpTerm opTerm) const { - // CHECK: - // NodeManager::fromExprManager(d_exprMgr) - // == NodeManager::fromExprManager(opExpr.getExprManager()) - // CHECK: - // const Kind kind = NodeManager::opToKind(opExpr.getNode()); - // opExpr.getKind() != kind::BUILTIN - // && kind::metaKindOf(kind) != kind::metakind::PARAMETERIZED - // else "This Expr constructor is for parameterized kinds only" + checkMkOpTerm(opTerm, 0); return d_exprMgr->mkExpr(*opTerm.d_expr); } Term Solver::mkTerm(OpTerm opTerm, Term child) const { - // CHECK: - // NodeManager::fromExprManager(d_exprMgr) - // == NodeManager::fromExprManager(opExpr.getExprManager()) - // NodeManager::fromExprManager(d_exprMgr) - // == NodeManager::fromExprManager(child.getExprManager()) - // CHECK: - // const Kind kind = NodeManager::opToKind(opExpr.getNode()); - // opExpr.getKind() != kind::BUILTIN - // && kind::metaKindOf(kind) != kind::metakind::PARAMETERIZED - // else "This Expr constructor is for parameterized kinds only" - // CHECK: - // const unsigned n = 1 - (mk == kind::metakind::PARAMETERIZED ? 1 : 0); - // n < minArity(kind) || n > maxArity(kind) - // else "Exprs with kind %s must have at least %u children and " - // "at most %u children (the one under construction has %u)" + checkMkOpTerm(opTerm, 1); return d_exprMgr->mkExpr(*opTerm.d_expr, *child.d_expr); } Term Solver::mkTerm(OpTerm opTerm, Term child1, Term child2) const { - // CHECK: - // NodeManager::fromExprManager(d_exprMgr) - // == NodeManager::fromExprManager(opExpr.getExprManager()) - // NodeManager::fromExprManager(d_exprMgr) - // == NodeManager::fromExprManager(child1.getExprManager()) - // NodeManager::fromExprManager(d_exprMgr) - // == NodeManager::fromExprManager(child2.getExprManager()) - // CHECK: - // const Kind kind = NodeManager::opToKind(opExpr.getNode()); - // opExpr.getKind() != kind::BUILTIN - // && kind::metaKindOf(kind) != kind::metakind::PARAMETERIZED - // else "This Expr constructor is for parameterized kinds only" - // CHECK: - // const unsigned n = 2 - (mk == kind::metakind::PARAMETERIZED ? 1 : 0); - // n < minArity(kind) || n > maxArity(kind) - // else "Exprs with kind %s must have at least %u children and " - // "at most %u children (the one under construction has %u)" + checkMkOpTerm(opTerm, 2); return d_exprMgr->mkExpr(*opTerm.d_expr, *child1.d_expr, *child2.d_expr); } Term Solver::mkTerm(OpTerm opTerm, Term child1, Term child2, Term child3) const { - // CHECK: - // NodeManager::fromExprManager(d_exprMgr) - // == NodeManager::fromExprManager(opExpr.getExprManager()) - // NodeManager::fromExprManager(d_exprMgr) - // == NodeManager::fromExprManager(child1.getExprManager()) - // NodeManager::fromExprManager(d_exprMgr) - // == NodeManager::fromExprManager(child2.getExprManager()) - // NodeManager::fromExprManager(d_exprMgr) - // == NodeManager::fromExprManager(child3.getExprManager()) - // CHECK: - // const Kind kind = NodeManager::opToKind(opExpr.getNode()); - // opExpr.getKind() != kind::BUILTIN - // && kind::metaKindOf(kind) != kind::metakind::PARAMETERIZED - // else "This Expr constructor is for parameterized kinds only" - // CHECK: - // const unsigned n = 3 - (mk == kind::metakind::PARAMETERIZED ? 1 : 0); - // n < minArity(kind) || n > maxArity(kind) - // else "Exprs with kind %s must have at least %u children and " - // "at most %u children (the one under construction has %u)" + checkMkOpTerm(opTerm, 3); return d_exprMgr->mkExpr( *opTerm.d_expr, *child1.d_expr, *child2.d_expr, *child3.d_expr); } Term Solver::mkTerm(OpTerm opTerm, const std::vector<Term>& children) const { - // CHECK: - // NodeManager::fromExprManager(d_exprMgr) - // == NodeManager::fromExprManager(opExpr.getExprManager()) - // for c in children: - // NodeManager::fromExprManager(d_exprMgr) - // == NodeManager::fromExprManager(c.getExprManager()) - // CHECK: - // const Kind kind = NodeManager::opToKind(opExpr.getNode()); - // opExpr.getKind() != kind::BUILTIN - // && kind::metaKindOf(kind) != kind::metakind::PARAMETERIZED - // else "This Expr constructor is for parameterized kinds only" - // CHECK: - // const unsigned n = children.size() - (mk == kind::metakind::PARAMETERIZED ? - // 1 : 0); n < minArity(kind) || n > maxArity(kind) else "Exprs with kind %s - // must have at least %u children and " - // "at most %u children (the one under construction has %u)" + checkMkOpTerm(opTerm, children.size()); std::vector<Expr> echildren = termVectorToExprs(children); return d_exprMgr->mkExpr(*opTerm.d_expr, echildren); } @@ -2336,9 +2160,10 @@ OpTerm Solver::mkOpTerm(Kind kind, uint32_t arg) res = d_exprMgr->mkConst(CVC4::TupleUpdate(arg)); break; default: - // CHECK: kind valid? - Assert(!res.isNull()); + CVC4_API_KIND_CHECK_EXPECTED( + false, kind, "operator kind with uint32_t argument"); } + Assert(!res.isNull()); return res; } @@ -2374,9 +2199,10 @@ OpTerm Solver::mkOpTerm(Kind kind, uint32_t arg1, uint32_t arg2) res = d_exprMgr->mkConst(CVC4::FloatingPointToFPGeneric(arg1, arg2)); break; default: - // CHECK: kind valid? - Assert(!res.isNull()); + CVC4_API_KIND_CHECK_EXPECTED( + false, kind, "operator kind with two uint32_t arguments"); } + Assert(!res.isNull()); return res; } @@ -2466,7 +2292,6 @@ Result Solver::checkSatAssuming(const std::vector<Term>& assumptions) const */ Term Solver::declareConst(const std::string& symbol, Sort sort) const { - // CHECK: sort exists return d_exprMgr->mkVar(symbol, *sort.d_type); } @@ -2490,7 +2315,6 @@ Sort Solver::declareDatatype( */ Term Solver::declareFun(const std::string& symbol, Sort sort) const { - // CHECK: sort exists // CHECK: // sort.isFirstClass() // else "can not create function type for range type that is not first class" @@ -2511,8 +2335,6 @@ Term Solver::declareFun(const std::string& symbol, const std::vector<Sort>& sorts, Sort sort) const { - // CHECK: for all s in sorts, s exists - // CHECK: sort exists // CHECK: // for (unsigned i = 0; i < sorts.size(); ++ i) // sorts[i].isFirstClass() @@ -2563,7 +2385,6 @@ Term Solver::defineFun(const std::string& symbol, // == NodeManager::fromExprManager(bv.getExprManager()) // NodeManager::fromExprManager(d_exprMgr) // == NodeManager::fromExprManager(expr.getExprManager()) - // CHECK: sort exists // CHECK: not recursive // CHECK: // sort.isFirstClass() @@ -2627,7 +2448,6 @@ Term Solver::defineFunRec(const std::string& symbol, // == NodeManager::fromExprManager(bv.getExprManager()) // NodeManager::fromExprManager(d_exprMgr) // == NodeManager::fromExprManager(expr.getExprManager()) - // CHECK: sort exists // CHECK: // sort.isFirstClass() // else "can not create function type for range type that is not first class" diff --git a/src/api/cvc4cpp.h b/src/api/cvc4cpp.h index a701eb472..3481fd953 100644 --- a/src/api/cvc4cpp.h +++ b/src/api/cvc4cpp.h @@ -55,6 +55,7 @@ class CVC4_PUBLIC CVC4ApiException : public std::exception CVC4ApiException(const std::string& str) : d_msg(str) {} CVC4ApiException(const std::stringstream& stream) :d_msg(stream.str()) {} std::string getMessage() const { return d_msg; } + const char* what() const noexcept override { return d_msg.c_str(); } private: std::string d_msg; }; @@ -2427,6 +2428,10 @@ class CVC4_PUBLIC Solver std::vector<Type> sortVectorToTypes(const std::vector<Sort>& vector) const; /* Helper to convert a vector of sorts to internal types. */ std::vector<Expr> termVectorToExprs(const std::vector<Term>& vector) const; + /* Helper to check for API misuse in mkTerm functions. */ + void checkMkOpTerm(OpTerm opTerm, uint32_t nchildren) const; + /* Helper to check for API misuse in mkOpTerm functions. */ + void checkMkTerm(Kind kind, uint32_t nchildren) const; /* The expression manager of this solver. */ std::unique_ptr<ExprManager> d_exprMgr; diff --git a/src/base/CMakeLists.txt b/src/base/CMakeLists.txt new file mode 100644 index 000000000..532ed475d --- /dev/null +++ b/src/base/CMakeLists.txt @@ -0,0 +1,121 @@ +#-----------------------------------------------------------------------------# +# Extract info from Git for git_versioninfo.cpp + +find_package(Git) + +set(GIT_BUILD "false") +set(GIT_IS_DIRTY "false") +set(GIT_SHA1 "") +set(GIT_BRANCH "") + +if(GIT_FOUND) + # Get current git branch, result is != 0 if this is not a git repository + execute_process( + COMMAND ${GIT_EXECUTABLE} -C ${PROJECT_SOURCE_DIR} rev-parse --abbrev-ref HEAD + RESULT_VARIABLE GIT_RESULT + OUTPUT_VARIABLE GIT_BRANCH + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + if("${GIT_RESULT}" STREQUAL "0") + set(GIT_BUILD "true") + # Extract sha1 of HEAD + execute_process( + COMMAND ${GIT_EXECUTABLE} -C ${PROJECT_SOURCE_DIR} rev-parse HEAD + OUTPUT_VARIABLE GIT_SHA1 + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + # Result is != 0 if worktree is dirty + execute_process( + COMMAND ${GIT_EXECUTABLE} -C ${PROJECT_SOURCE_DIR} diff --quiet + RESULT_VARIABLE GIT_RESULT + ) + if(NOT "${GIT_RESULT}" STREQUAL "0") + set(GIT_IS_DIRTY "true") + endif() + endif() +endif() + +#-----------------------------------------------------------------------------# +# Generate git_versioninfo.cpp + +configure_file(git_versioninfo.cpp.in git_versioninfo.cpp) + +libcvc4_add_sources( + configuration.cpp + configuration.h + configuration_private.h + cvc4_assert.cpp + cvc4_assert.h + cvc4_check.cpp + cvc4_check.h + exception.cpp + exception.h + listener.cpp + listener.h + modal_exception.h + output.cpp + output.h +) + +libcvc4_add_sources(GENERATED git_versioninfo.cpp) + +#-----------------------------------------------------------------------------# +# Generate code for debug/trace tags + +set(gentmptags_script ${CMAKE_CURRENT_LIST_DIR}/gentmptags.sh) +set(gentags_script ${CMAKE_CURRENT_LIST_DIR}/gentags.sh) +set(genheader_script ${CMAKE_CURRENT_LIST_DIR}/genheader.sh) + +file(GLOB_RECURSE source_files + ${PROJECT_SOURCE_DIR}/src/*.cpp + ${PROJECT_SOURCE_DIR}/src/*.cc + ${PROJECT_SOURCE_DIR}/src/*.h + ${PROJECT_SOURCE_DIR}/src/*.g) +string(REPLACE ";" " " source_files_list "${source_files}") + +# Note: gen-tags-{debug,trace} are targets since we always want to generate +# the temporary tag files {Debug,Trace}_tags.tmp in order to check if tags +# were added/modified/deleted. +add_custom_target( + gen-tags-debug + COMMAND + ${gentmptags_script} ${CMAKE_CURRENT_LIST_DIR} Debug ${source_files_list} + DEPENDS mktags +) + +add_custom_target( + gen-tags-trace + COMMAND + ${gentmptags_script} ${CMAKE_CURRENT_LIST_DIR} Trace ${source_files_list} + DEPENDS mktags +) + +add_custom_command( + OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/Debug_tags + COMMAND ${gentags_script} Debug + DEPENDS gen-tags-debug ${CMAKE_CURRENT_BINARY_DIR}/Debug_tags.tmp +) + +add_custom_command( + OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/Trace_tags + COMMAND ${gentags_script} Trace + DEPENDS gen-tags-trace ${CMAKE_CURRENT_BINARY_DIR}/Trace_tags.tmp +) + +add_custom_command( + OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/Debug_tags.h + COMMAND ${genheader_script} ${CMAKE_CURRENT_LIST_DIR} Debug + DEPENDS mktagheaders ${CMAKE_CURRENT_BINARY_DIR}/Debug_tags +) + +add_custom_command( + OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/Trace_tags.h + COMMAND ${genheader_script} ${CMAKE_CURRENT_LIST_DIR} Trace + DEPENDS mktagheaders ${CMAKE_CURRENT_BINARY_DIR}/Trace_tags +) + +add_custom_target(gen-tags + DEPENDS + ${CMAKE_CURRENT_BINARY_DIR}/Debug_tags.h + ${CMAKE_CURRENT_BINARY_DIR}/Trace_tags.h +) diff --git a/src/base/genheader.sh b/src/base/genheader.sh new file mode 100755 index 000000000..2091f7781 --- /dev/null +++ b/src/base/genheader.sh @@ -0,0 +1,21 @@ +#!/bin/sh +# +# Convenience wrapper for cmake in src/base/CMakeLists.txt +# +# Create Debug_tags.h/Trace_tags.h header files. +# +# Usage: genheader.sh <directory-mktags> Debug|Trace + +path="$1" +shift +tags_type="$1" # Debug/Trace +tags_file="${tags_type}_tags" + +if [ "${tags_type}" != "Debug" ] && [ "${tags_type}" != "Trace" ]; then + echo "$0: Invalid tags type '${tags_type}' (must be 'Debug' or 'Trace')" + exit 1 +fi + +[ ! -e "${tags_file}" ] && echo "$0: ${tags_file} does not exist" && exit 1 + +"${path}/mktagheaders" "${tags_file}" "${tags_file}" > "${tags_file}.h" diff --git a/src/base/gentags.sh b/src/base/gentags.sh new file mode 100755 index 000000000..67888b3f5 --- /dev/null +++ b/src/base/gentags.sh @@ -0,0 +1,26 @@ +#!/bin/sh +# +# Convenience wrapper for cmake in src/base/CMakeLists.txt +# +# Update Debug_tags/Trace_tags in case that debug/trace tags have been +# modified. Use diff to compare the contents of the *.tmp files with the +# corresponding *_tags file. +# +# Usage: gentags.sh Debug|Trace + +tags_type="$1" # Debug/Trace +tags_file="${tags_type}_tags" + +if [ "${tags_type}" != "Debug" ] && [ "${tags_type}" != "Trace" ]; then + echo "$0: Invalid tags type '${tags_type}' (must be 'Debug' or 'Trace')" + exit 1 +fi + +[ ! -e "${tags_file}.tmp" ] && \ + echo "$0: ${tags_file}.tmp does not exist" && exit 1 + +if [ -e "${tags_file}" ]; then + # Do not update file if tags didn't change. + diff -q "${tags_file}.tmp" "${tags_file}" > /dev/null 2>&1 && exit 0 +fi +mv "${tags_file}.tmp" "${tags_file}" diff --git a/src/base/gentmptags.sh b/src/base/gentmptags.sh new file mode 100755 index 000000000..566fa1747 --- /dev/null +++ b/src/base/gentmptags.sh @@ -0,0 +1,21 @@ +#!/bin/sh +# +# Convenience wrapper for cmake in src/base/CMakeLists.txt +# +# Create Debug_tags.tmp/Trace_tags.tmp files from given source files. +# +# Usage: gentmptags.sh <directory-mktags> Debug|Trace <source files ...> + +path="$1" +shift +tags_type="$1" +tags_file="${tags_type}_tags" +shift +source_files_list="$*" + +if [ "${tags_type}" != "Debug" ] && [ "${tags_type}" != "Trace" ]; then + echo "$0: Invalid tags type '${tags_type}' (must be 'Debug' or 'Trace')" + exit 1 +fi + +"${path}/mktags" "${tags_type}" "${source_files_list}" > "${tags_file}.tmp" diff --git a/src/base/git_versioninfo.cpp.in b/src/base/git_versioninfo.cpp.in new file mode 100644 index 000000000..20da094bc --- /dev/null +++ b/src/base/git_versioninfo.cpp.in @@ -0,0 +1,5 @@ +#include "base/configuration.h" +const bool ::CVC4::Configuration::IS_GIT_BUILD = @GIT_BUILD@; +const char* const ::CVC4::Configuration::GIT_BRANCH_NAME = "@GIT_BRANCH@"; +const char* const ::CVC4::Configuration::GIT_COMMIT = "@GIT_SHA1@"; +const bool ::CVC4::Configuration::GIT_HAS_MODIFICATIONS = @GIT_IS_DIRTY@; diff --git a/src/bindings/CMakeLists.txt b/src/bindings/CMakeLists.txt new file mode 100644 index 000000000..1c62ecd58 --- /dev/null +++ b/src/bindings/CMakeLists.txt @@ -0,0 +1,22 @@ +if(NOT ENABLE_SHARED) + message(FATAL_ERROR "Can't build language bindings for static CVC4 build.") +endif() + +find_package(SWIG 3.0.0 REQUIRED) +include(${SWIG_USE_FILE}) + +set(CVC4_SWIG_INTERFACE ${PROJECT_SOURCE_DIR}/src/cvc4.i) + +set_property(SOURCE ${CVC4_SWIG_INTERFACE} PROPERTY CPLUSPLUS ON) + +include_directories( + ${PROJECT_SOURCE_DIR}/src + ${PROJECT_SOURCE_DIR}/src/include + ${CMAKE_BINARY_DIR}/src) + +if(BUILD_BINDINGS_JAVA) + add_subdirectory(java) +endif() +if(BUILD_BINDINGS_PYTHON) + add_subdirectory(python) +endif() diff --git a/src/bindings/java/CMakeLists.txt b/src/bindings/java/CMakeLists.txt new file mode 100644 index 000000000..c3fee67a5 --- /dev/null +++ b/src/bindings/java/CMakeLists.txt @@ -0,0 +1,239 @@ +find_package(Java REQUIRED) +find_package(JNI REQUIRED) +include(UseJava) + +include_directories(${JNI_INCLUDE_DIRS}) + +set(SWIG_MODULE_cvc4jni_EXTRA_DEPS cvc4 cvc4parser) +set_property(SOURCE ${CVC4_SWIG_INTERFACE} PROPERTY CPLUSPLUS ON) +set(CMAKE_SWIG_FLAGS -package edu.nyu.acsys.CVC4) + +if(${CMAKE_VERSION} VERSION_LESS "3.8.0") + swig_add_module(cvc4jni Java ${CVC4_SWIG_INTERFACE}) +else() + swig_add_library(cvc4jni LANGUAGE Java SOURCES ${CVC4_SWIG_INTERFACE}) +endif() +swig_link_libraries(cvc4jni cvc4 cvc4parser ${JNI_LIBRARIRES}) + +# Create CVC4.jar from all generated *.java files. +set(gen_java_files + ${CMAKE_CURRENT_BINARY_DIR}/ArrayStoreAll.java + ${CMAKE_CURRENT_BINARY_DIR}/ArrayStoreAllHashFunction.java + ${CMAKE_CURRENT_BINARY_DIR}/ArrayType.java + ${CMAKE_CURRENT_BINARY_DIR}/AscriptionType.java + ${CMAKE_CURRENT_BINARY_DIR}/AscriptionTypeHashFunction.java + ${CMAKE_CURRENT_BINARY_DIR}/AssertCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/BenchmarkStatus.java + ${CMAKE_CURRENT_BINARY_DIR}/BitVector.java + ${CMAKE_CURRENT_BINARY_DIR}/BitVectorBitOf.java + ${CMAKE_CURRENT_BINARY_DIR}/BitVectorBitOfHashFunction.java + ${CMAKE_CURRENT_BINARY_DIR}/BitVectorExtract.java + ${CMAKE_CURRENT_BINARY_DIR}/BitVectorExtractHashFunction.java + ${CMAKE_CURRENT_BINARY_DIR}/BitVectorHashFunction.java + ${CMAKE_CURRENT_BINARY_DIR}/BitVectorRepeat.java + ${CMAKE_CURRENT_BINARY_DIR}/BitVectorRotateLeft.java + ${CMAKE_CURRENT_BINARY_DIR}/BitVectorRotateRight.java + ${CMAKE_CURRENT_BINARY_DIR}/BitVectorSignExtend.java + ${CMAKE_CURRENT_BINARY_DIR}/BitVectorSize.java + ${CMAKE_CURRENT_BINARY_DIR}/BitVectorType.java + ${CMAKE_CURRENT_BINARY_DIR}/BitVectorZeroExtend.java + ${CMAKE_CURRENT_BINARY_DIR}/BoolHashFunction.java + ${CMAKE_CURRENT_BINARY_DIR}/BooleanType.java + ${CMAKE_CURRENT_BINARY_DIR}/CVC4.java + ${CMAKE_CURRENT_BINARY_DIR}/CVC4IllegalArgumentException.java + ${CMAKE_CURRENT_BINARY_DIR}/CVC4JNI.java + ${CMAKE_CURRENT_BINARY_DIR}/CVC4String.java + ${CMAKE_CURRENT_BINARY_DIR}/CVC4StringHashFunction.java + ${CMAKE_CURRENT_BINARY_DIR}/Cardinality.java + ${CMAKE_CURRENT_BINARY_DIR}/CardinalityBeth.java + ${CMAKE_CURRENT_BINARY_DIR}/CardinalityUnknown.java + ${CMAKE_CURRENT_BINARY_DIR}/CheckSatAssumingCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/CheckSatCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/CheckSynthCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/Command.java + ${CMAKE_CURRENT_BINARY_DIR}/CommandFailure.java + ${CMAKE_CURRENT_BINARY_DIR}/CommandInterrupted.java + ${CMAKE_CURRENT_BINARY_DIR}/CommandPrintSuccess.java + ${CMAKE_CURRENT_BINARY_DIR}/CommandRecoverableFailure.java + ${CMAKE_CURRENT_BINARY_DIR}/CommandSequence.java + ${CMAKE_CURRENT_BINARY_DIR}/CommandStatus.java + ${CMAKE_CURRENT_BINARY_DIR}/CommandSuccess.java + ${CMAKE_CURRENT_BINARY_DIR}/CommandUnsupported.java + ${CMAKE_CURRENT_BINARY_DIR}/CommentCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/Configuration.java + ${CMAKE_CURRENT_BINARY_DIR}/ConstructorType.java + ${CMAKE_CURRENT_BINARY_DIR}/Datatype.java + ${CMAKE_CURRENT_BINARY_DIR}/DatatypeConstructor.java + ${CMAKE_CURRENT_BINARY_DIR}/DatatypeConstructorArg.java + ${CMAKE_CURRENT_BINARY_DIR}/DatatypeDeclarationCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/DatatypeHashFunction.java + ${CMAKE_CURRENT_BINARY_DIR}/DatatypeIndexConstant.java + ${CMAKE_CURRENT_BINARY_DIR}/DatatypeIndexConstantHashFunction.java + ${CMAKE_CURRENT_BINARY_DIR}/DatatypeResolutionException.java + ${CMAKE_CURRENT_BINARY_DIR}/DatatypeSelfType.java + ${CMAKE_CURRENT_BINARY_DIR}/DatatypeType.java + ${CMAKE_CURRENT_BINARY_DIR}/DatatypeUnresolvedType.java + ${CMAKE_CURRENT_BINARY_DIR}/DeclarationCheck.java + ${CMAKE_CURRENT_BINARY_DIR}/DeclarationDefinitionCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/DeclarationSequence.java + ${CMAKE_CURRENT_BINARY_DIR}/DeclareFunctionCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/DeclareTypeCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/DefineFunctionCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/DefineFunctionRecCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/DefineNamedFunctionCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/DefineTypeCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/EchoCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/EmptyCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/EmptySet.java + ${CMAKE_CURRENT_BINARY_DIR}/EmptySetHashFunction.java + ${CMAKE_CURRENT_BINARY_DIR}/Exception.java + ${CMAKE_CURRENT_BINARY_DIR}/ExpandDefinitionsCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/ExportUnsupportedException.java + ${CMAKE_CURRENT_BINARY_DIR}/Expr.java + ${CMAKE_CURRENT_BINARY_DIR}/ExprHashFunction.java + ${CMAKE_CURRENT_BINARY_DIR}/ExprManager.java + ${CMAKE_CURRENT_BINARY_DIR}/ExprManagerMapCollection.java + ${CMAKE_CURRENT_BINARY_DIR}/ExprStream.java + ${CMAKE_CURRENT_BINARY_DIR}/FloatingPointType.java + ${CMAKE_CURRENT_BINARY_DIR}/FunctionType.java + ${CMAKE_CURRENT_BINARY_DIR}/GetAssertionsCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/GetAssignmentCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/GetInfoCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/GetInstantiationsCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/GetModelCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/GetOptionCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/GetQuantifierEliminationCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/GetSynthSolutionCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/GetUnsatAssumptionsCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/GetUnsatCoreCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/GetValueCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/Input.java + ${CMAKE_CURRENT_BINARY_DIR}/InputLanguage.java + ${CMAKE_CURRENT_BINARY_DIR}/InputStream.java + ${CMAKE_CURRENT_BINARY_DIR}/InputStreamException.java + ${CMAKE_CURRENT_BINARY_DIR}/IntToBitVector.java + ${CMAKE_CURRENT_BINARY_DIR}/Integer.java + ${CMAKE_CURRENT_BINARY_DIR}/IntegerHashFunction.java + ${CMAKE_CURRENT_BINARY_DIR}/IntegerType.java + ${CMAKE_CURRENT_BINARY_DIR}/JavaInputStreamAdapter.java + ${CMAKE_CURRENT_BINARY_DIR}/JavaIteratorAdapter_CommandSequence.java + ${CMAKE_CURRENT_BINARY_DIR}/JavaIteratorAdapter_Datatype.java + ${CMAKE_CURRENT_BINARY_DIR}/JavaIteratorAdapter_DatatypeConstructor.java + ${CMAKE_CURRENT_BINARY_DIR}/JavaIteratorAdapter_Expr.java + ${CMAKE_CURRENT_BINARY_DIR}/JavaIteratorAdapter_StatisticsBase.java + ${CMAKE_CURRENT_BINARY_DIR}/JavaIteratorAdapter_UnsatCore.java + ${CMAKE_CURRENT_BINARY_DIR}/JavaOutputStreamAdapter.java + ${CMAKE_CURRENT_BINARY_DIR}/Kind.java + ${CMAKE_CURRENT_BINARY_DIR}/KindHashFunction.java + ${CMAKE_CURRENT_BINARY_DIR}/LastExceptionBuffer.java + ${CMAKE_CURRENT_BINARY_DIR}/LogicException.java + ${CMAKE_CURRENT_BINARY_DIR}/LogicInfo.java + ${CMAKE_CURRENT_BINARY_DIR}/ModalException.java + ${CMAKE_CURRENT_BINARY_DIR}/OptionException.java + ${CMAKE_CURRENT_BINARY_DIR}/Options.java + ${CMAKE_CURRENT_BINARY_DIR}/OutputLanguage.java + ${CMAKE_CURRENT_BINARY_DIR}/Parser.java + ${CMAKE_CURRENT_BINARY_DIR}/ParserBuilder.java + ${CMAKE_CURRENT_BINARY_DIR}/ParserEndOfFileException.java + ${CMAKE_CURRENT_BINARY_DIR}/ParserException.java + ${CMAKE_CURRENT_BINARY_DIR}/ParserExprStream.java + ${CMAKE_CURRENT_BINARY_DIR}/PopCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/PrettySExprs.java + ${CMAKE_CURRENT_BINARY_DIR}/Proof.java + ${CMAKE_CURRENT_BINARY_DIR}/PropagateRuleCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/PushCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/QueryCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/QuitCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/Rational.java + ${CMAKE_CURRENT_BINARY_DIR}/RationalHashFunction.java + ${CMAKE_CURRENT_BINARY_DIR}/RealType.java + ${CMAKE_CURRENT_BINARY_DIR}/Record.java + ${CMAKE_CURRENT_BINARY_DIR}/RecordHashFunction.java + ${CMAKE_CURRENT_BINARY_DIR}/RecordUpdate.java + ${CMAKE_CURRENT_BINARY_DIR}/RecordUpdateHashFunction.java + ${CMAKE_CURRENT_BINARY_DIR}/RecoverableModalException.java + ${CMAKE_CURRENT_BINARY_DIR}/RegExpType.java + ${CMAKE_CURRENT_BINARY_DIR}/ResetAssertionsCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/ResetCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/ResourceManager.java + ${CMAKE_CURRENT_BINARY_DIR}/Result.java + ${CMAKE_CURRENT_BINARY_DIR}/RewriteRuleCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/RoundingModeType.java + ${CMAKE_CURRENT_BINARY_DIR}/SExpr.java + ${CMAKE_CURRENT_BINARY_DIR}/SExprKeyword.java + ${CMAKE_CURRENT_BINARY_DIR}/SExprType.java + ${CMAKE_CURRENT_BINARY_DIR}/SWIGTYPE_p_CVC4__Model.java + ${CMAKE_CURRENT_BINARY_DIR}/SWIGTYPE_p_CVC4__Printer.java + ${CMAKE_CURRENT_BINARY_DIR}/SWIGTYPE_p_CVC4__api__Solver.java + ${CMAKE_CURRENT_BINARY_DIR}/SWIGTYPE_p_InstFormatMode.java + ${CMAKE_CURRENT_BINARY_DIR}/SWIGTYPE_p_LemmaChannels.java + ${CMAKE_CURRENT_BINARY_DIR}/SWIGTYPE_p_Listener.java + ${CMAKE_CURRENT_BINARY_DIR}/SWIGTYPE_p_ListenerCollection__Registration.java + ${CMAKE_CURRENT_BINARY_DIR}/SWIGTYPE_p_MaybeT_CVC4__Rational_t.java + ${CMAKE_CURRENT_BINARY_DIR}/SWIGTYPE_p_Type.java + ${CMAKE_CURRENT_BINARY_DIR}/SWIGTYPE_p_mpq_class.java + ${CMAKE_CURRENT_BINARY_DIR}/SWIGTYPE_p_mpz_class.java + ${CMAKE_CURRENT_BINARY_DIR}/SWIGTYPE_p_std__istream.java + ${CMAKE_CURRENT_BINARY_DIR}/SWIGTYPE_p_std__mapT_CVC4__Expr_CVC4__Expr_t.java + ${CMAKE_CURRENT_BINARY_DIR}/SWIGTYPE_p_std__ostream.java + ${CMAKE_CURRENT_BINARY_DIR}/SWIGTYPE_p_std__shared_ptrT_CVC4__SygusPrintCallback_t.java + ${CMAKE_CURRENT_BINARY_DIR}/SWIGTYPE_p_std__string.java + ${CMAKE_CURRENT_BINARY_DIR}/SWIGTYPE_p_std__unordered_mapT_CVC4__Expr_CVC4__ProofLetCount_CVC4__ExprHashFunction_t.java + ${CMAKE_CURRENT_BINARY_DIR}/SWIGTYPE_p_std__vectorT_CVC4__DatatypeConstructorArg_t.java + ${CMAKE_CURRENT_BINARY_DIR}/SWIGTYPE_p_std__vectorT_CVC4__DatatypeConstructor_t.java + ${CMAKE_CURRENT_BINARY_DIR}/SWIGTYPE_p_std__vectorT_CVC4__SygusGTerm_t.java + ${CMAKE_CURRENT_BINARY_DIR}/SWIGTYPE_p_std__vectorT_std__pairT_CVC4__Expr_CVC4__Expr_t_t.java + ${CMAKE_CURRENT_BINARY_DIR}/SWIGTYPE_p_std__vectorT_std__vectorT_std__string_t_t.java + ${CMAKE_CURRENT_BINARY_DIR}/ScopeException.java + ${CMAKE_CURRENT_BINARY_DIR}/SelectorType.java + ${CMAKE_CURRENT_BINARY_DIR}/SetBenchmarkLogicCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/SetBenchmarkStatusCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/SetExpressionNameCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/SetInfoCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/SetOptionCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/SetType.java + ${CMAKE_CURRENT_BINARY_DIR}/SetUserAttributeCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/SimplifyCommand.java + ${CMAKE_CURRENT_BINARY_DIR}/SmtEngine.java + ${CMAKE_CURRENT_BINARY_DIR}/SortConstructorType.java + ${CMAKE_CURRENT_BINARY_DIR}/SortType.java + ${CMAKE_CURRENT_BINARY_DIR}/Statistics.java + ${CMAKE_CURRENT_BINARY_DIR}/StatisticsBase.java + ${CMAKE_CURRENT_BINARY_DIR}/StringType.java + ${CMAKE_CURRENT_BINARY_DIR}/SygusGTerm.java + ${CMAKE_CURRENT_BINARY_DIR}/SygusPrintCallback.java + ${CMAKE_CURRENT_BINARY_DIR}/SymbolTable.java + ${CMAKE_CURRENT_BINARY_DIR}/SymbolType.java + ${CMAKE_CURRENT_BINARY_DIR}/TesterType.java + ${CMAKE_CURRENT_BINARY_DIR}/TheoryId.java + ${CMAKE_CURRENT_BINARY_DIR}/Timer.java + ${CMAKE_CURRENT_BINARY_DIR}/TupleUpdate.java + ${CMAKE_CURRENT_BINARY_DIR}/TupleUpdateHashFunction.java + ${CMAKE_CURRENT_BINARY_DIR}/Type.java + ${CMAKE_CURRENT_BINARY_DIR}/TypeCheckingException.java + ${CMAKE_CURRENT_BINARY_DIR}/TypeConstant.java + ${CMAKE_CURRENT_BINARY_DIR}/TypeConstantHashFunction.java + ${CMAKE_CURRENT_BINARY_DIR}/TypeHashFunction.java + ${CMAKE_CURRENT_BINARY_DIR}/UninterpretedConstant.java + ${CMAKE_CURRENT_BINARY_DIR}/UninterpretedConstantHashFunction.java + ${CMAKE_CURRENT_BINARY_DIR}/UnrecognizedOptionException.java + ${CMAKE_CURRENT_BINARY_DIR}/UnsafeInterruptException.java + ${CMAKE_CURRENT_BINARY_DIR}/UnsatCore.java + ${CMAKE_CURRENT_BINARY_DIR}/VariableTypeMap.java + ${CMAKE_CURRENT_BINARY_DIR}/hashmapExpr.java + ${CMAKE_CURRENT_BINARY_DIR}/pairStringType.java + ${CMAKE_CURRENT_BINARY_DIR}/setOfType.java + ${CMAKE_CURRENT_BINARY_DIR}/vectorCommandPtr.java + ${CMAKE_CURRENT_BINARY_DIR}/vectorDatatype.java + ${CMAKE_CURRENT_BINARY_DIR}/vectorDatatypeType.java + ${CMAKE_CURRENT_BINARY_DIR}/vectorExpr.java + ${CMAKE_CURRENT_BINARY_DIR}/vectorPairStringType.java + ${CMAKE_CURRENT_BINARY_DIR}/vectorSExpr.java + ${CMAKE_CURRENT_BINARY_DIR}/vectorString.java + ${CMAKE_CURRENT_BINARY_DIR}/vectorType.java + ${CMAKE_CURRENT_BINARY_DIR}/vectorUnsignedInt.java + ${CMAKE_CURRENT_BINARY_DIR}/vectorVectorExpr.java +) + +add_jar(cvc4jar SOURCES ${gen_java_files} OUTPUT_NAME CVC4) +add_dependencies(cvc4jar cvc4jni) diff --git a/src/bindings/python/CMakeLists.txt b/src/bindings/python/CMakeLists.txt new file mode 100644 index 000000000..d03924680 --- /dev/null +++ b/src/bindings/python/CMakeLists.txt @@ -0,0 +1,43 @@ +# Make sure that interpreter and libraries have a compatible version. +# Note: We use the Python interpreter to determine the install path for Python +# modules. If the interpreter and library have different versions, the module +# will be installed for the wrong Python version. Hence, we require the library +# version to match the Python interpreter's version. +find_package(PythonLibs + ${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR} REQUIRED) +include_directories(${PYTHON_INCLUDE_DIRS}) + +set(SWIG_MODULE_CVC4_EXTRA_DEPS cvc4 cvc4parser) +set_property(SOURCE ${CVC4_SWIG_INTERFACE} PROPERTY CPLUSPLUS ON) + +# Suppress -Wsuggest-override warnings for generated code +set_property( + SOURCE ${CMAKE_CURRENT_BINARY_DIR}/cvc4PYTHON_wrap.cxx + PROPERTY COMPILE_OPTIONS -Wno-suggest-override) + +# The generated module should have the name _CVC4.so, hence we use CVC4 as +# target name. +if(${CMAKE_VERSION} VERSION_LESS "3.8.0") + swig_add_module(CVC4 Python ${CVC4_SWIG_INTERFACE}) +else() + swig_add_library(CVC4 LANGUAGE Python SOURCES ${CVC4_SWIG_INTERFACE}) +endif() +swig_link_libraries(CVC4 cvc4 cvc4parser ${PYTHON_LIBRARIES}) + + +# Install Python bindings to the corresponding python-*/site-packages +# directory. Lookup Python module directory and store path in +# PYTHON_MODULE_PATH. +execute_process(COMMAND + ${PYTHON_EXECUTABLE} -c + "from distutils.sysconfig import get_python_lib;\ + print(get_python_lib(plat_specific=True,\ + prefix='${CMAKE_INSTALL_PREFIX}'))" + OUTPUT_VARIABLE PYTHON_MODULE_PATH + OUTPUT_STRIP_TRAILING_WHITESPACE) + +# Copy _CVC4.so and CVC4.py to PYTHON_MODULE_PATH +install(TARGETS ${SWIG_MODULE_CVC4_REAL_NAME} + DESTINATION ${PYTHON_MODULE_PATH}) +install(FILES ${CMAKE_CURRENT_BINARY_DIR}/CVC4.py + DESTINATION ${PYTHON_MODULE_PATH}) diff --git a/src/expr/CMakeLists.txt b/src/expr/CMakeLists.txt new file mode 100644 index 000000000..35ef34dfa --- /dev/null +++ b/src/expr/CMakeLists.txt @@ -0,0 +1,185 @@ +libcvc4_add_sources( + array.h + array_store_all.cpp + array_store_all.h + ascription_type.h + attribute.h + attribute.cpp + attribute_internals.h + attribute_unique_id.h + chain.h + emptyset.cpp + emptyset.h + expr_iomanip.cpp + expr_iomanip.h + expr_manager_scope.h + expr_stream.h + kind_map.h + matcher.h + node.cpp + node.h + node_algorithm.cpp + node_algorithm.h + node_builder.h + node_manager.cpp + node_manager.h + node_manager_attributes.h + node_manager_listeners.cpp + node_manager_listeners.h + node_self_iterator.h + node_value.cpp + node_value.h + pickle_data.cpp + pickle_data.h + pickler.cpp + pickler.h + symbol_table.cpp + symbol_table.h + type.cpp + type.h + type_checker.h + type_node.cpp + type_node.h + variable_type_map.h + datatype.h + datatype.cpp + record.cpp + record.h + uninterpreted_constant.cpp + uninterpreted_constant.h +) + +libcvc4_add_sources(GENERATED + kind.cpp + kind.h + metakind.cpp + metakind.h + expr.cpp + expr.h + expr_manager.cpp + expr_manager.h + type_checker.cpp + type_properties.h +) + +# +# Generate code for kinds. +# + +set(mkkind_script ${CMAKE_CURRENT_LIST_DIR}/mkkind) +set(mkmetakind_script ${CMAKE_CURRENT_LIST_DIR}/mkmetakind) +set(mkexpr_script ${CMAKE_CURRENT_LIST_DIR}/mkexpr) + +add_custom_command( + OUTPUT kind.h + COMMAND + ${mkkind_script} + ${CMAKE_CURRENT_LIST_DIR}/kind_template.h + ${KINDS_FILES} + > ${CMAKE_CURRENT_BINARY_DIR}/kind.h + DEPENDS mkkind kind_template.h ${KINDS_FILES} +) + +add_custom_command( + OUTPUT kind.cpp + COMMAND + ${mkkind_script} + ${CMAKE_CURRENT_LIST_DIR}/kind_template.cpp + ${KINDS_FILES} + > ${CMAKE_CURRENT_BINARY_DIR}/kind.cpp + DEPENDS mkkind kind_template.cpp kind.h ${KINDS_FILES} +) + +add_custom_command( + OUTPUT type_properties.h + COMMAND + ${mkkind_script} + ${CMAKE_CURRENT_LIST_DIR}/type_properties_template.h + ${KINDS_FILES} + > ${CMAKE_CURRENT_BINARY_DIR}/type_properties.h + DEPENDS mkkind type_properties_template.h ${KINDS_FILES} +) + +add_custom_command( + OUTPUT metakind.h + COMMAND + ${mkmetakind_script} + ${CMAKE_CURRENT_LIST_DIR}/metakind_template.h + ${KINDS_FILES} + > ${CMAKE_CURRENT_BINARY_DIR}/metakind.h + DEPENDS mkmetakind metakind_template.h ${KINDS_FILES} +) + +add_custom_command( + OUTPUT metakind.cpp + COMMAND + ${mkmetakind_script} + ${CMAKE_CURRENT_LIST_DIR}/metakind_template.cpp + ${KINDS_FILES} + > ${CMAKE_CURRENT_BINARY_DIR}/metakind.cpp + DEPENDS mkmetakind metakind_template.cpp metakind.h ${KINDS_FILES} +) + +add_custom_command( + OUTPUT expr.h + COMMAND + ${mkexpr_script} + ${CMAKE_CURRENT_LIST_DIR}/expr_template.h + ${KINDS_FILES} + > ${CMAKE_CURRENT_BINARY_DIR}/expr.h + DEPENDS mkexpr expr_template.h kind.h ${KINDS_FILES} +) + +add_custom_command( + OUTPUT expr.cpp + COMMAND + ${mkexpr_script} + ${CMAKE_CURRENT_LIST_DIR}/expr_template.cpp + ${KINDS_FILES} + > ${CMAKE_CURRENT_BINARY_DIR}/expr.cpp + DEPENDS mkexpr expr_template.cpp expr.h ${KINDS_FILES} +) + +add_custom_command( + OUTPUT expr_manager.h + COMMAND + ${mkexpr_script} + ${CMAKE_CURRENT_LIST_DIR}/expr_manager_template.h + ${KINDS_FILES} + > ${CMAKE_CURRENT_BINARY_DIR}/expr_manager.h + DEPENDS mkexpr expr_manager_template.h expr.h ${KINDS_FILES} +) + +add_custom_command( + OUTPUT expr_manager.cpp + COMMAND + ${mkexpr_script} + ${CMAKE_CURRENT_LIST_DIR}/expr_manager_template.cpp + ${KINDS_FILES} + > ${CMAKE_CURRENT_BINARY_DIR}/expr_manager.cpp + DEPENDS mkexpr expr_manager_template.cpp expr_manager.h ${KINDS_FILES} +) + +add_custom_command( + OUTPUT type_checker.cpp + COMMAND + ${mkexpr_script} + ${CMAKE_CURRENT_LIST_DIR}/type_checker_template.cpp + ${KINDS_FILES} + > ${CMAKE_CURRENT_BINARY_DIR}/type_checker.cpp + DEPENDS mkexpr type_checker_template.cpp ${KINDS_FILES} +) + +add_custom_target(gen-expr + DEPENDS + kind.cpp + kind.h + metakind.cpp + metakind.h + expr.cpp + expr.h + expr_manager.cpp + expr_manager.h + type_checker.cpp + type_properties.h +) diff --git a/src/expr/expr_template.h b/src/expr/expr_template.h index 7cecdebbd..324915b1d 100644 --- a/src/expr/expr_template.h +++ b/src/expr/expr_template.h @@ -60,6 +60,10 @@ class Type; class TypeCheckingException; class TypeCheckingExceptionPrivate; +namespace api { +class Solver; +} + namespace expr { namespace pickle { class Pickler; @@ -208,6 +212,16 @@ struct ExprHashFunction { * expressions. */ class CVC4_PUBLIC Expr { + friend class ExprManager; + friend class NodeManager; + friend class SmtEngine; + friend class TypeCheckingException; + friend class api::Solver; + friend class expr::ExportPrivate; + friend class expr::pickle::Pickler; + friend class prop::TheoryProxy; + friend class smt::SmtEnginePrivate; + friend std::ostream& CVC4::operator<<(std::ostream& out, const Expr& e); /** The internal expression representation */ NodeTemplate<true>* d_node; @@ -542,7 +556,7 @@ public: * only be used once. For more details see the 4/27/2010 CVC4 * developer's meeting notes at: * - * http://goedel.cims.nyu.edu/wiki/Meeting_Minutes_-_April_27,_2010#isAtomic.28.29_and_isAtomicFormula.28.29 + * http://cvc4.cs.stanford.edu/wiki/Meeting_Minutes_-_April_27,_2010#isAtomic.28.29_and_isAtomicFormula.28.29 */ // bool containsDecision(); // is "atomic" // bool properlyContainsDecision(); // maybe not atomic but all children are @@ -592,17 +606,6 @@ private: * @return the internal node */ NodeTemplate<false> getTNode() const; - - // Friend to access the actual internal expr information and private methods - friend class SmtEngine; - friend class smt::SmtEnginePrivate; - friend class ExprManager; - friend class NodeManager; - friend class TypeCheckingException; - friend class expr::pickle::Pickler; - friend class prop::TheoryProxy; - friend class expr::ExportPrivate; - friend std::ostream& CVC4::operator<<(std::ostream& out, const Expr& e); template <bool ref_count> friend class NodeTemplate; };/* class Expr */ diff --git a/src/expr/node.h b/src/expr/node.h index 4b12c7ece..750a5547b 100644 --- a/src/expr/node.h +++ b/src/expr/node.h @@ -139,7 +139,7 @@ typedef NodeTemplate<true> Node; * * More guidelines on when to use TNodes is available in the CVC4 * Developer's Guide: - * http://goedel.cims.nyu.edu/wiki/Developer%27s_Guide#Dealing_with_expressions_.28Nodes_and_TNodes.29 + * http://cvc4.cs.stanford.edu/wiki/Developer%27s_Guide#Dealing_with_expressions_.28Nodes_and_TNodes.29 */ typedef NodeTemplate<false> TNode; @@ -423,7 +423,7 @@ public: * only be used once. For more details see the 4/27/2010 CVC4 * developer's meeting notes at: * - * http://goedel.cims.nyu.edu/wiki/Meeting_Minutes_-_April_27,_2010#isAtomic.28.29_and_isAtomicFormula.28.29 + * http://cvc4.cs.stanford.edu/wiki/Meeting_Minutes_-_April_27,_2010#isAtomic.28.29_and_isAtomicFormula.28.29 */ // bool containsDecision(); // is "atomic" // bool properlyContainsDecision(); // maybe not atomic but all children are diff --git a/src/expr/node_manager.h b/src/expr/node_manager.h index 61aaa8721..7cafb6e11 100644 --- a/src/expr/node_manager.h +++ b/src/expr/node_manager.h @@ -342,7 +342,7 @@ class NodeManager { * only be used once. For more details see the 4/27/2010 CVC4 * developer's meeting notes at: * - * http://goedel.cims.nyu.edu/wiki/Meeting_Minutes_-_April_27,_2010#isAtomic.28.29_and_isAtomicFormula.28.29 + * http://cvc4.cs.stanford.edu/wiki/Meeting_Minutes_-_April_27,_2010#isAtomic.28.29_and_isAtomicFormula.28.29 */ // bool containsDecision(TNode); // is "atomic" // bool properlyContainsDecision(TNode); // all children are atomic diff --git a/src/main/CMakeLists.txt b/src/main/CMakeLists.txt new file mode 100644 index 000000000..dba12006e --- /dev/null +++ b/src/main/CMakeLists.txt @@ -0,0 +1,130 @@ +#-----------------------------------------------------------------------------# +# libmain source files + +set(libmain_src_files + command_executor.cpp + driver_unified.cpp + interactive_shell.cpp + interactive_shell.h + main.h + util.cpp +) + +#-----------------------------------------------------------------------------# +# Build object library since we will use the object files for cvc4-bin, +# pcvc4-bin, and main-test library. + +add_library(main OBJECT ${libmain_src_files}) +target_compile_definitions(main PRIVATE -D__BUILDING_CVC4DRIVER) +if(ENABLE_SHARED) + set_target_properties(main PROPERTIES POSITION_INDEPENDENT_CODE ON) +endif() + +# We can't use target_link_libraries(...) here since this is only supported for +# cmake version >= 3.12. Hence, we have to manually add the library +# dependencies for main. As a consequence, include directories from +# dependencies are not propagated and we need to manually add the include +# directories of libcvc4 to main. +add_dependencies(main cvc4 cvc4parser gen-tokens) +get_target_property(LIBCVC4_INCLUDES cvc4 INCLUDE_DIRECTORIES) +target_include_directories(main PRIVATE ${LIBCVC4_INCLUDES}) + +# main-test library is only used for linking against system and unit tests so +# that we don't have to include all object files of main into each unit/system +# test. Do not link against main-test in any other case. +add_library(main-test $<TARGET_OBJECTS:main>) +target_link_libraries(main-test cvc4 cvc4parser) + +#-----------------------------------------------------------------------------# +# cvc4 binary configuration + +add_executable(cvc4-bin main.cpp $<TARGET_OBJECTS:main>) +target_compile_definitions(cvc4-bin PRIVATE -D__BUILDING_CVC4DRIVER) +set_target_properties(cvc4-bin + PROPERTIES + OUTPUT_NAME cvc4 + RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin) +target_link_libraries(cvc4-bin cvc4 cvc4parser) +if(PROGRAM_PREFIX) + install(PROGRAMS + $<TARGET_FILE:cvc4-bin> DESTINATION bin RENAME ${PROGRAM_PREFIX}cvc4) +else() + install(TARGETS cvc4-bin DESTINATION bin) +endif() + +# In order to get a fully static executable we have to make sure that we also +# use the static system libraries. +# https://cmake.org/cmake/help/v3.0/prop_tgt/LINK_SEARCH_START_STATIC.html +# https://cmake.org/cmake/help/v3.0/prop_tgt/LINK_SEARCH_END_STATIC.html +if(NOT ENABLE_SHARED) + set_target_properties(cvc4-bin PROPERTIES LINK_FLAGS -static) + set_target_properties(cvc4-bin PROPERTIES LINK_SEARCH_START_STATIC ON) + set_target_properties(cvc4-bin PROPERTIES LINK_SEARCH_END_STATIC ON) +endif() + +if(ENABLE_PORTFOLIO) + set(pcvc4_src_files + main.cpp + portfolio.cpp + portfolio.h + portfolio_util.cpp + portfolio_util.h + command_executor_portfolio.cpp + command_executor_portfolio.h + ) + + add_executable(pcvc4-bin ${pcvc4_src_files} $<TARGET_OBJECTS:main>) + target_compile_definitions(pcvc4-bin PRIVATE -D__BUILDING_CVC4DRIVER) + set_target_properties(pcvc4-bin + PROPERTIES + OUTPUT_NAME pcvc4 + RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin) + target_link_libraries(pcvc4-bin cvc4 cvc4parser ${Boost_LIBRARIES}) + target_include_directories(pcvc4-bin PRIVATE ${Boost_INCLUDE_DIRS}) + if(PROGRAM_PREFIX) + install(PROGRAMS + $<TARGET_FILE:pcvc4-bin> DESTINATION bin RENAME ${PROGRAM_PREFIX}pcvc4) + else() + install(TARGETS pcvc4-bin DESTINATION bin) + endif() + + if(NOT ENABLE_SHARED) + set_target_properties(pcvc4-bin PROPERTIES LINK_FLAGS -static) + set_target_properties(pcvc4-bin PROPERTIES LINK_SEARCH_START_STATIC ON) + set_target_properties(pcvc4-bin PROPERTIES LINK_SEARCH_END_STATIC ON) + endif() +endif() + +if(USE_READLINE) + target_link_libraries(cvc4-bin ${Readline_LIBRARIES}) + target_link_libraries(main-test ${Readline_LIBRARIES}) + target_include_directories(main PRIVATE ${Readline_INCLUDE_DIR}) + if(ENABLE_PORTFOLIO) + target_link_libraries(pcvc4-bin ${Readline_LIBRARIES}) + endif() +endif() + +#-----------------------------------------------------------------------------# +# Generate language tokens header files. + +foreach(lang Cvc Smt1 Smt2 Tptp) + string(TOLOWER ${lang} lang_lc) + add_custom_command( + OUTPUT ${lang_lc}_tokens.h + COMMAND + sh ${CMAKE_CURRENT_LIST_DIR}/gen-token-header.sh + ${CMAKE_CURRENT_LIST_DIR}/../parser/${lang_lc}/${lang}.g + ${CMAKE_CURRENT_BINARY_DIR}/${lang_lc}_tokens.h + DEPENDS ../parser/${lang_lc}/${lang}.g + ) +endforeach() + +# Create target used as a dependency for libmain. +add_custom_target(gen-tokens + DEPENDS + cvc_tokens.h + smt1_tokens.h + smt2_tokens.h + tptp_tokens.h +) + diff --git a/src/main/gen-token-header.sh b/src/main/gen-token-header.sh new file mode 100644 index 000000000..86e30ae42 --- /dev/null +++ b/src/main/gen-token-header.sh @@ -0,0 +1,5 @@ +#!/bin/sh + +grep "'[a-zA-Z][a-zA-Z0-9_-][a-zA-Z0-9_-]*'" "$1" | \ + sed 's/.*'\''\([a-zA-Z0-9_-]*\)'\''.*/"\1",/' | \ + sort -u > "$2" diff --git a/src/options/CMakeLists.txt b/src/options/CMakeLists.txt new file mode 100644 index 000000000..457fd23cd --- /dev/null +++ b/src/options/CMakeLists.txt @@ -0,0 +1,105 @@ +libcvc4_add_sources( + argument_extender.h + argument_extender_implementation.cpp + argument_extender_implementation.h + arith_heuristic_pivot_rule.cpp + arith_heuristic_pivot_rule.h + arith_propagation_mode.cpp + arith_propagation_mode.h + arith_unate_lemma_mode.cpp + arith_unate_lemma_mode.h + base_handlers.h + bv_bitblast_mode.cpp + bv_bitblast_mode.h + datatypes_modes.h + decision_mode.cpp + decision_mode.h + decision_weight.h + didyoumean.cpp + didyoumean.h + language.cpp + language.h + open_ostream.cpp + open_ostream.h + option_exception.h + options.h + options_handler.cpp + options_handler.h + options_public_functions.cpp + printer_modes.cpp + printer_modes.h + quantifiers_modes.cpp + quantifiers_modes.h + set_language.cpp + set_language.h + simplification_mode.cpp + simplification_mode.h + sygus_out_mode.h + theoryof_mode.cpp + theoryof_mode.h + ufss_mode.h +) + +set(options_toml_files + arith_options.toml + arrays_options.toml + base_options.toml + booleans_options.toml + builtin_options.toml + bv_options.toml + datatypes_options.toml + decision_options.toml + expr_options.toml + fp_options.toml + idl_options.toml + main_options.toml + parser_options.toml + printer_options.toml + proof_options.toml + prop_options.toml + quantifiers_options.toml + sep_options.toml + sets_options.toml + smt_options.toml + strings_options.toml + theory_options.toml + uf_options.toml +) + +string(REPLACE "toml" "cpp;" options_gen_cpp_files ${options_toml_files}) +string(REPLACE "toml" "h;" options_gen_h_files ${options_toml_files}) + +libcvc4_add_sources(GENERATED options.cpp ${options_gen_cpp_files}) + +list_prepend(options_toml_files "${CMAKE_CURRENT_LIST_DIR}/" abs_toml_files) + +add_custom_command( + OUTPUT + options.cpp options_holder.h + ${options_gen_cpp_files} ${options_gen_h_files} + COMMAND + ${PYTHON_EXECUTABLE} + ${CMAKE_CURRENT_LIST_DIR}/mkoptions.py + ${CMAKE_CURRENT_LIST_DIR} + ${CMAKE_CURRENT_BINARY_DIR}/../../doc + ${CMAKE_CURRENT_BINARY_DIR} + ${abs_toml_files} + DEPENDS + mkoptions.py + ${options_toml_files} + module_template.h + module_template.cpp + options_holder_template.h + options_template.cpp + ${CMAKE_CURRENT_BINARY_DIR}/../../doc/cvc4.1_template + ${CMAKE_CURRENT_BINARY_DIR}/../../doc/SmtEngine.3cvc_template + ${CMAKE_CURRENT_BINARY_DIR}/../../doc/options.3cvc_template +) + +add_custom_target(gen-options + DEPENDS + options.cpp + options_holder.h + ${options_gen_cpp_files} + ${options_gen_h_files} +) diff --git a/src/options/mkoptions.py b/src/options/mkoptions.py index f3a045e02..8f801466c 100755 --- a/src/options/mkoptions.py +++ b/src/options/mkoptions.py @@ -303,10 +303,8 @@ def write_file(directory, name, content): if os.path.isfile(fname): with open(fname, 'r') as file: if content == file.read(): - print('{} is up-to-date'.format(name)) return with open(fname, 'w') as file: - print('generated {}'.format(name)) file.write(content) except IOError: die("Could not write '{}'".format(fname)) diff --git a/src/parser/CMakeLists.txt b/src/parser/CMakeLists.txt new file mode 100644 index 000000000..d7491f8ca --- /dev/null +++ b/src/parser/CMakeLists.txt @@ -0,0 +1,111 @@ +set(ANTLR_HOME ${ANTLR_DIR}) +find_package(ANTLR REQUIRED) + +if(NOT HAVE_ANTLR3_FILE_STREAM_NEW) + add_definitions(-DCVC4_ANTLR3_OLD_INPUT_STREAM) +endif() + +# Java runtime is required for ANTLR +find_package(Java COMPONENTS Runtime REQUIRED) + +#-----------------------------------------------------------------------------# +# libcvc4parser source files + +set(libcvc4parser_src_files + antlr_input.cpp + antlr_input.h + antlr_input_imports.cpp + antlr_line_buffered_input.cpp + antlr_line_buffered_input.h + antlr_tracing.h + antlr_undefines.h + bounded_token_buffer.cpp + bounded_token_buffer.h + bounded_token_factory.cpp + bounded_token_factory.h + cvc/cvc_input.cpp + cvc/cvc_input.h + input.cpp + input.h + line_buffer.cpp + line_buffer.h + memory_mapped_input_buffer.cpp + memory_mapped_input_buffer.h + parser.cpp + parser.h + parser_builder.cpp + parser_builder.h + parser_exception.h + smt1/smt1.cpp + smt1/smt1.h + smt1/smt1_input.cpp + smt1/smt1_input.h + smt2/smt2.cpp + smt2/smt2.h + smt2/smt2_input.cpp + smt2/smt2_input.h + smt2/sygus_input.cpp + smt2/sygus_input.h + tptp/TptpLexer.c + tptp/TptpParser.c + tptp/tptp.cpp + tptp/tptp.h + tptp/tptp_input.cpp + tptp/tptp_input.h +) + +#-----------------------------------------------------------------------------# +# Generate parsers for all supported languages + +foreach(lang Cvc Smt1 Smt2 Tptp) + string(TOLOWER ${lang} lang_dir) + file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${lang_dir}) + add_custom_command( + OUTPUT + ${CMAKE_CURRENT_BINARY_DIR}/${lang_dir}/${lang}Lexer.c + ${CMAKE_CURRENT_BINARY_DIR}/${lang_dir}/${lang}Lexer.h + ${CMAKE_CURRENT_BINARY_DIR}/${lang_dir}/${lang}Parser.c + ${CMAKE_CURRENT_BINARY_DIR}/${lang_dir}/${lang}Parser.h + ${CMAKE_CURRENT_BINARY_DIR}/${lang_dir}/${lang}.tokens + COMMAND + ${ANTLR_BINARY} + ${CMAKE_CURRENT_SOURCE_DIR}/${lang_dir}/${lang}.g + -fo ${CMAKE_CURRENT_BINARY_DIR}/${lang_dir} + DEPENDS + ${lang_dir}/${lang}.g + ) + set(gen_src_files + ${CMAKE_CURRENT_BINARY_DIR}/${lang_dir}/${lang}Lexer.c + ${CMAKE_CURRENT_BINARY_DIR}/${lang_dir}/${lang}Parser.c) + + # Tell cmake that generated source files are actually c++ files + set_source_files_properties(${gen_src_files} PROPERTIES LANGUAGE CXX) + set_source_files_properties(${gen_src_files} PROPERTIES GENERATED TRUE) + + # We don't want to enable -Wall for code generated by ANTLR. + set_source_files_properties( + ${gen_src_files} PROPERTIES COMPILE_FLAGS -Wno-all) + + # Add generated source files to the parser source files + list(APPEND libcvc4parser_src_files ${gen_src_files}) +endforeach() + +#-----------------------------------------------------------------------------# +# libcvc4parser configuration + +add_library(cvc4parser ${libcvc4parser_src_files}) +set_target_properties(cvc4parser PROPERTIES SOVERSION ${CVC4_SOVERSION}) +target_compile_definitions(cvc4parser PRIVATE -D__BUILDING_CVC4PARSERLIB) +target_link_libraries(cvc4parser cvc4 ${ANTLR_LIBRARIES}) +target_include_directories(cvc4parser PRIVATE ${ANTLR_INCLUDE_DIR}) +install(TARGETS cvc4parser DESTINATION lib) + +# The generated lexer/parser files define some functions as +# __declspec(dllexport) via the ANTLR3_API macro, which leads to lots of +# unresolved symbols when linking against libcvc4parser. +# -Wl,--export-all-symbols makes sure that all symbols are exported when +# building a DLL. +if(CVC4_WINDOWS_BUILD) + set_target_properties(cvc4parser + PROPERTIES LINK_FLAGS "-Wl,--export-all-symbols") +endif() diff --git a/src/theory/CMakeLists.txt b/src/theory/CMakeLists.txt new file mode 100644 index 000000000..4c2f66a0e --- /dev/null +++ b/src/theory/CMakeLists.txt @@ -0,0 +1,45 @@ +libcvc4_add_sources(GENERATED + rewriter_tables.h + theory_traits.h + type_enumerator.cpp +) + +set(mktheorytraits_script ${CMAKE_CURRENT_LIST_DIR}/mktheorytraits) +set(mkrewriter_script ${CMAKE_CURRENT_LIST_DIR}/mkrewriter) + +add_custom_command( + OUTPUT rewriter_tables.h + COMMAND + ${mkrewriter_script} + ${CMAKE_CURRENT_LIST_DIR}/rewriter_tables_template.h + ${KINDS_FILES} + > ${CMAKE_CURRENT_BINARY_DIR}/rewriter_tables.h + DEPENDS mkrewriter rewriter_tables_template.h ${KINDS_FILES} +) + +add_custom_command( + OUTPUT theory_traits.h + COMMAND + ${mktheorytraits_script} + ${CMAKE_CURRENT_LIST_DIR}/theory_traits_template.h + ${KINDS_FILES} + > ${CMAKE_CURRENT_BINARY_DIR}/theory_traits.h + DEPENDS mktheorytraits theory_traits_template.h ${KINDS_FILES} +) + +add_custom_command( + OUTPUT type_enumerator.cpp + COMMAND + ${mktheorytraits_script} + ${CMAKE_CURRENT_LIST_DIR}/type_enumerator_template.cpp + ${KINDS_FILES} + > ${CMAKE_CURRENT_BINARY_DIR}/type_enumerator.cpp + DEPENDS mktheorytraits type_enumerator_template.cpp ${KINDS_FILES} +) + +add_custom_target(gen-theory + DEPENDS + type_enumerator.cpp + theory_traits.h + rewriter_tables.h +) diff --git a/src/theory/arith/nonlinear_extension.cpp b/src/theory/arith/nonlinear_extension.cpp index 9f6608dc5..4cd7896d3 100644 --- a/src/theory/arith/nonlinear_extension.cpp +++ b/src/theory/arith/nonlinear_extension.cpp @@ -888,17 +888,25 @@ bool NonlinearExtension::checkModel(const std::vector<Node>& assertions, Kind k = tfs.first; for (const Node& tf : tfs.second) { + bool success = true; // tf is Figure 3 : tf( x ) Node atf = computeModelValue(tf, 0); if (k == PI) { - addCheckModelBound(atf, d_pi_bound[0], d_pi_bound[1]); + success = addCheckModelBound(atf, d_pi_bound[0], d_pi_bound[1]); } else if (isRefineableTfFun(tf)) { d_used_approx = true; std::pair<Node, Node> bounds = getTfModelBounds(tf, d_taylor_degree); - addCheckModelBound(atf, bounds.first, bounds.second); + success = addCheckModelBound(atf, bounds.first, bounds.second); + } + if (!success) + { + Trace("nl-ext-cm-debug") + << "...failed to set bound for transcendental function." + << std::endl; + return false; } if (Trace.isOn("nl-ext-cm")) { @@ -962,7 +970,8 @@ bool NonlinearExtension::checkModel(const std::vector<Node>& assertions, << "check-model-bound : exact : " << cur << " = "; printRationalApprox("nl-ext-cm", curv); Trace("nl-ext-cm") << std::endl; - addCheckModelSubstitution(cur, curv); + bool ret = addCheckModelSubstitution(cur, curv); + AlwaysAssert(ret); } } } @@ -1036,15 +1045,31 @@ bool NonlinearExtension::checkModel(const std::vector<Node>& assertions, return true; } -void NonlinearExtension::addCheckModelSubstitution(TNode v, TNode s) +bool NonlinearExtension::addCheckModelSubstitution(TNode v, TNode s) { // should not substitute the same variable twice Trace("nl-ext-model") << "* check model substitution : " << v << " -> " << s << std::endl; // should not set exact bound more than once if(std::find(d_check_model_vars.begin(),d_check_model_vars.end(),v)!=d_check_model_vars.end()) { + Trace("nl-ext-model") << "...ERROR: already has value." << std::endl; + // this should never happen since substitutions should be applied eagerly Assert( false ); - return; + return false; + } + // if we previously had an approximate bound, the exact bound should be in its + // range + std::map<Node, std::pair<Node, Node> >::iterator itb = + d_check_model_bounds.find(v); + if (itb != d_check_model_bounds.end()) + { + if (s.getConst<Rational>() >= itb->second.first.getConst<Rational>() + || s.getConst<Rational>() <= itb->second.second.getConst<Rational>()) + { + Trace("nl-ext-model") + << "...ERROR: already has bound which is out of range." << std::endl; + return false; + } } for (unsigned i = 0, size = d_check_model_subs.size(); i < size; i++) { @@ -1058,23 +1083,32 @@ void NonlinearExtension::addCheckModelSubstitution(TNode v, TNode s) } d_check_model_vars.push_back(v); d_check_model_subs.push_back(s); + return true; } -void NonlinearExtension::addCheckModelBound(TNode v, TNode l, TNode u) +bool NonlinearExtension::addCheckModelBound(TNode v, TNode l, TNode u) { Trace("nl-ext-model") << "* check model bound : " << v << " -> [" << l << " " << u << "]" << std::endl; if( l==u ) { // bound is exact, can add as substitution - addCheckModelSubstitution(v,l); - return; + return addCheckModelSubstitution(v, l); } // should not set a bound for a value that is exact - Assert(std::find(d_check_model_vars.begin(),d_check_model_vars.end(),v)==d_check_model_vars.end()); + if (std::find(d_check_model_vars.begin(), d_check_model_vars.end(), v) + != d_check_model_vars.end()) + { + Trace("nl-ext-model") + << "...ERROR: setting bound for variable that already has exact value." + << std::endl; + Assert(false); + return false; + } Assert(l.isConst()); Assert(u.isConst()); Assert(l.getConst<Rational>() <= u.getConst<Rational>()); d_check_model_bounds[v] = std::pair<Node, Node>(l, u); + return true; } bool NonlinearExtension::hasCheckModelAssignment(Node v) const @@ -1203,11 +1237,14 @@ bool NonlinearExtension::solveEqualitySimple(Node eq) { Trace("nl-ext-cm") << "check-model-subs : " << uv << " -> " << slv << std::endl; - addCheckModelSubstitution(uv, slv); - Trace("nl-ext-cms") << "...success, model substitution " << uv - << " -> " << slv << std::endl; - d_check_model_solved[eq] = uv; - return true; + bool ret = addCheckModelSubstitution(uv, slv); + if (ret) + { + Trace("nl-ext-cms") << "...success, model substitution " << uv + << " -> " << slv << std::endl; + d_check_model_solved[eq] = uv; + } + return ret; } } } @@ -1223,9 +1260,9 @@ bool NonlinearExtension::solveEqualitySimple(Node eq) Trace("nl-ext-cm") << "check-model-bound : exact : " << uvf << " = "; printRationalApprox("nl-ext-cm", uvfv); Trace("nl-ext-cm") << std::endl; - addCheckModelSubstitution(uvf, uvfv); + bool ret = addCheckModelSubstitution(uvf, uvfv); // recurse - return solveEqualitySimple(eq); + return ret ? solveEqualitySimple(eq) : false; } } Trace("nl-ext-cms") << "...fail due to constrained invalid terms." @@ -1252,10 +1289,13 @@ bool NonlinearExtension::solveEqualitySimple(Node eq) Trace("nl-ext-cm") << "check-model-bound : exact : " << var << " = "; printRationalApprox("nl-ext-cm", val); Trace("nl-ext-cm") << std::endl; - addCheckModelSubstitution(var, val); - Trace("nl-ext-cms") << "...success, solved linear." << std::endl; - d_check_model_solved[eq] = var; - return true; + bool ret = addCheckModelSubstitution(var, val); + if (ret) + { + Trace("nl-ext-cms") << "...success, solved linear." << std::endl; + d_check_model_solved[eq] = var; + } + return ret; } Trace("nl-ext-quad") << "Solve quadratic : " << seq << std::endl; Trace("nl-ext-quad") << " a : " << a << std::endl; @@ -1352,10 +1392,14 @@ bool NonlinearExtension::solveEqualitySimple(Node eq) Trace("nl-ext-cm") << " <= " << var << " <= "; printRationalApprox("nl-ext-cm", bounds[r_use_index][1]); Trace("nl-ext-cm") << std::endl; - addCheckModelBound(var, bounds[r_use_index][0], bounds[r_use_index][1]); - d_check_model_solved[eq] = var; - Trace("nl-ext-cms") << "...success, solved quadratic." << std::endl; - return true; + bool ret = + addCheckModelBound(var, bounds[r_use_index][0], bounds[r_use_index][1]); + if (ret) + { + d_check_model_solved[eq] = var; + Trace("nl-ext-cms") << "...success, solved quadratic." << std::endl; + } + return ret; } bool NonlinearExtension::simpleCheckModelLit(Node lit) @@ -3622,7 +3666,7 @@ std::vector<Node> NonlinearExtension::checkFactoring( sum = Rewriter::rewrite( sum ); Trace("nl-ext-factor") << "* Factored sum for " << x << " : " << sum << std::endl; - Node kf = getFactorSkolem( sum, lemmas ); + Node kf = getFactorSkolem(sum, lemmas); std::vector< Node > poly; poly.push_back(NodeManager::currentNM()->mkNode(MULT, x, kf)); std::map<Node, std::vector<Node> >::iterator itfo = @@ -3672,7 +3716,7 @@ Node NonlinearExtension::getFactorSkolem( Node n, std::vector< Node >& lemmas ) return itf->second; } } - + std::vector<Node> NonlinearExtension::checkMonomialInferResBounds() { std::vector< Node > lemmas; Trace("nl-ext") << "Get monomial resolution inferred bound lemmas..." << std::endl; diff --git a/src/theory/arith/nonlinear_extension.h b/src/theory/arith/nonlinear_extension.h index c0af312b3..f2cdea334 100644 --- a/src/theory/arith/nonlinear_extension.h +++ b/src/theory/arith/nonlinear_extension.h @@ -317,8 +317,10 @@ class NonlinearExtension { * Adds the model substitution v -> s. This applies the substitution * { v -> s } to each term in d_check_model_subs and adds v,s to * d_check_model_vars and d_check_model_subs respectively. + * If this method returns false, then the substitution v -> s is inconsistent + * with the current substitution and bounds. */ - void addCheckModelSubstitution(TNode v, TNode s); + bool addCheckModelSubstitution(TNode v, TNode s); /** lower and upper bounds for check model * * For each term t in the domain of this map, if this stores the pair @@ -335,9 +337,11 @@ class NonlinearExtension { /** add check model bound * * Adds the bound x -> < l, u > to the map above, and records the - * approximation ( x, l <= x <= u ) in the model. + * approximation ( x, l <= x <= u ) in the model. This method returns false + * if the bound is inconsistent with the current model substitution or + * bounds. */ - void addCheckModelBound(TNode v, TNode l, TNode u); + bool addCheckModelBound(TNode v, TNode l, TNode u); /** * The map from literals that our model construction solved, to the variable * that was solved for. Examples of such literals are: @@ -586,7 +590,7 @@ class NonlinearExtension { // factor skolems std::map< Node, Node > d_factor_skolem; Node getFactorSkolem( Node n, std::vector< Node >& lemmas ); - + // tangent plane bounds std::map< Node, std::map< Node, Node > > d_tangent_val_bound[4]; diff --git a/src/theory/datatypes/datatypes_rewriter.h b/src/theory/datatypes/datatypes_rewriter.h index a6c95b893..05f1a9960 100644 --- a/src/theory/datatypes/datatypes_rewriter.h +++ b/src/theory/datatypes/datatypes_rewriter.h @@ -39,6 +39,17 @@ struct SygusAnyConstAttributeId }; typedef expr::Attribute<SygusAnyConstAttributeId, bool> SygusAnyConstAttribute; +/** + * Attribute true for enumerators whose current model values have been excluded + * by sygus symmetry breaking. This is set by the datatypes sygus solver during + * LAST_CALL effort checks for each active sygus enumerator. + */ +struct SygusSymBreakExcAttributeId +{ +}; +typedef expr::Attribute<SygusSymBreakExcAttributeId, bool> + SygusSymBreakExcAttribute; + namespace datatypes { class DatatypesRewriter { diff --git a/src/theory/datatypes/datatypes_sygus.cpp b/src/theory/datatypes/datatypes_sygus.cpp index db1ce1c05..1d1d2c2be 100644 --- a/src/theory/datatypes/datatypes_sygus.cpp +++ b/src/theory/datatypes/datatypes_sygus.cpp @@ -1223,8 +1223,8 @@ void SygusSymBreakNew::incrementCurrentSearchSize( Node m, std::vector< Node >& for (const TNode& t : itt->second) { if (!options::sygusSymBreakLazy() - || d_active_terms.find(t) != d_active_terms.end() - && !it->second.empty()) + || (d_active_terms.find(t) != d_active_terms.end() + && !it->second.empty())) { Node rlv = getRelevancyCondition(t); std::unordered_map<TNode, TNode, TNodeHashFunction> cache; @@ -1317,6 +1317,8 @@ void SygusSymBreakNew::check( std::vector< Node >& lemmas ) { // register the search value ( prog -> progv ), this may invoke symmetry breaking if( options::sygusSymBreakDynamic() ){ Node rsv = registerSearchValue(prog, prog, progv, 0, lemmas); + SygusSymBreakExcAttribute ssbea; + prog.setAttribute(ssbea, rsv.isNull()); if (rsv.isNull()) { Trace("sygus-sb") << " SygusSymBreakNew::check: ...added new symmetry breaking lemma for " << prog << "." << std::endl; @@ -1474,6 +1476,8 @@ Node SygusSymBreakNew::SygusSizeDecisionStrategy::mkLiteral(unsigned s) } Assert(!d_this.isNull()); NodeManager* nm = NodeManager::currentNM(); + Trace("cegqi-engine") << "******* Sygus : allocate size literal " << s + << " for " << d_this << std::endl; return nm->mkNode(DT_SYGUS_BOUND, d_this, nm->mkConst(Rational(s))); } diff --git a/src/theory/quantifiers/extended_rewrite.cpp b/src/theory/quantifiers/extended_rewrite.cpp index df82e0750..ab292e7bb 100644 --- a/src/theory/quantifiers/extended_rewrite.cpp +++ b/src/theory/quantifiers/extended_rewrite.cpp @@ -787,8 +787,8 @@ Node ExtendedRewriter::extendedRewriteBcp( // also, treat it as clause if possible if (cln.getNumChildren() > 0 - & (bcp_kinds.empty() - || bcp_kinds.find(cln.getKind()) != bcp_kinds.end())) + && (bcp_kinds.empty() + || bcp_kinds.find(cln.getKind()) != bcp_kinds.end())) { if (std::find(clauses.begin(), clauses.end(), cn) == clauses.end() && prop_clauses.find(cn) == prop_clauses.end()) @@ -1671,208 +1671,6 @@ Node ExtendedRewriter::extendedRewriteStrings(Node ret) Node new_ret; Trace("q-ext-rewrite-debug") << "Extended rewrite strings : " << ret << std::endl; - NodeManager* nm = NodeManager::currentNM(); - if (ret.getKind() == EQUAL) - { - if (ret[0].getType().isString()) - { - std::vector<Node> c[2]; - for (unsigned i = 0; i < 2; i++) - { - strings::TheoryStringsRewriter::getConcat(ret[i], c[i]); - } - - // ------- equality unification - bool changed = false; - for (unsigned i = 0; i < 2; i++) - { - while (!c[0].empty() && !c[1].empty() && c[0].back() == c[1].back()) - { - c[0].pop_back(); - c[1].pop_back(); - changed = true; - } - // splice constants - if (!c[0].empty() && !c[1].empty() && c[0].back().isConst() - && c[1].back().isConst()) - { - String cs[2]; - for (unsigned j = 0; j < 2; j++) - { - cs[j] = c[j].back().getConst<String>(); - } - unsigned larger = cs[0].size() > cs[1].size() ? 0 : 1; - unsigned smallerSize = cs[1 - larger].size(); - if (cs[1 - larger] - == (i == 0 ? cs[larger].suffix(smallerSize) - : cs[larger].prefix(smallerSize))) - { - unsigned sizeDiff = cs[larger].size() - smallerSize; - c[larger][c[larger].size() - 1] = - nm->mkConst(i == 0 ? cs[larger].prefix(sizeDiff) - : cs[larger].suffix(sizeDiff)); - c[1 - larger].pop_back(); - changed = true; - } - } - for (unsigned j = 0; j < 2; j++) - { - std::reverse(c[j].begin(), c[j].end()); - } - } - if (changed) - { - // e.g. x++y = x++z ---> y = z, "AB" ++ x = "A" ++ y --> "B" ++ x = y - Node s1 = strings::TheoryStringsRewriter::mkConcat(STRING_CONCAT, c[0]); - Node s2 = strings::TheoryStringsRewriter::mkConcat(STRING_CONCAT, c[1]); - new_ret = s1.eqNode(s2); - debugExtendedRewrite(ret, new_ret, "string-eq-unify"); - return new_ret; - } - - // ------- using the contains rewriter to reduce equalities - Node tcontains[2]; - bool tcontainsOneTrue = false; - unsigned tcontainsTrueIndex = 0; - for (unsigned i = 0; i < 2; i++) - { - Node tc = nm->mkNode(STRING_STRCTN, ret[i], ret[1 - i]); - tcontains[i] = Rewriter::rewrite(tc); - if (tcontains[i].isConst()) - { - if (tcontains[i].getConst<bool>()) - { - tcontainsOneTrue = true; - tcontainsTrueIndex = i; - } - else - { - new_ret = tcontains[i]; - // if str.contains( x, y ) ---> false then x = y ---> false - // Notice we may not catch this in the rewriter for strings - // equality, since it only calls the specific rewriter for - // contains and not the full rewriter. - debugExtendedRewrite(ret, new_ret, "eq-contains-one-false"); - return new_ret; - } - } - } - if (tcontainsOneTrue) - { - // if str.contains( x, y ) ---> true - // then x = y ---> contains( y, x ) - new_ret = tcontains[1 - tcontainsTrueIndex]; - debugExtendedRewrite(ret, new_ret, "eq-contains-one-true"); - return new_ret; - } - else if (tcontains[0] == tcontains[1] && tcontains[0] != ret) - { - // if str.contains( x, y ) ---> t and str.contains( y, x ) ---> t, - // then x = y ---> t - new_ret = tcontains[0]; - debugExtendedRewrite(ret, new_ret, "eq-dual-contains-eq"); - return new_ret; - } - - // ------- homogeneous constants - if (d_aggr) - { - for (unsigned i = 0; i < 2; i++) - { - if (ret[i].isConst()) - { - bool isHomogeneous = true; - unsigned hchar = 0; - String lhss = ret[i].getConst<String>(); - std::vector<unsigned> vec = lhss.getVec(); - if (vec.size() > 1) - { - hchar = vec[0]; - for (unsigned j = 1, size = vec.size(); j < size; j++) - { - if (vec[j] != hchar) - { - isHomogeneous = false; - break; - } - } - } - if (isHomogeneous) - { - std::sort(c[1 - i].begin(), c[1 - i].end()); - std::vector<Node> trimmed; - unsigned rmChar = 0; - for (unsigned j = 0, size = c[1 - i].size(); j < size; j++) - { - if (c[1 - i][j].isConst()) - { - // process the constant : either we have a conflict, or we - // drop an equal number of constants on the LHS - std::vector<unsigned> vecj = - c[1 - i][j].getConst<String>().getVec(); - for (unsigned k = 0, sizev = vecj.size(); k < sizev; k++) - { - bool conflict = false; - if (vec.empty()) - { - // e.g. "" = x ++ "A" ---> false - conflict = true; - } - else if (vecj[k] != hchar) - { - // e.g. "AA" = x ++ "B" ---> false - conflict = true; - } - else - { - rmChar++; - if (rmChar > lhss.size()) - { - // e.g. "AA" = x ++ "AAA" ---> false - conflict = true; - } - } - if (conflict) - { - // The three conflict cases should mostly should be taken - // care of by multiset reasoning in the strings rewriter, - // but we recognize this conflict just in case. - new_ret = nm->mkConst(false); - debugExtendedRewrite( - ret, new_ret, "string-eq-const-conflict"); - return new_ret; - } - } - } - else - { - trimmed.push_back(c[1 - i][j]); - } - } - Node lhs = ret[i]; - if (rmChar > 0) - { - Assert(lhss.size() >= rmChar); - // we trimmed - lhs = nm->mkConst(lhss.substr(0, lhss.size() - rmChar)); - } - Node ss = strings::TheoryStringsRewriter::mkConcat(STRING_CONCAT, - trimmed); - if (lhs != ret[i] || ss != ret[1 - i]) - { - // e.g. - // "AA" = y ++ x ---> "AA" = x ++ y if x < y - // "AAA" = y ++ "A" ++ z ---> "AA" = y ++ z - new_ret = lhs.eqNode(ss); - debugExtendedRewrite(ret, new_ret, "string-eq-homog-const"); - return new_ret; - } - } - } - } - } - } - } return new_ret; } diff --git a/src/theory/quantifiers/quantifiers_rewriter.cpp b/src/theory/quantifiers/quantifiers_rewriter.cpp index 1f94dd3df..e2a26f6e6 100644 --- a/src/theory/quantifiers/quantifiers_rewriter.cpp +++ b/src/theory/quantifiers/quantifiers_rewriter.cpp @@ -667,7 +667,28 @@ Node QuantifiersRewriter::computeProcessTerms2( Node body, bool hasPol, bool pol } } } - }else if( elimExtArith ){ + } + else if (ret.getKind() == SELECT && ret[0].getKind() == STORE) + { + Node st = ret[0]; + Node index = ret[1]; + std::vector<Node> iconds; + std::vector<Node> elements; + while (st.getKind() == STORE) + { + iconds.push_back(index.eqNode(st[1])); + elements.push_back(st[2]); + st = st[0]; + } + ret = nm->mkNode(SELECT, st, index); + // conditions + for (int i = (iconds.size() - 1); i >= 0; i--) + { + ret = nm->mkNode(ITE, iconds[i], elements[i], ret); + } + } + else if( elimExtArith ) + { if( ret.getKind()==INTS_DIVISION_TOTAL || ret.getKind()==INTS_MODULUS_TOTAL ){ Node num = ret[0]; Node den = ret[1]; @@ -711,25 +732,6 @@ Node QuantifiersRewriter::computeProcessTerms2( Node body, bool hasPol, bool pol } } } - else if (ret.getKind() == SELECT && ret[0].getKind() == STORE) - { - Node st = ret[0]; - Node index = ret[1]; - std::vector<Node> iconds; - std::vector<Node> elements; - while (st.getKind() == STORE) - { - iconds.push_back(index.eqNode(st[1])); - elements.push_back(st[2]); - st = st[0]; - } - ret = nm->mkNode(SELECT, st, index); - // conditions - for (int i = (iconds.size() - 1); i >= 0; i--) - { - ret = nm->mkNode(ITE, iconds[i], elements[i], ret); - } - } icache[prev] = ret; return ret; } diff --git a/src/theory/quantifiers/sygus/cegis_unif.cpp b/src/theory/quantifiers/sygus/cegis_unif.cpp index 456f44019..d4926311d 100644 --- a/src/theory/quantifiers/sygus/cegis_unif.cpp +++ b/src/theory/quantifiers/sygus/cegis_unif.cpp @@ -166,6 +166,13 @@ bool CegisUnif::processConstructCandidates(const std::vector<Node>& enums, ->toStreamSygus(ss, m_eu); Trace("cegis") << ss.str() << std::endl; } + if (m_eu.isNull()) + { + // A condition enumerator was excluded by symmetry breaking, fail. + // TODO (#2498): either move conditions to getTermList or handle + // partial models in this module. + return false; + } unif_values[index][e].push_back(m_eu); } // inter-enumerator symmetry breaking for return values diff --git a/src/theory/quantifiers/sygus/sygus_module.h b/src/theory/quantifiers/sygus/sygus_module.h index c1b12dfd0..02cf1cdf2 100644 --- a/src/theory/quantifiers/sygus/sygus_module.h +++ b/src/theory/quantifiers/sygus/sygus_module.h @@ -71,6 +71,16 @@ class SygusModule */ virtual void getTermList(const std::vector<Node>& candidates, std::vector<Node>& terms) = 0; + /** allow partial model + * + * This method returns true if this module does not require that all + * terms returned by getTermList have "proper" model values when calling + * constructCandidates. A term may have a model value that is not proper + * if is excluded by symmetry breaking, e.g. x+0 is not proper. All model + * values that are not proper are replaced by "null" when calling + * constructCandidates. + */ + virtual bool allowPartialModel() { return false; } /** construct candidate * * This function takes as input: diff --git a/src/theory/quantifiers/sygus/sygus_pbe.cpp b/src/theory/quantifiers/sygus/sygus_pbe.cpp index 9a6645560..647b16637 100644 --- a/src/theory/quantifiers/sygus/sygus_pbe.cpp +++ b/src/theory/quantifiers/sygus/sygus_pbe.cpp @@ -415,6 +415,8 @@ void SygusPbe::getTermList(const std::vector<Node>& candidates, } } +bool SygusPbe::allowPartialModel() { return !options::sygusPbeMultiFair(); } + bool SygusPbe::constructCandidates(const std::vector<Node>& enums, const std::vector<Node>& enum_values, const std::vector<Node>& candidates, @@ -431,10 +433,18 @@ bool SygusPbe::constructCandidates(const std::vector<Node>& enums, Trace("sygus-pbe-enum") << " " << enums[i] << " -> "; TermDbSygus::toStreamSygus("sygus-pbe-enum", enum_values[i]); Trace("sygus-pbe-enum") << std::endl; - unsigned sz = d_tds->getSygusTermSize( enum_values[i] ); - szs.push_back(sz); - if( i==0 || sz<min_term_size ){ - min_term_size = sz; + if (!enum_values[i].isNull()) + { + unsigned sz = d_tds->getSygusTermSize(enum_values[i]); + szs.push_back(sz); + if (i == 0 || sz < min_term_size) + { + min_term_size = sz; + } + } + else + { + szs.push_back(0); } } // Assume two enumerators of types T1 and T2. @@ -448,11 +458,14 @@ bool SygusPbe::constructCandidates(const std::vector<Node>& enums, std::vector<unsigned> enum_consider; for (unsigned i = 0, esize = enums.size(); i < esize; i++) { - Assert(szs[i] >= min_term_size); - int diff = szs[i] - min_term_size; - if (!options::sygusPbeMultiFair() || diff <= diffAllow) + if (!enum_values[i].isNull()) { - enum_consider.push_back( i ); + Assert(szs[i] >= min_term_size); + int diff = szs[i] - min_term_size; + if (!options::sygusPbeMultiFair() || diff <= diffAllow) + { + enum_consider.push_back(i); + } } } diff --git a/src/theory/quantifiers/sygus/sygus_pbe.h b/src/theory/quantifiers/sygus/sygus_pbe.h index 66e19b6c9..b2ad5f63a 100644 --- a/src/theory/quantifiers/sygus/sygus_pbe.h +++ b/src/theory/quantifiers/sygus/sygus_pbe.h @@ -117,6 +117,11 @@ class SygusPbe : public SygusModule */ void getTermList(const std::vector<Node>& candidates, std::vector<Node>& terms) override; + /** + * PBE allows partial models to handle multiple enumerators if we are not + * using a strictly fair enumeration strategy. + */ + bool allowPartialModel() override; /** construct candidates * * This function attempts to use unification-based approaches for constructing diff --git a/src/theory/quantifiers/sygus/synth_conjecture.cpp b/src/theory/quantifiers/sygus/synth_conjecture.cpp index fde69d196..a29fdcc9f 100644 --- a/src/theory/quantifiers/sygus/synth_conjecture.cpp +++ b/src/theory/quantifiers/sygus/synth_conjecture.cpp @@ -23,6 +23,7 @@ #include "smt/smt_engine.h" #include "smt/smt_engine_scope.h" #include "smt/smt_statistics_registry.h" +#include "theory/datatypes/datatypes_rewriter.h" #include "theory/quantifiers/first_order_model.h" #include "theory/quantifiers/instantiate.h" #include "theory/quantifiers/quantifiers_attributes.h" @@ -338,7 +339,14 @@ void SynthConjecture::doCheck(std::vector<Node>& lems) // get the model value of the relevant terms from the master module std::vector<Node> enum_values; - getModelValues(terms, enum_values); + bool fullModel = getModelValues(terms, enum_values); + + // if the master requires a full model and the model is partial, we fail + if (!d_master->allowPartialModel() && !fullModel) + { + Trace("cegqi-check") << "...partial model, fail." << std::endl; + return; + } if (!constructed_cand) { @@ -586,36 +594,54 @@ void SynthConjecture::preregisterConjecture(Node q) d_ceg_si->preregisterConjecture(q); } -void SynthConjecture::getModelValues(std::vector<Node>& n, std::vector<Node>& v) +bool SynthConjecture::getModelValues(std::vector<Node>& n, std::vector<Node>& v) { + bool ret = true; Trace("cegqi-engine") << " * Value is : "; for (unsigned i = 0; i < n.size(); i++) { Node nv = getModelValue(n[i]); v.push_back(nv); + ret = ret && !nv.isNull(); if (Trace.isOn("cegqi-engine")) { - TypeNode tn = nv.getType(); - Trace("cegqi-engine") << n[i] << " -> "; + Node onv = nv.isNull() ? d_qe->getModel()->getValue(n[i]) : nv; + TypeNode tn = onv.getType(); std::stringstream ss; - Printer::getPrinter(options::outputLanguage())->toStreamSygus(ss, nv); - Trace("cegqi-engine") << ss.str() << " "; - if (Trace.isOn("cegqi-engine-rr")) + Printer::getPrinter(options::outputLanguage())->toStreamSygus(ss, onv); + Trace("cegqi-engine") << n[i] << " -> "; + if (nv.isNull()) + { + Trace("cegqi-engine") << "[EXC: " << ss.str() << "] "; + } + else { - Node bv = d_qe->getTermDatabaseSygus()->sygusToBuiltin(nv, tn); - bv = Rewriter::rewrite(bv); - Trace("cegqi-engine-rr") << " -> " << bv << std::endl; + Trace("cegqi-engine") << ss.str() << " "; + if (Trace.isOn("cegqi-engine-rr")) + { + Node bv = d_qe->getTermDatabaseSygus()->sygusToBuiltin(nv, tn); + bv = Rewriter::rewrite(bv); + Trace("cegqi-engine-rr") << " -> " << bv << std::endl; + } } } - Assert(!nv.isNull()); } Trace("cegqi-engine") << std::endl; + return ret; } Node SynthConjecture::getModelValue(Node n) { Trace("cegqi-mv") << "getModelValue for : " << n << std::endl; - return d_qe->getModel()->getValue(n); + if (n.getAttribute(SygusSymBreakExcAttribute())) + { + // if the current model value of n was excluded by symmetry breaking, then + // it does not have a proper model value that we should consider, thus we + // return null. + return Node::null(); + } + Node mv = d_qe->getModel()->getValue(n); + return mv; } void SynthConjecture::debugPrint(const char* c) diff --git a/src/theory/quantifiers/sygus/synth_conjecture.h b/src/theory/quantifiers/sygus/synth_conjecture.h index 1cbd4e949..53bc829cf 100644 --- a/src/theory/quantifiers/sygus/synth_conjecture.h +++ b/src/theory/quantifiers/sygus/synth_conjecture.h @@ -112,9 +112,15 @@ class SynthConjecture void assign(Node q); /** has a conjecture been assigned to this class */ bool isAssigned() { return !d_embed_quant.isNull(); } - /** get model values for terms n, store in vector v */ - void getModelValues(std::vector<Node>& n, std::vector<Node>& v); - /** get model value for term n */ + /** + * Get model values for terms n, store in vector v. This method returns true + * if and only if all values added to v are non-null. + */ + bool getModelValues(std::vector<Node>& n, std::vector<Node>& v); + /** + * Get model value for term n. If n has a value that was excluded by + * datatypes sygus symmetry breaking, this method returns null. + */ Node getModelValue(Node n); /** get utility for static preprocessing and analysis of conjectures */ diff --git a/src/theory/quantifiers/sygus/synth_engine.cpp b/src/theory/quantifiers/sygus/synth_engine.cpp index 56844ec1f..296c10ff6 100644 --- a/src/theory/quantifiers/sygus/synth_engine.cpp +++ b/src/theory/quantifiers/sygus/synth_engine.cpp @@ -42,8 +42,7 @@ SynthEngine::~SynthEngine() { delete d_conj; } bool SynthEngine::needsCheck(Theory::Effort e) { - return !d_quantEngine->getTheoryEngine()->needCheck() - && e >= Theory::EFFORT_LAST_CALL; + return e >= Theory::EFFORT_LAST_CALL; } QuantifiersModule::QEffort SynthEngine::needsModel(Theory::Effort e) diff --git a/src/theory/quantifiers/sygus/term_database_sygus.cpp b/src/theory/quantifiers/sygus/term_database_sygus.cpp index 1f4e34c1f..a10ecc566 100644 --- a/src/theory/quantifiers/sygus/term_database_sygus.cpp +++ b/src/theory/quantifiers/sygus/term_database_sygus.cpp @@ -343,6 +343,7 @@ void TermDbSygus::registerSygusType( TypeNode tn ) { } }else{ // no arguments to synthesis functions + d_var_list[tn].clear(); } // register connected types for (unsigned i = 0, ncons = dt.getNumConstructors(); i < ncons; i++) @@ -421,11 +422,51 @@ void TermDbSygus::registerSygusType( TypeNode tn ) { } } +/** A trie indexed by types that assigns unique identifiers to nodes. */ +class TypeNodeIdTrie +{ + public: + /** children of this node */ + std::map<TypeNode, TypeNodeIdTrie> d_children; + /** the data stored at this node */ + std::vector<Node> d_data; + /** add v to this trie, indexed by types */ + void add(Node v, std::vector<TypeNode>& types) + { + TypeNodeIdTrie* tnt = this; + for (unsigned i = 0, size = types.size(); i < size; i++) + { + tnt = &tnt->d_children[types[i]]; + } + tnt->d_data.push_back(v); + } + /** + * Assign each node in this trie an identifier such that + * assign[v1] = assign[v2] iff v1 and v2 are indexed by the same values. + */ + void assignIds(std::map<Node, unsigned>& assign, unsigned& idCount) + { + if (!d_data.empty()) + { + for (const Node& v : d_data) + { + assign[v] = idCount; + } + idCount++; + } + for (std::pair<const TypeNode, TypeNodeIdTrie>& c : d_children) + { + c.second.assignIds(assign, idCount); + } + } +}; + void TermDbSygus::registerEnumerator(Node e, Node f, SynthConjecture* conj, bool mkActiveGuard, - bool useSymbolicCons) + bool useSymbolicCons, + bool isVarAgnostic) { if (d_enum_to_conjecture.find(e) != d_enum_to_conjecture.end()) { @@ -441,15 +482,7 @@ void TermDbSygus::registerEnumerator(Node e, NodeManager* nm = NodeManager::currentNM(); if( mkActiveGuard ){ // make the guard - Node eg = Rewriter::rewrite(nm->mkSkolem("eG", nm->booleanType())); - eg = d_quantEngine->getValuation().ensureLiteral( eg ); - AlwaysAssert( !eg.isNull() ); - d_quantEngine->getOutputChannel().requirePhase( eg, true ); - //add immediate lemma - Node lem = nm->mkNode(OR, eg, eg.negate()); - Trace("cegqi-lemma") << "Cegqi::Lemma : enumerator : " << lem << std::endl; - d_quantEngine->getOutputChannel().lemma( lem ); - d_enum_to_active_guard[e] = eg; + d_enum_to_active_guard[e] = nm->mkSkolem("eG", nm->booleanType()); } Trace("sygus-db") << " registering symmetry breaking clauses..." @@ -459,35 +492,47 @@ void TermDbSygus::registerEnumerator(Node e, // breaking lemma templates for each relevant subtype of the grammar std::vector<TypeNode> sf_types; getSubfieldTypes(et, sf_types); + // maps variables to the list of subfield types they occur in + std::map<Node, std::vector<TypeNode> > type_occurs; + std::map<TypeNode, std::vector<Node> >::iterator itv = d_var_list.find(et); + Assert(itv != d_var_list.end()); + for (const Node& v : itv->second) + { + type_occurs[v].clear(); + } // for each type of subfield type of this enumerator for (unsigned i = 0, ntypes = sf_types.size(); i < ntypes; i++) { std::vector<unsigned> rm_indices; TypeNode stn = sf_types[i]; Assert(stn.isDatatype()); - const Datatype& dt = static_cast<DatatypeType>(stn.toType()).getDatatype(); - std::map<TypeNode, unsigned>::iterator itsa = - d_sym_cons_any_constant.find(stn); - if (itsa != d_sym_cons_any_constant.end()) + const Datatype& dt = stn.getDatatype(); + int anyC = getAnyConstantConsNum(stn); + for (unsigned i = 0, ncons = dt.getNumConstructors(); i < ncons; i++) { - if (!useSymbolicCons) + Expr sop = dt[i].getSygusOp(); + Assert(!sop.isNull()); + bool isAnyC = static_cast<int>(i) == anyC; + Node sopn = Node::fromExpr(sop); + if (type_occurs.find(sopn) != type_occurs.end()) + { + // if it is a variable, store that it occurs in stn + type_occurs[sopn].push_back(stn); + } + else if (isAnyC && !useSymbolicCons) { + // if we are not using the any constant constructor // do not use the symbolic constructor - rm_indices.push_back(itsa->second); + rm_indices.push_back(i); } - else + else if (anyC != -1 && !isAnyC && useSymbolicCons) { - // can remove all other concrete constant constructors - for (unsigned i = 0, ncons = dt.getNumConstructors(); i < ncons; i++) + // if we are using the any constant constructor, do not use any + // concrete constant + Node c_op = getConsNumConst(stn, i); + if (!c_op.isNull()) { - if (i != itsa->second) - { - Node c_op = getConsNumConst(stn, i); - if (!c_op.isNull()) - { - rm_indices.push_back(i); - } - } + rm_indices.push_back(i); } } } @@ -515,6 +560,33 @@ void TermDbSygus::registerEnumerator(Node e, } } Trace("sygus-db") << " ...finished" << std::endl; + + d_enum_var_agnostic[e] = isVarAgnostic; + if (isVarAgnostic) + { + // if not done so already, compute type class identifiers for each variable + if (d_var_subclass_id.find(et) == d_var_subclass_id.end()) + { + d_var_subclass_id[et].clear(); + TypeNodeIdTrie tnit; + for (std::pair<const Node, std::vector<TypeNode> >& to : type_occurs) + { + tnit.add(to.first, to.second); + } + // 0 is reserved for "no type class id" + unsigned typeIdCount = 1; + tnit.assignIds(d_var_subclass_id[et], typeIdCount); + // assign the list and reverse map to index + for (std::pair<const Node, std::vector<TypeNode> >& to : type_occurs) + { + Node v = to.first; + unsigned sc = d_var_subclass_id[et][v]; + Trace("sygus-db") << v << " has subclass id " << sc << std::endl; + d_var_subclass_list_index[et][v] = d_var_subclass_list[et][sc].size(); + d_var_subclass_list[et][sc].push_back(v); + } + } + } } bool TermDbSygus::isEnumerator(Node e) const @@ -561,6 +633,16 @@ bool TermDbSygus::usingSymbolicConsForEnumerator(Node e) const return false; } +bool TermDbSygus::isVariableAgnosticEnumerator(Node e) const +{ + std::map<Node, bool>::const_iterator itus = d_enum_var_agnostic.find(e); + if (itus != d_enum_var_agnostic.end()) + { + return itus->second; + } + return false; +} + void TermDbSygus::getEnumerators(std::vector<Node>& mts) { for (std::map<Node, SynthConjecture*>::iterator itm = @@ -881,6 +963,82 @@ bool TermDbSygus::hasSubtermSymbolicCons(TypeNode tn) const return d_has_subterm_sym_cons.find(tn) != d_has_subterm_sym_cons.end(); } +unsigned TermDbSygus::getSubclassForVar(TypeNode tn, Node n) const +{ + std::map<TypeNode, std::map<Node, unsigned> >::const_iterator itc = + d_var_subclass_id.find(tn); + if (itc == d_var_subclass_id.end()) + { + Assert(false); + return 0; + } + std::map<Node, unsigned>::const_iterator itcc = itc->second.find(n); + if (itcc == itc->second.end()) + { + Assert(false); + return 0; + } + return itcc->second; +} + +unsigned TermDbSygus::getNumSubclassVars(TypeNode tn, unsigned sc) const +{ + std::map<TypeNode, std::map<unsigned, std::vector<Node> > >::const_iterator + itv = d_var_subclass_list.find(tn); + if (itv == d_var_subclass_list.end()) + { + Assert(false); + return 0; + } + std::map<unsigned, std::vector<Node> >::const_iterator itvv = + itv->second.find(sc); + if (itvv == itv->second.end()) + { + Assert(false); + return 0; + } + return itvv->second.size(); +} +Node TermDbSygus::getVarSubclassIndex(TypeNode tn, + unsigned sc, + unsigned i) const +{ + std::map<TypeNode, std::map<unsigned, std::vector<Node> > >::const_iterator + itv = d_var_subclass_list.find(tn); + if (itv == d_var_subclass_list.end()) + { + Assert(false); + return Node::null(); + } + std::map<unsigned, std::vector<Node> >::const_iterator itvv = + itv->second.find(sc); + if (itvv == itv->second.end() || i >= itvv->second.size()) + { + Assert(false); + return Node::null(); + } + return itvv->second[i]; +} + +bool TermDbSygus::getIndexInSubclassForVar(TypeNode tn, + Node v, + unsigned& index) const +{ + std::map<TypeNode, std::map<Node, unsigned> >::const_iterator itv = + d_var_subclass_list_index.find(tn); + if (itv == d_var_subclass_list_index.end()) + { + return false; + } + std::map<Node, unsigned>::const_iterator itvv = itv->second.find(v); + if (itvv == itv->second.end()) + { + return false; + } + index = itvv->second; + return true; +} + bool TermDbSygus::isSymbolicConsApp(Node n) const { if (n.getKind() != APPLY_CONSTRUCTOR) diff --git a/src/theory/quantifiers/sygus/term_database_sygus.h b/src/theory/quantifiers/sygus/term_database_sygus.h index b7bdba3ab..361c6bae0 100644 --- a/src/theory/quantifiers/sygus/term_database_sygus.h +++ b/src/theory/quantifiers/sygus/term_database_sygus.h @@ -69,6 +69,10 @@ class TermDbSygus { * (see d_enum_to_active_guard), * useSymbolicCons : whether we want model values for e to include symbolic * constructors like the "any constant" variable. + * isVarAgnostic : if this flag is true, the enumerator will only generate + * values whose variables are in canonical order (for example, only x1-x2 + * and not x2-x1 will be generated, assuming x1 and x2 are in the same + * "subclass", see getSubclassForVar). * * Notice that enumerator e may not be one-to-one with f in * synthesis-through-unification approaches (e.g. decision tree construction @@ -78,7 +82,8 @@ class TermDbSygus { Node f, SynthConjecture* conj, bool mkActiveGuard = false, - bool useSymbolicCons = false); + bool useSymbolicCons = false, + bool isVarAgnostic = false); /** is e an enumerator registered with this class? */ bool isEnumerator(Node e) const; /** return the conjecture e is associated with */ @@ -89,6 +94,8 @@ class TermDbSygus { Node getActiveGuardForEnumerator(Node e) const; /** are we using symbolic constructors for enumerator e? */ bool usingSymbolicConsForEnumerator(Node e) const; + /** is this enumerator agnostic to variables? */ + bool isVariableAgnosticEnumerator(Node e) const; /** get all registered enumerators */ void getEnumerators(std::vector<Node>& mts); /** Register symmetry breaking lemma @@ -273,6 +280,8 @@ class TermDbSygus { std::map<Node, TypeNode> d_sb_lemma_to_type; /** mapping from symmetry breaking lemmas to size */ std::map<Node, unsigned> d_sb_lemma_to_size; + /** enumerators to whether they are variable agnostic */ + std::map<Node, bool> d_enum_var_agnostic; //------------------------------end enumerators //-----------------------------conversion from sygus to builtin @@ -345,6 +354,17 @@ class TermDbSygus { * for this type. */ std::map<TypeNode, bool> d_has_subterm_sym_cons; + /** + * Map from sygus types and bound variables to their type subclass id. Note + * type class identifiers are computed for each type of registered sygus + * enumerators, but not all sygus types. For details, see getSubclassIdForVar. + */ + std::map<TypeNode, std::map<Node, unsigned> > d_var_subclass_id; + /** the list of variables with given subclass */ + std::map<TypeNode, std::map<unsigned, std::vector<Node> > > + d_var_subclass_list; + /** the index of each variable in the above list */ + std::map<TypeNode, std::map<Node, unsigned> > d_var_subclass_list_index; public: // general sygus utilities bool isRegistered(TypeNode tn) const; @@ -390,6 +410,45 @@ class TermDbSygus { * Returns true if any subterm of type tn can be a symbolic constructor. */ bool hasSubtermSymbolicCons(TypeNode tn) const; + //--------------------------------- variable subclasses + /** Get subclass id for variable + * + * This returns the "subclass" identifier for variable v in sygus + * type tn. A subclass identifier groups variables based on the sygus + * types they occur in: + * A -> A + B | C + C | x | y | z | w | u + * B -> y | z + * C -> u + * The variables in this grammar can be grouped according to the sygus types + * they appear in: + * { x,w } occur in A + * { y,z } occur in A,B + * { u } occurs in A,C + * We say that e.g. x, w are in the same subclass. + * + * If this method returns 0, then v is not a variable in sygus type tn. + * Otherwise, this method returns a positive value n, such that + * getSubclassIdForVar[v1] = getSubclassIdForVar[v2] iff v1 and v2 are in the + * same subclass. + * + * The type tn should be the type of an enumerator registered to this + * database, where notice that we do not compute this information for the + * subfield types of the enumerator. + */ + unsigned getSubclassForVar(TypeNode tn, Node v) const; + /** + * Get the number of variable in the subclass with identifier sc for type tn. + */ + unsigned getNumSubclassVars(TypeNode tn, unsigned sc) const; + /** Get the i^th variable in the subclass with identifier sc for type tn */ + Node getVarSubclassIndex(TypeNode tn, unsigned sc, unsigned i) const; + /** + * Get the a variable's index in its subclass list. This method returns true + * iff variable v has been assigned a subclass in tn. It updates index to + * be v's index iff the method returns true. + */ + bool getIndexInSubclassForVar(TypeNode tn, Node v, unsigned& index) const; + //--------------------------------- end variable subclasses /** return whether n is an application of a symbolic constructor */ bool isSymbolicConsApp(Node n) const; /** can construct kind diff --git a/src/theory/strings/theory_strings_rewriter.cpp b/src/theory/strings/theory_strings_rewriter.cpp index 7803224c6..f8bbeecf5 100644 --- a/src/theory/strings/theory_strings_rewriter.cpp +++ b/src/theory/strings/theory_strings_rewriter.cpp @@ -315,10 +315,179 @@ Node TheoryStringsRewriter::rewriteEquality(Node node) { return NodeManager::currentNM()->mkNode(kind::EQUAL, node[1], node[0]); } - else + return node; +} + +Node TheoryStringsRewriter::rewriteEqualityExt(Node node) +{ + Assert(node.getKind() == EQUAL); + if (!node[0].getType().isString()) { return node; } + NodeManager* nm = NodeManager::currentNM(); + std::vector<Node> c[2]; + Node new_ret; + for (unsigned i = 0; i < 2; i++) + { + getConcat(node[i], c[i]); + } + // ------- equality unification + bool changed = false; + for (unsigned i = 0; i < 2; i++) + { + while (!c[0].empty() && !c[1].empty() && c[0].back() == c[1].back()) + { + c[0].pop_back(); + c[1].pop_back(); + changed = true; + } + // splice constants + if (!c[0].empty() && !c[1].empty() && c[0].back().isConst() + && c[1].back().isConst()) + { + String cs[2]; + for (unsigned j = 0; j < 2; j++) + { + cs[j] = c[j].back().getConst<String>(); + } + unsigned larger = cs[0].size() > cs[1].size() ? 0 : 1; + unsigned smallerSize = cs[1 - larger].size(); + if (cs[1 - larger] + == (i == 0 ? cs[larger].suffix(smallerSize) + : cs[larger].prefix(smallerSize))) + { + unsigned sizeDiff = cs[larger].size() - smallerSize; + c[larger][c[larger].size() - 1] = nm->mkConst( + i == 0 ? cs[larger].prefix(sizeDiff) : cs[larger].suffix(sizeDiff)); + c[1 - larger].pop_back(); + changed = true; + } + } + for (unsigned j = 0; j < 2; j++) + { + std::reverse(c[j].begin(), c[j].end()); + } + } + if (changed) + { + // e.g. x++y = x++z ---> y = z, "AB" ++ x = "A" ++ y --> "B" ++ x = y + Node s1 = mkConcat(STRING_CONCAT, c[0]); + Node s2 = mkConcat(STRING_CONCAT, c[1]); + new_ret = s1.eqNode(s2); + node = returnRewrite(node, new_ret, "str-eq-unify"); + } + + // ------- homogeneous constants + for (unsigned i = 0; i < 2; i++) + { + if (node[i].isConst()) + { + bool isHomogeneous = true; + unsigned hchar = 0; + String lhss = node[i].getConst<String>(); + std::vector<unsigned> vec = lhss.getVec(); + if (vec.size() > 1) + { + hchar = vec[0]; + for (unsigned j = 1, size = vec.size(); j < size; j++) + { + if (vec[j] != hchar) + { + isHomogeneous = false; + break; + } + } + } + if (isHomogeneous) + { + std::sort(c[1 - i].begin(), c[1 - i].end()); + std::vector<Node> trimmed; + unsigned rmChar = 0; + for (unsigned j = 0, size = c[1 - i].size(); j < size; j++) + { + if (c[1 - i][j].isConst()) + { + // process the constant : either we have a conflict, or we + // drop an equal number of constants on the LHS + std::vector<unsigned> vecj = + c[1 - i][j].getConst<String>().getVec(); + for (unsigned k = 0, sizev = vecj.size(); k < sizev; k++) + { + bool conflict = false; + if (vec.empty()) + { + // e.g. "" = x ++ "A" ---> false + conflict = true; + } + else if (vecj[k] != hchar) + { + // e.g. "AA" = x ++ "B" ---> false + conflict = true; + } + else + { + rmChar++; + if (rmChar > lhss.size()) + { + // e.g. "AA" = x ++ "AAA" ---> false + conflict = true; + } + } + if (conflict) + { + // The three conflict cases should mostly should be taken + // care of by multiset reasoning in the strings rewriter, + // but we recognize this conflict just in case. + new_ret = nm->mkConst(false); + return returnRewrite(node, new_ret, "string-eq-const-conflict"); + } + } + } + else + { + trimmed.push_back(c[1 - i][j]); + } + } + Node lhs = node[i]; + if (rmChar > 0) + { + Assert(lhss.size() >= rmChar); + // we trimmed + lhs = nm->mkConst(lhss.substr(0, lhss.size() - rmChar)); + } + Node ss = mkConcat(STRING_CONCAT, trimmed); + if (lhs != node[i] || ss != node[1 - i]) + { + // e.g. + // "AA" = y ++ x ---> "AA" = x ++ y if x < y + // "AAA" = y ++ "A" ++ z ---> "AA" = y ++ z + new_ret = lhs.eqNode(ss); + node = returnRewrite(node, new_ret, "str-eq-homog-const"); + } + } + } + } + + Assert(node.getKind() == EQUAL); + + // Try to rewrite (= x y) into a conjunction of equalities based on length + // entailment. + // + // (<= (str.len x) (str.++ y1 ... yn)) AND (= x (str.++ y1 ... yn)) ---> + // (and (= x (str.++ y1' ... ym')) (= y1'' "") ... (= yk'' "")) + // + // where yi' and yi'' correspond to some yj and + // (<= (str.len x) (str.++ y1' ... ym')) + for (unsigned i = 0; i < 2; i++) + { + new_ret = inferEqsFromContains(node[i], node[1 - i]); + if (!new_ret.isNull()) + { + return returnRewrite(node, new_ret, "str-eq-conj-len-entail"); + } + } + return node; } // TODO (#1180) add rewrite @@ -1587,6 +1756,8 @@ Node TheoryStringsRewriter::rewriteContains( Node node ) { // (str.contains x (str.++ w (str.replace x y x) z)) ---> // (and (= w "") (= x (str.replace x y x)) (= z "")) + // + // TODO: Remove with under-/over-approximation if (node[0] == n[0] && node[0] == n[2]) { Node ret; @@ -1684,7 +1855,6 @@ Node TheoryStringsRewriter::rewriteContains( Node node ) { } } Trace("strings-rewrite-multiset") << "For " << node << " : " << std::endl; - bool sameConst = true; for (const Node& ch : chars) { Trace("strings-rewrite-multiset") << " # occurrences of substring "; @@ -1696,64 +1866,6 @@ Node TheoryStringsRewriter::rewriteContains( Node node ) { Node ret = NodeManager::currentNM()->mkConst(false); return returnRewrite(node, ret, "ctn-mset-nss"); } - else if (count_const[0][ch] > count_const[1][ch]) - { - sameConst = false; - } - } - - if (sameConst) - { - // At this point, we know that both the first and the second argument - // both contain the same constants. Now we can check if there are - // non-const components that appear in the second argument but not the - // first. If there are, we know that the str.contains is true iff those - // components are empty, so we can pull them out of the str.contains. For - // example: - // - // (str.contains (str.++ "A" x) (str.++ y x "A")) --> - // (and (str.contains (str.++ "A" x) (str.++ x "A")) (= y "")) - // - // These equalities can be used by other rewrites for subtitutions. - - // Find all non-const components that appear more times in second - // argument than the first - std::unordered_set<Node, NodeHashFunction> nConstEmpty; - for (std::pair<const Node, unsigned>& nncp : num_nconst[1]) - { - if (nncp.second > num_nconst[0][nncp.first]) - { - nConstEmpty.insert(nncp.first); - } - } - - // Check if there are any non-const components that must be empty - if (nConstEmpty.size() > 0) - { - // Generate str.contains of the (potentially) non-empty parts - std::vector<Node> cs; - std::vector<Node> nnc2; - for (const Node& n : nc2) - { - if (nConstEmpty.find(n) == nConstEmpty.end()) - { - nnc2.push_back(n); - } - } - cs.push_back(nm->mkNode( - kind::STRING_STRCTN, node[0], mkConcat(kind::STRING_CONCAT, nnc2))); - - // Generate equalities for the parts that must be empty - Node emptyStr = nm->mkConst(String("")); - for (const Node& n : nConstEmpty) - { - cs.push_back(nm->mkNode(kind::EQUAL, n, emptyStr)); - } - - Assert(cs.size() >= 2); - Node res = nm->mkNode(kind::AND, cs); - return returnRewrite(node, res, "ctn-mset-substs"); - } } // TODO (#1180): count the number of 2,3,4,.. character substrings @@ -1767,11 +1879,11 @@ Node TheoryStringsRewriter::rewriteContains( Node node ) { // TODO (#1180): abstract interpretation with multi-set domain // to show first argument is a strict subset of second argument - if (checkEntailArithEq(len_n1, len_n2)) + if (checkEntailArith(len_n2, len_n1, false)) { - // len( n2 ) = len( n1 ) => contains( n1, n2 ) ---> n1 = n2 + // len( n2 ) >= len( n1 ) => contains( n1, n2 ) ---> n1 = n2 Node ret = node[0].eqNode(node[1]); - return returnRewrite(node, ret, "ctn-len-eq"); + return returnRewrite(node, ret, "ctn-len-ineq-nstrict"); } // splitting @@ -1822,9 +1934,7 @@ Node TheoryStringsRewriter::rewriteContains( Node node ) { // (str.contains (str.substr x n (str.len y)) y) ---> // (= (str.substr x n (str.len y)) y) // - // TODO: generalize with over-/underapproximation to: - // - // (str.contains x y) ---> (= x y) if (<= (str.len x) (str.len y)) + // TODO: Remove with under-/over-approximation if (node[0][2] == nm->mkNode(kind::STRING_LENGTH, node[1])) { Node ret = nm->mkNode(kind::EQUAL, node[0], node[1]); @@ -1844,6 +1954,10 @@ Node TheoryStringsRewriter::rewriteContains( Node node ) { // (str.contains x (str.replace "" x y)) ---> // (= "" (str.replace "" x y)) + // + // Note: Length-based reasoning is not sufficient to get this rewrite. We + // can neither show that str.len(str.replace("", x, y)) - str.len(x) >= 0 + // nor str.len(x) - str.len(str.replace("", x, y)) >= 0 Node emp = nm->mkConst(CVC4::String("")); if (node[0] == node[1][1] && node[1][0] == emp) { @@ -2606,17 +2720,19 @@ Node TheoryStringsRewriter::rewritePrefixSuffix(Node n) { val = NodeManager::currentNM()->mkNode(kind::MINUS, lent, lens); } + + // Check if we can turn the prefix/suffix into equalities by showing that the + // prefix/suffix is at least as long as the string + Node eqs = inferEqsFromContains(n[1], n[0]); + if (!eqs.isNull()) + { + return returnRewrite(n, eqs, "suf/prefix-to-eqs"); + } + // general reduction to equality + substr Node retNode = n[0].eqNode( NodeManager::currentNM()->mkNode(kind::STRING_SUBSTR, n[1], val, lens)); - // add length constraint if it cannot be shown by simple entailment check - if (!checkEntailArith(lent, lens)) - { - retNode = NodeManager::currentNM()->mkNode( - kind::AND, - retNode, - NodeManager::currentNM()->mkNode(kind::GEQ, lent, lens)); - } + return retNode; } @@ -3809,9 +3925,174 @@ Node TheoryStringsRewriter::getStringOrEmpty(Node n) return res; } +bool TheoryStringsRewriter::inferZerosInSumGeq(Node x, + std::vector<Node>& ys, + std::vector<Node>& zeroYs) +{ + Assert(zeroYs.empty()); + + NodeManager* nm = NodeManager::currentNM(); + + // Check if we can show that y1 + ... + yn >= x + Node sum = (ys.size() > 1) ? nm->mkNode(PLUS, ys) : ys[0]; + if (!checkEntailArith(sum, x)) + { + return false; + } + + // Try to remove yi one-by-one and check if we can still show: + // + // y1 + ... + yi-1 + yi+1 + ... + yn >= x + // + // If that's the case, we know that yi can be zero and the inequality still + // holds. + size_t i = 0; + while (i < ys.size()) + { + Node yi = ys[i]; + std::vector<Node>::iterator pos = ys.erase(ys.begin() + i); + if (ys.size() > 1) + { + sum = nm->mkNode(PLUS, ys); + } + else + { + sum = ys.size() == 1 ? ys[0] : nm->mkConst(Rational(0)); + } + + if (checkEntailArith(sum, x)) + { + zeroYs.push_back(yi); + } + else + { + ys.insert(pos, yi); + i++; + } + } + return true; +} + +Node TheoryStringsRewriter::inferEqsFromContains(Node x, Node y) +{ + NodeManager* nm = NodeManager::currentNM(); + Node emp = nm->mkConst(String("")); + + Node xLen = nm->mkNode(STRING_LENGTH, x); + std::vector<Node> yLens; + if (y.getKind() != STRING_CONCAT) + { + yLens.push_back(nm->mkNode(STRING_LENGTH, y)); + } + else + { + for (const Node& yi : y) + { + yLens.push_back(nm->mkNode(STRING_LENGTH, yi)); + } + } + + std::vector<Node> zeroLens; + if (x == emp) + { + // If x is the empty string, then all ys must be empty, too, and we can + // skip the expensive checks. Note that this is just a performance + // optimization. + zeroLens.swap(yLens); + } + else + { + // Check if we can infer that str.len(x) <= str.len(y). If that is the + // case, try to minimize the sum in str.len(x) <= str.len(y1) + ... + + // str.len(yn) (where y = y1 ++ ... ++ yn) while keeping the inequality + // true. The terms that can have length zero without making the inequality + // false must be all be empty if (str.contains x y) is true. + if (!inferZerosInSumGeq(xLen, yLens, zeroLens)) + { + // We could not prove that the inequality holds + return Node::null(); + } + else if (yLens.size() == y.getNumChildren()) + { + // We could only prove that the inequality holds but not that any of the + // ys must be empty + return nm->mkNode(EQUAL, x, y); + } + } + + if (y.getKind() != STRING_CONCAT) + { + if (zeroLens.size() == 1) + { + // y is not a concatenation and we found that it must be empty, so just + // return (= y "") + Assert(zeroLens[0][0] == y); + return nm->mkNode(EQUAL, y, emp); + } + else + { + Assert(yLens.size() == 1 && yLens[0][0] == y); + return nm->mkNode(EQUAL, x, y); + } + } + + std::vector<Node> cs; + for (const Node& yiLen : yLens) + { + Assert(std::find(y.begin(), y.end(), yiLen[0]) != y.end()); + cs.push_back(yiLen[0]); + } + + NodeBuilder<> nb(AND); + // (= x (str.++ y1' ... ym')) + if (!cs.empty()) + { + nb << nm->mkNode(EQUAL, x, mkConcat(STRING_CONCAT, cs)); + } + // (= y1'' "") ... (= yk'' "") + for (const Node& zeroLen : zeroLens) + { + Assert(std::find(y.begin(), y.end(), zeroLen[0]) != y.end()); + nb << nm->mkNode(EQUAL, zeroLen[0], emp); + } + + // (and (= x (str.++ y1' ... ym')) (= y1'' "") ... (= yk'' "")) + return nb.constructNode(); +} + Node TheoryStringsRewriter::returnRewrite(Node node, Node ret, const char* c) { Trace("strings-rewrite") << "Rewrite " << node << " to " << ret << " by " << c << "." << std::endl; + // standard post-processing + // We rewrite (string) equalities immediately here. This allows us to forego + // the standard invariant on equality rewrites (that s=t must rewrite to one + // of { s=t, t=s, true, false } ). + Kind retk = ret.getKind(); + if (retk == OR || retk == AND) + { + std::vector<Node> children; + bool childChanged = false; + for (const Node& cret : ret) + { + Node creter = cret; + if (cret.getKind() == EQUAL) + { + creter = rewriteEqualityExt(cret); + } + childChanged = childChanged || cret != creter; + children.push_back(creter); + } + if (childChanged) + { + ret = NodeManager::currentNM()->mkNode(retk, children); + } + } + else if (retk == EQUAL && node.getKind() != EQUAL) + { + Trace("strings-rewrite") + << "Apply extended equality rewrite on " << ret << std::endl; + ret = rewriteEqualityExt(ret); + } return ret; } diff --git a/src/theory/strings/theory_strings_rewriter.h b/src/theory/strings/theory_strings_rewriter.h index 5937e778f..c0aa91360 100644 --- a/src/theory/strings/theory_strings_rewriter.h +++ b/src/theory/strings/theory_strings_rewriter.h @@ -98,12 +98,16 @@ class TheoryStringsRewriter { * a is in rewritten form. */ static bool checkEntailArithInternal(Node a); - /** return rewrite + /** * Called when node rewrites to ret. - * The string c indicates the justification - * for the rewrite, which is printed by this - * function for debugging. - * This function returns ret. + * + * The string c indicates the justification for the rewrite, which is printed + * by this function for debugging. + * + * If node is not an equality and ret is an equality, this method applies + * an additional rewrite step (rewriteEqualityExt) that performs + * additional rewrites on ret, after which we return the result of this call. + * Otherwise, this method simply returns ret. */ static Node returnRewrite(Node node, Node ret, const char* c); @@ -118,9 +122,18 @@ class TheoryStringsRewriter { /** rewrite equality * * This method returns a formula that is equivalent to the equality between - * two strings, given by node. + * two strings s = t, given by node. The result of rewrite is one of + * { s = t, t = s, true, false }. */ static Node rewriteEquality(Node node); + /** rewrite equality extended + * + * This method returns a formula that is equivalent to the equality between + * two strings s = t, given by node. Specifically, this function performs + * rewrites whose conclusion is not necessarily one of + * { s = t, t = s, true, false }. + */ + static Node rewriteEqualityExt(Node node); /** rewrite concat * This is the entry point for post-rewriting terms node of the form * str.++( t1, .., tn ) @@ -534,6 +547,42 @@ class TheoryStringsRewriter { * because the function could not compute a simpler */ static Node getStringOrEmpty(Node n); + + /** + * Given an inequality y1 + ... + yn >= x, removes operands yi s.t. the + * original inequality still holds. Returns true if the original inequality + * holds and false otherwise. The list of ys is modified to contain a subset + * of the original ys. + * + * Example: + * + * inferZerosInSumGeq( (str.len x), [ (str.len x), (str.len y), 1 ], [] ) + * --> returns true with ys = [ (str.len x) ] and zeroYs = [ (str.len y), 1 ] + * (can be used to rewrite the inequality to false) + * + * inferZerosInSumGeq( (str.len x), [ (str.len y) ], [] ) + * --> returns false because it is not possible to show + * str.len(y) >= str.len(x) + */ + static bool inferZerosInSumGeq(Node x, + std::vector<Node>& ys, + std::vector<Node>& zeroYs); + + /** + * Infers a conjunction of equalities that correspond to (str.contains x y) + * if it can show that the length of y is greater or equal to the length of + * x. If y is a concatentation, we get x = y1 ++ ... ++ yn, the conjunction + * is of the form: + * + * (and (= x (str.++ y1' ... ym')) (= y1'' "") ... (= yk'' "")) + * + * where each yi'' are yi that must be empty for (= x y) to hold and yi' are + * yi that the function could not infer anything about. Returns a null node + * if the function cannot infer that str.len(y) >= str.len(x). Returns (= x + * y) if the function can infer that str.len(y) >= str.len(x) but cannot + * infer that any of the yi must be empty. + */ + static Node inferEqsFromContains(Node x, Node y); };/* class TheoryStringsRewriter */ }/* CVC4::theory::strings namespace */ diff --git a/src/util/CMakeLists.txt b/src/util/CMakeLists.txt new file mode 100644 index 000000000..a17f7c510 --- /dev/null +++ b/src/util/CMakeLists.txt @@ -0,0 +1,59 @@ +configure_file(floatingpoint.h.in floatingpoint.h) +configure_file(rational.h.in rational.h) +configure_file(integer.h.in integer.h) + +libcvc4_add_sources( + abstract_value.cpp + abstract_value.h + bin_heap.h + bitvector.cpp + bitvector.h + bool.h + cardinality.cpp + cardinality.h + channel.h + debug.h + dense_map.h + divisible.cpp + divisible.h + floatingpoint.cpp + gmp_util.h + hash.h + index.cpp + index.h + maybe.h + ostream_util.cpp + ostream_util.h + proof.h + random.cpp + random.h + regexp.cpp + regexp.h + resource_manager.cpp + resource_manager.h + result.cpp + result.h + safe_print.cpp + safe_print.h + sampler.cpp + sampler.h + sexpr.cpp + sexpr.h + smt2_quote_string.cpp + smt2_quote_string.h + statistics.cpp + statistics.h + statistics_registry.cpp + statistics_registry.h + tuple.h + unsafe_interrupt_exception.h + utility.h +) + +if(CVC4_USE_CLN_IMP) + libcvc4_add_sources(rational_cln_imp.cpp integer_cln_imp.cpp) +endif() + +if(CVC4_USE_GMP_IMP) + libcvc4_add_sources(rational_gmp_imp.cpp integer_gmp_imp.cpp) +endif() diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt new file mode 100644 index 000000000..44cf5a651 --- /dev/null +++ b/test/CMakeLists.txt @@ -0,0 +1,30 @@ +#-----------------------------------------------------------------------------# +# Add subdirectories + +add_subdirectory(regress) +add_subdirectory(system EXCLUDE_FROM_ALL) + +if(BUILD_BINDINGS_JAVA) + add_subdirectory(java) +endif() + +if(ENABLE_UNIT_TESTING) + add_subdirectory(unit EXCLUDE_FROM_ALL) +endif() + +#-----------------------------------------------------------------------------# +# Add target 'check', builds and runs +# > unit tests +# > regression tests of levels 0 and 1 +# > system tests + +add_custom_target(check + COMMAND + ctest --output-on-failure -LE "regress[2-4]" -j${CTEST_NTHREADS} $(ARGS) + DEPENDS regress systemtests) +if(BUILD_BINDINGS_JAVA) + add_dependencies(check cvc4javatests) +endif() +if(ENABLE_UNIT_TESTING) + add_dependencies(check units) +endif() diff --git a/test/java/BitVectors.java b/test/java/BitVectors.java index 22dccfefc..f24861322 100644 --- a/test/java/BitVectors.java +++ b/test/java/BitVectors.java @@ -51,7 +51,7 @@ public class BitVectors { // // Two more efficient yet equivalent methods are: // - //(1) x = a ⊕ b ⊕ x; + //(1) x = a xor b xor x; // //(2) x = a + b - x; // diff --git a/test/java/CMakeLists.txt b/test/java/CMakeLists.txt new file mode 100644 index 000000000..27042559a --- /dev/null +++ b/test/java/CMakeLists.txt @@ -0,0 +1,38 @@ +find_package(Java REQUIRED) +find_package(JUnit 4.0 REQUIRED) +include(UseJava) + +set(java_test_src_files + BitVectors.java + BitVectorsAndArrays.java + Combination.java + HelloWorld.java + LinearArith.java +) + +add_jar(cvc4javatests + SOURCES ${java_test_src_files} + INCLUDE_JARS + ${CMAKE_BINARY_DIR}/src/bindings/java/CVC4.jar + ${JUnit_JAR} +) +add_dependencies(cvc4javatests cvc4jar) + +# Add java tests to ctest +set(classpath "${CMAKE_CURRENT_BINARY_DIR}/cvc4javatests.jar") +set(classpath "${classpath}:${CMAKE_BINARY_DIR}/src/bindings/java/CVC4.jar") +set(classpath "${classpath}:${JUnit_JAR}:${JUnit_JAR_DEPS}") + +foreach(src_file ${java_test_src_files}) + string(REPLACE ".java" "" name ${src_file}) + add_test( + NAME ${name} + COMMAND + ${Java_JAVA_EXECUTABLE} + -Djava.library.path=${CMAKE_BINARY_DIR}/src/bindings/java/ + -cp ${classpath} + org.junit.runner.JUnitCore + ${name} + ) + set_tests_properties(${name} PROPERTIES LABELS "java") +endforeach() diff --git a/test/regress/CMakeLists.txt b/test/regress/CMakeLists.txt new file mode 100644 index 000000000..88be6b94b --- /dev/null +++ b/test/regress/CMakeLists.txt @@ -0,0 +1,2108 @@ +#-----------------------------------------------------------------------------# +# Regression level 0 tests + +set(regress_0_tests + regress0/arith/arith.01.cvc + regress0/arith/arith.02.cvc + regress0/arith/arith.03.cvc + regress0/arith/bug443.delta01.smt + regress0/arith/bug547.2.smt2 + regress0/arith/bug569.smt2 + regress0/arith/delta-minimized-row-vector-bug.smt + regress0/arith/div-chainable.smt2 + regress0/arith/div.01.smt2 + regress0/arith/div.02.smt2 + regress0/arith/div.04.smt2 + regress0/arith/div.05.smt2 + regress0/arith/div.07.smt2 + regress0/arith/fuzz_3-eq.smt + regress0/arith/integers/arith-int-042.cvc + regress0/arith/integers/arith-int-042.min.cvc + regress0/arith/leq.01.smt + regress0/arith/miplib.cvc + regress0/arith/miplib2.cvc + regress0/arith/miplib4.cvc + regress0/arith/miplibtrick.smt + regress0/arith/mod-simp.smt2 + regress0/arith/mod.01.smt2 + regress0/arith/mult.01.smt2 + regress0/arrayinuf_declare.smt2 + regress0/arrays/arrays0.smt2 + regress0/arrays/arrays1.smt2 + regress0/arrays/arrays2.smt2 + regress0/arrays/arrays3.smt2 + regress0/arrays/arrays4.smt2 + regress0/arrays/bool-array.smt2 + regress0/arrays/bug272.minimized.smt + regress0/arrays/bug272.smt + regress0/arrays/bug637.delta.smt2 + regress0/arrays/constarr.cvc + regress0/arrays/constarr.smt2 + regress0/arrays/constarr2.cvc + regress0/arrays/constarr2.smt2 + regress0/arrays/incorrect1.smt + regress0/arrays/incorrect10.smt + regress0/arrays/incorrect11.smt + regress0/arrays/incorrect2.minimized.smt + regress0/arrays/incorrect2.smt + regress0/arrays/incorrect3.smt + regress0/arrays/incorrect4.smt + regress0/arrays/incorrect5.smt + regress0/arrays/incorrect6.smt + regress0/arrays/incorrect7.smt + regress0/arrays/incorrect8.minimized.smt + regress0/arrays/incorrect8.smt + regress0/arrays/incorrect9.smt + regress0/arrays/swap_t1_np_nf_ai_00005_007.cvc.smt + regress0/arrays/x2.smt + regress0/arrays/x3.smt + regress0/aufbv/array_rewrite_bug.smt + regress0/aufbv/bug00.smt + regress0/aufbv/bug338.smt2 + regress0/aufbv/bug347.smt + regress0/aufbv/bug451.smt + regress0/aufbv/bug509.smt + regress0/aufbv/bug580.delta.smt2 + regress0/aufbv/diseqprop.01.smt + regress0/aufbv/dubreva005ue.delta01.smt + regress0/aufbv/fifo32bc06k08.delta01.smt + regress0/aufbv/fuzz00.smt + regress0/aufbv/fuzz01.delta01.smt + regress0/aufbv/fuzz01.smt + regress0/aufbv/fuzz02.delta01.smt + regress0/aufbv/fuzz02.smt + regress0/aufbv/fuzz03.delta01.smt + regress0/aufbv/fuzz03.smt + regress0/aufbv/fuzz04.delta01.smt + regress0/aufbv/fuzz04.smt + regress0/aufbv/fuzz05.delta01.smt + regress0/aufbv/fuzz05.smt + regress0/aufbv/fuzz06.delta01.smt + regress0/aufbv/fuzz06.smt + regress0/aufbv/fuzz07.smt + regress0/aufbv/fuzz08.smt + regress0/aufbv/fuzz09.smt + regress0/aufbv/fuzz11.smt + regress0/aufbv/fuzz12.smt + regress0/aufbv/fuzz13.smt + regress0/aufbv/fuzz14.smt + regress0/aufbv/fuzz15.smt + regress0/aufbv/rewrite_bug.smt + regress0/aufbv/try3_sameret_functions_fse-bfs_tac.calc_next.il.fse-bfs.delta01.smt + regress0/aufbv/try5_small_difret_functions_wp_su.set_char_quoting.il.wp.delta01.smt + regress0/aufbv/wchains010ue.delta01.smt + regress0/aufbv/wchains010ue.delta02.smt + regress0/auflia/a17.smt + regress0/auflia/bug336.smt2 + regress0/auflia/error72.delta2.smt + regress0/auflia/fuzz-error1099.smt + regress0/auflia/fuzz-error232.smt + regress0/auflia/fuzz01.delta01.smt + regress0/auflia/fuzz02.smt + regress0/auflia/fuzz03.smt + regress0/auflia/fuzz04.smt + regress0/auflia/fuzz05.smt + regress0/auflia/x2.smt + regress0/boolean-prec.cvc + regress0/boolean-terms-bug-array.smt2 + regress0/boolean-terms-kernel1.smt2 + regress0/boolean-terms.cvc + regress0/bt-test-00.smt2 + regress0/bt-test-01.smt2 + regress0/bug1247.smt2 + regress0/bug161.smt + regress0/bug164.smt + regress0/bug167.smt + regress0/bug168.smt + regress0/bug187.smt2 + regress0/bug217.smt2 + regress0/bug220.smt2 + regress0/bug239.smt + regress0/bug274.cvc + regress0/bug288.smt + regress0/bug288b.smt + regress0/bug288c.smt + regress0/bug303.smt2 + regress0/bug310.cvc + regress0/bug32.cvc + regress0/bug322.cvc + regress0/bug322b.cvc + regress0/bug339.smt2 + regress0/bug365.smt2 + regress0/bug382.smt2 + regress0/bug383.smt2 + regress0/bug398.smt2 + regress0/bug421.smt2 + regress0/bug421b.smt2 + regress0/bug480.smt2 + regress0/bug484.smt2 + regress0/bug486.cvc + regress0/bug49.smt + regress0/bug512.minimized.smt2 + regress0/bug521.minimized.smt2 + regress0/bug522.smt2 + regress0/bug528a.smt2 + regress0/bug541.smt2 + regress0/bug544.smt2 + regress0/bug548a.smt2 + regress0/bug576.smt2 + regress0/bug576a.smt2 + regress0/bug578.smt2 + regress0/bug586.cvc + regress0/bug595.cvc + regress0/bug596.cvc + regress0/bug596b.cvc + regress0/bug605.cvc + regress0/bug639.smt2 + regress0/buggy-ite.smt2 + regress0/bv/bool-to-bv.smt2 + regress0/bv/bug260a.smt + regress0/bv/bug260b.smt + regress0/bv/bug440.smt + regress0/bv/bug733.smt2 + regress0/bv/bug734.smt2 + regress0/bv/bv-abstr-bug.smt2 + regress0/bv/bv-abstr-bug2.smt2 + regress0/bv/bv-int-collapse1.smt2 + regress0/bv/bv-int-collapse2.smt2 + regress0/bv/bv-options1.smt2 + regress0/bv/bv-options2.smt2 + regress0/bv/bv-options3.smt2 + regress0/bv/bv-options4.smt2 + regress0/bv/bv-to-bool.smt + regress0/bv/bv2nat-ground-c.smt2 + regress0/bv/bv2nat-simp-range.smt2 + regress0/bv/bvmul-pow2-only.smt2 + regress0/bv/bvsimple.cvc + regress0/bv/calc2_sec2_shifter_mult_bmc15.atlas.delta01.smt + regress0/bv/core/a78test0002.smt + regress0/bv/core/a95test0002.smt + regress0/bv/core/bitvec0.smt + regress0/bv/core/bitvec2.smt + regress0/bv/core/bitvec5.smt + regress0/bv/core/bitvec7.smt + regress0/bv/core/bv_eq_diamond10.smt + regress0/bv/core/concat-merge-0.smt + regress0/bv/core/concat-merge-1.smt + regress0/bv/core/concat-merge-2.smt + regress0/bv/core/concat-merge-3.smt + regress0/bv/core/equality-00.smt + regress0/bv/core/equality-01.smt + regress0/bv/core/equality-02.smt + regress0/bv/core/equality-05.smt + regress0/bv/core/extract-concat-0.smt + regress0/bv/core/extract-concat-1.smt + regress0/bv/core/extract-concat-10.smt + regress0/bv/core/extract-concat-11.smt + regress0/bv/core/extract-concat-2.smt + regress0/bv/core/extract-concat-3.smt + regress0/bv/core/extract-concat-4.smt + regress0/bv/core/extract-concat-5.smt + regress0/bv/core/extract-concat-6.smt + regress0/bv/core/extract-concat-7.smt + regress0/bv/core/extract-concat-8.smt + regress0/bv/core/extract-concat-9.smt + regress0/bv/core/extract-constant.smt + regress0/bv/core/extract-extract-0.smt + regress0/bv/core/extract-extract-1.smt + regress0/bv/core/extract-extract-10.smt + regress0/bv/core/extract-extract-11.smt + regress0/bv/core/extract-extract-2.smt + regress0/bv/core/extract-extract-3.smt + regress0/bv/core/extract-extract-4.smt + regress0/bv/core/extract-extract-5.smt + regress0/bv/core/extract-extract-6.smt + regress0/bv/core/extract-extract-7.smt + regress0/bv/core/extract-extract-8.smt + regress0/bv/core/extract-extract-9.smt + regress0/bv/core/extract-whole-0.smt + regress0/bv/core/extract-whole-1.smt + regress0/bv/core/extract-whole-2.smt + regress0/bv/core/extract-whole-3.smt + regress0/bv/core/extract-whole-4.smt + regress0/bv/core/slice-01.smt + regress0/bv/core/slice-02.smt + regress0/bv/core/slice-03.smt + regress0/bv/core/slice-04.smt + regress0/bv/core/slice-05.smt + regress0/bv/core/slice-06.smt + regress0/bv/core/slice-07.smt + regress0/bv/core/slice-08.smt + regress0/bv/core/slice-09.smt + regress0/bv/core/slice-10.smt + regress0/bv/core/slice-11.smt + regress0/bv/core/slice-12.smt + regress0/bv/core/slice-13.smt + regress0/bv/core/slice-14.smt + regress0/bv/core/slice-15.smt + regress0/bv/core/slice-16.smt + regress0/bv/core/slice-17.smt + regress0/bv/core/slice-18.smt + regress0/bv/core/slice-19.smt + regress0/bv/core/slice-20.smt + regress0/bv/divtest_2_5.smt2 + regress0/bv/divtest_2_6.smt2 + regress0/bv/eager-inc-cryptominisat.smt2 + regress0/bv/fuzz01.smt + regress0/bv/fuzz02.delta01.smt + regress0/bv/fuzz02.smt + regress0/bv/fuzz03.smt + regress0/bv/fuzz04.smt + regress0/bv/fuzz05.smt + regress0/bv/fuzz06.smt + regress0/bv/fuzz07.smt + regress0/bv/fuzz08.smt + regress0/bv/fuzz09.smt + regress0/bv/fuzz10.smt + regress0/bv/fuzz11.smt + regress0/bv/fuzz12.smt + regress0/bv/fuzz13.smt + regress0/bv/fuzz14.smt + regress0/bv/fuzz16.delta01.smt + regress0/bv/fuzz17.delta01.smt + regress0/bv/fuzz18.delta01.smt + regress0/bv/fuzz18.delta02.smt + regress0/bv/fuzz18.delta03.smt + regress0/bv/fuzz18.smt + regress0/bv/fuzz19.delta01.smt + regress0/bv/fuzz19.smt + regress0/bv/fuzz20.delta01.smt + regress0/bv/fuzz20.smt + regress0/bv/fuzz21.delta01.smt + regress0/bv/fuzz21.smt + regress0/bv/fuzz22.delta01.smt + regress0/bv/fuzz22.smt + regress0/bv/fuzz23.delta01.smt + regress0/bv/fuzz23.smt + regress0/bv/fuzz24.delta01.smt + regress0/bv/fuzz24.smt + regress0/bv/fuzz25.delta01.smt + regress0/bv/fuzz25.smt + regress0/bv/fuzz26.delta01.smt + regress0/bv/fuzz26.smt + regress0/bv/fuzz27.delta01.smt + regress0/bv/fuzz27.smt + regress0/bv/fuzz28.delta01.smt + regress0/bv/fuzz28.smt + regress0/bv/fuzz29.delta01.smt + regress0/bv/fuzz29.smt + regress0/bv/fuzz30.delta01.smt + regress0/bv/fuzz30.smt + regress0/bv/fuzz31.delta01.smt + regress0/bv/fuzz31.smt + regress0/bv/fuzz32.delta01.smt + regress0/bv/fuzz32.smt + regress0/bv/fuzz33.delta01.smt + regress0/bv/fuzz33.smt + regress0/bv/fuzz34.delta01.smt + regress0/bv/fuzz35.delta01.smt + regress0/bv/fuzz35.smt + regress0/bv/fuzz36.delta01.smt + regress0/bv/fuzz36.smt + regress0/bv/fuzz37.delta01.smt + regress0/bv/fuzz37.smt + regress0/bv/fuzz38.delta01.smt + regress0/bv/fuzz39.delta01.smt + regress0/bv/fuzz39.smt + regress0/bv/fuzz40.delta01.smt + regress0/bv/fuzz40.smt + regress0/bv/fuzz41.smt + regress0/bv/mul-neg-unsat.smt2 + regress0/bv/mul-negpow2.smt2 + regress0/bv/mult-pow2-negative.smt2 + regress0/bv/sizecheck.cvc + regress0/bv/smtcompbug.smt + regress0/bv/test-bv_intro_pow2.smt2 + regress0/bv/unsound1-reduced.smt2 + regress0/chained-equality.smt2 + regress0/constant-rewrite.smt + regress0/cvc3.userdoc.01.cvc + regress0/cvc3.userdoc.02.cvc + regress0/cvc3.userdoc.03.cvc + regress0/cvc3.userdoc.04.cvc + regress0/cvc3.userdoc.05.cvc + regress0/cvc3.userdoc.06.cvc + regress0/datatypes/Test1-tup-mp.cvc + regress0/datatypes/boolean-equality.cvc + regress0/datatypes/boolean-terms-datatype.cvc + regress0/datatypes/boolean-terms-parametric-datatype-1.cvc + regress0/datatypes/boolean-terms-parametric-datatype-2.cvc + regress0/datatypes/boolean-terms-record.cvc + regress0/datatypes/boolean-terms-rewrite.cvc + regress0/datatypes/boolean-terms-tuple.cvc + regress0/datatypes/bug286.cvc + regress0/datatypes/bug438.cvc + regress0/datatypes/bug438b.cvc + regress0/datatypes/bug597-rbt.smt2 + regress0/datatypes/bug604.smt2 + regress0/datatypes/bug625.smt2 + regress0/datatypes/cdt-model-cade15.smt2 + regress0/datatypes/cdt-non-canon-stream.smt2 + regress0/datatypes/coda_simp_model.smt2 + regress0/datatypes/conqueue-dt-enum-iloop.smt2 + regress0/datatypes/datatype.cvc + regress0/datatypes/datatype0.cvc + regress0/datatypes/datatype1.cvc + regress0/datatypes/datatype13.cvc + regress0/datatypes/datatype2.cvc + regress0/datatypes/datatype3.cvc + regress0/datatypes/datatype4.cvc + regress0/datatypes/dt-2.6.smt2 + regress0/datatypes/dt-match-pat-param-2.6.smt2 + regress0/datatypes/dt-param-2.6.smt2 + regress0/datatypes/dt-param-card4-bool-sat.smt2 + regress0/datatypes/dt-sel-2.6.smt2 + regress0/datatypes/empty_tuprec.cvc + regress0/datatypes/example-dailler-min.smt2 + regress0/datatypes/is_test.smt2 + regress0/datatypes/issue1433.smt2 + regress0/datatypes/jsat-2.6.smt2 + regress0/datatypes/model-subterms-min.smt2 + regress0/datatypes/mutually-recursive.cvc + regress0/datatypes/pair-bool-bool.cvc + regress0/datatypes/pair-real-bool.smt2 + regress0/datatypes/rec1.cvc + regress0/datatypes/rec2.cvc + regress0/datatypes/rec4.cvc + regress0/datatypes/rewriter.cvc + regress0/datatypes/sc-cdt1.smt2 + regress0/datatypes/some-boolean-tests.cvc + regress0/datatypes/stream-singleton.smt2 + regress0/datatypes/tenum-bug.smt2 + regress0/datatypes/tuple-model.cvc + regress0/datatypes/tuple-no-clash.cvc + regress0/datatypes/tuple-record-bug.cvc + regress0/datatypes/tuple.cvc + regress0/datatypes/tuples-empty.smt2 + regress0/datatypes/tuples-multitype.smt2 + regress0/datatypes/typed_v10l30054.cvc + regress0/datatypes/typed_v1l80005.cvc + regress0/datatypes/typed_v2l30079.cvc + regress0/datatypes/typed_v3l20092.cvc + regress0/datatypes/typed_v5l30069.cvc + regress0/datatypes/v10l40099.cvc + regress0/datatypes/v2l40025.cvc + regress0/datatypes/v3l60006.cvc + regress0/datatypes/v5l30058.cvc + regress0/datatypes/wrong-sel-simp.cvc + regress0/decision/aufbv-fuzz01.smt + regress0/decision/bitvec0.delta01.smt + regress0/decision/bitvec0.smt + regress0/decision/bitvec5.smt + regress0/decision/bug347.smt + regress0/decision/bug374a.smt + regress0/decision/bug374b.smt2 + regress0/decision/error122.delta01.smt + regress0/decision/error122.smt + regress0/decision/error20.delta01.smt + regress0/decision/error20.smt + regress0/decision/error3.delta01.smt + regress0/decision/pp-regfile.delta01.smt + regress0/decision/pp-regfile.delta02.smt + regress0/decision/quant-ex1.smt2 + regress0/decision/uflia-xs-09-16-3-4-1-5.delta03.smt + regress0/decision/wchains010ue.delta02.smt + regress0/declare-fun-is-match.smt2 + regress0/declare-funs.smt2 + regress0/distinct.smt + regress0/expect/scrub.01.smt + regress0/expect/scrub.02.smt + regress0/expect/scrub.03.smt2 + regress0/expect/scrub.04.smt2 + regress0/expect/scrub.06.cvc + regress0/expect/scrub.08.sy + regress0/expect/scrub.09.p + regress0/flet.smt + regress0/flet2.smt + regress0/fmf/Arrow_Order-smtlib.778341.smt + regress0/fmf/QEpres-uf.855035.smt + regress0/fmf/array_card.smt2 + regress0/fmf/bounded_sets.smt2 + regress0/fmf/bug-041417-set-options.cvc + regress0/fmf/bug652.smt2 + regress0/fmf/bug782.smt2 + regress0/fmf/cruanes-no-minimal-unk.smt2 + regress0/fmf/fc-simple.smt2 + regress0/fmf/fc-unsat-pent.smt2 + regress0/fmf/fc-unsat-tot-2.smt2 + regress0/fmf/fd-false.smt2 + regress0/fmf/fmc_unsound_model.smt2 + regress0/fmf/fmf-strange-bounds-2.smt2 + regress0/fmf/forall_unit_data2.smt2 + regress0/fmf/krs-sat.smt2 + regress0/fmf/no-minimal-sat.smt2 + regress0/fmf/quant_real_univ.cvc + regress0/fmf/sat-logic.smt2 + regress0/fmf/sc_bad_model_1221.smt2 + regress0/fmf/syn002-si-real-int.smt2 + regress0/fmf/tail_rec.smt2 + regress0/fp/simple.smt2 + regress0/fuzz_1.smt + regress0/fuzz_3.smt + regress0/get-value-incremental.smt2 + regress0/get-value-ints.smt2 + regress0/get-value-reals-ints.smt2 + regress0/get-value-reals.smt2 + regress0/ho/apply-collapse-sat.smt2 + regress0/ho/apply-collapse-unsat.smt2 + regress0/ho/cong-full-apply.smt2 + regress0/ho/cong.smt2 + regress0/ho/declare-fun-variants.smt2 + regress0/ho/def-fun-flatten.smt2 + regress0/ho/ext-finite-unsat.smt2 + regress0/ho/ext-ho-nested-lambda-model.smt2 + regress0/ho/ext-ho.smt2 + regress0/ho/ext-sat-partial-eval.smt2 + regress0/ho/ext-sat.smt2 + regress0/ho/finite-fun-ext.smt2 + regress0/ho/fta0144-alpha-eq.smt2 + regress0/ho/ho-match-fun-suffix.smt2 + regress0/ho/ho-matching-enum.smt2 + regress0/ho/ho-matching-nested-app.smt2 + regress0/ho/ite-apply-eq.smt2 + regress0/ho/lambda-equality-non-canon.smt2 + regress0/ho/modulo-func-equality.smt2 + regress0/ho/simple-matching-partial.smt2 + regress0/ho/simple-matching.smt2 + regress0/ho/trans.smt2 + regress0/hung10_itesdk_output1.smt2 + regress0/hung10_itesdk_output2.smt2 + regress0/hung13sdk_output1.smt2 + regress0/hung13sdk_output2.smt2 + regress0/ineq_basic.smt + regress0/ineq_slack.smt + regress0/issue1063-overloading-dt-cons.smt2 + regress0/issue1063-overloading-dt-fun.smt2 + regress0/issue1063-overloading-dt-sel.smt2 + regress0/ite.cvc + regress0/ite2.smt2 + regress0/ite3.smt2 + regress0/ite4.smt2 + regress0/ite_real_int_type.smt + regress0/ite_real_valid.smt + regress0/lang_opts_2_5.smt2 + regress0/lang_opts_2_6_1.smt2 + regress0/lemmas/clocksynchro_5clocks.main_invar.base.model.smt + regress0/lemmas/fs_not_sc_seen.induction.smt + regress0/lemmas/mode_cntrl.induction.smt + regress0/lemmas/sc_init_frame_gap.induction.smt + regress0/let.cvc + regress0/let.smt + regress0/let2.smt + regress0/logops.01.cvc + regress0/logops.02.cvc + regress0/logops.03.cvc + regress0/logops.04.cvc + regress0/logops.05.cvc + regress0/model-core.smt2 + regress0/nl/coeff-sat.smt2 + regress0/nl/magnitude-wrong-1020-m.smt2 + regress0/nl/mult-po.smt2 + regress0/nl/nia-wrong-tl.smt2 + regress0/nl/nta/cos-sig-value.smt2 + regress0/nl/nta/exp-n0.5-lb.smt2 + regress0/nl/nta/exp-n0.5-ub.smt2 + regress0/nl/nta/exp1-ub.smt2 + regress0/nl/nta/real-pi.smt2 + regress0/nl/nta/sin-sym.smt2 + regress0/nl/nta/sqrt-simple.smt2 + regress0/nl/nta/tan-rewrite.smt2 + regress0/nl/real-as-int.smt2 + regress0/nl/real-div-ufnra.smt2 + regress0/nl/subs0-unsat-confirm.smt2 + regress0/nl/very-easy-sat.smt2 + regress0/nl/very-simple-unsat.smt2 + regress0/parallel-let.smt2 + regress0/parser/as.smt2 + regress0/parser/constraint.smt2 + regress0/parser/declarefun-emptyset-uf.smt2 + regress0/parser/shadow_fun_symbol_all.smt2 + regress0/parser/shadow_fun_symbol_nirat.smt2 + regress0/parser/strings20.smt2 + regress0/parser/strings25.smt2 + regress0/precedence/and-not.cvc + regress0/precedence/and-xor.cvc + regress0/precedence/bool-cmp.cvc + regress0/precedence/cmp-plus.cvc + regress0/precedence/eq-fun.cvc + regress0/precedence/iff-assoc.cvc + regress0/precedence/iff-implies.cvc + regress0/precedence/implies-assoc.cvc + regress0/precedence/implies-iff.cvc + regress0/precedence/implies-or.cvc + regress0/precedence/not-and.cvc + regress0/precedence/not-eq.cvc + regress0/precedence/or-implies.cvc + regress0/precedence/or-xor.cvc + regress0/precedence/plus-mult.cvc + regress0/precedence/xor-and.cvc + regress0/precedence/xor-assoc.cvc + regress0/precedence/xor-or.cvc + regress0/preprocess/preprocess_00.cvc + regress0/preprocess/preprocess_01.cvc + regress0/preprocess/preprocess_02.cvc + regress0/preprocess/preprocess_03.cvc + regress0/preprocess/preprocess_04.cvc + regress0/preprocess/preprocess_05.cvc + regress0/preprocess/preprocess_06.cvc + regress0/preprocess/preprocess_07.cvc + regress0/preprocess/preprocess_08.cvc + regress0/preprocess/preprocess_09.cvc + regress0/preprocess/preprocess_10.cvc + regress0/preprocess/preprocess_11.cvc + regress0/preprocess/preprocess_12.cvc + regress0/preprocess/preprocess_13.cvc + regress0/preprocess/preprocess_14.cvc + regress0/preprocess/preprocess_15.cvc + regress0/print_lambda.cvc + regress0/push-pop/boolean/fuzz_12.smt2 + regress0/push-pop/boolean/fuzz_13.smt2 + regress0/push-pop/boolean/fuzz_14.smt2 + regress0/push-pop/boolean/fuzz_18.smt2 + regress0/push-pop/boolean/fuzz_2.smt2 + regress0/push-pop/boolean/fuzz_21.smt2 + regress0/push-pop/boolean/fuzz_22.smt2 + regress0/push-pop/boolean/fuzz_27.smt2 + regress0/push-pop/boolean/fuzz_3.smt2 + regress0/push-pop/boolean/fuzz_31.smt2 + regress0/push-pop/boolean/fuzz_33.smt2 + regress0/push-pop/boolean/fuzz_36.smt2 + regress0/push-pop/boolean/fuzz_38.smt2 + regress0/push-pop/boolean/fuzz_46.smt2 + regress0/push-pop/boolean/fuzz_47.smt2 + regress0/push-pop/boolean/fuzz_48.smt2 + regress0/push-pop/boolean/fuzz_49.smt2 + regress0/push-pop/boolean/fuzz_50.smt2 + regress0/push-pop/bug1990.smt2 + regress0/push-pop/bug233.cvc + regress0/push-pop/bug654-dd.smt2 + regress0/push-pop/bug691.smt2 + regress0/push-pop/bug821-check_sat_assuming.smt2 + regress0/push-pop/bug821.smt2 + regress0/push-pop/inc-define.smt2 + regress0/push-pop/inc-double-u.smt2 + regress0/push-pop/incremental-subst-bug.cvc + regress0/push-pop/issue1986.smt2 + regress0/push-pop/issue2137.min.smt2 + regress0/push-pop/quant-fun-proc-unfd.smt2 + regress0/push-pop/simple_unsat_cores.smt2 + regress0/push-pop/test.00.cvc + regress0/push-pop/test.01.cvc + regress0/push-pop/tiny_bug.smt2 + regress0/push-pop/units.cvc + regress0/quantifiers/ARI176e1.smt2 + regress0/quantifiers/agg-rew-test-cf.smt2 + regress0/quantifiers/agg-rew-test.smt2 + regress0/quantifiers/ari056.smt2 + regress0/quantifiers/bug269.smt2 + regress0/quantifiers/bug290.smt2 + regress0/quantifiers/bug291.smt2 + regress0/quantifiers/bug749-rounding.smt2 + regress0/quantifiers/cbqi-lia-dt-simp.smt2 + regress0/quantifiers/cegqi-nl-simp.cvc + regress0/quantifiers/cegqi-nl-sq.smt2 + regress0/quantifiers/clock-10.smt2 + regress0/quantifiers/clock-3.smt2 + regress0/quantifiers/cond-var-elim-binary.smt2 + regress0/quantifiers/delta-simp.smt2 + regress0/quantifiers/double-pattern.smt2 + regress0/quantifiers/ex3.smt2 + regress0/quantifiers/ex6.smt2 + regress0/quantifiers/floor.smt2 + regress0/quantifiers/horn-ground-pre-post.smt2 + regress0/quantifiers/is-even-pred.smt2 + regress0/quantifiers/is-int.smt2 + regress0/quantifiers/issue1805.smt2 + regress0/quantifiers/issue2031-bv-var-elim.smt2 + regress0/quantifiers/issue2033-macro-arith.smt2 + regress0/quantifiers/lra-triv-gn.smt2 + regress0/quantifiers/macros-int-real.smt2 + regress0/quantifiers/macros-real-arg.smt2 + regress0/quantifiers/matching-lia-1arg.smt2 + regress0/quantifiers/mix-complete-strat.smt2 + regress0/quantifiers/mix-match.smt2 + regress0/quantifiers/mix-simp.smt2 + regress0/quantifiers/nested-delta.smt2 + regress0/quantifiers/nested-inf.smt2 + regress0/quantifiers/partial-trigger.smt2 + regress0/quantifiers/pure_dt_cbqi.smt2 + regress0/quantifiers/qbv-inequality2.smt2 + regress0/quantifiers/qbv-simp.smt2 + regress0/quantifiers/qbv-test-invert-bvadd-neq.smt2 + regress0/quantifiers/qbv-test-invert-bvand-neq.smt2 + regress0/quantifiers/qbv-test-invert-bvand.smt2 + regress0/quantifiers/qbv-test-invert-bvashr-0-neq.smt2 + regress0/quantifiers/qbv-test-invert-bvashr-1-neq.smt2 + regress0/quantifiers/qbv-test-invert-bvlshr-0-neq.smt2 + regress0/quantifiers/qbv-test-invert-bvlshr-0.smt2 + regress0/quantifiers/qbv-test-invert-bvlshr-1-neq.smt2 + regress0/quantifiers/qbv-test-invert-bvor-neq.smt2 + regress0/quantifiers/qbv-test-invert-bvor.smt2 + regress0/quantifiers/qbv-test-invert-bvshl-0.smt2 + regress0/quantifiers/qbv-test-invert-bvult-1.smt2 + regress0/quantifiers/qbv-test-invert-bvxor-neq.smt2 + regress0/quantifiers/qbv-test-invert-bvxor.smt2 + regress0/quantifiers/qbv-test-invert-concat-0.smt2 + regress0/quantifiers/qbv-test-invert-concat-1.smt2 + regress0/quantifiers/qbv-test-invert-sign-extend.smt2 + regress0/quantifiers/qcf-rel-dom-opt.smt2 + regress0/quantifiers/rew-to-scala.smt2 + regress0/quantifiers/simp-len.smt2 + regress0/quantifiers/simp-typ-test.smt2 + regress0/queries0.cvc + regress0/rec-fun-const-parse-bug.smt2 + regress0/rels/addr_book_0.cvc + regress0/rels/atom_univ2.cvc + regress0/rels/card_transpose.cvc + regress0/rels/iden_0.cvc + regress0/rels/iden_1.cvc + regress0/rels/join-eq-u-sat.cvc + regress0/rels/join-eq-u.cvc + regress0/rels/joinImg_0.cvc + regress0/rels/oneLoc_no_quant-int_0_1.cvc + regress0/rels/rel_1tup_0.cvc + regress0/rels/rel_complex_0.cvc + regress0/rels/rel_complex_1.cvc + regress0/rels/rel_conflict_0.cvc + regress0/rels/rel_join_0.cvc + regress0/rels/rel_join_0_1.cvc + regress0/rels/rel_join_1.cvc + regress0/rels/rel_join_1_1.cvc + regress0/rels/rel_join_2.cvc + regress0/rels/rel_join_2_1.cvc + regress0/rels/rel_join_3.cvc + regress0/rels/rel_join_3_1.cvc + regress0/rels/rel_join_4.cvc + regress0/rels/rel_join_5.cvc + regress0/rels/rel_join_6.cvc + regress0/rels/rel_join_7.cvc + regress0/rels/rel_product_0.cvc + regress0/rels/rel_product_0_1.cvc + regress0/rels/rel_product_1.cvc + regress0/rels/rel_product_1_1.cvc + regress0/rels/rel_symbolic_1.cvc + regress0/rels/rel_symbolic_1_1.cvc + regress0/rels/rel_symbolic_2_1.cvc + regress0/rels/rel_symbolic_3_1.cvc + regress0/rels/rel_tc_11.cvc + regress0/rels/rel_tc_2_1.cvc + regress0/rels/rel_tc_3.cvc + regress0/rels/rel_tc_3_1.cvc + regress0/rels/rel_tc_7.cvc + regress0/rels/rel_tc_8.cvc + regress0/rels/rel_tp_3_1.cvc + regress0/rels/rel_tp_join_0.cvc + regress0/rels/rel_tp_join_1.cvc + regress0/rels/rel_tp_join_2.cvc + regress0/rels/rel_tp_join_3.cvc + regress0/rels/rel_tp_join_eq_0.cvc + regress0/rels/rel_tp_join_int_0.cvc + regress0/rels/rel_tp_join_pro_0.cvc + regress0/rels/rel_tp_join_var_0.cvc + regress0/rels/rel_transpose_0.cvc + regress0/rels/rel_transpose_1.cvc + regress0/rels/rel_transpose_1_1.cvc + regress0/rels/rel_transpose_3.cvc + regress0/rels/rel_transpose_4.cvc + regress0/rels/rel_transpose_5.cvc + regress0/rels/rel_transpose_6.cvc + regress0/rels/rel_transpose_7.cvc + regress0/rels/relations-ops.smt2 + regress0/rels/rels-sharing-simp.cvc + regress0/reset-assertions.smt2 + regress0/rewriterules/datatypes.smt2 + regress0/rewriterules/length_trick.smt2 + regress0/rewriterules/native_arrays.smt2 + regress0/rewriterules/relation.smt2 + regress0/rewriterules/simulate_rewriting.smt2 + regress0/sep/dispose-1.smt2 + regress0/sep/dup-nemp.smt2 + regress0/sep/nemp.smt2 + regress0/sep/nil-no-elim.smt2 + regress0/sep/nspatial-simp.smt2 + regress0/sep/pto-01.smt2 + regress0/sep/pto-02.smt2 + regress0/sep/sep-01.smt2 + regress0/sep/sep-plus1.smt2 + regress0/sep/sep-simp-unsat-emp.smt2 + regress0/sep/skolem_emp.smt2 + regress0/sep/trees-1.smt2 + regress0/sep/wand-crash.smt2 + regress0/sets/abt-min.smt2 + regress0/sets/abt-te-exh.smt2 + regress0/sets/abt-te-exh2.smt2 + regress0/sets/card-2.smt2 + regress0/sets/card-3sets.cvc + regress0/sets/card.smt2 + regress0/sets/card3-ground.smt2 + regress0/sets/complement.cvc + regress0/sets/complement2.cvc + regress0/sets/complement3.cvc + regress0/sets/cvc-sample.cvc + regress0/sets/dt-simp-mem.smt2 + regress0/sets/emptyset.smt2 + regress0/sets/eqtest.smt2 + regress0/sets/error1.smt2 + regress0/sets/error2.smt2 + regress0/sets/insert.smt2 + regress0/sets/int-real-univ-unsat.smt2 + regress0/sets/int-real-univ.smt2 + regress0/sets/jan24/deepmeas0.hs.fqout.cvc4.47.smt2 + regress0/sets/jan24/deepmeas0.hs.fqout.small.smt2 + regress0/sets/jan27/ListConcat.hs.fqout.177minimized.smt2 + regress0/sets/jan27/ListConcat.hs.fqout.cvc4.177.smt2 + regress0/sets/jan28/TalkingAboutSets.hs.fqout.3577minimized.smt2 + regress0/sets/jan30/UniqueZipper.hs.fqout.minimized10.smt2 + regress0/sets/jan30/UniqueZipper.hs.fqout.minimized1832.smt2 + regress0/sets/mar2014/sharing-preregister.smt2 + regress0/sets/mar2014/small.smt2 + regress0/sets/mar2014/smaller.smt2 + regress0/sets/nonvar-univ.smt2 + regress0/sets/pre-proc-univ.smt2 + regress0/sets/rec_copy_loop_check_heap_access_43_4.smt2 + regress0/sets/sets-equal.smt2 + regress0/sets/sets-inter.smt2 + regress0/sets/sets-of-sets-subtypes.smt2 + regress0/sets/sets-poly-int-real.smt2 + regress0/sets/sets-poly-nonint.smt2 + regress0/sets/sets-sample.smt2 + regress0/sets/sets-sharing.smt2 + regress0/sets/sets-testlemma.smt2 + regress0/sets/sets-union.smt2 + regress0/sets/sharing-simp.smt2 + regress0/sets/union-1a-flip.smt2 + regress0/sets/union-1a.smt2 + regress0/sets/union-1b-flip.smt2 + regress0/sets/union-1b.smt2 + regress0/sets/union-2.smt2 + regress0/sets/univset-simp.smt2 + regress0/simple-lra.smt + regress0/simple-lra.smt2 + regress0/simple-rdl.smt + regress0/simple-rdl.smt2 + regress0/simple-uf.smt + regress0/simple-uf.smt2 + regress0/simple.cvc + regress0/simple.smt + regress0/simple2.smt + regress0/simplification_bug.smt + regress0/simplification_bug2.smt + regress0/smallcnf.cvc + regress0/smt2output.smt2 + regress0/strings/bug001.smt2 + regress0/strings/bug002.smt2 + regress0/strings/bug612.smt2 + regress0/strings/bug613.smt2 + regress0/strings/code-sat-neg-one.smt2 + regress0/strings/escchar.smt2 + regress0/strings/escchar_25.smt2 + regress0/strings/idof-rewrites.smt2 + regress0/strings/idof-sem.smt2 + regress0/strings/ilc-like.smt2 + regress0/strings/indexof-sym-simp.smt2 + regress0/strings/issue1189.smt2 + regress0/strings/leadingzero001.smt2 + regress0/strings/loop001.smt2 + regress0/strings/model001.smt2 + regress0/strings/norn-31.smt2 + regress0/strings/norn-simp-rew.smt2 + regress0/strings/repl-rewrites2.smt2 + regress0/strings/rewrites-v2.smt2 + regress0/strings/std2.6.1.smt2 + regress0/strings/str003.smt2 + regress0/strings/str004.smt2 + regress0/strings/str005.smt2 + regress0/strings/strings-charat.cvc + regress0/strings/strings-native-simple.cvc + regress0/strings/strip-endpoint-itos.smt2 + regress0/strings/substr-rewrites.smt2 + regress0/strings/type001.smt2 + regress0/strings/unsound-0908.smt2 + regress0/sygus/General_plus10.sy + regress0/sygus/aig-si.sy + regress0/sygus/c100.sy + regress0/sygus/ccp16.lus.sy + regress0/sygus/check-generic-red.sy + regress0/sygus/const-var-test.sy + regress0/sygus/dt-no-syntax.sy + regress0/sygus/let-ringer.sy + regress0/sygus/let-simp.sy + regress0/sygus/no-syntax-test-bool.sy + regress0/sygus/no-syntax-test.sy + regress0/sygus/parity-AIG-d0.sy + regress0/sygus/parse-bv-let.sy + regress0/sygus/real-si-all.sy + regress0/sygus/strings-unconstrained.sy + regress0/sygus/uminus_one.sy + regress0/test11.cvc + regress0/test9.cvc + regress0/tptp/ARI086=1.p + regress0/tptp/DAT001=1.p + regress0/tptp/KRS018+1.p + regress0/tptp/KRS063+1.p + regress0/tptp/MGT019+2.p + regress0/tptp/MGT041-2.p + regress0/tptp/PUZ131_1.p + regress0/tptp/SYN000+1.p + regress0/tptp/SYN000+2.p + regress0/tptp/SYN000-1.p + regress0/tptp/SYN000-2.p + regress0/tptp/SYN000=2.p + regress0/tptp/SYN000_1.p + regress0/tptp/SYN000_2.p + regress0/tptp/SYN075-1.p + regress0/tptp/tff0-arith.p + regress0/tptp/tff0.p + regress0/tptp/tptp_parser.p + regress0/tptp/tptp_parser10.p + regress0/tptp/tptp_parser2.p + regress0/tptp/tptp_parser3.p + regress0/tptp/tptp_parser4.p + regress0/tptp/tptp_parser5.p + regress0/tptp/tptp_parser6.p + regress0/tptp/tptp_parser7.p + regress0/tptp/tptp_parser8.p + regress0/tptp/tptp_parser9.p + regress0/uf/NEQ016_size5_reduced2a.smt + regress0/uf/NEQ016_size5_reduced2b.smt + regress0/uf/bool-pred-nested.smt2 + regress0/uf/ccredesign-fuzz.smt + regress0/uf/cnf-and-neg.smt2 + regress0/uf/cnf-iff-base.smt2 + regress0/uf/cnf-iff.smt2 + regress0/uf/cnf-ite.smt2 + regress0/uf/cnf_abc.smt2 + regress0/uf/dead_dnd002.smt + regress0/uf/eq_diamond1.smt + regress0/uf/eq_diamond14.reduced.smt + regress0/uf/eq_diamond14.reduced2.smt + regress0/uf/eq_diamond23.smt + regress0/uf/euf_simp01.smt + regress0/uf/euf_simp02.smt + regress0/uf/euf_simp03.smt + regress0/uf/euf_simp04.smt + regress0/uf/euf_simp05.smt + regress0/uf/euf_simp06.smt + regress0/uf/euf_simp08.smt + regress0/uf/euf_simp09.smt + regress0/uf/euf_simp10.smt + regress0/uf/euf_simp11.smt + regress0/uf/euf_simp12.smt + regress0/uf/euf_simp13.smt + regress0/uf/iso_brn001.smt + regress0/uf/pred.smt + regress0/uf/simple.01.cvc + regress0/uf/simple.02.cvc + regress0/uf/simple.03.cvc + regress0/uf/simple.04.cvc + regress0/uf20-03.cvc + regress0/uflia/check01.smt2 + regress0/uflia/check02.smt2 + regress0/uflia/check03.smt2 + regress0/uflia/check04.smt2 + regress0/uflia/error0.delta01.smt + regress0/uflia/error1.smt + regress0/uflia/error30.smt + regress0/uflia/stalmark_e7_27_e7_31.ec.minimized.smt2 + regress0/uflia/tiny.smt2 + regress0/uflia/xs-09-16-3-4-1-5.delta01.smt + regress0/uflia/xs-09-16-3-4-1-5.delta02.smt + regress0/uflia/xs-09-16-3-4-1-5.delta03.smt + regress0/uflia/xs-09-16-3-4-1-5.delta04.smt + regress0/uflra/bug293.cvc + regress0/uflra/bug449.smt + regress0/uflra/constants0.smt + regress0/uflra/fuzz01.smt + regress0/uflra/incorrect1.delta01.smt + regress0/uflra/incorrect1.delta02.smt + regress0/uflra/neq-deltacomp.smt + regress0/uflra/pb_real_10_0100_10_10.smt + regress0/uflra/pb_real_10_0100_10_11.smt + regress0/uflra/pb_real_10_0100_10_15.smt + regress0/uflra/pb_real_10_0100_10_16.smt + regress0/uflra/pb_real_10_0100_10_19.smt + regress0/uflra/pb_real_10_0200_10_22.smt + regress0/uflra/pb_real_10_0200_10_26.smt + regress0/uflra/pb_real_10_0200_10_29.smt + regress0/uflra/simple.01.cvc + regress0/uflra/simple.02.cvc + regress0/uflra/simple.03.cvc + regress0/uflra/simple.04.cvc + regress0/unconstrained/arith.smt2 + regress0/unconstrained/arith3.smt2 + regress0/unconstrained/arith4.smt2 + regress0/unconstrained/arith5.smt2 + regress0/unconstrained/arith6.smt2 + regress0/unconstrained/array1.smt2 + regress0/unconstrained/bvbool.smt2 + regress0/unconstrained/bvbool2.smt2 + regress0/unconstrained/bvbool3.smt2 + regress0/unconstrained/bvcmp.smt2 + regress0/unconstrained/bvconcat2.smt2 + regress0/unconstrained/bvext.smt2 + regress0/unconstrained/bvite.smt2 + regress0/unconstrained/bvmul.smt2 + regress0/unconstrained/bvmul2.smt2 + regress0/unconstrained/bvmul3.smt2 + regress0/unconstrained/bvnot.smt2 + regress0/unconstrained/bvsle.smt2 + regress0/unconstrained/bvsle2.smt2 + regress0/unconstrained/bvsle3.smt2 + regress0/unconstrained/bvsle4.smt2 + regress0/unconstrained/bvsle5.smt2 + regress0/unconstrained/bvslt.smt2 + regress0/unconstrained/bvslt2.smt2 + regress0/unconstrained/bvslt3.smt2 + regress0/unconstrained/bvslt4.smt2 + regress0/unconstrained/bvslt5.smt2 + regress0/unconstrained/bvule.smt2 + regress0/unconstrained/bvule2.smt2 + regress0/unconstrained/bvule3.smt2 + regress0/unconstrained/bvule4.smt2 + regress0/unconstrained/bvule5.smt2 + regress0/unconstrained/bvult.smt2 + regress0/unconstrained/bvult2.smt2 + regress0/unconstrained/bvult3.smt2 + regress0/unconstrained/bvult4.smt2 + regress0/unconstrained/bvult5.smt2 + regress0/unconstrained/geq.smt2 + regress0/unconstrained/gt.smt2 + regress0/unconstrained/ite.smt2 + regress0/unconstrained/leq.smt2 + regress0/unconstrained/lt.smt2 + regress0/unconstrained/mult1.smt2 + regress0/unconstrained/uf1.smt2 + regress0/unconstrained/xor.smt2 + regress0/wiki.01.cvc + regress0/wiki.02.cvc + regress0/wiki.03.cvc + regress0/wiki.04.cvc + regress0/wiki.05.cvc + regress0/wiki.06.cvc + regress0/wiki.07.cvc + regress0/wiki.08.cvc + regress0/wiki.09.cvc + regress0/wiki.10.cvc + regress0/wiki.11.cvc + regress0/wiki.12.cvc + regress0/wiki.13.cvc + regress0/wiki.14.cvc + regress0/wiki.15.cvc + regress0/wiki.16.cvc + regress0/wiki.17.cvc + regress0/wiki.18.cvc + regress0/wiki.19.cvc + regress0/wiki.20.cvc + regress0/wiki.21.cvc + regress0/bv/ackermann1.smt2 + regress0/bv/ackermann2.smt2 + regress0/datatypes/data-nested-codata.smt2 + regress0/fmf/sort-infer-typed-082718.smt2 + regress0/fp/ext-rew-test.smt2 + regress0/nl/ext-rew-aggr-test.smt2 + regress0/nl/nlExtPurify-test.smt2 + regress0/quantifiers/issue2035.smt2 + regress0/smtlib/get-unsat-assumptions.smt2 + regress0/strings/rewrites-re-concat.smt2 + regress0/strings/str_unsound_ext_rew_eq.smt2 + regress0/sygus/hd-05-d1-prog-nogrammar.sy +) + +#-----------------------------------------------------------------------------# +# Regression level 1 tests + +set(regress_1_tests + regress1/arith/arith-int-004.cvc + regress1/arith/arith-int-011.cvc + regress1/arith/arith-int-012.cvc + regress1/arith/arith-int-013.cvc + regress1/arith/arith-int-022.cvc + regress1/arith/arith-int-024.cvc + regress1/arith/arith-int-047.cvc + regress1/arith/arith-int-048.cvc + regress1/arith/arith-int-050.cvc + regress1/arith/arith-int-084.cvc + regress1/arith/arith-int-085.cvc + regress1/arith/arith-int-097.cvc + regress1/arith/bug547.1.smt2 + regress1/arith/bug716.0.smt2 + regress1/arith/bug716.1.cvc + regress1/arith/div.03.smt2 + regress1/arith/div.06.smt2 + regress1/arith/div.08.smt2 + regress1/arith/div.09.smt2 + regress1/arith/miplib3.cvc + regress1/arith/mod.02.smt2 + regress1/arith/mod.03.smt2 + regress1/arith/mult.02.smt2 + regress1/arith/pbrewrites-test.smt2 + regress1/arith/problem__003.smt2 + regress1/arith/real2int-test.smt2 + regress1/arrayinuf_error.smt2 + regress1/aufbv/bug580.smt2 + regress1/aufbv/fuzz10.smt + regress1/auflia/bug330.smt2 + regress1/boolean-terms-kernel2.smt2 + regress1/boolean.cvc + regress1/bug216.smt2 + regress1/bug296.smt2 + regress1/bug425.cvc + regress1/bug507.smt2 + regress1/bug512.smt2 + regress1/bug516.smt2 + regress1/bug519.smt2 + regress1/bug520.smt2 + regress1/bug521.smt2 + regress1/bug543.smt2 + regress1/bug567.smt2 + regress1/bug593.smt2 + regress1/bug681.smt2 + regress1/bug694-Unapply1.scala-0.smt2 + regress1/bug800.smt2 + regress1/bv/bug787.smt2 + regress1/bv/bug_extract_mult_leading_bit.smt2 + regress1/bv/bv-int-collapse2-sat.smt2 + regress1/bv/bv-proof00.smt + regress1/bv/bv2nat-ground.smt2 + regress1/bv/bv2nat-simp-range-sat.smt2 + regress1/bv/bv2nat-types.smt2 + regress1/bv/cmu-rdk-3.smt2 + regress1/bv/decision-weight00.smt2 + regress1/bv/divtest.smt2 + regress1/bv/fuzz34.smt + regress1/bv/fuzz38.smt + regress1/bv/test-bv-abstraction.smt2 + regress1/bv/unsound1.smt2 + regress1/bvdiv2.smt2 + regress1/constarr3.cvc + regress1/constarr3.smt2 + regress1/datatypes/acyclicity-sr-ground096.smt2 + regress1/datatypes/dt-color-2.6.smt2 + regress1/datatypes/dt-param-card4-unsat.smt2 + regress1/datatypes/error.cvc + regress1/datatypes/manos-model.smt2 + regress1/decision/error3.smt + regress1/decision/quant-Arrays_Q1-noinfer.smt2 + regress1/decision/quant-symmetric_unsat_7.smt2 + regress1/error.cvc + regress1/errorcrash.smt2 + regress1/fmf-fun-dbu.smt2 + regress1/fmf/ALG008-1.smt2 + regress1/fmf/Hoare-z3.931718.smt + regress1/fmf/LeftistHeap.scala-8-ncm.smt2 + regress1/fmf/PUZ001+1.smt2 + regress1/fmf/agree466.smt2 + regress1/fmf/agree467.smt2 + regress1/fmf/alg202+1.smt2 + regress1/fmf/am-bad-model.cvc + regress1/fmf/bound-int-alt.smt2 + regress1/fmf/bug0909.smt2 + regress1/fmf/bug651.smt2 + regress1/fmf/bug723-irrelevant-funs.smt2 + regress1/fmf/bug764.smt2 + regress1/fmf/cons-sets-bounds.smt2 + regress1/fmf/constr-ground-to.smt2 + regress1/fmf/datatypes-ufinite-nested.smt2 + regress1/fmf/datatypes-ufinite.smt2 + regress1/fmf/dt-proper-model.smt2 + regress1/fmf/fc-pigeonhole19.smt2 + regress1/fmf/fib-core.smt2 + regress1/fmf/fmf-bound-2dim.smt2 + regress1/fmf/fmf-bound-int.smt2 + regress1/fmf/fmf-fun-divisor-pp.smt2 + regress1/fmf/fmf-fun-no-elim-ext-arith.smt2 + regress1/fmf/fmf-fun-no-elim-ext-arith2.smt2 + regress1/fmf/fmf-strange-bounds.smt2 + regress1/fmf/forall_unit_data.smt2 + regress1/fmf/fore19-exp2-core.smt2 + regress1/fmf/german169.smt2 + regress1/fmf/german73.smt2 + regress1/fmf/issue2034-preinit.smt2 + regress1/fmf/issue916-fmf-or.smt2 + regress1/fmf/jasmin-cdt-crash.smt2 + regress1/fmf/ko-bound-set.cvc + regress1/fmf/loopy_coda.smt2 + regress1/fmf/lst-no-self-rev-exp.smt2 + regress1/fmf/memory_model-R_cpp-dd.cvc + regress1/fmf/nlp042+1.smt2 + regress1/fmf/nun-0208-to.smt2 + regress1/fmf/pow2-bool.smt2 + regress1/fmf/radu-quant-set.smt2 + regress1/fmf/refcount24.cvc.smt2 + regress1/fmf/sc-crash-052316.smt2 + regress1/fmf/sort-inf-int-real.smt2 + regress1/fmf/sort-inf-int.smt2 + regress1/fmf/with-ind-104-core.smt2 + regress1/gensys_brn001.smt2 + regress1/ho/auth0068.smt2 + regress1/ho/fta0210.smt2 + regress1/ho/fta0409.smt2 + regress1/ho/ho-exponential-model.smt2 + regress1/ho/ho-matching-enum-2.smt2 + regress1/ho/ho-std-fmf.smt2 + regress1/ho/hoa0008.smt2 + regress1/ho/match-middle.smt2 + regress1/hole6.cvc + regress1/ite5.smt2 + regress1/lemmas/clocksynchro_5clocks.main_invar.base.smt + regress1/lemmas/pursuit-safety-8.smt + regress1/lemmas/simple_startup_9nodes.abstract.base.smt + regress1/nl/NAVIGATION2.smt2 + regress1/nl/approx-sqrt-unsat.smt2 + regress1/nl/approx-sqrt.smt2 + regress1/nl/arctan2-expdef.smt2 + regress1/nl/arrowsmith-050317.smt2 + regress1/nl/bad-050217.smt2 + regress1/nl/bug698.smt2 + regress1/nl/coeff-unsat-base.smt2 + regress1/nl/coeff-unsat.smt2 + regress1/nl/combine.smt2 + regress1/nl/cos-bound.smt2 + regress1/nl/cos1-tc.smt2 + regress1/nl/disj-eval.smt2 + regress1/nl/dist-big.smt2 + regress1/nl/div-mod-partial.smt2 + regress1/nl/dumortier_llibre_artes_ex_5_13.transcendental.k2.smt2 + regress1/nl/exp-4.5-lt.smt2 + regress1/nl/exp1-lb.smt2 + regress1/nl/exp_monotone.smt2 + regress1/nl/factor_agg_s.smt2 + regress1/nl/metitarski-1025.smt2 + regress1/nl/metitarski-3-4.smt2 + regress1/nl/metitarski_3_4_2e.smt2 + regress1/nl/mirko-050417.smt2 + regress1/nl/nl-eq-infer.smt2 + regress1/nl/nl-help-unsat-quant.smt2 + regress1/nl/nl-unk-quant.smt2 + regress1/nl/nl_uf_lalt.smt2 + regress1/nl/ones.smt2 + regress1/nl/poly-1025.smt2 + regress1/nl/quant-nl.smt2 + regress1/nl/red-exp.smt2 + regress1/nl/rewriting-sums.smt2 + regress1/nl/shifting.smt2 + regress1/nl/shifting2.smt2 + regress1/nl/simple-mono-unsat.smt2 + regress1/nl/simple-mono.smt2 + regress1/nl/sin-compare-across-phase.smt2 + regress1/nl/sin-compare.smt2 + regress1/nl/sin-init-tangents.smt2 + regress1/nl/sin-sign.smt2 + regress1/nl/sin-sym2.smt2 + regress1/nl/sin1-deq-sat.smt2 + regress1/nl/sin1-lb.smt2 + regress1/nl/sin1-sat.smt2 + regress1/nl/sin1-ub.smt2 + regress1/nl/sin2-lb.smt2 + regress1/nl/sin2-ub.smt2 + regress1/nl/solve-eq-small-qf-nra.smt2 + regress1/nl/sqrt-problem-1.smt2 + regress1/nl/sugar-ident-2.smt2 + regress1/nl/sugar-ident-3.smt2 + regress1/nl/sugar-ident.smt2 + regress1/nl/tan-rewrite2.smt2 + regress1/nl/zero-subset.smt2 + regress1/non-fatal-errors.smt2 + regress1/parsing_ringer.cvc + regress1/proof00.smt2 + regress1/push-pop/arith_lra_01.smt2 + regress1/push-pop/arith_lra_02.smt2 + regress1/push-pop/bug-fmf-fun-skolem.smt2 + regress1/push-pop/bug216.smt2 + regress1/push-pop/bug326.smt2 + regress1/push-pop/fuzz_1.smt2 + regress1/push-pop/fuzz_10.smt2 + regress1/push-pop/fuzz_11.smt2 + regress1/push-pop/fuzz_15.smt2 + regress1/push-pop/fuzz_16.smt2 + regress1/push-pop/fuzz_19.smt2 + regress1/push-pop/fuzz_1_to_52_merged.smt2 + regress1/push-pop/fuzz_20.smt2 + regress1/push-pop/fuzz_23.smt2 + regress1/push-pop/fuzz_24.smt2 + regress1/push-pop/fuzz_25.smt2 + regress1/push-pop/fuzz_26.smt2 + regress1/push-pop/fuzz_28.smt2 + regress1/push-pop/fuzz_29.smt2 + regress1/push-pop/fuzz_30.smt2 + regress1/push-pop/fuzz_32.smt2 + regress1/push-pop/fuzz_34.smt2 + regress1/push-pop/fuzz_35.smt2 + regress1/push-pop/fuzz_37.smt2 + regress1/push-pop/fuzz_39.smt2 + regress1/push-pop/fuzz_3_1.smt2 + regress1/push-pop/fuzz_3_10.smt2 + regress1/push-pop/fuzz_3_11.smt2 + regress1/push-pop/fuzz_3_12.smt2 + regress1/push-pop/fuzz_3_13.smt2 + regress1/push-pop/fuzz_3_14.smt2 + regress1/push-pop/fuzz_3_15.smt2 + regress1/push-pop/fuzz_3_2.smt2 + regress1/push-pop/fuzz_3_3.smt2 + regress1/push-pop/fuzz_3_4.smt2 + regress1/push-pop/fuzz_3_5.smt2 + regress1/push-pop/fuzz_3_6.smt2 + regress1/push-pop/fuzz_3_7.smt2 + regress1/push-pop/fuzz_3_8.smt2 + regress1/push-pop/fuzz_3_9.smt2 + regress1/push-pop/fuzz_4.smt2 + regress1/push-pop/fuzz_40.smt2 + regress1/push-pop/fuzz_41.smt2 + regress1/push-pop/fuzz_42.smt2 + regress1/push-pop/fuzz_43.smt2 + regress1/push-pop/fuzz_44.smt2 + regress1/push-pop/fuzz_45.smt2 + regress1/push-pop/fuzz_5.smt2 + regress1/push-pop/fuzz_51.smt2 + regress1/push-pop/fuzz_52.smt2 + regress1/push-pop/fuzz_5_1.smt2 + regress1/push-pop/fuzz_5_2.smt2 + regress1/push-pop/fuzz_5_3.smt2 + regress1/push-pop/fuzz_5_4.smt2 + regress1/push-pop/fuzz_5_5.smt2 + regress1/push-pop/fuzz_5_6.smt2 + regress1/push-pop/fuzz_6.smt2 + regress1/push-pop/fuzz_7.smt2 + regress1/push-pop/fuzz_8.smt2 + regress1/push-pop/fuzz_9.smt2 + regress1/push-pop/quant-fun-proc-unmacro.smt2 + regress1/push-pop/quant-fun-proc.smt2 + regress1/quantifiers/006-cbqi-ite.smt2 + regress1/quantifiers/015-psyco-pp.smt2 + regress1/quantifiers/AdditiveMethods_OwnedResults.Mz.smt2 + regress1/quantifiers/Arrays_Q1-noinfer.smt2 + regress1/quantifiers/NUM878.smt2 + regress1/quantifiers/RND-small.smt2 + regress1/quantifiers/RNDPRE_4_1-dd-nqe.smt2 + regress1/quantifiers/RND_4_1-existing-inst.smt2 + regress1/quantifiers/RND_4_16.smt2 + regress1/quantifiers/anti-sk-simp.smt2 + regress1/quantifiers/ari118-bv-2occ-x.smt2 + regress1/quantifiers/arith-rec-fun.smt2 + regress1/quantifiers/arith-snorm.smt2 + regress1/quantifiers/array-unsat-simp3.smt2 + regress1/quantifiers/bi-artm-s.smt2 + regress1/quantifiers/bignum_quant.smt2 + regress1/quantifiers/bug802.smt2 + regress1/quantifiers/bug822.smt2 + regress1/quantifiers/bug_743.smt2 + regress1/quantifiers/burns13.smt2 + regress1/quantifiers/burns4.smt2 + regress1/quantifiers/cbqi-sdlx-fixpoint-3-dd.smt2 + regress1/quantifiers/cdt-0208-to.smt2 + regress1/quantifiers/const.cvc + regress1/quantifiers/constfunc.cvc + regress1/quantifiers/dump-inst-i.smt2 + regress1/quantifiers/dump-inst-proof.smt2 + regress1/quantifiers/dump-inst.smt2 + regress1/quantifiers/ext-ex-deq-trigger.smt2 + regress1/quantifiers/extract-nproc.smt2 + regress1/quantifiers/florian-case-ax.smt2 + regress1/quantifiers/fp-cegqi-unsat.smt2 + regress1/quantifiers/gauss_init_0030.fof.smt2 + regress1/quantifiers/horn-simple.smt2 + regress1/quantifiers/infer-arith-trigger-eq.smt2 + regress1/quantifiers/inst-max-level-segf.smt2 + regress1/quantifiers/inst-prop-simp.smt2 + regress1/quantifiers/intersection-example-onelane.proof-node22337.smt2 + regress1/quantifiers/is-even.smt2 + regress1/quantifiers/isaplanner-goal20.smt2 + regress1/quantifiers/javafe.ast.StmtVec.009.smt2 + regress1/quantifiers/lra-vts-inf.smt2 + regress1/quantifiers/mix-coeff.smt2 + regress1/quantifiers/model_6_1_bv.smt2 + regress1/quantifiers/mutualrec2.cvc + regress1/quantifiers/nested9_true-unreach-call.i_575.smt2 + regress1/quantifiers/nl-pow-trick.smt2 + regress1/quantifiers/nra-interleave-inst.smt2 + regress1/quantifiers/opisavailable-12.smt2 + regress1/quantifiers/parametric-lists.smt2 + regress1/quantifiers/psyco-001-bv.smt2 + regress1/quantifiers/psyco-107-bv.smt2 + regress1/quantifiers/psyco-196.smt2 + regress1/quantifiers/qbv-disequality3.smt2 + regress1/quantifiers/qbv-simple-2vars-vo.smt2 + regress1/quantifiers/qbv-subcall.smt2 + regress1/quantifiers/qbv-test-invert-bvashr-0.smt2 + regress1/quantifiers/qbv-test-invert-bvashr-1.smt2 + regress1/quantifiers/qbv-test-invert-bvcomp.smt2 + regress1/quantifiers/qbv-test-invert-bvlshr-1.smt2 + regress1/quantifiers/qbv-test-invert-bvmul-neq.smt2 + regress1/quantifiers/qbv-test-invert-bvmul.smt2 + regress1/quantifiers/qbv-test-invert-bvudiv-0-neq.smt2 + regress1/quantifiers/qbv-test-invert-bvudiv-0.smt2 + regress1/quantifiers/qbv-test-invert-bvudiv-1-neq.smt2 + regress1/quantifiers/qbv-test-invert-bvudiv-1.smt2 + regress1/quantifiers/qbv-test-invert-bvurem-1-neq.smt2 + regress1/quantifiers/qbv-test-invert-bvurem-1.smt2 + regress1/quantifiers/qbv-test-urem-rewrite.smt2 + regress1/quantifiers/qcft-javafe.filespace.TreeWalker.006.smt2 + regress1/quantifiers/qcft-smtlib3dbc51.smt2 + regress1/quantifiers/qe-partial.smt2 + regress1/quantifiers/qe.smt2 + regress1/quantifiers/quant-wf-int-ind.smt2 + regress1/quantifiers/quaternion_ds1_symm_0428.fof.smt2 + regress1/quantifiers/recfact.cvc + regress1/quantifiers/repair-const-nterm.smt2 + regress1/quantifiers/rew-to-0211-dd.smt2 + regress1/quantifiers/ricart-agrawala6.smt2 + regress1/quantifiers/set-choice-koikonomou.cvc + regress1/quantifiers/set8.smt2 + regress1/quantifiers/small-pipeline-fixpoint-3.smt2 + regress1/quantifiers/smtcomp-qbv-053118.smt2 + regress1/quantifiers/smtlib384a03.smt2 + regress1/quantifiers/smtlib46f14a.smt2 + regress1/quantifiers/smtlibe99bbe.smt2 + regress1/quantifiers/smtlibf957ea.smt2 + regress1/quantifiers/stream-x2014-09-18-unsat.smt2 + regress1/quantifiers/sygus-infer-nested.smt2 + regress1/quantifiers/symmetric_unsat_7.smt2 + regress1/quantifiers/z3.620661-no-fv-trigger.smt2 + regress1/rels/addr_book_1.cvc + regress1/rels/addr_book_1_1.cvc + regress1/rels/bv1-unit.cvc + regress1/rels/bv1-unitb.cvc + regress1/rels/bv1.cvc + regress1/rels/bv1p-sat.cvc + regress1/rels/bv1p.cvc + regress1/rels/bv2.cvc + regress1/rels/iden_1_1.cvc + regress1/rels/join-eq-structure-and.cvc + regress1/rels/join-eq-structure.cvc + regress1/rels/join-eq-structure_0_1.cvc + regress1/rels/joinImg_0_1.cvc + regress1/rels/joinImg_0_2.cvc + regress1/rels/joinImg_1.cvc + regress1/rels/joinImg_1_1.cvc + regress1/rels/joinImg_2.cvc + regress1/rels/joinImg_2_1.cvc + regress1/rels/prod-mod-eq.cvc + regress1/rels/prod-mod-eq2.cvc + regress1/rels/rel_complex_3.cvc + regress1/rels/rel_complex_4.cvc + regress1/rels/rel_complex_5.cvc + regress1/rels/rel_mix_0_1.cvc + regress1/rels/rel_pressure_0.cvc + regress1/rels/rel_tc_10_1.cvc + regress1/rels/rel_tc_4.cvc + regress1/rels/rel_tc_4_1.cvc + regress1/rels/rel_tc_5_1.cvc + regress1/rels/rel_tc_6.cvc + regress1/rels/rel_tc_9_1.cvc + regress1/rels/rel_tp_2.cvc + regress1/rels/rel_tp_join_2_1.cvc + regress1/rels/set-strat.cvc + regress1/rels/strat.cvc + regress1/rels/strat_0_1.cvc + regress1/rewriterules/datatypes_sat.smt2 + regress1/rewriterules/length_gen.smt2 + regress1/rewriterules/length_gen_020.smt2 + regress1/rewriterules/length_gen_020_sat.smt2 + regress1/rewriterules/length_gen_040.smt2 + regress1/rewriterules/length_gen_040_lemma.smt2 + regress1/rewriterules/length_gen_040_lemma_trigger.smt2 + regress1/rewriterules/reachability_back_to_the_future.smt2 + regress1/rewriterules/read5.smt2 + regress1/rr-verify/bool-crci.sy + regress1/rr-verify/bv-term-32.sy + regress1/rr-verify/bv-term.sy + regress1/rr-verify/regex.sy + regress1/rr-verify/string-term.sy + regress1/sep/chain-int.smt2 + regress1/sep/crash1220.smt2 + regress1/sep/dispose-list-4-init.smt2 + regress1/sep/emp2-quant-unsat.smt2 + regress1/sep/finite-witness-sat.smt2 + regress1/sep/fmf-nemp-2.smt2 + regress1/sep/loop-1220.smt2 + regress1/sep/pto-04.smt2 + regress1/sep/quant_wand.smt2 + regress1/sep/sep-02.smt2 + regress1/sep/sep-03.smt2 + regress1/sep/sep-find2.smt2 + regress1/sep/sep-fmf-priority.smt2 + regress1/sep/sep-neg-1refine.smt2 + regress1/sep/sep-neg-nstrict.smt2 + regress1/sep/sep-neg-nstrict2.smt2 + regress1/sep/sep-neg-simple.smt2 + regress1/sep/sep-neg-swap.smt2 + regress1/sep/sep-nterm-again.smt2 + regress1/sep/sep-nterm-val-model.smt2 + regress1/sep/sep-simp-unc.smt2 + regress1/sep/simple-neg-sat.smt2 + regress1/sep/sl-standard.smt2 + regress1/sep/split-find-unsat-w-emp.smt2 + regress1/sep/split-find-unsat.smt2 + regress1/sep/wand-0526-sat.smt2 + regress1/sep/wand-false.smt2 + regress1/sep/wand-nterm-simp.smt2 + regress1/sep/wand-nterm-simp2.smt2 + regress1/sep/wand-simp-sat.smt2 + regress1/sep/wand-simp-sat2.smt2 + regress1/sep/wand-simp-unsat.smt2 + regress1/sets/ListElem.hs.fqout.cvc4.38.smt2 + regress1/sets/ListElts.hs.fqout.cvc4.317.smt2 + regress1/sets/TalkingAboutSets.hs.fqout.cvc4.3577.smt2 + regress1/sets/UniqueZipper.hs.1030minimized.cvc4.smt2 + regress1/sets/UniqueZipper.hs.1030minimized2.cvc4.smt2 + regress1/sets/UniqueZipper.hs.fqout.cvc4.10.smt2 + regress1/sets/UniqueZipper.hs.fqout.cvc4.1832.smt2 + regress1/sets/arjun-set-univ.cvc + regress1/sets/card-3.smt2 + regress1/sets/card-4.smt2 + regress1/sets/card-5.smt2 + regress1/sets/card-6.smt2 + regress1/sets/card-7.smt2 + regress1/sets/card-vc6-minimized.smt2 + regress1/sets/copy_check_heap_access_33_4.smt2 + regress1/sets/deepmeas0.hs.fqout.cvc4.41.smt2 + regress1/sets/fuzz14418.smt2 + regress1/sets/fuzz15201.smt2 + regress1/sets/fuzz31811.smt2 + regress1/sets/insert_invariant_37_2.smt2 + regress1/sets/lemmabug-ListElts317minimized.smt2 + regress1/sets/remove_check_free_31_6.smt2 + regress1/sets/sets-disequal.smt2 + regress1/sets/sets-tuple-poly.cvc + regress1/sets/sharingbug.smt2 + regress1/sets/univ-set-uf-elim.smt2 + regress1/simplification_bug4.smt2 + regress1/sqrt2-sort-inf-unk.smt2 + regress1/strings/artemis-0512-nonterm.smt2 + regress1/strings/at001.smt2 + regress1/strings/bug615.smt2 + regress1/strings/bug682.smt2 + regress1/strings/bug686dd.smt2 + regress1/strings/bug768.smt2 + regress1/strings/bug799-min.smt2 + regress1/strings/chapman150408.smt2 + regress1/strings/cmu-2db2-extf-reg.smt2 + regress1/strings/cmu-5042-0707-2.smt2 + regress1/strings/cmu-inc-nlpp-071516.smt2 + regress1/strings/cmu-substr-rw.smt2 + regress1/strings/code-sequence.smt2 + regress1/strings/crash-1019.smt2 + regress1/strings/csp-prefix-exp-bug.smt2 + regress1/strings/double-replace.smt2 + regress1/strings/fmf001.smt2 + regress1/strings/fmf002.smt2 + regress1/strings/gm-inc-071516-2.smt2 + regress1/strings/goodAI.smt2 + regress1/strings/idof-handg.smt2 + regress1/strings/idof-nconst-index.smt2 + regress1/strings/idof-neg-index.smt2 + regress1/strings/idof-triv.smt2 + regress1/strings/ilc-l-nt.smt2 + regress1/strings/issue1105.smt2 + regress1/strings/issue1684-regex.smt2 + regress1/strings/issue2060.smt2 + regress1/strings/issue2429-code.smt2 + regress1/strings/kaluza-fl.smt2 + regress1/strings/loop002.smt2 + regress1/strings/loop003.smt2 + regress1/strings/loop004.smt2 + regress1/strings/loop005.smt2 + regress1/strings/loop006.smt2 + regress1/strings/loop007.smt2 + regress1/strings/loop008.smt2 + regress1/strings/loop009.smt2 + regress1/strings/nf-ff-contains-abs.smt2 + regress1/strings/non_termination_regular_expression4.smt2 + regress1/strings/norn-13.smt2 + regress1/strings/norn-360.smt2 + regress1/strings/norn-ab.smt2 + regress1/strings/norn-nel-bug-052116.smt2 + regress1/strings/norn-simp-rew-sat.smt2 + regress1/strings/nterm-re-inter-sigma.smt2 + regress1/strings/pierre150331.smt2 + regress1/strings/policy_variable.smt2 + regress1/strings/re-elim-exact.smt2 + regress1/strings/re-unsound-080718.smt2 + regress1/strings/regexp001.smt2 + regress1/strings/regexp002.smt2 + regress1/strings/regexp003.smt2 + regress1/strings/reloop.smt2 + regress1/strings/repl-empty-sem.smt2 + regress1/strings/repl-soundness-sem.smt2 + regress1/strings/rew-020618.smt2 + regress1/strings/str-code-sat.smt2 + regress1/strings/str-code-unsat-2.smt2 + regress1/strings/str-code-unsat-3.smt2 + regress1/strings/str-code-unsat.smt2 + regress1/strings/str001.smt2 + regress1/strings/str002.smt2 + regress1/strings/str006.smt2 + regress1/strings/str007.smt2 + regress1/strings/string-unsound-sem.smt2 + regress1/strings/strings-index-empty.smt2 + regress1/strings/strings-leq-trans-unsat.smt2 + regress1/strings/strings-lt-len5.smt2 + regress1/strings/strings-lt-simple.smt2 + regress1/strings/strip-endpt-sound.smt2 + regress1/strings/substr001.smt2 + regress1/strings/type002.smt2 + regress1/strings/type003.smt2 + regress1/strings/username_checker_min.smt2 + regress1/sygus/VC22_a.sy + regress1/sygus/abv.sy + regress1/sygus/array_search_2.sy + regress1/sygus/array_search_5-Q-easy.sy + regress1/sygus/array_sum_2_5.sy + regress1/sygus/bvudiv-by-2.sy + regress1/sygus/car_3.lus.sy + regress1/sygus/cegar1.sy + regress1/sygus/cegis-unif-inv-eq-fair.sy + regress1/sygus/cegisunif-depth1.sy + regress1/sygus/cggmp.sy + regress1/sygus/clock-inc-tuple.sy + regress1/sygus/commutative-stream.sy + regress1/sygus/commutative.sy + regress1/sygus/constant-bool-si-all.sy + regress1/sygus/constant-dec-tree-bug.sy + regress1/sygus/constant-ite-bv.sy + regress1/sygus/constant.sy + regress1/sygus/crci-ssb-unk.sy + regress1/sygus/crcy-si-rcons.sy + regress1/sygus/crcy-si.sy + regress1/sygus/dt-test-ns.sy + regress1/sygus/dup-op.sy + regress1/sygus/fg_polynomial3.sy + regress1/sygus/find_sc_bvult_bvnot.sy + regress1/sygus/hd-01-d1-prog.sy + regress1/sygus/hd-19-d1-prog-dup-op.sy + regress1/sygus/hd-sdiv.sy + regress1/sygus/icfp_14.12-flip-args.sy + regress1/sygus/icfp_14.12.sy + regress1/sygus/icfp_14_12_diff_types.sy + regress1/sygus/icfp_28_10.sy + regress1/sygus/icfp_easy-ite.sy + regress1/sygus/inv-example.sy + regress1/sygus/inv-unused.sy + regress1/sygus/large-const-simp.sy + regress1/sygus/let-bug-simp.sy + regress1/sygus/list-head-x.sy + regress1/sygus/logiccell_help.sy + regress1/sygus/max.sy + regress1/sygus/max2-bv.sy + regress1/sygus/multi-fun-polynomial2.sy + regress1/sygus/nflat-fwd-3.sy + regress1/sygus/nflat-fwd.sy + regress1/sygus/nia-max-square-ns.sy + regress1/sygus/no-flat-simp.sy + regress1/sygus/no-mention.sy + regress1/sygus/parity-si-rcons.sy + regress1/sygus/pbe_multi.sy + regress1/sygus/phone-1-long.sy + regress1/sygus/planning-unif.sy + regress1/sygus/process-10-vars.sy + regress1/sygus/qe.sy + regress1/sygus/real-grammar.sy + regress1/sygus/simple-regexp.sy + regress1/sygus/stopwatch-bt.sy + regress1/sygus/strings-concat-3-args.sy + regress1/sygus/strings-double-rec.sy + regress1/sygus/strings-small.sy + regress1/sygus/strings-template-infer-unused.sy + regress1/sygus/strings-template-infer.sy + regress1/sygus/strings-trivial-simp.sy + regress1/sygus/strings-trivial-two-type.sy + regress1/sygus/strings-trivial.sy + regress1/sygus/sygus-dt.sy + regress1/sygus/sygus-lambda-fv.sy + regress1/sygus/sygus-uf-ex.sy + regress1/sygus/t8.sy + regress1/sygus/tl-type-0.sy + regress1/sygus/tl-type-4x.sy + regress1/sygus/tl-type.sy + regress1/sygus/triv-type-mismatch-si.sy + regress1/sygus/trivial-stream.sy + regress1/sygus/twolets1.sy + regress1/sygus/twolets2-orig.sy + regress1/sygus/unbdd_inv_gen_ex7.sy + regress1/sygus/unbdd_inv_gen_winf1.sy + regress1/sygus/univ_2-long-repeat.sy + regress1/sym/q-constant.smt2 + regress1/sym/q-function.smt2 + regress1/sym/qf-function.smt2 + regress1/sym/sb-wrong.smt2 + regress1/sym/sym-setAB.smt2 + regress1/sym/sym1.smt2 + regress1/sym/sym2.smt2 + regress1/sym/sym3.smt2 + regress1/sym/sym4.smt2 + regress1/sym/sym5.smt2 + regress1/sym/sym6.smt2 + regress1/sym/sym7-uf.smt2 + regress1/test12.cvc + regress1/trim.cvc + regress1/uf2.smt2 + regress1/uflia/DRAGON_11_e1_2450.ec.minimized.smt2 + regress1/uflia/FIREFLY_3_e2_2236_e7_3681.ec.core.smt2 + regress1/uflia/FIREFLY_luke_1b_e2_3049_e7_1173.ec.minimized.smt2 + regress1/uflia/microwave21.ec.minimized.smt2 + regress1/uflia/simple_cyclic2.smt2 + regress1/uflia/speed2_e8_449_e8_517.ec.smt2 + regress1/uflia/stalmark_e7_27_e7_31.ec.smt2 + regress1/wrong-qfabvfp-smtcomp2018.smt2 +) + +#-----------------------------------------------------------------------------# +# Regression level 2 tests + +set(regress_2_tests + regress2/DTP_k2_n35_c175_s15.smt2 + regress2/FIREFLY_3_e2_2236_e7_3681.ec.minimized.smt2 + regress2/GEO123+1.minimized.smt2 + regress2/arith/abz5_1400.smt + regress2/arith/lpsat-goal-9.smt2 + regress2/arith/prp-13-24.smt2 + regress2/arith/pursuit-safety-11.smt + regress2/arith/pursuit-safety-12.smt + regress2/arith/qlock-4-10-9.base.cvc.smt2 + regress2/arith/sc-7.base.cvc.smt + regress2/arith/uart-8.base.cvc.smt + regress2/auflia-fuzz06.smt + regress2/bug136.smt + regress2/bug148.smt + regress2/bug394.smt2 + regress2/bug674.smt2 + regress2/bug765.smt2 + regress2/bug812.smt2 + regress2/error0.smt2 + regress2/error1.smt + regress2/friedman_n4_i5.smt + regress2/fuzz_2.smt + regress2/hash_sat_06_19.smt2 + regress2/hash_sat_07_17.smt2 + regress2/hash_sat_09_09.smt2 + regress2/hash_sat_10_09.smt2 + regress2/hole7.cvc + regress2/hole8.cvc + regress2/instance_1444.smt + regress2/javafe.ast.StandardPrettyPrint.319_no_forall.smt2 + regress2/javafe.ast.WhileStmt.447_no_forall.smt2 + regress2/nl/siegel-nl-bases.smt2 + regress2/ooo.rf6.smt2 + regress2/ooo.tag10.smt2 + regress2/piVC_5581bd.smt2 + regress2/push-pop/DRAGON_4_e2_2799_e3_1915.lus.ic3.1.min.smt2 + regress2/quantifiers/AdditiveMethods_AdditiveMethods..ctor.smt2 + regress2/quantifiers/gn-wrong-091018.smt2 + regress2/quantifiers/javafe.ast.ArrayInit.35.smt2 + regress2/quantifiers/javafe.ast.StandardPrettyPrint.319.smt2 + regress2/quantifiers/javafe.ast.WhileStmt.447.smt2 + regress2/quantifiers/javafe.tc.CheckCompilationUnit.001.smt2 + regress2/quantifiers/javafe.tc.FlowInsensitiveChecks.682.smt2 + regress2/quantifiers/mutualrec2.cvc + regress2/quantifiers/net-policy-no-time.smt2 + regress2/quantifiers/nunchaku2309663.nun.min.smt2 + regress2/simplify.javafe.ast.ArrayInit.35_without_quantification2.smt2 + regress2/strings/cmu-dis-0707-3.smt2 + regress2/strings/cmu-disagree-0707-dd.smt2 + regress2/strings/cmu-prereg-fmf.smt2 + regress2/strings/cmu-repl-len-nterm.smt2 + regress2/strings/norn-dis-0707-3.smt2 + regress2/strings/repl-repl.smt2 + regress2/sygus/MPwL_d1s3.sy + regress2/sygus/array_sum_dd.sy + regress2/sygus/cegisunif-depth1-bv.sy + regress2/sygus/ex23.sy + regress2/sygus/icfp_easy_mt_ite.sy + regress2/sygus/inv_gen_n_c11.sy + regress2/sygus/lustre-real.sy + regress2/sygus/max2-univ.sy + regress2/sygus/mpg_guard1-dd.sy + regress2/sygus/nia-max-square.sy + regress2/sygus/no-syntax-test-no-si.sy + regress2/sygus/process-10-vars-2fun.sy + regress2/sygus/process-arg-invariance.sy + regress2/sygus/real-grammar-neg.sy + regress2/sygus/sixfuncs.sy + regress2/sygus/three.sy + regress2/sygus/vcb.sy + regress2/typed_v1l50016-simp.cvc + regress2/uflia-error0.smt2 + regress2/xs-09-16-3-4-1-5.decn.smt + regress2/xs-09-16-3-4-1-5.smt +) + +#-----------------------------------------------------------------------------# +# Regression level 3 tests + +set(regress_3_tests + regress3/bmc-ibm-1.smt + regress3/bmc-ibm-2.smt + regress3/bmc-ibm-5.smt + regress3/bmc-ibm-7.smt + regress3/eq_diamond14.smt + regress3/friedman_n6_i4.smt + regress3/hole9.cvc + regress3/incorrect1.smt + regress3/incorrect2.smt + regress3/issue2429.smt2 + regress3/pp-regfile.smt + regress3/qwh.35.405.shuffled-as.sat03-1651.smt +) + +#-----------------------------------------------------------------------------# +# Regression level 4 tests + +set(regress_4_tests + regress4/C880mul.miter.shuffled-as.sat03-348.smt + regress4/NEQ016_size5.smt + regress4/bug143.smt + regress4/comb2.shuffled-as.sat03-420.smt + regress4/hole10.cvc + regress4/instance_1151.smt +) + +#-----------------------------------------------------------------------------# +# Disabled tests, will not be run. + +set(regression_disabled_tests + regress0/arith/bug549.cvc + regress0/arith/incorrect1.smt + regress0/arith/integers/arith-int-014.cvc + regress0/arith/integers/arith-int-015.cvc + regress0/arith/integers/arith-int-021.cvc + regress0/arith/integers/arith-int-023.cvc + regress0/arith/integers/arith-int-025.cvc + regress0/arith/integers/arith-int-079.cvc + regress0/arith/integers/arith-interval.cvc + regress0/arith/miplib-opt1217--27.smt + regress0/arith/miplib-pp08a-3000.smt + regress0/arr1.smt + regress0/arr1.smt2 + regress0/arr2.smt + # regress0/aufbv/bug348 does not seem to terminate with proofs + regress0/aufbv/bug348.smt + regress0/aufbv/bug349.smt + regress0/aufbv/bug493.smt + regress0/aufbv/dubreva005ue.smt + regress0/aufbv/fifo32bc06k08.smt + regress0/aufbv/fifo32in06k08.delta01.smt + regress0/aufbv/fifo32in06k08.smt + regress0/aufbv/no_init_multi_delete14.smt + regress0/aufbv/try3_sameret_functions_fse-bfs_tac.calc_next.il.fse-bfs.smt + regress0/aufbv/wchains010ue.smt + regress0/auflia/fuzz01.smt + regress0/bug2.smt + regress0/bug374.delta01.smt + regress0/bug374.smt + regress0/bv/bug345.smt + regress0/bv/bvcomp.cvc + regress0/bv/bvsmod.smt2 + regress0/bv/core/bitvec0.delta01.smt + regress0/bv/core/bitvec1.smt + regress0/bv/core/bitvec3.smt + regress0/bv/core/bv_eq_diamond11.smt + regress0/bv/core/bv_eq_diamond12.smt + regress0/bv/core/bv_eq_diamond13.smt + regress0/bv/core/bv_eq_diamond14.smt + regress0/bv/core/bv_eq_diamond15.smt + regress0/bv/core/bv_eq_diamond16.smt + regress0/bv/core/bv_eq_diamond17.smt + regress0/bv/core/concat-merge-0.cvc + regress0/bv/core/concat-merge-1.cvc + regress0/bv/core/concat-merge-2.cvc + regress0/bv/core/concat-merge-3.cvc + regress0/bv/core/constant_core.smt2 + regress0/bv/core/equality-00.cvc + regress0/bv/core/equality-01.cvc + regress0/bv/core/equality-02.cvc + regress0/bv/core/equality-03.cvc + regress0/bv/core/equality-03.smt + regress0/bv/core/equality-04.smt + regress0/bv/core/equality-05.smt + regress0/bv/core/ext_con_004_001_1024.smt + regress0/bv/core/extract-concat-0.cvc + regress0/bv/core/extract-concat-1.cvc + regress0/bv/core/extract-concat-10.cvc + regress0/bv/core/extract-concat-11.cvc + regress0/bv/core/extract-concat-2.cvc + regress0/bv/core/extract-concat-3.cvc + regress0/bv/core/extract-concat-4.cvc + regress0/bv/core/extract-concat-5.cvc + regress0/bv/core/extract-concat-6.cvc + regress0/bv/core/extract-concat-7.cvc + regress0/bv/core/extract-concat-8.cvc + regress0/bv/core/extract-concat-9.cvc + regress0/bv/core/extract-constant.cvc + regress0/bv/core/extract-extract-0.cvc + regress0/bv/core/extract-extract-1.cvc + regress0/bv/core/extract-extract-10.cvc + regress0/bv/core/extract-extract-11.cvc + regress0/bv/core/extract-extract-2.cvc + regress0/bv/core/extract-extract-3.cvc + regress0/bv/core/extract-extract-4.cvc + regress0/bv/core/extract-extract-5.cvc + regress0/bv/core/extract-extract-6.cvc + regress0/bv/core/extract-extract-7.cvc + regress0/bv/core/extract-extract-8.cvc + regress0/bv/core/extract-extract-9.cvc + regress0/bv/core/extract-whole-0.cvc + regress0/bv/core/extract-whole-1.cvc + regress0/bv/core/extract-whole-2.cvc + regress0/bv/core/extract-whole-3.cvc + regress0/bv/core/extract-whole-4.cvc + regress0/bv/core/incremental.smt + regress0/bv/core/slice-01.cvc + regress0/bv/core/slice-02.cvc + regress0/bv/core/slice-03.cvc + regress0/bv/core/slice-04.cvc + regress0/bv/core/slice-05.cvc + regress0/bv/core/slice-06.cvc + regress0/bv/core/slice-07.cvc + regress0/bv/core/slice-08.cvc + regress0/bv/core/slice-09.cvc + regress0/bv/core/slice-10.cvc + regress0/bv/core/slice-11.cvc + regress0/bv/core/slice-12.cvc + regress0/bv/core/slice-13.cvc + regress0/bv/core/slice-14.cvc + regress0/bv/core/slice-15.cvc + regress0/bv/core/slice-16.cvc + regress0/bv/core/slice-17.cvc + regress0/bv/core/slice-18.cvc + regress0/bv/core/slice-19.cvc + regress0/bv/core/slice-20.cvc + regress0/bv/fuzz07-delta.smt + # Proof checking takes too long. Add this back. FIXME + regress0/bv/fuzz15.delta01.smt + ### + regress0/bv/fuzz15.smt + regress0/bv/fuzz16.smt + regress0/bv/fuzz17.smt + regress0/bv/incorrect1.delta01.smt + regress0/bv/incorrect1.smt + regress0/bv/inequality00.smt2 + regress0/bv/inequality01.smt2 + regress0/bv/inequality02.smt2 + regress0/bv/inequality03.smt2 + regress0/bv/inequality04.smt2 + regress0/bv/inequality05.smt2 + regress0/bv/test00.smt + regress0/cvc3-bug15.cvc + # regress0/datatypes/datatype-dump.cvc (FIXME #1649) + regress0/datatypes/datatype-dump.cvc + regress0/decision/uflia-xs-09-16-3-4-1-5.smt + regress0/decision/wchains010ue.smt + regress0/incorrect1.smt + regress0/ite.smt2 + regress0/ite_arith.smt2 + regress0/lemmas/fischer3-mutex-16.smt + regress0/nl/all-logic.smt2 + regress0/quantifiers/qbv-multi-lit-uge.smt2 + regress0/quantifiers/qbv-test-invert-bvshl-0-neq.smt2 + regress0/quantifiers/qbv-test-invert-concat-0-neq.smt2 + regress0/quantifiers/qbv-test-invert-concat-1-neq.smt2 + regress0/rewriterules/datatypes_clark.smt2 + regress0/rewriterules/length.smt2 + regress0/rewriterules/length_gen_n.smt2 + regress0/rewriterules/length_gen_n_lemma.smt2 + regress0/rewriterules/length_trick2.smt2 + regress0/rewriterules/native_datatypes.smt2 + regress0/sets/mar2014/stacks0.hs.78.cvc4.smt2 + regress0/sets/setel-eq.smt2 + regress0/sets/sets-new.smt2 + regress0/sets/sets-testlemma-ints.smt2 + regress0/sets/sets-testlemma-reals.smt2 + regress0/sygus/sygus-uf.sy + regress0/symmetric.smt + regress0/tptp/BOO003-4.p + regress0/tptp/BOO027-1.p + regress0/tptp/MGT031-1.p + regress0/tptp/NLP114-1.p + regress0/tptp/SYN075+1.p + regress0/uf/PEQ018_size4.smt + regress0/uf/SEQ032_size2.smt + regress0/uf/iso_icl_repgen004.smt + regress0/uflia/diseqprop.01.smt + regress0/uflia/diseqprop.02.smt + regress0/uflia/diseqprop.03.smt + regress0/uflia/diseqprop.04.smt + regress0/uflia/diseqprop.05.smt + regress0/uflia/diseqprop.06.smt + regress0/uflia/xs-09-16-3-4-1-5.delta05.smt + regress0/uflra/pb_real_10_0200_10_25.smt + regress0/uflra/pb_real_10_0200_10_27.smt + # dejan: disabled these because it's mixed arithmetic and it doesn't go + # well when changing theoryof: + regress0/unconstrained/arith2.smt2 + regress0/unconstrained/arith7.smt2 + ### + # lianah: disabled these as the unconstrained terms are no longer + # recognized after implementing the divide-by-zero semantics for bv division: + regress0/unconstrained/bvconcat.smt2 + regress0/unconstrained/bvdiv.smt + ### + regress1/arith/arith-int-001.cvc + regress1/arith/arith-int-002.cvc + regress1/arith/arith-int-003.cvc + regress1/arith/arith-int-005.cvc + regress1/arith/arith-int-006.cvc + regress1/arith/arith-int-007.cvc + regress1/arith/arith-int-008.cvc + regress1/arith/arith-int-009.cvc + regress1/arith/arith-int-010.cvc + regress1/arith/arith-int-016.cvc + regress1/arith/arith-int-017.cvc + regress1/arith/arith-int-018.cvc + regress1/arith/arith-int-019.cvc + regress1/arith/arith-int-020.cvc + regress1/arith/arith-int-026.cvc + regress1/arith/arith-int-027.cvc + regress1/arith/arith-int-028.cvc + regress1/arith/arith-int-029.cvc + regress1/arith/arith-int-030.cvc + regress1/arith/arith-int-031.cvc + regress1/arith/arith-int-032.cvc + regress1/arith/arith-int-033.cvc + regress1/arith/arith-int-034.cvc + regress1/arith/arith-int-035.cvc + regress1/arith/arith-int-036.cvc + regress1/arith/arith-int-037.cvc + regress1/arith/arith-int-038.cvc + regress1/arith/arith-int-039.cvc + regress1/arith/arith-int-040.cvc + regress1/arith/arith-int-041.cvc + regress1/arith/arith-int-043.cvc + regress1/arith/arith-int-044.cvc + regress1/arith/arith-int-045.cvc + regress1/arith/arith-int-046.cvc + regress1/arith/arith-int-049.cvc + regress1/arith/arith-int-051.cvc + regress1/arith/arith-int-052.cvc + regress1/arith/arith-int-053.cvc + regress1/arith/arith-int-054.cvc + regress1/arith/arith-int-055.cvc + regress1/arith/arith-int-056.cvc + regress1/arith/arith-int-057.cvc + regress1/arith/arith-int-058.cvc + regress1/arith/arith-int-059.cvc + regress1/arith/arith-int-060.cvc + regress1/arith/arith-int-061.cvc + regress1/arith/arith-int-062.cvc + regress1/arith/arith-int-063.cvc + regress1/arith/arith-int-064.cvc + regress1/arith/arith-int-065.cvc + regress1/arith/arith-int-066.cvc + regress1/arith/arith-int-067.cvc + regress1/arith/arith-int-068.cvc + regress1/arith/arith-int-069.cvc + regress1/arith/arith-int-070.cvc + regress1/arith/arith-int-071.cvc + regress1/arith/arith-int-072.cvc + regress1/arith/arith-int-073.cvc + regress1/arith/arith-int-074.cvc + regress1/arith/arith-int-075.cvc + regress1/arith/arith-int-076.cvc + regress1/arith/arith-int-077.cvc + regress1/arith/arith-int-078.cvc + regress1/arith/arith-int-080.cvc + regress1/arith/arith-int-081.cvc + regress1/arith/arith-int-082.cvc + regress1/arith/arith-int-083.cvc + regress1/arith/arith-int-086.cvc + regress1/arith/arith-int-087.cvc + regress1/arith/arith-int-088.cvc + regress1/arith/arith-int-089.cvc + regress1/arith/arith-int-090.cvc + regress1/arith/arith-int-091.cvc + regress1/arith/arith-int-092.cvc + regress1/arith/arith-int-093.cvc + regress1/arith/arith-int-094.cvc + regress1/arith/arith-int-095.cvc + regress1/arith/arith-int-096.cvc + regress1/arith/arith-int-099.cvc + regress1/arith/arith-int-100.cvc + regress1/auflia/bug337.smt2 + regress1/bug472.smt2 + regress1/bug585.cvc + regress1/bug590.smt2 + regress1/bv/bench_38.delta.smt2 + regress1/crash_burn_locusts.smt2 + # regress1/ho/hoa0102.smt2 results in an assertion failure (see issue #1650). + regress1/ho/hoa0102.smt2 + # issue1048-arrays-int-real.smt2 -- different errors on debug and production. + regress1/issue1048-arrays-int-real.smt2 + # ajreynol: disabled these since they give different error messages on + # production and debug: + regress1/quantifiers/macro-subtype-param.smt2 + regress1/quantifiers/subtype-param-unk.smt2 + regress1/quantifiers/subtype-param.smt2 + ### + # regress1/quantifiers/set3.smt2 does not terminate/takes a long time when + # doing a coverage build with LFSC. + regress1/quantifiers/set3.smt2 + regress1/rels/garbage_collect.cvc + regress1/rewriterules/datatypes2.smt2 + regress1/rewriterules/datatypes3.smt2 + regress1/rewriterules/datatypes_clark_quantification.smt2 + regress1/rewriterules/length_gen_010.smt2 + regress1/rewriterules/length_gen_010_lemma.smt2 + regress1/rewriterules/length_gen_080.smt2 + regress1/rewriterules/length_gen_160_lemma.smt2 + regress1/rewriterules/length_gen_inv_160.smt2 + regress1/rewriterules/length_trick3.smt2 + regress1/rewriterules/length_trick3_int.smt2 + regress1/rewriterules/set_A_new_fast_tableau-base.smt2 + regress1/rewriterules/set_A_new_fast_tableau-base_sat.smt2 + regress1/rewriterules/test_guards.smt2 + regress1/rewriterules/why3_vstte10_max_sum_harness2.smt2 + regress1/sets/setofsets-disequal.smt2 + regress1/simple-rdl-definefun.smt2 + regress1/sygus/Base16_1.sy + regress1/sygus/enum-test.sy + regress1/sygus/inv_gen_fig8.sy + regress2/arith/arith-int-098.cvc + regress2/arith/miplib-opt1217--27.smt2 + regress2/arith/miplib-pp08a-3000.smt2 + regress2/bug396.smt2 + regress2/nl/dumortier-050317.smt2 + regress2/nl/nt-lemmas-bad.smt2 + regress2/quantifiers/ForElimination-scala-9.smt2 + regress2/quantifiers/small-bug1-fixpoint-3.smt2 + regress2/xs-11-20-5-2-5-3.smt + regress2/xs-11-20-5-2-5-3.smt2 +) + +#-----------------------------------------------------------------------------# +# Add target 'regress', builds and runs +# > regression tests of levels 0 and 1 + +get_target_property(path_to_cvc4 cvc4-bin RUNTIME_OUTPUT_DIRECTORY) +set(run_regress_script ${CMAKE_CURRENT_LIST_DIR}/run_regression.py) + +add_custom_target(regress + COMMAND + ctest --output-on-failure -L "regress[0-1]" -j${CTEST_NTHREADS} $(ARGS) + DEPENDS cvc4-bin) + +macro(cvc4_add_regression_test level file) + add_test(${file} + ${run_regress_script} + ${RUN_REGRESSION_ARGS} + ${path_to_cvc4}/cvc4 ${CMAKE_CURRENT_LIST_DIR}/${file}) + set_tests_properties(${file} PROPERTIES LABELS "regress${level}") +endmacro() + +foreach(file ${regress_0_tests}) + cvc4_add_regression_test(0 ${file}) +endforeach() + +foreach(file ${regress_1_tests}) + cvc4_add_regression_test(1 ${file}) +endforeach() + +foreach(file ${regress_2_tests}) + cvc4_add_regression_test(2 ${file}) +endforeach() + +foreach(file ${regress_3_tests}) + cvc4_add_regression_test(3 ${file}) +endforeach() + +foreach(file ${regress_4_tests}) + cvc4_add_regression_test(4 ${file}) +endforeach() diff --git a/test/regress/regress0/quantifiers/qarray-sel-over-store.smt2 b/test/regress/regress0/quantifiers/qarray-sel-over-store.smt2 new file mode 100644 index 000000000..f7e5a3a04 --- /dev/null +++ b/test/regress/regress0/quantifiers/qarray-sel-over-store.smt2 @@ -0,0 +1,32 @@ +; EXPECT: unsat +(set-logic AUFBV) +(set-info :status unsat) +(set-info :category "crafted") +(declare-sort Element 0) + +(declare-fun a1 () (Array (_ BitVec 8) Element)) +(declare-fun a2 () (Array (_ BitVec 8) Element)) +(declare-fun a3 () (Array (_ BitVec 8) Element)) +(declare-fun a4 () (Array (_ BitVec 8) Element)) + +(declare-fun i2 () (_ BitVec 8)) +(declare-fun i3 () (_ BitVec 8)) + +(declare-fun e1 () Element) +(declare-fun e2 () Element) + +(assert (not (= e1 e2))) +(assert (= a3 (store a1 (_ bv3 8) e1))) +(assert (= a4 (store a2 (_ bv3 8) e1))) +(assert (= (select a3 (_ bv2 8)) e1)) +(assert (= (select a4 (_ bv2 8)) e2)) + +; (assert (eqrange a3 a4 (_ bv0 8) (_ bv2 8))) + +(assert (forall ((x (_ BitVec 8))) + (=> (and (bvule (_ bv0 8) x) (bvule x (_ bv2 8))) (= (select a3 x) (select a4 x))) + )) + + +(check-sat) +(exit) diff --git a/test/regress/regress2/strings/cmu-disagree-0707-dd.smt2 b/test/regress/regress2/strings/cmu-disagree-0707-dd.smt2 index c44dfa396..140c7c659 100644 --- a/test/regress/regress2/strings/cmu-disagree-0707-dd.smt2 +++ b/test/regress/regress2/strings/cmu-disagree-0707-dd.smt2 @@ -1,6 +1,8 @@ (set-logic ALL_SUPPORTED) (set-info :status sat) (set-option :strings-exp true) +(set-option :strings-fmf true) + (declare-fun url () String) diff --git a/test/system/CMakeLists.txt b/test/system/CMakeLists.txt new file mode 100644 index 000000000..1832217c3 --- /dev/null +++ b/test/system/CMakeLists.txt @@ -0,0 +1,36 @@ +include_directories(.) +include_directories(${PROJECT_SOURCE_DIR}/src) +include_directories(${PROJECT_SOURCE_DIR}/src/include) +include_directories(${CMAKE_BINARY_DIR}/src) + +#-----------------------------------------------------------------------------# +# Add target 'systemtests', builds and runs +# > system tests + +add_custom_target(systemtests + COMMAND ctest --output-on-failure -L "system" -j${CTEST_NTHREADS} $(ARGS) + DEPENDS main-test) + +set(CVC4_SYSTEM_TEST_FLAGS + -D__BUILDING_CVC4_SYSTEM_TEST -D__STDC_LIMIT_MACROS -D__STDC_FORMAT_MACROS) + +macro(cvc4_add_system_test name) + add_executable(${name} ${name}.cpp) + target_link_libraries(${name} main-test) + target_compile_definitions(${name} PRIVATE ${CVC4_SYSTEM_TEST_FLAGS}) + add_test(system/${name} ${CMAKE_CURRENT_BINARY_DIR}/${name}) + set_tests_properties(system/${name} PROPERTIES LABELS "system") + add_dependencies(systemtests ${name}) + if(ENABLE_COVERAGE) + add_dependencies(coverage ${name}) + endif() +endmacro() + +cvc4_add_system_test(boilerplate) +cvc4_add_system_test(ouroborous) +cvc4_add_system_test(reset_assertions) +cvc4_add_system_test(sep_log_api) +cvc4_add_system_test(smt2_compliance) +cvc4_add_system_test(statistics) +cvc4_add_system_test(two_smt_engines) +# TODO: Move CVC4JavaTest.java to test/java and delete run_java_test (after full cmake migration) diff --git a/test/unit/CMakeLists.txt b/test/unit/CMakeLists.txt new file mode 100644 index 000000000..3d1007929 --- /dev/null +++ b/test/unit/CMakeLists.txt @@ -0,0 +1,84 @@ +include_directories(.) +include_directories(${PROJECT_SOURCE_DIR}/src) +include_directories(${PROJECT_SOURCE_DIR}/src/include) +include_directories(${CMAKE_BINARY_DIR}/src) + +#-----------------------------------------------------------------------------# +# Add target 'units', builds and runs +# > unit tests + +add_custom_target(units + COMMAND ctest --output-on-failure -L "unit" -j${CTEST_NTHREADS} $(ARGS)) + +set(CVC4_CXXTEST_FLAGS_BLACK + -D__BUILDING_CVC4LIB_UNIT_TEST -D__BUILDING_CVC4PARSERLIB_UNIT_TEST + -D__STDC_LIMIT_MACROS -D__STDC_FORMAT_MACROS) +set(CVC4_CXXTEST_FLAGS_WHITE -fno-access-control ${CVC4_CXXTEST_FLAGS_BLACK}) + +# Generate and add unit test. +# Note: we do not use cxxtest_add_test from the FindCxxTest module since it +# does not allow test names containing '/'. +macro(cvc4_add_unit_test is_white name output_dir) + # generate the test sources + set(test_src ${CMAKE_CURRENT_BINARY_DIR}/${name}.cpp) + set(test_header ${CMAKE_CURRENT_LIST_DIR}/${name}.h) + add_custom_command( + OUTPUT ${test_src} + DEPENDS ${test_header} + COMMAND + ${CXXTEST_TESTGEN_INTERPRETER} + ${CXXTEST_TESTGEN_EXECUTABLE} + ${CXXTEST_TESTGEN_ARGS} -o ${test_src} ${test_header} + ) + set_source_files_properties(${test_src} PROPERTIES GENERATED true) + # The build target is created without the path prefix (not supported), + # e.g., for '<output_dir>/myunittest.h' + # we generate '${CMAKE_BINAR_DIR}/test/unit/<output_dir>/myunittest.cpp', + # create build target 'myunittest' + # and build it with 'make myunittest'. + # As a consequence, all build target names must be globally unique. + add_executable(${name} ${test_src} ${test_header}) + target_link_libraries(${name} main-test) + target_compile_definitions(${name} PRIVATE ${CVC4_CXXTEST_FLAGS_BLACK}) + if(${is_white}) + target_compile_options(${name} PRIVATE -fno-access-control) + endif() + # Disable the Wsuggest-override warnings for the unit tests. CxxTest generates + # code that does not properly add the override keyword to runTest(). + target_compile_options(${name} PRIVATE -Wno-suggest-override) + add_dependencies(units ${name}) + # Generate into bin/test/unit/<output_dir>. + set(test_bin_dir ${CMAKE_BINARY_DIR}/bin/test/unit/${output_dir}) + set_target_properties(${name} + PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${test_bin_dir}) + # The test target is prefixed with test identifier 'unit/' and the path, + # e.g., for '<output_dir>/myunittest.h' + # we create test target 'unit/<output_dir>/myunittest' + # and run it with 'ctest -R "example/<output_dir>/myunittest"'. + if("${output_dir}" STREQUAL "") + set(test_name unit/${name}) + else() + set(test_name unit/${output_dir}/${name}) + endif() + add_test(${test_name} ${test_bin_dir}/${name}) + set_tests_properties(${test_name} PROPERTIES LABELS "unit") + if(ENABLE_COVERAGE) + add_dependencies(coverage ${name}) + endif() +endmacro() + +macro(cvc4_add_unit_test_black name output_dir) + cvc4_add_unit_test(FALSE ${name} ${output_dir}) +endmacro() +macro(cvc4_add_unit_test_white name output_dir) + cvc4_add_unit_test(TRUE ${name} ${output_dir}) +endmacro() + +add_subdirectory(base) +add_subdirectory(context) +add_subdirectory(expr) +add_subdirectory(main) +add_subdirectory(parser) +add_subdirectory(prop) +add_subdirectory(theory) +add_subdirectory(util) diff --git a/test/unit/base/CMakeLists.txt b/test/unit/base/CMakeLists.txt new file mode 100644 index 000000000..0a308b7a9 --- /dev/null +++ b/test/unit/base/CMakeLists.txt @@ -0,0 +1,4 @@ +#-----------------------------------------------------------------------------# +# Add unit tests + +cvc4_add_unit_test_black(map_util_black base) diff --git a/test/unit/context/CMakeLists.txt b/test/unit/context/CMakeLists.txt new file mode 100644 index 000000000..f089ac5f3 --- /dev/null +++ b/test/unit/context/CMakeLists.txt @@ -0,0 +1,10 @@ +#-----------------------------------------------------------------------------# +# Add unit tests + +cvc4_add_unit_test_black(cdlist_black context) +cvc4_add_unit_test_black(cdmap_black context) +cvc4_add_unit_test_white(cdmap_white context) +cvc4_add_unit_test_black(cdo_black context) +cvc4_add_unit_test_black(context_black context) +cvc4_add_unit_test_black(context_mm_black context) +cvc4_add_unit_test_white(context_white context) diff --git a/test/unit/expr/CMakeLists.txt b/test/unit/expr/CMakeLists.txt new file mode 100644 index 000000000..575268cae --- /dev/null +++ b/test/unit/expr/CMakeLists.txt @@ -0,0 +1,18 @@ +#-----------------------------------------------------------------------------# +# Add unit tests + +cvc4_add_unit_test_black(attribute_black expr) +cvc4_add_unit_test_white(attribute_white expr) +cvc4_add_unit_test_black(expr_manager_public expr) +cvc4_add_unit_test_black(expr_public expr) +cvc4_add_unit_test_black(kind_black expr) +cvc4_add_unit_test_black(kind_map_black expr) +cvc4_add_unit_test_black(node_black expr) +cvc4_add_unit_test_black(node_builder_black expr) +cvc4_add_unit_test_black(node_manager_black expr) +cvc4_add_unit_test_white(node_manager_white expr) +cvc4_add_unit_test_black(node_self_iterator_black expr) +cvc4_add_unit_test_white(node_white expr) +cvc4_add_unit_test_black(symbol_table_black expr) +cvc4_add_unit_test_black(type_cardinality_public expr) +cvc4_add_unit_test_white(type_node_white expr) diff --git a/test/unit/main/CMakeLists.txt b/test/unit/main/CMakeLists.txt new file mode 100644 index 000000000..7dbd01bd2 --- /dev/null +++ b/test/unit/main/CMakeLists.txt @@ -0,0 +1,4 @@ +#-----------------------------------------------------------------------------# +# Add unit tests + +cvc4_add_unit_test_black(interactive_shell_black main) diff --git a/test/unit/parser/CMakeLists.txt b/test/unit/parser/CMakeLists.txt new file mode 100644 index 000000000..37204f0c3 --- /dev/null +++ b/test/unit/parser/CMakeLists.txt @@ -0,0 +1,5 @@ +#-----------------------------------------------------------------------------# +# Add unit tests + +cvc4_add_unit_test_black(parser_black parser) +cvc4_add_unit_test_black(parser_builder_black parser) diff --git a/test/unit/preprocessing/CMakeLists.txt b/test/unit/preprocessing/CMakeLists.txt new file mode 100644 index 000000000..5f8a79055 --- /dev/null +++ b/test/unit/preprocessing/CMakeLists.txt @@ -0,0 +1,4 @@ +#-----------------------------------------------------------------------------# +# Add unit tests + +cvc4_add_unit_test_white(pass_bv_gauss_white) diff --git a/test/unit/prop/CMakeLists.txt b/test/unit/prop/CMakeLists.txt new file mode 100644 index 000000000..dbb6de01d --- /dev/null +++ b/test/unit/prop/CMakeLists.txt @@ -0,0 +1,4 @@ +#-----------------------------------------------------------------------------# +# Add unit tests + +cvc4_add_unit_test_white(cnf_stream_white prop) diff --git a/test/unit/theory/CMakeLists.txt b/test/unit/theory/CMakeLists.txt new file mode 100644 index 000000000..a5a67cfa2 --- /dev/null +++ b/test/unit/theory/CMakeLists.txt @@ -0,0 +1,11 @@ +cvc4_add_unit_test_white(evaluator_white theory) +cvc4_add_unit_test_white(logic_info_white theory) +cvc4_add_unit_test_white(theory_arith_white theory) +cvc4_add_unit_test_black(theory_black theory) +cvc4_add_unit_test_white(theory_bv_white theory) +cvc4_add_unit_test_white(theory_engine_white theory) +cvc4_add_unit_test_white(theory_quantifiers_bv_instantiator_white theory) +cvc4_add_unit_test_white(theory_quantifiers_bv_inverter_white theory) +cvc4_add_unit_test_white(theory_strings_rewriter_white theory) +cvc4_add_unit_test_white(theory_white theory) +cvc4_add_unit_test_white(type_enumerator_white theory) diff --git a/test/unit/theory/theory_strings_rewriter_white.h b/test/unit/theory/theory_strings_rewriter_white.h index 99abdb5a4..0b569394d 100644 --- a/test/unit/theory/theory_strings_rewriter_white.h +++ b/test/unit/theory/theory_strings_rewriter_white.h @@ -18,24 +18,23 @@ #include "expr/node_manager.h" #include "smt/smt_engine.h" #include "smt/smt_engine_scope.h" +#include "theory/quantifiers/extended_rewrite.h" #include "theory/rewriter.h" #include "theory/strings/theory_strings_rewriter.h" #include <cxxtest/TestSuite.h> +#include <iostream> +#include <memory> #include <vector> using namespace CVC4; using namespace CVC4::smt; using namespace CVC4::theory; +using namespace CVC4::theory::quantifiers; using namespace CVC4::theory::strings; class TheoryStringsRewriterWhite : public CxxTest::TestSuite { - ExprManager *d_em; - NodeManager *d_nm; - SmtEngine *d_smt; - SmtScope *d_scope; - public: TheoryStringsRewriterWhite() {} @@ -44,18 +43,43 @@ class TheoryStringsRewriterWhite : public CxxTest::TestSuite Options opts; opts.setOutputLanguage(language::output::LANG_SMTLIB_V2); d_em = new ExprManager(opts); - d_nm = NodeManager::fromExprManager(d_em); d_smt = new SmtEngine(d_em); d_scope = new SmtScope(d_smt); + d_rewriter = new ExtendedRewriter(true); + + d_nm = NodeManager::currentNM(); } void tearDown() override { + delete d_rewriter; delete d_scope; delete d_smt; delete d_em; } + void sameNormalForm(Node t1, Node t2) + { + Node res_t1 = d_rewriter->extendedRewrite(t1); + Node res_t2 = d_rewriter->extendedRewrite(t2); + + std::cout << std::endl; + std::cout << t1 << " ---> " << res_t1 << std::endl; + std::cout << t2 << " ---> " << res_t2 << std::endl; + TS_ASSERT_EQUALS(res_t1, res_t2); + } + + void differentNormalForms(Node t1, Node t2) + { + Node res_t1 = d_rewriter->extendedRewrite(t1); + Node res_t2 = d_rewriter->extendedRewrite(t2); + + std::cout << std::endl; + std::cout << t1 << " ---> " << res_t1 << std::endl; + std::cout << t2 << " ---> " << res_t2 << std::endl; + TS_ASSERT_DIFFERS(res_t1, res_t2); + } + void testCheckEntailArithWithAssumption() { TypeNode intType = d_nm->integerType(); @@ -199,9 +223,7 @@ class TheoryStringsRewriterWhite : public CxxTest::TestSuite Node repl_a_x_e = d_nm->mkNode(kind::STRING_STRREPL, a, x, empty); Node repl_a = d_nm->mkNode(kind::STRING_CONCAT, repl_a_x_e, a); Node a_repl = d_nm->mkNode(kind::STRING_CONCAT, a, repl_a_x_e); - Node res_repl_a = Rewriter::rewrite(repl_a); - Node res_a_repl = Rewriter::rewrite(a_repl); - TS_ASSERT_EQUALS(res_repl_a, res_a_repl); + sameNormalForm(repl_a, a_repl); // Same normal form for: // @@ -212,9 +234,7 @@ class TheoryStringsRewriterWhite : public CxxTest::TestSuite Node repl_e_x_z = d_nm->mkNode(kind::STRING_STRREPL, empty, x, z); repl_a = d_nm->mkNode(kind::STRING_CONCAT, y, repl_e_x_z, z, a, z); a_repl = d_nm->mkNode(kind::STRING_CONCAT, y, z, repl_e_x_z, a, z); - res_repl_a = Rewriter::rewrite(repl_a); - res_a_repl = Rewriter::rewrite(a_repl); - TS_ASSERT_EQUALS(res_repl_a, res_a_repl); + sameNormalForm(repl_a, a_repl); // Same normal form for: // @@ -226,9 +246,7 @@ class TheoryStringsRewriterWhite : public CxxTest::TestSuite d_nm->mkNode(kind::STRING_CONCAT, a, substr_a, repl_a_x_e); Node substr_repl_a = d_nm->mkNode(kind::STRING_CONCAT, substr_a, repl_a_x_e, a); - Node res_a_substr_repl = Rewriter::rewrite(a_substr_repl); - Node res_substr_repl_a = Rewriter::rewrite(substr_repl_a); - TS_ASSERT_EQUALS(res_a_substr_repl, res_substr_repl_a); + sameNormalForm(a_substr_repl, substr_repl_a); // Same normal form for: // @@ -241,9 +259,7 @@ class TheoryStringsRewriterWhite : public CxxTest::TestSuite d_nm->mkNode(kind::STRING_CONCAT, repl_e_x_s, substr_a, charat_a); Node a_repl_substr = d_nm->mkNode(kind::STRING_CONCAT, charat_a, repl_e_x_s, substr_a); - Node res_repl_substr_a = Rewriter::rewrite(repl_substr_a); - Node res_a_repl_substr = Rewriter::rewrite(a_repl_substr); - TS_ASSERT_EQUALS(res_repl_substr_a, res_a_repl_substr); + sameNormalForm(repl_substr_a, a_repl_substr); } void testLengthPreserveRewrite() @@ -301,9 +317,7 @@ class TheoryStringsRewriterWhite : public CxxTest::TestSuite Node itos_a_idof_x = d_nm->mkNode(kind::STRING_ITOS, a_idof_x); Node b_idof_x = d_nm->mkNode(kind::STRING_STRIDOF, b, x, one); Node itos_b_idof_x = d_nm->mkNode(kind::STRING_ITOS, b_idof_x); - Node res_itos_a_idof_x = Rewriter::rewrite(itos_a_idof_x); - Node res_itos_b_idof_x = Rewriter::rewrite(itos_b_idof_x); - TS_ASSERT_EQUALS(res_itos_a_idof_x, res_itos_b_idof_x); + sameNormalForm(itos_a_idof_x, itos_b_idof_x); // Same normal form for: // @@ -318,9 +332,7 @@ class TheoryStringsRewriterWhite : public CxxTest::TestSuite d_nm->mkNode(kind::STRING_CONCAT, aaad, x), y, three); - Node res_idof_abcd = Rewriter::rewrite(idof_abcd); - Node res_idof_aaad = Rewriter::rewrite(idof_aaad); - TS_ASSERT_EQUALS(res_idof_abcd, res_idof_aaad); + sameNormalForm(idof_abcd, idof_aaad); } void testRewriteReplace() @@ -347,25 +359,21 @@ class TheoryStringsRewriterWhite : public CxxTest::TestSuite d_nm->mkNode(kind::STRING_STRREPL, x, b, a), x, a); - Node res_repl_repl = Rewriter::rewrite(repl_repl); - Node res_repl_repl_short = Rewriter::rewrite(repl_repl_short); - TS_ASSERT_EQUALS(res_repl_repl, res_repl_repl_short); + sameNormalForm(repl_repl, repl_repl_short); // (str.replace "A" (str.replace "B", x, "C") "D") --> "A" repl_repl = d_nm->mkNode(kind::STRING_STRREPL, a, d_nm->mkNode(kind::STRING_STRREPL, b, x, c), d); - res_repl_repl = Rewriter::rewrite(repl_repl); - TS_ASSERT_EQUALS(res_repl_repl, a); + sameNormalForm(repl_repl, a); // (str.replace "A" (str.replace "B", x, "A") "D") -/-> "A" repl_repl = d_nm->mkNode(kind::STRING_STRREPL, a, d_nm->mkNode(kind::STRING_STRREPL, b, x, a), d); - res_repl_repl = Rewriter::rewrite(repl_repl); - TS_ASSERT_DIFFERS(res_repl_repl, a); + differentNormalForms(repl_repl, a); // Same normal form for: // @@ -375,17 +383,14 @@ class TheoryStringsRewriterWhite : public CxxTest::TestSuite Node xyz = d_nm->mkNode(kind::STRING_CONCAT, x, y, z); Node repl_x_xyz = d_nm->mkNode(kind::STRING_STRREPL, x, xyz, y); Node repl_x_zyx = d_nm->mkNode(kind::STRING_STRREPL, x, xyz, z); - Node res_repl_x_xyz = Rewriter::rewrite(repl_x_xyz); - Node res_repl_x_zyx = Rewriter::rewrite(repl_x_zyx); - TS_ASSERT_EQUALS(res_repl_x_xyz, res_repl_x_zyx); + sameNormalForm(repl_x_xyz, repl_x_zyx); // (str.replace "" (str.++ x x) x) --> "" Node repl_empty_xx = d_nm->mkNode(kind::STRING_STRREPL, empty, d_nm->mkNode(kind::STRING_CONCAT, x, x), x); - Node res_repl_empty_xx = Rewriter::rewrite(repl_empty_xx); - TS_ASSERT_EQUALS(res_repl_empty_xx, empty); + sameNormalForm(repl_empty_xx, empty); // (str.replace "AB" (str.++ x "A") x) --> (str.replace "AB" (str.++ x "A") // "") @@ -397,9 +402,7 @@ class TheoryStringsRewriterWhite : public CxxTest::TestSuite d_nm->mkNode(kind::STRING_CONCAT, a, b), d_nm->mkNode(kind::STRING_CONCAT, x, a), empty); - Node res_repl_ab_xa_x = Rewriter::rewrite(repl_ab_xa_x); - Node res_repl_ab_xa_e = Rewriter::rewrite(repl_ab_xa_e); - TS_ASSERT_EQUALS(res_repl_ab_xa_x, res_repl_ab_xa_e); + sameNormalForm(repl_ab_xa_x, repl_ab_xa_e); // (str.replace "AB" (str.++ x "A") x) -/-> (str.replace "AB" (str.++ "A" x) // "") @@ -407,8 +410,7 @@ class TheoryStringsRewriterWhite : public CxxTest::TestSuite d_nm->mkNode(kind::STRING_CONCAT, a, b), d_nm->mkNode(kind::STRING_CONCAT, a, x), empty); - Node res_repl_ab_ax_e = Rewriter::rewrite(repl_ab_ax_e); - TS_ASSERT_DIFFERS(res_repl_ab_xa_x, res_repl_ab_ax_e); + differentNormalForms(repl_ab_ax_e, repl_ab_xa_e); } void testRewriteContains() @@ -422,6 +424,8 @@ class TheoryStringsRewriterWhite : public CxxTest::TestSuite Node c = d_nm->mkConst(::CVC4::String("C")); Node x = d_nm->mkVar("x", strType); Node y = d_nm->mkVar("y", strType); + Node xy = d_nm->mkNode(kind::STRING_CONCAT, x, y); + Node yx = d_nm->mkNode(kind::STRING_CONCAT, y, x); Node z = d_nm->mkVar("z", strType); Node n = d_nm->mkVar("n", intType); Node one = d_nm->mkConst(Rational(2)); @@ -444,9 +448,7 @@ class TheoryStringsRewriterWhite : public CxxTest::TestSuite a, d_nm->mkNode(kind::STRING_SUBSTR, x, one, four), z); - Node res_substr_3 = Rewriter::rewrite(substr_3); - Node res_substr_4 = Rewriter::rewrite(substr_4); - TS_ASSERT_EQUALS(res_substr_3, res_substr_4); + sameNormalForm(substr_3, substr_4); // Same normal form for: // @@ -467,9 +469,7 @@ class TheoryStringsRewriterWhite : public CxxTest::TestSuite y, d_nm->mkNode(kind::STRING_SUBSTR, x, one, four)), z); - Node res_concat_substr_3 = Rewriter::rewrite(concat_substr_3); - Node res_concat_substr_4 = Rewriter::rewrite(concat_substr_4); - TS_ASSERT_EQUALS(res_concat_substr_3, res_concat_substr_4); + sameNormalForm(concat_substr_3, concat_substr_4); // (str.contains "A" (str.++ a (str.replace "B", x, "C")) --> false Node ctn_repl = @@ -478,32 +478,24 @@ class TheoryStringsRewriterWhite : public CxxTest::TestSuite d_nm->mkNode(kind::STRING_CONCAT, a, d_nm->mkNode(kind::STRING_STRREPL, b, x, c))); - Node res_ctn_repl = Rewriter::rewrite(ctn_repl); - TS_ASSERT_EQUALS(res_ctn_repl, f); + sameNormalForm(ctn_repl, f); // (str.contains x (str.++ x x)) --> (= x "") Node x_cnts_x_x = d_nm->mkNode( kind::STRING_STRCTN, x, d_nm->mkNode(kind::STRING_CONCAT, x, x)); - Node res_x_cnts_x_x = Rewriter::rewrite(x_cnts_x_x); - Node res_x_eq_empty = - Rewriter::rewrite(d_nm->mkNode(kind::EQUAL, x, empty)); - TS_ASSERT_EQUALS(res_x_cnts_x_x, res_x_eq_empty); + sameNormalForm(x_cnts_x_x, d_nm->mkNode(kind::EQUAL, x, empty)); // Same normal form for: // // (str.contains (str.++ y x) (str.++ x z y)) // // (and (str.contains (str.++ y x) (str.++ x y)) (= z "")) - Node yx = d_nm->mkNode(kind::STRING_CONCAT, y, x); Node yx_cnts_xzy = d_nm->mkNode( kind::STRING_STRCTN, yx, d_nm->mkNode(kind::STRING_CONCAT, x, z, y)); - Node res_yx_cnts_xzy = Rewriter::rewrite(yx_cnts_xzy); - Node xy = d_nm->mkNode(kind::STRING_CONCAT, x, y); Node yx_cnts_xy = d_nm->mkNode(kind::AND, - d_nm->mkNode(kind::STRING_STRCTN, yx, xy), - d_nm->mkNode(kind::EQUAL, z, empty)); - Node res_yx_cnts_xy = Rewriter::rewrite(yx_cnts_xy); - TS_ASSERT_EQUALS(res_yx_cnts_xzy, res_yx_cnts_xy); + d_nm->mkNode(kind::EQUAL, z, empty), + d_nm->mkNode(kind::STRING_STRCTN, yx, xy)); + sameNormalForm(yx_cnts_xzy, yx_cnts_xy); // Same normal form for: // @@ -520,9 +512,7 @@ class TheoryStringsRewriterWhite : public CxxTest::TestSuite d_nm->mkNode( kind::STRING_SUBSTR, x, n, d_nm->mkNode(kind::STRING_LENGTH, y)), y); - Node res_ctn_substr = Rewriter::rewrite(ctn_substr); - Node res_substr_eq = Rewriter::rewrite(substr_eq); - TS_ASSERT_EQUALS(res_ctn_substr, res_substr_eq); + sameNormalForm(ctn_substr, substr_eq); // Same normal form for: // @@ -532,9 +522,7 @@ class TheoryStringsRewriterWhite : public CxxTest::TestSuite Node ctn_repl_y_x_y = d_nm->mkNode( kind::STRING_STRCTN, x, d_nm->mkNode(kind::STRING_STRREPL, y, x, y)); Node ctn_x_y = d_nm->mkNode(kind::STRING_STRCTN, x, y); - Node res_ctn_repl_y_x_y = Rewriter::rewrite(ctn_repl_y_x_y); - Node res_ctn_x_y = Rewriter::rewrite(ctn_x_y); - TS_ASSERT_EQUALS(res_ctn_repl_y_x_y, res_ctn_x_y); + sameNormalForm(ctn_repl_y_x_y, ctn_repl_y_x_y); // Same normal form for: // @@ -545,9 +533,7 @@ class TheoryStringsRewriterWhite : public CxxTest::TestSuite kind::STRING_STRCTN, x, d_nm->mkNode(kind::STRING_STRREPL, x, y, x)); Node eq_repl = d_nm->mkNode( kind::EQUAL, x, d_nm->mkNode(kind::STRING_STRREPL, x, y, x)); - Node res_ctn_repl_self = Rewriter::rewrite(ctn_repl_self); - Node res_eq_repl = Rewriter::rewrite(eq_repl); - TS_ASSERT_EQUALS(res_ctn_repl_self, res_eq_repl); + sameNormalForm(ctn_repl_self, eq_repl); // (str.contains x (str.++ "A" (str.replace x y x))) ---> false Node ctn_repl_self_f = @@ -556,8 +542,7 @@ class TheoryStringsRewriterWhite : public CxxTest::TestSuite d_nm->mkNode(kind::STRING_CONCAT, a, d_nm->mkNode(kind::STRING_STRREPL, x, y, x))); - Node res_ctn_repl_self_f = Rewriter::rewrite(ctn_repl_self_f); - TS_ASSERT_EQUALS(res_ctn_repl_self_f, f); + sameNormalForm(ctn_repl_self_f, f); // Same normal form for: // @@ -570,8 +555,117 @@ class TheoryStringsRewriterWhite : public CxxTest::TestSuite d_nm->mkNode(kind::STRING_STRREPL, empty, x, y)); Node eq_repl_empty = d_nm->mkNode( kind::EQUAL, empty, d_nm->mkNode(kind::STRING_STRREPL, empty, x, y)); - Node res_ctn_repl_empty = Rewriter::rewrite(ctn_repl_empty); - Node res_eq_repl_empty = Rewriter::rewrite(eq_repl_empty); - TS_ASSERT_EQUALS(res_ctn_repl_empty, res_eq_repl_empty); + sameNormalForm(ctn_repl_empty, eq_repl_empty); + + // Same normal form for: + // + // (str.contains x (str.++ x y)) + // + // (= "" y) + Node ctn_x_x_y = d_nm->mkNode( + kind::STRING_STRCTN, x, d_nm->mkNode(kind::STRING_CONCAT, x, y)); + Node eq_emp_y = d_nm->mkNode(kind::EQUAL, empty, y); + sameNormalForm(ctn_x_x_y, eq_emp_y); + + // Same normal form for: + // + // (str.contains (str.++ y x) (str.++ x y)) + // + // (= (str.++ y x) (str.++ x y)) + Node ctn_yxxy = d_nm->mkNode(kind::STRING_STRCTN, yx, xy); + Node eq_yxxy = d_nm->mkNode(kind::EQUAL, yx, xy); + sameNormalForm(ctn_yxxy, eq_yxxy); + } + + void testInferEqsFromContains() + { + TypeNode strType = d_nm->stringType(); + + Node empty = d_nm->mkConst(::CVC4::String("")); + Node a = d_nm->mkConst(::CVC4::String("A")); + Node b = d_nm->mkConst(::CVC4::String("B")); + Node x = d_nm->mkVar("x", strType); + Node y = d_nm->mkVar("y", strType); + Node xy = d_nm->mkNode(kind::STRING_CONCAT, x, y); + Node f = d_nm->mkConst(false); + + // inferEqsFromContains("", (str.++ x y)) returns something equivalent to + // (= "" y) + Node empty_x_y = d_nm->mkNode(kind::AND, + d_nm->mkNode(kind::EQUAL, empty, x), + d_nm->mkNode(kind::EQUAL, empty, y)); + sameNormalForm(TheoryStringsRewriter::inferEqsFromContains(empty, xy), + empty_x_y); + + // inferEqsFromContains(x, (str.++ x y)) returns false + Node bxya = d_nm->mkNode(kind::STRING_CONCAT, b, y, x, a); + sameNormalForm(TheoryStringsRewriter::inferEqsFromContains(x, bxya), f); + + // inferEqsFromContains(x, y) returns null + Node n = TheoryStringsRewriter::inferEqsFromContains(x, y); + TS_ASSERT(n.isNull()); + + // inferEqsFromContains(x, x) returns something equivalent to (= x x) + Node eq_x_x = d_nm->mkNode(kind::EQUAL, x, x); + sameNormalForm(TheoryStringsRewriter::inferEqsFromContains(x, x), eq_x_x); + + // inferEqsFromContains((str.replace x "B" "A"), x) returns something + // equivalent to (= (str.replace x "B" "A") x) + Node repl = d_nm->mkNode(kind::STRING_STRREPL, x, b, a); + Node eq_repl_x = d_nm->mkNode(kind::EQUAL, repl, x); + sameNormalForm(TheoryStringsRewriter::inferEqsFromContains(repl, x), + eq_repl_x); + + // inferEqsFromContains(x, (str.replace x "B" "A")) returns something + // equivalent to (= (str.replace x "B" "A") x) + Node eq_x_repl = d_nm->mkNode(kind::EQUAL, x, repl); + sameNormalForm(TheoryStringsRewriter::inferEqsFromContains(x, repl), + eq_x_repl); } + + void testRewritePrefixSuffix() + { + TypeNode strType = d_nm->stringType(); + + Node empty = d_nm->mkConst(::CVC4::String("")); + Node a = d_nm->mkConst(::CVC4::String("A")); + Node x = d_nm->mkVar("x", strType); + Node y = d_nm->mkVar("y", strType); + Node xx = d_nm->mkNode(kind::STRING_CONCAT, x, x); + Node xxa = d_nm->mkNode(kind::STRING_CONCAT, x, x, a); + Node xy = d_nm->mkNode(kind::STRING_CONCAT, x, y); + Node f = d_nm->mkConst(false); + + // Same normal form for: + // + // (str.prefix x (str.++ x y)) + // + // (= y "") + Node p_xy = d_nm->mkNode(kind::STRING_PREFIX, xy, x); + Node empty_y = d_nm->mkNode(kind::EQUAL, y, empty); + sameNormalForm(p_xy, empty_y); + + // Same normal form for: + // + // (str.suffix x (str.++ x x)) + // + // (= x "") + Node p_xx = d_nm->mkNode(kind::STRING_SUFFIX, xx, x); + Node empty_x = d_nm->mkNode(kind::EQUAL, x, empty); + sameNormalForm(p_xx, empty_x); + + // (str.suffix x (str.++ x x "A")) --> false + // + // (= x "") + Node p_xxa = d_nm->mkNode(kind::STRING_SUFFIX, xxa, x); + sameNormalForm(p_xxa, f); + } + + private: + ExprManager* d_em; + SmtEngine* d_smt; + SmtScope* d_scope; + ExtendedRewriter* d_rewriter; + + NodeManager* d_nm; }; diff --git a/test/unit/util/CMakeLists.txt b/test/unit/util/CMakeLists.txt new file mode 100644 index 000000000..0748e1059 --- /dev/null +++ b/test/unit/util/CMakeLists.txt @@ -0,0 +1,20 @@ +#-----------------------------------------------------------------------------# +# Add unit tests + +cvc4_add_unit_test_black(array_store_all_black util) +cvc4_add_unit_test_white(assert_white util) +cvc4_add_unit_test_black(binary_heap_black util) +cvc4_add_unit_test_black(bitvector_black util) +cvc4_add_unit_test_black(boolean_simplification_black util) +cvc4_add_unit_test_black(cardinality_public util) +cvc4_add_unit_test_white(check_white util) +cvc4_add_unit_test_black(configuration_black util) +cvc4_add_unit_test_black(datatype_black util) +cvc4_add_unit_test_black(exception_black util) +cvc4_add_unit_test_black(integer_black util) +cvc4_add_unit_test_white(integer_white util) +cvc4_add_unit_test_black(listener_black util) +cvc4_add_unit_test_black(output_black util) +cvc4_add_unit_test_black(rational_black util) +cvc4_add_unit_test_white(rational_white util) +cvc4_add_unit_test_black(stats_black util) |