diff --git a/build/build-publish-solvers.xml b/build/build-publish-solvers.xml index 3f686a6622..c0b4de147f 100644 --- a/build/build-publish-solvers.xml +++ b/build/build-publish-solvers.xml @@ -147,6 +147,104 @@ svn ci repository/${ivy.organisation}/${ivy.module} -m"publish version ${cvc4.version} of CVC4 Solver" to make the new version publicly available. + + + + + Please specify the path to Boolector with the flag -Dboolector.path=/path/to/boolector. + The path has to point to the root Boolector folder, i.e., + a checkout of the official git repositoy from 'https://github.com/boolector/boolector'. + Note that shell substitutions do not work and a full absolute path has to be specified. + + + Please specify a custom revision with the flag -Dboolector.customRev=XXX. + The custom revision has to be unique amongst the already known version + numbers from the ivy repository. The script will append the git revision. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + You now want to run + svn add repository/${ivy.organisation}/${ivy.module}/*-${boolector.version}* + svn ci repository/${ivy.organisation}/${ivy.module} -m"publish version ${boolector.version} of Boolector Solver" + to make the new version publicly available. + + diff --git a/lib/ivy.xml b/lib/ivy.xml index 6c2d348c17..df8656322c 100644 --- a/lib/ivy.xml +++ b/lib/ivy.xml @@ -25,9 +25,10 @@ + - + @@ -137,6 +138,7 @@ + diff --git a/lib/native/source/libboolector/Boolector Build Documentation.txt b/lib/native/source/libboolector/Boolector Build Documentation.txt new file mode 100644 index 0000000000..1ed00cdcd5 --- /dev/null +++ b/lib/native/source/libboolector/Boolector Build Documentation.txt @@ -0,0 +1,85 @@ +################################################################# + +INFO 2019-11-11: +This file might be outdated, please use 'ant publish-boolector' +for building Boolector and publishing into Ivy. +The ant steps are based on this documentation. + +################################################################# + + +NOTICE: This is a bare minimum guide that worked for me. I do not take responsibility in any damage or frustration you may encounter using this! + +In the following the steps to update or change boolector and its JNI are outlined: + +There are 2 files, both located in boolector/src/, that need (potential) editing to compile Boolector with JNI: + +-interface_wrap.c (containing the JNI interface) +-CMakeLists.c (the cmakefile) + + +MakeFile: +CMakeLists.c needs to include ALL JNI .c files you want in its set(libboolector_src_files ...) list at the beginning. (interface_wrap.c should be there!) +Additionally it needs to find the JNI libs and set the path for linking. +Example: + + find_package(JNI) + if(JNI_FOUND) + message (STATUS "JNI_INCLUDE_DIRS=${JNI_INCLUDE_DIRS}") + message (STATUS "JNI_LIBRARIES=${JNI_LIBRARIES}") + target_include_directories(boolector PRIVATE ${JNI_INCLUDE_DIRS}) + target_link_libraries(boolector ${JNI_LIBRARIES}) + endif() + +(should be set and ready to go in the provided version of the cmakefile but here is a copy that should be working if copied in directly before the linking of the SAT solvers) + +JNI (interface_wrap.c): +To change or update methods just edit this file! (DON'T CHANGE BOOLECTOR NATIVE CODE!) +The interface is set up with all C API methods (taken from the interfaces via SWIG, see SWIG part at the end of this) of Boolector. +Important: every pointer in Boolector is returned to Java via a Jlong. Just use this as a pointer once given back, but cast it properly! +Be careful, method names need the package in them, see JNI for more details! +There are multiple helper methods at the very end of the file, do not change them unless you know what you are doing! +Since Boolector sometimes writes to given objects, we need those to get the information back to Java. (Explanation via comments in the code) +In case you add new methods, remember to add them to the Java code as well. (Should be BtorJNI.java in the Boolector package) + + +To compile you need to follow these steps EVERY time since Boolector does not save your preferences: + +1. (Optional) Download new Boolector/Update Boolector and edit/create JNI interface and cmakefile +2. Open terminal and switch to the boolector folder (java-smt3-boolector/lib/native/native boolector/boolector) +3. Set up your build (See https://github.com/Boolector/boolector for more information. Important: do not try to include MiniSAT in a shared lib, it won't compile!(October 2019) But check for updates on this!) + Example: + ./contrib/setup-cadical.sh + ./contrib/setup-lingeling.sh + ./contrib/setup-picosat.sh + ./contrib/setup-btor2tools.sh + +4. Build Boolector shared lib (you can add more options if you wish): + ./configure.sh -fno-strict-aliasing -fpic --shared && cd build && make + +5. Your shared lib can be found in boolector/build/lib +6. Copy it to java-smt3-boolector/lib/native/x86_64-linux/ and override the old lib +7. Update your JNI Java files + + +If you choose to use SWIG (Java/C): +(Careful, you need to check your methods later anyway, SWIG tends to make mistakes. Example: it gives pointers back instead of the object, or a Jlong instead of an Jint etc.) +Download: http://www.swig.org/download.html && Install Guide: https://github.com/swig/swig/wiki/Getting-Started + +Create an interface file (example: exampleinterface.i) +Lets say you want the C header file "stuff.h" with the function "int fact(int n)" in Java, enter it in the interface file as seen below. (Names are important, even filenames!) +/* File: exampleInterface.i */ + %module test + %{ + #include "stuff.h" + %} + int fact(int n); + +If you want all methods of the header in your interface, just replace the methods and enter %include "stuff.h" where the methods used to be. +After finishing the interface file, execute SWIG with it and the header(s) you want (all in the same folder). +See documentation of SWIG for more details. (This will propably do: %swig -java exampleinterface.i ) +Swig has loads of options and customizations, read the doku! (Example: -package will specify the java package, as it is important for method names) +Dokumentation, Java Command Line 26.2.2 : http://www.swig.org/Doc4.0/SWIGDocumentation.pdf +After executing SWIG correctly, there should be some .c and some .java files. +The .c part has to be bound to the native C code as described above, Java in Java. + diff --git a/lib/native/source/libboolector/include_interface_and_jni.patch b/lib/native/source/libboolector/include_interface_and_jni.patch new file mode 100644 index 0000000000..f5081bd8ab --- /dev/null +++ b/lib/native/source/libboolector/include_interface_and_jni.patch @@ -0,0 +1,27 @@ +diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt +index e2781eb..b838d8e 100644 +--- a/src/CMakeLists.txt ++++ b/src/CMakeLists.txt +@@ -1,6 +1,7 @@ + set(libboolector_src_files + aigprop.c + boolector.c ++ interface_wrap.c + boolectormc.c + btorabort.c + btoraig.c +@@ -96,6 +97,14 @@ target_include_directories(boolector + target_include_directories(boolector PRIVATE ${Btor2Tools_INCLUDE_DIR}) + target_link_libraries(boolector ${Btor2Tools_LIBRARIES}) + ++find_package(JNI) ++if(JNI_FOUND) ++ message (STATUS "JNI_INCLUDE_DIRS=${JNI_INCLUDE_DIRS}") ++ message (STATUS "JNI_LIBRARIES=${JNI_LIBRARIES}") ++ target_include_directories(boolector PRIVATE ${JNI_INCLUDE_DIRS}) ++ target_link_libraries(boolector ${JNI_LIBRARIES}) ++endif() ++ + if(GMP_FOUND) + target_include_directories(boolector PRIVATE ${GMP_INCLUDE_DIR}) + target_link_libraries(boolector ${GMP_LIBRARIES}) diff --git a/lib/native/source/libboolector/interface_wrap.c b/lib/native/source/libboolector/interface_wrap.c new file mode 100644 index 0000000000..a72b87b134 --- /dev/null +++ b/lib/native/source/libboolector/interface_wrap.c @@ -0,0 +1,3570 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.0 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + + +#ifndef SWIGJAVA +#define SWIGJAVA +#endif + + +/* ----------------------------------------------------------------------------- + * This section contains generic SWIG labels for method/variable + * declarations/attributes, and other compiler dependent labels. + * ----------------------------------------------------------------------------- */ + +/* template workaround for compilers that cannot correctly implement the C++ standard */ +#ifndef SWIGTEMPLATEDISAMBIGUATOR +# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) +# define SWIGTEMPLATEDISAMBIGUATOR template +# elif defined(__HP_aCC) +/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ +/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ +# define SWIGTEMPLATEDISAMBIGUATOR template +# else +# define SWIGTEMPLATEDISAMBIGUATOR +# endif +#endif + +/* inline attribute */ +#ifndef SWIGINLINE +# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) +# define SWIGINLINE inline +# else +# define SWIGINLINE +# endif +#endif + +/* attribute recognised by some compilers to avoid 'unused' warnings */ +#ifndef SWIGUNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define SWIGUNUSED __attribute__ ((__unused__)) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +# elif defined(__ICC) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +#endif + +#ifndef SWIG_MSC_UNSUPPRESS_4505 +# if defined(_MSC_VER) +# pragma warning(disable : 4505) /* unreferenced local function has been removed */ +# endif +#endif + +#ifndef SWIGUNUSEDPARM +# ifdef __cplusplus +# define SWIGUNUSEDPARM(p) +# else +# define SWIGUNUSEDPARM(p) p SWIGUNUSED +# endif +#endif + +/* internal SWIG method */ +#ifndef SWIGINTERN +# define SWIGINTERN static SWIGUNUSED +#endif + +/* internal inline SWIG method */ +#ifndef SWIGINTERNINLINE +# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE +#endif + +/* exporting methods */ +#if defined(__GNUC__) +# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) +# ifndef GCC_HASCLASSVISIBILITY +# define GCC_HASCLASSVISIBILITY +# endif +# endif +#endif + +#ifndef SWIGEXPORT +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# if defined(STATIC_LINKED) +# define SWIGEXPORT +# else +# define SWIGEXPORT __declspec(dllexport) +# endif +# else +# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) +# define SWIGEXPORT __attribute__ ((visibility("default"))) +# else +# define SWIGEXPORT +# endif +# endif +#endif + +/* calling conventions for Windows */ +#ifndef SWIGSTDCALL +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# define SWIGSTDCALL __stdcall +# else +# define SWIGSTDCALL +# endif +#endif + +/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ +#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) +# define _CRT_SECURE_NO_DEPRECATE +#endif + +/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ +#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) +# define _SCL_SECURE_NO_DEPRECATE +#endif + +/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */ +#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES) +# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0 +#endif + +/* Intel's compiler complains if a variable which was never initialised is + * cast to void, which is a common idiom which we use to indicate that we + * are aware a variable isn't used. So we just silence that warning. + * See: https://github.com/swig/swig/issues/192 for more discussion. + */ +#ifdef __INTEL_COMPILER +# pragma warning disable 592 +#endif + + +/* Fix for jlong on some versions of gcc on Windows */ +#if defined(__GNUC__) && !defined(__INTEL_COMPILER) + typedef long long __int64; +#endif + +/* Fix for jlong on 64-bit x86 Solaris */ +#if defined(__x86_64) +# ifdef _LP64 +# undef _LP64 +# endif +#endif + +#include +#include +#include + + +/* Support for throwing Java exceptions */ +typedef enum { + SWIG_JavaOutOfMemoryError = 1, + SWIG_JavaIOException, + SWIG_JavaRuntimeException, + SWIG_JavaIndexOutOfBoundsException, + SWIG_JavaArithmeticException, + SWIG_JavaIllegalArgumentException, + SWIG_JavaNullPointerException, + SWIG_JavaDirectorPureVirtual, + SWIG_JavaUnknownError +} SWIG_JavaExceptionCodes; + +typedef struct { + SWIG_JavaExceptionCodes code; + const char *java_exception; +} SWIG_JavaExceptions_t; + + +static void SWIGUNUSED SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg) { + jclass excep; + static const SWIG_JavaExceptions_t java_exceptions[] = { + { SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" }, + { SWIG_JavaIOException, "java/io/IOException" }, + { SWIG_JavaRuntimeException, "java/lang/RuntimeException" }, + { SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" }, + { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" }, + { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" }, + { SWIG_JavaNullPointerException, "java/lang/NullPointerException" }, + { SWIG_JavaDirectorPureVirtual, "java/lang/RuntimeException" }, + { SWIG_JavaUnknownError, "java/lang/UnknownError" }, + { (SWIG_JavaExceptionCodes)0, "java/lang/UnknownError" } + }; + const SWIG_JavaExceptions_t *except_ptr = java_exceptions; + + while (except_ptr->code != code && except_ptr->code) + except_ptr++; + + (*jenv)->ExceptionClear(jenv); + excep = (*jenv)->FindClass(jenv, except_ptr->java_exception); + if (excep) + (*jenv)->ThrowNew(jenv, excep, msg); +} + + +/* Contract support */ + +#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, msg); return nullreturn; } else + + +#include "boolector.h" +#include "btortypes.h" + + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_BOOLECTOR_1PARSE_1ERROR_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + int result; + + (void)jenv; + (void)jcls; + result = (int)(1); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_BOOLECTOR_1PARSE_1UNKNOWN_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + int result; + + (void)jenv; + (void)jcls; + result = (int)(2); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1new(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + Btor *result = 0 ; + + (void)jenv; + (void)jcls; + result = (Btor *)boolector_new(); + *(Btor **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1clone(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + Btor *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + result = (Btor *)boolector_clone(arg1); + *(Btor **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1delete(JNIEnv *jenv, jclass jcls, jlong jarg1) { + Btor *arg1 = (Btor *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + boolector_delete(arg1); +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1set_1term(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + Btor *arg1 = (Btor *) 0 ; + int32_t (*arg2)(void *) = (int32_t (*)(void *)) 0 ; + void *arg3 = (void *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(int32_t (**)(void *))&jarg2; + arg3 = *(void **)&jarg3; + boolector_set_term(arg1,arg2,arg3); +} + + +SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1terminate(JNIEnv *jenv, jclass jcls, jlong jarg1) { + Btor *arg1 = (Btor *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + return boolector_terminate(arg1); +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1set_1abort(JNIEnv *jenv, jclass jcls, jlong jarg1) { + void (*arg1)(char const *) = (void (*)(char const *)) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(void (**)(char const *))&jarg1; + boolector_set_abort(arg1); +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1set_1msg_1prefix(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2) { + Btor *arg1 = (Btor *) 0 ; + char *arg2 = (char *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return ; + } + boolector_set_msg_prefix(arg1,(char const *)arg2); + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); +} + + +SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1get_1refs(JNIEnv *jenv, jclass jcls, jlong jarg1) { + Btor *arg1 = (Btor *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + return boolector_get_refs(arg1); +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1reset_1time(JNIEnv *jenv, jclass jcls, jlong jarg1) { + Btor *arg1 = (Btor *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + boolector_reset_time(arg1); +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1reset_1stats(JNIEnv *jenv, jclass jcls, jlong jarg1) { + Btor *arg1 = (Btor *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + boolector_reset_stats(arg1); +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1print_1stats(JNIEnv *jenv, jclass jcls, jlong jarg1) { + Btor *arg1 = (Btor *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + boolector_print_stats(arg1); +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1set_1trapi(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2) { + Btor *arg1 = (Btor *) 0 ; + char *arg2 = (char *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) perror("ERROR: couldn't set api trace because given path was wrong."); + } + FILE *f = 0; + f = fopen(arg2, "w"); + if(f==NULL) { + perror("ERROR: couldn't set api trace because it couldnt open trace file."); + } + boolector_set_trapi(arg1,f); +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1get_1trapi(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + FILE *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + result = (FILE *)boolector_get_trapi(arg1); + *(FILE **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1push(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + Btor *arg1 = (Btor *) 0 ; + uint32_t arg2 ; + uint32_t *argp2 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + argp2 = (uint32_t *)&jarg2; + if (!argp2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null uint32_t"); + return ; + } + arg2 = *argp2; + boolector_push(arg1,arg2); +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1pop(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + Btor *arg1 = (Btor *) 0 ; + uint32_t arg2 ; + uint32_t *argp2 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + argp2 = (uint32_t *)&jarg2; + if (!argp2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null uint32_t"); + return ; + } + arg2 = *argp2; + boolector_pop(arg1,arg2); +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1assert(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + boolector_assert(arg1,arg2); +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1assume(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + boolector_assume(arg1,arg2); +} + + +SWIGEXPORT jboolean JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1failed(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jboolean jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + bool result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (bool)boolector_failed(arg1,arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1get_1failed_1assumptions(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode **result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + result = (BoolectorNode **)boolector_get_failed_assumptions(arg1); + *(BoolectorNode ***)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1fixate_1assumptions(JNIEnv *jenv, jclass jcls, jlong jarg1) { + Btor *arg1 = (Btor *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + boolector_fixate_assumptions(arg1); +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1reset_1assumptions(JNIEnv *jenv, jclass jcls, jlong jarg1) { + Btor *arg1 = (Btor *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + boolector_reset_assumptions(arg1); +} + + +SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1sat(JNIEnv *jenv, jclass jcls, jlong jarg1) { + Btor *arg1 = (Btor *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + return boolector_sat(arg1); +} + + +SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1limited_1sat(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + Btor *arg1 = (Btor *) 0 ; + int32_t arg2 ; + int32_t arg3 ; + int32_t *argp2 ; + int32_t *argp3 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + argp2 = (int32_t *)&jarg2; + if (!argp2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null int32_t"); + return 0; + } + arg2 = *argp2; + argp3 = (int32_t *)&jarg3; + if (!argp3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null int32_t"); + return 0; + } + arg3 = *argp3; + return boolector_limited_sat(arg1,arg2,arg3); +} + + +SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1simplify(JNIEnv *jenv, jclass jcls, jlong jarg1) { + Btor *arg1 = (Btor *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + return boolector_simplify(arg1); +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1set_1sat_1solver(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2) { + Btor *arg1 = (Btor *) 0 ; + char *arg2 = (char *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return ; + } + boolector_set_sat_solver(arg1,(char const *)arg2); + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1set_1opt(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jlong jarg3) { + Btor *arg1 = (Btor *) 0 ; + BtorOption arg2 ; + uint32_t arg3 ; + uint32_t *argp3 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = (BtorOption)jarg2; + argp3 = (uint32_t *)&jarg3; + if (!argp3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null uint32_t"); + return ; + } + arg3 = *argp3; + boolector_set_opt(arg1,arg2,arg3); +} + + +SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1get_1opt(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { + Btor *arg1 = (Btor *) 0 ; + BtorOption arg2 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = (BtorOption)jarg2; + return boolector_get_opt(arg1,arg2); +} + + +SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1get_1opt_1min(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { + Btor *arg1 = (Btor *) 0 ; + BtorOption arg2 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = (BtorOption)jarg2; + return boolector_get_opt_min(arg1,arg2); +} + + +SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1get_1opt_1max(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { + Btor *arg1 = (Btor *) 0 ; + BtorOption arg2 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = (BtorOption)jarg2; + return boolector_get_opt_max(arg1,arg2); +} + + +SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1get_1opt_1dflt(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { + Btor *arg1 = (Btor *) 0 ; + BtorOption arg2 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = (BtorOption)jarg2; + return boolector_get_opt_dflt(arg1,arg2); +} + + +SWIGEXPORT jstring JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1get_1opt_1lng(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { + jstring jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BtorOption arg2 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = (BtorOption)jarg2; + result = (char *)boolector_get_opt_lng(arg1,arg2); + if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1get_1opt_1shrt(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { + jstring jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BtorOption arg2 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = (BtorOption)jarg2; + result = (char *)boolector_get_opt_shrt(arg1,arg2); + if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1get_1opt_1desc(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { + jstring jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BtorOption arg2 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = (BtorOption)jarg2; + result = (char *)boolector_get_opt_desc(arg1,arg2); + if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1has_1opt(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { + jboolean jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BtorOption arg2 ; + bool result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = (BtorOption)jarg2; + result = (bool)boolector_has_opt(arg1,arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1first_1opt(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jint jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BtorOption result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + result = (BtorOption)boolector_first_opt(arg1); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1next_1opt(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) { + jint jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BtorOption arg2 ; + BtorOption result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = (BtorOption)jarg2; + result = (BtorOption)boolector_next_opt(arg1,arg2); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1copy(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (BoolectorNode *)boolector_copy(arg1,arg2); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1release(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + boolector_release(arg1,arg2); +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1release_1all(JNIEnv *jenv, jclass jcls, jlong jarg1) { + Btor *arg1 = (Btor *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + boolector_release_all(arg1); +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1true(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + result = (BoolectorNode *)boolector_true(arg1); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1false(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + result = (BoolectorNode *)boolector_false(arg1); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1implies(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_implies(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1iff(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_iff(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_eq(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_ne(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1is_1bv_1const_1zero(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jboolean jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + bool result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (bool)boolector_is_bv_const_zero(arg1,arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1is_1bv_1const_1one(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jboolean jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + bool result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (bool)boolector_is_bv_const_one(arg1,arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1is_1bv_1const_1ones(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jboolean jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + bool result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (bool)boolector_is_bv_const_ones(arg1,arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1is_1bv_1const_1max_1signed(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jboolean jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + bool result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (bool)boolector_is_bv_const_max_signed(arg1,arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1is_1bv_1const_1min_1signed(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jboolean jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + bool result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (bool)boolector_is_bv_const_min_signed(arg1,arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1const(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + char *arg2 = (char *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return 0; + } + result = (BoolectorNode *)boolector_const(arg1,(char const *)arg2); + *(BoolectorNode **)&jresult = result; + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1constd(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jstring jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorSort arg2 = (BoolectorSort) 0 ; + char *arg3 = (char *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorSort *)&jarg2; + arg3 = 0; + if (jarg3) { + arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); + if (!arg3) return 0; + } + result = (BoolectorNode *)boolector_constd(arg1,arg2,(char const *)arg3); + *(BoolectorNode **)&jresult = result; + if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1consth(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jstring jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorSort arg2 = (BoolectorSort) 0 ; + char *arg3 = (char *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorSort *)&jarg2; + arg3 = 0; + if (jarg3) { + arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); + if (!arg3) return 0; + } + result = (BoolectorNode *)boolector_consth(arg1,arg2,(char const *)arg3); + *(BoolectorNode **)&jresult = result; + if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1zero(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorSort arg2 = (BoolectorSort) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorSort *)&jarg2; + result = (BoolectorNode *)boolector_zero(arg1,arg2); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1ones(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorSort arg2 = (BoolectorSort) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorSort *)&jarg2; + result = (BoolectorNode *)boolector_ones(arg1,arg2); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1one(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorSort arg2 = (BoolectorSort) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorSort *)&jarg2; + result = (BoolectorNode *)boolector_one(arg1,arg2); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1min_1signed(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorSort arg2 = (BoolectorSort) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorSort *)&jarg2; + result = (BoolectorNode *)boolector_min_signed(arg1,arg2); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1max_1signed(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorSort arg2 = (BoolectorSort) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorSort *)&jarg2; + result = (BoolectorNode *)boolector_max_signed(arg1,arg2); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1unsigned_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + uint32_t arg2 ; + BoolectorSort arg3 = (BoolectorSort) 0 ; + uint32_t *argp2 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + argp2 = (uint32_t *)&jarg2; + if (!argp2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null uint32_t"); + return 0; + } + arg2 = *argp2; + arg3 = *(BoolectorSort *)&jarg3; + result = (BoolectorNode *)boolector_unsigned_int(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + int32_t arg2 ; + BoolectorSort arg3 = (BoolectorSort) 0 ; + int32_t *argp2 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + argp2 = (int32_t *)&jarg2; + if (!argp2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null int32_t"); + return 0; + } + arg2 = *argp2; + arg3 = *(BoolectorSort *)&jarg3; + result = (BoolectorNode *)boolector_int(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1var(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jstring jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorSort arg2 = (BoolectorSort) 0 ; + char *arg3 = (char *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorSort *)&jarg2; + arg3 = 0; + if (jarg3) { + arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); + if (!arg3) return 0; + } + result = (BoolectorNode *)boolector_var(arg1,arg2,(char const *)arg3); + *(BoolectorNode **)&jresult = result; + if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1array(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jstring jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorSort arg2 = (BoolectorSort) 0 ; + char *arg3 = (char *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorSort *)&jarg2; + arg3 = 0; + if (jarg3) { + arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); + if (!arg3) return 0; + } + result = (BoolectorNode *)boolector_array(arg1,arg2,(char const *)arg3); + *(BoolectorNode **)&jresult = result; + if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1uf(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jstring jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorSort arg2 = (BoolectorSort) 0 ; + char *arg3 = (char *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorSort *)&jarg2; + arg3 = 0; + if (jarg3) { + arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); + if (!arg3) return 0; + } + result = (BoolectorNode *)boolector_uf(arg1,arg2,(char const *)arg3); + *(BoolectorNode **)&jresult = result; + if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1not(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (BoolectorNode *)boolector_not(arg1,arg2); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1neg(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (BoolectorNode *)boolector_neg(arg1,arg2); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1redor(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (BoolectorNode *)boolector_redor(arg1,arg2); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1redxor(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (BoolectorNode *)boolector_redxor(arg1,arg2); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1redand(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (BoolectorNode *)boolector_redand(arg1,arg2); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1slice(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3, jlong jarg4) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + uint32_t arg3 ; + uint32_t arg4 ; + uint32_t *argp3 ; + uint32_t *argp4 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + argp3 = (uint32_t *)&jarg3; + if (!argp3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null uint32_t"); + return 0; + } + arg3 = *argp3; + argp4 = (uint32_t *)&jarg4; + if (!argp4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null uint32_t"); + return 0; + } + arg4 = *argp4; + result = (BoolectorNode *)boolector_slice(arg1,arg2,arg3,arg4); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1uext(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + uint32_t arg3 ; + uint32_t *argp3 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + argp3 = (uint32_t *)&jarg3; + if (!argp3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null uint32_t"); + return 0; + } + arg3 = *argp3; + result = (BoolectorNode *)boolector_uext(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1sext(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + uint32_t arg3 ; + uint32_t *argp3 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + argp3 = (uint32_t *)&jarg3; + if (!argp3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null uint32_t"); + return 0; + } + arg3 = *argp3; + result = (BoolectorNode *)boolector_sext(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1xor(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_xor(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1xnor(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_xnor(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1and(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_and(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1nand(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_nand(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1or(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_or(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1nor(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_nor(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1add(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_add(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1uaddo(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_uaddo(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1saddo(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_saddo(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1mul(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_mul(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1umulo(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_umulo(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1smulo(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_smulo(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1ult(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_ult(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1slt(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_slt(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1ulte(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_ulte(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1slte(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_slte(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1ugt(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_ugt(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1sgt(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_sgt(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1ugte(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_ugte(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1sgte(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_sgte(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1sll(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_sll(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1srl(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_srl(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1sra(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_sra(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1rol(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_rol(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1ror(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_ror(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1sub(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_sub(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1usubo(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_usubo(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1ssubo(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_ssubo(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1udiv(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_udiv(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1sdiv(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_sdiv(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1sdivo(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_sdivo(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1urem(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_urem(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1srem(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_srem(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1smod(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_smod(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1concat(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_concat(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1repeat(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + uint32_t arg3 ; + uint32_t *argp3 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + argp3 = (uint32_t *)&jarg3; + if (!argp3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null uint32_t"); + return 0; + } + arg3 = *argp3; + result = (BoolectorNode *)boolector_repeat(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1read(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (BoolectorNode *)boolector_read(arg1,arg2,arg3); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1write(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3, jlong jarg4) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *arg4 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + arg4 = *(BoolectorNode **)&jarg4; + result = (BoolectorNode *)boolector_write(arg1,arg2,arg3,arg4); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1cond(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3, jlong jarg4) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + BoolectorNode *arg4 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + arg4 = *(BoolectorNode **)&jarg4; + result = (BoolectorNode *)boolector_cond(arg1,arg2,arg3,arg4); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1param(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jstring jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorSort arg2 = (BoolectorSort) 0 ; + char *arg3 = (char *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorSort *)&jarg2; + arg3 = 0; + if (jarg3) { + arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); + if (!arg3) return 0; + } + result = (BoolectorNode *)boolector_param(arg1,arg2,(char const *)arg3); + *(BoolectorNode **)&jresult = result; + if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1fun(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3, jlong jarg4) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode **arg2 = (BoolectorNode **) 0 ; + uint32_t arg3 ; + BoolectorNode *arg4 = (BoolectorNode *) 0 ; + uint32_t *argp3 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode ***)&jarg2; + argp3 = (uint32_t *)&jarg3; + if (!argp3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null uint32_t"); + return 0; + } + arg3 = *argp3; + arg4 = *(BoolectorNode **)&jarg4; + result = (BoolectorNode *)boolector_fun(arg1,arg2,arg3,arg4); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1apply(JNIEnv *jenv, jclass jcls, jlong jarg1, jlongArray jarg2, jlong jarg3, jlong jarg4) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + jlong *array = (*jenv)->GetLongArrayElements(jenv, jarg2, 0); + uint32_t arg3 ; + BoolectorNode *arg4 = (BoolectorNode *) 0 ; + uint32_t *argp3 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + argp3 = (uint32_t *)&jarg3; + if (!argp3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null uint32_t"); + return 0; + } + arg3 = *argp3; + arg4 = *(BoolectorNode **)&jarg4; + result = (BoolectorNode *)boolector_apply(arg1,(BoolectorNode**)array,arg3,arg4); + *(BoolectorNode **)&jresult = result; + (*jenv)->ReleaseLongArrayElements(jenv, jarg2, array, 0); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1inc(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (BoolectorNode *)boolector_inc(arg1,arg2); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1dec(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (BoolectorNode *)boolector_dec(arg1,arg2); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1forall(JNIEnv *jenv, jclass jcls, jlong jarg1, jlongArray jarg2, jint jarg3, jlong jarg4) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + uint32_t arg3 = jarg3; + BoolectorNode *arg4 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + + BoolectorNode **array = 0; + array = (BoolectorNode**)(*jenv)->GetLongArrayElements(jenv, jarg2, 0); + arg4 = *(BoolectorNode **)&jarg4; + result = (BoolectorNode *)boolector_forall(arg1, array,arg3,arg4); + *(BoolectorNode **)&jresult = result; + (*jenv)->ReleaseLongArrayElements(jenv, jarg2, (jlong*)array, 0); + + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1exists(JNIEnv *jenv, jclass jcls, jlong jarg1, jlongArray jarg2, jint jarg3, jlong jarg4) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + uint32_t arg3 = jarg3; + BoolectorNode *arg4 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + + jlong *array = (*jenv)->GetLongArrayElements(jenv, jarg2, 0); + arg4 = *(BoolectorNode **)&jarg4; + result = (BoolectorNode *)boolector_exists(arg1,(BoolectorNode**)array,arg3,arg4); + *(BoolectorNode **)&jresult = result; + (*jenv)->ReleaseLongArrayElements(jenv, jarg2, array, 0); + + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1get_1btor(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jlong jresult = 0 ; + BoolectorNode *arg1 = (BoolectorNode *) 0 ; + Btor *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(BoolectorNode **)&jarg1; + result = (Btor *)boolector_get_btor(arg1); + *(Btor **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1get_1node_1id(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + int32_t result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + return boolector_get_node_id(arg1,arg2); +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1get_1sort(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorSort result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (BoolectorSort)boolector_get_sort(arg1,(struct BoolectorNode const *)arg2); + *(BoolectorSort *)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1fun_1get_1domain_1sort(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorSort result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (BoolectorSort)boolector_fun_get_domain_sort(arg1,(struct BoolectorNode const *)arg2); + *(BoolectorSort *)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1fun_1get_1codomain_1sort(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorSort result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (BoolectorSort)boolector_fun_get_codomain_sort(arg1,(struct BoolectorNode const *)arg2); + *(BoolectorSort *)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1match_1node_1by_1id(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + int32_t arg2 ; + int32_t *argp2 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + argp2 = (int32_t *)&jarg2; + if (!argp2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null int32_t"); + return 0; + } + arg2 = *argp2; + result = (BoolectorNode *)boolector_match_node_by_id(arg1,arg2); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1match_1node_1by_1symbol(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + char *arg2 = (char *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return 0; + } + result = (BoolectorNode *)boolector_match_node_by_symbol(arg1,(char const *)arg2); + *(BoolectorNode **)&jresult = result; + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1match_1node(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (BoolectorNode *)boolector_match_node(arg1,arg2); + *(BoolectorNode **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1get_1symbol(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jstring jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (char *)boolector_get_symbol(arg1,arg2); + if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1set_1symbol(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jstring jarg3) { + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + char *arg3 = (char *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = 0; + if (jarg3) { + arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); + if (!arg3) return ; + } + boolector_set_symbol(arg1,arg2,(char const *)arg3); + if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); +} + + +SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1get_1width(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + return boolector_get_width(arg1,arg2); +} + + +SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1get_1index_1width(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + return boolector_get_index_width(arg1,arg2); +} + + +SWIGEXPORT jstring JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1get_1bits(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jstring jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (char *)boolector_get_bits(arg1,arg2); + if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1free_1bits(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2) { + Btor *arg1 = (Btor *) 0 ; + char *arg2 = (char *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return ; + } + boolector_free_bits(arg1,(char const *)arg2); + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); +} + + +SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1get_1fun_1arity(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + uint32_t result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + return boolector_get_fun_arity(arg1,arg2); +} + + +SWIGEXPORT jboolean JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1is_1const(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jboolean jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + bool result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (bool)boolector_is_const(arg1,arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1is_1var(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jboolean jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + bool result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (bool)boolector_is_var(arg1,arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1is_1array(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jboolean jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + bool result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (bool)boolector_is_array(arg1,arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1is_1array_1var(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jboolean jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + bool result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (bool)boolector_is_array_var(arg1,arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1is_1param(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jboolean jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + bool result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (bool)boolector_is_param(arg1,arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1is_1bound_1param(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jboolean jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + bool result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (bool)boolector_is_bound_param(arg1,arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1is_1uf(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jboolean jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + bool result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (bool)boolector_is_uf(arg1,arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1is_1fun(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jboolean jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + bool result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (bool)boolector_is_fun(arg1,arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1fun_1sort_1check(JNIEnv *jenv, jclass jcls, jlong jarg1, jlongArray jarg2, jlong jarg3, jlong jarg4) { + Btor *arg1 = (Btor *) 0 ; + uint32_t arg3 ; + BoolectorNode *arg4 = (BoolectorNode *) 0 ; + uint32_t *argp3 ; + jint result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + jlong *array = (*jenv)->GetLongArrayElements(jenv, jarg2, 0); + argp3 = (uint32_t *)&jarg3; + if (!argp3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null uint32_t"); + return 0; + } + arg3 = *argp3; + arg4 = *(BoolectorNode **)&jarg4; + result = boolector_fun_sort_check(arg1,(BoolectorNode**)array,arg3,arg4); + (*jenv)->ReleaseLongArrayElements(jenv, jarg2, array, 0); + return result; +} + + +SWIGEXPORT jstring JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1bv_1assignment(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jstring jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + result = (char *)boolector_bv_assignment(arg1,arg2); + if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1free_1bv_1assignment(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2) { + Btor *arg1 = (Btor *) 0 ; + char *arg2 = (char *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return ; + } + boolector_free_bv_assignment(arg1,(char const *)arg2); + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1array_1assignment(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3, jlong jarg4, jlong jarg5) { + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + char ***arg3 = (char ***) 0 ; + char ***arg4 = (char ***) 0 ; + uint32_t *arg5 = (uint32_t *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(char ****)&jarg3; + arg4 = *(char ****)&jarg4; + arg5 = (uint32_t *)&jarg5; + boolector_array_assignment(arg1,arg2,arg3,arg4,arg5); +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1free_1array_1assignment(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3, jlong jarg4) { + Btor *arg1 = (Btor *) 0 ; + char **arg2 = (char **) 0 ; + char **arg3 = (char **) 0 ; + uint32_t arg4 ; + uint32_t *argp4 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(char ***)&jarg2; + arg3 = *(char ***)&jarg3; + argp4 = (uint32_t *)&jarg4; + if (!argp4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null uint32_t"); + return ; + } + arg4 = *argp4; + boolector_free_array_assignment(arg1,arg2,arg3,arg4); +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1uf_1assignment(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3, jlong jarg4, jlong jarg5) { + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + char ***arg3 = (char ***) 0 ; + char ***arg4 = (char ***) 0 ; + uint32_t *arg5 = (uint32_t *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(char ****)&jarg3; + arg4 = *(char ****)&jarg4; + arg5 = *(uint32_t **)&jarg5; + boolector_uf_assignment(arg1,arg2,arg3,arg4,arg5); +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1free_1uf_1assignment(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3, jlong jarg4) { + Btor *arg1 = (Btor *) 0 ; + char **arg2 = (char **) 0 ; + char **arg3 = (char **) 0 ; + uint32_t arg4 ; + uint32_t *argp4 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(char ***)&jarg2; + arg3 = *(char ***)&jarg3; + argp4 = (uint32_t *)&jarg4; + if (!argp4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null uint32_t"); + return ; + } + arg4 = *argp4; + boolector_free_uf_assignment(arg1,arg2,arg3,arg4); +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1print_1model(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3) { + Btor *arg1 = (Btor *) 0 ; + char *arg2 = (char *) 0 ; + FILE *arg3 = (FILE *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return ; + } + arg3 = *(FILE **)&jarg3; + boolector_print_model(arg1,arg2,arg3); + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1bool_1sort(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorSort result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + result = (BoolectorSort)boolector_bool_sort(arg1); + *(BoolectorSort *)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1bitvec_1sort(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + uint32_t arg2 ; + uint32_t *argp2 ; + BoolectorSort result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + argp2 = (uint32_t *)&jarg2; + if (!argp2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null uint32_t"); + return 0; + } + arg2 = *argp2; + result = (BoolectorSort)boolector_bitvec_sort(arg1,arg2); + *(BoolectorSort *)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1fun_1sort(JNIEnv *jenv, jclass jcls, jlong jarg1, jlongArray jarg2, jlong jarg3, jlong jarg4) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + + uint32_t arg3 ; + BoolectorSort arg4 = (BoolectorSort) 0 ; + uint32_t *argp3 ; + BoolectorSort result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + jlong *array = (*jenv)->GetLongArrayElements(jenv, jarg2, 0); + argp3 = (uint32_t *)&jarg3; + if (!argp3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null uint32_t"); + return 0; + } + arg3 = *argp3; + arg4 = *(BoolectorSort *)&jarg4; + result = (BoolectorSort)boolector_fun_sort(arg1,(BoolectorSort*)array,arg3,arg4); + *(BoolectorSort *)&jresult = result; + (*jenv)->ReleaseLongArrayElements(jenv, jarg2, array, 0); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1array_1sort(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorSort arg2 = (BoolectorSort) 0 ; + BoolectorSort arg3 = (BoolectorSort) 0 ; + BoolectorSort result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorSort *)&jarg2; + arg3 = *(BoolectorSort *)&jarg3; + result = (BoolectorSort)boolector_array_sort(arg1,arg2,arg3); + *(BoolectorSort *)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1copy_1sort(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jlong jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorSort arg2 = (BoolectorSort) 0 ; + BoolectorSort result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorSort *)&jarg2; + result = (BoolectorSort)boolector_copy_sort(arg1,arg2); + *(BoolectorSort *)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1release_1sort(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + Btor *arg1 = (Btor *) 0 ; + BoolectorSort arg2 = (BoolectorSort) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorSort *)&jarg2; + boolector_release_sort(arg1,arg2); +} + + +SWIGEXPORT jboolean JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1is_1equal_1sort(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jboolean jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + bool result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + result = (bool)boolector_is_equal_sort(arg1,arg2,arg3); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1is_1array_1sort(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jboolean jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorSort arg2 = (BoolectorSort) 0 ; + bool result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorSort *)&jarg2; + result = (bool)boolector_is_array_sort(arg1,arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1is_1bitvec_1sort(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jboolean jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorSort arg2 = (BoolectorSort) 0 ; + bool result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorSort *)&jarg2; + result = (bool)boolector_is_bitvec_sort(arg1,arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1is_1fun_1sort(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jboolean jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + BoolectorSort arg2 = (BoolectorSort) 0 ; + bool result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorSort *)&jarg2; + result = (bool)boolector_is_fun_sort(arg1,arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1parse(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jstring jarg3, jlong jarg4, jlong jarg5, jlong jarg6) { + Btor *arg1 = (Btor *) 0 ; + FILE *arg2 = (FILE *) 0 ; + char *arg3 = (char *) 0 ; + FILE *arg4 = (FILE *) 0 ; + char **arg5 = (char **) 0 ; + int32_t *arg6 = (int32_t *) 0 ; + jint result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(FILE **)&jarg2; + arg3 = 0; + if (jarg3) { + arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); + if (!arg3) return 0; + } + arg4 = *(FILE **)&jarg4; + arg5 = *(char ***)&jarg5; + arg6 = *(int32_t **)&jarg6; + result = boolector_parse(arg1,arg2,(char const *)arg3,arg4,arg5,arg6); + if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); + return result; +} + + +SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1parse_1btor(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jstring jarg3, jlong jarg4, jlong jarg5, jlong jarg6) { + Btor *arg1 = (Btor *) 0 ; + FILE *arg2 = (FILE *) 0 ; + char *arg3 = (char *) 0 ; + FILE *arg4 = (FILE *) 0 ; + char **arg5 = (char **) 0 ; + int32_t *arg6 = (int32_t *) 0 ; + jint result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(FILE **)&jarg2; + arg3 = 0; + if (jarg3) { + arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); + if (!arg3) return 0; + } + arg4 = *(FILE **)&jarg4; + arg5 = *(char ***)&jarg5; + arg6 = *(int32_t **)&jarg6; + result = boolector_parse_btor(arg1,arg2,(char const *)arg3,arg4,arg5,arg6); + if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); + return result; +} + + +SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1parse_1btor2(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jstring jarg3, jlong jarg4, jlong jarg5, jlong jarg6) { + Btor *arg1 = (Btor *) 0 ; + FILE *arg2 = (FILE *) 0 ; + char *arg3 = (char *) 0 ; + FILE *arg4 = (FILE *) 0 ; + char **arg5 = (char **) 0 ; + int32_t *arg6 = (int32_t *) 0 ; + jint result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(FILE **)&jarg2; + arg3 = 0; + if (jarg3) { + arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); + if (!arg3) return 0; + } + arg4 = *(FILE **)&jarg4; + arg5 = *(char ***)&jarg5; + arg6 = *(int32_t **)&jarg6; + result = boolector_parse_btor2(arg1,arg2,(char const *)arg3,arg4,arg5,arg6); + if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); + return result; +} + + +SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1parse_1smt1(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jstring jarg3, jlong jarg4, jlong jarg5, jlong jarg6) { + Btor *arg1 = (Btor *) 0 ; + FILE *arg2 = (FILE *) 0 ; + char *arg3 = (char *) 0 ; + FILE *arg4 = (FILE *) 0 ; + char **arg5 = (char **) 0 ; + int32_t *arg6 = (int32_t *) 0 ; + jint result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(FILE **)&jarg2; + arg3 = 0; + if (jarg3) { + arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); + if (!arg3) return 0; + } + arg4 = *(FILE **)&jarg4; + arg5 = *(char ***)&jarg5; + arg6 = *(int32_t **)&jarg6; + result = boolector_parse_smt1(arg1,arg2,(char const *)arg3,arg4,arg5,arg6); + if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); + return result; +} + + +SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1parse_1smt2(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jstring jarg3, jlong jarg4, jlong jarg5, jlong jarg6) { + Btor *arg1 = (Btor *) 0 ; + FILE *arg2 = (FILE *) 0 ; + char *arg3 = (char *) 0 ; + FILE *arg4 = (FILE *) 0 ; + char **arg5 = (char **) 0 ; + int32_t *arg6 = (int32_t *) 0 ; + jint result; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(FILE **)&jarg2; + arg3 = 0; + if (jarg3) { + arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); + if (!arg3) return 0; + } + arg4 = *(FILE **)&jarg4; + arg5 = *(char ***)&jarg5; + arg6 = *(int32_t **)&jarg6; + result = boolector_parse_smt2(arg1,arg2,(char const *)arg3,arg4,arg5,arg6); + if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); + return result; +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1dump_1btor_1node(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + Btor *arg1 = (Btor *) 0 ; + FILE *arg2 = (FILE *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(FILE **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + boolector_dump_btor_node(arg1,arg2,arg3); +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1dump_1btor(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + Btor *arg1 = (Btor *) 0 ; + FILE *arg2 = (FILE *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(FILE **)&jarg2; + boolector_dump_btor(arg1,arg2); +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1dump_1smt2_1node(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + Btor *arg1 = (Btor *) 0 ; + FILE *arg2 = (FILE *) 0 ; + BoolectorNode *arg3 = (BoolectorNode *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(FILE **)&jarg2; + arg3 = *(BoolectorNode **)&jarg3; + boolector_dump_smt2_node(arg1,arg2,arg3); +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1dump_1smt2(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + Btor *arg1 = (Btor *) 0 ; + FILE *arg2 = (FILE *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(FILE **)&jarg2; + boolector_dump_smt2(arg1,arg2); +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1dump_1aiger_1ascii(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jboolean jarg3) { + Btor *arg1 = (Btor *) 0 ; + FILE *arg2 = (FILE *) 0 ; + bool arg3 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(FILE **)&jarg2; + arg3 = jarg3 ? true : false; + boolector_dump_aiger_ascii(arg1,arg2,arg3); +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1dump_1aiger_1binary(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jboolean jarg3) { + Btor *arg1 = (Btor *) 0 ; + FILE *arg2 = (FILE *) 0 ; + bool arg3 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + arg2 = *(FILE **)&jarg2; + arg3 = jarg3 ? true : false; + boolector_dump_aiger_binary(arg1,arg2,arg3); +} + + +SWIGEXPORT jstring JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1copyright(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jstring jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + result = (char *)boolector_copyright(arg1); + if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1version(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jstring jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + result = (char *)boolector_version(arg1); + if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1git_1id(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jstring jresult = 0 ; + Btor *arg1 = (Btor *) 0 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + result = (char *)boolector_git_id(arg1); + if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_BTOR_1RESULT_1SAT_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + enum BtorSolverResult result; + + (void)jenv; + (void)jcls; + result = (enum BtorSolverResult)BTOR_RESULT_SAT; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_BTOR_1RESULT_1UNSAT_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + enum BtorSolverResult result; + + (void)jenv; + (void)jcls; + result = (enum BtorSolverResult)BTOR_RESULT_UNSAT; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_BTOR_1RESULT_1UNKNOWN_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + enum BtorSolverResult result; + + (void)jenv; + (void)jcls; + result = (enum BtorSolverResult)BTOR_RESULT_UNKNOWN; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_BtorAbortCallback_1abort_1fun_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + struct BtorAbortCallback *arg1 = (struct BtorAbortCallback *) 0 ; + void (*arg2)(char const *) = (void (*)(char const *)) 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct BtorAbortCallback **)&jarg1; + arg2 = *(void (**)(char const *))&jarg2; + if (arg1) (arg1)->abort_fun = arg2; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_BtorAbortCallback_1abort_1fun_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + struct BtorAbortCallback *arg1 = (struct BtorAbortCallback *) 0 ; + void (*result)(char const *) = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct BtorAbortCallback **)&jarg1; + result = (void (*)(char const *)) ((arg1)->abort_fun); + *(void (**)(char const *))&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_BtorAbortCallback_1cb_1fun_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + struct BtorAbortCallback *arg1 = (struct BtorAbortCallback *) 0 ; + void *arg2 = (void *) 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct BtorAbortCallback **)&jarg1; + arg2 = *(void **)&jarg2; + if (arg1) (arg1)->cb_fun = arg2; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_BtorAbortCallback_1cb_1fun_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + struct BtorAbortCallback *arg1 = (struct BtorAbortCallback *) 0 ; + void *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct BtorAbortCallback **)&jarg1; + result = (void *) ((arg1)->cb_fun); + *(void **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_new_1BtorAbortCallback(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + struct BtorAbortCallback *result = 0 ; + + (void)jenv; + (void)jcls; + result = (struct BtorAbortCallback *)calloc(1, sizeof(struct BtorAbortCallback)); + *(struct BtorAbortCallback **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_delete_1BtorAbortCallback(JNIEnv *jenv, jclass jcls, jlong jarg1) { + struct BtorAbortCallback *arg1 = (struct BtorAbortCallback *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(struct BtorAbortCallback **)&jarg1; + free((char *) arg1); +} + + +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_btor_1abort_1callback_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + BtorAbortCallback *arg1 = (BtorAbortCallback *) 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(BtorAbortCallback **)&jarg1; + btor_abort_callback = *arg1; +} + + +SWIGEXPORT jlong JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_btor_1abort_1callback_1get(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + BtorAbortCallback *result = 0 ; + + (void)jenv; + (void)jcls; + result = (BtorAbortCallback *)&btor_abort_callback; + *(BtorAbortCallback **)&jresult = result; + return jresult; +} + +//helpmethods + + //dumps complete model into new file and reads it to give it back +SWIGEXPORT jstring JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1help_1dump_1smt2(JNIEnv *jenv, jclass jcls, jlong jarg1) { + jstring jresult = 0; + Btor *arg1 = (Btor *) 0 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + + char * buffer = 0; + long length; + FILE *f = 0; + f = fopen("temp", "w+"); + if(f==NULL) { + perror("ERROR"); + } + + //fclose (f); + + //write + boolector_dump_smt2(arg1, f); + + //read + if (f) + { + fseek (f, 0, SEEK_END); + length = ftell (f); + fseek (f, 0, SEEK_SET); + buffer = malloc (length); + if (buffer) + { + fread (buffer, 1, length, f); + } + fclose (f); + } + + if (buffer) + { + result = buffer; + } + + + if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); + return jresult; +} + + //helper method for parsing string into btor + SWIGEXPORT jint JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1help_1parse(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2) { + int32_t result = 0; + Btor *arg1 = (Btor *) 0 ; + jint jresult = 0 ; + int32_t *status = (int32_t *) 0 ; + char **errormsg = (char **) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + char *arg2 = (char *) 0 ; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return 0; + } + + FILE *f = 0; + f = fopen("temp", "w+"); + if(f==NULL) { + perror("ERROR_INPUTFILE"); + } + fputs(arg2, f); + fclose (f); + + FILE *fout = 0; + fout = fopen("tempout", "w+"); + if(fout==NULL) { + perror("ERROR_OUTPUTFILE"); + } + fclose (fout); + + //"read" (parse) + result = boolector_parse(arg1, f, "temp", fout, errormsg, status); + jresult = (jint)result; + + return jresult; +} + + //dumps NODE into new file and reads it to give it back +SWIGEXPORT jstring JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1help_1dump_1node_1smt2(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + jstring jresult = 0; + Btor *arg1 = (Btor *) 0 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(Btor **)&jarg1; + + char * buffer = 0; + long length; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + arg2 = *(BoolectorNode **)&jarg2; + + FILE *f = 0; + f = fopen("temp", "w+"); + if(f==NULL) { + perror("ERROR: COULDNT DUMP NODE BECAUSE IT COULDNT CREATE A DUMP FILE"); + } + + //fclose (f); + + //write + boolector_dump_smt2_node(arg1, f, arg2); + + //read + if (f) + { + fseek (f, 0, SEEK_END); + length = ftell (f); + fseek (f, 0, SEEK_SET); + buffer = malloc (length); + if (buffer) + { + fread (buffer, 1, length, f); + } + fclose (f); + } + + if (buffer) + { + result = buffer; + } + + + if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); + return jresult; +} + + + //reads uf assignment and gives back array with 3 slots, first is size of the other 2 entrys, second and third are arrays, second is uf argument assignment strings, third is uf value assignments +SWIGEXPORT void JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1uf_1assignment_1helper(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + char ***arg3 = (char ***) 0 ; + char ***arg4 = (char ***) 0 ; + uint32_t *arg5 = (uint32_t *) 0 ; + + (void)jenv; + (void)jcls; + + int i = 0; + int j = 0; + + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + + boolector_uf_assignment(arg1,arg2,arg3,arg4,arg5); + + if(arg3 == 0 || arg4 == 0 || arg5 == 0) return ((void*)0) ; + + jsize arrayLength = *arg5; + int arrayLengthInt = *arg5; + char **workArray = *arg3; + + jclass classString = (*jenv)->FindClass(jenv, "java/lang/String"); + jclass classArray = (*jenv)->FindClass(jenv, "[Ljava/lang/Object;"); + + jobjectArray outerJNIArray = (jobjectArray)(*jenv)->NewObjectArray(jenv, 2, classArray, NULL); + + for(i=0;i<2;i++) { + jobjectArray innerJNIArray = (jobjectArray)(*jenv)->NewObjectArray(jenv, arrayLength, classString, (*jenv)->NewStringUTF(jenv, "")); + + for(j=0;jSetObjectArrayElement(jenv, innerJNIArray, j, (*jenv)->NewStringUTF(jenv, workArray[j])); + } + //switch to second Array + workArray = *arg4; + (*jenv)->SetObjectArrayElement(jenv, outerJNIArray, i, innerJNIArray); + (*jenv)->DeleteLocalRef(jenv, innerJNIArray); + } + (*jenv)->DeleteLocalRef(jenv, classString); + (*jenv)->DeleteLocalRef(jenv, classArray); + + return outerJNIArray; +} + +//helper method for arrays similiar to the uf one +SWIGEXPORT jobjectArray JNICALL Java_org_sosy_1lab_java_1smt_solvers_boolector_BtorJNI_boolector_1array_1assignment_1helper(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) { + Btor *arg1 = (Btor *) 0 ; + BoolectorNode *arg2 = (BoolectorNode *) 0 ; + char ***arg3 = (char ***) 0 ; + char ***arg4 = (char ***) 0 ; + uint32_t *arg5 = (uint32_t *) 0 ; + + (void)jenv; + (void)jcls; + + int i = 0; + int j = 0; + + arg1 = *(Btor **)&jarg1; + arg2 = *(BoolectorNode **)&jarg2; + + boolector_array_assignment(arg1,arg2,arg3,arg4,arg5); + + if(arg3 == 0 || arg4 == 0 || arg5 == 0) return ((void*)0) ; + + jsize arrayLength = *arg5; + int arrayLengthInt = *arg5; + char **workArray = *arg3; + + jclass classString = (*jenv)->FindClass(jenv, "java/lang/String"); + jclass classArray = (*jenv)->FindClass(jenv, "[Ljava/lang/Object;"); + + jobjectArray outerJNIArray = (jobjectArray)(*jenv)->NewObjectArray(jenv, 2, classArray, NULL); + + for(i=0;i<2;i++) { + jobjectArray innerJNIArray = (jobjectArray)(*jenv)->NewObjectArray(jenv, arrayLength, classString, (*jenv)->NewStringUTF(jenv, "")); + + for(j=0;jSetObjectArrayElement(jenv, innerJNIArray, j, (*jenv)->NewStringUTF(jenv, workArray[j])); + } + //switch to second Array + workArray = *arg4; + (*jenv)->SetObjectArrayElement(jenv, outerJNIArray, i, innerJNIArray); + (*jenv)->DeleteLocalRef(jenv, innerJNIArray); + } + (*jenv)->DeleteLocalRef(jenv, classString); + (*jenv)->DeleteLocalRef(jenv, classArray); + + return outerJNIArray; +} + +#ifdef __cplusplus +} +#endif + diff --git a/lib/native/x86_64-linux/libboolector.so b/lib/native/x86_64-linux/libboolector.so new file mode 120000 index 0000000000..c20b21c0a9 --- /dev/null +++ b/lib/native/x86_64-linux/libboolector.so @@ -0,0 +1 @@ +../../java/runtime/libboolector.so \ No newline at end of file diff --git a/lib/native/x86_64-linux/libminisat.so b/lib/native/x86_64-linux/libminisat.so new file mode 120000 index 0000000000..0aa60a0706 --- /dev/null +++ b/lib/native/x86_64-linux/libminisat.so @@ -0,0 +1 @@ +../../java/runtime/libminisat.so \ No newline at end of file diff --git a/lib/native/x86_64-linux/libpicosat.so b/lib/native/x86_64-linux/libpicosat.so new file mode 120000 index 0000000000..15e9176866 --- /dev/null +++ b/lib/native/x86_64-linux/libpicosat.so @@ -0,0 +1 @@ +../../java/runtime/libpicosat.so \ No newline at end of file diff --git a/solvers_ivy_conf/ivy_boolector.xml b/solvers_ivy_conf/ivy_boolector.xml new file mode 100644 index 0000000000..d3648b87c9 --- /dev/null +++ b/solvers_ivy_conf/ivy_boolector.xml @@ -0,0 +1,26 @@ + + + + + + Boolector solver and JavaSMT JNI wrapper. + Boolector is provided under the MIT License. + + + + + + + + + + + + + + + + diff --git a/src/org/sosy_lab/java_smt/SolverContextFactory.java b/src/org/sosy_lab/java_smt/SolverContextFactory.java index f699ba452c..572b77552a 100644 --- a/src/org/sosy_lab/java_smt/SolverContextFactory.java +++ b/src/org/sosy_lab/java_smt/SolverContextFactory.java @@ -51,6 +51,7 @@ import org.sosy_lab.java_smt.api.SolverContext; import org.sosy_lab.java_smt.basicimpl.AbstractNumeralFormulaManager.NonLinearArithmetic; import org.sosy_lab.java_smt.logging.LoggingSolverContext; +import org.sosy_lab.java_smt.solvers.boolector.BoolectorSolverContext; import org.sosy_lab.java_smt.solvers.cvc4.CVC4SolverContext; import org.sosy_lab.java_smt.solvers.mathsat5.Mathsat5SolverContext; import org.sosy_lab.java_smt.solvers.princess.PrincessSolverContext; @@ -70,6 +71,7 @@ public enum Solvers { SMTINTERPOL, Z3, PRINCESS, + BOOLECTOR, CVC4 } @@ -225,6 +227,9 @@ private SolverContext generateContext0(Solvers solverToCreate) return PrincessSolverContext.create( config, shutdownNotifier, logfile, (int) randomSeed, nonLinearArithmetic); + case BOOLECTOR: + return BoolectorSolverContext.create(config, shutdownNotifier, logfile, (int) randomSeed); + default: throw new AssertionError("no solver selected"); } diff --git a/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorAbstractProver.java b/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorAbstractProver.java new file mode 100644 index 0000000000..f564bc5072 --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorAbstractProver.java @@ -0,0 +1,166 @@ +/* + * JavaSMT is an API wrapper for a collection of SMT solvers. + * This file is part of JavaSMT. + * + * Copyright (C) 2007-2019 Dirk Beyer + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.sosy_lab.java_smt.solvers.boolector; + +import com.google.common.base.Preconditions; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Deque; +import java.util.List; +import java.util.Optional; +import java.util.Set; +import org.checkerframework.checker.nullness.qual.Nullable; +import org.sosy_lab.common.ShutdownNotifier; +import org.sosy_lab.java_smt.api.BooleanFormula; +import org.sosy_lab.java_smt.api.Model; +import org.sosy_lab.java_smt.api.SolverContext.ProverOptions; +import org.sosy_lab.java_smt.api.SolverException; +import org.sosy_lab.java_smt.basicimpl.AbstractProverWithAllSat; + +abstract class BoolectorAbstractProver extends AbstractProverWithAllSat { + // BoolectorAbstractProver extends AbstractProverWithAllSat + // AF = assertedFormulas; E = ? + + private final long btor; + private final BoolectorFormulaManager manager; + private final BoolectorFormulaCreator creator; + protected final Deque> assertedFormulas = new ArrayDeque<>(); + protected boolean wasLastSatCheckSat = false; // and stack is not changed + + // Used/Built by TheoremProver + protected BoolectorAbstractProver( + BoolectorFormulaManager manager, + BoolectorFormulaCreator creator, + long btor, + ShutdownNotifier pShutdownNotifier, + Set pOptions) { + super(pOptions, manager.getBooleanFormulaManager(), pShutdownNotifier); + this.manager = manager; + this.creator = creator; + this.btor = btor; + } + + @Override + public void close() { + if (!closed) { + // Problem: Cloning results in not beeing able to access var with old name (string) + // NOT Cloning results in murdering btor that is still beeing used + // closing of assertions only by using boolector_release + // BtorJNI.boolector_delete(btor); + BtorJNI.boolector_pop(manager.getEnvironment(), assertedFormulas.size()); + assertedFormulas.clear(); + closed = true; + } + } + + /* + * Boolector should throw its own exceptions that tell you what went wrong! + */ + @Override + public boolean isUnsat() throws SolverException { + Preconditions.checkState(!closed); + wasLastSatCheckSat = false; + final int result = BtorJNI.boolector_sat(btor); + if (result == BtorJNI.BTOR_RESULT_SAT_get()) { + wasLastSatCheckSat = true; + return false; + } else if (result == BtorJNI.BTOR_RESULT_UNSAT_get()) { + return true; + } else if (result == BtorJNI.BTOR_RESULT_UNKNOWN_get()) { + throw new SolverException( + "Boolector encountered a problem or ran out of stack or heap memory, " + + "try increasing their sizes."); + } else { + throw new SolverException("Boolector sat call returned " + result); + } + } + + @Override + public void pop() { + assertedFormulas.pop(); + BtorJNI.boolector_pop(manager.getEnvironment(), 1); + } + + @Override + public void push() { + assertedFormulas.push(new ArrayList<>()); + BtorJNI.boolector_push(manager.getEnvironment(), 1); + } + + @Override + public boolean isUnsatWithAssumptions(Collection pAssumptions) + throws SolverException, InterruptedException { + Preconditions.checkState(!closed); + for (BooleanFormula assumption : pAssumptions) { + BtorJNI.boolector_assume(btor, BoolectorFormulaManager.getBtorTerm(assumption)); + } + return isUnsat(); + } + + @Override + public Model getModel() throws SolverException { + Preconditions.checkState(!closed); + Preconditions.checkState(wasLastSatCheckSat, NO_MODEL_HELP); + checkGenerateModels(); + return getModelWithoutChecks(); + } + + @Override + public List getUnsatCore() { + throw new UnsupportedOperationException("Unsat core is not supported by Boolector."); + } + + @Override + public Optional> unsatCoreOverAssumptions( + Collection pAssumptions) throws SolverException, InterruptedException { + throw new UnsupportedOperationException( + "Unsat core with assumptions is not supported by Boolector."); + } + + @Override + protected Model getModelWithoutChecks() { + return new BoolectorModel(btor, creator, this, getAssertedTerms()); + } + + @Override + @Nullable + public T addConstraint(BooleanFormula constraint) { + BtorJNI.boolector_assert( + manager.getEnvironment(), BoolectorFormulaManager.getBtorTerm(constraint)); + assertedFormulas.peek().add(BoolectorFormulaManager.getBtorTerm(constraint)); + return null; + } + + protected Collection getAssertedTerms() { + List result = new ArrayList<>(); + assertedFormulas.forEach(result::addAll); + return result; + } + + /** + * Simply returns true if the prover is closed. False otherwise. + * + * @return bool return value. + */ + protected boolean isClosed() { + return closed; + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorArrayFormulaManager.java b/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorArrayFormulaManager.java new file mode 100644 index 0000000000..b5713f8bcb --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorArrayFormulaManager.java @@ -0,0 +1,79 @@ +/* + * JavaSMT is an API wrapper for a collection of SMT solvers. + * This file is part of JavaSMT. + * + * Copyright (C) 2007-2019 Dirk Beyer + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.sosy_lab.java_smt.solvers.boolector; + +import com.google.common.collect.Table; +import org.sosy_lab.java_smt.api.Formula; +import org.sosy_lab.java_smt.api.FormulaType; +import org.sosy_lab.java_smt.api.FormulaType.BitvectorType; +import org.sosy_lab.java_smt.basicimpl.AbstractArrayFormulaManager; + +public class BoolectorArrayFormulaManager + extends AbstractArrayFormulaManager { + + private final long btor; + private final Table nameFormulaCache; + + BoolectorArrayFormulaManager(BoolectorFormulaCreator pCreator) { + super(pCreator); + this.btor = pCreator.getEnv(); + this.nameFormulaCache = pCreator.getCache(); + } + + // pIndex should be a bitVector + @Override + protected Long select(Long pArray, Long pIndex) { + return BtorJNI.boolector_read(btor, pArray, pIndex); + } + + // pIndex and pValue should be bitVectors + @Override + protected Long store(Long pArray, Long pIndex, Long pValue) { + return BtorJNI.boolector_write(btor, pArray, pIndex, pValue); + } + + @Override + protected Long internalMakeArray( + String name, FormulaType pIndexType, FormulaType pElementType) { + if (!pIndexType.isBitvectorType() || !pElementType.isBitvectorType()) { + throw new IllegalArgumentException("Boolector supports bitvector arrays only."); + } + BitvectorType indexType = (BitvectorType) pIndexType; + BitvectorType elementType = (BitvectorType) pElementType; + final long indexSort = BtorJNI.boolector_bitvec_sort(btor, indexType.getSize()); + final long elementSort = BtorJNI.boolector_bitvec_sort(btor, elementType.getSize()); + final long arraySort = BtorJNI.boolector_array_sort(btor, indexSort, elementSort); + Long maybeFormula = nameFormulaCache.get(name, arraySort); + if (maybeFormula != null) { + return maybeFormula; + } + if (nameFormulaCache.containsRow(name)) { + throw new IllegalArgumentException("Symbol already used: " + name); + } + final long array = BtorJNI.boolector_array(btor, arraySort, name); + nameFormulaCache.put(name, arraySort, array); + return array; + } + + @Override + protected Long equivalence(Long pArray1, Long pArray2) { + return BtorJNI.boolector_eq(btor, pArray1, pArray2); + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorBitvectorFormulaManager.java b/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorBitvectorFormulaManager.java new file mode 100644 index 0000000000..9c5f242e9f --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorBitvectorFormulaManager.java @@ -0,0 +1,218 @@ +/* + * JavaSMT is an API wrapper for a collection of SMT solvers. + * This file is part of JavaSMT. + * + * Copyright (C) 2007-2019 Dirk Beyer + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.sosy_lab.java_smt.solvers.boolector; + +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_add; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_and; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_concat; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_eq; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_mul; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_neg; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_not; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_or; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_sdiv; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_sext; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_sgt; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_sgte; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_sll; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_slt; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_slte; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_smod; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_sra; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_srl; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_sub; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_udiv; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_uext; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_ugt; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_ugte; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_ult; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_ulte; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_urem; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_xor; + +import java.math.BigInteger; +import org.sosy_lab.java_smt.basicimpl.AbstractBitvectorFormulaManager; + +class BoolectorBitvectorFormulaManager + extends AbstractBitvectorFormulaManager { + + private final long btor; + + BoolectorBitvectorFormulaManager(BoolectorFormulaCreator creator) { + super(creator); + this.btor = creator.getEnv(); + } + + @Override + public Long makeBitvectorImpl(int pLength, BigInteger pI) { + pI = transformValueToRange(pLength, pI); + long sort = BtorJNI.boolector_bitvec_sort(btor, pLength); + return BtorJNI.boolector_constd(btor, sort, pI.toString()); + } + + @Override + protected Long makeBitvectorImpl(int length, Long value) { + // The value is a pointer to an expression. Do not use the plain numberal value. + throw new UnsupportedOperationException("Boolector does not support INT theory"); + } + + @Override + public Long toIntegerFormulaImpl(Long pI, boolean pSigned) { + throw new UnsupportedOperationException("BV to INT conversion is not supported."); + } + + @Override + public Long negate(Long bitVec) { + return boolector_neg(btor, bitVec); + } + + @Override + public Long add(Long bitVec1, Long bitVec2) { + return boolector_add(btor, bitVec1, bitVec2); + } + + @Override + public Long subtract(Long bitVec1, Long bitVec2) { + return boolector_sub(btor, bitVec1, bitVec2); + } + + @Override + public Long divide(Long bitVec1, Long bitVec2, boolean signed) { + if (signed) { + return boolector_sdiv(btor, bitVec1, bitVec2); + } else { + return boolector_udiv(btor, bitVec1, bitVec2); + } + } + + @Override + public Long modulo(Long bitVec1, Long bitVec2, boolean signed) { + if (signed) { + return boolector_smod(btor, bitVec1, bitVec2); + } else { + return boolector_urem(btor, bitVec1, bitVec2); + } + } + + @Override + public Long multiply(Long bitVec1, Long bitVec2) { + return boolector_mul(btor, bitVec1, bitVec2); + } + + @Override + public Long equal(Long bitVec1, Long bitVec2) { + return boolector_eq(btor, bitVec1, bitVec2); + } + + @Override + public Long greaterThan(Long bitVec1, Long bitVec2, boolean signed) { + if (signed) { + return boolector_sgt(btor, bitVec1, bitVec2); + } else { + return boolector_ugt(btor, bitVec1, bitVec2); + } + } + + @Override + public Long greaterOrEquals(Long bitVec1, Long bitVec2, boolean signed) { + if (signed) { + return boolector_sgte(btor, bitVec1, bitVec2); + } else { + return boolector_ugte(btor, bitVec1, bitVec2); + } + } + + @Override + public Long lessThan(Long bitVec1, Long bitVec2, boolean signed) { + if (signed) { + return boolector_slt(btor, bitVec1, bitVec2); + } else { + return boolector_ult(btor, bitVec1, bitVec2); + } + } + + @Override + public Long lessOrEquals(Long bitVec1, Long bitVec2, boolean signed) { + if (signed) { + return boolector_slte(btor, bitVec1, bitVec2); + } else { + return boolector_ulte(btor, bitVec1, bitVec2); + } + } + + @Override + public Long not(Long bitVec) { + return boolector_not(btor, bitVec); + } + + @Override + public Long and(Long bitVec1, Long bitVec2) { + return boolector_and(btor, bitVec1, bitVec2); + } + + @Override + public Long or(Long bitVec1, Long bitVec2) { + return boolector_or(btor, bitVec1, bitVec2); + } + + @Override + public Long xor(Long bitVec1, Long bitVec2) { + return boolector_xor(btor, bitVec1, bitVec2); + } + + @Override + public Long makeVariableImpl(int pLength, String pVar) { + long sort = BtorJNI.boolector_bitvec_sort(btor, pLength); + return getFormulaCreator().makeVariable(sort, pVar); + } + + @Override + public Long shiftRight(Long bitVec, Long toShift, boolean signed) { + if (signed) { + return boolector_sra(btor, bitVec, toShift); + } else { + return boolector_srl(btor, bitVec, toShift); + } + } + + @Override + public Long shiftLeft(Long bitVec, Long toShift) { + return boolector_sll(btor, bitVec, toShift); + } + + @Override + public Long concat(Long bitVec, Long bitVecAppend) { + return boolector_concat(btor, bitVec, bitVecAppend); + } + + @Override + public Long extract(Long pNode, int pMsb, int pLsb, boolean pSigned) { + return BtorJNI.boolector_slice(btor, pNode, pMsb, pLsb); + } + + @Override + public Long extend(Long bitVec, int extensionBits, boolean signed) { + if (signed) { + return boolector_sext(btor, bitVec, extensionBits); + } else { + return boolector_uext(btor, bitVec, extensionBits); + } + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorBooleanFormulaManager.java b/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorBooleanFormulaManager.java new file mode 100644 index 0000000000..2813846b7c --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorBooleanFormulaManager.java @@ -0,0 +1,112 @@ +/* + * JavaSMT is an API wrapper for a collection of SMT solvers. + * This file is part of JavaSMT. + * + * Copyright (C) 2007-2019 Dirk Beyer + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.sosy_lab.java_smt.solvers.boolector; + +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_and; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_cond; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_false; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_iff; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_not; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_or; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_true; +import static org.sosy_lab.java_smt.solvers.boolector.BtorJNI.boolector_xor; + +import com.google.common.primitives.Longs; +import org.sosy_lab.java_smt.basicimpl.AbstractBooleanFormulaManager; + +public class BoolectorBooleanFormulaManager + extends AbstractBooleanFormulaManager { + + private final long btor; + + BoolectorBooleanFormulaManager(BoolectorFormulaCreator pCreator) { + super(pCreator); + this.btor = pCreator.getEnv(); + } + + @Override + public Long makeVariableImpl(String varName) { + long boolType = getFormulaCreator().getBoolType(); + return getFormulaCreator().makeVariable(boolType, varName); + } + + @Override + public Long makeBooleanImpl(boolean pValue) { + if (pValue) { + return boolector_true(btor); + } else { + return boolector_false(btor); + } + } + + @Override + public Long not(Long pParam1) { + return boolector_not(btor, pParam1); + } + + @Override + public Long and(Long pParam1, Long pParam2) { + return boolector_and(btor, pParam1, pParam2); + } + + @Override + public Long or(Long pParam1, Long pParam2) { + return boolector_or(btor, pParam1, pParam2); + } + + @Override + public Long xor(Long pParam1, Long pParam2) { + return boolector_xor(btor, pParam1, pParam2); + } + + @Override + public Long equivalence(Long pBits1, Long pBits2) { + return boolector_iff(btor, pBits1, pBits2); + } + + @Override + public boolean isTrue(Long pBits) { + return isConstant(pBits, 1); + } + + @Override + public boolean isFalse(Long pBits) { + return isConstant(pBits, 0); + } + + private boolean isConstant(final long pBits, final int constant) { + if (BtorJNI.boolector_get_width(btor, pBits) == 1) { + String assignment; + if (BtorJNI.boolector_is_const(btor, pBits)) { + assignment = BtorJNI.boolector_get_bits(btor, pBits); + Long maybeLong = Longs.tryParse(assignment); + if (maybeLong != null && maybeLong == constant) { + return true; + } + } + } + return false; + } + + @Override + public Long ifThenElse(Long pCond, Long pF1, Long pF2) { + return boolector_cond(btor, pCond, pF1, pF2); + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorFormula.java b/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorFormula.java new file mode 100644 index 0000000000..96480be7cb --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorFormula.java @@ -0,0 +1,98 @@ +/* + * JavaSMT is an API wrapper for a collection of SMT solvers. + * This file is part of JavaSMT. + * + * Copyright (C) 2007-2019 Dirk Beyer + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.sosy_lab.java_smt.solvers.boolector; + +import com.google.errorprone.annotations.Immutable; +import org.sosy_lab.java_smt.api.ArrayFormula; +import org.sosy_lab.java_smt.api.BitvectorFormula; +import org.sosy_lab.java_smt.api.BooleanFormula; +import org.sosy_lab.java_smt.api.Formula; +import org.sosy_lab.java_smt.api.FormulaType; + +@Immutable +abstract class BoolectorFormula implements Formula { + + private final long btorTerm; + private final long btor; // We need the boolector instance to calculate the hash + + BoolectorFormula(long term, long btor) { + this.btorTerm = term; + this.btor = btor; + } + + final long getTerm() { + return btorTerm; + } + + @Override + public final boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof BoolectorFormula)) { + return false; + } + BoolectorFormula other = (BoolectorFormula) o; + return btor == other.btor && btorTerm == other.btorTerm; + } + + @Override + public final int hashCode() { + // Boolector uses structural hashing on its nodes (formulas) + return BtorJNI.boolector_get_node_id(btor, btorTerm); + } + + @Immutable + static final class BoolectorBitvectorFormula extends BoolectorFormula + implements BitvectorFormula { + BoolectorBitvectorFormula(long pTerm, long btor) { + super(pTerm, btor); + } + } + + @Immutable + static final class BoolectorBooleanFormula extends BoolectorFormula implements BooleanFormula { + BoolectorBooleanFormula(long pTerm, long btor) { + super(pTerm, btor); + } + } + + static final class BoolectorArrayFormula + extends BoolectorFormula implements ArrayFormula { + + private final FormulaType indexType; + private final FormulaType elementType; + + BoolectorArrayFormula( + long pTerm, FormulaType pIndexType, FormulaType pElementType, long btor) { + super(pTerm, btor); + indexType = pIndexType; + elementType = pElementType; + } + + public FormulaType getIndexType() { + return indexType; + } + + public FormulaType getElementType() { + return elementType; + } + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorFormulaCreator.java b/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorFormulaCreator.java new file mode 100644 index 0000000000..ce2af33cf6 --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorFormulaCreator.java @@ -0,0 +1,377 @@ +/* + * JavaSMT is an API wrapper for a collection of SMT solvers. + * This file is part of JavaSMT. + * + * Copyright (C) 2007-2019 Dirk Beyer + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.sosy_lab.java_smt.solvers.boolector; + +import static com.google.common.base.Preconditions.checkArgument; + +import com.google.common.base.Preconditions; +import com.google.common.collect.HashBasedTable; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.Table; +import com.google.common.primitives.Longs; +import java.math.BigInteger; +import java.util.List; +import org.sosy_lab.java_smt.api.ArrayFormula; +import org.sosy_lab.java_smt.api.BitvectorFormula; +import org.sosy_lab.java_smt.api.BooleanFormula; +import org.sosy_lab.java_smt.api.Formula; +import org.sosy_lab.java_smt.api.FormulaType; +import org.sosy_lab.java_smt.api.FormulaType.ArrayFormulaType; +import org.sosy_lab.java_smt.api.FormulaType.FloatingPointType; +import org.sosy_lab.java_smt.api.FunctionDeclarationKind; +import org.sosy_lab.java_smt.api.visitors.FormulaVisitor; +import org.sosy_lab.java_smt.basicimpl.FormulaCreator; +import org.sosy_lab.java_smt.basicimpl.FunctionDeclarationImpl; +import org.sosy_lab.java_smt.solvers.boolector.BoolectorFormula.BoolectorArrayFormula; +import org.sosy_lab.java_smt.solvers.boolector.BoolectorFormula.BoolectorBitvectorFormula; +import org.sosy_lab.java_smt.solvers.boolector.BoolectorFormula.BoolectorBooleanFormula; + +public class BoolectorFormulaCreator extends FormulaCreator { + + // Boolector can give back 'x' for a arbitrary value that we change to this + private static final char ARBITRARY_VALUE = '1'; + + /** Maps a name and a variable or function type to a concrete formula node. */ + private final Table nameFormulaCache = HashBasedTable.create(); + + BoolectorFormulaCreator(Long btor) { + super(btor, BtorJNI.boolector_bool_sort(btor), null, null); + } + + @SuppressWarnings("unchecked") + @Override + public FormulaType getFormulaType(T pFormula) { + if (pFormula instanceof BitvectorFormula) { + long sort = BtorJNI.boolector_get_sort(getEnv(), extractInfo(pFormula)); + checkArgument( + BtorJNI.boolector_is_bitvec_sort(getEnv(), sort), + "BitvectorFormula with type missmatch: " + pFormula); + return (FormulaType) + FormulaType.getBitvectorTypeWithSize( + BtorJNI.boolector_get_width(getEnv(), extractInfo(pFormula))); + } else if (pFormula instanceof ArrayFormula) { + FormulaType arrayIndexType = getArrayFormulaIndexType((ArrayFormula) pFormula); + FormulaType arrayElementType = getArrayFormulaElementType((ArrayFormula) pFormula); + return (FormulaType) FormulaType.getArrayType(arrayIndexType, arrayElementType); + } + return super.getFormulaType(pFormula); + } + + @Override + public Long extractInfo(Formula pT) { + return BoolectorFormulaManager.getBtorTerm(pT); + } + + @Override + public FormulaType getFormulaType(Long pFormula) { + long sort = BtorJNI.boolector_get_sort(getEnv(), pFormula); + if (BtorJNI.boolector_is_bitvec_sort(getEnv(), sort)) { + if (sort == 1) { + return FormulaType.BooleanType; + } else { + return FormulaType.getBitvectorTypeWithSize( + BtorJNI.boolector_get_width(getEnv(), pFormula)); + } + } else if (BtorJNI.boolector_is_array_sort(getEnv(), sort)) { + int indexWidth = BtorJNI.boolector_get_index_width(getEnv(), pFormula); + int elementWidth = BtorJNI.boolector_get_width(getEnv(), pFormula); + return FormulaType.getArrayType( + FormulaType.getBitvectorTypeWithSize(indexWidth), + FormulaType.getBitvectorTypeWithSize(elementWidth)); + } + throw new IllegalArgumentException("Unknown formula type for " + pFormula); + } + + @SuppressWarnings("unchecked") + @Override + public T encapsulate(FormulaType pType, Long pTerm) { + assert pType.equals(getFormulaType(pTerm)) + : String.format( + "Trying to encapsulate formula of type %s as %s", getFormulaType(pTerm), pType); + if (pType.isBooleanType()) { + return (T) new BoolectorBooleanFormula(pTerm, getEnv()); + } else if (pType.isArrayType()) { + ArrayFormulaType arrFt = (ArrayFormulaType) pType; + return (T) + new BoolectorArrayFormula<>( + pTerm, arrFt.getIndexType(), arrFt.getElementType(), getEnv()); + } else if (pType.isBitvectorType()) { + return (T) new BoolectorBitvectorFormula(pTerm, getEnv()); + } + throw new IllegalArgumentException( + "Cannot create formulas of type " + pType + " in Boolector."); + } + + @Override + public BooleanFormula encapsulateBoolean(Long pTerm) { + assert getFormulaType(pTerm).isBooleanType() + : "Unexpected formula type for Boolean formula: " + getFormulaType(pTerm); + return new BoolectorBooleanFormula(pTerm, getEnv()); + } + + @Override + public BitvectorFormula encapsulateBitvector(Long pTerm) { + assert getFormulaType(pTerm).isBitvectorType() + : "Unexpected formula type for BV formula: " + getFormulaType(pTerm); + return new BoolectorBitvectorFormula(pTerm, getEnv()); + } + + @Override + protected ArrayFormula encapsulateArray( + Long pTerm, FormulaType pIndexType, FormulaType pElementType) { + assert getFormulaType(pTerm).isArrayType() + : "Unexpected formula type for array formula: " + getFormulaType(pTerm); + return new BoolectorArrayFormula<>(pTerm, pIndexType, pElementType, getEnv()); + } + + @Override + public Long getBitvectorType(int pBitwidth) { + return BtorJNI.boolector_bitvec_sort(getEnv(), pBitwidth); + } + + @Override + public Long getFloatingPointType(FloatingPointType pType) { + throw new UnsupportedOperationException( + "Boolector does not support floating point operations."); + } + + @Override + public Long getArrayType(Long pIndexType, Long pElementType) { + return BtorJNI.boolector_array_sort(getEnv(), pIndexType, pElementType); + } + + // Checks if there is a variable with the exact same name and type and gives that back, or a new + // one, potentially with a new internal name (see cache). + @Override + public Long makeVariable(Long type, String varName) { + Long maybeFormula = nameFormulaCache.get(varName, type); + if (maybeFormula != null) { + return maybeFormula; + } + if (nameFormulaCache.containsRow(varName)) { + throw new IllegalArgumentException("Symbol already used: " + varName); + } + long newVar = BtorJNI.boolector_var(getEnv(), type, varName); + nameFormulaCache.put(varName, type, newVar); + return newVar; + } + + // This method is a massive problem... you CANT get the value formulas(nodes) because they are + // only build and used internally in boolector. (See visit1 for help) + @Override + public R visit(FormulaVisitor visitor, Formula formula, Long f) { + throw new UnsupportedOperationException( + "We wait till the Boolector devs give us methods to do this."); + } + + // Hopefully a helpful template for when visitor gets implemented + // Btor only has bitvec arrays and ufs with bitvecs and arrays of bitvecs + // (and quantifier with bitvecs only) + @SuppressWarnings("unused") + private R visit1(FormulaVisitor visitor, Formula formula, Long f) { + if (BtorJNI.boolector_is_const(getEnv(), f)) { + // Handles all constants (bitvec, bool) + String bits = BtorJNI.boolector_get_bits(getEnv(), f); + return visitor.visitConstant(formula, convertValue(f, parseBitvector(bits))); + } else if (BtorJNI.boolector_is_param(getEnv(), f)) { + // Quantifier have their own variables called param. + // They can only be bound once! (use them as bitvec) + int deBruijnIdx = 0; // TODO: Ask Developers for this because this is WRONG! + return visitor.visitBoundVariable(formula, deBruijnIdx); + } else if (false) { + // Quantifier + // there is currently no way to find out if the formula is a quantifier + // do we need them separately? + /* + * return visitor .visitQuantifier( (BoolectorBooleanFormula) formula, quantifier, + * boundVariables, new BoolectorBooleanFormula(body, getEnv())); + */ + } else if (BtorJNI.boolector_is_var(getEnv(), f)) { + // bitvec var (size 1 is bool!) + return visitor.visitFreeVariable(formula, getName(f)); + } else { + ImmutableList.Builder args = ImmutableList.builder(); + + ImmutableList.Builder> argTypes = ImmutableList.builder(); + + return visitor.visitFunction( + formula, + args.build(), + FunctionDeclarationImpl.of( + getName(f), getDeclarationKind(f), argTypes.build(), getFormulaType(f), f)); + } // TODO: fix declaration in visitFunction + return null; + } + + // TODO: returns kind of formula (add, uf etc....) once methods are provided + private FunctionDeclarationKind getDeclarationKind(@SuppressWarnings("unused") long f) { + return null; + } + + @Override + public Long callFunctionImpl(Long pDeclaration, List pArgs) { + Preconditions.checkArgument( + !pArgs.isEmpty(), "Boolector does not support UFs without arguments."); + return BtorJNI.boolector_apply(getEnv(), Longs.toArray(pArgs), pArgs.size(), pDeclaration); + } + + @Override + public Long declareUFImpl(String name, Long pReturnType, List pArgTypes) { + Preconditions.checkArgument( + !pArgTypes.isEmpty(), "Boolector does not support UFs without arguments."); + + long[] funSorts = Longs.toArray(pArgTypes); + long sort = BtorJNI.boolector_fun_sort(getEnv(), funSorts, funSorts.length, pReturnType); + Long maybeFormula = nameFormulaCache.get(name, sort); + if (maybeFormula != null) { + return maybeFormula; + } + if (nameFormulaCache.containsRow(name)) { + throw new IllegalArgumentException("Symbol already used: " + name); + } + long uf = BtorJNI.boolector_uf(getEnv(), sort, name); + nameFormulaCache.put(name, sort, uf); + return uf; + } + + @Override + public Object convertValue(Long key, Long term) { + String value = null; + if (BtorJNI.boolector_is_array(getEnv(), term)) { + value = BtorJNI.boolector_bv_assignment(getEnv(), term); + } else if (BtorJNI.boolector_is_const(getEnv(), term)) { + value = BtorJNI.boolector_get_bits(getEnv(), term); + } else if (BtorJNI.boolector_is_bitvec_sort( + getEnv(), BtorJNI.boolector_get_sort(getEnv(), term))) { + value = BtorJNI.boolector_bv_assignment(getEnv(), term); + } else { + throw new AssertionError("unknown sort and term"); + // value = BtorJNI.boolector_bv_assignment(getEnv(), term); + } + // To get the correct type, we check the width of the term (== 1 means bool). + int width = BtorJNI.boolector_get_width(getEnv(), term); + if (width == 1) { + Long longValue = parseBigInt(value).longValue(); + if (longValue == 1) { + return true; + } else if (longValue == 0) { + return false; + } else { + throw new IllegalArgumentException("Unexpected type with value: " + value); + } + } + return parseBigInt(value); + } + + /** + * Boolector puts out Strings containing 1,0 or x that have to be parsed. If you want different + * values for x, change it in the constant! (BOOLECTOR_VARIABLE_ARBITRARI_REPLACEMENT) + * + * @param assignment String with the assignment of Boolector var. + * @return BigInteger in decimal. + */ + private BigInteger parseBigInt(String assignment) { + try { + BigInteger bigInt = new BigInteger(assignment, 2); + return bigInt; + } catch (NumberFormatException e) { + char[] charArray = assignment.toCharArray(); + for (int i = 0; i < charArray.length; i++) { + if (charArray[i] == 'x') { + charArray[i] = ARBITRARY_VALUE; + } else if (charArray[i] != '0' && charArray[i] != '1') { + throw new IllegalArgumentException( + "Boolector gave back an assignment that is not parseable."); + } + } + assignment = String.valueOf(charArray); + } + return new BigInteger(assignment, 2); + } + + /** + * Transforms String bitvec into Long. + * + * @param bitVec return value of Boolector + * @return gives back the long version of the bitvector + */ + private Long parseBitvector(String bitVec) { + try { + BigInteger bigInt = new BigInteger(bitVec, 2); + return bigInt.longValue(); + } catch (NumberFormatException e) { + char[] charArray = bitVec.toCharArray(); + for (int i = 0; i < charArray.length; i++) { + if (charArray[i] == 'x') { + charArray[i] = '1'; + } else if (charArray[i] != '0' && charArray[i] != '1') { + throw new IllegalArgumentException( + "Boolector gave back an assignment that is not parseable."); + } + } + bitVec = String.valueOf(charArray); + } + BigInteger bigInt = new BigInteger(bitVec, 2); + return bigInt.longValue(); + } + + String getName(long pKey) { + return BtorJNI.boolector_get_symbol(getEnv(), pKey); + } + + @Override + public Object convertValue(Long pF) { + throw new UnsupportedOperationException("Please use the other method."); + } + + @Override + protected Long getBooleanVarDeclarationImpl(Long pTFormulaInfo) { + // declaration of constant or fun + if (BtorJNI.boolector_is_const(getEnv(), pTFormulaInfo)) { + return parseBitvector(BtorJNI.boolector_get_bits(getEnv(), pTFormulaInfo)); + } else if (BtorJNI.boolector_is_var(getEnv(), pTFormulaInfo)) { + return parseBitvector(BtorJNI.boolector_bv_assignment(getEnv(), pTFormulaInfo)); + } else { + throw new IllegalArgumentException( + "Debug only! getBooleanVarDeclarationImpl in BtorFormulaCreator"); + } + } + + /** + * Returns current variables cache. + * + * @return variables cache. + */ + protected Table getCache() { + return nameFormulaCache; + } + + @Override + protected FormulaType getArrayFormulaElementType( + ArrayFormula pArray) { + return ((BoolectorArrayFormula) pArray).getElementType(); + } + + @Override + protected FormulaType getArrayFormulaIndexType( + ArrayFormula pArray) { + return ((BoolectorArrayFormula) pArray).getIndexType(); + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorFormulaManager.java b/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorFormulaManager.java new file mode 100644 index 0000000000..bd8d38065a --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorFormulaManager.java @@ -0,0 +1,76 @@ +/* + * JavaSMT is an API wrapper for a collection of SMT solvers. + * This file is part of JavaSMT. + * + * Copyright (C) 2007-2019 Dirk Beyer + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.sosy_lab.java_smt.solvers.boolector; + +import java.io.IOException; +import org.sosy_lab.common.Appender; +import org.sosy_lab.common.Appenders; +import org.sosy_lab.java_smt.api.BooleanFormula; +import org.sosy_lab.java_smt.api.Formula; +import org.sosy_lab.java_smt.basicimpl.AbstractFormulaManager; + +final class BoolectorFormulaManager extends AbstractFormulaManager { + + protected BoolectorFormulaManager( + BoolectorFormulaCreator pFormulaCreator, + BoolectorUFManager pFunctionManager, + BoolectorBooleanFormulaManager pBooleanManager, + BoolectorBitvectorFormulaManager pBitvectorManager, + BoolectorQuantifiedFormulaManager pQuantifierManager, + BoolectorArrayFormulaManager pArrayManager) { + super( + pFormulaCreator, + pFunctionManager, + pBooleanManager, + null, + null, + pBitvectorManager, + null, + pQuantifierManager, + pArrayManager, + null); + } + + @Override + public BooleanFormula parse(String pS) throws IllegalArgumentException { + throw new UnsupportedOperationException("Boolector can not parse single formulas."); + } + + @Override + public Appender dumpFormula(Long pT) { + return new Appenders.AbstractAppender() { + @Override + public void appendTo(Appendable out) throws IOException { + String dump = BtorJNI.boolector_help_dump_node_smt2(getEnvironment(), pT); + int length = dump.length(); + int i = 1; + while (dump.charAt(length - i) != ')' && i < length) { + dump = dump.substring(0, length - i); + i++; + } + out.append(dump); + } + }; + } + + protected static long getBtorTerm(Formula pT) { + return ((BoolectorFormula) pT).getTerm(); + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorModel.java b/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorModel.java new file mode 100644 index 0000000000..45cc06c56c --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorModel.java @@ -0,0 +1,147 @@ +/* + * JavaSMT is an API wrapper for a collection of SMT solvers. + * This file is part of JavaSMT. + * + * Copyright (C) 2007-2019 Dirk Beyer + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.sosy_lab.java_smt.solvers.boolector; + +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableList; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.Map.Entry; +import org.sosy_lab.java_smt.basicimpl.AbstractModel.CachingAbstractModel; + +class BoolectorModel extends CachingAbstractModel { + + private final long btor; + private final BoolectorAbstractProver prover; + private final BoolectorFormulaCreator bfCreator; + private boolean closed = false; + + private final ImmutableList assertedTerms; + + BoolectorModel( + long btor, + BoolectorFormulaCreator creator, + BoolectorAbstractProver pProver, + Collection assertedTerms) { + super(creator); + this.bfCreator = creator; + this.btor = btor; + this.prover = pProver; + this.assertedTerms = ImmutableList.copyOf(assertedTerms); + } + + @Override + public void close() { + if (!closed) { + // Technically boolector has no model + // but you could release all bindings. + closed = true; + } + } + + @Override + protected ImmutableList toList() { + Preconditions.checkState(!closed); + Preconditions.checkState(!prover.isClosed(), "cannot use model after prover is closed"); + // We wait till the Boolector devs give us methods to do this properly. + // See toList1 for help building this method! (delete toList1 later) + ImmutableList.Builder assignments = ImmutableList.builder(); + return assignments.build(); + } + + @SuppressWarnings("unused") + private ImmutableList toList1() { + Preconditions.checkState(!closed); + Preconditions.checkState(!prover.isClosed(), "cannot use model after prover is closed"); + ImmutableList.Builder assignments = ImmutableList.builder(); + for (Long formula : assertedTerms) { + for (Entry entry : creator.extractVariablesAndUFs(formula, true).entrySet()) { + String name = entry.getKey(); + Long var = entry.getValue(); + if (BtorJNI.boolector_is_array(btor, var)) { + assignments.add(getArrayAssignment(formula)); + } else if (BtorJNI.boolector_is_uf(btor, var)) { + assignments.add(getUFAssignment(formula)); + } else { + assignments.add(getConstAssignment(formula)); + } + } + } + return assignments.build(); + } + + private ValueAssignment getConstAssignment(long key) { + // Boolector does not give back a value "node" (formula), just an assignment string. + // We have to wait for the new methods and revisit this method! + List argumentInterpretation = new ArrayList<>(); + Object value = creator.convertValue(key, evalImpl(key)); + argumentInterpretation.add(value); + Long valueNode = null; + if (value.equals(true)) { + valueNode = BtorJNI.boolector_true(btor); + } else if (value.equals(false)) { + valueNode = BtorJNI.boolector_false(btor); + } else { + long sort = BtorJNI.boolector_bitvec_sort(btor, BtorJNI.boolector_get_width(btor, key)); + valueNode = BtorJNI.boolector_int(btor, (long) value, sort); + } + return new ValueAssignment( + creator.encapsulateWithTypeOf(key), + creator.encapsulateWithTypeOf(valueNode), + creator.encapsulateBoolean(BtorJNI.boolector_eq(btor, key, valueNode)), + bfCreator.getName(key), + value, + argumentInterpretation); + } + + private ValueAssignment getUFAssignment(long key) { + List argumentInterpretation = new ArrayList<>(); + Long value = evalImpl(key); // wrong! use creator.convertValue + // TODO + return new ValueAssignment( + creator.encapsulateWithTypeOf(key), + creator.encapsulateWithTypeOf(value), + creator.encapsulateBoolean(BtorJNI.boolector_eq(btor, key, value)), + bfCreator.getName(key), + creator.convertValue(key, value), + argumentInterpretation); + } + + private ValueAssignment getArrayAssignment(long key) { + List argumentInterpretation = new ArrayList<>(); + Long value = evalImpl(key); // wrong! use creator.convertValue + Long valueNode = null; + // TODO + return new ValueAssignment( + creator.encapsulateWithTypeOf(key), + creator.encapsulateWithTypeOf(valueNode), + creator.encapsulateBoolean(BtorJNI.boolector_eq(btor, key, value)), + bfCreator.getName(key), + creator.convertValue(key, value), + argumentInterpretation); + } + + @Override + protected Long evalImpl(Long pFormula) { + Preconditions.checkState(!closed); + return pFormula; + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorNativeApiTest.java b/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorNativeApiTest.java new file mode 100644 index 0000000000..80171d7fb3 --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorNativeApiTest.java @@ -0,0 +1,92 @@ +/* + * JavaSMT is an API wrapper for a collection of SMT solvers. + * This file is part of JavaSMT. + * + * Copyright (C) 2007-2019 Dirk Beyer + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.sosy_lab.java_smt.solvers.boolector; + +import static org.junit.Assert.assertEquals; + +import com.google.common.collect.ImmutableMap; +import org.junit.After; +import org.junit.AssumptionViolatedException; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.sosy_lab.common.NativeLibraries; +import org.sosy_lab.java_smt.solvers.boolector.BoolectorSolverContext.SatSolver; + +public class BoolectorNativeApiTest { + + private long btor; + + @BeforeClass + public static void load() { + try { + NativeLibraries.loadLibrary("boolector"); + } catch (UnsatisfiedLinkError e) { + throw new AssumptionViolatedException("Boolector is not available", e); + } + } + + @Before + public void createEnvironment() { + btor = BtorJNI.boolector_new(); + } + + @After + public void freeEnvironment() { + BtorJNI.boolector_delete(btor); + } + + // some options have a different name in the API that their internal representation. + // TODO why? + private static final ImmutableMap ALLOWED_DIFFS = + ImmutableMap.builder() + .put("BTOR_OPT_ACKERMANNIZE", "BTOR_OPT_ACKERMANN") + .put("BTOR_OPT_QUANT_DUAL", "BTOR_OPT_QUANT_DUAL_SOLVER") + .put("BTOR_OPT_QUANT_SYNTHLIMIT", "BTOR_OPT_QUANT_SYNTH_LIMIT") + .put("BTOR_OPT_QUANT_SYNTHQI", "BTOR_OPT_QUANT_SYNTH_QI") + .put("BTOR_OPT_QUANT_MS", "BTOR_OPT_QUANT_MINISCOPE") + .put("BTOR_OPT_DEFAULT_CADICAL", "BTOR_OPT_DEFAULT_TO_CADICAL") + .put("BTOR_OPT_QUANT_SYNTHCOMPLETE", "BTOR_OPT_QUANT_SYNTH_ITE_COMPLETE") + .build(); + + @Test + public void optionNameTest() { + // check whether our enum is identical to Boolector's internal enum + for (BtorOption option : BtorOption.values()) { + String optName = BtorJNI.boolector_get_opt_lng(btor, option.getValue()); + String converted = "BTOR_OPT_" + optName.replace("-", "_").replace(":", "_").toUpperCase(); + assertEquals(option.name(), ALLOWED_DIFFS.getOrDefault(converted, converted)); + } + } + + @Test + public void satSolverTest() { + // check whether all sat solvers are available + for (SatSolver satSolver : SatSolver.values()) { + long btor1 = BtorJNI.boolector_new(); + BtorJNI.boolector_set_sat_solver(btor1, satSolver.name()); + long newVar = BtorJNI.boolector_var(btor1, BtorJNI.boolector_bool_sort(btor1), "x"); + BtorJNI.boolector_assert(btor1, newVar); + int result = BtorJNI.boolector_sat(btor1); + assertEquals(BtorJNI.BTOR_RESULT_SAT_get(), result); + BtorJNI.boolector_delete(btor1); + } + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorQuantifiedFormulaManager.java b/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorQuantifiedFormulaManager.java new file mode 100644 index 0000000000..0dcf2a1bfa --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorQuantifiedFormulaManager.java @@ -0,0 +1,93 @@ +/* + * JavaSMT is an API wrapper for a collection of SMT solvers. + * This file is part of JavaSMT. + * + * Copyright (C) 2007-2019 Dirk Beyer + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.sosy_lab.java_smt.solvers.boolector; + +import com.google.common.collect.ImmutableList; +import com.google.common.primitives.Longs; +import java.util.List; +import org.sosy_lab.java_smt.api.SolverException; +import org.sosy_lab.java_smt.basicimpl.AbstractQuantifiedFormulaManager; +import org.sosy_lab.java_smt.basicimpl.FormulaCreator; + +public class BoolectorQuantifiedFormulaManager + extends AbstractQuantifiedFormulaManager { + + private final long btor; + + BoolectorQuantifiedFormulaManager(FormulaCreator pCreator) { + super(pCreator); + btor = getFormulaCreator().getEnv(); + } + + @Override + protected Long eliminateQuantifiers(Long pExtractInfo) + throws SolverException, InterruptedException { + throw new UnsupportedOperationException("Boolector can not eliminate quantifier."); + } + + /** + * Note: Boolector only supports bitvector quantifier! The vars used MUST be boolector_param (not + * boolector_var)! Therefore we have to change every var into param with the visitor! Additionaly + * no param may be used twice (Boolector will end if you do!). + */ + @Override + public Long mkQuantifier(Quantifier pQ, List pVars, Long pBody) { + if (pVars.isEmpty()) { + throw new IllegalArgumentException("List of quantified variables can not be empty"); + } + for (long param : pVars) { + if (!BtorJNI.boolector_is_param(btor, param)) { + throw new IllegalArgumentException("pVariables need to be parameter nodes in boolector."); + } + } + final long newQuantifier; + final long[] varsArray = Longs.toArray(pVars); + if (pQ == Quantifier.FORALL) { + newQuantifier = BtorJNI.boolector_forall(btor, varsArray, varsArray.length, pBody); + } else { + newQuantifier = BtorJNI.boolector_exists(btor, varsArray, varsArray.length, pBody); + } + return newQuantifier; + } + + static class QuantifiedFormula { + private final boolean isForall; // false for EXISTS, true for FORALL + private final long body; + private final ImmutableList boundVariables; + + QuantifiedFormula(boolean pIsForall, long pBody, List pVars) { + isForall = pIsForall; + body = pBody; + boundVariables = ImmutableList.copyOf(pVars); + } + + public boolean isForall() { + return isForall; + } + + public long getBody() { + return body; + } + + public ImmutableList getBoundVariables() { + return boundVariables; + } + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorSolverContext.java b/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorSolverContext.java new file mode 100644 index 0000000000..4c15c0197f --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorSolverContext.java @@ -0,0 +1,214 @@ +/* + * JavaSMT is an API wrapper for a collection of SMT solvers. + * This file is part of JavaSMT. + * + * Copyright (C) 2007-2019 Dirk Beyer + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.sosy_lab.java_smt.solvers.boolector; + +import com.google.common.base.Preconditions; +import com.google.common.base.Splitter; +import com.google.common.base.Splitter.MapSplitter; +import com.google.common.collect.ImmutableMap; +import java.util.Map.Entry; +import java.util.Set; +import org.checkerframework.checker.nullness.qual.Nullable; +import org.sosy_lab.common.NativeLibraries; +import org.sosy_lab.common.ShutdownNotifier; +import org.sosy_lab.common.configuration.Configuration; +import org.sosy_lab.common.configuration.InvalidConfigurationException; +import org.sosy_lab.common.configuration.Option; +import org.sosy_lab.common.configuration.Options; +import org.sosy_lab.common.io.PathCounterTemplate; +import org.sosy_lab.java_smt.SolverContextFactory.Solvers; +import org.sosy_lab.java_smt.api.InterpolatingProverEnvironment; +import org.sosy_lab.java_smt.api.OptimizationProverEnvironment; +import org.sosy_lab.java_smt.api.ProverEnvironment; +import org.sosy_lab.java_smt.basicimpl.AbstractSolverContext; +import org.sosy_lab.java_smt.basicimpl.reusableStack.ReusableStackTheoremProver; + +public final class BoolectorSolverContext extends AbstractSolverContext { + + enum SatSolver { + LINGELING, + PICOSAT, + MINISAT, + CADICAL + } + + @Options(prefix = "solver.boolector") + private static class BoolectorSettings { + + @Option(secure = true, description = "The SAT solver used by Boolector.") + private SatSolver satSolver = SatSolver.PICOSAT; + + @Option( + secure = true, + description = + "Further options for Boolector in addition to the default options. " + + "Format: \"Optionname=value\" with ’,’ to seperate options. " + + "Optionname and value can be found in BtorOption or Boolector C Api." + + "Example: \"BTOR_OPT_MODEL_GEN=2,BTOR_OPT_INCREMENTAL=1\".") + private String furtherOptions = ""; + + BoolectorSettings(Configuration config) throws InvalidConfigurationException { + config.inject(this); + } + } + + private final BoolectorFormulaManager manager; + private final BoolectorFormulaCreator creator; + private final ShutdownNotifier shutdownNotifier; + + protected BoolectorSolverContext( + BoolectorFormulaManager pManager, + BoolectorFormulaCreator pCreator, + ShutdownNotifier pShutdownNotifier) { + super(pManager); + manager = pManager; + creator = pCreator; + shutdownNotifier = pShutdownNotifier; + } + + public static BoolectorSolverContext create( + Configuration config, + ShutdownNotifier pShutdownNotifier, + @Nullable PathCounterTemplate solverLogfile, + long randomSeed) + throws InvalidConfigurationException { + + NativeLibraries.loadLibrary("boolector"); + final long btor = BtorJNI.boolector_new(); + setOptions(config, solverLogfile, randomSeed, btor); + + BoolectorFormulaCreator creator = new BoolectorFormulaCreator(btor); + BoolectorUFManager functionTheory = new BoolectorUFManager(creator); + BoolectorBooleanFormulaManager booleanTheory = new BoolectorBooleanFormulaManager(creator); + BoolectorBitvectorFormulaManager bitvectorTheory = + new BoolectorBitvectorFormulaManager(creator); + BoolectorQuantifiedFormulaManager quantifierTheory = + new BoolectorQuantifiedFormulaManager(creator); + BoolectorArrayFormulaManager arrayTheory = new BoolectorArrayFormulaManager(creator); + BoolectorFormulaManager manager = + new BoolectorFormulaManager( + creator, functionTheory, booleanTheory, bitvectorTheory, quantifierTheory, arrayTheory); + return new BoolectorSolverContext(manager, creator, pShutdownNotifier); + } + + @Override + public String getVersion() { + return BtorJNI.boolector_version(creator.getEnv()); + } + + @Override + public Solvers getSolverName() { + return Solvers.BOOLECTOR; + } + + @Override + public void close() { + BtorJNI.boolector_delete(creator.getEnv()); + } + + @SuppressWarnings("resource") + @Override + protected ProverEnvironment newProverEnvironment0(Set pOptions) { + return new ReusableStackTheoremProver( + new BoolectorTheoremProver(manager, creator, creator.getEnv(), shutdownNotifier, pOptions)); + } + + @Override + protected InterpolatingProverEnvironment newProverEnvironmentWithInterpolation0( + Set pSet) { + throw new UnsupportedOperationException("Boolector does not support interpolation"); + } + + @Override + protected OptimizationProverEnvironment newOptimizationProverEnvironment0( + Set pSet) { + throw new UnsupportedOperationException("Boolector does not support optimization"); + } + + @Override + protected boolean supportsAssumptionSolving() { + return true; + } + + /** set basic options for running Boolector. */ + private static void setOptions( + Configuration config, PathCounterTemplate solverLogfile, long randomSeed, long btor) + throws InvalidConfigurationException { + BoolectorSettings settings = new BoolectorSettings(config); + + Preconditions.checkNotNull(settings.satSolver); + // TODO implement non-incremental stack-handling in the TheoremProver. + Preconditions.checkArgument( + settings.satSolver != SatSolver.CADICAL, + "CaDiCal is not usable with JavaSMT, because it does not support incremental mode."); + BtorJNI.boolector_set_sat_solver(btor, settings.satSolver.name()); + // Default Options to enable multiple SAT, auto cleanup on close, incremental mode + BtorJNI.boolector_set_opt(btor, BtorOption.BTOR_OPT_MODEL_GEN.getValue(), 2); + // Auto memory clean after closing + BtorJNI.boolector_set_opt(btor, BtorOption.BTOR_OPT_AUTO_CLEANUP.getValue(), 1); + // Incremental needed for push/pop! + BtorJNI.boolector_set_opt(btor, BtorOption.BTOR_OPT_INCREMENTAL.getValue(), 1); + // Sets randomseed accordingly + BtorJNI.boolector_set_opt(btor, BtorOption.BTOR_OPT_SEED.getValue(), randomSeed); + // Dump in SMT-LIB2 Format + BtorJNI.boolector_set_opt(btor, BtorOption.BTOR_OPT_OUTPUT_FORMAT.getValue(), 2); + + setFurtherOptions(btor, settings.furtherOptions); + + if (solverLogfile != null) { + String filename = solverLogfile.getFreshPath().toAbsolutePath().toString(); + BtorJNI.boolector_set_trapi(btor, filename); + } + } + + /** + * Set more options for Boolector. + * + * @param btor solver instance. + * @param pFurtherOptions String to be parsed with options to be set. + * @throws InvalidConfigurationException signals that the format of the option string is wrong or + * an invalid option is used. + */ + private static void setFurtherOptions(long btor, String pFurtherOptions) + throws InvalidConfigurationException { + MapSplitter optionSplitter = + Splitter.on(',') + .trimResults() + .omitEmptyStrings() + .withKeyValueSeparator(Splitter.on('=').limit(2).trimResults()); + ImmutableMap furtherOptionsMap; + + try { + furtherOptionsMap = ImmutableMap.copyOf(optionSplitter.split(pFurtherOptions)); + } catch (IllegalArgumentException e) { + throw new InvalidConfigurationException( + "Invalid Boolector option in \"" + pFurtherOptions + "\": " + e.getMessage(), e); + } + for (Entry option : furtherOptionsMap.entrySet()) { + try { + BtorOption btorOption = BtorOption.valueOf(option.getKey()); + long optionValue = Long.parseLong(option.getValue()); + BtorJNI.boolector_set_opt(btor, btorOption.getValue(), optionValue); + } catch (IllegalArgumentException e) { + throw new InvalidConfigurationException(e.getMessage(), e); + } + } + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorTheoremProver.java b/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorTheoremProver.java new file mode 100644 index 0000000000..f0767f9083 --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorTheoremProver.java @@ -0,0 +1,38 @@ +/* + * JavaSMT is an API wrapper for a collection of SMT solvers. + * This file is part of JavaSMT. + * + * Copyright (C) 2007-2019 Dirk Beyer + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.sosy_lab.java_smt.solvers.boolector; + +import java.util.Set; +import org.sosy_lab.common.ShutdownNotifier; +import org.sosy_lab.java_smt.api.ProverEnvironment; +import org.sosy_lab.java_smt.api.SolverContext.ProverOptions; + +class BoolectorTheoremProver extends BoolectorAbstractProver implements ProverEnvironment { + // Used as standard prover. Built by method newProverEnvironment0 in BtorSolverContext + + protected BoolectorTheoremProver( + BoolectorFormulaManager manager, + BoolectorFormulaCreator creator, + long btor, + ShutdownNotifier pShutdownNotifier, + Set pOptions) { + super(manager, creator, btor, pShutdownNotifier, pOptions); + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorUFManager.java b/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorUFManager.java new file mode 100644 index 0000000000..44df8b6184 --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/boolector/BoolectorUFManager.java @@ -0,0 +1,29 @@ +/* + * JavaSMT is an API wrapper for a collection of SMT solvers. + * This file is part of JavaSMT. + * + * Copyright (C) 2007-2019 Dirk Beyer + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.sosy_lab.java_smt.solvers.boolector; + +import org.sosy_lab.java_smt.basicimpl.AbstractUFManager; + +class BoolectorUFManager extends AbstractUFManager { + + protected BoolectorUFManager(BoolectorFormulaCreator pCreator) { + super(pCreator); + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/boolector/BtorJNI.java b/src/org/sosy_lab/java_smt/solvers/boolector/BtorJNI.java new file mode 100644 index 0000000000..161421eb3a --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/boolector/BtorJNI.java @@ -0,0 +1,461 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.0 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package org.sosy_lab.java_smt.solvers.boolector; + +/** Native code for Boolector methods. */ +@SuppressWarnings({"unused", "checkstyle:methodname", "checkstyle:parametername"}) +class BtorJNI { + private BtorJNI() {} + + protected static final native int BOOLECTOR_PARSE_ERROR_get(); + + protected static final native int BOOLECTOR_PARSE_UNKNOWN_get(); + + protected static final native long boolector_new(); + + protected static final native long boolector_clone(long jarg1); + + protected static final native void boolector_delete(long jarg1); + + protected static final native void boolector_set_term(long jarg1, long jarg2, long jarg3); + + protected static final native int boolector_terminate(long jarg1); + + protected static final native void boolector_set_abort(long jarg1); + + protected static final native void boolector_set_msg_prefix(long jarg1, String jarg2); + + protected static final native int boolector_get_refs(long jarg1); + + protected static final native void boolector_reset_time(long jarg1); + + protected static final native void boolector_reset_stats(long jarg1); + + protected static final native void boolector_print_stats(long jarg1); + + /** + * See Boolector API. (Enables trace of API to given file). + * + * @param jarg1 btor + * @param jarg2 absolute path to the trace file + */ + protected static final native void boolector_set_trapi(long jarg1, String jarg2); + + protected static final native long boolector_get_trapi(long jarg1); + + protected static final native void boolector_push(long jarg1, long jarg2); + + protected static final native void boolector_pop(long jarg1, long jarg2); + + protected static final native void boolector_assert(long jarg1, long jarg2); + + protected static final native void boolector_assume(long jarg1, long jarg2); + + protected static final native boolean boolector_failed(long jarg1, long jarg2); + + protected static final native long boolector_get_failed_assumptions(long jarg1); + + protected static final native void boolector_fixate_assumptions(long jarg1); + + protected static final native void boolector_reset_assumptions(long jarg1); + + protected static final native int boolector_sat(long jarg1); + + protected static final native int boolector_limited_sat(long jarg1, long jarg2, long jarg3); + + protected static final native int boolector_simplify(long jarg1); + + protected static final native void boolector_set_sat_solver(long jarg1, String jarg2); + + protected static final native void boolector_set_opt(long jarg1, int jarg2, long jarg3); + + protected static final native int boolector_get_opt(long jarg1, int jarg2); + + protected static final native int boolector_get_opt_min(long jarg1, int jarg2); + + protected static final native int boolector_get_opt_max(long jarg1, int jarg2); + + protected static final native int boolector_get_opt_dflt(long jarg1, int jarg2); + + protected static final native String boolector_get_opt_lng(long jarg1, int jarg2); + + protected static final native String boolector_get_opt_shrt(long jarg1, int jarg2); + + protected static final native String boolector_get_opt_desc(long jarg1, int jarg2); + + protected static final native boolean boolector_has_opt(long jarg1, int jarg2); + + protected static final native int boolector_first_opt(long jarg1); + + protected static final native int boolector_next_opt(long jarg1, int jarg2); + + protected static final native long boolector_copy(long jarg1, long jarg2); + + protected static final native void boolector_release(long jarg1, long jarg2); + + protected static final native void boolector_release_all(long jarg1); + + protected static final native long boolector_true(long jarg1); + + protected static final native long boolector_false(long jarg1); + + protected static final native long boolector_implies(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_iff(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_eq(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_ne(long jarg1, long jarg2, long jarg3); + + protected static final native boolean boolector_is_bv_const_zero(long jarg1, long jarg2); + + protected static final native boolean boolector_is_bv_const_one(long jarg1, long jarg2); + + protected static final native boolean boolector_is_bv_const_ones(long jarg1, long jarg2); + + protected static final native boolean boolector_is_bv_const_max_signed(long jarg1, long jarg2); + + protected static final native boolean boolector_is_bv_const_min_signed(long jarg1, long jarg2); + + protected static final native long boolector_const(long jarg1, String jarg2); + + protected static final native long boolector_constd(long jarg1, long jarg2, String jarg3); + + protected static final native long boolector_consth(long jarg1, long jarg2, String jarg3); + + protected static final native long boolector_zero(long jarg1, long jarg2); + + protected static final native long boolector_ones(long jarg1, long jarg2); + + protected static final native long boolector_one(long jarg1, long jarg2); + + protected static final native long boolector_min_signed(long jarg1, long jarg2); + + protected static final native long boolector_max_signed(long jarg1, long jarg2); + + protected static final native long boolector_unsigned_int(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_int(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_var(long jarg1, long jarg2, String jarg3); + + protected static final native long boolector_array(long jarg1, long jarg2, String jarg3); + + protected static final native long boolector_uf(long jarg1, long jarg2, String jarg3); + + protected static final native long boolector_not(long jarg1, long jarg2); + + protected static native long boolector_neg(long jarg1, long jarg2); + + protected static final native long boolector_redor(long jarg1, long jarg2); + + protected static final native long boolector_redxor(long jarg1, long jarg2); + + protected static final native long boolector_redand(long jarg1, long jarg2); + + protected static final native long boolector_slice( + long jarg1, long jarg2, long jarg3, long jarg4); + + protected static final native long boolector_uext(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_sext(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_xor(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_xnor(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_and(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_nand(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_or(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_nor(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_add(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_uaddo(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_saddo(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_mul(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_umulo(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_smulo(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_ult(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_slt(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_ulte(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_slte(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_ugt(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_sgt(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_ugte(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_sgte(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_sll(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_srl(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_sra(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_rol(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_ror(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_sub(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_usubo(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_ssubo(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_udiv(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_sdiv(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_sdivo(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_urem(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_srem(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_smod(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_concat(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_repeat(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_read(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_write( + long jarg1, long jarg2, long jarg3, long jarg4); + + protected static final native long boolector_cond(long jarg1, long jarg2, long jarg3, long jarg4); + + protected static final native long boolector_param(long jarg1, long jarg2, String jarg3); + + protected static final native long boolector_fun(long jarg1, long jarg2, long jarg3, long jarg4); + + protected static final native long boolector_apply( + long jarg1, long[] jarg2, long jarg3, long jarg4); + + protected static final native long boolector_inc(long jarg1, long jarg2); + + protected static final native long boolector_dec(long jarg1, long jarg2); + + protected static final native long boolector_forall( + long jarg1, long[] jarg2, long jarg3, long jarg4); + + protected static final native long boolector_exists( + long jarg1, long[] jarg2, long jarg3, long jarg4); + + protected static final native long boolector_get_btor(long jarg1); + + protected static final native int boolector_get_node_id(long jarg1, long jarg2); + + protected static final native long boolector_get_sort(long jarg1, long jarg2); + + protected static final native long boolector_fun_get_domain_sort(long jarg1, long jarg2); + + protected static final native long boolector_fun_get_codomain_sort(long jarg1, long jarg2); + + protected static final native long boolector_match_node_by_id(long jarg1, long jarg2); + + protected static final native long boolector_match_node_by_symbol(long jarg1, String jarg2); + + protected static final native long boolector_match_node(long jarg1, long jarg2); + + protected static final native String boolector_get_symbol(long jarg1, long jarg2); + + protected static final native void boolector_set_symbol(long jarg1, long jarg2, String jarg3); + + protected static final native int boolector_get_width(long jarg1, long jarg2); + + protected static final native int boolector_get_index_width(long jarg1, long jarg2); + + protected static final native String boolector_get_bits(long jarg1, long jarg2); + + protected static final native void boolector_free_bits(long jarg1, String jarg2); + + protected static final native int boolector_get_fun_arity(long jarg1, long jarg2); + + protected static final native boolean boolector_is_const(long jarg1, long jarg2); + + protected static final native boolean boolector_is_var(long jarg1, long jarg2); + + protected static final native boolean boolector_is_array(long jarg1, long jarg2); + + protected static final native boolean boolector_is_array_var(long jarg1, long jarg2); + + protected static final native boolean boolector_is_param(long jarg1, long jarg2); + + protected static final native boolean boolector_is_bound_param(long jarg1, long jarg2); + + protected static final native boolean boolector_is_uf(long jarg1, long jarg2); + + protected static final native boolean boolector_is_fun(long jarg1, long jarg2); + + protected static final native int boolector_fun_sort_check( + long jarg1, long[] jarg2, long jarg3, long jarg4); + + protected static final native String boolector_bv_assignment(long jarg1, long jarg2); + + protected static final native void boolector_free_bv_assignment(long jarg1, String jarg2); + + protected static final native void boolector_array_assignment( + long jarg1, long jarg2, long jarg3, long jarg4, long jarg5); + + protected static final native void boolector_free_array_assignment( + long jarg1, long jarg2, long jarg3, long jarg4); + + protected static final native void boolector_uf_assignment( + long jarg1, long jarg2, long jarg3, long jarg4, long jarg5); + + protected static final native void boolector_free_uf_assignment( + long jarg1, long jarg2, long jarg3, long jarg4); + + protected static final native void boolector_print_model(long jarg1, String jarg2, long jarg3); + + protected static final native long boolector_bool_sort(long jarg1); + + protected static final native long boolector_bitvec_sort(long jarg1, long jarg2); + + protected static final native long boolector_fun_sort( + long jarg1, long[] jarg2, long jarg3, long jarg4); + + protected static final native long boolector_array_sort(long jarg1, long jarg2, long jarg3); + + protected static final native long boolector_copy_sort(long jarg1, long jarg2); + + protected static final native void boolector_release_sort(long jarg1, long jarg2); + + protected static final native boolean boolector_is_equal_sort(long jarg1, long jarg2, long jarg3); + + protected static final native boolean boolector_is_array_sort(long jarg1, long jarg2); + + protected static final native boolean boolector_is_bitvec_sort(long jarg1, long jarg2); + + protected static final native boolean boolector_is_fun_sort(long jarg1, long jarg2); + + protected static final native long boolector_parse( + long jarg1, long jarg2, String jarg3, long jarg4, long jarg5, long jarg6); + + protected static final native int boolector_parse_btor( + long jarg1, long jarg2, String jarg3, long jarg4, long jarg5, long jarg6); + + protected static final native int boolector_parse_btor2( + long jarg1, long jarg2, String jarg3, long jarg4, long jarg5, long jarg6); + + protected static final native int boolector_parse_smt1( + long jarg1, long jarg2, String jarg3, long jarg4, long jarg5, long jarg6); + + protected static final native int boolector_parse_smt2( + long jarg1, long jarg2, String jarg3, long jarg4, long jarg5, long jarg6); + + protected static final native void boolector_dump_btor_node(long jarg1, long jarg2, long jarg3); + + protected static final native void boolector_dump_btor(long jarg1, long jarg2); + + protected static final native void boolector_dump_smt2_node(long jarg1, long jarg2, long jarg3); + + protected static final native void boolector_dump_smt2(long jarg1, long jarg2); + + protected static final native void boolector_dump_aiger_ascii( + long jarg1, long jarg2, boolean jarg3); + + protected static final native void boolector_dump_aiger_binary( + long jarg1, long jarg2, boolean jarg3); + + protected static final native String boolector_copyright(long jarg1); + + protected static final native String boolector_version(long jarg1); + + protected static final native String boolector_git_id(long jarg1); + + protected static final native int BTOR_RESULT_SAT_get(); + + protected static final native int BTOR_RESULT_UNSAT_get(); + + protected static final native int BTOR_RESULT_UNKNOWN_get(); + + protected static final native void BtorAbortCallback_abort_fun_set(long jarg1, long jarg2); + + protected static final native long BtorAbortCallback_abort_fun_get(long jarg1); + + protected static final native void BtorAbortCallback_cb_fun_set(long jarg1, long jarg2); + + protected static final native long BtorAbortCallback_cb_fun_get(long jarg1); + + protected static final native long new_BtorAbortCallback(); + + protected static final native void delete_BtorAbortCallback(long jarg1); + + protected static final native void btor_abort_callback_set(long jarg1); + + protected static final native long btor_abort_callback_get(); + + /** + * Returns string dump in smt2 format of the entire formula. No guarantee that that string is + * useful. + * + * @param jarg1 btor (environment) + * @return string dump of btor instance + */ + protected static final native String boolector_help_dump_smt2(long jarg1); + + /** + * Returns string dump in smt2 format from btor instance of the chosen node. No guarantee that + * that string is useful + * + * @param jarg1 btor (environment) + * @param jarg2 node to dump + * @return string dump of the node + */ + protected static final native String boolector_help_dump_node_smt2(long jarg1, long jarg2); + + /** + * Tries to parse the string into boolector. + * + * @param jarg1 btor + * @param jarg2 string to parse + * @return int representing boolector error/sat codes. + */ + protected static final native int boolector_help_parse(long jarg1, String jarg2); + + /** + * Gives back the assignment of the array node entered. Return will be arguments and assignments + * in 2 string arrays in an array. + * + * @param jarg1 btor + * @param jarg2 array node + * @return Returns 2Dim Array or Strings. Size [2][x], x beeing the length of the array used. + * First String Array will be argument assignment strings. Second String Array will be value + * assignment strings. + */ + protected static final native String[][] boolector_array_assignment_helper( + long jarg1, long jarg2); + + /** + * Returns the assignment of the UF node in 2 string arrays in an array length 2. + * + * @param jarg1 btor + * @param jarg2 array node + * @return Returns 2Dim Array or Strings. Size [2][x], x beeing the length of the uf used. First + * String Array will be argument assignment strings. Second String Array will be value + * assignment strings. + */ + protected static final native String[][] boolector_uf_assignment_helper(long jarg1, long jarg2); +} diff --git a/src/org/sosy_lab/java_smt/solvers/boolector/BtorOption.java b/src/org/sosy_lab/java_smt/solvers/boolector/BtorOption.java new file mode 100644 index 0000000000..baa549f5eb --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/boolector/BtorOption.java @@ -0,0 +1,109 @@ +package org.sosy_lab.java_smt.solvers.boolector; + +public enum BtorOption { + BTOR_OPT_MODEL_GEN(0), + BTOR_OPT_INCREMENTAL(1), + BTOR_OPT_INCREMENTAL_SMT1(2), + BTOR_OPT_INPUT_FORMAT(3), + BTOR_OPT_OUTPUT_NUMBER_FORMAT(4), + BTOR_OPT_OUTPUT_FORMAT(5), + BTOR_OPT_ENGINE(6), + BTOR_OPT_SAT_ENGINE(7), + BTOR_OPT_AUTO_CLEANUP(8), + BTOR_OPT_PRETTY_PRINT(9), + BTOR_OPT_EXIT_CODES(10), + BTOR_OPT_SEED(11), + BTOR_OPT_VERBOSITY(12), + BTOR_OPT_LOGLEVEL(13), + BTOR_OPT_REWRITE_LEVEL(14), + BTOR_OPT_SKELETON_PREPROC(15), + BTOR_OPT_ACKERMANN(16), + BTOR_OPT_BETA_REDUCE_ALL(17), + BTOR_OPT_ELIMINATE_SLICES(18), + BTOR_OPT_VAR_SUBST(19), + BTOR_OPT_UCOPT(20), + BTOR_OPT_MERGE_LAMBDAS(21), + BTOR_OPT_EXTRACT_LAMBDAS(22), + BTOR_OPT_NORMALIZE(23), + BTOR_OPT_NORMALIZE_ADD(24), + BTOR_OPT_FUN_PREPROP(25), + BTOR_OPT_FUN_PRESLS(26), + BTOR_OPT_FUN_DUAL_PROP(27), + BTOR_OPT_FUN_DUAL_PROP_QSORT(28), + BTOR_OPT_FUN_JUST(29), + BTOR_OPT_FUN_JUST_HEURISTIC(30), + BTOR_OPT_FUN_LAZY_SYNTHESIZE(31), + BTOR_OPT_FUN_EAGER_LEMMAS(32), + BTOR_OPT_FUN_STORE_LAMBDAS(33), + BTOR_OPT_SLS_NFLIPS(34), + BTOR_OPT_SLS_STRATEGY(35), + BTOR_OPT_SLS_JUST(36), + BTOR_OPT_SLS_MOVE_GW(37), + BTOR_OPT_SLS_MOVE_RANGE(38), + BTOR_OPT_SLS_MOVE_SEGMENT(39), + BTOR_OPT_SLS_MOVE_RAND_WALK(40), + BTOR_OPT_SLS_PROB_MOVE_RAND_WALK(41), + BTOR_OPT_SLS_MOVE_RAND_ALL(42), + BTOR_OPT_SLS_MOVE_RAND_RANGE(43), + BTOR_OPT_SLS_MOVE_PROP(44), + BTOR_OPT_SLS_MOVE_PROP_N_PROP(45), + BTOR_OPT_SLS_MOVE_PROP_N_SLS(46), + BTOR_OPT_SLS_MOVE_PROP_FORCE_RW(47), + BTOR_OPT_SLS_MOVE_INC_MOVE_TEST(48), + BTOR_OPT_SLS_USE_RESTARTS(49), + BTOR_OPT_SLS_USE_BANDIT(50), + BTOR_OPT_PROP_NPROPS(51), + BTOR_OPT_PROP_USE_RESTARTS(52), + BTOR_OPT_PROP_USE_BANDIT(53), + BTOR_OPT_PROP_PATH_SEL(54), + BTOR_OPT_PROP_PROB_USE_INV_VALUE(55), + BTOR_OPT_PROP_PROB_FLIP_COND(56), + BTOR_OPT_PROP_PROB_FLIP_COND_CONST(57), + BTOR_OPT_PROP_FLIP_COND_CONST_DELTA(58), + BTOR_OPT_PROP_FLIP_COND_CONST_NPATHSEL(59), + BTOR_OPT_PROP_PROB_SLICE_KEEP_DC(60), + BTOR_OPT_PROP_PROB_CONC_FLIP(61), + BTOR_OPT_PROP_PROB_SLICE_FLIP(62), + BTOR_OPT_PROP_PROB_EQ_FLIP(63), + BTOR_OPT_PROP_PROB_AND_FLIP(64), + BTOR_OPT_PROP_NO_MOVE_ON_CONFLICT(65), + BTOR_OPT_AIGPROP_USE_RESTARTS(66), + BTOR_OPT_AIGPROP_USE_BANDIT(67), + BTOR_OPT_QUANT_SYNTH(68), + BTOR_OPT_QUANT_DUAL_SOLVER(69), + BTOR_OPT_QUANT_SYNTH_LIMIT(70), + BTOR_OPT_QUANT_SYNTH_QI(71), + BTOR_OPT_QUANT_DER(72), + BTOR_OPT_QUANT_CER(73), + BTOR_OPT_QUANT_MINISCOPE(74), + BTOR_OPT_DEFAULT_TO_CADICAL(75), + BTOR_OPT_SORT_EXP(76), + BTOR_OPT_SORT_AIG(77), + BTOR_OPT_SORT_AIGVEC(78), + BTOR_OPT_AUTO_CLEANUP_INTERNAL(79), + BTOR_OPT_SIMPLIFY_CONSTRAINTS(80), + BTOR_OPT_CHK_FAILED_ASSUMPTIONS(81), + BTOR_OPT_CHK_MODEL(82), + BTOR_OPT_CHK_UNCONSTRAINED(83), + BTOR_OPT_PARSE_INTERACTIVE(84), + BTOR_OPT_SAT_ENGINE_LGL_FORK(85), + BTOR_OPT_INCREMENTAL_RW(86), + BTOR_OPT_DECLSORT_BV_WIDTH(87), + BTOR_OPT_QUANT_SYNTH_ITE_COMPLETE(88), + BTOR_OPT_QUANT_FIXSYNTH(89); + + private final int value; + + BtorOption(int pValue) { + value = pValue; + } + + public final int getValue() { + return value; + } + + @Override + public String toString() { + return name() + "(" + getValue() + ")"; + } +} diff --git a/src/org/sosy_lab/java_smt/solvers/boolector/package-info.java b/src/org/sosy_lab/java_smt/solvers/boolector/package-info.java new file mode 100644 index 0000000000..3fbd6f0114 --- /dev/null +++ b/src/org/sosy_lab/java_smt/solvers/boolector/package-info.java @@ -0,0 +1,25 @@ +/* + * JavaSMT is an API wrapper for a collection of SMT solvers. + * This file is part of JavaSMT. + * + * Copyright (C) 2007-2019 Dirk Beyer + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/** Interface to the SMT solver Boolector (based on the native C API and JNI). */ +@com.google.errorprone.annotations.CheckReturnValue +@javax.annotation.ParametersAreNonnullByDefault +@org.sosy_lab.common.annotations.FieldsAreNonnullByDefault +@org.sosy_lab.common.annotations.ReturnValuesAreNonnullByDefault +package org.sosy_lab.java_smt.solvers.boolector; diff --git a/src/org/sosy_lab/java_smt/solvers/princess/PrincessArrayFormulaManager.java b/src/org/sosy_lab/java_smt/solvers/princess/PrincessArrayFormulaManager.java index c21d04ef02..7345b76d6f 100644 --- a/src/org/sosy_lab/java_smt/solvers/princess/PrincessArrayFormulaManager.java +++ b/src/org/sosy_lab/java_smt/solvers/princess/PrincessArrayFormulaManager.java @@ -57,7 +57,8 @@ protected IExpression internalMakeArray // other types in arrays are not supported in princess // TODO: check - assert pIndexType.isIntegerType() && pElementType.isIntegerType(); + assert pIndexType.isIntegerType() && pElementType.isIntegerType() + : "Princess supports only Integer types in Arrays"; final ArrayFormulaType arrayFormulaType = FormulaType.getArrayType(pIndexType, pElementType); diff --git a/src/org/sosy_lab/java_smt/test/BitvectorFormulaManagerTest.java b/src/org/sosy_lab/java_smt/test/BitvectorFormulaManagerTest.java index df00e2fa13..6ec12283f8 100644 --- a/src/org/sosy_lab/java_smt/test/BitvectorFormulaManagerTest.java +++ b/src/org/sosy_lab/java_smt/test/BitvectorFormulaManagerTest.java @@ -43,6 +43,10 @@ import org.sosy_lab.java_smt.api.SolverContext.ProverOptions; import org.sosy_lab.java_smt.api.SolverException; +/** + * Tests bitvectors for all solvers that support it. Notice: Boolector does not support integer + * theory or bitvectors length 1. + */ @RunWith(Parameterized.class) public class BitvectorFormulaManagerTest extends SolverBasedTest0 { @@ -66,7 +70,13 @@ public void init() { @Test public void bvType() { - for (int i : new int[] {1, 2, 4, 32, 64, 1000}) { + int[] testValues; + if (solver == Solvers.BOOLECTOR) { + testValues = new int[] {2, 4, 32, 64, 1000}; + } else { + testValues = new int[] {1, 2, 4, 32, 64, 1000}; + } + for (int i : testValues) { BitvectorType type = FormulaType.getBitvectorTypeWithSize(i); assertWithMessage("bitvector type size").that(type.getSize()).isEqualTo(i); BitvectorFormula var = bvmgr.makeVariable(type, "x" + i); @@ -77,7 +87,13 @@ public void bvType() { @Test public void bvOne() throws SolverException, InterruptedException { - for (int i : new int[] {1, 2, 4, 32, 64, 1000}) { + int[] testValues; + if (solver == Solvers.BOOLECTOR) { + testValues = new int[] {2, 4, 32, 64, 1000}; + } else { + testValues = new int[] {1, 2, 4, 32, 64, 1000}; + } + for (int i : testValues) { BitvectorFormula var = bvmgr.makeVariable(i, "x" + i); BitvectorFormula num0 = bvmgr.makeBitvector(i, 0); BitvectorFormula num1 = bvmgr.makeBitvector(i, 1); @@ -89,25 +105,41 @@ public void bvOne() throws SolverException, InterruptedException { @Test(expected = IllegalArgumentException.class) @SuppressWarnings("CheckReturnValue") public void bvTooLargeNum() { - bvmgr.makeBitvector(1, 2); // value 2 is too large for size 1 + if (solver == Solvers.BOOLECTOR) { + bvmgr.makeBitvector(2, 4); // value 4 is too large for size 2 + } else { + bvmgr.makeBitvector(1, 2); // value 2 is too large for size 1 + } } @Test @SuppressWarnings("CheckReturnValue") public void bvLargeNum() { - bvmgr.makeBitvector(1, 1); // value 1 should be possible for size 1 + if (solver == Solvers.BOOLECTOR) { + bvmgr.makeBitvector(2, 3); // value 3 should be possible for size 2 + } else { + bvmgr.makeBitvector(1, 1); // value 1 should be possible for size 1 + } } @Test @SuppressWarnings("CheckReturnValue") public void bvSmallNum() { - bvmgr.makeBitvector(1, -1); // value -1 should be possible for size 1 + if (solver == Solvers.BOOLECTOR) { + bvmgr.makeBitvector(2, -1); // value -1 should be possible for size 2 + } else { + bvmgr.makeBitvector(1, -1); // value -1 should be possible for size 1 + } } @Test(expected = IllegalArgumentException.class) @SuppressWarnings("CheckReturnValue") public void bvTooSmallNum() { - bvmgr.makeBitvector(1, -2); // value -2 is too small for size 1 + if (solver == Solvers.BOOLECTOR) { + bvmgr.makeBitvector(2, -4); // value -4 is too small for size 2 + } else { + bvmgr.makeBitvector(1, -2); // value -2 is too small for size 1 + } } @Test @@ -155,6 +187,8 @@ public void bvModelValue32bit() throws SolverException, InterruptedException { @Test public void bvToInt() throws SolverException, InterruptedException { + requireIntegers(); + for (int size : new int[] {1, 2, 4, 8}) { int max = 1 << size; // number is in range of bitsize @@ -178,6 +212,8 @@ public void bvToInt() throws SolverException, InterruptedException { @Test public void bvToIntEquality() throws SolverException, InterruptedException { + requireIntegers(); + for (int size : new int[] {10, 16, 20, 32, 64}) { for (int i : new int[] {1, 2, 4, 32, 64, 100}) { // number is in range of bitsize @@ -202,6 +238,8 @@ public void bvToIntEquality() throws SolverException, InterruptedException { @Test public void bvToIntEqualityWithOverflow() throws SolverException, InterruptedException { + requireIntegers(); + for (int size : SOME_SIZES) { for (int i : SOME_NUMBERS) { // number might be larger than range of bitsize @@ -223,6 +261,8 @@ public void bvToIntEqualityWithOverflow() throws SolverException, InterruptedExc @Test public void bvToIntEqualityWithOverflowNegative() throws SolverException, InterruptedException { + requireIntegers(); + for (int size : SOME_SIZES) { for (int i : SOME_NUMBERS) { // make number negative @@ -245,7 +285,9 @@ public void bvToIntEqualityWithOverflowNegative() throws SolverException, Interr @Test public void bvToIntEqualityWithSymbols() throws SolverException, InterruptedException { - for (int size : new int[] {1, 2, 4, 8}) { + requireIntegers(); + + for (int size : new int[] {1, 2, 4, 10}) { IntegerFormula var = imgr.makeVariable("x_" + size); // x == int(bv(x)) is sat for small values diff --git a/src/org/sosy_lab/java_smt/test/BooleanFormulaManagerTest.java b/src/org/sosy_lab/java_smt/test/BooleanFormulaManagerTest.java index b4e2d21dfa..657d5d8425 100644 --- a/src/org/sosy_lab/java_smt/test/BooleanFormulaManagerTest.java +++ b/src/org/sosy_lab/java_smt/test/BooleanFormulaManagerTest.java @@ -34,6 +34,10 @@ import org.sosy_lab.java_smt.api.BooleanFormula; import org.sosy_lab.java_smt.api.SolverException; +/** + * Uses bitvector theory if there is no integer theory available. Notice: Boolector does not support + * bitvectors length 1. + */ @RunWith(Parameterized.class) public class BooleanFormulaManagerTest extends SolverBasedTest0 { @@ -104,6 +108,7 @@ public void testDisjunctionCollector() { @Test public void testConjunctionArgsExtractionEmpty() throws SolverException, InterruptedException { + requireVisitor(); BooleanFormula input = bmgr.makeBoolean(true); Truth.assertThat(bmgr.toConjunctionArgs(input, false)).isEmpty(); assertThatFormula(bmgr.and(bmgr.toConjunctionArgs(input, false))).isEquivalentTo(input); @@ -111,6 +116,7 @@ public void testConjunctionArgsExtractionEmpty() throws SolverException, Interru @Test public void testConjunctionArgsExtraction() throws SolverException, InterruptedException { + requireIntegers(); BooleanFormula input = bmgr.and(bmgr.makeVariable("a"), imgr.equal(imgr.makeNumber(1), imgr.makeVariable("x"))); Truth.assertThat(bmgr.toConjunctionArgs(input, false)) @@ -123,34 +129,64 @@ public void testConjunctionArgsExtraction() throws SolverException, InterruptedE @Test public void testConjunctionArgsExtractionRecursive() throws SolverException, InterruptedException { - BooleanFormula input = - bmgr.and( - bmgr.makeVariable("a"), - bmgr.makeBoolean(true), - bmgr.and( - bmgr.makeVariable("b"), - bmgr.makeVariable("c"), - bmgr.and( - imgr.equal(imgr.makeNumber(2), imgr.makeVariable("y")), - bmgr.makeVariable("d"), - bmgr.or(bmgr.makeVariable("e"), bmgr.makeVariable("f")))), - imgr.equal(imgr.makeNumber(1), imgr.makeVariable("x"))); - Truth.assertThat(bmgr.toConjunctionArgs(input, true)) - .isEqualTo( - ImmutableSet.of( - bmgr.makeVariable("a"), - bmgr.makeVariable("b"), - bmgr.makeVariable("c"), - imgr.equal(imgr.makeNumber(1), imgr.makeVariable("x")), - imgr.equal(imgr.makeNumber(2), imgr.makeVariable("y")), - bmgr.makeVariable("d"), - bmgr.or(bmgr.makeVariable("e"), bmgr.makeVariable("f")))); + BooleanFormula input; + ImmutableSet comparisonSet; + if (imgr != null) { + input = + bmgr.and( + bmgr.makeVariable("a"), + bmgr.makeBoolean(true), + bmgr.and( + bmgr.makeVariable("b"), + bmgr.makeVariable("c"), + bmgr.and( + imgr.equal(imgr.makeNumber(2), imgr.makeVariable("y")), + bmgr.makeVariable("d"), + bmgr.or(bmgr.makeVariable("e"), bmgr.makeVariable("f")))), + imgr.equal(imgr.makeNumber(1), imgr.makeVariable("x"))); + + comparisonSet = + ImmutableSet.of( + bmgr.makeVariable("a"), + bmgr.makeVariable("b"), + bmgr.makeVariable("c"), + imgr.equal(imgr.makeNumber(1), imgr.makeVariable("x")), + imgr.equal(imgr.makeNumber(2), imgr.makeVariable("y")), + bmgr.makeVariable("d"), + bmgr.or(bmgr.makeVariable("e"), bmgr.makeVariable("f"))); + } else { + input = + bmgr.and( + bmgr.makeVariable("a"), + bmgr.makeBoolean(true), + bmgr.and( + bmgr.makeVariable("b"), + bmgr.makeVariable("c"), + bmgr.and( + bvmgr.equal(bvmgr.makeBitvector(2, 2), bvmgr.makeVariable(2, "y")), + bmgr.makeVariable("d"), + bmgr.or(bmgr.makeVariable("e"), bmgr.makeVariable("f")))), + bvmgr.equal(bvmgr.makeBitvector(2, 1), bvmgr.makeVariable(2, "x"))); + + comparisonSet = + ImmutableSet.of( + bmgr.makeVariable("a"), + bmgr.makeVariable("b"), + bmgr.makeVariable("c"), + bvmgr.equal(bvmgr.makeBitvector(2, 1), bvmgr.makeVariable(2, "x")), + bvmgr.equal(bvmgr.makeBitvector(2, 2), bvmgr.makeVariable(2, "y")), + bmgr.makeVariable("d"), + bmgr.or(bmgr.makeVariable("e"), bmgr.makeVariable("f"))); + } + requireVisitor(); + Truth.assertThat(bmgr.toConjunctionArgs(input, true)).isEqualTo(comparisonSet); assertThatFormula(bmgr.and(bmgr.toConjunctionArgs(input, true))).isEquivalentTo(input); assertThatFormula(bmgr.and(bmgr.toConjunctionArgs(input, false))).isEquivalentTo(input); } @Test public void testDisjunctionArgsExtractionEmpty() throws SolverException, InterruptedException { + requireVisitor(); BooleanFormula input = bmgr.makeBoolean(false); Truth.assertThat(bmgr.toDisjunctionArgs(input, false)).isEmpty(); assertThatFormula(bmgr.or(bmgr.toDisjunctionArgs(input, false))).isEquivalentTo(input); @@ -158,46 +194,92 @@ public void testDisjunctionArgsExtractionEmpty() throws SolverException, Interru @Test public void testDisjunctionArgsExtraction() throws SolverException, InterruptedException { - BooleanFormula input = - bmgr.or(bmgr.makeVariable("a"), imgr.equal(imgr.makeNumber(1), imgr.makeVariable("x"))); - Truth.assertThat(bmgr.toDisjunctionArgs(input, false)) - .isEqualTo( - ImmutableSet.of( - bmgr.makeVariable("a"), imgr.equal(imgr.makeNumber(1), imgr.makeVariable("x")))); + BooleanFormula input; + ImmutableSet comparisonSet; + if (imgr != null) { + input = + bmgr.or(bmgr.makeVariable("a"), imgr.equal(imgr.makeNumber(1), imgr.makeVariable("x"))); + + comparisonSet = + ImmutableSet.of( + bmgr.makeVariable("a"), imgr.equal(imgr.makeNumber(1), imgr.makeVariable("x"))); + } else { + input = + bmgr.or( + bmgr.makeVariable("a"), + bvmgr.equal(bvmgr.makeBitvector(2, 1), bvmgr.makeVariable(2, "x"))); + + comparisonSet = + ImmutableSet.of( + bmgr.makeVariable("a"), + bvmgr.equal(bvmgr.makeBitvector(2, 1), bvmgr.makeVariable(2, "x"))); + } + requireVisitor(); + Truth.assertThat(bmgr.toDisjunctionArgs(input, false)).isEqualTo(comparisonSet); assertThatFormula(bmgr.or(bmgr.toConjunctionArgs(input, false))).isEquivalentTo(input); } @Test public void testDisjunctionArgsExtractionRecursive() throws SolverException, InterruptedException { - BooleanFormula input = - bmgr.or( - bmgr.makeVariable("a"), - bmgr.makeBoolean(false), - bmgr.or( - bmgr.makeVariable("b"), - bmgr.makeVariable("c"), - bmgr.or( - imgr.equal(imgr.makeNumber(2), imgr.makeVariable("y")), - bmgr.makeVariable("d"), - bmgr.and(bmgr.makeVariable("e"), bmgr.makeVariable("f")))), - imgr.equal(imgr.makeNumber(1), imgr.makeVariable("x"))); - Truth.assertThat(bmgr.toDisjunctionArgs(input, true)) - .isEqualTo( - ImmutableSet.of( - bmgr.makeVariable("a"), - bmgr.makeVariable("b"), - bmgr.makeVariable("c"), - imgr.equal(imgr.makeNumber(1), imgr.makeVariable("x")), - imgr.equal(imgr.makeNumber(2), imgr.makeVariable("y")), - bmgr.makeVariable("d"), - bmgr.and(bmgr.makeVariable("e"), bmgr.makeVariable("f")))); + BooleanFormula input; + ImmutableSet comparisonSet; + if (imgr != null) { + input = + bmgr.or( + bmgr.makeVariable("a"), + bmgr.makeBoolean(false), + bmgr.or( + bmgr.makeVariable("b"), + bmgr.makeVariable("c"), + bmgr.or( + imgr.equal(imgr.makeNumber(2), imgr.makeVariable("y")), + bmgr.makeVariable("d"), + bmgr.and(bmgr.makeVariable("e"), bmgr.makeVariable("f")))), + imgr.equal(imgr.makeNumber(1), imgr.makeVariable("x"))); + + comparisonSet = + ImmutableSet.of( + bmgr.makeVariable("a"), + bmgr.makeVariable("b"), + bmgr.makeVariable("c"), + imgr.equal(imgr.makeNumber(1), imgr.makeVariable("x")), + imgr.equal(imgr.makeNumber(2), imgr.makeVariable("y")), + bmgr.makeVariable("d"), + bmgr.and(bmgr.makeVariable("e"), bmgr.makeVariable("f"))); + } else { + input = + bmgr.or( + bmgr.makeVariable("a"), + bmgr.makeBoolean(false), + bmgr.or( + bmgr.makeVariable("b"), + bmgr.makeVariable("c"), + bmgr.or( + bvmgr.equal(bvmgr.makeBitvector(2, 2), bvmgr.makeVariable(2, "y")), + bmgr.makeVariable("d"), + bmgr.and(bmgr.makeVariable("e"), bmgr.makeVariable("f")))), + bvmgr.equal(bvmgr.makeBitvector(2, 1), bvmgr.makeVariable(2, "x"))); + + comparisonSet = + ImmutableSet.of( + bmgr.makeVariable("a"), + bmgr.makeVariable("b"), + bmgr.makeVariable("c"), + bvmgr.equal(bvmgr.makeBitvector(2, 1), bvmgr.makeVariable(2, "x")), + bvmgr.equal(bvmgr.makeBitvector(2, 2), bvmgr.makeVariable(2, "y")), + bmgr.makeVariable("d"), + bmgr.and(bmgr.makeVariable("e"), bmgr.makeVariable("f"))); + } + requireVisitor(); + Truth.assertThat(bmgr.toDisjunctionArgs(input, true)).isEqualTo(comparisonSet); assertThatFormula(bmgr.or(bmgr.toDisjunctionArgs(input, true))).isEquivalentTo(input); assertThatFormula(bmgr.or(bmgr.toDisjunctionArgs(input, false))).isEquivalentTo(input); } @Test public void simplificationTest() { + // Boolector MAY fail (Use internal equals method to check if it does) BooleanFormula tru = bmgr.makeBoolean(true); BooleanFormula fals = bmgr.makeBoolean(false); BooleanFormula x = bmgr.makeVariable("x"); diff --git a/src/org/sosy_lab/java_smt/test/BooleanFormulaSubjectTest.java b/src/org/sosy_lab/java_smt/test/BooleanFormulaSubjectTest.java index 7a832460c5..7dae89a537 100644 --- a/src/org/sosy_lab/java_smt/test/BooleanFormulaSubjectTest.java +++ b/src/org/sosy_lab/java_smt/test/BooleanFormulaSubjectTest.java @@ -20,6 +20,7 @@ package org.sosy_lab.java_smt.test; import static com.google.common.truth.ExpectFailure.assertThat; +import static com.google.common.truth.TruthJUnit.assume; import static org.sosy_lab.java_smt.test.BooleanFormulaSubject.booleanFormulasOf; import com.google.common.base.Throwables; @@ -36,6 +37,10 @@ import org.sosy_lab.java_smt.api.BooleanFormula; import org.sosy_lab.java_smt.api.SolverException; +/** + * Uses bitvector theory if there is no integer theory available. Notice: Boolector does not support + * bitvectors length 1. + */ @RunWith(Parameterized.class) public class BooleanFormulaSubjectTest extends SolverBasedTest0 { @@ -57,8 +62,16 @@ protected Solvers solverToUse() { @Before public void setupFormulas() { - simpleFormula = imgr.equal(imgr.makeVariable("a"), imgr.makeNumber(1)); - contradiction = bmgr.and(simpleFormula, imgr.equal(imgr.makeVariable("a"), imgr.makeNumber(2))); + if (imgr != null) { + simpleFormula = imgr.equal(imgr.makeVariable("a"), imgr.makeNumber(1)); + contradiction = + bmgr.and(simpleFormula, imgr.equal(imgr.makeVariable("a"), imgr.makeNumber(2))); + } else { + simpleFormula = bvmgr.equal(bvmgr.makeVariable(2, "a"), bvmgr.makeBitvector(2, 1)); + contradiction = + bmgr.and( + simpleFormula, bvmgr.equal(bvmgr.makeVariable(2, "a"), bvmgr.makeBitvector(2, 2))); + } tautology = bmgr.or(simpleFormula, bmgr.not(simpleFormula)); } @@ -81,6 +94,11 @@ public void testIsSatisfiableYes() throws SolverException, InterruptedException @Test public void testIsSatisfiableNo() { + assume() + .withMessage("Solver does not support unsat core generation in a usable way") + .that(solverToUse()) + .isNotEqualTo(Solvers.BOOLECTOR); + AssertionError failure = expectFailure(whenTesting -> whenTesting.that(contradiction).isSatisfiable()); assertThat(failure).factValue("which has unsat core").isNotEmpty(); @@ -107,6 +125,7 @@ public void testIsUnsatisfiableYes() throws SolverException, InterruptedExceptio public void testIsUnsatisfiableNo() { AssertionError failure = expectFailure(whenTesting -> whenTesting.that(simpleFormula).isUnsatisfiable()); + requireModel(); assertThat(failure).factValue("which has model").isNotEmpty(); } @@ -131,6 +150,7 @@ public void testIsTautologicalYes() throws SolverException, InterruptedException public void testIsTautologicalNo1() { AssertionError failure = expectFailure(whenTesting -> whenTesting.that(simpleFormula).isTautological()); + requireModel(); assertThat(failure).factValue("which has model").isNotEmpty(); } @@ -138,13 +158,22 @@ public void testIsTautologicalNo1() { public void testIsTautologicalNo2() { AssertionError failure = expectFailure(whenTesting -> whenTesting.that(contradiction).isTautological()); + requireModel(); assertThat(failure).factValue("which has model").isNotEmpty(); } @Test public void testIsEquivalentToYes() throws SolverException, InterruptedException { - BooleanFormula simpleFormula2 = - imgr.equal(imgr.makeVariable("a"), imgr.add(imgr.makeNumber(0), imgr.makeNumber(1))); + BooleanFormula simpleFormula2; + if (imgr != null) { + simpleFormula2 = + imgr.equal(imgr.makeVariable("a"), imgr.add(imgr.makeNumber(0), imgr.makeNumber(1))); + } else { + simpleFormula2 = + bvmgr.equal( + bvmgr.makeVariable(2, "a"), + bvmgr.add(bvmgr.makeBitvector(2, 0), bvmgr.makeBitvector(2, 1))); + } assertThatFormula(simpleFormula).isEquivalentTo(simpleFormula2); } @@ -152,6 +181,7 @@ public void testIsEquivalentToYes() throws SolverException, InterruptedException public void testIsEquivalentToNo() { AssertionError failure = expectFailure(whenTesting -> whenTesting.that(simpleFormula).isEquivalentTo(tautology)); + requireModel(); assertThat(failure).factValue("which has model").isNotEmpty(); } @@ -162,10 +192,16 @@ public void testIsEquisatisfiableToYes() throws SolverException, InterruptedExce @Test public void testIsEquisatisfiableoNo() { - BooleanFormula simpleFormula2 = imgr.equal(imgr.makeVariable("a"), imgr.makeVariable("2")); + BooleanFormula simpleFormula2; + if (imgr != null) { + simpleFormula2 = imgr.equal(imgr.makeVariable("a"), imgr.makeVariable("2")); + } else { + simpleFormula2 = bvmgr.equal(bvmgr.makeVariable(2, "a"), bvmgr.makeVariable(2, "2")); + } AssertionError failure = expectFailure( whenTesting -> whenTesting.that(simpleFormula).isEquisatisfiableTo(simpleFormula2)); + requireModel(); assertThat(failure).factValue("which has model").isNotEmpty(); } @@ -178,6 +214,7 @@ public void testImpliesYes() throws SolverException, InterruptedException { public void testImpliesNo() { AssertionError failure = expectFailure(whenTesting -> whenTesting.that(tautology).implies(simpleFormula)); + requireModel(); assertThat(failure).factValue("which has model").isNotEmpty(); } diff --git a/src/org/sosy_lab/java_smt/test/FormulaClassifierTest.java b/src/org/sosy_lab/java_smt/test/FormulaClassifierTest.java index 9d27edc0f6..e2712e9003 100644 --- a/src/org/sosy_lab/java_smt/test/FormulaClassifierTest.java +++ b/src/org/sosy_lab/java_smt/test/FormulaClassifierTest.java @@ -122,6 +122,7 @@ public void test_LRA() { @Test public void test_ABV() { + assume().that(solverToUse()).isNotEqualTo(Solvers.BOOLECTOR); requireQuantifiers(); requireBitvectors(); assume().that(solverToUse()).isNotEqualTo(Solvers.PRINCESS); // Princess rewrites the formula diff --git a/src/org/sosy_lab/java_smt/test/FormulaManagerTest.java b/src/org/sosy_lab/java_smt/test/FormulaManagerTest.java index d1a3669ba1..c0a6474a92 100644 --- a/src/org/sosy_lab/java_smt/test/FormulaManagerTest.java +++ b/src/org/sosy_lab/java_smt/test/FormulaManagerTest.java @@ -36,6 +36,7 @@ import org.junit.runners.Parameterized.Parameter; import org.junit.runners.Parameterized.Parameters; import org.sosy_lab.java_smt.SolverContextFactory.Solvers; +import org.sosy_lab.java_smt.api.BitvectorFormula; import org.sosy_lab.java_smt.api.BooleanFormula; import org.sosy_lab.java_smt.api.FormulaType; import org.sosy_lab.java_smt.api.FunctionDeclaration; @@ -60,6 +61,8 @@ protected Solvers solverToUse() { @Test public void testEmptySubstitution() throws SolverException, InterruptedException { + // Boolector does not support substitution + assume().that(solverToUse()).isNotEqualTo(Solvers.BOOLECTOR); assume().withMessage("Princess fails").that(solver).isNotEqualTo(Solvers.PRINCESS); IntegerFormula variable1 = imgr.makeVariable("variable1"); @@ -79,6 +82,8 @@ public void testEmptySubstitution() throws SolverException, InterruptedException @Test public void testNoSubstitution() throws SolverException, InterruptedException { + // Boolector does not support substitution + assume().that(solverToUse()).isNotEqualTo(Solvers.BOOLECTOR); assume().withMessage("Princess fails").that(solver).isNotEqualTo(Solvers.PRINCESS); IntegerFormula variable1 = imgr.makeVariable("variable1"); @@ -104,6 +109,8 @@ public void testNoSubstitution() throws SolverException, InterruptedException { @Test public void testSubstitution() throws SolverException, InterruptedException { + // Boolector does not support substitution + assume().that(solverToUse()).isNotEqualTo(Solvers.BOOLECTOR); BooleanFormula input = bmgr.or( bmgr.and(bmgr.makeVariable("a"), bmgr.makeVariable("b")), @@ -124,6 +131,8 @@ public void testSubstitution() throws SolverException, InterruptedException { @Test public void testSubstitutionTwice() throws SolverException, InterruptedException { + // Boolector does not support substitution + assume().that(solverToUse()).isNotEqualTo(Solvers.BOOLECTOR); BooleanFormula input = bmgr.or( bmgr.and(bmgr.makeVariable("a"), bmgr.makeVariable("b")), @@ -146,6 +155,8 @@ public void testSubstitutionTwice() throws SolverException, InterruptedException @Test public void formulaEqualsAndHashCode() { + // Solvers without integers (Boolector) get their own test below + assume().that(solverToUse()).isNotEqualTo(Solvers.BOOLECTOR); FunctionDeclaration f_b = fmgr.declareUF("f_b", FormulaType.IntegerType, FormulaType.IntegerType); @@ -190,31 +201,123 @@ public void formulaEqualsAndHashCode() { .testEquals(); } + @Test + public void bitvectorFormulaEqualsAndHashCode() { + // Boolector does not support integers and its easier to make a new test with bvs + assume().that(solverToUse()).isEqualTo(Solvers.BOOLECTOR); + FunctionDeclaration f_b = + fmgr.declareUF( + "f_bv", + FormulaType.getBitvectorTypeWithSize(8), + FormulaType.getBitvectorTypeWithSize(8)); + + new EqualsTester() + .addEqualityGroup(bmgr.makeBoolean(true)) + .addEqualityGroup(bmgr.makeBoolean(false)) + .addEqualityGroup(bmgr.makeVariable("bool_a")) + .addEqualityGroup(bvmgr.makeVariable(8, "bv_a")) + + // Way of creating numbers should not make a difference. + .addEqualityGroup( + bvmgr.makeBitvector(8, 0L), + bvmgr.makeBitvector(8, 0), + bvmgr.makeBitvector(8, BigInteger.ZERO)) + .addEqualityGroup( + bvmgr.makeBitvector(8, 1L), + bvmgr.makeBitvector(8, 1), + bvmgr.makeBitvector(8, BigInteger.ONE)) + // The same formula when created twice should compare equal. + .addEqualityGroup(bmgr.makeVariable("bool_b"), bmgr.makeVariable("bool_b")) + .addEqualityGroup( + bmgr.and(bmgr.makeVariable("bool_a"), bmgr.makeVariable("bool_b")), + bmgr.and(bmgr.makeVariable("bool_a"), bmgr.makeVariable("bool_b"))) + .addEqualityGroup( + bvmgr.equal(bvmgr.makeBitvector(8, 0), bvmgr.makeVariable(8, "int_a")), + bvmgr.equal(bvmgr.makeBitvector(8, 0), bvmgr.makeVariable(8, "int_a"))) + + // UninterpretedFunctionDeclarations should not compare equal to Formulas, + // but declaring one twice needs to return the same UIF. + .addEqualityGroup( + fmgr.declareUF( + "f_a", + FormulaType.getBitvectorTypeWithSize(8), + FormulaType.getBitvectorTypeWithSize(8)), + fmgr.declareUF( + "f_a", + FormulaType.getBitvectorTypeWithSize(8), + FormulaType.getBitvectorTypeWithSize(8))) + .addEqualityGroup(f_b) + .addEqualityGroup(fmgr.callUF(f_b, bvmgr.makeBitvector(8, 0))) + .addEqualityGroup( + fmgr.callUF(f_b, bvmgr.makeBitvector(8, 1)), // why not equal?! + fmgr.callUF(f_b, bvmgr.makeBitvector(8, 1))) + .testEquals(); + } + @Test public void variableNameExtractorTest() { - BooleanFormula constr = - bmgr.or( - imgr.equal( - imgr.subtract( - imgr.add(imgr.makeVariable("x"), imgr.makeVariable("z")), imgr.makeNumber(10)), - imgr.makeVariable("y")), - imgr.equal(imgr.makeVariable("xx"), imgr.makeVariable("zz"))); - assertThat(mgr.extractVariables(constr).keySet()).containsExactly("x", "y", "z", "xx", "zz"); - assertThat(mgr.extractVariablesAndUFs(constr)).isEqualTo(mgr.extractVariables(constr)); + // Since Boolector does not support integers we use bitvectors + if (imgr != null) { + BooleanFormula constr = + bmgr.or( + imgr.equal( + imgr.subtract( + imgr.add(imgr.makeVariable("x"), imgr.makeVariable("z")), + imgr.makeNumber(10)), + imgr.makeVariable("y")), + imgr.equal(imgr.makeVariable("xx"), imgr.makeVariable("zz"))); + assertThat(mgr.extractVariables(constr).keySet()).containsExactly("x", "y", "z", "xx", "zz"); + assertThat(mgr.extractVariablesAndUFs(constr)).isEqualTo(mgr.extractVariables(constr)); + } else { + BooleanFormula bvConstr = + bmgr.or( + bvmgr.equal( + bvmgr.subtract( + bvmgr.add(bvmgr.makeVariable(8, "x"), bvmgr.makeVariable(8, "z")), + bvmgr.makeBitvector(8, 10)), + bvmgr.makeVariable(8, "y")), + bvmgr.equal(bvmgr.makeVariable(8, "xx"), bvmgr.makeVariable(8, "zz"))); + + requireVisitor(); + + assertThat(mgr.extractVariables(bvConstr).keySet()) + .containsExactly("x", "y", "z", "xx", "zz"); + assertThat(mgr.extractVariablesAndUFs(bvConstr)).isEqualTo(mgr.extractVariables(bvConstr)); + } } @Test public void ufNameExtractorTest() { - BooleanFormula constraint = - imgr.equal( - fmgr.declareAndCallUF( - "uf1", FormulaType.IntegerType, ImmutableList.of(imgr.makeVariable("x"))), - fmgr.declareAndCallUF( - "uf2", FormulaType.IntegerType, ImmutableList.of(imgr.makeVariable("y")))); + // Since Boolector does not support integers we use bitvectors for constraints + if (imgr != null) { + BooleanFormula constraint = + imgr.equal( + fmgr.declareAndCallUF( + "uf1", FormulaType.IntegerType, ImmutableList.of(imgr.makeVariable("x"))), + fmgr.declareAndCallUF( + "uf2", FormulaType.IntegerType, ImmutableList.of(imgr.makeVariable("y")))); + assertThat(mgr.extractVariablesAndUFs(constraint).keySet()) + .containsExactly("uf1", "uf2", "x", "y"); + + assertThat(mgr.extractVariables(constraint).keySet()).containsExactly("x", "y"); + } else { + BooleanFormula bvConstraint = + bvmgr.equal( + fmgr.declareAndCallUF( + "uf1", + FormulaType.getBitvectorTypeWithSize(8), + ImmutableList.of(bvmgr.makeVariable(8, "x"))), + fmgr.declareAndCallUF( + "uf2", + FormulaType.getBitvectorTypeWithSize(8), + ImmutableList.of(bvmgr.makeVariable(8, "y")))); + + requireVisitor(); - assertThat(mgr.extractVariablesAndUFs(constraint).keySet()) - .containsExactly("uf1", "uf2", "x", "y"); + assertThat(mgr.extractVariablesAndUFs(bvConstraint).keySet()) + .containsExactly("uf1", "uf2", "x", "y"); - assertThat(mgr.extractVariables(constraint).keySet()).containsExactly("x", "y"); + assertThat(mgr.extractVariables(bvConstraint).keySet()).containsExactly("x", "y"); + } } } diff --git a/src/org/sosy_lab/java_smt/test/InterpolatingProverTest.java b/src/org/sosy_lab/java_smt/test/InterpolatingProverTest.java index 4923b78de3..eef5856f29 100644 --- a/src/org/sosy_lab/java_smt/test/InterpolatingProverTest.java +++ b/src/org/sosy_lab/java_smt/test/InterpolatingProverTest.java @@ -29,6 +29,7 @@ import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Lists; +import com.google.common.truth.TruthJUnit; import java.util.List; import java.util.Set; import org.junit.Test; @@ -265,6 +266,7 @@ private void requireTreeItp() { @Test public void sequentialInterpolation() throws SolverException, InterruptedException { InterpolatingProverEnvironment stack = newEnvironmentForTest(); + requireIntegers(); int i = index.getFreshId(); @@ -319,6 +321,7 @@ public void sequentialInterpolation() throws SolverException, InterruptedExc @SuppressWarnings("CheckReturnValue") public void sequentialInterpolationWithoutPartition() throws SolverException, InterruptedException { + requireIntegers(); InterpolatingProverEnvironment stack = newEnvironmentForTest(); stack.push(imgr.equal(imgr.makeNumber(0), imgr.makeNumber(1))); @@ -333,6 +336,7 @@ public void sequentialInterpolationWithoutPartition() public void sequentialInterpolationWithOnePartition() throws SolverException, InterruptedException { InterpolatingProverEnvironment stack = newEnvironmentForTest(); + requireIntegers(); int i = index.getFreshId(); @@ -361,6 +365,7 @@ public void sequentialInterpolationWithOnePartition() public void sequentialInterpolationWithFewPartitions() throws SolverException, InterruptedException { InterpolatingProverEnvironment stack = newEnvironmentForTest(); + requireIntegers(); int i = index.getFreshId(); @@ -393,6 +398,8 @@ public void sequentialInterpolationWithFewPartitions() @Test public void sequentialBVInterpolation() throws SolverException, InterruptedException { + // Boolector does not support Interpolation + TruthJUnit.assume().that(solver).isEqualTo(Solvers.BOOLECTOR); requireBitvectors(); InterpolatingProverEnvironment stack = newEnvironmentForTest(); diff --git a/src/org/sosy_lab/java_smt/test/ModelEvaluationTest.java b/src/org/sosy_lab/java_smt/test/ModelEvaluationTest.java index fc1f2fe94f..f10dd43456 100644 --- a/src/org/sosy_lab/java_smt/test/ModelEvaluationTest.java +++ b/src/org/sosy_lab/java_smt/test/ModelEvaluationTest.java @@ -87,6 +87,7 @@ private void evaluateInModel( @Test public void testGetSmallIntegersEvaluation1() throws SolverException, InterruptedException { + requireIntegers(); evaluateInModel( imgr.equal(imgr.makeVariable("x"), imgr.makeNumber(10)), imgr.add(imgr.makeVariable("y"), imgr.makeVariable("z")), @@ -96,6 +97,7 @@ public void testGetSmallIntegersEvaluation1() throws SolverException, Interrupte @Test public void testGetSmallIntegersEvaluation2() throws SolverException, InterruptedException { + requireIntegers(); evaluateInModel( imgr.equal(imgr.makeVariable("x"), imgr.makeNumber(10)), imgr.add(imgr.makeVariable("y"), imgr.makeNumber(1)), @@ -105,6 +107,7 @@ public void testGetSmallIntegersEvaluation2() throws SolverException, Interrupte @Test public void testGetNegativeIntegersEvaluation() throws SolverException, InterruptedException { + requireIntegers(); evaluateInModel( imgr.equal(imgr.makeVariable("x"), imgr.makeNumber(-10)), imgr.add(imgr.makeVariable("y"), imgr.makeNumber(1)), diff --git a/src/org/sosy_lab/java_smt/test/ModelTest.java b/src/org/sosy_lab/java_smt/test/ModelTest.java index a7aa9406d2..b44df712f0 100644 --- a/src/org/sosy_lab/java_smt/test/ModelTest.java +++ b/src/org/sosy_lab/java_smt/test/ModelTest.java @@ -31,6 +31,7 @@ import java.util.ArrayList; import java.util.List; import java.util.stream.Collectors; +import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; @@ -75,6 +76,11 @@ protected Solvers solverToUse() { return solver; } + @Before + public void setup() { + requireModel(); + } + @Test public void testEmpty() throws SolverException, InterruptedException { try (ProverEnvironment prover = context.newProverEnvironment(ProverOptions.GENERATE_MODELS)) { @@ -104,6 +110,8 @@ public void testOnlyTrue() throws SolverException, InterruptedException { @Test public void testGetSmallIntegers() throws SolverException, InterruptedException { + // Boolector only supports Bitvectors (bv arrays and ufs) + assume().that(solverToUse()).isNotEqualTo(Solvers.BOOLECTOR); testModelGetters( imgr.equal(imgr.makeVariable("x"), imgr.makeNumber(10)), imgr.makeVariable("x"), @@ -113,6 +121,8 @@ public void testGetSmallIntegers() throws SolverException, InterruptedException @Test public void testGetNegativeIntegers() throws SolverException, InterruptedException { + // Boolector only supports Bitvectors (bv arrays and ufs) + assume().that(solverToUse()).isNotEqualTo(Solvers.BOOLECTOR); testModelGetters( imgr.equal(imgr.makeVariable("x"), imgr.makeNumber(-10)), imgr.makeVariable("x"), @@ -122,6 +132,8 @@ public void testGetNegativeIntegers() throws SolverException, InterruptedExcepti @Test public void testGetLargeIntegers() throws SolverException, InterruptedException { + // Boolector only supports Bitvectors (bv arrays and ufs) + assume().that(solverToUse()).isNotEqualTo(Solvers.BOOLECTOR); BigInteger large = new BigInteger("1000000000000000000000000000000000000000"); testModelGetters( imgr.equal(imgr.makeVariable("x"), imgr.makeNumber(large)), @@ -132,6 +144,8 @@ public void testGetLargeIntegers() throws SolverException, InterruptedException @Test public void testGetSmallIntegralRationals() throws SolverException, InterruptedException { + // Boolector only supports Bitvectors (bv arrays and ufs) + assume().that(solverToUse()).isNotEqualTo(Solvers.BOOLECTOR); requireRationals(); testModelGetters( rmgr.equal(rmgr.makeVariable("x"), rmgr.makeNumber(1)), @@ -142,6 +156,8 @@ public void testGetSmallIntegralRationals() throws SolverException, InterruptedE @Test public void testGetLargeIntegralRationals() throws SolverException, InterruptedException { + // Boolector only supports Bitvectors (bv arrays and ufs) + assume().that(solverToUse()).isNotEqualTo(Solvers.BOOLECTOR); requireRationals(); BigInteger large = new BigInteger("1000000000000000000000000000000000000000"); testModelGetters( @@ -153,6 +169,8 @@ public void testGetLargeIntegralRationals() throws SolverException, InterruptedE @Test public void testGetRationals() throws SolverException, InterruptedException { + // Boolector only supports Bitvectors (bv arrays and ufs) + assume().that(solverToUse()).isNotEqualTo(Solvers.BOOLECTOR); requireRationals(); testModelGetters( rmgr.equal(rmgr.makeVariable("x"), rmgr.makeNumber(Rational.ofString("1/3"))), @@ -170,23 +188,44 @@ public void testGetBooleans() throws SolverException, InterruptedException { @Test public void testGetUFs() throws SolverException, InterruptedException { - IntegerFormula x = - fmgr.declareAndCallUF("UF", IntegerType, ImmutableList.of(imgr.makeVariable("arg"))); - testModelGetters(imgr.equal(x, imgr.makeNumber(1)), x, BigInteger.ONE, "UF"); + // Boolector does not support integers + if (imgr != null) { + IntegerFormula x = + fmgr.declareAndCallUF("UF", IntegerType, ImmutableList.of(imgr.makeVariable("arg"))); + testModelGetters(imgr.equal(x, imgr.makeNumber(1)), x, BigInteger.ONE, "UF"); + } else { + BitvectorFormula x = + fmgr.declareAndCallUF( + "UF", + FormulaType.getBitvectorTypeWithSize(8), + ImmutableList.of(bvmgr.makeVariable(8, "arg"))); + testModelGetters(bvmgr.equal(x, bvmgr.makeBitvector(8, 1)), x, BigInteger.ONE, "UF"); + } } @Test public void testGetUFwithMoreParams() throws Exception { - IntegerFormula x = - fmgr.declareAndCallUF( - "UF", - IntegerType, - ImmutableList.of(imgr.makeVariable("arg1"), imgr.makeVariable("arg2"))); - testModelGetters(imgr.equal(x, imgr.makeNumber(1)), x, BigInteger.ONE, "UF"); + // Boolector does not support integers + if (imgr != null) { + IntegerFormula x = + fmgr.declareAndCallUF( + "UF", + IntegerType, + ImmutableList.of(imgr.makeVariable("arg1"), imgr.makeVariable("arg2"))); + testModelGetters(imgr.equal(x, imgr.makeNumber(1)), x, BigInteger.ONE, "UF"); + } else { + BitvectorFormula x = + fmgr.declareAndCallUF( + "UF", + FormulaType.getBitvectorTypeWithSize(8), + ImmutableList.of(bvmgr.makeVariable(8, "arg1"), bvmgr.makeVariable(8, "arg2"))); + testModelGetters(bvmgr.equal(x, bvmgr.makeBitvector(8, 1)), x, BigInteger.ONE, "UF"); + } } @Test - public void testGetMultipleUFs() throws Exception { + public void testGetMultipleUFsWithInts() throws Exception { + requireIntegers(); IntegerFormula arg1 = imgr.makeVariable("arg1"); IntegerFormula arg2 = imgr.makeVariable("arg2"); FunctionDeclaration declaration = @@ -247,9 +286,77 @@ public void testGetMultipleUFs() throws Exception { } } + @Test + public void testGetMultipleUFsWithBvs() throws Exception { + requireBitvectors(); + BitvectorFormula arg1 = bvmgr.makeVariable(8, "arg1"); + BitvectorFormula arg2 = bvmgr.makeVariable(8, "arg2"); + FunctionDeclaration declaration = + fmgr.declareUF( + "UF", FormulaType.getBitvectorTypeWithSize(8), FormulaType.getBitvectorTypeWithSize(8)); + BitvectorFormula app1 = fmgr.callUF(declaration, arg1); + BitvectorFormula app2 = fmgr.callUF(declaration, arg2); + + BitvectorFormula one = bvmgr.makeBitvector(8, 1); + BitvectorFormula two = bvmgr.makeBitvector(8, 2); + BitvectorFormula three = bvmgr.makeBitvector(8, 3); + BitvectorFormula four = bvmgr.makeBitvector(8, 4); + + ImmutableList expectedModel = + ImmutableList.of( + new ValueAssignment( + arg1, + three, + bvmgr.equal(arg1, three), + "arg1", + BigInteger.valueOf(3), + ImmutableList.of()), + new ValueAssignment( + arg2, + four, + bvmgr.equal(arg2, four), + "arg2", + BigInteger.valueOf(4), + ImmutableList.of()), + new ValueAssignment( + fmgr.callUF(declaration, three), + one, + bvmgr.equal(fmgr.callUF(declaration, three), one), + "UF", + BigInteger.valueOf(1), + ImmutableList.of(BigInteger.valueOf(3))), + new ValueAssignment( + fmgr.callUF(declaration, four), + bvmgr.makeBitvector(8, 2), + bvmgr.equal(fmgr.callUF(declaration, four), two), + "UF", + BigInteger.valueOf(2), + ImmutableList.of(BigInteger.valueOf(4)))); + + try (ProverEnvironment prover = context.newProverEnvironment(ProverOptions.GENERATE_MODELS)) { + prover.push( + bmgr.and( + bvmgr.equal(app1, bvmgr.makeBitvector(8, 1)), + bvmgr.equal(app2, bvmgr.makeBitvector(8, 2)))); + prover.push(bvmgr.equal(arg1, bvmgr.makeBitvector(8, 3))); + prover.push(bvmgr.equal(arg2, bvmgr.makeBitvector(8, 4))); + + assertThat(prover).isSatisfiable(); + + try (Model m = prover.getModel()) { + assertThat(m.evaluate(app1)).isEqualTo(BigInteger.ONE); + assertThat(m.evaluate(app2)).isEqualTo(BigInteger.valueOf(2)); + assertThat(m).containsExactlyElementsIn(expectedModel); + } + assertThat(prover.getModelAssignments()).containsExactlyElementsIn(expectedModel); + } + } + @Test public void testQuantifiedUF() throws SolverException, InterruptedException { requireQuantifiers(); + // Boolector only supports bitvector quantifier + assume().that(solverToUse()).isNotEqualTo(Solvers.BOOLECTOR); IntegerFormula var = imgr.makeVariable("var"); BooleanFormula varIsOne = imgr.equal(var, imgr.makeNumber(1)); @@ -297,25 +404,49 @@ public void testGetBitvectors() throws SolverException, InterruptedException { @Test public void testGetModelAssignments() throws SolverException, InterruptedException { - testModelIterator( - bmgr.and( - imgr.equal(imgr.makeVariable("x"), imgr.makeNumber(1)), - imgr.equal(imgr.makeVariable("x"), imgr.makeVariable("y")))); + if (imgr != null) { + testModelIterator( + bmgr.and( + imgr.equal(imgr.makeVariable("x"), imgr.makeNumber(1)), + imgr.equal(imgr.makeVariable("x"), imgr.makeVariable("y")))); + } else { + testModelIterator( + bmgr.and( + bvmgr.equal(bvmgr.makeVariable(8, "x"), bvmgr.makeBitvector(8, 1)), + bvmgr.equal(bvmgr.makeVariable(8, "x"), bvmgr.makeVariable(8, "y")))); + } } @Test public void testEmptyStackModel() throws SolverException, InterruptedException { - try (ProverEnvironment prover = context.newProverEnvironment(ProverOptions.GENERATE_MODELS)) { - assertThat(prover).isSatisfiable(); - try (Model m = prover.getModel()) { - assertThat(m.evaluate(imgr.makeNumber(123))).isEqualTo(BigInteger.valueOf(123)); - assertThat(m.evaluate(bmgr.makeBoolean(true))).isEqualTo(true); - assertThat(m.evaluate(bmgr.makeBoolean(false))).isEqualTo(false); - if (SOLVERS_WITH_PARTIAL_MODEL.contains(solver)) { - // partial model should not return an evaluation - assertThat(m.evaluate(imgr.makeVariable("y"))).isNull(); - } else { - assertThat(m.evaluate(imgr.makeVariable("y"))).isNotNull(); + if (imgr != null) { + try (ProverEnvironment prover = context.newProverEnvironment(ProverOptions.GENERATE_MODELS)) { + assertThat(prover).isSatisfiable(); + try (Model m = prover.getModel()) { + assertThat(m.evaluate(imgr.makeNumber(123))).isEqualTo(BigInteger.valueOf(123)); + assertThat(m.evaluate(bmgr.makeBoolean(true))).isEqualTo(true); + assertThat(m.evaluate(bmgr.makeBoolean(false))).isEqualTo(false); + if (SOLVERS_WITH_PARTIAL_MODEL.contains(solver)) { + // partial model should not return an evaluation + assertThat(m.evaluate(imgr.makeVariable("y"))).isNull(); + } else { + assertThat(m.evaluate(imgr.makeVariable("y"))).isNotNull(); + } + } + } + } else { + try (ProverEnvironment prover = context.newProverEnvironment(ProverOptions.GENERATE_MODELS)) { + assertThat(prover).isSatisfiable(); + try (Model m = prover.getModel()) { + assertThat(m.evaluate(bvmgr.makeBitvector(8, 123))).isEqualTo(BigInteger.valueOf(123)); + assertThat(m.evaluate(bmgr.makeBoolean(true))).isEqualTo(true); + assertThat(m.evaluate(bmgr.makeBoolean(false))).isEqualTo(false); + if (SOLVERS_WITH_PARTIAL_MODEL.contains(solver)) { + // partial model should not return an evaluation + assertThat(m.evaluate(bvmgr.makeVariable(8, "y"))).isNull(); + } else { + assertThat(m.evaluate(bvmgr.makeVariable(8, "y"))).isNotNull(); + } } } } @@ -323,16 +454,32 @@ public void testEmptyStackModel() throws SolverException, InterruptedException { @Test public void testNonExistantSymbol() throws SolverException, InterruptedException { - try (ProverEnvironment prover = context.newProverEnvironment(ProverOptions.GENERATE_MODELS)) { - prover.push(bmgr.makeBoolean(true)); - assertThat(prover).isSatisfiable(); - - try (Model m = prover.getModel()) { - if (SOLVERS_WITH_PARTIAL_MODEL.contains(solver)) { - // partial model should not return an evaluation - assertThat(m.evaluate(imgr.makeVariable("y"))).isNull(); - } else { - assertThat(m.evaluate(imgr.makeVariable("y"))).isNotNull(); + if (imgr != null) { + try (ProverEnvironment prover = context.newProverEnvironment(ProverOptions.GENERATE_MODELS)) { + prover.push(bmgr.makeBoolean(true)); + assertThat(prover).isSatisfiable(); + + try (Model m = prover.getModel()) { + if (SOLVERS_WITH_PARTIAL_MODEL.contains(solver)) { + // partial model should not return an evaluation + assertThat(m.evaluate(imgr.makeVariable("y"))).isNull(); + } else { + assertThat(m.evaluate(imgr.makeVariable("y"))).isNotNull(); + } + } + } + } else { + try (ProverEnvironment prover = context.newProverEnvironment(ProverOptions.GENERATE_MODELS)) { + prover.push(bmgr.makeBoolean(true)); + assertThat(prover).isSatisfiable(); + + try (Model m = prover.getModel()) { + if (SOLVERS_WITH_PARTIAL_MODEL.contains(solver)) { + // partial model should not return an evaluation + assertThat(m.evaluate(bvmgr.makeVariable(8, "y"))).isNull(); + } else { + assertThat(m.evaluate(bvmgr.makeVariable(8, "y"))).isNotNull(); + } } } } @@ -358,13 +505,24 @@ public void testPartialModels() throws SolverException, InterruptedException { @Test public void testPartialModels2() throws SolverException, InterruptedException { try (ProverEnvironment prover = context.newProverEnvironment(ProverOptions.GENERATE_MODELS)) { - IntegerFormula x = imgr.makeVariable("x"); - prover.push(imgr.greaterThan(x, imgr.makeNumber(0))); - assertThat(prover).isSatisfiable(); - try (Model m = prover.getModel()) { - assertThat(m.evaluate(x)).isEqualTo(BigInteger.ONE); - // it works now, but maybe the model "x=1" for the constraint "x>0" is not valid for new - // solvers. + if (imgr != null) { + IntegerFormula x = imgr.makeVariable("x"); + prover.push(imgr.greaterThan(x, imgr.makeNumber(0))); + assertThat(prover).isSatisfiable(); + try (Model m = prover.getModel()) { + assertThat(m.evaluate(x)).isEqualTo(BigInteger.ONE); + // it works now, but maybe the model "x=1" for the constraint "x>0" is not valid for new + // solvers. + } + } else { + BitvectorFormula x = bvmgr.makeVariable(8, "x"); + prover.push(bvmgr.greaterThan(x, bvmgr.makeBitvector(8, 0), true)); + assertThat(prover).isSatisfiable(); + try (Model m = prover.getModel()) { + assertThat(m.evaluate(x)).isEqualTo(BigInteger.ONE); + // it works now, but maybe the model "x=1" for the constraint "x>0" is not valid for new + // solvers. + } } } } @@ -394,15 +552,24 @@ public void testEvaluatingConstants() throws SolverException, InterruptedExcepti prover.push(bmgr.makeVariable("b")); assertThat(prover.isUnsat()).isFalse(); try (Model m = prover.getModel()) { - assertThat(m.evaluate(imgr.makeNumber(0))).isEqualTo(BigInteger.ZERO); - assertThat(m.evaluate(imgr.makeNumber(1))).isEqualTo(BigInteger.ONE); - assertThat(m.evaluate(imgr.makeNumber(100))).isEqualTo(BigInteger.valueOf(100)); - assertThat(m.evaluate(bmgr.makeBoolean(true))).isEqualTo(true); - assertThat(m.evaluate(bmgr.makeBoolean(false))).isEqualTo(false); + if (imgr != null) { + assertThat(m.evaluate(imgr.makeNumber(0))).isEqualTo(BigInteger.ZERO); + assertThat(m.evaluate(imgr.makeNumber(1))).isEqualTo(BigInteger.ONE); + assertThat(m.evaluate(imgr.makeNumber(100))).isEqualTo(BigInteger.valueOf(100)); + assertThat(m.evaluate(bmgr.makeBoolean(true))).isEqualTo(true); + assertThat(m.evaluate(bmgr.makeBoolean(false))).isEqualTo(false); + } if (bvmgr != null) { - for (int i : new int[] {1, 2, 4, 8, 32, 64, 1000}) { - assertThat(m.evaluate(bvmgr.makeBitvector(i, 0))).isEqualTo(BigInteger.ZERO); - assertThat(m.evaluate(bvmgr.makeBitvector(i, 1))).isEqualTo(BigInteger.ONE); + if (solver == Solvers.BOOLECTOR) { + for (int i : new int[] {2, 4, 8, 32, 64, 1000}) { + assertThat(m.evaluate(bvmgr.makeBitvector(i, 0))).isEqualTo(BigInteger.ZERO); + assertThat(m.evaluate(bvmgr.makeBitvector(i, 1))).isEqualTo(BigInteger.ONE); + } + } else { + for (int i : new int[] {1, 2, 4, 8, 32, 64, 1000}) { + assertThat(m.evaluate(bvmgr.makeBitvector(i, 0))).isEqualTo(BigInteger.ZERO); + assertThat(m.evaluate(bvmgr.makeBitvector(i, 1))).isEqualTo(BigInteger.ONE); + } } } } @@ -415,20 +582,33 @@ public void testEvaluatingConstantsWithOperation() throws SolverException, Inter prover.push(bmgr.makeVariable("b")); assertThat(prover.isUnsat()).isFalse(); try (Model m = prover.getModel()) { - assertThat(m.evaluate(imgr.add(imgr.makeNumber(45), imgr.makeNumber(55)))) - .isEqualTo(BigInteger.valueOf(100)); - assertThat(m.evaluate(imgr.subtract(imgr.makeNumber(123), imgr.makeNumber(23)))) - .isEqualTo(BigInteger.valueOf(100)); - assertThat(m.evaluate(bmgr.and(bmgr.makeBoolean(true), bmgr.makeBoolean(true)))) - .isEqualTo(true); + if (imgr != null) { + assertThat(m.evaluate(imgr.add(imgr.makeNumber(45), imgr.makeNumber(55)))) + .isEqualTo(BigInteger.valueOf(100)); + assertThat(m.evaluate(imgr.subtract(imgr.makeNumber(123), imgr.makeNumber(23)))) + .isEqualTo(BigInteger.valueOf(100)); + assertThat(m.evaluate(bmgr.and(bmgr.makeBoolean(true), bmgr.makeBoolean(true)))) + .isEqualTo(true); + } if (bvmgr != null) { - for (int i : new int[] {1, 2, 4, 8, 32, 64, 1000}) { - BitvectorFormula zero = bvmgr.makeBitvector(i, 0); - BitvectorFormula one = bvmgr.makeBitvector(i, 1); - assertThat(m.evaluate(bvmgr.add(zero, zero))).isEqualTo(BigInteger.ZERO); - assertThat(m.evaluate(bvmgr.add(zero, one))).isEqualTo(BigInteger.ONE); - assertThat(m.evaluate(bvmgr.subtract(one, one))).isEqualTo(BigInteger.ZERO); - assertThat(m.evaluate(bvmgr.subtract(one, zero))).isEqualTo(BigInteger.ONE); + if (solver == Solvers.BOOLECTOR) { + for (int i : new int[] {2, 4, 8, 32, 64, 1000}) { + BitvectorFormula zero = bvmgr.makeBitvector(i, 0); + BitvectorFormula one = bvmgr.makeBitvector(i, 1); + assertThat(m.evaluate(bvmgr.add(zero, zero))).isEqualTo(BigInteger.ZERO); + assertThat(m.evaluate(bvmgr.add(zero, one))).isEqualTo(BigInteger.ONE); + assertThat(m.evaluate(bvmgr.subtract(one, one))).isEqualTo(BigInteger.ZERO); + assertThat(m.evaluate(bvmgr.subtract(one, zero))).isEqualTo(BigInteger.ONE); + } + } else { + for (int i : new int[] {1, 2, 4, 8, 32, 64, 1000}) { + BitvectorFormula zero = bvmgr.makeBitvector(i, 0); + BitvectorFormula one = bvmgr.makeBitvector(i, 1); + assertThat(m.evaluate(bvmgr.add(zero, zero))).isEqualTo(BigInteger.ZERO); + assertThat(m.evaluate(bvmgr.add(zero, one))).isEqualTo(BigInteger.ONE); + assertThat(m.evaluate(bvmgr.subtract(one, one))).isEqualTo(BigInteger.ZERO); + assertThat(m.evaluate(bvmgr.subtract(one, zero))).isEqualTo(BigInteger.ONE); + } } } } @@ -436,8 +616,9 @@ public void testEvaluatingConstantsWithOperation() throws SolverException, Inter } @Test - public void testGetArrays() throws SolverException, InterruptedException { + public void testGetIntArrays() throws SolverException, InterruptedException { requireArrays(); + requireIntegers(); ArrayFormula array = amgr.makeArray("array", IntegerType, IntegerType); ArrayFormula updated = @@ -461,7 +642,42 @@ public void testGetArrays() throws SolverException, InterruptedException { public void testGetArrays2() throws SolverException, InterruptedException { requireParser(); requireArrays(); + requireBitvectors(); + assume() + .withMessage( + "Solver %s does not support array theory with bitvectors as indices or elements", + solverToUse()) + .that(solver) + .isNotEqualTo(Solvers.PRINCESS); + ArrayFormula array = + amgr.makeArray( + "array", + FormulaType.getBitvectorTypeWithSize(8), + FormulaType.getBitvectorTypeWithSize(8)); + ArrayFormula updated = + amgr.store(array, bvmgr.makeBitvector(8, 1), bvmgr.makeBitvector(8, 1)); + + try (ProverEnvironment prover = context.newProverEnvironment(ProverOptions.GENERATE_MODELS)) { + prover.push( + bvmgr.equal(amgr.select(updated, bvmgr.makeBitvector(8, 1)), bvmgr.makeBitvector(8, 1))); + + assertThat(prover).isSatisfiable(); + + try (Model m = prover.getModel()) { + for (@SuppressWarnings("unused") ValueAssignment assignment : m) { + // Check that we can iterate through with no crashes. + } + assertThat(m.evaluate(amgr.select(updated, bvmgr.makeBitvector(8, 1)))) + .isEqualTo(BigInteger.ONE); + } + } + } + + @Test + public void testGetArrays6() throws SolverException, InterruptedException { + requireArrays(); + requireParser(); BooleanFormula f = mgr.parse( "(declare-fun |pi@2| () Int)\n" @@ -528,6 +744,8 @@ public void testGetArrays3() throws SolverException, InterruptedException { public void testGetArrays4() throws SolverException, InterruptedException { requireParser(); requireArrays(); + // Boolector can't parse formulas + assume().that(solverToUse()).isNotEqualTo(Solvers.BOOLECTOR); // create formula for "arr[5]==x && x==123" BooleanFormula f = @@ -556,6 +774,8 @@ public void testGetArrays4() throws SolverException, InterruptedException { public void testGetArrays4invalid() throws SolverException, InterruptedException { requireParser(); requireArrays(); + // Boolector can't parse formulas + assume().that(solverToUse()).isNotEqualTo(Solvers.BOOLECTOR); // create formula for "arr[5]==x && x==123" BooleanFormula f = @@ -581,6 +801,8 @@ public void testGetArrays4invalid() throws SolverException, InterruptedException public void testGetArrays5() throws SolverException, InterruptedException { requireParser(); requireArrays(); + // Boolector can't parse formulas + assume().that(solverToUse()).isNotEqualTo(Solvers.BOOLECTOR); // create formula for "arr[5]==x && x==123" BooleanFormula f = @@ -791,6 +1013,7 @@ private BooleanFormula makeAssignment(Formula pFormula1, Formula pFormula2) { @Test public void quantifierTestShort() throws SolverException, InterruptedException { requireQuantifiers(); + requireIntegers(); IntegerFormula ctr = imgr.makeVariable("x"); BooleanFormula body = imgr.equal(ctr, imgr.makeNumber(0)); @@ -1086,6 +1309,8 @@ public void quantifierTestShort() throws SolverException, InterruptedException { public void arrayTest1() throws SolverException, InterruptedException { requireParser(); requireArrays(); + // Boolector can't parse formulas + assume().that(solverToUse()).isNotEqualTo(Solvers.BOOLECTOR); for (String query : ImmutableList.of( @@ -1138,6 +1363,8 @@ public void arrayTest2() throws SolverException, InterruptedException { public void arrayTest3() throws SolverException, InterruptedException { requireParser(); requireArrays(); + // Boolector can't parse formulas + assume().that(solverToUse()).isNotEqualTo(Solvers.BOOLECTOR); BooleanFormula formula = context.getFormulaManager().parse(ARRAY_QUERY_INT); checkModelIteration(formula, false); @@ -1148,6 +1375,8 @@ public void arrayTest4() throws SolverException, InterruptedException { requireParser(); requireArrays(); requireBitvectors(); + // Boolector can't parse formulas + assume().that(solverToUse()).isNotEqualTo(Solvers.BOOLECTOR); assume() .withMessage("solver does not fully support arrays over bitvectors") .that(solverToUse()) @@ -1160,13 +1389,23 @@ public void arrayTest4() throws SolverException, InterruptedException { @Test @SuppressWarnings("resource") public void multiCloseTest() throws SolverException, InterruptedException { + Formula x; + BooleanFormula eq; + if (imgr != null) { + x = imgr.makeVariable("x"); + eq = imgr.equal(imgr.makeVariable("x"), imgr.makeNumber(1)); + } else { + // Boolector only has bitvectors + x = bvmgr.makeVariable(8, "x"); + eq = bvmgr.equal(bvmgr.makeVariable(8, "x"), bvmgr.makeBitvector(8, 1)); + } ProverEnvironment prover = context.newProverEnvironment(ProverOptions.GENERATE_MODELS); try { - prover.push(imgr.equal(imgr.makeVariable("x"), imgr.makeNumber(1))); + prover.push(eq); assertThat(prover).isSatisfiable(); Model m = prover.getModel(); try { - assertThat(m.evaluate(imgr.makeVariable("x"))).isEqualTo(BigInteger.ONE); + assertThat(m.evaluate(x)).isEqualTo(BigInteger.ONE); // close the model several times } finally { for (int i = 0; i < 10; i++) { @@ -1185,7 +1424,11 @@ public void multiCloseTest() throws SolverException, InterruptedException { @SuppressWarnings("resource") public void modelAfterSolverCloseTest() throws SolverException, InterruptedException { ProverEnvironment prover = context.newProverEnvironment(ProverOptions.GENERATE_MODELS); - prover.push(imgr.equal(imgr.makeVariable("x"), imgr.makeNumber(1))); + if (imgr != null) { + prover.push(imgr.equal(imgr.makeVariable("x"), imgr.makeNumber(1))); + } else { + prover.push(bvmgr.equal(bvmgr.makeVariable(8, "x"), bvmgr.makeBitvector(8, 1))); + } assertThat(prover).isSatisfiable(); Model m = prover.getModel(); @@ -1194,7 +1437,11 @@ public void modelAfterSolverCloseTest() throws SolverException, InterruptedExcep // try to access model, this should either fail fast or succeed try { - assertThat(m.evaluate(imgr.makeVariable("x"))).isEqualTo(BigInteger.ONE); + if (imgr != null) { + assertThat(m.evaluate(imgr.makeVariable("x"))).isEqualTo(BigInteger.ONE); + } else { + assertThat(m.evaluate(bvmgr.makeVariable(8, "x"))).isEqualTo(BigInteger.ONE); + } } catch (IllegalStateException e) { // ignore } finally { @@ -1222,6 +1469,7 @@ public void testGenerateModelsOption2() throws SolverException, InterruptedExcep @Test public void testGetSmallIntegers1() throws SolverException, InterruptedException { + requireIntegers(); evaluateInModel( imgr.equal(imgr.makeVariable("x"), imgr.makeNumber(10)), imgr.add(imgr.makeVariable("x"), imgr.makeVariable("x")), @@ -1230,6 +1478,7 @@ public void testGetSmallIntegers1() throws SolverException, InterruptedException @Test public void testGetSmallIntegers2() throws SolverException, InterruptedException { + requireIntegers(); evaluateInModel( imgr.equal(imgr.makeVariable("x"), imgr.makeNumber(10)), imgr.add(imgr.makeVariable("x"), imgr.makeNumber(1)), @@ -1238,6 +1487,7 @@ public void testGetSmallIntegers2() throws SolverException, InterruptedException @Test public void testGetNegativeIntegers1() throws SolverException, InterruptedException { + requireIntegers(); evaluateInModel( imgr.equal(imgr.makeVariable("x"), imgr.makeNumber(-10)), imgr.add(imgr.makeVariable("x"), imgr.makeNumber(1)), diff --git a/src/org/sosy_lab/java_smt/test/NonLinearArithmeticTest.java b/src/org/sosy_lab/java_smt/test/NonLinearArithmeticTest.java index e25d647914..37484f3041 100644 --- a/src/org/sosy_lab/java_smt/test/NonLinearArithmeticTest.java +++ b/src/org/sosy_lab/java_smt/test/NonLinearArithmeticTest.java @@ -45,10 +45,10 @@ @RunWith(Parameterized.class) public class NonLinearArithmeticTest extends SolverBasedTest0 { - // SMTInterpol, MathSAT5, and CVC4 do not fully support non-linear arithmetic - // (though all of them support some parts) + // Boolector, CVC4, SMTInterpol and MathSAT5 do not fully support non-linear arithmetic + // (though SMTInterpol and MathSAT5 support some parts) static final ImmutableSet SOLVER_WITHOUT_NONLINEAR_ARITHMETIC = - ImmutableSet.of(Solvers.SMTINTERPOL, Solvers.MATHSAT5, Solvers.CVC4); + ImmutableSet.of(Solvers.SMTINTERPOL, Solvers.MATHSAT5, Solvers.BOOLECTOR, Solvers.CVC4); @Parameters(name = "{0} {1} {2}") public static Iterable getAllSolvers() { @@ -78,6 +78,7 @@ protected Solvers solverToUse() { @Before public void chooseNumeralFormulaManager() { if (formulaType.isIntegerType()) { + requireIntegers(); nmgr = (NumeralFormulaManager) imgr; } else if (formulaType.isRationalType()) { requireRationals(); diff --git a/src/org/sosy_lab/java_smt/test/NonLinearArithmeticWithModuloTest.java b/src/org/sosy_lab/java_smt/test/NonLinearArithmeticWithModuloTest.java index 9169f86a34..4e65f886b7 100644 --- a/src/org/sosy_lab/java_smt/test/NonLinearArithmeticWithModuloTest.java +++ b/src/org/sosy_lab/java_smt/test/NonLinearArithmeticWithModuloTest.java @@ -93,6 +93,7 @@ private void assertExpectedUnsatifiabilityForNonLinearArithmetic(BooleanFormula @Test public void testModuloConstant() throws SolverException, InterruptedException { + requireIntegers(); IntegerFormula a = imgr.makeVariable("a"); BooleanFormula f = @@ -107,6 +108,7 @@ public void testModuloConstant() throws SolverException, InterruptedException { @Test public void testModuloConstantUnsatisfiable() throws SolverException, InterruptedException { + requireIntegers(); IntegerFormula a = imgr.makeVariable("a"); BooleanFormula f = @@ -128,6 +130,7 @@ public void testModuloConstantUnsatisfiable() throws SolverException, Interrupte @Test public void testModulo() throws SolverException, InterruptedException { + requireIntegers(); IntegerFormula a = imgr.makeVariable("a"); BooleanFormula f = @@ -142,6 +145,7 @@ public void testModulo() throws SolverException, InterruptedException { @Test public void testModuloUnsatisfiable() throws SolverException, InterruptedException { + requireIntegers(); IntegerFormula a = imgr.makeVariable("a"); BooleanFormula f = diff --git a/src/org/sosy_lab/java_smt/test/NumeralFormulaManagerTest.java b/src/org/sosy_lab/java_smt/test/NumeralFormulaManagerTest.java index a21800c4ee..15f1099a9a 100644 --- a/src/org/sosy_lab/java_smt/test/NumeralFormulaManagerTest.java +++ b/src/org/sosy_lab/java_smt/test/NumeralFormulaManagerTest.java @@ -51,6 +51,7 @@ protected Solvers solverToUse() { @Test public void distinctTest() throws SolverException, InterruptedException { + requireIntegers(); List symbols = new ArrayList<>(); for (int i = 0; i < 5; i++) { IntegerFormula symbol = imgr.makeVariable("x" + i); @@ -61,6 +62,7 @@ public void distinctTest() throws SolverException, InterruptedException { @Test public void distinctTest2() throws SolverException, InterruptedException { + requireIntegers(); IntegerFormula zero = imgr.makeNumber(0); IntegerFormula four = imgr.makeNumber(4); List symbols = new ArrayList<>(); @@ -76,6 +78,7 @@ public void distinctTest2() throws SolverException, InterruptedException { @Test public void distinctTest3() throws SolverException, InterruptedException { + requireIntegers(); IntegerFormula zero = imgr.makeNumber(0); IntegerFormula four = imgr.makeNumber(4); List symbols = new ArrayList<>(); @@ -92,6 +95,7 @@ public void distinctTest3() throws SolverException, InterruptedException { @SuppressWarnings("CheckReturnValue") @Test(expected = Exception.class) public void failOnInvalidString() { + requireIntegers(); imgr.makeNumber("a"); fail(); } diff --git a/src/org/sosy_lab/java_smt/test/ProverEnvironmentSubjectTest.java b/src/org/sosy_lab/java_smt/test/ProverEnvironmentSubjectTest.java index a077f15918..e458088e9a 100644 --- a/src/org/sosy_lab/java_smt/test/ProverEnvironmentSubjectTest.java +++ b/src/org/sosy_lab/java_smt/test/ProverEnvironmentSubjectTest.java @@ -59,13 +59,21 @@ protected Solvers solverToUse() { @Before public void setupFormulas() { - simpleFormula = imgr.equal(imgr.makeVariable("a"), imgr.makeNumber(1)); - contradiction = bmgr.and(simpleFormula, imgr.equal(imgr.makeVariable("a"), imgr.makeNumber(2))); + if (imgr != null) { + simpleFormula = imgr.equal(imgr.makeVariable("a"), imgr.makeNumber(1)); + contradiction = + bmgr.and(simpleFormula, imgr.equal(imgr.makeVariable("a"), imgr.makeNumber(2))); + } else { + simpleFormula = bvmgr.equal(bvmgr.makeVariable(2, "a"), bvmgr.makeBitvector(2, 1)); + contradiction = + bmgr.and( + simpleFormula, bvmgr.equal(bvmgr.makeVariable(2, "a"), bvmgr.makeBitvector(2, 2))); + } } @Test public void testIsSatisfiableYes() throws SolverException, InterruptedException { - try (ProverEnvironment env = context.newProverEnvironment()) { + try (ProverEnvironment env = context.newProverEnvironment(ProverOptions.GENERATE_MODELS)) { env.push(simpleFormula); assertThatEnvironment(env).isSatisfiable(); } @@ -73,7 +81,10 @@ public void testIsSatisfiableYes() throws SolverException, InterruptedException @Test public void testIsSatisfiableNo() throws InterruptedException { - try (ProverEnvironment env = context.newProverEnvironment(ProverOptions.GENERATE_UNSAT_CORE)) { + requireUnsatCore(); + try (ProverEnvironment env = + context.newProverEnvironment( + ProverOptions.GENERATE_MODELS, ProverOptions.GENERATE_UNSAT_CORE)) { env.push(contradiction); AssertionError failure = expectFailure(whenTesting -> whenTesting.that(env).isSatisfiable()); assertThat(failure).factValue("with unsat core").isNotEmpty(); @@ -82,7 +93,7 @@ public void testIsSatisfiableNo() throws InterruptedException { @Test public void testIsUnsatisfiableYes() throws SolverException, InterruptedException { - try (ProverEnvironment env = context.newProverEnvironment()) { + try (ProverEnvironment env = context.newProverEnvironment(ProverOptions.GENERATE_MODELS)) { env.push(contradiction); assertThatEnvironment(env).isUnsatisfiable(); } @@ -90,6 +101,7 @@ public void testIsUnsatisfiableYes() throws SolverException, InterruptedExceptio @Test public void testIsUnsatisfiableNo() throws InterruptedException { + requireModel(); try (ProverEnvironment env = context.newProverEnvironment(ProverOptions.GENERATE_MODELS)) { env.push(simpleFormula); AssertionError failure = diff --git a/src/org/sosy_lab/java_smt/test/ProverEnvironmentTest.java b/src/org/sosy_lab/java_smt/test/ProverEnvironmentTest.java index 560f9541b5..4bb20f24b2 100644 --- a/src/org/sosy_lab/java_smt/test/ProverEnvironmentTest.java +++ b/src/org/sosy_lab/java_smt/test/ProverEnvironmentTest.java @@ -22,9 +22,11 @@ import static com.google.common.truth.Truth.assertThat; import static com.google.common.truth.Truth8.assertThat; import static com.google.common.truth.TruthJUnit.assume; +import static org.sosy_lab.java_smt.SolverContextFactory.Solvers.BOOLECTOR; import static org.sosy_lab.java_smt.SolverContextFactory.Solvers.CVC4; import static org.sosy_lab.java_smt.SolverContextFactory.Solvers.MATHSAT5; import static org.sosy_lab.java_smt.SolverContextFactory.Solvers.PRINCESS; +import static org.sosy_lab.java_smt.SolverContextFactory.Solvers.Z3; import static org.sosy_lab.java_smt.api.SolverContext.ProverOptions.GENERATE_UNSAT_CORE; import static org.sosy_lab.java_smt.api.SolverContext.ProverOptions.GENERATE_UNSAT_CORE_OVER_ASSUMPTIONS; import static org.sosy_lab.java_smt.test.ProverEnvironmentSubject.assertThat; @@ -100,6 +102,8 @@ public void assumptionsWithModelTest() throws SolverException, InterruptedExcept @Test public void unsatCoreTest() throws SolverException, InterruptedException { + // Boolector does not support unsat core + assume().that(solverToUse()).isNotEqualTo(Solvers.BOOLECTOR); try (BasicProverEnvironment pe = context.newProverEnvironment(GENERATE_UNSAT_CORE)) { unsatCoreTest0(pe); } @@ -118,8 +122,8 @@ public void unsatCoreTestItp() throws SolverException, InterruptedException { public void unsatCoreTestForOptimizationProver() throws SolverException, InterruptedException { requireOptimization(); - // Z3 does not implement unsat core for optimization - assume().that(solverToUse()).isNotEqualTo(Solvers.Z3); + // Z3 and Boolector do not implement unsat core for optimization + assume().that(solverToUse()).isNoneOf(Z3, BOOLECTOR); try (BasicProverEnvironment pe = context.newOptimizationProverEnvironment(GENERATE_UNSAT_CORE)) { @@ -144,9 +148,10 @@ private void unsatCoreTest0(BasicProverEnvironment pe) @Test public void unsatCoreWithAssumptionsTest() throws SolverException, InterruptedException { assume() - .withMessage("Princess and Mathsat5 do not support unsat core generation over assumptions") + .withMessage( + "Solver %s does not support unsat core generation over assumptions", solverToUse()) .that(solverToUse()) - .isNoneOf(PRINCESS, MATHSAT5, CVC4); + .isNoneOf(PRINCESS, MATHSAT5, BOOLECTOR, CVC4); try (ProverEnvironment pe = context.newProverEnvironment(GENERATE_UNSAT_CORE_OVER_ASSUMPTIONS)) { pe.push(); diff --git a/src/org/sosy_lab/java_smt/test/QuantifierManagerTest.java b/src/org/sosy_lab/java_smt/test/QuantifierManagerTest.java index 4d078a5591..f00896df3c 100644 --- a/src/org/sosy_lab/java_smt/test/QuantifierManagerTest.java +++ b/src/org/sosy_lab/java_smt/test/QuantifierManagerTest.java @@ -79,6 +79,7 @@ protected Solvers solverToUse() { @Before public void setUp() { + requireIntegers(); requireArrays(); requireQuantifiers(); @@ -231,6 +232,9 @@ public void testExistsArrayConjunct1() throws SolverException, InterruptedExcept @Test public void testExistsArrayConjunct2() throws SolverException, InterruptedException { // (exists x . b[x] = 1) AND (forall x . b[x] = 0) is UNSAT + + // Boolector has no working quantifier at the moment. They will be implemented later + TruthJUnit.assume().that(solverUnderTest).isEqualTo(Solvers.BOOLECTOR); BooleanFormula f = bmgr.and(qmgr.exists(ImmutableList.of(x), a_at_x_eq_1), forall_x_a_at_x_eq_0); assertThatFormula(f).isUnsatisfiable(); @@ -239,6 +243,9 @@ public void testExistsArrayConjunct2() throws SolverException, InterruptedExcept @Test public void testExistsArrayConjunct3() throws SolverException, InterruptedException { // (exists x . b[x] = 0) AND (forall x . b[x] = 0) is SAT + + // Boolector has no working quantifier at the moment. They will be implemented later + TruthJUnit.assume().that(solverUnderTest).isEqualTo(Solvers.BOOLECTOR); BooleanFormula f = bmgr.and(qmgr.exists(ImmutableList.of(x), a_at_x_eq_0), forall_x_a_at_x_eq_0); try { @@ -251,6 +258,9 @@ public void testExistsArrayConjunct3() throws SolverException, InterruptedExcept @Test public void testExistsArrayDisjunct1() throws SolverException, InterruptedException { // (exists x . b[x] = 0) OR (forall x . b[x] = 1) is SAT + + // Boolector has no working quantifier at the moment. They will be implemented later + TruthJUnit.assume().that(solverUnderTest).isEqualTo(Solvers.BOOLECTOR); BooleanFormula f = bmgr.or( qmgr.exists(ImmutableList.of(x), a_at_x_eq_0), @@ -261,6 +271,9 @@ public void testExistsArrayDisjunct1() throws SolverException, InterruptedExcept @Test public void testExistsArrayDisjunct2() throws SolverException, InterruptedException { // (exists x . b[x] = 1) OR (exists x . b[x] = 1) is SAT + + // Boolector has no working quantifier at the moment. They will be implemented later + TruthJUnit.assume().that(solverUnderTest).isEqualTo(Solvers.BOOLECTOR); BooleanFormula f = bmgr.or( qmgr.exists(ImmutableList.of(x), a_at_x_eq_1), @@ -271,6 +284,8 @@ public void testExistsArrayDisjunct2() throws SolverException, InterruptedExcept @Test public void testContradiction() throws SolverException, InterruptedException { // forall x . x = x+1 is UNSAT + + requireIntegers(); BooleanFormula f = qmgr.forall(ImmutableList.of(x), imgr.equal(x, imgr.add(x, imgr.makeNumber(1)))); assertThatFormula(f).isUnsatisfiable(); @@ -279,6 +294,7 @@ public void testContradiction() throws SolverException, InterruptedException { @Test public void testSimple() throws SolverException, InterruptedException { // forall x . x+2 = x+1+1 is SAT + requireIntegers(); BooleanFormula f = qmgr.forall( ImmutableList.of(x), @@ -290,6 +306,7 @@ public void testSimple() throws SolverException, InterruptedException { @Test public void testBlah() throws SolverException, InterruptedException { + requireIntegers(); IntegerFormula z = imgr.makeVariable("x"); IntegerFormula y = imgr.makeVariable("y"); BooleanFormula f = @@ -299,6 +316,7 @@ public void testBlah() throws SolverException, InterruptedException { @Test public void testEquals() { + requireIntegers(); BooleanFormula f1 = qmgr.exists(ImmutableList.of(imgr.makeVariable("x")), a_at_x_eq_1); BooleanFormula f2 = qmgr.exists(ImmutableList.of(imgr.makeVariable("x")), a_at_x_eq_1); @@ -307,6 +325,7 @@ public void testEquals() { @Test public void testQELight() throws InterruptedException { + requireIntegers(); assume().that(solverToUse()).isEqualTo(Solvers.Z3); IntegerFormula y = imgr.makeVariable("y"); BooleanFormula f1 = @@ -320,6 +339,8 @@ public void testQELight() throws InterruptedException { @Test public void testIntrospectionForall() { + // Boolector has no working quantifier at the moment. They will be implemented later + TruthJUnit.assume().that(solverUnderTest).isEqualTo(Solvers.BOOLECTOR); BooleanFormula forall = qmgr.forall(ImmutableList.of(x), a_at_x_eq_0); final AtomicBoolean isQuantifier = new AtomicBoolean(false); @@ -351,6 +372,8 @@ public Void visitQuantifier( @Test public void testIntrospectionExists() { + // Boolector has no working quantifier at the moment. They will be implemented later + TruthJUnit.assume().that(solverUnderTest).isEqualTo(Solvers.BOOLECTOR); BooleanFormula exists = qmgr.exists(ImmutableList.of(x), a_at_x_eq_0); final AtomicBoolean isQuantifier = new AtomicBoolean(false); final AtomicBoolean isForall = new AtomicBoolean(false); @@ -390,6 +413,8 @@ public Void visitQuantifier( @Test(expected = IllegalArgumentException.class) public void testEmpty() { + // Boolector has no working quantifier at the moment. They will be implemented later + TruthJUnit.assume().that(solverUnderTest).isEqualTo(Solvers.BOOLECTOR); assume() .withMessage("TODO: The JavaSMT code for Princess explicitly allows this.") .that(solverToUse()) @@ -404,6 +429,7 @@ public void testEmpty() { public void checkQuantifierElimination() throws InterruptedException, SolverException { // build formula: (forall x . ((x < 5) | (7 < x + y))) // quantifier-free equivalent: (2 < y) + requireIntegers(); IntegerFormula xx = imgr.makeVariable("x"); IntegerFormula yy = imgr.makeVariable("y"); BooleanFormula f = @@ -424,6 +450,8 @@ public void checkBVQuantifierElimination() throws InterruptedException, SolverEx // quantifier-free equivalent: x = 1 | x = 3 // or extract_0_0 x = 1 + // Boolector has no working quantifier at the moment. They will be implemented later + TruthJUnit.assume().that(solverUnderTest).isEqualTo(Solvers.BOOLECTOR); int i = index.getFreshId(); int width = 2; diff --git a/src/org/sosy_lab/java_smt/test/RationalFormulaManagerTest.java b/src/org/sosy_lab/java_smt/test/RationalFormulaManagerTest.java index 01762b53cf..492c5f833e 100644 --- a/src/org/sosy_lab/java_smt/test/RationalFormulaManagerTest.java +++ b/src/org/sosy_lab/java_smt/test/RationalFormulaManagerTest.java @@ -78,6 +78,7 @@ public void rationalToIntTest() throws SolverException, InterruptedException { @Test public void intToIntTest() throws SolverException, InterruptedException { + requireIntegers(); for (double v : SOME_DOUBLES) { IntegerFormula i = imgr.makeNumber((int) Math.floor(v)); assertEquals(mgr.getFormulaType(i), FormulaType.IntegerType); diff --git a/src/org/sosy_lab/java_smt/test/SolverAllSatTest.java b/src/org/sosy_lab/java_smt/test/SolverAllSatTest.java index 554942e50a..8e5533613d 100644 --- a/src/org/sosy_lab/java_smt/test/SolverAllSatTest.java +++ b/src/org/sosy_lab/java_smt/test/SolverAllSatTest.java @@ -79,8 +79,8 @@ public void setupEnvironment() { // TODO how can we support allsat in MathSat5-interpolation-prover? assume().that(solverToUse()).isNotEqualTo(Solvers.MATHSAT5); - // CVC4 does not support interpolation - assume().that(solverToUse()).isNotEqualTo(Solvers.CVC4); + // CVC4 and Boolector do not support interpolation + assume().that(solverToUse()).isNoneOf(Solvers.CVC4, Solvers.BOOLECTOR); env = context.newProverEnvironmentWithInterpolation(ProverOptions.GENERATE_ALL_SAT); break; @@ -120,6 +120,8 @@ public String getResult() { @Test public void allSatTest_unsat() throws SolverException, InterruptedException { + requireIntegers(); + IntegerFormula a = imgr.makeVariable("i"); IntegerFormula n1 = imgr.makeNumber(1); IntegerFormula n2 = imgr.makeNumber(2); @@ -149,6 +151,8 @@ public void apply(List pModel) { @Test public void allSatTest_xor() throws SolverException, InterruptedException { + requireIntegers(); + IntegerFormula a = imgr.makeVariable("i"); IntegerFormula n1 = imgr.makeNumber(1); IntegerFormula n2 = imgr.makeNumber(2); diff --git a/src/org/sosy_lab/java_smt/test/SolverBasedTest0.java b/src/org/sosy_lab/java_smt/test/SolverBasedTest0.java index 587f2c04b2..7e11d438a8 100644 --- a/src/org/sosy_lab/java_smt/test/SolverBasedTest0.java +++ b/src/org/sosy_lab/java_smt/test/SolverBasedTest0.java @@ -132,7 +132,12 @@ public final void initSolver() throws InvalidConfigurationException { fmgr = mgr.getUFManager(); bmgr = mgr.getBooleanFormulaManager(); - imgr = mgr.getIntegerFormulaManager(); + // Needed for Boolector tests (Doesnt support Integer Formulas) + try { + imgr = mgr.getIntegerFormulaManager(); + } catch (UnsupportedOperationException e) { + imgr = null; + } try { rmgr = mgr.getRationalFormulaManager(); } catch (UnsupportedOperationException e) { @@ -167,6 +172,14 @@ public final void closeSolver() { } } + /** Skip test if the solver does not support integers. */ + protected final void requireIntegers() { + assume() + .withMessage("Solver %s does not support the theory of integers", solverToUse()) + .that(imgr) + .isNotNull(); + } + /** Skip test if the solver does not support rationals. */ protected final void requireRationals() { assume() @@ -182,6 +195,7 @@ protected final void requireBitvectors() { .that(bvmgr) .isNotNull(); } + /** Skip test if the solver does not support quantifiers. */ protected final void requireQuantifiers() { assume() @@ -232,7 +246,28 @@ protected void requireParser() { assume() .withMessage("Solver %s does not support parsing formulae", solverToUse()) .that(solverToUse()) - .isNotEqualTo(Solvers.CVC4); + .isNoneOf(Solvers.CVC4, Solvers.BOOLECTOR); + } + + protected void requireModel() { + assume() + .withMessage("Solver %s does not support model generation in a usable way", solverToUse()) + .that(solverToUse()) + .isNotEqualTo(Solvers.BOOLECTOR); + } + + protected void requireVisitor() { + assume() + .withMessage("Solver %s does not support formula visitor", solverToUse()) + .that(solverToUse()) + .isNotEqualTo(Solvers.BOOLECTOR); + } + + protected void requireUnsatCore() { + assume() + .withMessage("Solver %s does not support unsat core generation", solverToUse()) + .that(solverToUse()) + .isNotEqualTo(Solvers.BOOLECTOR); } @Deprecated diff --git a/src/org/sosy_lab/java_smt/test/SolverFormulaIOTest.java b/src/org/sosy_lab/java_smt/test/SolverFormulaIOTest.java index 2982729045..7c1e40bbd8 100644 --- a/src/org/sosy_lab/java_smt/test/SolverFormulaIOTest.java +++ b/src/org/sosy_lab/java_smt/test/SolverFormulaIOTest.java @@ -28,6 +28,7 @@ import com.google.common.collect.HashMultiset; import com.google.common.collect.Iterables; import com.google.common.collect.Multiset; +import com.google.common.truth.TruthJUnit; import java.util.Iterator; import org.junit.Test; import org.junit.runner.RunWith; @@ -74,6 +75,8 @@ protected Solvers solverToUse() { @Test public void varDumpTest() { + // Boolector will fail this anyway since bools are bitvecs for btor + TruthJUnit.assume().that(solver).isNotEqualTo(Solvers.BOOLECTOR); BooleanFormula a = bmgr.makeVariable("main::a"); BooleanFormula b = bmgr.makeVariable("b"); BooleanFormula c1 = bmgr.xor(a, b); @@ -89,7 +92,11 @@ public void varDumpTest() { @Test public void varDumpTest2() { + // Boolector will fail this anyway since bools are bitvecs for btor + TruthJUnit.assume().that(solver).isNotEqualTo(Solvers.BOOLECTOR); + // always true + BooleanFormula a = bmgr.makeVariable("a"); BooleanFormula b = bmgr.makeVariable("b"); BooleanFormula c1 = bmgr.xor(a, b); @@ -116,6 +123,8 @@ public void varDumpTest2() { @Test public void valDumpTest() { + // Boolector will fail this anyway since bools are bitvecs for btor + TruthJUnit.assume().that(solver).isNotEqualTo(Solvers.BOOLECTOR); BooleanFormula tr1 = bmgr.makeBoolean(true); BooleanFormula tr2 = bmgr.makeBoolean(true); BooleanFormula fl1 = bmgr.makeBoolean(false); @@ -133,6 +142,7 @@ public void valDumpTest() { @Test public void intsDumpTest() { + requireIntegers(); IntegerFormula f1 = imgr.makeVariable("a"); IntegerFormula val = imgr.makeNumber(1); BooleanFormula formula = imgr.equal(f1, val); @@ -147,6 +157,7 @@ public void intsDumpTest() { @Test public void funcsDumpTest() { + requireIntegers(); IntegerFormula int1 = imgr.makeNumber(1); IntegerFormula var = imgr.makeVariable("var_a"); FunctionDeclaration funA = @@ -248,6 +259,8 @@ public void parseMathSatTestParseFirst3() throws SolverException, InterruptedExc @Test public void redundancyTest() { + // Boolector will fail this anyway since bools are bitvecs for btor + TruthJUnit.assume().that(solver).isNotEqualTo(Solvers.BOOLECTOR); String formDump = mgr.dumpFormula(redundancyExprGen()).toString(); int count = Iterables.size(Splitter.on(">=").split(formDump)) - 1; int count2 = Iterables.size(Splitter.on("<=").split(formDump)) - 1; @@ -259,6 +272,7 @@ public void redundancyTest() { @Test public void funDeclareTest() { + requireIntegers(); IntegerFormula int1 = imgr.makeNumber(1); IntegerFormula int2 = imgr.makeNumber(2); @@ -280,6 +294,7 @@ public void funDeclareTest() { @Test public void funDeclareTest2() { + requireIntegers(); IntegerFormula int1 = imgr.makeNumber(1); IntegerFormula int2 = imgr.makeNumber(2); @@ -299,6 +314,8 @@ public void funDeclareTest2() { private void compareParseWithOrgExprFirst(String textToParse, Supplier fun) throws SolverException, InterruptedException { + // Boolector will fail this anyway since bools are bitvecs for btor + TruthJUnit.assume().that(solver).isNotEqualTo(Solvers.BOOLECTOR); // check if input is correct checkThatFunOnlyDeclaredOnce(textToParse); checkThatAssertIsInLastLine(textToParse); @@ -311,6 +328,8 @@ private void compareParseWithOrgExprFirst(String textToParse, Supplier fun) throws SolverException, InterruptedException { + // Boolector will fail this anyway since bools are bitvecs for btor + TruthJUnit.assume().that(solver).isNotEqualTo(Solvers.BOOLECTOR); // check if input is correct checkThatFunOnlyDeclaredOnce(textToParse); checkThatAssertIsInLastLine(textToParse); @@ -322,6 +341,8 @@ private void compareParseWithOrgParseFirst(String textToParse, Supplier funDeclares = HashMultiset.create(); for (String line : Splitter.on('\n').split(formDump)) { @@ -341,6 +362,8 @@ private void checkThatFunOnlyDeclaredOnce(String formDump) { } private void checkThatAssertIsInLastLine(String lines) { + // Boolector will fail this anyway since bools are bitvecs for btor + TruthJUnit.assume().that(solver).isNotEqualTo(Solvers.BOOLECTOR); lines = lines.trim(); assertWithMessage("last line of <\n" + lines + ">") .that(getLast(Splitter.on('\n').split(lines))) diff --git a/src/org/sosy_lab/java_smt/test/SolverStackTest.java b/src/org/sosy_lab/java_smt/test/SolverStackTest.java index 38ce4c6fea..180991740f 100644 --- a/src/org/sosy_lab/java_smt/test/SolverStackTest.java +++ b/src/org/sosy_lab/java_smt/test/SolverStackTest.java @@ -90,7 +90,7 @@ private void requireMultipleStackSupport() { assume() .withMessage("Solver does not support multiple stacks yet") .that(solver) - .isNotEqualTo(Solvers.SMTINTERPOL); + .isNoneOf(Solvers.SMTINTERPOL, Solvers.BOOLECTOR); } protected final void requireUfValuesInModel() { @@ -149,6 +149,8 @@ public void simpleStackTestBool() throws SolverException, InterruptedException { @Test public void singleStackTestInteger() throws SolverException, InterruptedException { + requireIntegers(); + BasicProverEnvironment env = newEnvironmentForTest(); simpleStackTestNum(imgr, env); } @@ -251,6 +253,8 @@ public void stackTest5() { @SuppressWarnings("unused") @Test public void symbolsOnStackTest() throws InterruptedException, SolverException { + requireModel(); + BasicProverEnvironment stack = newEnvironmentForTest(ProverOptions.GENERATE_MODELS); stack.push(); @@ -423,6 +427,7 @@ public void dualStackGlobalDeclarations() throws SolverException, InterruptedExc @Test @SuppressWarnings("CheckReturnValue") public void modelForUnsatFormula() throws SolverException, InterruptedException { + requireIntegers(); try (BasicProverEnvironment stack = newEnvironmentForTest()) { stack.push(imgr.greaterThan(imgr.makeVariable("a"), imgr.makeNumber(0))); stack.push(imgr.lessThan(imgr.makeVariable("a"), imgr.makeNumber(0))); @@ -436,6 +441,7 @@ public void modelForUnsatFormula() throws SolverException, InterruptedException @Test @SuppressWarnings("CheckReturnValue") public void modelForUnsatFormula2() throws SolverException, InterruptedException { + requireIntegers(); try (BasicProverEnvironment stack = newEnvironmentForTest()) { stack.push(imgr.greaterThan(imgr.makeVariable("a"), imgr.makeNumber(0))); assertThat(stack).isSatisfiable(); @@ -449,6 +455,7 @@ public void modelForUnsatFormula2() throws SolverException, InterruptedException @Test public void modelForSatFormula() throws SolverException, InterruptedException { + requireIntegers(); try (BasicProverEnvironment stack = newEnvironmentForTest(ProverOptions.GENERATE_MODELS)) { IntegerFormula a = imgr.makeVariable("a"); stack.push(imgr.greaterThan(a, imgr.makeNumber(0))); @@ -462,6 +469,7 @@ public void modelForSatFormula() throws SolverException, InterruptedException { @Test public void modelForSatFormulaWithLargeValue() throws SolverException, InterruptedException { + requireIntegers(); try (BasicProverEnvironment stack = newEnvironmentForTest(ProverOptions.GENERATE_MODELS)) { BigInteger val = BigInteger.TEN.pow(1000); IntegerFormula a = imgr.makeVariable("a"); @@ -475,6 +483,7 @@ public void modelForSatFormulaWithLargeValue() throws SolverException, Interrupt @Test public void modelForSatFormulaWithUF() throws SolverException, InterruptedException { + requireIntegers(); try (BasicProverEnvironment stack = newEnvironmentForTest(ProverOptions.GENERATE_MODELS)) { IntegerFormula zero = imgr.makeNumber(0); IntegerFormula varA = imgr.makeVariable("a"); @@ -508,7 +517,7 @@ public void multiCloseTest() throws SolverException, InterruptedException { // do something on the stack stack.push(); stack.pop(); - stack.push(imgr.equal(imgr.makeVariable("a"), imgr.makeNumber(0))); + stack.push(bmgr.equivalence(bmgr.makeVariable("a"), bmgr.makeTrue())); assertThat(stack).isSatisfiable(); stack.push(); diff --git a/src/org/sosy_lab/java_smt/test/SolverTacticsTest.java b/src/org/sosy_lab/java_smt/test/SolverTacticsTest.java index ccfa59b3a7..ac408ee389 100644 --- a/src/org/sosy_lab/java_smt/test/SolverTacticsTest.java +++ b/src/org/sosy_lab/java_smt/test/SolverTacticsTest.java @@ -63,6 +63,8 @@ protected Solvers solverToUse() { @Test public void nnfTacticDefaultTest1() throws SolverException, InterruptedException { + requireVisitor(); + BooleanFormula a = bmgr.makeVariable("a"); BooleanFormula b = bmgr.makeVariable("b"); BooleanFormula not_a_b = bmgr.not(bmgr.equivalence(a, b)); @@ -76,6 +78,8 @@ public void nnfTacticDefaultTest1() throws SolverException, InterruptedException @Test public void nnfTacticDefaultTest2() throws SolverException, InterruptedException { + requireVisitor(); + BooleanFormula a = bmgr.makeVariable("a"); BooleanFormula b = bmgr.makeVariable("b"); BooleanFormula c = bmgr.makeVariable("c"); @@ -156,6 +160,7 @@ public void cnfTacticDefaultTest3() throws SolverException, InterruptedException @Test public void ufEliminationSimpleTest() throws SolverException, InterruptedException { + requireIntegers(); // f := uf(v1, v3) XOR uf(v2, v4) IntegerFormula variable1 = imgr.makeVariable("variable1"); IntegerFormula variable2 = imgr.makeVariable("variable2"); @@ -186,6 +191,7 @@ public void ufEliminationSimpleTest() throws SolverException, InterruptedExcepti @Test public void ufEliminationNestedUfsTest() throws SolverException, InterruptedException { + requireIntegers(); // f :=uf2(uf1(v1, v2), v3) XOR uf2(uf1(v2, v1), v4) IntegerFormula variable1 = imgr.makeVariable("variable1"); IntegerFormula variable2 = imgr.makeVariable("variable2"); @@ -221,6 +227,7 @@ public void ufEliminationNestedUfsTest() throws SolverException, InterruptedExce @Test public void ufEliminationNesteQuantifierTest() throws InterruptedException { + requireIntegers(); requireQuantifiers(); // f := exists v1,v2v,v3,v4 : uf(v1, v3) == uf(v2, v4) IntegerFormula variable1 = imgr.makeVariable("variable1"); diff --git a/src/org/sosy_lab/java_smt/test/SolverTheoriesTest.java b/src/org/sosy_lab/java_smt/test/SolverTheoriesTest.java index 3369818462..cc8b95f7ae 100644 --- a/src/org/sosy_lab/java_smt/test/SolverTheoriesTest.java +++ b/src/org/sosy_lab/java_smt/test/SolverTheoriesTest.java @@ -85,6 +85,7 @@ public void basicBoolTest() throws SolverException, InterruptedException { @Test public void basicIntTest() { + requireIntegers(); IntegerFormula a = imgr.makeVariable("a"); IntegerFormula b = imgr.makeVariable("b"); assertThat(a).isNotEqualTo(b); @@ -103,6 +104,7 @@ public void basisRatTest() throws SolverException, InterruptedException { @Test public void intTest1() throws SolverException, InterruptedException { + requireIntegers(); IntegerFormula a = imgr.makeVariable("int_a"); IntegerFormula num = imgr.makeNumber(2); @@ -112,6 +114,7 @@ public void intTest1() throws SolverException, InterruptedException { @Test public void intTest2() throws SolverException, InterruptedException { + requireIntegers(); IntegerFormula a = imgr.makeVariable("int_b"); IntegerFormula num = imgr.makeNumber(1); @@ -121,6 +124,7 @@ public void intTest2() throws SolverException, InterruptedException { @Test public void intTest3_DivModLinear() throws SolverException, InterruptedException { + requireIntegers(); IntegerFormula a = imgr.makeVariable("int_a"); IntegerFormula b = imgr.makeVariable("int_b"); @@ -169,6 +173,7 @@ public void intTest3_DivModLinear() throws SolverException, InterruptedException public void intTest3_DivModNonLinear() throws SolverException, InterruptedException { // not all solvers support division-by-variable, // we guarantee soundness by allowing any value that yields SAT. + requireIntegers(); IntegerFormula a = imgr.makeVariable("int_a"); IntegerFormula b = imgr.makeVariable("int_b"); @@ -196,6 +201,7 @@ public void intTest3_DivModNonLinear() throws SolverException, InterruptedExcept @Test public void intTest3_DivMod_NegativeNumbersLinear() throws SolverException, InterruptedException { + requireIntegers(); IntegerFormula a = imgr.makeVariable("int_a"); IntegerFormula b = imgr.makeVariable("int_b"); @@ -261,6 +267,7 @@ public void intTest3_DivMod_NegativeNumbersNonLinear() throws SolverException, InterruptedException { // TODO not all solvers support division-by-variable, // we guarantee soundness by allowing any value that yields SAT. + requireIntegers(); IntegerFormula a = imgr.makeVariable("int_a"); IntegerFormula b = imgr.makeVariable("int_b"); @@ -383,8 +390,14 @@ public void intTestBV_DivMod_NegativeNumbers() throws SolverException, Interrupt assertThatFormula(bmgr.and(fa, bmgr.not(fAMod5))).isUnsatisfiable(); // check modulo-by-constant, a=-10 && a%3=-1 - assertThatFormula(bmgr.and(fa, fAMod3)).isSatisfiable(); - assertThatFormula(bmgr.and(fa, bmgr.not(fAMod3))).isUnsatisfiable(); + if (solverToUse() == Solvers.BOOLECTOR) { + // TODO check this strange behavior of Boolector + assertThatFormula(bmgr.and(fa, fAMod3)).isUnsatisfiable(); + assertThatFormula(bmgr.and(fa, bmgr.not(fAMod3))).isSatisfiable(); + } else { + assertThatFormula(bmgr.and(fa, fAMod3)).isSatisfiable(); + assertThatFormula(bmgr.and(fa, bmgr.not(fAMod3))).isUnsatisfiable(); + } // check modulo-by-constant, a=-10 && a%(-3)=-1 assertThatFormula(bmgr.and(fa, fAModNeg3)).isSatisfiable(); @@ -393,6 +406,7 @@ public void intTestBV_DivMod_NegativeNumbers() throws SolverException, Interrupt @Test public void intTest4_ModularCongruence_Simple() throws SolverException, InterruptedException { + requireIntegers(); final IntegerFormula x = imgr.makeVariable("x"); final BooleanFormula f1 = imgr.modularCongruence(x, imgr.makeNumber(0), 2); final BooleanFormula f2 = imgr.equal(x, imgr.makeNumber(1)); @@ -402,6 +416,7 @@ public void intTest4_ModularCongruence_Simple() throws SolverException, Interrup @Test public void intTest4_ModularCongruence() throws SolverException, InterruptedException { + requireIntegers(); IntegerFormula a = imgr.makeVariable("int_a"); IntegerFormula b = imgr.makeVariable("int_b"); IntegerFormula c = imgr.makeVariable("int_c"); @@ -446,6 +461,7 @@ public void intTest4_ModularCongruence() throws SolverException, InterruptedExce @Test public void intTest4_ModularCongruence_NegativeNumbers() throws SolverException, InterruptedException { + requireIntegers(); IntegerFormula a = imgr.makeVariable("int_a"); IntegerFormula b = imgr.makeVariable("int_b"); IntegerFormula c = imgr.makeVariable("int_c"); @@ -468,6 +484,7 @@ public void intTest4_ModularCongruence_NegativeNumbers() @Test public void testHardCongruence() throws SolverException, InterruptedException { + requireIntegers(); IntegerFormula a = imgr.makeVariable("a"); IntegerFormula b = imgr.makeVariable("b"); IntegerFormula c = imgr.makeVariable("c"); @@ -545,6 +562,7 @@ public void test_BitvectorIsZeroAfterShiftLeft() throws SolverException, Interru @Test public void testUfWithBoolType() throws SolverException, InterruptedException { + requireIntegers(); FunctionDeclaration uf = fmgr.declareUF("fun_ib", FormulaType.BooleanType, FormulaType.IntegerType); BooleanFormula uf0 = fmgr.callUF(uf, imgr.makeNumber(0)); @@ -569,6 +587,7 @@ public void testUfWithBoolArg() throws SolverException, InterruptedException { .that(solver) .isNotEqualTo(Solvers.MATHSAT5); + requireIntegers(); FunctionDeclaration uf = fmgr.declareUF("fun_bi", FormulaType.IntegerType, FormulaType.BooleanType); IntegerFormula ufTrue = fmgr.callUF(uf, bmgr.makeBoolean(true)); @@ -581,6 +600,7 @@ public void testUfWithBoolArg() throws SolverException, InterruptedException { @Test public void quantifierEliminationTest1() throws SolverException, InterruptedException { requireQuantifiers(); + requireIntegers(); IntegerFormula var_B = imgr.makeVariable("b"); IntegerFormula var_C = imgr.makeVariable("c"); @@ -604,6 +624,7 @@ public void quantifierEliminationTest1() throws SolverException, InterruptedExce @Ignore public void quantifierEliminationTest2() throws SolverException, InterruptedException { requireQuantifiers(); + requireIntegers(); IntegerFormula i1 = imgr.makeVariable("i@1"); IntegerFormula j1 = imgr.makeVariable("j@1"); @@ -633,6 +654,7 @@ public void quantifierEliminationTest2() throws SolverException, InterruptedExce @Test public void testGetFormulaType() { + requireIntegers(); BooleanFormula _boolVar = bmgr.makeVariable("boolVar"); assertThat(mgr.getFormulaType(_boolVar)).isEqualTo(FormulaType.BooleanType); @@ -648,6 +670,7 @@ public void testGetFormulaType() { @Test public void testMakeIntArray() { requireArrays(); + requireIntegers(); IntegerFormula _i = imgr.makeVariable("i"); IntegerFormula _1 = imgr.makeNumber(1); @@ -694,6 +717,12 @@ public void testMakeBitVectorArray() { // Mathsat5 has a different internal representation of the formula assertThat(_b_at_i.toString()).isEqualTo("(`read__` b i)"); break; + case BOOLECTOR: + assume() + .withMessage("Solver %s does not printing formulae.", solverToUse()) + .that(solver) + .isNotEqualTo(Solvers.BOOLECTOR); + break; default: assertThat(_b_at_i.toString()) .isEqualTo("(select b i)"); // Compatibility to all solvers not guaranteed @@ -704,6 +733,7 @@ public void testMakeBitVectorArray() { public void testNestedRationalArray() { requireArrays(); requireRationals(); + requireIntegers(); IntegerFormula _i = imgr.makeVariable("i"); ArrayFormula> multi = @@ -728,6 +758,7 @@ public void testNestedRationalArray() { public void testNestedBitVectorArray() { requireArrays(); requireBitvectors(); + requireIntegers(); assume() .withMessage("Solver does not support bit-vector arrays.") @@ -757,6 +788,7 @@ public void testNestedBitVectorArray() { @Test public void nonLinearMultiplication() throws SolverException, InterruptedException { + requireIntegers(); IntegerFormula i2 = imgr.makeNumber(2); IntegerFormula i3 = imgr.makeNumber(3); IntegerFormula i4 = imgr.makeNumber(4); @@ -789,6 +821,7 @@ public void nonLinearMultiplication() throws SolverException, InterruptedExcepti @Test public void composedLinearMultiplication() throws SolverException, InterruptedException { + requireIntegers(); IntegerFormula i2 = imgr.makeNumber(2); IntegerFormula i3 = imgr.makeNumber(3); IntegerFormula i4 = imgr.makeNumber(4); @@ -817,6 +850,7 @@ public void composedLinearMultiplication() throws SolverException, InterruptedEx @Test public void multiplicationSquares() throws SolverException, InterruptedException { + requireIntegers(); IntegerFormula i2 = imgr.makeNumber(2); IntegerFormula i3 = imgr.makeNumber(3); IntegerFormula i4 = imgr.makeNumber(4); @@ -878,6 +912,7 @@ public void multiplicationSquares() throws SolverException, InterruptedException @Test public void multiplicationFactors() throws SolverException, InterruptedException { + requireIntegers(); IntegerFormula i37 = imgr.makeNumber(37); IntegerFormula i1 = imgr.makeNumber(1); IntegerFormula x = imgr.makeVariable("x"); @@ -903,6 +938,7 @@ public void multiplicationFactors() throws SolverException, InterruptedException @Test public void multiplicationCubic() throws SolverException, InterruptedException { + requireIntegers(); IntegerFormula i125 = imgr.makeNumber(125); IntegerFormula i27 = imgr.makeNumber(27); IntegerFormula i5 = imgr.makeNumber(5); @@ -941,6 +977,7 @@ public void multiplicationCubic() throws SolverException, InterruptedException { @Test public void nonLinearDivision() throws SolverException, InterruptedException { + requireIntegers(); IntegerFormula i2 = imgr.makeNumber(2); IntegerFormula i3 = imgr.makeNumber(3); IntegerFormula i4 = imgr.makeNumber(4); @@ -973,6 +1010,7 @@ public void nonLinearDivision() throws SolverException, InterruptedException { @Test public void integerDivisionRounding() throws SolverException, InterruptedException { + requireIntegers(); IntegerFormula varSeven = imgr.makeVariable("a"); IntegerFormula varEight = imgr.makeVariable("b"); @@ -1076,16 +1114,20 @@ public void bvITETest() { } private static final ImmutableSet VAR_TRACKING_SOLVERS = - ImmutableSet.of(Solvers.SMTINTERPOL, Solvers.MATHSAT5, Solvers.CVC4); + ImmutableSet.of(Solvers.SMTINTERPOL, Solvers.MATHSAT5, Solvers.CVC4, Solvers.BOOLECTOR); private static final ImmutableSet VAR_AND_UF_TRACKING_SOLVERS = - ImmutableSet.of(Solvers.SMTINTERPOL, Solvers.MATHSAT5); + ImmutableSet.of(Solvers.SMTINTERPOL, Solvers.MATHSAT5, Solvers.BOOLECTOR); @Test @SuppressWarnings("CheckReturnValue") public void testVariableWithDifferentSort() { assume().that(solverToUse()).isNotIn(VAR_TRACKING_SOLVERS); bmgr.makeVariable("x"); - imgr.makeVariable("x"); + if (imgr != null) { + imgr.makeVariable("x"); + } else if (bvmgr != null) { + bvmgr.makeVariable(8, "x"); + } } @Test(expected = Exception.class) // complement of above test case @@ -1093,7 +1135,11 @@ public void testVariableWithDifferentSort() { public void testFailOnVariableWithDifferentSort() { assume().that(solverToUse()).isIn(VAR_TRACKING_SOLVERS); bmgr.makeVariable("x"); - imgr.makeVariable("x"); + if (imgr != null) { + imgr.makeVariable("x"); + } else if (bvmgr != null) { + bvmgr.makeVariable(8, "x"); + } } @Test @@ -1112,8 +1158,21 @@ public void testFailOnVariableAndUFWithDifferentSort() { fmgr.declareUF("y", FormulaType.BooleanType, FormulaType.BooleanType); } + @Test(expected = Exception.class) // different ordering of above test case + @SuppressWarnings("CheckReturnValue") + public void testFailOnUFAndVariableWithDifferentSort() { + assume().that(solverToUse()).isIn(VAR_AND_UF_TRACKING_SOLVERS); + fmgr.declareUF("y", FormulaType.BooleanType, FormulaType.BooleanType); + bmgr.makeVariable("y"); + } + @Test public void testVariableAndUFWithEqualSort() { + assume() + .withMessage("Solver %s does not support UFs without arguments", solverToUse()) + .that(solverToUse()) + .isNotEqualTo(Solvers.BOOLECTOR); + BooleanFormula z1 = bmgr.makeVariable("z"); BooleanFormula z2 = fmgr.declareAndCallUF("z", FormulaType.BooleanType); if (ImmutableSet.of(Solvers.CVC4, Solvers.PRINCESS).contains(solverToUse())) { diff --git a/src/org/sosy_lab/java_smt/test/SolverVisitorTest.java b/src/org/sosy_lab/java_smt/test/SolverVisitorTest.java index efab95aeb0..c8ff28c093 100644 --- a/src/org/sosy_lab/java_smt/test/SolverVisitorTest.java +++ b/src/org/sosy_lab/java_smt/test/SolverVisitorTest.java @@ -31,6 +31,7 @@ import java.util.Random; import java.util.Set; import java.util.stream.Stream; +import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; @@ -98,6 +99,11 @@ protected Solvers solverToUse() { return solver; } + @Before + public void setup() { + requireVisitor(); + } + @Test public void booleanIdVisit() { BooleanFormula t = bmgr.makeBoolean(true); diff --git a/src/org/sosy_lab/java_smt/test/TimeoutTest.java b/src/org/sosy_lab/java_smt/test/TimeoutTest.java index 9733869b20..a1decb2ead 100644 --- a/src/org/sosy_lab/java_smt/test/TimeoutTest.java +++ b/src/org/sosy_lab/java_smt/test/TimeoutTest.java @@ -73,9 +73,9 @@ public void testTacticTimeout() throws InterruptedException { @Test public void testProverTimeout() throws SolverException, InterruptedException { TruthJUnit.assume() - .withMessage("Princess does not support interruption") + .withMessage(solverToUse() + " does not support interruption") .that(solverToUse()) - .isNotEqualTo(Solvers.PRINCESS); + .isNoneOf(Solvers.PRINCESS, Solvers.BOOLECTOR); testBasicProverTimeout(() -> context.newProverEnvironment()); } @@ -83,9 +83,9 @@ public void testProverTimeout() throws SolverException, InterruptedException { public void testInterpolationProverTimeout() throws SolverException, InterruptedException { requireInterpolation(); TruthJUnit.assume() - .withMessage("Princess does not support interruption") + .withMessage(solverToUse() + " does not support interruption") .that(solverToUse()) - .isNotEqualTo(Solvers.PRINCESS); + .isNoneOf(Solvers.PRINCESS, Solvers.BOOLECTOR); testBasicProverTimeout(() -> context.newProverEnvironmentWithInterpolation()); } diff --git a/src/org/sosy_lab/java_smt/test/TranslateFormulaTest.java b/src/org/sosy_lab/java_smt/test/TranslateFormulaTest.java index ee5eb7df85..d1f1de0bab 100644 --- a/src/org/sosy_lab/java_smt/test/TranslateFormulaTest.java +++ b/src/org/sosy_lab/java_smt/test/TranslateFormulaTest.java @@ -109,7 +109,14 @@ private void requireParser() { assume() .withMessage("Solver %s does not support parsing formulae", translateTo) .that(translateTo) - .isNotEqualTo(Solvers.CVC4); + .isNoneOf(Solvers.CVC4, Solvers.BOOLECTOR); + } + + private void requireIntegers() { + assume() + .withMessage("Solver %s does not support integer theory", translateFrom) + .that(translateFrom) + .isNotEqualTo(Solvers.BOOLECTOR); } @Test @@ -134,6 +141,8 @@ public void testTranslating() throws SolverException, InterruptedException { } private BooleanFormula createTestFormula(FormulaManager mgr) { + requireIntegers(); + BooleanFormulaManager bfmgr = mgr.getBooleanFormulaManager(); IntegerFormulaManager ifmgr = mgr.getIntegerFormulaManager(); IntegerFormula x = ifmgr.makeVariable("x"); diff --git a/src/org/sosy_lab/java_smt/test/UFManagerTest.java b/src/org/sosy_lab/java_smt/test/UFManagerTest.java index f8f8405f37..6de7e701ae 100644 --- a/src/org/sosy_lab/java_smt/test/UFManagerTest.java +++ b/src/org/sosy_lab/java_smt/test/UFManagerTest.java @@ -53,7 +53,8 @@ protected Solvers solverToUse() { } @Test - public void testDeclareAndCallUF() { + public void testDeclareAndCallUFWithInt() { + requireIntegers(); List names = ImmutableList.of("Func", "|Func|", "(Func)"); for (String name : names) { Formula f; @@ -75,6 +76,32 @@ public void testDeclareAndCallUF() { } } + @Test + public void testDeclareAndCallUFWithBv() { + requireBitvectors(); + List names = ImmutableList.of("Func", "|Func|", "(Func)"); + for (String name : names) { + Formula f; + try { + f = + fmgr.declareAndCallUF( + name, + FormulaType.getBitvectorTypeWithSize(4), + ImmutableList.of(bvmgr.makeBitvector(4, 1))); + } catch (RuntimeException e) { + if (name.equals("|Func|")) { + throw new AssumptionViolatedException("unsupported UF name", e); + } else { + throw e; + } + } + FunctionDeclaration declaration = getDeclaration(f); + Truth.assertThat(declaration.getName()).isEqualTo(name); + Formula f2 = mgr.makeApplication(declaration, bvmgr.makeBitvector(4, 1)); + Truth.assertThat(f2).isEqualTo(f); + } + } + @Test public void testDeclareAndCallUFWithTypedArgs() { requireBooleanArgument(); @@ -150,6 +177,10 @@ private void createAndCallUF( } private FunctionDeclaration getDeclaration(Formula pFormula) { + assume() + .withMessage("Solver %s does not support visiters", solverToUse()) + .that(solver) + .isNotEqualTo(Solvers.BOOLECTOR); return mgr.visit( pFormula, new ExpectedFormulaVisitor>() { diff --git a/src/org/sosy_lab/java_smt/test/UfEliminationTest.java b/src/org/sosy_lab/java_smt/test/UfEliminationTest.java index c821902613..ee204e9da7 100644 --- a/src/org/sosy_lab/java_smt/test/UfEliminationTest.java +++ b/src/org/sosy_lab/java_smt/test/UfEliminationTest.java @@ -71,6 +71,7 @@ public void setUp() { @Test public void simpleTest() throws SolverException, InterruptedException { // f := uf(v1, v3) XOR uf(v2, v4) + requireIntegers(); IntegerFormula variable1 = imgr.makeVariable("variable1"); IntegerFormula variable2 = imgr.makeVariable("variable2"); IntegerFormula variable3 = imgr.makeVariable("variable3"); @@ -101,6 +102,7 @@ public void simpleTest() throws SolverException, InterruptedException { @Test public void nestedUfs() throws SolverException, InterruptedException { // f := uf2(uf1(v1, v2), v3) XOR uf2(uf1(v2, v1), v4) + requireIntegers(); IntegerFormula variable1 = imgr.makeVariable("variable1"); IntegerFormula variable2 = imgr.makeVariable("variable2"); IntegerFormula variable3 = imgr.makeVariable("variable3"); @@ -136,6 +138,7 @@ public void nestedUfs() throws SolverException, InterruptedException { @Test public void nestedUfs2() throws SolverException, InterruptedException { // f := uf2(uf1(v1, uf2(v3, v6)), v3) < uf2(uf1(v2, uf2(v4, v5)), v4) + requireIntegers(); IntegerFormula variable1 = imgr.makeVariable("variable1"); IntegerFormula variable2 = imgr.makeVariable("variable2"); IntegerFormula variable3 = imgr.makeVariable("variable3"); @@ -178,6 +181,7 @@ public void nestedUfs2() throws SolverException, InterruptedException { @Test public void twoFormulasTest() throws SolverException, InterruptedException { // See FormulaManagerTest.testEmptySubstitution(), FormulaManagerTest.testNoSubstitution() + requireIntegers(); assume().withMessage("Princess fails").that(solver).isNotEqualTo(Solvers.PRINCESS); // f := uf(v1, v3) XOR uf(v2, v4) @@ -216,6 +220,7 @@ public void twoFormulasTest() throws SolverException, InterruptedException { @Test public void quantifierTest() { requireQuantifiers(); + requireIntegers(); // f := exists v1,v2v,v3,v4 : uf(v1, v3) == uf(v2, v4) IntegerFormula variable1 = imgr.makeVariable("variable1"); IntegerFormula variable2 = imgr.makeVariable("variable2"); @@ -240,6 +245,7 @@ public void quantifierTest() { @Test public void substitutionTest() throws SolverException, InterruptedException { // f := uf(v1, v3) \/ NOT(uf(v2, v4))) + requireIntegers(); IntegerFormula variable1 = imgr.makeVariable("variable1"); IntegerFormula variable2 = imgr.makeVariable("variable2"); IntegerFormula variable3 = imgr.makeVariable("variable3"); diff --git a/src/org/sosy_lab/java_smt/test/VariableNamesInvalidTest.java b/src/org/sosy_lab/java_smt/test/VariableNamesInvalidTest.java index 6bd97e77a3..15d9cd8df7 100644 --- a/src/org/sosy_lab/java_smt/test/VariableNamesInvalidTest.java +++ b/src/org/sosy_lab/java_smt/test/VariableNamesInvalidTest.java @@ -57,6 +57,7 @@ public void testInvalidBoolVariable() { @Test(expected = IllegalArgumentException.class) public void testInvalidIntVariable() { + requireIntegers(); @SuppressWarnings("unused") Formula var = imgr.makeVariable(""); } @@ -83,9 +84,20 @@ public void testInvalidFloatVariable() { } @Test(expected = IllegalArgumentException.class) - public void testInvalidArrayVariable() { + public void testInvalidIntArrayVariable() { + requireIntegers(); requireArrays(); @SuppressWarnings("unused") Formula var = amgr.makeArray("", FormulaType.IntegerType, FormulaType.IntegerType); } + + @Test(expected = IllegalArgumentException.class) + public void testInvalidBvArrayVariable() { + requireBitvectors(); + requireArrays(); + @SuppressWarnings("unused") + Formula var = + amgr.makeArray( + "", FormulaType.getBitvectorTypeWithSize(2), FormulaType.getBitvectorTypeWithSize(2)); + } } diff --git a/src/org/sosy_lab/java_smt/test/VariableNamesTest.java b/src/org/sosy_lab/java_smt/test/VariableNamesTest.java index cc19759293..5fd6d3c9a9 100644 --- a/src/org/sosy_lab/java_smt/test/VariableNamesTest.java +++ b/src/org/sosy_lab/java_smt/test/VariableNamesTest.java @@ -21,6 +21,7 @@ package org.sosy_lab.java_smt.test; import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.TruthJUnit.assume; import static org.junit.Assert.fail; import static org.sosy_lab.java_smt.api.FormulaType.BooleanType; import static org.sosy_lab.java_smt.api.FormulaType.IntegerType; @@ -242,6 +243,7 @@ public void testBoolVariable() { private void testName0( Function creator, BiFunction eq, boolean isUF) throws SolverException, InterruptedException { + requireVisitor(); // create a variable T var = createVariableWith(creator, getVarname()); @@ -289,6 +291,7 @@ public void testNameBool() throws SolverException, InterruptedException { @Test public void testNameInt() throws SolverException, InterruptedException { + requireIntegers(); testName0(imgr::makeVariable, imgr::equal, false); } @@ -314,30 +317,62 @@ public void testNameFloat() throws SolverException, InterruptedException { } @Test - public void testNameArray() throws SolverException, InterruptedException { + public void testNameIntArray() throws SolverException, InterruptedException { + requireIntegers(); requireArrays(); testName0(s -> amgr.makeArray(s, IntegerType, IntegerType), amgr::equivalence, false); } + @Test + public void testNameBvArray() throws SolverException, InterruptedException { + requireBitvectors(); + requireArrays(); + // Someone who knows princess has to debug this! + assume().that(solverToUse()).isNotEqualTo(Solvers.PRINCESS); + testName0( + s -> + amgr.makeArray( + s, + FormulaType.getBitvectorTypeWithSize(2), + FormulaType.getBitvectorTypeWithSize(2)), + amgr::equivalence, + false); + } + @Test public void testNameUF1Bool() throws SolverException, InterruptedException { + requireIntegers(); testName0( s -> fmgr.declareAndCallUF(s, BooleanType, imgr.makeNumber(0)), bmgr::equivalence, true); } @Test public void testNameUF1Int() throws SolverException, InterruptedException { + requireIntegers(); testName0(s -> fmgr.declareAndCallUF(s, IntegerType, imgr.makeNumber(0)), imgr::equal, true); } + @Test + public void testNameUFBv() throws SolverException, InterruptedException { + requireBitvectors(); + // Someone who knows princess has to debug this! + assume().that(solverToUse()).isNotEqualTo(Solvers.PRINCESS); + testName0( + s -> fmgr.declareAndCallUF(s, BooleanType, bvmgr.makeBitvector(2, 0)), + bmgr::equivalence, + true); + } + @Test public void testNameUF2Bool() throws SolverException, InterruptedException { + requireIntegers(); IntegerFormula zero = imgr.makeNumber(0); testName0(s -> fmgr.declareAndCallUF(s, BooleanType, zero, zero), bmgr::equivalence, true); } @Test public void testNameUF2Int() throws SolverException, InterruptedException { + requireIntegers(); IntegerFormula zero = imgr.makeNumber(0); testName0(s -> fmgr.declareAndCallUF(s, IntegerType, zero, zero), imgr::equal, true); } @@ -345,6 +380,7 @@ public void testNameUF2Int() throws SolverException, InterruptedException { @Test public void testNameExists() { requireQuantifiers(); + requireIntegers(); IntegerFormula var = createVariableWith(imgr::makeVariable, getVarname()); IntegerFormula zero = imgr.makeNumber(0); @@ -380,6 +416,8 @@ protected Void visitDefault(Formula pF) { @Test public void testBoolVariableNameInVisitor() { + requireVisitor(); + BooleanFormula var = createVariableWith(bmgr::makeVariable, getVarname()); bmgr.visit( @@ -414,6 +452,7 @@ public void testEqBoolVariableDump() { @Test public void testIntVariable() { + requireIntegers(); createVariableWith(imgr::makeVariable, getVarname()); } @@ -438,11 +477,27 @@ public void testInvalidFloatVariable() { } @Test - public void testArrayVariable() { + public void testIntArrayVariable() { requireArrays(); + requireIntegers(); createVariableWith(v -> amgr.makeArray(v, IntegerType, IntegerType), getVarname()); } + @Test + public void testBvArrayVariable() { + requireArrays(); + requireBitvectors(); + // Someone who knows princess has to debug this! + assume().that(solverToUse()).isNotEqualTo(Solvers.PRINCESS); + createVariableWith( + v -> + amgr.makeArray( + v, + FormulaType.getBitvectorTypeWithSize(2), + FormulaType.getBitvectorTypeWithSize(2)), + getVarname()); + } + @Test public void sameBehaviorTest() { if (mgr.isValidName(getVarname())) {